X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftest.cpp;h=8a080454b6bf7f447bc66727360c6f3dd8d37b2b;hb=a020d1b653f94fbcaac06c15f9dbab4521fda355;hp=1b9dfcb5dcf0c4c9b6546d090b351a2d8a3fa309;hpb=e71262463f8fd2d9509b5646b4e08cfa09fc2889;p=oweals%2Fminetest.git diff --git a/src/test.cpp b/src/test.cpp index 1b9dfcb5d..8a080454b 100644 --- a/src/test.cpp +++ b/src/test.cpp @@ -1,33 +1,33 @@ /* -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 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" @@ -35,7 +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 @@ -45,26 +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 +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"; @@ -77,15 +94,14 @@ void define_some_nodes(IWritableItemDefManager *idef, IWritableNodeDefManager *n f = ContentFeatures(); f.name = itemdef.name; for(int i = 0; i < 6; i++) - f.tname_tiles[i] = "default_stone.png"; + 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"; @@ -97,39 +113,278 @@ void define_some_nodes(IWritableItemDefManager *idef, IWritableNodeDefManager *n "{default_dirt.png&default_grass_side.png"; f = ContentFeatures(); f.name = itemdef.name; - f.tname_tiles[0] = "default_grass.png"; - f.tname_tiles[1] = "default_dirt.png"; + f.tiledef[0].name = "default_grass.png"; + f.tiledef[1].name = "default_dirt.png"; for(int i = 2; i < 6; i++) - f.tname_tiles[i] = "default_dirt.png^default_grass_side.png"; + 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) + */ + 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); + 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(\"" + <get(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) { @@ -420,33 +715,33 @@ 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); } @@ -464,7 +759,7 @@ struct TestVoxelManipulator v.print(infostream, nodedef); - assert(v.getNode(v3s16(-1,0,-1)).getContent() == CONTENT_GRASS); + UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == CONTENT_GRASS); infostream<<"*** Reading from inexistent (0,0,-1) ***"< 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)); + { + std::set 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); + } + { + std::set 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)); + { + std::set 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); + } + { + std::set 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); + } + { + std::set 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); + } + { + std::set 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); + } + { + std::set 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); + } + { + std::set 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)); + { + std::set 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); + } + } + /* + voxalgo::clearLightAndCollectSources + */ + { + 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); + } + { + 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); + UASSERT(v.getNode(v3s16(0,1,1)).getLight(LIGHTBANK_DAY, ndef) + == 0); + 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: 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"; + + std::string serialized_inventory_2 = + "List main 32\n" + "Width 5\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"; + + Inventory inv(idef); + std::istringstream is(serialized_inventory, std::ios::binary); + inv.deSerialize(is); + UASSERT(inv.getList("0")); + UASSERT(!inv.getList("main")); + inv.getList("0")->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); + } +}; + /* 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 +struct TestMapBlock: public TestBase { class TC : public NodeContainer { @@ -546,33 +1086,33 @@ 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.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 @@ -580,10 +1120,10 @@ 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 @@ -700,11 +1240,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: @@ -740,12 +1280,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 { @@ -791,13 +1331,13 @@ struct TestMapSector // 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 @@ -808,41 +1348,227 @@ 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() { const int port = 30003; - UDPSocket socket; - socket.Bind(port); + Address address(0,0,0,0, port); + Address address6((IPv6AddressBytes*) NULL, port); - const char sendbuffer[] = "hello world!"; - socket.Send(Address(127,0,0,1,port), sendbuffer, sizeof(sendbuffer)); + // IPv6 socket test + { + UDPSocket socket6(true); + socket6.Bind(address6); - sleep_ms(50); + const char sendbuffer[] = "hello world!"; + IPv6AddressBytes bytes; + bytes.bytes[15] = 1; + + try { + socket6.Send(Address(&bytes, port), sendbuffer, sizeof(sendbuffer)); + + sleep_ms(50); + + char rcvbuffer[256]; + memset(rcvbuffer, 0, sizeof(rcvbuffer)); + Address sender; + for(;;) + { + int bytes_read = socket6.Receive(sender, rcvbuffer, sizeof(rcvbuffer)); + if(bytes_read < 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; + } + + } - char rcvbuffer[256]; - memset(rcvbuffer, 0, sizeof(rcvbuffer)); - Address sender; - for(;;) + // IPv4 socket test { - int bytes_read = socket.Receive(sender, rcvbuffer, sizeof(rcvbuffer)); - if(bytes_read < 0) - break; + 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]; + memset(rcvbuffer, 0, sizeof(rcvbuffer)); + Address sender; + for(;;) + { + int bytes_read = socket.Receive(sender, rcvbuffer, sizeof(rcvbuffer)); + if(bytes_read < 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() { @@ -870,10 +1596,10 @@ 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)<