X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftest.cpp;h=072bda8ef79ab63bd5abae70662328667918db68;hb=00fc0babe0c6c5464fa9ffbc5a257b1e2aa93111;hp=448ba23ceddd63ff918e4ba8fe33cf70a897b157;hpb=fd1135c7af46eb2f5b99a11f48bf9f9ae335ea9c;p=oweals%2Fminetest.git diff --git a/src/test.cpp b/src/test.cpp index 448ba23ce..072bda8ef 100644 --- a/src/test.cpp +++ b/src/test.cpp @@ -1,6 +1,6 @@ /* -Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by @@ -18,16 +18,16 @@ with this program; if not, write to the Free Software Foundation, Inc., */ #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" @@ -35,9 +35,15 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "mapsector.h" #include "settings.h" #include "log.h" -#include "utility_string.h" +#include "util/string.h" +#include "filesys.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 +#include /* Asserts that the exception occurs @@ -47,27 +53,35 @@ 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);\ } +#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 +static content_t CONTENT_STONE; +static content_t CONTENT_GRASS; +static content_t CONTENT_TORCH; 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"; @@ -83,12 +97,11 @@ void define_some_nodes(IWritableItemDefManager *idef, IWritableNodeDefManager *n f.tiledef[i].name = "default_stone.png"; f.is_ground_content = true; idef->registerItem(itemdef); - ndef->set(i, f); + CONTENT_STONE = ndef->set(f.name, f); /* Grass */ - i = CONTENT_GRASS; itemdef = ItemDefinition(); itemdef.type = ITEM_NODE; itemdef.name = "default:dirt_with_grass"; @@ -106,12 +119,11 @@ void define_some_nodes(IWritableItemDefManager *idef, IWritableNodeDefManager *n f.tiledef[i].name = "default_dirt.png^default_grass_side.png"; f.is_ground_content = true; idef->registerItem(itemdef); - ndef->set(i, f); + CONTENT_GRASS = ndef->set(f.name, f); /* Torch (minimal definition for lighting tests) */ - i = CONTENT_TORCH; itemdef = ItemDefinition(); itemdef.type = ITEM_NODE; itemdef.name = "default:torch"; @@ -122,65 +134,453 @@ void define_some_nodes(IWritableItemDefManager *idef, IWritableNodeDefManager *n f.sunlight_propagates = true; f.light_source = LIGHT_MAX-1; idef->registerItem(itemdef); - ndef->set(i, f); + CONTENT_TORCH = ndef->set(f.name, f); } -struct TestUtilities +struct TestBase +{ + bool test_failed; + TestBase(): + test_failed(false) + {} +}; + +struct TestUtilities: public TestBase { void Run() { /*infostream<<"wrapDegrees(100.0) = "< changes '/' to DIR_DELIM + // -> absolute paths start with "C:\\" on windows + std::string p(std::string path) + { + for(size_t i = 0; i < path.size(); ++i){ + if(path[i] == '/'){ + path.replace(i, 1, DIR_DELIM); + i += std::string(DIR_DELIM).size() - 1; // generally a no-op + } + } + + #ifdef _WIN32 + if(path[0] == '\\') + path = "C:" + path; + #endif + + return path; + } + + void Run() + { + std::string path, result, removed; + + /* + Test fs::IsDirDelimiter + */ + UASSERT(fs::IsDirDelimiter('/') == true); + UASSERT(fs::IsDirDelimiter('A') == false); + UASSERT(fs::IsDirDelimiter(0) == false); + #ifdef _WIN32 + UASSERT(fs::IsDirDelimiter('\\') == true); + #else + UASSERT(fs::IsDirDelimiter('\\') == false); + #endif + + /* + Test fs::PathStartsWith + */ + { + const int numpaths = 12; + std::string paths[numpaths] = { + "", + p("/"), + p("/home/user/minetest"), + p("/home/user/minetest/bin"), + p("/home/user/.minetest"), + p("/tmp/dir/file"), + p("/tmp/file/"), + p("/tmP/file"), + p("/tmp"), + p("/tmp/dir"), + p("/home/user2/minetest/worlds"), + p("/home/user2/minetest/world"), + }; + /* + expected fs::PathStartsWith results + 0 = returns false + 1 = returns true + 2 = returns false on windows, false elsewhere + 3 = returns true on windows, true elsewhere + 4 = returns true if and only if + FILESYS_CASE_INSENSITIVE is true + */ + int expected_results[numpaths][numpaths] = { + {1,2,0,0,0,0,0,0,0,0,0,0}, + {1,1,0,0,0,0,0,0,0,0,0,0}, + {1,1,1,0,0,0,0,0,0,0,0,0}, + {1,1,1,1,0,0,0,0,0,0,0,0}, + {1,1,0,0,1,0,0,0,0,0,0,0}, + {1,1,0,0,0,1,0,0,1,1,0,0}, + {1,1,0,0,0,0,1,4,1,0,0,0}, + {1,1,0,0,0,0,4,1,4,0,0,0}, + {1,1,0,0,0,0,0,0,1,0,0,0}, + {1,1,0,0,0,0,0,0,1,1,0,0}, + {1,1,0,0,0,0,0,0,0,0,1,0}, + {1,1,0,0,0,0,0,0,0,0,0,1}, + }; + + for (int i = 0; i < numpaths; i++) + for (int j = 0; j < numpaths; j++){ + /*verbosestream<<"testing fs::PathStartsWith(\"" + <getS16("a") == 5); + UASSERT(fabs(group->getFloat("bb") - 2.5) < 0.001); + + Settings *group3 = new Settings; + group3->set("cat", "meow"); + group3->set("dog", "woof"); + + Settings *group2 = new Settings; + group2->setS16("num_apples", 4); + group2->setS16("num_oranges", 53); + group2->setGroup("animals", group3); + group2->set("animals", "cute"); //destroys group 3 + s.setGroup("groupy_thing", group2); + + // Test set failure conditions + UASSERT(s.set("Zoop = Poop\nsome_other_setting", "false") == false); + UASSERT(s.set("sneaky", "\"\"\"\njabberwocky = false") == false); + UASSERT(s.set("hehe", "asdfasdf\n\"\"\"\nsomething = false") == false); + + // Test multiline settings + UASSERT(group->get("ccc") == "testy\n testa "); + + UASSERT(s.get("blarg") == + "some multiline text\n" + " with leading whitespace!"); + + // Test NoiseParams + UASSERT(s.getEntry("np_terrain").is_group == false); + + NoiseParams np; + UASSERT(s.getNoiseParams("np_terrain", np) == true); + UASSERT(fabs(np.offset - 5) < 0.001); + UASSERT(fabs(np.scale - 40) < 0.001); + UASSERT(fabs(np.spread.X - 250) < 0.001); + UASSERT(fabs(np.spread.Y - 250) < 0.001); + UASSERT(fabs(np.spread.Z - 250) < 0.001); + UASSERT(np.seed == 12341); + UASSERT(np.octaves == 5); + UASSERT(fabs(np.persist - 0.7) < 0.001); + + np.offset = 3.5; + np.octaves = 6; + s.setNoiseParams("np_terrain", np); + + UASSERT(s.getEntry("np_terrain").is_group == true); + + // Test writing + std::ostringstream os(std::ios_base::binary); + is.clear(); + is.seekg(0); + + UASSERT(s.updateConfigObject(is, os, "", 0) == true); + //printf(">>>> expected config:\n%s\n", TEST_CONFIG_TEXT_AFTER); + //printf(">>>> actual config:\n%s\n", os.str().c_str()); + UASSERT(os.str() == TEST_CONFIG_TEXT_AFTER); + } catch (SettingNotFoundException &e) { + UASSERT(!"Setting not found!"); + } } }; -struct TestSerialization +struct TestSerialization: public TestBase { // To be used like this: // mkstr("Some\0string\0with\0embedded\0nuls") @@ -194,19 +594,19 @@ struct TestSerialization { // Tests some serialization primitives - assert(serializeString("") == mkstr("\0\0")); - assert(serializeWideString(L"") == mkstr("\0\0")); - assert(serializeLongString("") == mkstr("\0\0\0\0")); - assert(serializeJsonString("") == "\"\""); - + UASSERT(serializeString("") == mkstr("\0\0")); + UASSERT(serializeWideString(L"") == mkstr("\0\0")); + UASSERT(serializeLongString("") == mkstr("\0\0\0\0")); + UASSERT(serializeJsonString("") == "\"\""); + std::string teststring = "Hello world!"; - assert(serializeString(teststring) == + UASSERT(serializeString(teststring) == mkstr("\0\14Hello world!")); - assert(serializeWideString(narrow_to_wide(teststring)) == + UASSERT(serializeWideString(narrow_to_wide(teststring)) == mkstr("\0\14\0H\0e\0l\0l\0o\0 \0w\0o\0r\0l\0d\0!")); - assert(serializeLongString(teststring) == + UASSERT(serializeLongString(teststring) == mkstr("\0\0\0\14Hello world!")); - assert(serializeJsonString(teststring) == + UASSERT(serializeJsonString(teststring) == "\"Hello world!\""); std::string teststring2; @@ -226,15 +626,15 @@ struct TestSerialization teststring2_w = tmp_os_w.str(); teststring2_w_encoded = tmp_os_w_encoded.str(); } - assert(serializeString(teststring2) == + UASSERT(serializeString(teststring2) == mkstr("\1\0") + teststring2); - assert(serializeWideString(teststring2_w) == + UASSERT(serializeWideString(teststring2_w) == mkstr("\1\0") + teststring2_w_encoded); - assert(serializeLongString(teststring2) == + UASSERT(serializeLongString(teststring2) == mkstr("\0\0\1\0") + teststring2); // MSVC fails when directly using "\\\\" std::string backslash = "\\"; - assert(serializeJsonString(teststring2) == + UASSERT(serializeJsonString(teststring2) == mkstr("\"") + "\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007" + "\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f" + @@ -263,37 +663,57 @@ struct TestSerialization { std::istringstream is(serializeString(teststring2), std::ios::binary); - assert(deSerializeString(is) == teststring2); - assert(!is.eof()); + UASSERT(deSerializeString(is) == teststring2); + UASSERT(!is.eof()); is.get(); - assert(is.eof()); + UASSERT(is.eof()); } { std::istringstream is(serializeWideString(teststring2_w), std::ios::binary); - assert(deSerializeWideString(is) == teststring2_w); - assert(!is.eof()); + UASSERT(deSerializeWideString(is) == teststring2_w); + UASSERT(!is.eof()); is.get(); - assert(is.eof()); + UASSERT(is.eof()); } { std::istringstream is(serializeLongString(teststring2), std::ios::binary); - assert(deSerializeLongString(is) == teststring2); - assert(!is.eof()); + UASSERT(deSerializeLongString(is) == teststring2); + UASSERT(!is.eof()); is.get(); - assert(is.eof()); + UASSERT(is.eof()); } { std::istringstream is(serializeJsonString(teststring2), std::ios::binary); //dstream< "; for(u32 i=0; i "; for(u32 i=0; iget(n).light_propagates == true); + UASSERT(nodedef->get(n).light_propagates == true); n.setContent(LEGN(nodedef, "CONTENT_STONE")); - assert(nodedef->get(n).light_propagates == false); + UASSERT(nodedef->get(n).light_propagates == false); } }; -struct TestVoxelManipulator +struct TestVoxelManipulator: public TestBase { void Run(INodeDefManager *nodedef) { @@ -439,51 +879,51 @@ struct TestVoxelManipulator */ 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- VoxelArea d(v3s16(-2,-2,-3), v3s16(3,2,2)); - - core::list aa; + + std::list aa; d.diff(c, aa); - + // Correct results - core::array results; + std::vector results; 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()); + infostream<<"Result of diff:"<::Iterator - i = aa.begin(); i != aa.end(); i++) + for(std::list::const_iterator + i = aa.begin(); i != aa.end(); ++i) { i->print(infostream); infostream<::iterator j = std::find(results.begin(), results.end(), *i); + UASSERT(j != results.end()); + results.erase(j); } /* VoxelManipulator */ - + VoxelManipulator v; v.print(infostream, nodedef); infostream<<"*** Setting (-1,0,-1)=2 ***"< light_sources; + std::set 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); - assert(res.bottom_sunlight_valid == true); - assert(v.getNode(v3s16(1,1,1)).getLight(LIGHTBANK_DAY, ndef) + 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; + std::set light_sources; voxalgo::setLight(v, a, 0, ndef); voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( v, a, true, light_sources, ndef); - assert(res.bottom_sunlight_valid == true); - assert(v.getNode(v3s16(1,1,1)).getLight(LIGHTBANK_DAY, ndef) + UASSERT(res.bottom_sunlight_valid == true); + UASSERT(v.getNode(v3s16(1,1,1)).getLight(LIGHTBANK_DAY, ndef) == LIGHT_SUN); } { - core::map light_sources; + std::set light_sources; voxalgo::setLight(v, a, 0, ndef); voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( v, a, false, light_sources, ndef); - assert(res.bottom_sunlight_valid == true); - assert(v.getNode(v3s16(2,0,2)).getLight(LIGHTBANK_DAY, 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; + std::set light_sources; voxalgo::setLight(v, a, 0, ndef); voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( v, a, true, light_sources, ndef); - assert(res.bottom_sunlight_valid == true); - assert(v.getNode(v3s16(1,1,2)).getLight(LIGHTBANK_DAY, ndef) + UASSERT(res.bottom_sunlight_valid == true); + UASSERT(v.getNode(v3s16(1,1,2)).getLight(LIGHTBANK_DAY, ndef) == 0); } { - core::map light_sources; + std::set light_sources; voxalgo::setLight(v, a, 0, ndef); voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( v, a, false, light_sources, ndef); - assert(res.bottom_sunlight_valid == true); - assert(v.getNode(v3s16(1,0,2)).getLight(LIGHTBANK_DAY, ndef) + UASSERT(res.bottom_sunlight_valid == true); + UASSERT(v.getNode(v3s16(1,0,2)).getLight(LIGHTBANK_DAY, ndef) == 0); } { @@ -573,18 +1013,18 @@ struct TestVoxelAlgorithms v.setNodeNoRef(v3s16(1,-1,2), n); } { - core::map light_sources; + std::set light_sources; voxalgo::setLight(v, a, 0, ndef); voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( v, a, true, light_sources, ndef); - assert(res.bottom_sunlight_valid == true); + UASSERT(res.bottom_sunlight_valid == true); } { - core::map light_sources; + std::set light_sources; voxalgo::setLight(v, a, 0, ndef); voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( v, a, false, light_sources, ndef); - assert(res.bottom_sunlight_valid == true); + UASSERT(res.bottom_sunlight_valid == true); } { MapNode n(CONTENT_AIR); @@ -592,26 +1032,26 @@ struct TestVoxelAlgorithms v.setNodeNoRef(v3s16(1,-1,2), n); } { - core::map light_sources; + std::set light_sources; voxalgo::setLight(v, a, 0, ndef); voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( v, a, true, light_sources, ndef); - assert(res.bottom_sunlight_valid == false); + UASSERT(res.bottom_sunlight_valid == false); } { - core::map light_sources; + std::set light_sources; voxalgo::setLight(v, a, 0, ndef); voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( v, a, false, light_sources, ndef); - assert(res.bottom_sunlight_valid == false); + UASSERT(res.bottom_sunlight_valid == false); } v.setNodeNoRef(v3s16(1,3,2), MapNode(CONTENT_IGNORE)); { - core::map light_sources; + std::set light_sources; voxalgo::setLight(v, a, 0, ndef); voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( v, a, true, light_sources, ndef); - assert(res.bottom_sunlight_valid == true); + UASSERT(res.bottom_sunlight_valid == true); } } /* @@ -635,28 +1075,29 @@ struct TestVoxelAlgorithms v.setNode(v3s16(1,1,2), n); } { - core::map light_sources; - core::map unlight_from; + std::set light_sources; + std::map unlight_from; voxalgo::clearLightAndCollectSources(v, a, LIGHTBANK_DAY, ndef, light_sources, unlight_from); //v.print(dstream, ndef, VOXELPRINT_LIGHT_DAY); - assert(v.getNode(v3s16(0,1,1)).getLight(LIGHTBANK_DAY, ndef) + UASSERT(v.getNode(v3s16(0,1,1)).getLight(LIGHTBANK_DAY, ndef) == 0); - assert(light_sources.find(v3s16(1,1,1)) != NULL); - assert(light_sources.size() == 1); - assert(unlight_from.find(v3s16(1,1,2)) != NULL); - assert(unlight_from.size() == 1); + UASSERT(light_sources.find(v3s16(1,1,1)) != light_sources.end()); + UASSERT(light_sources.size() == 1); + UASSERT(unlight_from.find(v3s16(1,1,2)) != unlight_from.end()); + UASSERT(unlight_from.size() == 1); } } } }; -struct TestInventory +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" @@ -691,9 +1132,10 @@ struct TestInventory "Empty\n" "EndInventoryList\n" "EndInventory\n"; - + std::string serialized_inventory_2 = "List main 32\n" + "Width 5\n" "Empty\n" "Empty\n" "Empty\n" @@ -728,18 +1170,20 @@ struct TestInventory "Empty\n" "EndInventoryList\n" "EndInventory\n"; - + Inventory inv(idef); std::istringstream is(serialized_inventory, std::ios::binary); inv.deSerialize(is); - assert(inv.getList("0")); - assert(!inv.getList("main")); + UASSERT(inv.getList("0")); + UASSERT(!inv.getList("main")); inv.getList("0")->setName("main"); - assert(!inv.getList("0")); - assert(inv.getList("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); - assert(inv_os.str() == serialized_inventory_2); + UASSERT(inv_os.str() == serialized_inventory_2); } }; @@ -749,7 +1193,7 @@ struct TestInventory interface for Map (IMap would be fine). */ #if 0 -struct TestMapBlock +struct TestMapBlock: public TestBase { class TC : public NodeContainer { @@ -802,37 +1246,37 @@ struct TestMapBlock void Run() { TC parent; - + MapBlock b(&parent, v3s16(1,1,1)); v3s16 relpos(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE); - assert(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); - - 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.getPosRelative() == relpos); + + 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); + + 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.getModified() == MOD_STATE_WRITE_NEEDED); + UASSERT(b.getModified() == MOD_STATE_WRITE_NEEDED); b.resetModified(); - assert(b.getModified() == MOD_STATE_CLEAN); + UASSERT(b.getModified() == MOD_STATE_CLEAN); // All nodes should have been set to // .d=CONTENT_IGNORE and .getLight() = 0 @@ -840,12 +1284,12 @@ struct TestMapBlock for(u16 y=0; y 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.getFaceLight2(1000, p, v3s16(0,1,0)) == LIGHT_SUN); - assert(b.getFaceLight2(1000, p, v3s16(0,-1,0)) == 0); - assert(b.getFaceLight2(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.getFaceLight2(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 @@ -960,11 +1404,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: @@ -1000,12 +1444,12 @@ struct TestMapBlock parent.node.setLight(LIGHTBANK_DAY, LIGHT_MAX/2); core::map 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 { @@ -1036,29 +1480,29 @@ struct TestMapSector if(position_valid == false) throw InvalidPositionException(); }; - + virtual u16 nodeContainerId() const { return 666; } }; - + void Run() { TC parent; parent.position_valid = false; - + // Create one with no heightmaps ServerMapSector sector(&parent, v2s16(1,1)); - - assert(sector.getBlockNoCreateNoEx(0) == 0); - assert(sector.getBlockNoCreateNoEx(1) == 0); + + UASSERT(sector.getBlockNoCreateNoEx(0) == 0); + UASSERT(sector.getBlockNoCreateNoEx(1) == 0); MapBlock * bref = sector.createBlankBlock(-2); - - assert(sector.getBlockNoCreateNoEx(0) == 0); - assert(sector.getBlockNoCreateNoEx(-2) == bref); - + + UASSERT(sector.getBlockNoCreateNoEx(0) == 0); + UASSERT(sector.getBlockNoCreateNoEx(-2) == bref); + //TODO: Check for AlreadyExistsException /*bool exception_thrown = false; @@ -1068,41 +1512,236 @@ struct TestMapSector catch(InvalidPositionException &e){ exception_thrown = true; } - assert(exception_thrown);*/ + UASSERT(exception_thrown);*/ } }; #endif -struct TestSocket +struct TestCollision: public TestBase { void Run() { - const int port = 30003; - UDPSocket socket; - socket.Bind(port); + /* + axisAlignedCollision + */ - const char sendbuffer[] = "hello world!"; - socket.Send(Address(127,0,0,1,port), sendbuffer, sizeof(sendbuffer)); + 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); + } - sleep_ms(50); + // 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+ - char rcvbuffer[256]; - memset(rcvbuffer, 0, sizeof(rcvbuffer)); - Address sender; - for(;;) + // 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() + { + const int port = 30003; + Address address(0,0,0,0, port); + Address address6((IPv6AddressBytes*) NULL, port); + + // IPv6 socket test { - int bytes_read = socket.Receive(sender, rcvbuffer, sizeof(rcvbuffer)); - if(bytes_read < 0) - break; + UDPSocket socket6; + + if (!socket6.init(true, true)) { + /* Note: Failing to create an IPv6 socket is not technically an + error because the OS may not support IPv6 or it may + have been disabled. IPv6 is not /required/ by + minetest and therefore this should not cause the unit + test to fail + */ + dstream << "WARNING: IPv6 socket creation failed (unit test)" + << std::endl; + } else { + const char sendbuffer[] = "hello world!"; + IPv6AddressBytes bytes; + bytes.bytes[15] = 1; + + socket6.Bind(address6); + + try { + socket6.Send(Address(&bytes, port), sendbuffer, sizeof(sendbuffer)); + + sleep_ms(50); + + char rcvbuffer[256] = { 0 }; + Address sender; + + for(;;) { + if (socket6.Receive(sender, rcvbuffer, sizeof(rcvbuffer )) < 0) + break; + } + //FIXME: This fails on some systems + UASSERT(strncmp(sendbuffer, rcvbuffer, sizeof(sendbuffer)) == 0); + UASSERT(memcmp(sender.getAddress6().sin6_addr.s6_addr, + Address(&bytes, 0).getAddress6().sin6_addr.s6_addr, 16) == 0); + } + catch (SendFailedException e) { + errorstream << "IPv6 support enabled but not available!" + << std::endl; + } + } + } + + // IPv4 socket test + { + UDPSocket socket(false); + socket.Bind(address); + + const char sendbuffer[] = "hello world!"; + socket.Send(Address(127, 0, 0 ,1, port), sendbuffer, sizeof(sendbuffer)); + + sleep_ms(50); + + char rcvbuffer[256] = { 0 }; + Address sender; + for(;;) { + if (socket.Receive(sender, rcvbuffer, sizeof(rcvbuffer)) < 0) + break; + } + //FIXME: This fails on some systems + UASSERT(strncmp(sendbuffer, rcvbuffer, sizeof(sendbuffer)) == 0); + UASSERT(sender.getAddress().sin_addr.s_addr == + Address(127, 0, 0, 1, 0).getAddress().sin_addr.s_addr); } - //FIXME: This fails on some systems - assert(strncmp(sendbuffer, rcvbuffer, sizeof(sendbuffer))==0); - assert(sender.getAddress() == Address(127,0,0,1, 0).getAddress()); } }; -struct TestConnection +struct TestConnection: public TestBase { void TestHelpers() { @@ -1117,7 +1756,7 @@ struct TestConnection SharedBuffer data1(1); data1[0] = 100; Address a(127,0,0,1, 10); - u16 seqnum = 34352; + const u16 seqnum = 34352; con::BufferedPacket p1 = con::makePacket(a, data1, proto_id, peer_id, channel); @@ -1130,11 +1769,11 @@ 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]); + //infostream<<"initial data1[0]="<<((u32)data1[0]&0xff)< p2 = con::makeReliablePacket(data1, seqnum); @@ -1145,10 +1784,10 @@ struct TestConnection <<" p2[3]="<<((u32)p2[3]&0xff)<channels[chn]; u16 sn = ch->next_outgoing_seqnum; @@ -1366,10 +2006,10 @@ struct TestConnection <<", size="< data1(datasize); for(u16 i=0; i recvdata; infostream<<"** running client.Receive()"<