X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Ftest.cpp;h=bc0692a78325f05ee5fcfb6fac7d2d81b4619081;hb=9f1ae4084d945adb6281eaddc2ae56f488691d8b;hp=1de902787987e72acfdd280e0ffbfe2f8bf835cb;hpb=d065bae323838734556de2693b6b004c98c95092;p=dragonfireclient.git diff --git a/src/test.cpp b/src/test.cpp index 1de902787..bc0692a78 100644 --- a/src/test.cpp +++ b/src/test.cpp @@ -3,33 +3,45 @@ Minetest-c55 Copyright (C) 2010 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "test.h" -#include "common_irrlicht.h" +#include "irrlichttypes_extrabloated.h" #include "debug.h" #include "map.h" #include "player.h" #include "main.h" #include "socket.h" #include "connection.h" -#include "utility.h" #include "serialization.h" #include "voxel.h" +#include "collision.h" #include #include "porting.h" +#include "content_mapnode.h" +#include "nodedef.h" +#include "mapsector.h" +#include "settings.h" +#include "log.h" +#include "util/string.h" +#include "voxelalgorithms.h" +#include "inventory.h" +#include "util/numeric.h" +#include "util/serialize.h" +#include "noise.h" // PseudoRandom used for random data for compression +#include "clientserver.h" // LATEST_PROTOCOL_VERSION /* Asserts that the exception occurs @@ -39,28 +51,291 @@ with this program; if not, write to the Free Software Foundation, Inc., bool exception_thrown = false;\ try{ code; }\ catch(EType &e) { exception_thrown = true; }\ - assert(exception_thrown);\ + UASSERT(exception_thrown);\ } -struct TestUtilities +#define UTEST(x, fmt, ...)\ +{\ + if(!(x)){\ + LOGLINEF(LMT_ERROR, "Test (%s) failed: " fmt, #x, ##__VA_ARGS__);\ + test_failed = true;\ + }\ +} + +#define UASSERT(x) UTEST(x, "UASSERT") + +/* + A few item and node definitions for those tests that need them +*/ + +#define CONTENT_STONE 0 +#define CONTENT_GRASS 0x800 +#define CONTENT_TORCH 100 + +void define_some_nodes(IWritableItemDefManager *idef, IWritableNodeDefManager *ndef) +{ + content_t i; + ItemDefinition itemdef; + ContentFeatures f; + + /* + Stone + */ + i = CONTENT_STONE; + itemdef = ItemDefinition(); + itemdef.type = ITEM_NODE; + itemdef.name = "default:stone"; + itemdef.description = "Stone"; + itemdef.groups["cracky"] = 3; + itemdef.inventory_image = "[inventorycube" + "{default_stone.png" + "{default_stone.png" + "{default_stone.png"; + f = ContentFeatures(); + f.name = itemdef.name; + for(int i = 0; i < 6; i++) + f.tiledef[i].name = "default_stone.png"; + f.is_ground_content = true; + idef->registerItem(itemdef); + ndef->set(i, f); + + /* + Grass + */ + i = CONTENT_GRASS; + itemdef = ItemDefinition(); + itemdef.type = ITEM_NODE; + itemdef.name = "default:dirt_with_grass"; + itemdef.description = "Dirt with grass"; + itemdef.groups["crumbly"] = 3; + itemdef.inventory_image = "[inventorycube" + "{default_grass.png" + "{default_dirt.png&default_grass_side.png" + "{default_dirt.png&default_grass_side.png"; + f = ContentFeatures(); + f.name = itemdef.name; + f.tiledef[0].name = "default_grass.png"; + f.tiledef[1].name = "default_dirt.png"; + for(int i = 2; i < 6; i++) + f.tiledef[i].name = "default_dirt.png^default_grass_side.png"; + f.is_ground_content = true; + idef->registerItem(itemdef); + ndef->set(i, f); + + /* + Torch (minimal definition for lighting tests) + */ + i = CONTENT_TORCH; + itemdef = ItemDefinition(); + itemdef.type = ITEM_NODE; + itemdef.name = "default:torch"; + f = ContentFeatures(); + f.name = itemdef.name; + f.param_type = CPT_LIGHT; + f.light_propagates = true; + f.sunlight_propagates = true; + f.light_source = LIGHT_MAX-1; + idef->registerItem(itemdef); + ndef->set(i, f); +} + +struct TestBase +{ + bool test_failed; + TestBase(): + test_failed(false) + {} +}; + +struct TestUtilities: public TestBase { void Run() { - /*dstream<<"wrapDegrees(100.0) = "< std::string mkstr(const char (&s)[N]) + { + return std::string(s, N - 1); + } + + void Run() + { + // Tests some serialization primitives + + UASSERT(serializeString("") == mkstr("\0\0")); + UASSERT(serializeWideString(L"") == mkstr("\0\0")); + UASSERT(serializeLongString("") == mkstr("\0\0\0\0")); + UASSERT(serializeJsonString("") == "\"\""); -struct TestCompress + std::string teststring = "Hello world!"; + UASSERT(serializeString(teststring) == + mkstr("\0\14Hello world!")); + UASSERT(serializeWideString(narrow_to_wide(teststring)) == + mkstr("\0\14\0H\0e\0l\0l\0o\0 \0w\0o\0r\0l\0d\0!")); + UASSERT(serializeLongString(teststring) == + mkstr("\0\0\0\14Hello world!")); + UASSERT(serializeJsonString(teststring) == + "\"Hello world!\""); + + std::string teststring2; + std::wstring teststring2_w; + std::string teststring2_w_encoded; + { + std::ostringstream tmp_os; + std::wostringstream tmp_os_w; + std::ostringstream tmp_os_w_encoded; + for(int i = 0; i < 256; i++) + { + tmp_os<<(char)i; + tmp_os_w<<(wchar_t)i; + tmp_os_w_encoded<<(char)0<<(char)i; + } + teststring2 = tmp_os.str(); + teststring2_w = tmp_os_w.str(); + teststring2_w_encoded = tmp_os_w_encoded.str(); + } + UASSERT(serializeString(teststring2) == + mkstr("\1\0") + teststring2); + UASSERT(serializeWideString(teststring2_w) == + mkstr("\1\0") + teststring2_w_encoded); + UASSERT(serializeLongString(teststring2) == + mkstr("\0\0\1\0") + teststring2); + // MSVC fails when directly using "\\\\" + std::string backslash = "\\"; + UASSERT(serializeJsonString(teststring2) == + mkstr("\"") + + "\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007" + + "\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f" + + "\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017" + + "\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f" + + " !\\\"" + teststring2.substr(0x23, 0x2f-0x23) + + "\\/" + teststring2.substr(0x30, 0x5c-0x30) + + backslash + backslash + teststring2.substr(0x5d, 0x7f-0x5d) + "\\u007f" + + "\\u0080\\u0081\\u0082\\u0083\\u0084\\u0085\\u0086\\u0087" + + "\\u0088\\u0089\\u008a\\u008b\\u008c\\u008d\\u008e\\u008f" + + "\\u0090\\u0091\\u0092\\u0093\\u0094\\u0095\\u0096\\u0097" + + "\\u0098\\u0099\\u009a\\u009b\\u009c\\u009d\\u009e\\u009f" + + "\\u00a0\\u00a1\\u00a2\\u00a3\\u00a4\\u00a5\\u00a6\\u00a7" + + "\\u00a8\\u00a9\\u00aa\\u00ab\\u00ac\\u00ad\\u00ae\\u00af" + + "\\u00b0\\u00b1\\u00b2\\u00b3\\u00b4\\u00b5\\u00b6\\u00b7" + + "\\u00b8\\u00b9\\u00ba\\u00bb\\u00bc\\u00bd\\u00be\\u00bf" + + "\\u00c0\\u00c1\\u00c2\\u00c3\\u00c4\\u00c5\\u00c6\\u00c7" + + "\\u00c8\\u00c9\\u00ca\\u00cb\\u00cc\\u00cd\\u00ce\\u00cf" + + "\\u00d0\\u00d1\\u00d2\\u00d3\\u00d4\\u00d5\\u00d6\\u00d7" + + "\\u00d8\\u00d9\\u00da\\u00db\\u00dc\\u00dd\\u00de\\u00df" + + "\\u00e0\\u00e1\\u00e2\\u00e3\\u00e4\\u00e5\\u00e6\\u00e7" + + "\\u00e8\\u00e9\\u00ea\\u00eb\\u00ec\\u00ed\\u00ee\\u00ef" + + "\\u00f0\\u00f1\\u00f2\\u00f3\\u00f4\\u00f5\\u00f6\\u00f7" + + "\\u00f8\\u00f9\\u00fa\\u00fb\\u00fc\\u00fd\\u00fe\\u00ff" + + "\""); + + { + std::istringstream is(serializeString(teststring2), std::ios::binary); + UASSERT(deSerializeString(is) == teststring2); + UASSERT(!is.eof()); + is.get(); + UASSERT(is.eof()); + } + { + std::istringstream is(serializeWideString(teststring2_w), std::ios::binary); + UASSERT(deSerializeWideString(is) == teststring2_w); + UASSERT(!is.eof()); + is.get(); + UASSERT(is.eof()); + } + { + std::istringstream is(serializeLongString(teststring2), std::ios::binary); + UASSERT(deSerializeLongString(is) == teststring2); + UASSERT(!is.eof()); + is.get(); + UASSERT(is.eof()); + } + { + std::istringstream is(serializeJsonString(teststring2), std::ios::binary); + //dstream< "; + infostream<<"str_out.size()="< "; for(u32 i=0; i "; + infostream<<"str_out.size()="< "; for(u32 i=0; iget(n).light_propagates == true); + n.setContent(LEGN(nodedef, "CONTENT_STONE")); + UASSERT(nodedef->get(n).light_propagates == false); } }; -struct TestVoxelManipulator +struct TestVoxelManipulator: public TestBase { - void Run() + void Run(INodeDefManager *nodedef) { /* VoxelArea */ VoxelArea a(v3s16(-1,-1,-1), v3s16(1,1,1)); - assert(a.index(0,0,0) == 1*3*3 + 1*3 + 1); - assert(a.index(-1,-1,-1) == 0); + UASSERT(a.index(0,0,0) == 1*3*3 + 1*3 + 1); + UASSERT(a.index(-1,-1,-1) == 0); VoxelArea c(v3s16(-2,-2,-2), v3s16(2,2,2)); // An area that is 1 bigger in x+ and z- @@ -221,17 +516,17 @@ struct TestVoxelManipulator results.push_back(VoxelArea(v3s16(-2,-2,-3),v3s16(3,2,-3))); results.push_back(VoxelArea(v3s16(3,-2,-2),v3s16(3,2,2))); - assert(aa.size() == results.size()); + UASSERT(aa.size() == results.size()); - dstream<<"Result of diff:"<::Iterator i = aa.begin(); i != aa.end(); i++) { - i->print(dstream); - dstream<print(infostream); + infostream<=0; y--) - for(s16 x=0; x light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, true, light_sources, ndef); + //v.print(dstream, ndef, VOXELPRINT_LIGHT_DAY); + UASSERT(res.bottom_sunlight_valid == true); + UASSERT(v.getNode(v3s16(1,1,1)).getLight(LIGHTBANK_DAY, ndef) + == LIGHT_SUN); + } + v.setNodeNoRef(v3s16(0,0,0), MapNode(CONTENT_STONE)); + { + core::map light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, true, light_sources, ndef); + UASSERT(res.bottom_sunlight_valid == true); + UASSERT(v.getNode(v3s16(1,1,1)).getLight(LIGHTBANK_DAY, ndef) + == LIGHT_SUN); + } + { + core::map light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, false, light_sources, ndef); + UASSERT(res.bottom_sunlight_valid == true); + UASSERT(v.getNode(v3s16(2,0,2)).getLight(LIGHTBANK_DAY, ndef) + == 0); + } + v.setNodeNoRef(v3s16(1,3,2), MapNode(CONTENT_STONE)); + { + core::map light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, true, light_sources, ndef); + UASSERT(res.bottom_sunlight_valid == true); + UASSERT(v.getNode(v3s16(1,1,2)).getLight(LIGHTBANK_DAY, ndef) + == 0); + } + { + core::map light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, false, light_sources, ndef); + UASSERT(res.bottom_sunlight_valid == true); + UASSERT(v.getNode(v3s16(1,0,2)).getLight(LIGHTBANK_DAY, ndef) + == 0); + } + { + MapNode n(CONTENT_AIR); + n.setLight(LIGHTBANK_DAY, 10, ndef); + v.setNodeNoRef(v3s16(1,-1,2), n); + } + { + core::map light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, true, light_sources, ndef); + UASSERT(res.bottom_sunlight_valid == true); + } + { + core::map light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, false, light_sources, ndef); + UASSERT(res.bottom_sunlight_valid == true); + } + { + MapNode n(CONTENT_AIR); + n.setLight(LIGHTBANK_DAY, LIGHT_SUN, ndef); + v.setNodeNoRef(v3s16(1,-1,2), n); + } + { + core::map light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, true, light_sources, ndef); + UASSERT(res.bottom_sunlight_valid == false); + } + { + core::map light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, false, light_sources, ndef); + UASSERT(res.bottom_sunlight_valid == false); + } + v.setNodeNoRef(v3s16(1,3,2), MapNode(CONTENT_IGNORE)); + { + core::map light_sources; + voxalgo::setLight(v, a, 0, ndef); + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + v, a, true, light_sources, ndef); + UASSERT(res.bottom_sunlight_valid == true); + } } - - v.print(dstream, VOXELPRINT_WATERPRESSURE); - - core::map active_nodes; - v.updateAreaWaterPressure(area, active_nodes); - - v.print(dstream, VOXELPRINT_WATERPRESSURE); - - //s16 highest_y = -32768; /* - NOTE: These are commented out because this behaviour is changed - all the time + voxalgo::clearLightAndCollectSources */ - //assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == -1); - //assert(highest_y == 3); - /*assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == 3); - //assert(highest_y == 3);*/ - - active_nodes.clear(); - active_nodes[v3s16(9,1,0)] = 1; - //v.flowWater(active_nodes, 0, true, 1000); - v.flowWater(active_nodes, 0, false, 1000); + { + VoxelManipulator v; + for(u16 z=0; z<3; z++) + for(u16 y=0; y<3; y++) + for(u16 x=0; x<3; x++) + { + v3s16 p(x,y,z); + v.setNode(p, MapNode(CONTENT_AIR)); + } + VoxelArea a(v3s16(0,0,0), v3s16(2,2,2)); + v.setNodeNoRef(v3s16(0,0,0), MapNode(CONTENT_STONE)); + v.setNodeNoRef(v3s16(1,1,1), MapNode(CONTENT_TORCH)); + { + MapNode n(CONTENT_AIR); + n.setLight(LIGHTBANK_DAY, 1, ndef); + v.setNode(v3s16(1,1,2), n); + } + { + core::map light_sources; + core::map unlight_from; + voxalgo::clearLightAndCollectSources(v, a, LIGHTBANK_DAY, + ndef, light_sources, unlight_from); + //v.print(dstream, ndef, VOXELPRINT_LIGHT_DAY); + UASSERT(v.getNode(v3s16(0,1,1)).getLight(LIGHTBANK_DAY, ndef) + == 0); + UASSERT(light_sources.find(v3s16(1,1,1)) != NULL); + UASSERT(light_sources.size() == 1); + UASSERT(unlight_from.find(v3s16(1,1,2)) != NULL); + UASSERT(unlight_from.size() == 1); + } + } + } +}; + +struct TestInventory: public TestBase +{ + void Run(IItemDefManager *idef) + { + std::string serialized_inventory = + "List 0 32\n" + "Width 3\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Item default:cobble 61\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Item default:dirt 71\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Item default:dirt 99\n" + "Item default:cobble 38\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "Empty\n" + "EndInventoryList\n" + "EndInventory\n"; - dstream<<"Final result of flowWater:"<setName("main"); + UASSERT(!inv.getList("0")); + UASSERT(inv.getList("main")); + UASSERT(inv.getList("main")->getWidth() == 3); + inv.getList("main")->setWidth(5); + std::ostringstream inv_os(std::ios::binary); + inv.serialize(inv_os); + UASSERT(inv_os.str() == serialized_inventory_2); } }; -struct TestMapBlock +/* + NOTE: These tests became non-working then NodeContainer was removed. + These should be redone, utilizing some kind of a virtual + interface for Map (IMap would be fine). +*/ +#if 0 +struct TestMapBlock: public TestBase { class TC : public NodeContainer { @@ -395,63 +872,74 @@ struct TestMapBlock MapBlock b(&parent, v3s16(1,1,1)); v3s16 relpos(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE); - assert(b.getPosRelative() == relpos); + UASSERT(b.getPosRelative() == relpos); - assert(b.getBox().MinEdge.X == MAP_BLOCKSIZE); - assert(b.getBox().MaxEdge.X == MAP_BLOCKSIZE*2-1); - assert(b.getBox().MinEdge.Y == MAP_BLOCKSIZE); - assert(b.getBox().MaxEdge.Y == MAP_BLOCKSIZE*2-1); - assert(b.getBox().MinEdge.Z == MAP_BLOCKSIZE); - assert(b.getBox().MaxEdge.Z == MAP_BLOCKSIZE*2-1); + UASSERT(b.getBox().MinEdge.X == MAP_BLOCKSIZE); + UASSERT(b.getBox().MaxEdge.X == MAP_BLOCKSIZE*2-1); + UASSERT(b.getBox().MinEdge.Y == MAP_BLOCKSIZE); + UASSERT(b.getBox().MaxEdge.Y == MAP_BLOCKSIZE*2-1); + UASSERT(b.getBox().MinEdge.Z == MAP_BLOCKSIZE); + UASSERT(b.getBox().MaxEdge.Z == MAP_BLOCKSIZE*2-1); - assert(b.isValidPosition(v3s16(0,0,0)) == true); - assert(b.isValidPosition(v3s16(-1,0,0)) == false); - assert(b.isValidPosition(v3s16(-1,-142,-2341)) == false); - assert(b.isValidPosition(v3s16(-124,142,2341)) == false); - assert(b.isValidPosition(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1)) == true); - assert(b.isValidPosition(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE,MAP_BLOCKSIZE-1)) == false); + UASSERT(b.isValidPosition(v3s16(0,0,0)) == true); + UASSERT(b.isValidPosition(v3s16(-1,0,0)) == false); + UASSERT(b.isValidPosition(v3s16(-1,-142,-2341)) == false); + UASSERT(b.isValidPosition(v3s16(-124,142,2341)) == false); + UASSERT(b.isValidPosition(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1)) == true); + UASSERT(b.isValidPosition(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE,MAP_BLOCKSIZE-1)) == false); /* TODO: this method should probably be removed if the block size isn't going to be set variable */ - /*assert(b.getSizeNodes() == v3s16(MAP_BLOCKSIZE, + /*UASSERT(b.getSizeNodes() == v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE));*/ // Changed flag should be initially set - assert(b.getChangedFlag() == true); - b.resetChangedFlag(); - assert(b.getChangedFlag() == false); + UASSERT(b.getModified() == MOD_STATE_WRITE_NEEDED); + b.resetModified(); + UASSERT(b.getModified() == MOD_STATE_CLEAN); // All nodes should have been set to - // .d=CONTENT_AIR and .getLight() = 0 + // .d=CONTENT_IGNORE and .getLight() = 0 for(u16 z=0; z light_sources; // The bottom block is invalid, because we have a shadowing node - assert(b.propagateSunlight(light_sources) == false); - assert(b.getNode(v3s16(1,4,0)).getLight(LIGHTBANK_DAY) == LIGHT_SUN); - assert(b.getNode(v3s16(1,3,0)).getLight(LIGHTBANK_DAY) == LIGHT_SUN); - assert(b.getNode(v3s16(1,2,0)).getLight(LIGHTBANK_DAY) == 0); - assert(b.getNode(v3s16(1,1,0)).getLight(LIGHTBANK_DAY) == 0); - assert(b.getNode(v3s16(1,0,0)).getLight(LIGHTBANK_DAY) == 0); - assert(b.getNode(v3s16(1,2,3)).getLight(LIGHTBANK_DAY) == LIGHT_SUN); - assert(b.getFaceLight(1000, p, v3s16(0,1,0)) == LIGHT_SUN); - assert(b.getFaceLight(1000, p, v3s16(0,-1,0)) == 0); - assert(b.getFaceLight(0, p, v3s16(0,-1,0)) == 0); + UASSERT(b.propagateSunlight(light_sources) == false); + UASSERT(b.getNode(v3s16(1,4,0)).getLight(LIGHTBANK_DAY) == LIGHT_SUN); + UASSERT(b.getNode(v3s16(1,3,0)).getLight(LIGHTBANK_DAY) == LIGHT_SUN); + UASSERT(b.getNode(v3s16(1,2,0)).getLight(LIGHTBANK_DAY) == 0); + UASSERT(b.getNode(v3s16(1,1,0)).getLight(LIGHTBANK_DAY) == 0); + UASSERT(b.getNode(v3s16(1,0,0)).getLight(LIGHTBANK_DAY) == 0); + UASSERT(b.getNode(v3s16(1,2,3)).getLight(LIGHTBANK_DAY) == LIGHT_SUN); + UASSERT(b.getFaceLight2(1000, p, v3s16(0,1,0)) == LIGHT_SUN); + UASSERT(b.getFaceLight2(1000, p, v3s16(0,-1,0)) == 0); + UASSERT(b.getFaceLight2(0, p, v3s16(0,-1,0)) == 0); // According to MapBlock::getFaceLight, // The face on the z+ side should have double-diminished light - //assert(b.getFaceLight(p, v3s16(0,0,1)) == diminish_light(diminish_light(LIGHT_MAX))); + //UASSERT(b.getFaceLight(p, v3s16(0,0,1)) == diminish_light(diminish_light(LIGHT_MAX))); // The face on the z+ side should have diminished light - assert(b.getFaceLight(1000, p, v3s16(0,0,1)) == diminish_light(LIGHT_MAX)); + UASSERT(b.getFaceLight2(1000, p, v3s16(0,0,1)) == diminish_light(LIGHT_MAX)); } /* Check how the block handles being in between blocks with some non-sunlight @@ -538,11 +1026,11 @@ struct TestMapBlock core::map light_sources; // The block below should be valid because there shouldn't be // sunlight in there either - assert(b.propagateSunlight(light_sources, true) == true); + UASSERT(b.propagateSunlight(light_sources, true) == true); // Should not touch nodes that are not affected (that is, all of them) - //assert(b.getNode(v3s16(1,2,3)).getLight() == LIGHT_SUN); + //UASSERT(b.getNode(v3s16(1,2,3)).getLight() == LIGHT_SUN); // Should set light of non-sunlighted blocks to 0. - assert(b.getNode(v3s16(1,2,3)).getLight(LIGHTBANK_DAY) == 0); + UASSERT(b.getNode(v3s16(1,2,3)).getLight(LIGHTBANK_DAY) == 0); } /* Set up a situation where: @@ -560,7 +1048,7 @@ struct TestMapBlock for(u16 y=0; y light_sources; // Bottom block is not valid - assert(b.propagateSunlight(light_sources) == false); + UASSERT(b.propagateSunlight(light_sources) == false); } } }; -struct TestMapSector +struct TestMapSector: public TestBase { class TC : public NodeContainer { @@ -629,13 +1117,13 @@ struct TestMapSector // Create one with no heightmaps ServerMapSector sector(&parent, v2s16(1,1)); - EXCEPTION_CHECK(InvalidPositionException, sector.getBlockNoCreate(0)); - EXCEPTION_CHECK(InvalidPositionException, sector.getBlockNoCreate(1)); + UASSERT(sector.getBlockNoCreateNoEx(0) == 0); + UASSERT(sector.getBlockNoCreateNoEx(1) == 0); MapBlock * bref = sector.createBlankBlock(-2); - EXCEPTION_CHECK(InvalidPositionException, sector.getBlockNoCreate(0)); - assert(sector.getBlockNoCreate(-2) == bref); + UASSERT(sector.getBlockNoCreateNoEx(0) == 0); + UASSERT(sector.getBlockNoCreateNoEx(-2) == bref); //TODO: Check for AlreadyExistsException @@ -646,12 +1134,160 @@ struct TestMapSector catch(InvalidPositionException &e){ exception_thrown = true; } - assert(exception_thrown);*/ + UASSERT(exception_thrown);*/ } }; +#endif -struct TestSocket +struct TestCollision: public TestBase +{ + void Run() + { + /* + axisAlignedCollision + */ + + for(s16 bx = -3; bx <= 3; bx++) + for(s16 by = -3; by <= 3; by++) + for(s16 bz = -3; bz <= 3; bz++) + { + // X- + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx-2, by, bz, bx-1, by+1, bz+1); + v3f v(1, 0, 0); + f32 dtime = 0; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 0); + UASSERT(fabs(dtime - 1.000) < 0.001); + } + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx-2, by, bz, bx-1, by+1, bz+1); + v3f v(-1, 0, 0); + f32 dtime = 0; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == -1); + } + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx-2, by+1.5, bz, bx-1, by+2.5, bz-1); + v3f v(1, 0, 0); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == -1); + } + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx-2, by-1.5, bz, bx-1.5, by+0.5, bz+1); + v3f v(0.5, 0.1, 0); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 0); + UASSERT(fabs(dtime - 3.000) < 0.001); + } + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx-2, by-1.5, bz, bx-1.5, by+0.5, bz+1); + v3f v(0.5, 0.1, 0); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 0); + UASSERT(fabs(dtime - 3.000) < 0.001); + } + + // X+ + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx+2, by, bz, bx+3, by+1, bz+1); + v3f v(-1, 0, 0); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 0); + UASSERT(fabs(dtime - 1.000) < 0.001); + } + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx+2, by, bz, bx+3, by+1, bz+1); + v3f v(1, 0, 0); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == -1); + } + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx+2, by, bz+1.5, bx+3, by+1, bz+3.5); + v3f v(-1, 0, 0); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == -1); + } + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx+2, by-1.5, bz, bx+2.5, by-0.5, bz+1); + v3f v(-0.5, 0.2, 0); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 1); // Y, not X! + UASSERT(fabs(dtime - 2.500) < 0.001); + } + { + aabb3f s(bx, by, bz, bx+1, by+1, bz+1); + aabb3f m(bx+2, by-1.5, bz, bx+2.5, by-0.5, bz+1); + v3f v(-0.5, 0.3, 0); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 0); + UASSERT(fabs(dtime - 2.000) < 0.001); + } + + // TODO: Y-, Y+, Z-, Z+ + + // misc + { + aabb3f s(bx, by, bz, bx+2, by+2, bz+2); + aabb3f m(bx+2.3, by+2.29, bz+2.29, bx+4.2, by+4.2, bz+4.2); + v3f v(-1./3, -1./3, -1./3); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 0); + UASSERT(fabs(dtime - 0.9) < 0.001); + } + { + aabb3f s(bx, by, bz, bx+2, by+2, bz+2); + aabb3f m(bx+2.29, by+2.3, bz+2.29, bx+4.2, by+4.2, bz+4.2); + v3f v(-1./3, -1./3, -1./3); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 1); + UASSERT(fabs(dtime - 0.9) < 0.001); + } + { + aabb3f s(bx, by, bz, bx+2, by+2, bz+2); + aabb3f m(bx+2.29, by+2.29, bz+2.3, bx+4.2, by+4.2, bz+4.2); + v3f v(-1./3, -1./3, -1./3); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 2); + UASSERT(fabs(dtime - 0.9) < 0.001); + } + { + aabb3f s(bx, by, bz, bx+2, by+2, bz+2); + aabb3f m(bx-4.2, by-4.2, bz-4.2, bx-2.3, by-2.29, bz-2.29); + v3f v(1./7, 1./7, 1./7); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 0); + UASSERT(fabs(dtime - 16.1) < 0.001); + } + { + aabb3f s(bx, by, bz, bx+2, by+2, bz+2); + aabb3f m(bx-4.2, by-4.2, bz-4.2, bx-2.29, by-2.3, bz-2.29); + v3f v(1./7, 1./7, 1./7); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 1); + UASSERT(fabs(dtime - 16.1) < 0.001); + } + { + aabb3f s(bx, by, bz, bx+2, by+2, bz+2); + aabb3f m(bx-4.2, by-4.2, bz-4.2, bx-2.29, by-2.29, bz-2.3); + v3f v(1./7, 1./7, 1./7); + f32 dtime; + UASSERT(axisAlignedCollision(s, m, v, 0, dtime) == 2); + UASSERT(fabs(dtime - 16.1) < 0.001); + } + } + } +}; + +struct TestSocket: public TestBase { void Run() { @@ -674,12 +1310,12 @@ struct TestSocket break; } //FIXME: This fails on some systems - assert(strncmp(sendbuffer, rcvbuffer, sizeof(sendbuffer))==0); - assert(sender.getAddress() == Address(127,0,0,1, 0).getAddress()); + UASSERT(strncmp(sendbuffer, rcvbuffer, sizeof(sendbuffer))==0); + UASSERT(sender.getAddress() == Address(127,0,0,1, 0).getAddress()); } }; -struct TestConnection +struct TestConnection: public TestBase { void TestHelpers() { @@ -707,25 +1343,25 @@ struct TestConnection Data: [7] u8 data1[0] */ - assert(readU32(&p1.data[0]) == proto_id); - assert(readU16(&p1.data[4]) == peer_id); - assert(readU8(&p1.data[6]) == channel); - assert(readU8(&p1.data[7]) == data1[0]); + UASSERT(readU32(&p1.data[0]) == proto_id); + UASSERT(readU16(&p1.data[4]) == peer_id); + UASSERT(readU8(&p1.data[6]) == channel); + UASSERT(readU8(&p1.data[7]) == data1[0]); - //dstream<<"initial data1[0]="<<((u32)data1[0]&0xff)< data; + infostream<<"** running client.Receive()"< data = SharedBufferFromString("Hello World!"); - dstream<<"** running client.Send()"< data1 = SharedBufferFromString("hello1"); SharedBuffer data2 = SharedBufferFromString("Hello2"); Address client_address = - server.GetPeer(peer_id_client)->address; + server.GetPeerAddress(peer_id_client); - dstream<<"*** Sending packets in wrong order (2,1,2)" + infostream<<"*** Sending packets in wrong order (2,1,2)" <channels[chn]; + con::Channel *ch = &server.getPeer(peer_id_client)->channels[chn]; u16 sn = ch->next_outgoing_seqnum; ch->next_outgoing_seqnum = sn+1; server.Send(peer_id_client, chn, data2, true); @@ -904,98 +1566,157 @@ struct TestConnection sleep_ms(50); - dstream<<"*** Receiving the packets"< recvdata; u32 size; - dstream<<"** running client.Receive()"< data1(1100); - for(u16 i=0; i<1100; i++){ + infostream<<"Sending large amounts of packets (infinite test)"<20) - dstream<<"..."; - dstream<20) + infostream<<"..."; + infostream< recvdata; + infostream<<"** running client.Receive()"<20) - dstream<<"..."; - dstream<