Initial commit

src/unittest/CMakeLists.txt

@@ -0,0 +1,55 @@
+set (UNITTEST_SRCS
+	${CMAKE_CURRENT_SOURCE_DIR}/test.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_address.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_authdatabase.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_activeobject.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_areastore.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_ban.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_collision.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_compression.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_connection.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_filepath.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_inventory.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_irrptr.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_lua.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_map.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_map_settings_manager.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_mapnode.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_modchannels.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_modmetadatadatabase.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_nodedef.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_noderesolver.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_noise.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_objdef.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_profiler.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_random.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_schematic.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_serialization.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_serveractiveobjectmgr.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_server_shutdown_state.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_settings.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_socket.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_servermodmanager.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_threading.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_utilities.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_voxelarea.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_voxelalgorithms.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_voxelmanipulator.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_gettext.cpp
+	PARENT_SCOPE)
+
+set (UNITTEST_CLIENT_SRCS
+	${CMAKE_CURRENT_SOURCE_DIR}/test_clientactiveobjectmgr.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_eventmanager.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_gameui.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/test_keycode.cpp
+	PARENT_SCOPE)
+
+set (TEST_WORLDDIR ${CMAKE_CURRENT_SOURCE_DIR}/test_world)
+set (TEST_SUBGAME_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../games/devtest)
+set (TEST_MOD_PATH ${CMAKE_CURRENT_SOURCE_DIR}/test_mod)
+
+configure_file(
+	"${CMAKE_CURRENT_SOURCE_DIR}/test_config.h.in"
+	"${PROJECT_BINARY_DIR}/test_config.h"
+)

src/unittest/test.cpp

@@ -0,0 +1,678 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "client/sound.h"
+#include "nodedef.h"
+#include "itemdef.h"
+#include "gamedef.h"
+#include "modchannels.h"
+#include "content/mods.h"
+#include "database/database-dummy.h"
+#include "util/numeric.h"
+#include "porting.h"
+
+content_t t_CONTENT_STONE;
+content_t t_CONTENT_GRASS;
+content_t t_CONTENT_TORCH;
+content_t t_CONTENT_WATER;
+content_t t_CONTENT_LAVA;
+content_t t_CONTENT_BRICK;
+
+////////////////////////////////////////////////////////////////////////////////
+
+////
+//// TestGameDef
+////
+
+class TestGameDef : public IGameDef {
+public:
+	TestGameDef();
+	~TestGameDef();
+
+	IItemDefManager *getItemDefManager() { return m_itemdef; }
+	const NodeDefManager *getNodeDefManager() { return m_nodedef; }
+	ICraftDefManager *getCraftDefManager() { return m_craftdef; }
+	ITextureSource *getTextureSource() { return m_texturesrc; }
+	IShaderSource *getShaderSource() { return m_shadersrc; }
+	ISoundManager *getSoundManager() { return m_soundmgr; }
+	scene::ISceneManager *getSceneManager() { return m_scenemgr; }
+	IRollbackManager *getRollbackManager() { return m_rollbackmgr; }
+	EmergeManager *getEmergeManager() { return m_emergemgr; }
+	ModMetadataDatabase *getModStorageDatabase() { return m_mod_storage_database; }
+
+	scene::IAnimatedMesh *getMesh(const std::string &filename) { return NULL; }
+	bool checkLocalPrivilege(const std::string &priv) { return false; }
+	u16 allocateUnknownNodeId(const std::string &name) { return 0; }
+
+	void defineSomeNodes();
+
+	virtual const std::vector<ModSpec> &getMods() const
+	{
+		static std::vector<ModSpec> testmodspec;
+		return testmodspec;
+	}
+	virtual const ModSpec* getModSpec(const std::string &modname) const { return NULL; }
+	virtual bool registerModStorage(ModMetadata *meta) { return true; }
+	virtual void unregisterModStorage(const std::string &name) {}
+	bool joinModChannel(const std::string &channel);
+	bool leaveModChannel(const std::string &channel);
+	bool sendModChannelMessage(const std::string &channel, const std::string &message);
+	ModChannel *getModChannel(const std::string &channel)
+	{
+		return m_modchannel_mgr->getModChannel(channel);
+	}
+
+private:
+	IItemDefManager *m_itemdef = nullptr;
+	const NodeDefManager *m_nodedef = nullptr;
+	ICraftDefManager *m_craftdef = nullptr;
+	ITextureSource *m_texturesrc = nullptr;
+	IShaderSource *m_shadersrc = nullptr;
+	ISoundManager *m_soundmgr = nullptr;
+	scene::ISceneManager *m_scenemgr = nullptr;
+	IRollbackManager *m_rollbackmgr = nullptr;
+	EmergeManager *m_emergemgr = nullptr;
+	ModMetadataDatabase *m_mod_storage_database = nullptr;
+	std::unique_ptr<ModChannelMgr> m_modchannel_mgr;
+};
+
+
+TestGameDef::TestGameDef() :
+	m_mod_storage_database(new Database_Dummy()),
+	m_modchannel_mgr(new ModChannelMgr())
+{
+	m_itemdef = createItemDefManager();
+	m_nodedef = createNodeDefManager();
+
+	defineSomeNodes();
+}
+
+
+TestGameDef::~TestGameDef()
+{
+	delete m_itemdef;
+	delete m_nodedef;
+	delete m_mod_storage_database;
+}
+
+
+void TestGameDef::defineSomeNodes()
+{
+	IWritableItemDefManager *idef = (IWritableItemDefManager *)m_itemdef;
+	NodeDefManager *ndef = (NodeDefManager *)m_nodedef;
+
+	ItemDefinition itemdef;
+	ContentFeatures f;
+
+	//// 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 (TileDef &tiledef : f.tiledef)
+		tiledef.name = "default_stone.png";
+	f.is_ground_content = true;
+	idef->registerItem(itemdef);
+	t_CONTENT_STONE = ndef->set(f.name, f);
+
+	//// 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);
+	t_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);
+	t_CONTENT_TORCH = ndef->set(f.name, f);
+
+	//// Water
+	itemdef = ItemDefinition();
+	itemdef.type = ITEM_NODE;
+	itemdef.name = "default:water";
+	itemdef.description = "Water";
+	itemdef.inventory_image = "[inventorycube"
+		"{default_water.png"
+		"{default_water.png"
+		"{default_water.png";
+	f = ContentFeatures();
+	f.name = itemdef.name;
+	f.alpha = ALPHAMODE_BLEND;
+	f.liquid_type = LIQUID_SOURCE;
+	f.liquid_viscosity = 4;
+	f.is_ground_content = true;
+	f.groups["liquids"] = 3;
+	for (TileDef &tiledef : f.tiledef)
+		tiledef.name = "default_water.png";
+	idef->registerItem(itemdef);
+	t_CONTENT_WATER = ndef->set(f.name, f);
+
+	//// Lava
+	itemdef = ItemDefinition();
+	itemdef.type = ITEM_NODE;
+	itemdef.name = "default:lava";
+	itemdef.description = "Lava";
+	itemdef.inventory_image = "[inventorycube"
+		"{default_lava.png"
+		"{default_lava.png"
+		"{default_lava.png";
+	f = ContentFeatures();
+	f.name = itemdef.name;
+	f.alpha = ALPHAMODE_OPAQUE;
+	f.liquid_type = LIQUID_SOURCE;
+	f.liquid_viscosity = 7;
+	f.light_source = LIGHT_MAX-1;
+	f.is_ground_content = true;
+	f.groups["liquids"] = 3;
+	for (TileDef &tiledef : f.tiledef)
+		tiledef.name = "default_lava.png";
+	idef->registerItem(itemdef);
+	t_CONTENT_LAVA = ndef->set(f.name, f);
+
+
+	//// Brick
+	itemdef = ItemDefinition();
+	itemdef.type = ITEM_NODE;
+	itemdef.name = "default:brick";
+	itemdef.description = "Brick";
+	itemdef.groups["cracky"] = 3;
+	itemdef.inventory_image = "[inventorycube"
+		"{default_brick.png"
+		"{default_brick.png"
+		"{default_brick.png";
+	f = ContentFeatures();
+	f.name = itemdef.name;
+	for (TileDef &tiledef : f.tiledef)
+		tiledef.name = "default_brick.png";
+	f.is_ground_content = true;
+	idef->registerItem(itemdef);
+	t_CONTENT_BRICK = ndef->set(f.name, f);
+}
+
+bool TestGameDef::joinModChannel(const std::string &channel)
+{
+	return m_modchannel_mgr->joinChannel(channel, PEER_ID_SERVER);
+}
+
+bool TestGameDef::leaveModChannel(const std::string &channel)
+{
+	return m_modchannel_mgr->leaveChannel(channel, PEER_ID_SERVER);
+}
+
+bool TestGameDef::sendModChannelMessage(const std::string &channel,
+	const std::string &message)
+{
+	if (!m_modchannel_mgr->channelRegistered(channel))
+		return false;
+
+	return true;
+}
+
+////
+//// run_tests
+////
+
+bool run_tests()
+{
+	u64 t1 = porting::getTimeMs();
+	TestGameDef gamedef;
+
+	g_logger.setLevelSilenced(LL_ERROR, true);
+
+	u32 num_modules_failed     = 0;
+	u32 num_total_tests_failed = 0;
+	u32 num_total_tests_run    = 0;
+	std::vector<TestBase *> &testmods = TestManager::getTestModules();
+	for (size_t i = 0; i != testmods.size(); i++) {
+		if (!testmods[i]->testModule(&gamedef))
+			num_modules_failed++;
+
+		num_total_tests_failed += testmods[i]->num_tests_failed;
+		num_total_tests_run += testmods[i]->num_tests_run;
+	}
+
+	u64 tdiff = porting::getTimeMs() - t1;
+
+	g_logger.setLevelSilenced(LL_ERROR, false);
+
+	const char *overall_status = (num_modules_failed == 0) ? "PASSED" : "FAILED";
+
+	rawstream
+		<< "++++++++++++++++++++++++++++++++++++++++"
+		<< "++++++++++++++++++++++++++++++++++++++++" << std::endl
+		<< "Unit Test Results: " << overall_status << std::endl
+		<< "    " << num_modules_failed << " / " << testmods.size()
+		<< " failed modules (" << num_total_tests_failed << " / "
+		<< num_total_tests_run << " failed individual tests)." << std::endl
+		<< "    Testing took " << tdiff << "ms total." << std::endl
+		<< "++++++++++++++++++++++++++++++++++++++++"
+		<< "++++++++++++++++++++++++++++++++++++++++" << std::endl;
+
+	return num_modules_failed;
+}
+
+////
+//// TestBase
+////
+
+bool TestBase::testModule(IGameDef *gamedef)
+{
+	rawstream << "======== Testing module " << getName() << std::endl;
+	u64 t1 = porting::getTimeMs();
+
+
+	runTests(gamedef);
+
+	u64 tdiff = porting::getTimeMs() - t1;
+	rawstream << "======== Module " << getName() << " "
+		<< (num_tests_failed ? "failed" : "passed") << " (" << num_tests_failed
+		<< " failures / " << num_tests_run << " tests) - " << tdiff
+		<< "ms" << std::endl;
+
+	if (!m_test_dir.empty())
+		fs::RecursiveDelete(m_test_dir);
+
+	return num_tests_failed == 0;
+}
+
+std::string TestBase::getTestTempDirectory()
+{
+	if (!m_test_dir.empty())
+		return m_test_dir;
+
+	char buf[32];
+	porting::mt_snprintf(buf, sizeof(buf), "%08X", myrand());
+
+	m_test_dir = fs::TempPath() + DIR_DELIM "mttest_" + buf;
+	if (!fs::CreateDir(m_test_dir))
+		throw TestFailedException();
+
+	return m_test_dir;
+}
+
+std::string TestBase::getTestTempFile()
+{
+	char buf[32];
+	porting::mt_snprintf(buf, sizeof(buf), "%08X", myrand());
+
+	return getTestTempDirectory() + DIR_DELIM + buf + ".tmp";
+}
+
+
+/*
+	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
+	{
+	public:
+
+		MapNode node;
+		bool position_valid;
+		std::list<v3s16> validity_exceptions;
+
+		TC()
+		{
+			position_valid = true;
+		}
+
+		virtual bool isValidPosition(v3s16 p)
+		{
+			//return position_valid ^ (p==position_valid_exception);
+			bool exception = false;
+			for(std::list<v3s16>::iterator i=validity_exceptions.begin();
+					i != validity_exceptions.end(); i++)
+			{
+				if(p == *i)
+				{
+					exception = true;
+					break;
+				}
+			}
+			return exception ? !position_valid : position_valid;
+		}
+
+		virtual MapNode getNode(v3s16 p)
+		{
+			if(isValidPosition(p) == false)
+				throw InvalidPositionException();
+			return node;
+		}
+
+		virtual void setNode(v3s16 p, MapNode & n)
+		{
+			if(isValidPosition(p) == false)
+				throw InvalidPositionException();
+		};
+
+		virtual u16 nodeContainerId() const
+		{
+			return 666;
+		}
+	};
+
+	void Run()
+	{
+		TC parent;
+
+		MapBlock b(&parent, v3s16(1,1,1));
+		v3s16 relpos(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
+
+		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
+		*/
+		/*UASSERT(b.getSizeNodes() == v3s16(MAP_BLOCKSIZE,
+				MAP_BLOCKSIZE, MAP_BLOCKSIZE));*/
+
+		// Changed flag should be initially set
+		UASSERT(b.getModified() == MOD_STATE_WRITE_NEEDED);
+		b.resetModified();
+		UASSERT(b.getModified() == MOD_STATE_CLEAN);
+
+		// All nodes should have been set to
+		// .d=CONTENT_IGNORE and .getLight() = 0
+		for(u16 z=0; z<MAP_BLOCKSIZE; z++)
+		for(u16 y=0; y<MAP_BLOCKSIZE; y++)
+		for(u16 x=0; x<MAP_BLOCKSIZE; x++)
+		{
+			//UASSERT(b.getNode(v3s16(x,y,z)).getContent() == CONTENT_AIR);
+			UASSERT(b.getNode(v3s16(x,y,z)).getContent() == CONTENT_IGNORE);
+			UASSERT(b.getNode(v3s16(x,y,z)).getLight(LIGHTBANK_DAY) == 0);
+			UASSERT(b.getNode(v3s16(x,y,z)).getLight(LIGHTBANK_NIGHT) == 0);
+		}
+
+		{
+			MapNode n(CONTENT_AIR);
+			for(u16 z=0; z<MAP_BLOCKSIZE; z++)
+			for(u16 y=0; y<MAP_BLOCKSIZE; y++)
+			for(u16 x=0; x<MAP_BLOCKSIZE; x++)
+			{
+				b.setNode(v3s16(x,y,z), n);
+			}
+		}
+
+		/*
+			Parent fetch functions
+		*/
+		parent.position_valid = false;
+		parent.node.setContent(5);
+
+		MapNode n;
+
+		// Positions in the block should still be valid
+		UASSERT(b.isValidPositionParent(v3s16(0,0,0)) == true);
+		UASSERT(b.isValidPositionParent(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1)) == true);
+		n = b.getNodeParent(v3s16(0,MAP_BLOCKSIZE-1,0));
+		UASSERT(n.getContent() == CONTENT_AIR);
+
+		// ...but outside the block they should be invalid
+		UASSERT(b.isValidPositionParent(v3s16(-121,2341,0)) == false);
+		UASSERT(b.isValidPositionParent(v3s16(-1,0,0)) == false);
+		UASSERT(b.isValidPositionParent(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE)) == false);
+
+		{
+			bool exception_thrown = false;
+			try{
+				// This should throw an exception
+				MapNode n = b.getNodeParent(v3s16(0,0,-1));
+			}
+			catch(InvalidPositionException &e)
+			{
+				exception_thrown = true;
+			}
+			UASSERT(exception_thrown);
+		}
+
+		parent.position_valid = true;
+		// Now the positions outside should be valid
+		UASSERT(b.isValidPositionParent(v3s16(-121,2341,0)) == true);
+		UASSERT(b.isValidPositionParent(v3s16(-1,0,0)) == true);
+		UASSERT(b.isValidPositionParent(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE)) == true);
+		n = b.getNodeParent(v3s16(0,0,MAP_BLOCKSIZE));
+		UASSERT(n.getContent() == 5);
+
+		/*
+			Set a node
+		*/
+		v3s16 p(1,2,0);
+		n.setContent(4);
+		b.setNode(p, n);
+		UASSERT(b.getNode(p).getContent() == 4);
+		//TODO: Update to new system
+		/*UASSERT(b.getNodeTile(p) == 4);
+		UASSERT(b.getNodeTile(v3s16(-1,-1,0)) == 5);*/
+
+		/*
+			propagateSunlight()
+		*/
+		// Set lighting of all nodes to 0
+		for(u16 z=0; z<MAP_BLOCKSIZE; z++){
+			for(u16 y=0; y<MAP_BLOCKSIZE; y++){
+				for(u16 x=0; x<MAP_BLOCKSIZE; x++){
+					MapNode n = b.getNode(v3s16(x,y,z));
+					n.setLight(LIGHTBANK_DAY, 0);
+					n.setLight(LIGHTBANK_NIGHT, 0);
+					b.setNode(v3s16(x,y,z), n);
+				}
+			}
+		}
+		{
+			/*
+				Check how the block handles being a lonely sky block
+			*/
+			parent.position_valid = true;
+			b.setIsUnderground(false);
+			parent.node.setContent(CONTENT_AIR);
+			parent.node.setLight(LIGHTBANK_DAY, LIGHT_SUN);
+			parent.node.setLight(LIGHTBANK_NIGHT, 0);
+			std::map<v3s16, bool> light_sources;
+			// The bottom block is invalid, because we have a shadowing node
+			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
+			//UASSERT(b.getFaceLight(p, v3s16(0,0,1)) == diminish_light(diminish_light(LIGHT_MAX)));
+			// The face on the z+ side should have diminished light
+			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
+			while being underground
+		*/
+		{
+			// Make neighbours to exist and set some non-sunlight to them
+			parent.position_valid = true;
+			b.setIsUnderground(true);
+			parent.node.setLight(LIGHTBANK_DAY, LIGHT_MAX/2);
+			std::map<v3s16, bool> light_sources;
+			// The block below should be valid because there shouldn't be
+			// sunlight in there either
+			UASSERT(b.propagateSunlight(light_sources, true) == true);
+			// Should not touch nodes that are not affected (that is, all of them)
+			//UASSERT(b.getNode(v3s16(1,2,3)).getLight() == LIGHT_SUN);
+			// Should set light of non-sunlighted blocks to 0.
+			UASSERT(b.getNode(v3s16(1,2,3)).getLight(LIGHTBANK_DAY) == 0);
+		}
+		/*
+			Set up a situation where:
+			- There is only air in this block
+			- There is a valid non-sunlighted block at the bottom, and
+			- Invalid blocks elsewhere.
+			- the block is not underground.
+
+			This should result in bottom block invalidity
+		*/
+		{
+			b.setIsUnderground(false);
+			// Clear block
+			for(u16 z=0; z<MAP_BLOCKSIZE; z++){
+				for(u16 y=0; y<MAP_BLOCKSIZE; y++){
+					for(u16 x=0; x<MAP_BLOCKSIZE; x++){
+						MapNode n;
+						n.setContent(CONTENT_AIR);
+						n.setLight(LIGHTBANK_DAY, 0);
+						b.setNode(v3s16(x,y,z), n);
+					}
+				}
+			}
+			// Make neighbours invalid
+			parent.position_valid = false;
+			// Add exceptions to the top of the bottom block
+			for(u16 x=0; x<MAP_BLOCKSIZE; x++)
+			for(u16 z=0; z<MAP_BLOCKSIZE; z++)
+			{
+				parent.validity_exceptions.push_back(v3s16(MAP_BLOCKSIZE+x, MAP_BLOCKSIZE-1, MAP_BLOCKSIZE+z));
+			}
+			// Lighting value for the valid nodes
+			parent.node.setLight(LIGHTBANK_DAY, LIGHT_MAX/2);
+			std::map<v3s16, bool> light_sources;
+			// Bottom block is not valid
+			UASSERT(b.propagateSunlight(light_sources) == false);
+		}
+	}
+};
+
+struct TestMapSector: public TestBase
+{
+	class TC : public NodeContainer
+	{
+	public:
+
+		MapNode node;
+		bool position_valid;
+
+		TC()
+		{
+			position_valid = true;
+		}
+
+		virtual bool isValidPosition(v3s16 p)
+		{
+			return position_valid;
+		}
+
+		virtual MapNode getNode(v3s16 p)
+		{
+			if(position_valid == false)
+				throw InvalidPositionException();
+			return node;
+		}
+
+		virtual void setNode(v3s16 p, MapNode & n)
+		{
+			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));
+
+		UASSERT(sector.getBlockNoCreateNoEx(0) == nullptr);
+		UASSERT(sector.getBlockNoCreateNoEx(1) == nullptr);
+
+		MapBlock * bref = sector.createBlankBlock(-2);
+
+		UASSERT(sector.getBlockNoCreateNoEx(0) == nullptr);
+		UASSERT(sector.getBlockNoCreateNoEx(-2) == bref);
+
+		//TODO: Check for AlreadyExistsException
+
+		/*bool exception_thrown = false;
+		try{
+			sector.getBlock(0);
+		}
+		catch(InvalidPositionException &e){
+			exception_thrown = true;
+		}
+		UASSERT(exception_thrown);*/
+
+	}
+};
+#endif

src/unittest/test.h

@@ -0,0 +1,142 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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.
+*/
+
+#pragma once
+
+#include <exception>
+#include <vector>
+
+#include "irrlichttypes_extrabloated.h"
+#include "porting.h"
+#include "filesys.h"
+#include "mapnode.h"
+
+class TestFailedException : public std::exception {
+};
+
+// Runs a unit test and reports results
+#define TEST(fxn, ...) {                                                      \
+	u64 t1 = porting::getTimeMs();                                            \
+	try {                                                                     \
+		fxn(__VA_ARGS__);                                                     \
+		rawstream << "[PASS] ";                                               \
+	} catch (TestFailedException &e) {                                        \
+		rawstream << "[FAIL] ";                                               \
+		num_tests_failed++;                                                   \
+	} catch (std::exception &e) {                                             \
+		rawstream << "Caught unhandled exception: " << e.what() << std::endl; \
+		rawstream << "[FAIL] ";                                               \
+		num_tests_failed++;                                                   \
+	}                                                                         \
+	num_tests_run++;                                                          \
+	u64 tdiff = porting::getTimeMs() - t1;                                    \
+	rawstream << #fxn << " - " << tdiff << "ms" << std::endl;                 \
+}
+
+// Asserts the specified condition is true, or fails the current unit test
+#define UASSERT(x)                                              \
+	if (!(x)) {                                                 \
+		rawstream << "Test assertion failed: " #x << std::endl  \
+			<< "    at " << fs::GetFilenameFromPath(__FILE__)   \
+			<< ":" << __LINE__ << std::endl;                    \
+		throw TestFailedException();                            \
+	}
+
+// Asserts the specified condition is true, or fails the current unit test
+// and prints the format specifier fmt
+#define UTEST(x, fmt, ...)                                               \
+	if (!(x)) {                                                          \
+		char utest_buf[1024];                                            \
+		snprintf(utest_buf, sizeof(utest_buf), fmt, __VA_ARGS__);        \
+		rawstream << "Test assertion failed: " << utest_buf << std::endl \
+			<< "    at " << fs::GetFilenameFromPath(__FILE__)            \
+			<< ":" << __LINE__ << std::endl;                             \
+		throw TestFailedException();                                     \
+	}
+
+// Asserts the comparison specified by CMP is true, or fails the current unit test
+#define UASSERTCMP(T, CMP, actual, expected) {                            \
+	T a = (actual);                                                       \
+	T e = (expected);                                                     \
+	if (!(a CMP e)) {                                                     \
+		rawstream                                                         \
+			<< "Test assertion failed: " << #actual << " " << #CMP << " " \
+			<< #expected << std::endl                                     \
+			<< "    at " << fs::GetFilenameFromPath(__FILE__) << ":"      \
+			<< __LINE__ << std::endl                                      \
+			<< "    actual  : " << a << std::endl << "    expected: "     \
+			<< e << std::endl;                                            \
+		throw TestFailedException();                                      \
+	}                                                                     \
+}
+
+#define UASSERTEQ(T, actual, expected) UASSERTCMP(T, ==, actual, expected)
+
+// UASSERTs that the specified exception occurs
+#define EXCEPTION_CHECK(EType, code) {    \
+	bool exception_thrown = false;        \
+	try {                                 \
+		code;                             \
+	} catch (EType &e) {                  \
+		exception_thrown = true;          \
+	}                                     \
+	UASSERT(exception_thrown);            \
+}
+
+class IGameDef;
+
+class TestBase {
+public:
+	bool testModule(IGameDef *gamedef);
+	std::string getTestTempDirectory();
+	std::string getTestTempFile();
+
+	virtual void runTests(IGameDef *gamedef) = 0;
+	virtual const char *getName() = 0;
+
+	u32 num_tests_failed;
+	u32 num_tests_run;
+
+private:
+	std::string m_test_dir;
+};
+
+class TestManager {
+public:
+	static std::vector<TestBase *> &getTestModules()
+	{
+		static std::vector<TestBase *> m_modules_to_test;
+		return m_modules_to_test;
+	}
+
+	static void registerTestModule(TestBase *module)
+	{
+		getTestModules().push_back(module);
+	}
+};
+
+// A few item and node definitions for those tests that need them
+extern content_t t_CONTENT_STONE;
+extern content_t t_CONTENT_GRASS;
+extern content_t t_CONTENT_TORCH;
+extern content_t t_CONTENT_WATER;
+extern content_t t_CONTENT_LAVA;
+extern content_t t_CONTENT_BRICK;
+
+bool run_tests();

src/unittest/test_activeobject.cpp

@@ -0,0 +1,60 @@
+/*
+Minetest
+Copyright (C) 2018 nerzhul, Loic BLOT <loic.blot@unix-experience.fr>
+
+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
+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 Lesser General Public License for more details.
+
+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 "activeobject.h"
+
+class TestActiveObject : public TestBase
+{
+public:
+	TestActiveObject() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestActiveObject"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testAOAttributes();
+};
+
+static TestActiveObject g_test_instance;
+
+void TestActiveObject::runTests(IGameDef *gamedef)
+{
+	TEST(testAOAttributes);
+}
+
+class TestAO : public ActiveObject
+{
+public:
+	TestAO(u16 id) : ActiveObject(id) {}
+
+	virtual ActiveObjectType getType() const { return ACTIVEOBJECT_TYPE_TEST; }
+	virtual bool getCollisionBox(aabb3f *toset) const { return false; }
+	virtual bool getSelectionBox(aabb3f *toset) const { return false; }
+	virtual bool collideWithObjects() const { return false; }
+};
+
+void TestActiveObject::testAOAttributes()
+{
+	TestAO ao(44);
+	UASSERT(ao.getId() == 44);
+
+	ao.setId(558);
+	UASSERT(ao.getId() == 558);
+}

src/unittest/test_address.cpp

@@ -0,0 +1,67 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "log.h"
+#include "settings.h"
+#include "network/socket.h"
+
+class TestAddress : public TestBase
+{
+public:
+	TestAddress() { TestManager::registerTestModule(this); }
+
+	const char *getName() { return "TestAddress"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testIsLocalhost();
+};
+
+static TestAddress g_test_instance;
+
+void TestAddress::runTests(IGameDef *gamedef)
+{
+	TEST(testIsLocalhost);
+}
+
+void TestAddress::testIsLocalhost()
+{
+	// v4
+	UASSERT(Address(127, 0, 0, 1, 0).isLocalhost());
+	UASSERT(Address(127, 254, 12, 99, 0).isLocalhost());
+	UASSERT(Address(127, 188, 255, 247, 0).isLocalhost());
+	UASSERT(!Address(126, 255, 255, 255, 0).isLocalhost());
+	UASSERT(!Address(128, 0, 0, 0, 0).isLocalhost());
+	UASSERT(!Address(1, 0, 0, 0, 0).isLocalhost());
+	UASSERT(!Address(255, 255, 255, 255, 0).isLocalhost());
+	UASSERT(!Address(36, 45, 99, 158, 0).isLocalhost());
+	UASSERT(!Address(172, 45, 37, 68, 0).isLocalhost());
+
+	// v6
+	auto ipv6Bytes = std::make_unique<IPv6AddressBytes>();
+	std::vector<u8> ipv6RawAddr = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+	memcpy(ipv6Bytes->bytes, &ipv6RawAddr[0], 16);
+	UASSERT(Address(ipv6Bytes.get(), 0).isLocalhost())
+
+	ipv6RawAddr = {16, 34, 0, 0, 0, 0, 29, 0, 0, 0, 188, 0, 0, 0, 0, 14};
+	memcpy(ipv6Bytes->bytes, &ipv6RawAddr[0], 16);
+	UASSERT(!Address(ipv6Bytes.get(), 0).isLocalhost())
+}

src/unittest/test_areastore.cpp

@@ -0,0 +1,173 @@
+/*
+Minetest
+Copyright (C) 2015 est31, <MTest31@outlook.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "util/areastore.h"
+
+class TestAreaStore : public TestBase {
+public:
+	TestAreaStore() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestAreaStore"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void genericStoreTest(AreaStore *store);
+	void testVectorStore();
+	void testSpatialStore();
+	void testSerialization();
+};
+
+static TestAreaStore g_test_instance;
+
+void TestAreaStore::runTests(IGameDef *gamedef)
+{
+	TEST(testVectorStore);
+#if USE_SPATIAL
+	TEST(testSpatialStore);
+#endif
+	TEST(testSerialization);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestAreaStore::testVectorStore()
+{
+	VectorAreaStore store;
+	genericStoreTest(&store);
+}
+
+void TestAreaStore::testSpatialStore()
+{
+#if USE_SPATIAL
+	SpatialAreaStore store;
+	genericStoreTest(&store);
+#endif
+}
+
+void TestAreaStore::genericStoreTest(AreaStore *store)
+{
+	Area a(v3s16(-10, -3, 5), v3s16(0, 29, 7));
+	Area b(v3s16(-5, -2, 5), v3s16(0, 28, 6));
+	Area c(v3s16(-7, -3, 6), v3s16(-1, 27, 7));
+	std::vector<Area *> res;
+
+	UASSERTEQ(size_t, store->size(), 0);
+	store->reserve(2); // sic
+	store->insertArea(&a);
+	store->insertArea(&b);
+	store->insertArea(&c);
+	UASSERTEQ(size_t, store->size(), 3);
+
+	store->getAreasForPos(&res, v3s16(-1, 0, 6));
+	UASSERTEQ(size_t, res.size(), 3);
+	res.clear();
+	store->getAreasForPos(&res, v3s16(0, 0, 7));
+	UASSERTEQ(size_t, res.size(), 1);
+	res.clear();
+
+	store->removeArea(a.id);
+
+	store->getAreasForPos(&res, v3s16(0, 0, 7));
+	UASSERTEQ(size_t, res.size(), 0);
+	res.clear();
+
+	store->insertArea(&a);
+
+	store->getAreasForPos(&res, v3s16(0, 0, 7));
+	UASSERTEQ(size_t, res.size(), 1);
+	res.clear();
+
+	store->getAreasInArea(&res, v3s16(-10, -3, 5), v3s16(0, 29, 7), false);
+	UASSERTEQ(size_t, res.size(), 3);
+	res.clear();
+
+	store->getAreasInArea(&res, v3s16(-100, 0, 6), v3s16(200, 0, 6), false);
+	UASSERTEQ(size_t, res.size(), 0);
+	res.clear();
+
+	store->getAreasInArea(&res, v3s16(-100, 0, 6), v3s16(200, 0, 6), true);
+	UASSERTEQ(size_t, res.size(), 3);
+	res.clear();
+
+	store->removeArea(a.id);
+	store->removeArea(b.id);
+	store->removeArea(c.id);
+
+	Area d(v3s16(-100, -300, -200), v3s16(-50, -200, -100));
+	d.data = "Hi!";
+	store->insertArea(&d);
+
+	store->getAreasForPos(&res, v3s16(-75, -250, -150));
+	UASSERTEQ(size_t, res.size(), 1);
+	UASSERTEQ(u16, res[0]->data.size(), 3);
+	UASSERT(strncmp(res[0]->data.c_str(), "Hi!", 3) == 0);
+	res.clear();
+
+	store->removeArea(d.id);
+}
+
+void TestAreaStore::testSerialization()
+{
+	VectorAreaStore store;
+
+	Area a(v3s16(-1, 0, 1), v3s16(0, 1, 2));
+	a.data = "Area AA";
+	store.insertArea(&a);
+
+	Area b(v3s16(123, 456, 789), v3s16(32000, 100, 10));
+	b.data = "Area BB";
+	store.insertArea(&b);
+
+	std::ostringstream os(std::ios_base::binary);
+	store.serialize(os);
+	std::string str = os.str();
+
+	std::string str_wanted("\x00"  // Version
+			"\x00\x02"  // Count
+			"\xFF\xFF\x00\x00\x00\x01"  // Area A min edge
+			"\x00\x00\x00\x01\x00\x02"  // Area A max edge
+			"\x00\x07"  // Area A data length
+			"Area AA"   // Area A data
+			"\x00\x7B\x00\x64\x00\x0A"  // Area B min edge (last two swapped with max edge for sorting)
+			"\x7D\x00\x01\xC8\x03\x15"  // Area B max edge (^)
+			"\x00\x07"  // Area B data length
+			"Area BB"   // Area B data
+			"\x00\x00\x00\x00"  // ID A = 0
+			"\x00\x00\x00\x01", // ID B = 1
+			1 + 2 +
+			(6 + 6 + 2 + 7) * 2 + // min/max edge, length, data
+			2 * 4); // Area IDs
+
+	UASSERTEQ(const std::string &, str, str_wanted);
+
+	std::istringstream is(str, std::ios_base::binary);
+	store.deserialize(is);
+
+	// deserialize() doesn't clear the store
+	// But existing IDs are overridden
+	UASSERTEQ(size_t, store.size(), 2);
+
+	Area c(v3s16(33, -2, -6), v3s16(4, 77, -76));
+	c.data = "Area CC";
+	store.insertArea(&c);
+
+	UASSERTEQ(u32, c.id, 2);
+}
+

src/unittest/test_authdatabase.cpp

@@ -0,0 +1,296 @@
+/*
+Minetest
+Copyright (C) 2018 bendeutsch, Ben Deutsch <ben@bendeutsch.de>
+
+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
+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 Lesser General Public License for more details.
+
+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 <algorithm>
+#include "database/database-files.h"
+#include "database/database-sqlite3.h"
+#include "util/string.h"
+#include "filesys.h"
+
+namespace
+{
+// Anonymous namespace to create classes that are only
+// visible to this file
+//
+// These are helpers that return a *AuthDatabase and
+// allow us to run the same tests on different databases and
+// database acquisition strategies.
+
+class AuthDatabaseProvider
+{
+public:
+	virtual ~AuthDatabaseProvider() = default;
+	virtual AuthDatabase *getAuthDatabase() = 0;
+};
+
+class FixedProvider : public AuthDatabaseProvider
+{
+public:
+	FixedProvider(AuthDatabase *auth_db) : auth_db(auth_db){};
+	virtual ~FixedProvider(){};
+	virtual AuthDatabase *getAuthDatabase() { return auth_db; };
+
+private:
+	AuthDatabase *auth_db;
+};
+
+class FilesProvider : public AuthDatabaseProvider
+{
+public:
+	FilesProvider(const std::string &dir) : dir(dir){};
+	virtual ~FilesProvider() { delete auth_db; };
+	virtual AuthDatabase *getAuthDatabase()
+	{
+		delete auth_db;
+		auth_db = new AuthDatabaseFiles(dir);
+		return auth_db;
+	};
+
+private:
+	std::string dir;
+	AuthDatabase *auth_db = nullptr;
+};
+
+class SQLite3Provider : public AuthDatabaseProvider
+{
+public:
+	SQLite3Provider(const std::string &dir) : dir(dir){};
+	virtual ~SQLite3Provider() { delete auth_db; };
+	virtual AuthDatabase *getAuthDatabase()
+	{
+		delete auth_db;
+		auth_db = new AuthDatabaseSQLite3(dir);
+		return auth_db;
+	};
+
+private:
+	std::string dir;
+	AuthDatabase *auth_db = nullptr;
+};
+}
+
+class TestAuthDatabase : public TestBase
+{
+public:
+	TestAuthDatabase() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestAuthDatabase"; }
+
+	void runTests(IGameDef *gamedef);
+	void runTestsForCurrentDB();
+
+	void testRecallFail();
+	void testCreate();
+	void testRecall();
+	void testChange();
+	void testRecallChanged();
+	void testChangePrivileges();
+	void testRecallChangedPrivileges();
+	void testListNames();
+	void testDelete();
+
+private:
+	AuthDatabaseProvider *auth_provider;
+};
+
+static TestAuthDatabase g_test_instance;
+
+void TestAuthDatabase::runTests(IGameDef *gamedef)
+{
+	// fixed directory, for persistence
+	thread_local const std::string test_dir = getTestTempDirectory();
+
+	// Each set of tests is run twice for each database type:
+	// one where we reuse the same AuthDatabase object (to test local caching),
+	// and one where we create a new AuthDatabase object for each call
+	// (to test actual persistence).
+
+	rawstream << "-------- Files database (same object)" << std::endl;
+
+	AuthDatabase *auth_db = new AuthDatabaseFiles(test_dir);
+	auth_provider = new FixedProvider(auth_db);
+
+	runTestsForCurrentDB();
+
+	delete auth_db;
+	delete auth_provider;
+
+	// reset database
+	fs::DeleteSingleFileOrEmptyDirectory(test_dir + DIR_DELIM + "auth.txt");
+
+	rawstream << "-------- Files database (new objects)" << std::endl;
+
+	auth_provider = new FilesProvider(test_dir);
+
+	runTestsForCurrentDB();
+
+	delete auth_provider;
+
+	rawstream << "-------- SQLite3 database (same object)" << std::endl;
+
+	auth_db = new AuthDatabaseSQLite3(test_dir);
+	auth_provider = new FixedProvider(auth_db);
+
+	runTestsForCurrentDB();
+
+	delete auth_db;
+	delete auth_provider;
+
+	// reset database
+	fs::DeleteSingleFileOrEmptyDirectory(test_dir + DIR_DELIM + "auth.sqlite");
+
+	rawstream << "-------- SQLite3 database (new objects)" << std::endl;
+
+	auth_provider = new SQLite3Provider(test_dir);
+
+	runTestsForCurrentDB();
+
+	delete auth_provider;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestAuthDatabase::runTestsForCurrentDB()
+{
+	TEST(testRecallFail);
+	TEST(testCreate);
+	TEST(testRecall);
+	TEST(testChange);
+	TEST(testRecallChanged);
+	TEST(testChangePrivileges);
+	TEST(testRecallChangedPrivileges);
+	TEST(testListNames);
+	TEST(testDelete);
+	TEST(testRecallFail);
+}
+
+void TestAuthDatabase::testRecallFail()
+{
+	AuthDatabase *auth_db = auth_provider->getAuthDatabase();
+	AuthEntry authEntry;
+
+	// no such user yet
+	UASSERT(!auth_db->getAuth("TestName", authEntry));
+}
+
+void TestAuthDatabase::testCreate()
+{
+	AuthDatabase *auth_db = auth_provider->getAuthDatabase();
+	AuthEntry authEntry;
+
+	authEntry.name = "TestName";
+	authEntry.password = "TestPassword";
+	authEntry.privileges.emplace_back("shout");
+	authEntry.privileges.emplace_back("interact");
+	authEntry.last_login = 1000;
+	UASSERT(auth_db->createAuth(authEntry));
+}
+
+void TestAuthDatabase::testRecall()
+{
+	AuthDatabase *auth_db = auth_provider->getAuthDatabase();
+	AuthEntry authEntry;
+
+	UASSERT(auth_db->getAuth("TestName", authEntry));
+	UASSERTEQ(std::string, authEntry.name, "TestName");
+	UASSERTEQ(std::string, authEntry.password, "TestPassword");
+	// the order of privileges is unimportant
+	std::sort(authEntry.privileges.begin(), authEntry.privileges.end());
+	UASSERTEQ(std::string, str_join(authEntry.privileges, ","), "interact,shout");
+}
+
+void TestAuthDatabase::testChange()
+{
+	AuthDatabase *auth_db = auth_provider->getAuthDatabase();
+	AuthEntry authEntry;
+
+	UASSERT(auth_db->getAuth("TestName", authEntry));
+	authEntry.password = "NewPassword";
+	authEntry.last_login = 1002;
+	UASSERT(auth_db->saveAuth(authEntry));
+}
+
+void TestAuthDatabase::testRecallChanged()
+{
+	AuthDatabase *auth_db = auth_provider->getAuthDatabase();
+	AuthEntry authEntry;
+
+	UASSERT(auth_db->getAuth("TestName", authEntry));
+	UASSERTEQ(std::string, authEntry.password, "NewPassword");
+	// the order of privileges is unimportant
+	std::sort(authEntry.privileges.begin(), authEntry.privileges.end());
+	UASSERTEQ(std::string, str_join(authEntry.privileges, ","), "interact,shout");
+	UASSERTEQ(u64, authEntry.last_login, 1002);
+}
+
+void TestAuthDatabase::testChangePrivileges()
+{
+	AuthDatabase *auth_db = auth_provider->getAuthDatabase();
+	AuthEntry authEntry;
+
+	UASSERT(auth_db->getAuth("TestName", authEntry));
+	authEntry.privileges.clear();
+	authEntry.privileges.emplace_back("interact");
+	authEntry.privileges.emplace_back("fly");
+	authEntry.privileges.emplace_back("dig");
+	UASSERT(auth_db->saveAuth(authEntry));
+}
+
+void TestAuthDatabase::testRecallChangedPrivileges()
+{
+	AuthDatabase *auth_db = auth_provider->getAuthDatabase();
+	AuthEntry authEntry;
+
+	UASSERT(auth_db->getAuth("TestName", authEntry));
+	// the order of privileges is unimportant
+	std::sort(authEntry.privileges.begin(), authEntry.privileges.end());
+	UASSERTEQ(std::string, str_join(authEntry.privileges, ","), "dig,fly,interact");
+}
+
+void TestAuthDatabase::testListNames()
+{
+
+	AuthDatabase *auth_db = auth_provider->getAuthDatabase();
+	std::vector<std::string> list;
+
+	AuthEntry authEntry;
+
+	authEntry.name = "SecondName";
+	authEntry.password = "SecondPassword";
+	authEntry.privileges.emplace_back("shout");
+	authEntry.privileges.emplace_back("interact");
+	authEntry.last_login = 1003;
+	auth_db->createAuth(authEntry);
+
+	auth_db->listNames(list);
+	// not necessarily sorted, so sort before comparing
+	std::sort(list.begin(), list.end());
+	UASSERTEQ(std::string, str_join(list, ","), "SecondName,TestName");
+}
+
+void TestAuthDatabase::testDelete()
+{
+	AuthDatabase *auth_db = auth_provider->getAuthDatabase();
+
+	UASSERT(!auth_db->deleteAuth("NoSuchName"));
+	UASSERT(auth_db->deleteAuth("TestName"));
+	// second try, expect failure
+	UASSERT(!auth_db->deleteAuth("TestName"));
+}

src/unittest/test_ban.cpp

@@ -0,0 +1,170 @@
+/*
+Minetest
+Copyright (C) 2018 nerzhul, Loic BLOT <loic.blot@unix-experience.fr>
+
+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
+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 Lesser General Public License for more details.
+
+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 "ban.h"
+
+class TestBan : public TestBase
+{
+public:
+	TestBan() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestBan"; }
+
+	void runTests(IGameDef *gamedef);
+
+private:
+	void testCreate();
+	void testAdd();
+	void testRemove();
+	void testModificationFlag();
+	void testGetBanName();
+	void testGetBanDescription();
+
+	void reinitTestEnv();
+};
+
+static TestBan g_test_instance;
+
+void TestBan::runTests(IGameDef *gamedef)
+{
+	reinitTestEnv();
+	TEST(testCreate);
+
+	reinitTestEnv();
+	TEST(testAdd);
+
+	reinitTestEnv();
+	TEST(testRemove);
+
+	reinitTestEnv();
+	TEST(testModificationFlag);
+
+	reinitTestEnv();
+	TEST(testGetBanName);
+
+	reinitTestEnv();
+	TEST(testGetBanDescription);
+
+	// Delete leftover files
+	reinitTestEnv();
+}
+
+// This module is stateful due to disk writes, add helper to remove files
+void TestBan::reinitTestEnv()
+{
+	fs::DeleteSingleFileOrEmptyDirectory("testbm.txt");
+	fs::DeleteSingleFileOrEmptyDirectory("testbm2.txt");
+}
+
+void TestBan::testCreate()
+{
+	// test save on object removal
+	{
+		BanManager bm("testbm.txt");
+	}
+
+	UASSERT(std::ifstream("testbm.txt", std::ios::binary).is_open());
+
+	// test manual save
+	{
+		BanManager bm("testbm2.txt");
+		bm.save();
+		UASSERT(std::ifstream("testbm2.txt", std::ios::binary).is_open());
+	}
+}
+
+void TestBan::testAdd()
+{
+	std::string bm_test1_entry = "192.168.0.246";
+	std::string bm_test1_result = "test_username";
+
+	BanManager bm("testbm.txt");
+	bm.add(bm_test1_entry, bm_test1_result);
+
+	UASSERT(bm.getBanName(bm_test1_entry) == bm_test1_result);
+}
+
+void TestBan::testRemove()
+{
+	std::string bm_test1_entry = "192.168.0.249";
+	std::string bm_test1_result = "test_username";
+
+	std::string bm_test2_entry = "192.168.0.250";
+	std::string bm_test2_result = "test_username7";
+
+	BanManager bm("testbm.txt");
+
+	// init data
+	bm.add(bm_test1_entry, bm_test1_result);
+	bm.add(bm_test2_entry, bm_test2_result);
+
+	// the test
+	bm.remove(bm_test1_entry);
+	UASSERT(bm.getBanName(bm_test1_entry).empty());
+
+	bm.remove(bm_test2_result);
+	UASSERT(bm.getBanName(bm_test2_result).empty());
+}
+
+void TestBan::testModificationFlag()
+{
+	BanManager bm("testbm.txt");
+	bm.add("192.168.0.247", "test_username");
+	UASSERT(bm.isModified());
+
+	bm.remove("192.168.0.247");
+	UASSERT(bm.isModified());
+
+	// Clear the modification flag
+	bm.save();
+
+	// Test modification flag is entry was not present
+	bm.remove("test_username");
+	UASSERT(!bm.isModified());
+}
+
+void TestBan::testGetBanName()
+{
+	std::string bm_test1_entry = "192.168.0.247";
+	std::string bm_test1_result = "test_username";
+
+	BanManager bm("testbm.txt");
+	bm.add(bm_test1_entry, bm_test1_result);
+
+	// Test with valid entry
+	UASSERT(bm.getBanName(bm_test1_entry) == bm_test1_result);
+
+	// Test with invalid entry
+	UASSERT(bm.getBanName("---invalid---").empty());
+}
+
+void TestBan::testGetBanDescription()
+{
+	std::string bm_test1_entry = "192.168.0.247";
+	std::string bm_test1_entry2 = "test_username";
+
+	std::string bm_test1_result = "192.168.0.247|test_username";
+
+	BanManager bm("testbm.txt");
+	bm.add(bm_test1_entry, bm_test1_entry2);
+
+	UASSERT(bm.getBanDescription(bm_test1_entry) == bm_test1_result);
+	UASSERT(bm.getBanDescription(bm_test1_entry2) == bm_test1_result);
+}

src/unittest/test_clientactiveobjectmgr.cpp

@@ -0,0 +1,118 @@
+/*
+Minetest
+Copyright (C) 2018 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
+
+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
+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 Lesser General Public License for more details.
+
+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 "client/activeobjectmgr.h"
+#include <algorithm>
+#include "test.h"
+
+#include "profiler.h"
+
+class TestClientActiveObject : public ClientActiveObject
+{
+public:
+	TestClientActiveObject() : ClientActiveObject(0, nullptr, nullptr) {}
+	~TestClientActiveObject() = default;
+	ActiveObjectType getType() const { return ACTIVEOBJECT_TYPE_TEST; }
+	virtual void addToScene(ITextureSource *tsrc, scene::ISceneManager *smgr) {}
+};
+
+class TestClientActiveObjectMgr : public TestBase
+{
+public:
+	TestClientActiveObjectMgr() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestClientActiveObjectMgr"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testFreeID();
+	void testRegisterObject();
+	void testRemoveObject();
+};
+
+static TestClientActiveObjectMgr g_test_instance;
+
+void TestClientActiveObjectMgr::runTests(IGameDef *gamedef)
+{
+	TEST(testFreeID);
+	TEST(testRegisterObject)
+	TEST(testRemoveObject)
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestClientActiveObjectMgr::testFreeID()
+{
+	client::ActiveObjectMgr caomgr;
+	std::vector<u16> aoids;
+
+	u16 aoid = caomgr.getFreeId();
+	// Ensure it's not the same id
+	UASSERT(caomgr.getFreeId() != aoid);
+
+	aoids.push_back(aoid);
+
+	// Register basic objects, ensure we never found
+	for (u8 i = 0; i < UINT8_MAX; i++) {
+		// Register an object
+		auto tcao = new TestClientActiveObject();
+		caomgr.registerObject(tcao);
+		aoids.push_back(tcao->getId());
+
+		// Ensure next id is not in registered list
+		UASSERT(std::find(aoids.begin(), aoids.end(), caomgr.getFreeId()) ==
+				aoids.end());
+	}
+
+	caomgr.clear();
+}
+
+void TestClientActiveObjectMgr::testRegisterObject()
+{
+	client::ActiveObjectMgr caomgr;
+	auto tcao = new TestClientActiveObject();
+	UASSERT(caomgr.registerObject(tcao));
+
+	u16 id = tcao->getId();
+
+	auto tcaoToCompare = caomgr.getActiveObject(id);
+	UASSERT(tcaoToCompare->getId() == id);
+	UASSERT(tcaoToCompare == tcao);
+
+	tcao = new TestClientActiveObject();
+	UASSERT(caomgr.registerObject(tcao));
+	UASSERT(caomgr.getActiveObject(tcao->getId()) == tcao);
+	UASSERT(caomgr.getActiveObject(tcao->getId()) != tcaoToCompare);
+
+	caomgr.clear();
+}
+
+void TestClientActiveObjectMgr::testRemoveObject()
+{
+	client::ActiveObjectMgr caomgr;
+	auto tcao = new TestClientActiveObject();
+	UASSERT(caomgr.registerObject(tcao));
+
+	u16 id = tcao->getId();
+	UASSERT(caomgr.getActiveObject(id) != nullptr)
+
+	caomgr.removeObject(tcao->getId());
+	UASSERT(caomgr.getActiveObject(id) == nullptr)
+
+	caomgr.clear();
+}

src/unittest/test_collision.cpp

@@ -0,0 +1,180 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "collision.h"
+
+class TestCollision : public TestBase {
+public:
+	TestCollision() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestCollision"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testAxisAlignedCollision();
+};
+
+static TestCollision g_test_instance;
+
+void TestCollision::runTests(IGameDef *gamedef)
+{
+	TEST(testAxisAlignedCollision);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestCollision::testAxisAlignedCollision()
+{
+	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 = 1.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 1.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 1.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 3.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 3.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 1.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 1.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 1.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 2.5f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 2.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 1.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 1.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 1.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 17.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 17.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &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 = 17.0f;
+			UASSERT(axisAlignedCollision(s, m, v, &dtime) == 2);
+			UASSERT(fabs(dtime - 16.1) < 0.001);
+		}
+	}
+}

src/unittest/test_compression.cpp

@@ -0,0 +1,273 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 <sstream>
+
+#include "irrlichttypes_extrabloated.h"
+#include "log.h"
+#include "serialization.h"
+#include "nodedef.h"
+#include "noise.h"
+
+class TestCompression : public TestBase {
+public:
+	TestCompression() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestCompression"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testRLECompression();
+	void testZlibCompression();
+	void testZlibLargeData();
+	void testZstdLargeData();
+	void testZlibLimit();
+	void _testZlibLimit(u32 size, u32 limit);
+};
+
+static TestCompression g_test_instance;
+
+void TestCompression::runTests(IGameDef *gamedef)
+{
+	TEST(testRLECompression);
+	TEST(testZlibCompression);
+	TEST(testZlibLargeData);
+	TEST(testZstdLargeData);
+	TEST(testZlibLimit);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestCompression::testRLECompression()
+{
+	SharedBuffer<u8> fromdata(4);
+	fromdata[0]=1;
+	fromdata[1]=5;
+	fromdata[2]=5;
+	fromdata[3]=1;
+
+	std::ostringstream os(std::ios_base::binary);
+	compress(fromdata, os, 0);
+
+	std::string str_out = os.str();
+
+	infostream << "str_out.size()="<<str_out.size()<<std::endl;
+	infostream << "TestCompress: 1,5,5,1 -> ";
+	for (char i : str_out)
+		infostream << (u32) i << ",";
+	infostream << std::endl;
+
+	UASSERT(str_out.size() == 10);
+
+	UASSERT(str_out[0] == 0);
+	UASSERT(str_out[1] == 0);
+	UASSERT(str_out[2] == 0);
+	UASSERT(str_out[3] == 4);
+	UASSERT(str_out[4] == 0);
+	UASSERT(str_out[5] == 1);
+	UASSERT(str_out[6] == 1);
+	UASSERT(str_out[7] == 5);
+	UASSERT(str_out[8] == 0);
+	UASSERT(str_out[9] == 1);
+
+	std::istringstream is(str_out, std::ios_base::binary);
+	std::ostringstream os2(std::ios_base::binary);
+
+	decompress(is, os2, 0);
+	std::string str_out2 = os2.str();
+
+	infostream << "decompress: ";
+	for (char i : str_out2)
+		infostream << (u32) i << ",";
+	infostream << std::endl;
+
+	UASSERTEQ(size_t, str_out2.size(), fromdata.getSize());
+
+	for (u32 i = 0; i < str_out2.size(); i++)
+		UASSERT(str_out2[i] == fromdata[i]);
+}
+
+void TestCompression::testZlibCompression()
+{
+	SharedBuffer<u8> fromdata(4);
+	fromdata[0]=1;
+	fromdata[1]=5;
+	fromdata[2]=5;
+	fromdata[3]=1;
+
+	std::ostringstream os(std::ios_base::binary);
+	compressZlib(*fromdata, fromdata.getSize(), os);
+
+	std::string str_out = os.str();
+
+	infostream << "str_out.size()=" << str_out.size() <<std::endl;
+	infostream << "TestCompress: 1,5,5,1 -> ";
+	for (char i : str_out)
+		infostream << (u32) i << ",";
+	infostream << std::endl;
+
+	std::istringstream is(str_out, std::ios_base::binary);
+	std::ostringstream os2(std::ios_base::binary);
+
+	decompressZlib(is, os2);
+	std::string str_out2 = os2.str();
+
+	infostream << "decompress: ";
+	for (char i : str_out2)
+		infostream << (u32) i << ",";
+	infostream << std::endl;
+
+	UASSERTEQ(size_t, str_out2.size(), fromdata.getSize());
+
+	for (u32 i = 0; i < str_out2.size(); i++)
+		UASSERT(str_out2[i] == fromdata[i]);
+}
+
+void TestCompression::testZlibLargeData()
+{
+	infostream << "Test: Testing zlib wrappers with a large amount "
+		"of pseudorandom data" << std::endl;
+
+	u32 size = 50000;
+	infostream << "Test: Input size of large compressZlib is "
+		<< size << std::endl;
+
+	std::string data_in;
+	data_in.resize(size);
+	PseudoRandom pseudorandom(9420);
+	for (u32 i = 0; i < size; i++)
+		data_in[i] = pseudorandom.range(0, 255);
+
+	std::ostringstream os_compressed(std::ios::binary);
+	compressZlib(data_in, os_compressed);
+	infostream << "Test: Output size of large compressZlib is "
+		<< os_compressed.str().size()<<std::endl;
+
+	std::istringstream is_compressed(os_compressed.str(), std::ios::binary);
+	std::ostringstream os_decompressed(std::ios::binary);
+	decompressZlib(is_compressed, os_decompressed);
+	infostream << "Test: Output size of large decompressZlib is "
+		<< os_decompressed.str().size() << std::endl;
+
+	std::string str_decompressed = os_decompressed.str();
+	UASSERTEQ(size_t, str_decompressed.size(), data_in.size());
+
+	for (u32 i = 0; i < size && i < str_decompressed.size(); i++) {
+		UTEST(str_decompressed[i] == data_in[i],
+				"index out[%i]=%i differs from in[%i]=%i",
+				i, str_decompressed[i], i, data_in[i]);
+	}
+}
+
+void TestCompression::testZstdLargeData()
+{
+	infostream << "Test: Testing zstd wrappers with a large amount "
+		"of pseudorandom data" << std::endl;
+
+	u32 size = 500000;
+	infostream << "Test: Input size of large compressZstd is "
+		<< size << std::endl;
+
+	std::string data_in;
+	data_in.resize(size);
+	PseudoRandom pseudorandom(9420);
+	for (u32 i = 0; i < size; i++)
+		data_in[i] = pseudorandom.range(0, 255);
+
+	std::ostringstream os_compressed(std::ios::binary);
+	compressZstd(data_in, os_compressed, 0);
+	infostream << "Test: Output size of large compressZstd is "
+		<< os_compressed.str().size()<<std::endl;
+
+	std::istringstream is_compressed(os_compressed.str(), std::ios::binary);
+	std::ostringstream os_decompressed(std::ios::binary);
+	decompressZstd(is_compressed, os_decompressed);
+	infostream << "Test: Output size of large decompressZstd is "
+		<< os_decompressed.str().size() << std::endl;
+
+	std::string str_decompressed = os_decompressed.str();
+	UASSERTEQ(size_t, str_decompressed.size(), data_in.size());
+
+	for (u32 i = 0; i < size && i < str_decompressed.size(); i++) {
+		UTEST(str_decompressed[i] == data_in[i],
+				"index out[%i]=%i differs from in[%i]=%i",
+				i, str_decompressed[i], i, data_in[i]);
+	}
+}
+
+void TestCompression::testZlibLimit()
+{
+	// edge cases
+	_testZlibLimit(1024, 1023);
+	_testZlibLimit(1024, 1024);
+	_testZlibLimit(1024, 1025);
+
+	// test around buffer borders
+	u32 bufsize = 16384; // as in implementation
+	for (int s = -1; s <= 1; s++)
+	{
+		for (int l = -1; l <= 1; l++)
+		{
+			_testZlibLimit(bufsize + s, bufsize + l);
+		}
+	}
+	// span multiple buffers
+	_testZlibLimit(35000, 22000);
+	_testZlibLimit(22000, 35000);
+}
+
+void TestCompression::_testZlibLimit(u32 size, u32 limit)
+{
+	infostream << "Test: Testing zlib wrappers with a decompression "
+		"memory limit of " << limit << std::endl;
+
+	infostream << "Test: Input size of compressZlib for limit is "
+		<< size << std::endl;
+
+	// how much data we expect to get
+	u32 expected = size < limit ? size : limit;
+
+	// create recognizable data
+	std::string data_in;
+	data_in.resize(size);
+	for (u32 i = 0; i < size; i++)
+		data_in[i] = (u8)(i % 256);
+
+	std::ostringstream os_compressed(std::ios::binary);
+	compressZlib(data_in, os_compressed);
+	infostream << "Test: Output size of compressZlib for limit is "
+		<< os_compressed.str().size()<<std::endl;
+
+	std::istringstream is_compressed(os_compressed.str(), std::ios::binary);
+	std::ostringstream os_decompressed(std::ios::binary);
+	decompressZlib(is_compressed, os_decompressed, limit);
+	infostream << "Test: Output size of decompressZlib with limit is "
+		<< os_decompressed.str().size() << std::endl;
+
+	std::string str_decompressed = os_decompressed.str();
+	UASSERTEQ(size_t, str_decompressed.size(), expected);
+
+	for (u32 i = 0; i < size && i < str_decompressed.size(); i++) {
+		UTEST(str_decompressed[i] == data_in[i],
+				"index out[%i]=%i differs from in[%i]=%i",
+				i, str_decompressed[i], i, data_in[i]);
+	}
+}
+

src/unittest/test_config.h.in

@@ -0,0 +1,7 @@
+// Filled in by the build system
+
+#pragma once
+
+#define TEST_WORLDDIR "@TEST_WORLDDIR@"
+#define TEST_SUBGAME_PATH "@TEST_SUBGAME_PATH@"
+#define TEST_MOD_PATH "@TEST_MOD_PATH@"

src/unittest/test_connection.cpp

@@ -0,0 +1,378 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "log.h"
+#include "porting.h"
+#include "settings.h"
+#include "util/serialize.h"
+#include "network/connection.h"
+#include "network/networkpacket.h"
+#include "network/socket.h"
+
+class TestConnection : public TestBase {
+public:
+	TestConnection()
+	{
+		if (INTERNET_SIMULATOR == false)
+			TestManager::registerTestModule(this);
+	}
+
+	const char *getName() { return "TestConnection"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testNetworkPacketSerialize();
+	void testHelpers();
+	void testConnectSendReceive();
+};
+
+static TestConnection g_test_instance;
+
+void TestConnection::runTests(IGameDef *gamedef)
+{
+	TEST(testNetworkPacketSerialize);
+	TEST(testHelpers);
+	TEST(testConnectSendReceive);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct Handler : public con::PeerHandler
+{
+	Handler(const char *a_name) : name(a_name) {}
+
+	void peerAdded(con::Peer *peer)
+	{
+		infostream << "Handler(" << name << ")::peerAdded(): "
+			"id=" << peer->id << std::endl;
+		last_id = peer->id;
+		count++;
+	}
+
+	void deletingPeer(con::Peer *peer, bool timeout)
+	{
+		infostream << "Handler(" << name << ")::deletingPeer(): "
+			"id=" << peer->id << ", timeout=" << timeout << std::endl;
+		last_id = peer->id;
+		count--;
+	}
+
+	s32 count = 0;
+	u16 last_id = 0;
+	const char *name;
+};
+
+void TestConnection::testNetworkPacketSerialize()
+{
+	const static u8 expected[] = {
+		0x00, 0x7b,
+		0x00, 0x02, 0xd8, 0x42, 0xdf, 0x9a
+	};
+
+	if (sizeof(wchar_t) == 2)
+		warningstream << __FUNCTION__ << " may fail on this platform." << std::endl;
+
+	{
+		NetworkPacket pkt(123, 0);
+
+		// serializing wide strings should do surrogate encoding, we test that here
+		pkt << std::wstring(L"\U00020b9a");
+
+		auto buf = pkt.oldForgePacket();
+		UASSERTEQ(int, buf.getSize(), sizeof(expected));
+		UASSERT(!memcmp(expected, &buf[0], buf.getSize()));
+	}
+
+	{
+		NetworkPacket pkt;
+		pkt.putRawPacket(expected, sizeof(expected), 0);
+
+		// same for decoding
+		std::wstring pkt_s;
+		pkt >> pkt_s;
+
+		UASSERT(pkt_s == L"\U00020b9a");
+	}
+}
+
+void TestConnection::testHelpers()
+{
+	// Some constants for testing
+	u32 proto_id = 0x12345678;
+	session_t peer_id = 123;
+	u8 channel = 2;
+	SharedBuffer<u8> data1(1);
+	data1[0] = 100;
+	Address a(127,0,0,1, 10);
+	const u16 seqnum = 34352;
+
+	con::BufferedPacketPtr p1 = con::makePacket(a, data1,
+			proto_id, peer_id, channel);
+	/*
+		We should now have a packet with this data:
+		Header:
+			[0] u32 protocol_id
+			[4] session_t sender_peer_id
+			[6] u8 channel
+		Data:
+			[7] u8 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)<<std::endl;
+
+	SharedBuffer<u8> p2 = con::makeReliablePacket(data1, seqnum);
+
+	/*infostream<<"p2.getSize()="<<p2.getSize()<<", data1.getSize()="
+			<<data1.getSize()<<std::endl;
+	infostream<<"readU8(&p2[3])="<<readU8(&p2[3])
+			<<" p2[3]="<<((u32)p2[3]&0xff)<<std::endl;
+	infostream<<"data1[0]="<<((u32)data1[0]&0xff)<<std::endl;*/
+
+	UASSERT(p2.getSize() == 3 + data1.getSize());
+	UASSERT(readU8(&p2[0]) == con::PACKET_TYPE_RELIABLE);
+	UASSERT(readU16(&p2[1]) == seqnum);
+	UASSERT(readU8(&p2[3]) == data1[0]);
+}
+
+
+void TestConnection::testConnectSendReceive()
+{
+	/*
+		Test some real connections
+
+		NOTE: This mostly tests the legacy interface.
+	*/
+
+	u32 proto_id = 0xad26846a;
+
+	Handler hand_server("server");
+	Handler hand_client("client");
+
+	Address address(0, 0, 0, 0, 30001);
+	Address bind_addr(0, 0, 0, 0, 30001);
+	/*
+	 * Try to use the bind_address for servers with no localhost address
+	 * For example: FreeBSD jails
+	 */
+	std::string bind_str = g_settings->get("bind_address");
+	try {
+		bind_addr.Resolve(bind_str.c_str());
+
+		if (!bind_addr.isIPv6()) {
+			address = bind_addr;
+		}
+	} catch (ResolveError &e) {
+	}
+
+	infostream << "** Creating server Connection" << std::endl;
+	con::Connection server(proto_id, 512, 5.0, false, &hand_server);
+	server.Serve(address);
+
+	infostream << "** Creating client Connection" << std::endl;
+	con::Connection client(proto_id, 512, 5.0, false, &hand_client);
+
+	UASSERT(hand_server.count == 0);
+	UASSERT(hand_client.count == 0);
+
+	sleep_ms(50);
+
+	Address server_address(127, 0, 0, 1, 30001);
+	if (address != Address(0, 0, 0, 0, 30001)) {
+		server_address = bind_addr;
+	}
+
+	infostream << "** running client.Connect()" << std::endl;
+	client.Connect(server_address);
+
+	sleep_ms(50);
+
+	// Client should not have added client yet
+	UASSERT(hand_client.count == 0);
+
+	try {
+		NetworkPacket pkt;
+		infostream << "** running client.Receive()" << std::endl;
+		client.Receive(&pkt);
+		infostream << "** Client received: peer_id=" << pkt.getPeerId()
+			<< ", size=" << pkt.getSize() << std::endl;
+	} catch (con::NoIncomingDataException &e) {
+	}
+
+	// Client should have added server now
+	UASSERT(hand_client.count == 1);
+	UASSERT(hand_client.last_id == 1);
+	// Server should not have added client yet
+	UASSERT(hand_server.count == 0);
+
+	sleep_ms(100);
+
+	try {
+		NetworkPacket pkt;
+		infostream << "** running server.Receive()" << std::endl;
+		server.Receive(&pkt);
+		infostream << "** Server received: peer_id=" << pkt.getPeerId()
+				<< ", size=" << pkt.getSize()
+				<< std::endl;
+	} catch (con::NoIncomingDataException &e) {
+		// No actual data received, but the client has
+		// probably been connected
+	}
+
+	// Client should be the same
+	UASSERT(hand_client.count == 1);
+	UASSERT(hand_client.last_id == 1);
+	// Server should have the client
+	UASSERT(hand_server.count == 1);
+	UASSERT(hand_server.last_id == 2);
+
+	//sleep_ms(50);
+
+	while (client.Connected() == false) {
+		try {
+			NetworkPacket pkt;
+			infostream << "** running client.Receive()" << std::endl;
+			client.Receive(&pkt);
+			infostream << "** Client received: peer_id=" << pkt.getPeerId()
+				<< ", size=" << pkt.getSize() << std::endl;
+		} catch (con::NoIncomingDataException &e) {
+		}
+		sleep_ms(50);
+	}
+
+	sleep_ms(50);
+
+	try {
+		NetworkPacket pkt;
+		infostream << "** running server.Receive()" << std::endl;
+		server.Receive(&pkt);
+		infostream << "** Server received: peer_id=" << pkt.getPeerId()
+				<< ", size=" << pkt.getSize()
+				<< std::endl;
+	} catch (con::NoIncomingDataException &e) {
+	}
+
+	/*
+		Simple send-receive test
+	*/
+	{
+		NetworkPacket pkt;
+		pkt.putRawPacket((u8*) "Hello World !", 14, 0);
+
+		auto sentdata = pkt.oldForgePacket();
+
+		infostream<<"** running client.Send()"<<std::endl;
+		client.Send(PEER_ID_SERVER, 0, &pkt, true);
+
+		sleep_ms(50);
+
+		NetworkPacket recvpacket;
+		infostream << "** running server.Receive()" << std::endl;
+		server.Receive(&recvpacket);
+		infostream << "** Server received: peer_id=" << pkt.getPeerId()
+				<< ", size=" << pkt.getSize()
+				<< ", data=" << (const char*)pkt.getU8Ptr(0)
+				<< std::endl;
+
+		auto recvdata = pkt.oldForgePacket();
+
+		UASSERT(memcmp(*sentdata, *recvdata, recvdata.getSize()) == 0);
+	}
+
+	session_t peer_id_client = 2;
+	/*
+		Send a large packet
+	*/
+	{
+		const int datasize = 30000;
+		NetworkPacket pkt(0, datasize);
+		for (u16 i=0; i<datasize; i++) {
+			pkt << (u8) i/4;
+		}
+
+		infostream << "Sending data (size=" << datasize << "):";
+		for (int i = 0; i < datasize && i < 20; i++) {
+			if (i % 2 == 0)
+				infostream << " ";
+			char buf[10];
+			porting::mt_snprintf(buf, sizeof(buf), "%.2X",
+				((int)((const char *)pkt.getU8Ptr(0))[i]) & 0xff);
+			infostream<<buf;
+		}
+		if (datasize > 20)
+			infostream << "...";
+		infostream << std::endl;
+
+		auto sentdata = pkt.oldForgePacket();
+
+		server.Send(peer_id_client, 0, &pkt, true);
+
+		//sleep_ms(3000);
+
+		Buffer<u8> recvdata;
+		infostream << "** running client.Receive()" << std::endl;
+		session_t peer_id = 132;
+		u16 size = 0;
+		bool received = false;
+		u64 timems0 = porting::getTimeMs();
+		for (;;) {
+			if (porting::getTimeMs() - timems0 > 5000 || received)
+				break;
+			try {
+				NetworkPacket pkt;
+				client.Receive(&pkt);
+				size = pkt.getSize();
+				peer_id = pkt.getPeerId();
+				recvdata = pkt.oldForgePacket();
+				received = true;
+			} catch (con::NoIncomingDataException &e) {
+			}
+			sleep_ms(10);
+		}
+		UASSERT(received);
+		infostream << "** Client received: peer_id=" << peer_id
+			<< ", size=" << size << std::endl;
+
+		infostream << "Received data (size=" << size << "): ";
+		for (int i = 0; i < size && i < 20; i++) {
+			if (i % 2 == 0)
+				infostream << " ";
+			char buf[10];
+			porting::mt_snprintf(buf, sizeof(buf), "%.2X", ((int)(recvdata[i])) & 0xff);
+			infostream << buf;
+		}
+		if (size > 20)
+			infostream << "...";
+		infostream << std::endl;
+
+		UASSERT(memcmp(*sentdata, *recvdata, recvdata.getSize()) == 0);
+		UASSERT(peer_id == PEER_ID_SERVER);
+	}
+
+	// Check peer handlers
+	UASSERT(hand_client.count == 1);
+	UASSERT(hand_client.last_id == 1);
+	UASSERT(hand_server.count == 1);
+	UASSERT(hand_server.last_id == 2);
+}

src/unittest/test_eventmanager.cpp

@@ -0,0 +1,112 @@
+/*
+Minetest
+Copyright (C) 2018 nerzhul, Loic BLOT <loic.blot@unix-experience.fr>
+
+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
+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 Lesser General Public License for more details.
+
+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 <unordered_map>
+#include "test.h"
+#include "client/event_manager.h"
+
+class TestEventManager : public TestBase
+{
+public:
+	TestEventManager() { TestManager::registerTestModule(this); }
+	const char *getName() override { return "TestEventManager"; }
+
+	void runTests(IGameDef *gamedef) override;
+
+	void testRegister();
+	void testDeregister();
+	void testRealEvent();
+	void testRealEventAfterDereg();
+};
+
+// EventManager test class
+class EventManagerTest : public EventManager
+{
+public:
+	static void eventTest(MtEvent *e, void *data)
+	{
+		UASSERT(e->getType() >= 0);
+		UASSERT(e->getType() < MtEvent::TYPE_MAX);
+		EventManagerTest *emt = (EventManagerTest *)data;
+		emt->m_test_value = e->getType();
+	}
+
+	u64 getTestValue() const { return m_test_value; }
+	void resetValue() { m_test_value = 0; }
+
+private:
+	u64 m_test_value = 0;
+};
+
+static TestEventManager g_test_instance;
+
+void TestEventManager::runTests(IGameDef *gamedef)
+{
+	TEST(testRegister);
+	TEST(testDeregister);
+	TEST(testRealEvent);
+	TEST(testRealEventAfterDereg);
+}
+
+void TestEventManager::testRegister()
+{
+	EventManager ev;
+	ev.reg(MtEvent::PLAYER_DAMAGE, nullptr, nullptr);
+	ev.reg(MtEvent::PLAYER_DAMAGE, nullptr, nullptr);
+}
+
+void TestEventManager::testDeregister()
+{
+	EventManager ev;
+	ev.dereg(MtEvent::NODE_DUG, nullptr, nullptr);
+	ev.reg(MtEvent::PLAYER_DAMAGE, nullptr, nullptr);
+	ev.dereg(MtEvent::PLAYER_DAMAGE, nullptr, nullptr);
+}
+
+void TestEventManager::testRealEvent()
+{
+	EventManager ev;
+	auto emt = std::make_unique<EventManagerTest>();
+	ev.reg(MtEvent::PLAYER_REGAIN_GROUND, EventManagerTest::eventTest, emt.get());
+
+	// Put event & verify event value
+	ev.put(new SimpleTriggerEvent(MtEvent::PLAYER_REGAIN_GROUND));
+	UASSERT(emt->getTestValue() == MtEvent::PLAYER_REGAIN_GROUND);
+}
+
+void TestEventManager::testRealEventAfterDereg()
+{
+	EventManager ev;
+	auto emt = std::make_unique<EventManagerTest>();
+	ev.reg(MtEvent::PLAYER_REGAIN_GROUND, EventManagerTest::eventTest, emt.get());
+
+	// Put event & verify event value
+	ev.put(new SimpleTriggerEvent(MtEvent::PLAYER_REGAIN_GROUND));
+	UASSERT(emt->getTestValue() == MtEvent::PLAYER_REGAIN_GROUND);
+
+	// Reset internal value
+	emt->resetValue();
+
+	// Remove the registered event
+	ev.dereg(MtEvent::PLAYER_REGAIN_GROUND, EventManagerTest::eventTest, emt.get());
+
+	// Push the new event & ensure we target the default value
+	ev.put(new SimpleTriggerEvent(MtEvent::PLAYER_REGAIN_GROUND));
+	UASSERT(emt->getTestValue() == 0);
+}

src/unittest/test_filepath.cpp

@@ -0,0 +1,264 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 <sstream>
+
+#include "log.h"
+#include "serialization.h"
+#include "nodedef.h"
+#include "noise.h"
+
+class TestFilePath : public TestBase {
+public:
+	TestFilePath() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestFilePath"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testIsDirDelimiter();
+	void testPathStartsWith();
+	void testRemoveLastPathComponent();
+	void testRemoveLastPathComponentWithTrailingDelimiter();
+	void testRemoveRelativePathComponent();
+};
+
+static TestFilePath g_test_instance;
+
+void TestFilePath::runTests(IGameDef *gamedef)
+{
+	TEST(testIsDirDelimiter);
+	TEST(testPathStartsWith);
+	TEST(testRemoveLastPathComponent);
+	TEST(testRemoveLastPathComponentWithTrailingDelimiter);
+	TEST(testRemoveRelativePathComponent);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// adjusts a POSIX path to system-specific conventions
+// -> 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 TestFilePath::testIsDirDelimiter()
+{
+	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
+}
+
+
+void TestFilePath::testPathStartsWith()
+{
+	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, true elsewhere
+		3 = returns true on windows, false 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(\""
+			<<paths[i]<<"\", \""
+			<<paths[j]<<"\")"<<std::endl;*/
+		bool starts = fs::PathStartsWith(paths[i], paths[j]);
+		int expected = expected_results[i][j];
+		if(expected == 0){
+			UASSERT(starts == false);
+		}
+		else if(expected == 1){
+			UASSERT(starts == true);
+		}
+		#ifdef _WIN32
+		else if(expected == 2){
+			UASSERT(starts == false);
+		}
+		else if(expected == 3){
+			UASSERT(starts == true);
+		}
+		#else
+		else if(expected == 2){
+			UASSERT(starts == true);
+		}
+		else if(expected == 3){
+			UASSERT(starts == false);
+		}
+		#endif
+		else if(expected == 4){
+			UASSERT(starts == (bool)FILESYS_CASE_INSENSITIVE);
+		}
+	}
+}
+
+
+void TestFilePath::testRemoveLastPathComponent()
+{
+	std::string path, result, removed;
+
+	UASSERT(fs::RemoveLastPathComponent("") == "");
+	path = p("/home/user/minetest/bin/..//worlds/world1");
+	result = fs::RemoveLastPathComponent(path, &removed, 0);
+	UASSERT(result == path);
+	UASSERT(removed == "");
+	result = fs::RemoveLastPathComponent(path, &removed, 1);
+	UASSERT(result == p("/home/user/minetest/bin/..//worlds"));
+	UASSERT(removed == p("world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 2);
+	UASSERT(result == p("/home/user/minetest/bin/.."));
+	UASSERT(removed == p("worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 3);
+	UASSERT(result == p("/home/user/minetest/bin"));
+	UASSERT(removed == p("../worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 4);
+	UASSERT(result == p("/home/user/minetest"));
+	UASSERT(removed == p("bin/../worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 5);
+	UASSERT(result == p("/home/user"));
+	UASSERT(removed == p("minetest/bin/../worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 6);
+	UASSERT(result == p("/home"));
+	UASSERT(removed == p("user/minetest/bin/../worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 7);
+#ifdef _WIN32
+	UASSERT(result == "C:");
+#else
+	UASSERT(result == "");
+#endif
+	UASSERT(removed == p("home/user/minetest/bin/../worlds/world1"));
+}
+
+
+void TestFilePath::testRemoveLastPathComponentWithTrailingDelimiter()
+{
+	std::string path, result, removed;
+
+	path = p("/home/user/minetest/bin/..//worlds/world1/");
+	result = fs::RemoveLastPathComponent(path, &removed, 0);
+	UASSERT(result == path);
+	UASSERT(removed == "");
+	result = fs::RemoveLastPathComponent(path, &removed, 1);
+	UASSERT(result == p("/home/user/minetest/bin/..//worlds"));
+	UASSERT(removed == p("world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 2);
+	UASSERT(result == p("/home/user/minetest/bin/.."));
+	UASSERT(removed == p("worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 3);
+	UASSERT(result == p("/home/user/minetest/bin"));
+	UASSERT(removed == p("../worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 4);
+	UASSERT(result == p("/home/user/minetest"));
+	UASSERT(removed == p("bin/../worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 5);
+	UASSERT(result == p("/home/user"));
+	UASSERT(removed == p("minetest/bin/../worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 6);
+	UASSERT(result == p("/home"));
+	UASSERT(removed == p("user/minetest/bin/../worlds/world1"));
+	result = fs::RemoveLastPathComponent(path, &removed, 7);
+#ifdef _WIN32
+	UASSERT(result == "C:");
+#else
+	UASSERT(result == "");
+#endif
+	UASSERT(removed == p("home/user/minetest/bin/../worlds/world1"));
+}
+
+
+void TestFilePath::testRemoveRelativePathComponent()
+{
+	std::string path, result, removed;
+
+	path = p("/home/user/minetest/bin");
+	result = fs::RemoveRelativePathComponents(path);
+	UASSERT(result == path);
+	path = p("/home/user/minetest/bin/../worlds/world1");
+	result = fs::RemoveRelativePathComponents(path);
+	UASSERT(result == p("/home/user/minetest/worlds/world1"));
+	path = p("/home/user/minetest/bin/../worlds/world1/");
+	result = fs::RemoveRelativePathComponents(path);
+	UASSERT(result == p("/home/user/minetest/worlds/world1"));
+	path = p(".");
+	result = fs::RemoveRelativePathComponents(path);
+	UASSERT(result == "");
+	path = p("../a");
+	result = fs::RemoveRelativePathComponents(path);
+	UASSERT(result == "");
+	path = p("./subdir/../..");
+	result = fs::RemoveRelativePathComponents(path);
+	UASSERT(result == "");
+	path = p("/a/b/c/.././../d/../e/f/g/../h/i/j/../../../..");
+	result = fs::RemoveRelativePathComponents(path);
+	UASSERT(result == p("/a/e"));
+}

src/unittest/test_gameui.cpp

@@ -0,0 +1,93 @@
+/*
+Minetest
+Copyright (C) 2018 nerzhul, Loic BLOT <loic.blot@unix-experience.fr>
+
+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
+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 Lesser General Public License for more details.
+
+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 "client/gameui.h"
+
+class TestGameUI : public TestBase
+{
+public:
+	TestGameUI() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestGameUI"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testInit();
+	void testFlagSetters();
+	void testInfoText();
+	void testStatusText();
+};
+
+static TestGameUI g_test_instance;
+
+void TestGameUI::runTests(IGameDef *gamedef)
+{
+	TEST(testInit);
+	TEST(testFlagSetters);
+	TEST(testInfoText);
+	TEST(testStatusText);
+}
+
+void TestGameUI::testInit()
+{
+	GameUI gui{};
+	// Ensure flags on GameUI init
+	UASSERT(gui.getFlags().show_chat)
+	UASSERT(gui.getFlags().show_hud)
+	UASSERT(!gui.getFlags().show_minimap)
+	UASSERT(!gui.getFlags().show_profiler_graph)
+
+	// And after the initFlags init stage
+	gui.initFlags();
+	UASSERT(gui.getFlags().show_chat)
+	UASSERT(gui.getFlags().show_hud)
+	UASSERT(!gui.getFlags().show_minimap)
+	UASSERT(!gui.getFlags().show_profiler_graph)
+
+	// @TODO verify if we can create non UI nulldevice to test this function
+	// gui.init();
+}
+
+void TestGameUI::testFlagSetters()
+{
+	GameUI gui{};
+	gui.showMinimap(true);
+	UASSERT(gui.getFlags().show_minimap);
+
+	gui.showMinimap(false);
+	UASSERT(!gui.getFlags().show_minimap);
+}
+
+void TestGameUI::testStatusText()
+{
+	GameUI gui{};
+	gui.showStatusText(L"test status");
+
+	UASSERT(gui.m_statustext_time == 0.0f);
+	UASSERT(gui.m_statustext == L"test status");
+}
+
+void TestGameUI::testInfoText()
+{
+	GameUI gui{};
+	gui.setInfoText(L"test info");
+
+	UASSERT(gui.m_infotext == L"test info");
+}

src/unittest/test_gettext.cpp

@@ -0,0 +1,43 @@
+#include "test.h"
+#include "porting.h"
+#include "gettext.h"
+
+class TestGettext : public TestBase
+{
+public:
+	TestGettext() {
+		TestManager::registerTestModule(this);
+	}
+
+	const char *getName() { return "TestGettext"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testFmtgettext();
+};
+
+static TestGettext g_test_instance;
+
+void TestGettext::runTests(IGameDef *gamedef)
+{
+	TEST(testFmtgettext);
+}
+
+// Make sure updatepo.sh does not pick up the strings
+#define dummyname fmtgettext
+
+void TestGettext::testFmtgettext()
+{
+	std::string buf = dummyname("sample text %d", 12);
+	UASSERTEQ(std::string, buf, "sample text 12");
+
+	std::string src, expect;
+	src    = "You are about to join this server with the name \"%s\".\n";
+	expect = "You are about to join this server with the name \"foo\".\n";
+	for (int i = 0; i < 20; i++) {
+		src.append("loooong text");
+		expect.append("loooong text");
+	}
+	buf = dummyname(src.c_str(), "foo");
+	UASSERTEQ(const std::string &, buf, expect);
+}

src/unittest/test_inventory.cpp

@@ -0,0 +1,126 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 <sstream>
+
+#include "gamedef.h"
+#include "inventory.h"
+
+class TestInventory : public TestBase {
+public:
+	TestInventory() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestInventory"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testSerializeDeserialize(IItemDefManager *idef);
+
+	static const char *serialized_inventory_in;
+	static const char *serialized_inventory_out;
+	static const char *serialized_inventory_inc;
+};
+
+static TestInventory g_test_instance;
+
+void TestInventory::runTests(IGameDef *gamedef)
+{
+	TEST(testSerializeDeserialize, gamedef->getItemDefManager());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestInventory::testSerializeDeserialize(IItemDefManager *idef)
+{
+	Inventory inv(idef);
+	std::istringstream is(serialized_inventory_in, 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"));
+	UASSERTEQ(u32, inv.getList("main")->getWidth(), 3);
+
+	inv.getList("main")->setWidth(5);
+	std::ostringstream inv_os(std::ios::binary);
+	inv.serialize(inv_os, false);
+	UASSERTEQ(std::string, inv_os.str(), serialized_inventory_out);
+
+	inv.setModified(false);
+	inv_os.str("");
+	inv_os.clear();
+	inv.serialize(inv_os, true);
+	UASSERTEQ(std::string, inv_os.str(), serialized_inventory_inc);
+
+	ItemStack leftover = inv.getList("main")->takeItem(7, 99 - 12);
+	ItemStack wanted = ItemStack("default:dirt", 99 - 12, 0, idef);
+	UASSERT(leftover == wanted);
+	leftover = inv.getList("main")->getItem(7);
+	wanted.count = 12;
+	UASSERT(leftover == wanted);
+}
+
+const char *TestInventory::serialized_inventory_in =
+	"List 0 10\n"
+	"Width 3\n"
+	"Empty\n"
+	"Empty\n"
+	"Item default:cobble 61\n"
+	"Empty\n"
+	"Empty\n"
+	"Item default:dirt 71\n"
+	"Empty\n"
+	"Item default:dirt 99\n"
+	"Item default:cobble 38\n"
+	"Empty\n"
+	"EndInventoryList\n"
+	"List abc 1\n"
+	"Item default:stick 3\n"
+	"Width 0\n"
+	"EndInventoryList\n"
+	"EndInventory\n";
+
+const char *TestInventory::serialized_inventory_out =
+	"List main 10\n"
+	"Width 5\n"
+	"Empty\n"
+	"Empty\n"
+	"Item default:cobble 61\n"
+	"Empty\n"
+	"Empty\n"
+	"Item default:dirt 71\n"
+	"Empty\n"
+	"Item default:dirt 99\n"
+	"Item default:cobble 38\n"
+	"Empty\n"
+	"EndInventoryList\n"
+	"List abc 1\n"
+	"Width 0\n"
+	"Item default:stick 3\n"
+	"EndInventoryList\n"
+	"EndInventory\n";
+
+const char *TestInventory::serialized_inventory_inc =
+	"KeepList main\n"
+	"KeepList abc\n"
+	"EndInventory\n";

src/unittest/test_irrptr.cpp

@@ -0,0 +1,143 @@
+/*
+Minetest
+Copyright (C) 2018 numzero, Lobachevskiy Vitaliy <numzer0@yandex.ru>
+
+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
+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 Lesser General Public License for more details.
+
+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 "exceptions.h"
+#include "irr_ptr.h"
+
+class TestIrrPtr : public TestBase
+{
+public:
+	TestIrrPtr() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestIrrPtr"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testRefCounting();
+	void testSelfAssignment();
+	void testNullHandling();
+};
+
+static TestIrrPtr g_test_instance;
+
+void TestIrrPtr::runTests(IGameDef *gamedef)
+{
+	TEST(testRefCounting);
+	TEST(testSelfAssignment);
+	TEST(testNullHandling);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#define UASSERT_REFERENCE_COUNT(object, value, info)                                     \
+	UTEST((object)->getReferenceCount() == value,                                    \
+			info "Reference count is %d instead of " #value,                 \
+			(object)->getReferenceCount())
+
+void TestIrrPtr::testRefCounting()
+{
+	IReferenceCounted *obj = new IReferenceCounted(); // RC=1
+	obj->grab();
+	UASSERT_REFERENCE_COUNT(obj, 2, "Pre-condition failed: ");
+	{
+		irr_ptr<IReferenceCounted> p1{obj}; // move semantics
+		UASSERT(p1.get() == obj);
+		UASSERT_REFERENCE_COUNT(obj, 2, );
+
+		irr_ptr<IReferenceCounted> p2{p1}; // copy ctor
+		UASSERT(p1.get() == obj);
+		UASSERT(p2.get() == obj);
+		UASSERT_REFERENCE_COUNT(obj, 3, );
+
+		irr_ptr<IReferenceCounted> p3{std::move(p1)}; // move ctor
+		UASSERT(p1.get() == nullptr);
+		UASSERT(p3.get() == obj);
+		UASSERT_REFERENCE_COUNT(obj, 3, );
+
+		p1 = std::move(p2); // move assignment
+		UASSERT(p1.get() == obj);
+		UASSERT(p2.get() == nullptr);
+		UASSERT_REFERENCE_COUNT(obj, 3, );
+
+		p2 = p3; // copy assignment
+		UASSERT(p2.get() == obj);
+		UASSERT(p3.get() == obj);
+		UASSERT_REFERENCE_COUNT(obj, 4, );
+
+		p1.release();
+		UASSERT(p1.get() == nullptr);
+		UASSERT_REFERENCE_COUNT(obj, 4, );
+	}
+	UASSERT_REFERENCE_COUNT(obj, 2, );
+	obj->drop();
+	UTEST(obj->drop(), "Dropping failed: reference count is %d",
+			obj->getReferenceCount());
+}
+
+#if defined(__clang__)
+	#pragma GCC diagnostic push
+	#if __clang_major__ >= 7
+		#pragma GCC diagnostic ignored "-Wself-assign-overloaded"
+	#endif
+	#pragma GCC diagnostic ignored "-Wself-move"
+#endif
+
+void TestIrrPtr::testSelfAssignment()
+{
+	irr_ptr<IReferenceCounted> p1{new IReferenceCounted()};
+	UASSERT(p1);
+	UASSERT_REFERENCE_COUNT(p1, 1, );
+	p1 = p1;
+	UASSERT(p1);
+	UASSERT_REFERENCE_COUNT(p1, 1, );
+	p1 = std::move(p1);
+	UASSERT(p1);
+	UASSERT_REFERENCE_COUNT(p1, 1, );
+}
+
+void TestIrrPtr::testNullHandling()
+{
+	// In the case of an error, it will probably crash with SEGV.
+	// Nevertheless, UASSERTs are used to catch possible corner cases.
+	irr_ptr<IReferenceCounted> p1{new IReferenceCounted()};
+	UASSERT(p1);
+	irr_ptr<IReferenceCounted> p2;
+	UASSERT(!p2);
+	irr_ptr<IReferenceCounted> p3{p2};
+	UASSERT(!p2);
+	UASSERT(!p3);
+	irr_ptr<IReferenceCounted> p4{std::move(p2)};
+	UASSERT(!p2);
+	UASSERT(!p4);
+	p2 = p2;
+	UASSERT(!p2);
+	p2 = std::move(p2);
+	UASSERT(!p2);
+	p3 = p2;
+	UASSERT(!p2);
+	UASSERT(!p3);
+	p3 = std::move(p2);
+	UASSERT(!p2);
+	UASSERT(!p3);
+}
+
+#if defined(__clang__)
+	#pragma GCC diagnostic pop
+#endif

src/unittest/test_keycode.cpp

@@ -0,0 +1,129 @@
+/*
+Minetest
+Copyright (C) 2016 sfan5 <sfan5@live.de>
+
+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
+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 Lesser General Public License for more details.
+
+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 <string>
+#include "exceptions.h"
+#include "client/keycode.h"
+
+class TestKeycode : public TestBase {
+public:
+	TestKeycode() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestKeycode"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testCreateFromString();
+	void testCreateFromSKeyInput();
+	void testCompare();
+};
+
+static TestKeycode g_test_instance;
+
+void TestKeycode::runTests(IGameDef *gamedef)
+{
+	TEST(testCreateFromString);
+	TEST(testCreateFromSKeyInput);
+	TEST(testCompare);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#define UASSERTEQ_STR(one, two) UASSERT(strcmp(one, two) == 0)
+
+void TestKeycode::testCreateFromString()
+{
+	KeyPress k;
+
+	// Character key, from char
+	k = KeyPress("R");
+	UASSERTEQ_STR(k.sym(), "KEY_KEY_R");
+	UASSERTCMP(int, >, strlen(k.name()), 0); // should have human description
+
+	// Character key, from identifier
+	k = KeyPress("KEY_KEY_B");
+	UASSERTEQ_STR(k.sym(), "KEY_KEY_B");
+	UASSERTCMP(int, >, strlen(k.name()), 0);
+
+	// Non-Character key, from identifier
+	k = KeyPress("KEY_UP");
+	UASSERTEQ_STR(k.sym(), "KEY_UP");
+	UASSERTCMP(int, >, strlen(k.name()), 0);
+
+	k = KeyPress("KEY_F6");
+	UASSERTEQ_STR(k.sym(), "KEY_F6");
+	UASSERTCMP(int, >, strlen(k.name()), 0);
+
+	// Irrlicht-unknown key, from char
+	k = KeyPress("/");
+	UASSERTEQ_STR(k.sym(), "/");
+	UASSERTCMP(int, >, strlen(k.name()), 0);
+}
+
+void TestKeycode::testCreateFromSKeyInput()
+{
+	KeyPress k;
+	irr::SEvent::SKeyInput in;
+
+	// Character key
+	in.Key = irr::KEY_KEY_3;
+	in.Char = L'3';
+	k = KeyPress(in);
+	UASSERTEQ_STR(k.sym(), "KEY_KEY_3");
+
+	// Non-Character key
+	in.Key = irr::KEY_RSHIFT;
+	in.Char = L'\0';
+	k = KeyPress(in);
+	UASSERTEQ_STR(k.sym(), "KEY_RSHIFT");
+
+	// Irrlicht-unknown key
+	in.Key = irr::KEY_KEY_CODES_COUNT;
+	in.Char = L'?';
+	k = KeyPress(in);
+	UASSERTEQ_STR(k.sym(), "?");
+
+	// prefer_character mode
+	in.Key = irr::KEY_COMMA;
+	in.Char = L'G';
+	k = KeyPress(in, true);
+	UASSERTEQ_STR(k.sym(), "KEY_KEY_G");
+}
+
+void TestKeycode::testCompare()
+{
+	// Basic comparison
+	UASSERT(KeyPress("5") == KeyPress("KEY_KEY_5"));
+	UASSERT(!(KeyPress("5") == KeyPress("KEY_NUMPAD_5")));
+
+	// Matching char suffices
+	// note: This is a real-world example, Irrlicht maps XK_equal to irr::KEY_PLUS on Linux
+	irr::SEvent::SKeyInput in;
+	in.Key = irr::KEY_PLUS;
+	in.Char = L'=';
+	UASSERT(KeyPress("=") == KeyPress(in));
+
+	// Matching keycode suffices
+	irr::SEvent::SKeyInput in2;
+	in.Key = in2.Key = irr::KEY_OEM_CLEAR;
+	in.Char = L'\0';
+	in2.Char = L';';
+	UASSERT(KeyPress(in) == KeyPress(in2));
+}

src/unittest/test_lua.cpp

@@ -0,0 +1,79 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2021 TurkeyMcMac, Jude Melton-Houghton <jwmhjwmh@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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"
+
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+}
+
+class TestLua : public TestBase
+{
+public:
+	TestLua() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestLua"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testLuaDestructors();
+};
+
+static TestLua g_test_instance;
+
+void TestLua::runTests(IGameDef *gamedef)
+{
+	TEST(testLuaDestructors);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace
+{
+
+	class DestructorDetector {
+		bool *did_destruct;
+	public:
+		DestructorDetector(bool *did_destruct) : did_destruct(did_destruct)
+		{
+			*did_destruct = false;
+		}
+		~DestructorDetector()
+		{
+			*did_destruct = true;
+		}
+	};
+
+}
+
+void TestLua::testLuaDestructors()
+{
+	bool did_destruct = false;
+
+	lua_State *L = luaL_newstate();
+	lua_cpcall(L, [](lua_State *L) -> int {
+		DestructorDetector d(reinterpret_cast<bool*>(lua_touserdata(L, 1)));
+		luaL_error(L, "error");
+		return 0;
+	}, &did_destruct);
+	lua_close(L);
+
+	UASSERT(did_destruct);
+}

src/unittest/test_map.cpp

@@ -0,0 +1,68 @@
+/*
+Minetest
+
+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
+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 Lesser General Public License for more details.
+
+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 <cstdio>
+#include "mapblock.h"
+
+class TestMap : public TestBase
+{
+public:
+	TestMap() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestMap"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testMaxMapgenLimit();
+};
+
+static TestMap g_test_instance;
+
+void TestMap::runTests(IGameDef *gamedef)
+{
+	TEST(testMaxMapgenLimit);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestMap::testMaxMapgenLimit()
+{
+	// limit must end on a mapblock boundary
+	UASSERTEQ(int, MAX_MAP_GENERATION_LIMIT % MAP_BLOCKSIZE, MAP_BLOCKSIZE - 1);
+
+	// objectpos_over_limit should do exactly this except the last node
+	// actually spans from LIMIT-0.5 to LIMIT+0.5
+	float limit_times_bs = MAX_MAP_GENERATION_LIMIT * BS;
+	UASSERT(objectpos_over_limit(v3f(limit_times_bs-BS/2)) == false);
+	UASSERT(objectpos_over_limit(v3f(limit_times_bs)) == false);
+	UASSERT(objectpos_over_limit(v3f(limit_times_bs+BS/2)) == false);
+	UASSERT(objectpos_over_limit(v3f(limit_times_bs+BS)) == true);
+
+	UASSERT(objectpos_over_limit(v3f(-limit_times_bs+BS/2)) == false);
+	UASSERT(objectpos_over_limit(v3f(-limit_times_bs)) == false);
+	UASSERT(objectpos_over_limit(v3f(-limit_times_bs-BS/2)) == false);
+	UASSERT(objectpos_over_limit(v3f(-limit_times_bs-BS)) == true);
+
+	// blockpos_over_max_limit
+	s16 limit_block = MAX_MAP_GENERATION_LIMIT / MAP_BLOCKSIZE;
+	UASSERT(blockpos_over_max_limit(v3s16(limit_block)) == false);
+	UASSERT(blockpos_over_max_limit(v3s16(limit_block+1)) == true);
+	UASSERT(blockpos_over_max_limit(v3s16(-limit_block)) == false);
+	UASSERT(blockpos_over_max_limit(v3s16(-limit_block-1)) == true);
+}

src/unittest/test_map_settings_manager.cpp

@@ -0,0 +1,266 @@
+ /*
+Minetest
+Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
+
+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
+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 Lesser General Public License for more details.
+
+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 "noise.h"
+#include "settings.h"
+#include "mapgen/mapgen_v5.h"
+#include "util/sha1.h"
+#include "map_settings_manager.h"
+
+class TestMapSettingsManager : public TestBase {
+public:
+	TestMapSettingsManager() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestMapSettingsManager"; }
+
+	void makeUserConfig();
+	std::string makeMetaFile(bool make_corrupt);
+
+	void runTests(IGameDef *gamedef);
+
+	void testMapSettingsManager();
+	void testMapMetaSaveLoad();
+	void testMapMetaFailures();
+};
+
+static TestMapSettingsManager g_test_instance;
+
+void TestMapSettingsManager::runTests(IGameDef *gamedef)
+{
+	TEST(testMapSettingsManager);
+	TEST(testMapMetaSaveLoad);
+	TEST(testMapMetaFailures);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+void check_noise_params(const NoiseParams *np1, const NoiseParams *np2)
+{
+	UASSERTEQ(float, np1->offset, np2->offset);
+	UASSERTEQ(float, np1->scale, np2->scale);
+	UASSERT(np1->spread == np2->spread);
+	UASSERTEQ(s32, np1->seed, np2->seed);
+	UASSERTEQ(u16, np1->octaves, np2->octaves);
+	UASSERTEQ(float, np1->persist, np2->persist);
+	UASSERTEQ(float, np1->lacunarity, np2->lacunarity);
+	UASSERTEQ(u32, np1->flags, np2->flags);
+}
+
+
+void TestMapSettingsManager::makeUserConfig()
+{
+	delete Settings::getLayer(SL_GLOBAL);
+	Settings *conf = Settings::createLayer(SL_GLOBAL);
+
+	conf->set("mg_name", "v7");
+	conf->set("seed", "5678");
+	conf->set("water_level", "20");
+	conf->set("mgv5_np_factor", "0, 12,  (500, 250, 500), 920382, 5, 0.45, 3.0");
+	conf->set("mgv5_np_height", "0, 15, (500, 250, 500), 841746,  5, 0.5,  3.0");
+	conf->set("mgv5_np_filler_depth", "20, 1, (150, 150, 150), 261, 4, 0.7,  1.0");
+	conf->set("mgv5_np_ground", "-43, 40, (80,  80,  80),  983240, 4, 0.55, 2.0");
+}
+
+
+std::string TestMapSettingsManager::makeMetaFile(bool make_corrupt)
+{
+	std::string metafile = getTestTempFile();
+
+	const char *metafile_contents =
+		"mg_name = v5\n"
+		"seed = 1234\n"
+		"mg_flags = light\n"
+		"mgv5_np_filler_depth = 20, 1, (150, 150, 150), 261, 4, 0.7,  1.0\n"
+		"mgv5_np_height = 20, 10, (250, 250, 250), 84174,  4, 0.5,  1.0\n";
+
+	FILE *f = fopen(metafile.c_str(), "wb");
+	UASSERT(f != NULL);
+
+	fputs(metafile_contents, f);
+	if (!make_corrupt)
+		fputs("[end_of_params]\n", f);
+
+	fclose(f);
+
+	return metafile;
+}
+
+
+void TestMapSettingsManager::testMapSettingsManager()
+{
+	makeUserConfig();
+
+	std::string test_mapmeta_path = makeMetaFile(false);
+
+	MapSettingsManager mgr(test_mapmeta_path);
+	std::string value;
+
+	UASSERT(mgr.getMapSetting("mg_name", &value));
+	UASSERT(value == "v7");
+
+	// Pretend we're initializing the ServerMap
+	UASSERT(mgr.loadMapMeta());
+
+	// Pretend some scripts are requesting mapgen params
+	UASSERT(mgr.getMapSetting("mg_name", &value));
+	UASSERT(value == "v5");
+	UASSERT(mgr.getMapSetting("seed", &value));
+	UASSERT(value == "1234");
+	UASSERT(mgr.getMapSetting("water_level", &value));
+	UASSERT(value == "20");
+
+    // Pretend we have some mapgen settings configured from the scripting
+	UASSERT(mgr.setMapSetting("water_level", "15"));
+	UASSERT(mgr.setMapSetting("seed", "02468"));
+	UASSERT(mgr.setMapSetting("mg_flags", "nolight", true));
+
+	NoiseParams script_np_filler_depth(0, 100, v3f(200, 100, 200), 261, 4, 0.7, 2.0);
+	NoiseParams script_np_factor(0, 100, v3f(50, 50, 50), 920381, 3, 0.45, 2.0);
+	NoiseParams script_np_height(0, 100, v3f(450, 450, 450), 84174, 4, 0.5, 2.0);
+	NoiseParams meta_np_height(20, 10, v3f(250, 250, 250), 84174,  4, 0.5,  1.0);
+	NoiseParams user_np_ground(-43, 40, v3f(80,  80,  80),  983240, 4, 0.55, 2.0, NOISE_FLAG_EASED);
+
+	mgr.setMapSettingNoiseParams("mgv5_np_filler_depth", &script_np_filler_depth, true);
+	mgr.setMapSettingNoiseParams("mgv5_np_height", &script_np_height);
+	mgr.setMapSettingNoiseParams("mgv5_np_factor", &script_np_factor);
+
+	{
+		NoiseParams dummy;
+		mgr.getMapSettingNoiseParams("mgv5_np_factor", &dummy);
+		check_noise_params(&dummy, &script_np_factor);
+	}
+
+	// The settings manager MUST leave user settings alone
+	mgr.setMapSetting("testname", "1");
+	mgr.setMapSetting("testname", "1", true);
+	UASSERT(!Settings::getLayer(SL_GLOBAL)->exists("testname"));
+
+	// Now make our Params and see if the values are correctly sourced
+	MapgenParams *params = mgr.makeMapgenParams();
+	UASSERT(params->mgtype == MAPGEN_V5);
+	UASSERT(params->chunksize == 5);
+	UASSERT(params->water_level == 15);
+	UASSERT(params->seed == 1234);
+	UASSERT((params->flags & MG_LIGHT) == 0);
+
+	MapgenV5Params *v5params = (MapgenV5Params *)params;
+
+	check_noise_params(&v5params->np_filler_depth, &script_np_filler_depth);
+	check_noise_params(&v5params->np_factor, &script_np_factor);
+	check_noise_params(&v5params->np_height, &meta_np_height);
+	check_noise_params(&v5params->np_ground, &user_np_ground);
+
+	UASSERT(mgr.setMapSetting("foobar", "25") == false);
+
+	// Pretend the ServerMap is shutting down
+	UASSERT(mgr.saveMapMeta());
+
+	// Make sure our interface expectations are met
+	UASSERT(mgr.mapgen_params == params);
+	UASSERT(mgr.makeMapgenParams() == params);
+
+#if 0
+	// TODO(paramat or hmmmm): change this to compare the result against a static file
+
+	// Load the resulting map_meta.txt and make sure it contains what we expect
+	unsigned char expected_contents_hash[20] = {
+		0x48, 0x3f, 0x88, 0x5a, 0xc0, 0x7a, 0x14, 0x48, 0xa4, 0x71,
+		0x78, 0x56, 0x95, 0x2d, 0xdc, 0x6a, 0xf7, 0x61, 0x36, 0x5f
+	};
+
+	SHA1 ctx;
+	std::string metafile_contents;
+	UASSERT(fs::ReadFile(test_mapmeta_path, metafile_contents));
+	ctx.addBytes(&metafile_contents[0], metafile_contents.size());
+	unsigned char *sha1_result = ctx.getDigest();
+	int resultdiff = memcmp(sha1_result, expected_contents_hash, 20);
+	free(sha1_result);
+
+	UASSERT(!resultdiff);
+#endif
+}
+
+
+void TestMapSettingsManager::testMapMetaSaveLoad()
+{
+	std::string path = getTestTempDirectory()
+		+ DIR_DELIM + "foobar" + DIR_DELIM + "map_meta.txt";
+
+	makeUserConfig();
+	Settings &conf = *Settings::getLayer(SL_GLOBAL);
+
+	// There cannot be two MapSettingsManager
+	// copy the mapgen params to compare them
+	MapgenParams params1, params2;
+	// Create a set of mapgen params and save them to map meta
+	{
+		conf.set("seed", "12345");
+		conf.set("water_level", "5");
+		MapSettingsManager mgr(path);
+		MapgenParams *params = mgr.makeMapgenParams();
+		UASSERT(params);
+		params1 = *params;
+		params1.bparams = nullptr; // No double-free
+		UASSERT(mgr.saveMapMeta());
+	}
+
+	// Now try loading the map meta to mapgen params
+	{
+		conf.set("seed", "67890");
+		conf.set("water_level", "32");
+		MapSettingsManager mgr(path);
+		UASSERT(mgr.loadMapMeta());
+		MapgenParams *params = mgr.makeMapgenParams();
+		UASSERT(params);
+		params2 = *params;
+		params2.bparams = nullptr; // No double-free
+	}
+
+	// Check that both results are correct
+	UASSERTEQ(u64, params1.seed, 12345);
+	UASSERTEQ(s16, params1.water_level, 5);
+	UASSERTEQ(u64, params2.seed, 12345);
+	UASSERTEQ(s16, params2.water_level, 5);
+}
+
+
+void TestMapSettingsManager::testMapMetaFailures()
+{
+	std::string test_mapmeta_path;
+
+	// Check to see if it'll fail on a non-existent map meta file
+	{
+		test_mapmeta_path = "woobawooba/fgdfg/map_meta.txt";
+		UASSERT(!fs::PathExists(test_mapmeta_path));
+
+		MapSettingsManager mgr1(test_mapmeta_path);
+		UASSERT(!mgr1.loadMapMeta());
+	}
+
+	// Check to see if it'll fail on a corrupt map meta file
+	{
+		test_mapmeta_path = makeMetaFile(true);
+		UASSERT(fs::PathExists(test_mapmeta_path));
+
+		MapSettingsManager mgr2(test_mapmeta_path);
+		UASSERT(!mgr2.loadMapMeta());
+	}
+}

src/unittest/test_mapnode.cpp

@@ -0,0 +1,57 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "gamedef.h"
+#include "nodedef.h"
+#include "content_mapnode.h"
+
+class TestMapNode : public TestBase
+{
+public:
+	TestMapNode() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestMapNode"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testNodeProperties(const NodeDefManager *nodedef);
+};
+
+static TestMapNode g_test_instance;
+
+void TestMapNode::runTests(IGameDef *gamedef)
+{
+	TEST(testNodeProperties, gamedef->getNodeDefManager());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestMapNode::testNodeProperties(const NodeDefManager *nodedef)
+{
+	MapNode n(CONTENT_AIR);
+
+	UASSERT(n.getContent() == CONTENT_AIR);
+	UASSERT(n.getLight(LIGHTBANK_DAY, nodedef) == 0);
+	UASSERT(n.getLight(LIGHTBANK_NIGHT, nodedef) == 0);
+
+	// Transparency
+	n.setContent(CONTENT_AIR);
+	UASSERT(nodedef->get(n).light_propagates == true);
+}

src/unittest/test_mod/test_mod/init.lua

@@ -0,0 +1 @@
+-- deliberately empty

src/unittest/test_mod/test_mod/mod.conf

@@ -0,0 +1,2 @@
+name = test_mod
+description = A mod doing nothing, to test if MINETEST_MOD_PATH is recognised

src/unittest/test_modchannels.cpp

@@ -0,0 +1,76 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "gamedef.h"
+#include "modchannels.h"
+
+class TestModChannels : public TestBase
+{
+public:
+	TestModChannels() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestModChannels"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testJoinChannel(IGameDef *gamedef);
+	void testLeaveChannel(IGameDef *gamedef);
+	void testSendMessageToChannel(IGameDef *gamedef);
+};
+
+static TestModChannels g_test_instance;
+
+void TestModChannels::runTests(IGameDef *gamedef)
+{
+	TEST(testJoinChannel, gamedef);
+	TEST(testLeaveChannel, gamedef);
+	TEST(testSendMessageToChannel, gamedef);
+}
+
+void TestModChannels::testJoinChannel(IGameDef *gamedef)
+{
+	// Test join
+	UASSERT(gamedef->joinModChannel("test_join_channel"));
+	// Test join (fail, already join)
+	UASSERT(!gamedef->joinModChannel("test_join_channel"));
+}
+
+void TestModChannels::testLeaveChannel(IGameDef *gamedef)
+{
+	// Test leave (not joined)
+	UASSERT(!gamedef->leaveModChannel("test_leave_channel"));
+
+	UASSERT(gamedef->joinModChannel("test_leave_channel"));
+
+	// Test leave (joined)
+	UASSERT(gamedef->leaveModChannel("test_leave_channel"));
+}
+
+void TestModChannels::testSendMessageToChannel(IGameDef *gamedef)
+{
+	// Test sendmsg (not joined)
+	UASSERT(!gamedef->sendModChannelMessage(
+			"test_sendmsg_channel", "testmsgchannel"));
+
+	UASSERT(gamedef->joinModChannel("test_sendmsg_channel"));
+
+	// Test sendmsg (joined)
+	UASSERT(gamedef->sendModChannelMessage("test_sendmsg_channel", "testmsgchannel"));
+}

src/unittest/test_modmetadatadatabase.cpp

@@ -0,0 +1,253 @@
+/*
+Minetest
+Copyright (C) 2018 bendeutsch, Ben Deutsch <ben@bendeutsch.de>
+Copyright (C) 2021 TurkeyMcMac, Jude Melton-Houghton <jwmhjwmh@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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.
+*/
+
+// This file is an edited copy of test_authdatabase.cpp
+
+#include "test.h"
+
+#include <algorithm>
+#include "database/database-files.h"
+#include "database/database-sqlite3.h"
+#include "filesys.h"
+
+namespace
+{
+// Anonymous namespace to create classes that are only
+// visible to this file
+//
+// These are helpers that return a *ModMetadataDatabase and
+// allow us to run the same tests on different databases and
+// database acquisition strategies.
+
+class ModMetadataDatabaseProvider
+{
+public:
+	virtual ~ModMetadataDatabaseProvider() = default;
+	virtual ModMetadataDatabase *getModMetadataDatabase() = 0;
+};
+
+class FixedProvider : public ModMetadataDatabaseProvider
+{
+public:
+	FixedProvider(ModMetadataDatabase *mod_meta_db) : mod_meta_db(mod_meta_db){};
+	virtual ~FixedProvider(){};
+	virtual ModMetadataDatabase *getModMetadataDatabase() { return mod_meta_db; };
+
+private:
+	ModMetadataDatabase *mod_meta_db;
+};
+
+class FilesProvider : public ModMetadataDatabaseProvider
+{
+public:
+	FilesProvider(const std::string &dir) : dir(dir){};
+	virtual ~FilesProvider()
+	{
+		if (mod_meta_db)
+			mod_meta_db->endSave();
+		delete mod_meta_db;
+	}
+	virtual ModMetadataDatabase *getModMetadataDatabase()
+	{
+		if (mod_meta_db)
+			mod_meta_db->endSave();
+		delete mod_meta_db;
+		mod_meta_db = new ModMetadataDatabaseFiles(dir);
+		mod_meta_db->beginSave();
+		return mod_meta_db;
+	};
+
+private:
+	std::string dir;
+	ModMetadataDatabase *mod_meta_db = nullptr;
+};
+
+class SQLite3Provider : public ModMetadataDatabaseProvider
+{
+public:
+	SQLite3Provider(const std::string &dir) : dir(dir){};
+	virtual ~SQLite3Provider()
+	{
+		if (mod_meta_db)
+			mod_meta_db->endSave();
+		delete mod_meta_db;
+	}
+	virtual ModMetadataDatabase *getModMetadataDatabase()
+	{
+		if (mod_meta_db)
+			mod_meta_db->endSave();
+		delete mod_meta_db;
+		mod_meta_db = new ModMetadataDatabaseSQLite3(dir);
+		mod_meta_db->beginSave();
+		return mod_meta_db;
+	};
+
+private:
+	std::string dir;
+	ModMetadataDatabase *mod_meta_db = nullptr;
+};
+}
+
+class TestModMetadataDatabase : public TestBase
+{
+public:
+	TestModMetadataDatabase() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestModMetadataDatabase"; }
+
+	void runTests(IGameDef *gamedef);
+	void runTestsForCurrentDB();
+
+	void testRecallFail();
+	void testCreate();
+	void testRecall();
+	void testChange();
+	void testRecallChanged();
+	void testListMods();
+	void testRemove();
+
+private:
+	ModMetadataDatabaseProvider *mod_meta_provider;
+};
+
+static TestModMetadataDatabase g_test_instance;
+
+void TestModMetadataDatabase::runTests(IGameDef *gamedef)
+{
+	// fixed directory, for persistence
+	thread_local const std::string test_dir = getTestTempDirectory();
+
+	// Each set of tests is run twice for each database type:
+	// one where we reuse the same ModMetadataDatabase object (to test local caching),
+	// and one where we create a new ModMetadataDatabase object for each call
+	// (to test actual persistence).
+
+	rawstream << "-------- Files database (same object)" << std::endl;
+
+	ModMetadataDatabase *mod_meta_db = new ModMetadataDatabaseFiles(test_dir);
+	mod_meta_provider = new FixedProvider(mod_meta_db);
+
+	runTestsForCurrentDB();
+
+	delete mod_meta_db;
+	delete mod_meta_provider;
+
+	// reset database
+	fs::RecursiveDelete(test_dir + DIR_DELIM + "mod_storage");
+
+	rawstream << "-------- Files database (new objects)" << std::endl;
+
+	mod_meta_provider = new FilesProvider(test_dir);
+
+	runTestsForCurrentDB();
+
+	delete mod_meta_provider;
+
+	rawstream << "-------- SQLite3 database (same object)" << std::endl;
+
+	mod_meta_db = new ModMetadataDatabaseSQLite3(test_dir);
+	mod_meta_provider = new FixedProvider(mod_meta_db);
+
+	runTestsForCurrentDB();
+
+	delete mod_meta_db;
+	delete mod_meta_provider;
+
+	// reset database
+	fs::DeleteSingleFileOrEmptyDirectory(test_dir + DIR_DELIM + "mod_storage.sqlite");
+
+	rawstream << "-------- SQLite3 database (new objects)" << std::endl;
+
+	mod_meta_provider = new SQLite3Provider(test_dir);
+
+	runTestsForCurrentDB();
+
+	delete mod_meta_provider;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestModMetadataDatabase::runTestsForCurrentDB()
+{
+	TEST(testRecallFail);
+	TEST(testCreate);
+	TEST(testRecall);
+	TEST(testChange);
+	TEST(testRecallChanged);
+	TEST(testListMods);
+	TEST(testRemove);
+	TEST(testRecallFail);
+}
+
+void TestModMetadataDatabase::testRecallFail()
+{
+	ModMetadataDatabase *mod_meta_db = mod_meta_provider->getModMetadataDatabase();
+	StringMap recalled;
+	mod_meta_db->getModEntries("mod1", &recalled);
+	UASSERT(recalled.empty());
+}
+
+void TestModMetadataDatabase::testCreate()
+{
+	ModMetadataDatabase *mod_meta_db = mod_meta_provider->getModMetadataDatabase();
+	StringMap recalled;
+	UASSERT(mod_meta_db->setModEntry("mod1", "key1", "value1"));
+}
+
+void TestModMetadataDatabase::testRecall()
+{
+	ModMetadataDatabase *mod_meta_db = mod_meta_provider->getModMetadataDatabase();
+	StringMap recalled;
+	mod_meta_db->getModEntries("mod1", &recalled);
+	UASSERT(recalled.size() == 1);
+	UASSERT(recalled["key1"] == "value1");
+}
+
+void TestModMetadataDatabase::testChange()
+{
+	ModMetadataDatabase *mod_meta_db = mod_meta_provider->getModMetadataDatabase();
+	StringMap recalled;
+	UASSERT(mod_meta_db->setModEntry("mod1", "key1", "value2"));
+}
+
+void TestModMetadataDatabase::testRecallChanged()
+{
+	ModMetadataDatabase *mod_meta_db = mod_meta_provider->getModMetadataDatabase();
+	StringMap recalled;
+	mod_meta_db->getModEntries("mod1", &recalled);
+	UASSERT(recalled.size() == 1);
+	UASSERT(recalled["key1"] == "value2");
+}
+
+void TestModMetadataDatabase::testListMods()
+{
+	ModMetadataDatabase *mod_meta_db = mod_meta_provider->getModMetadataDatabase();
+	UASSERT(mod_meta_db->setModEntry("mod2", "key1", "value1"));
+	std::vector<std::string> mod_list;
+	mod_meta_db->listMods(&mod_list);
+	UASSERT(mod_list.size() == 2);
+	UASSERT(std::find(mod_list.cbegin(), mod_list.cend(), "mod1") != mod_list.cend());
+	UASSERT(std::find(mod_list.cbegin(), mod_list.cend(), "mod2") != mod_list.cend());
+}
+
+void TestModMetadataDatabase::testRemove()
+{
+	ModMetadataDatabase *mod_meta_db = mod_meta_provider->getModMetadataDatabase();
+	UASSERT(mod_meta_db->removeModEntry("mod1", "key1"));
+}

src/unittest/test_nodedef.cpp

@@ -0,0 +1,67 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 <sstream>
+
+#include "gamedef.h"
+#include "nodedef.h"
+#include "network/networkprotocol.h"
+
+class TestNodeDef : public TestBase
+{
+public:
+	TestNodeDef() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestNodeDef"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testContentFeaturesSerialization();
+};
+
+static TestNodeDef g_test_instance;
+
+void TestNodeDef::runTests(IGameDef *gamedef)
+{
+	TEST(testContentFeaturesSerialization);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestNodeDef::testContentFeaturesSerialization()
+{
+	ContentFeatures f;
+
+	f.name = "default:stone";
+	for (TileDef &tiledef : f.tiledef)
+		tiledef.name = "default_stone.png";
+	f.is_ground_content = true;
+
+	std::ostringstream os(std::ios::binary);
+	f.serialize(os, LATEST_PROTOCOL_VERSION);
+	// verbosestream<<"Test ContentFeatures size: "<<os.str().size()<<std::endl;
+
+	std::istringstream is(os.str(), std::ios::binary);
+	ContentFeatures f2;
+	f2.deSerialize(is, LATEST_PROTOCOL_VERSION);
+
+	UASSERT(f.walkable == f2.walkable);
+	UASSERT(f.node_box.type == f2.node_box.type);
+}

src/unittest/test_noderesolver.cpp

@@ -0,0 +1,212 @@
+/*
+Minetest
+Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
+
+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
+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 Lesser General Public License for more details.
+
+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 "util/numeric.h"
+#include "exceptions.h"
+#include "gamedef.h"
+#include "nodedef.h"
+
+#include <algorithm>
+
+
+class TestNodeResolver : public TestBase {
+public:
+	TestNodeResolver() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestNodeResolver"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testNodeResolving(NodeDefManager *ndef);
+	void testPendingResolveCancellation(NodeDefManager *ndef);
+	void testDirectResolveMethod(NodeDefManager *ndef);
+	void testNoneResolveMethod(NodeDefManager *ndef);
+};
+
+static TestNodeResolver g_test_instance;
+
+void TestNodeResolver::runTests(IGameDef *gamedef)
+{
+	NodeDefManager *ndef =
+		(NodeDefManager *)gamedef->getNodeDefManager();
+
+	ndef->resetNodeResolveState();
+	TEST(testNodeResolving, ndef);
+
+	ndef->resetNodeResolveState();
+	TEST(testPendingResolveCancellation, ndef);
+}
+
+class Foobar : public NodeResolver {
+public:
+	friend class TestNodeResolver; // m_ndef
+
+	void resolveNodeNames();
+
+	content_t test_nr_node1;
+	content_t test_nr_node2;
+	content_t test_nr_node3;
+	content_t test_nr_node4;
+	content_t test_nr_node5;
+	std::vector<content_t> test_nr_list;
+	std::vector<content_t> test_nr_list_group;
+	std::vector<content_t> test_nr_list_required;
+	std::vector<content_t> test_nr_list_empty;
+};
+
+class Foobaz : public NodeResolver {
+public:
+	void resolveNodeNames();
+
+	content_t test_content1;
+	content_t test_content2;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+void Foobar::resolveNodeNames()
+{
+	UASSERT(getIdFromNrBacklog(&test_nr_node1, "", CONTENT_IGNORE) == true);
+	UASSERT(getIdsFromNrBacklog(&test_nr_list) == true);
+	UASSERT(getIdsFromNrBacklog(&test_nr_list_group) == true);
+	UASSERT(getIdsFromNrBacklog(&test_nr_list_required,
+		true, CONTENT_AIR) == false);
+	UASSERT(getIdsFromNrBacklog(&test_nr_list_empty) == true);
+
+	UASSERT(getIdFromNrBacklog(&test_nr_node2, "", CONTENT_IGNORE) == true);
+	UASSERT(getIdFromNrBacklog(&test_nr_node3,
+		"default:brick", CONTENT_IGNORE) == true);
+	UASSERT(getIdFromNrBacklog(&test_nr_node4,
+		"default:gobbledygook", CONTENT_AIR) == false);
+	UASSERT(getIdFromNrBacklog(&test_nr_node5, "", CONTENT_IGNORE) == false);
+}
+
+
+void Foobaz::resolveNodeNames()
+{
+	UASSERT(getIdFromNrBacklog(&test_content1, "", CONTENT_IGNORE) == true);
+	UASSERT(getIdFromNrBacklog(&test_content2, "", CONTENT_IGNORE) == false);
+}
+
+
+void TestNodeResolver::testNodeResolving(NodeDefManager *ndef)
+{
+	Foobar foobar;
+	size_t i;
+
+	foobar.m_nodenames.emplace_back("default:torch");
+
+	foobar.m_nodenames.emplace_back("default:dirt_with_grass");
+	foobar.m_nodenames.emplace_back("default:water");
+	foobar.m_nodenames.emplace_back("default:abloobloobloo");
+	foobar.m_nodenames.emplace_back("default:stone");
+	foobar.m_nodenames.emplace_back("default:shmegoldorf");
+	foobar.m_nnlistsizes.push_back(5);
+
+	foobar.m_nodenames.emplace_back("group:liquids");
+	foobar.m_nnlistsizes.push_back(1);
+
+	foobar.m_nodenames.emplace_back("default:warf");
+	foobar.m_nodenames.emplace_back("default:stone");
+	foobar.m_nodenames.emplace_back("default:bloop");
+	foobar.m_nnlistsizes.push_back(3);
+
+	foobar.m_nnlistsizes.push_back(0);
+
+	foobar.m_nodenames.emplace_back("default:brick");
+	foobar.m_nodenames.emplace_back("default:desert_stone");
+	foobar.m_nodenames.emplace_back("default:shnitzle");
+
+	ndef->pendNodeResolve(&foobar);
+	UASSERT(foobar.m_ndef == ndef);
+
+	ndef->setNodeRegistrationStatus(true);
+	ndef->runNodeResolveCallbacks();
+
+	// Check that we read single nodes successfully
+	UASSERTEQ(content_t, foobar.test_nr_node1, t_CONTENT_TORCH);
+	UASSERTEQ(content_t, foobar.test_nr_node2, t_CONTENT_BRICK);
+	UASSERTEQ(content_t, foobar.test_nr_node3, t_CONTENT_BRICK);
+	UASSERTEQ(content_t, foobar.test_nr_node4, CONTENT_AIR);
+	UASSERTEQ(content_t, foobar.test_nr_node5, CONTENT_IGNORE);
+
+	// Check that we read all the regular list items
+	static const content_t expected_test_nr_list[] = {
+		t_CONTENT_GRASS,
+		t_CONTENT_WATER,
+		t_CONTENT_STONE,
+	};
+	UASSERTEQ(size_t, foobar.test_nr_list.size(), 3);
+	for (i = 0; i != foobar.test_nr_list.size(); i++)
+		UASSERTEQ(content_t, foobar.test_nr_list[i], expected_test_nr_list[i]);
+
+	// Check that we read all the list items that were from a group entry
+	static const content_t expected_test_nr_list_group[] = {
+		t_CONTENT_WATER,
+		t_CONTENT_LAVA,
+	};
+	UASSERTEQ(size_t, foobar.test_nr_list_group.size(), 2);
+	for (i = 0; i != foobar.test_nr_list_group.size(); i++) {
+		UASSERT(CONTAINS(foobar.test_nr_list_group,
+			expected_test_nr_list_group[i]));
+	}
+
+	// Check that we read all the items we're able to in a required list
+	static const content_t expected_test_nr_list_required[] = {
+		CONTENT_AIR,
+		t_CONTENT_STONE,
+		CONTENT_AIR,
+	};
+	UASSERTEQ(size_t, foobar.test_nr_list_required.size(), 3);
+	for (i = 0; i != foobar.test_nr_list_required.size(); i++)
+		UASSERTEQ(content_t, foobar.test_nr_list_required[i],
+			expected_test_nr_list_required[i]);
+
+	// Check that the edge case of 0 is successful
+	UASSERTEQ(size_t, foobar.test_nr_list_empty.size(), 0);
+}
+
+
+void TestNodeResolver::testPendingResolveCancellation(NodeDefManager *ndef)
+{
+	Foobaz foobaz1;
+	foobaz1.test_content1 = 1234;
+	foobaz1.test_content2 = 5678;
+	foobaz1.m_nodenames.emplace_back("default:dirt_with_grass");
+	foobaz1.m_nodenames.emplace_back("default:abloobloobloo");
+	ndef->pendNodeResolve(&foobaz1);
+
+	Foobaz foobaz2;
+	foobaz2.test_content1 = 1234;
+	foobaz2.test_content2 = 5678;
+	foobaz2.m_nodenames.emplace_back("default:dirt_with_grass");
+	foobaz2.m_nodenames.emplace_back("default:abloobloobloo");
+	ndef->pendNodeResolve(&foobaz2);
+
+	ndef->cancelNodeResolveCallback(&foobaz1);
+
+	ndef->setNodeRegistrationStatus(true);
+	ndef->runNodeResolveCallbacks();
+
+	UASSERT(foobaz1.test_content1 == 1234);
+	UASSERT(foobaz1.test_content2 == 5678);
+	UASSERT(foobaz2.test_content1 == t_CONTENT_GRASS);
+	UASSERT(foobaz2.test_content2 == CONTENT_IGNORE);
+}

src/unittest/test_noise.cpp

@@ -0,0 +1,340 @@
+/*
+Minetest
+Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
+
+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
+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 Lesser General Public License for more details.
+
+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 <cmath>
+#include "exceptions.h"
+#include "noise.h"
+
+class TestNoise : public TestBase {
+public:
+	TestNoise() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestNoise"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testNoise2dAtOriginWithZeroSeed();
+	void testNoise2dWithMaxSeed();
+	void testNoise2dWithFunPrimes();
+	void testNoise2dPoint();
+	void testNoise2dBulk();
+	void testNoise3dAtOriginWithZeroSeed();
+	void testNoise3dWithMaxSeed();
+	void testNoise3dWithFunPrimes();
+	void testNoise3dPoint();
+	void testNoise3dBulk();
+	void testNoiseInvalidParams();
+
+	static const float expected_2d_results[10 * 10];
+	static const float expected_3d_results[10 * 10 * 10];
+};
+
+static TestNoise g_test_instance;
+
+void TestNoise::runTests(IGameDef *gamedef)
+{
+	TEST(testNoise2dAtOriginWithZeroSeed);
+	TEST(testNoise2dWithMaxSeed);
+	TEST(testNoise2dWithFunPrimes);
+	TEST(testNoise2dPoint);
+	TEST(testNoise2dBulk);
+	TEST(testNoise3dAtOriginWithZeroSeed);
+	TEST(testNoise3dWithMaxSeed);
+	TEST(testNoise3dWithFunPrimes);
+	TEST(testNoise3dPoint);
+	TEST(testNoise3dBulk);
+	TEST(testNoiseInvalidParams);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestNoise::testNoise2dAtOriginWithZeroSeed()
+{
+	float actual{ noise2d(0, 0, 0) };
+	constexpr float expected{ -0.281791f };
+	UASSERT(std::fabs(actual - expected) <= 0.00001);
+}
+
+void TestNoise::testNoise2dWithMaxSeed()
+{
+	float actual{ noise2d(4096, 4096, 2147483647) };
+	constexpr float expected{ 0.950606f };
+	UASSERT(std::fabs(actual - expected) <= 0.00001);
+}
+
+void TestNoise::testNoise2dWithFunPrimes()
+{
+	float actual{ noise2d(-3947, -2333, 7027) };
+	constexpr float expected{ -0.294907f };
+	UASSERT(std::fabs(actual - expected) <= 0.00001);
+}
+
+void TestNoise::testNoise2dPoint()
+{
+	NoiseParams np_normal(20, 40, v3f(50, 50, 50), 9,  5, 0.6, 2.0);
+
+	u32 i = 0;
+	for (u32 y = 0; y != 10; y++)
+	for (u32 x = 0; x != 10; x++, i++) {
+		float actual   = NoisePerlin2D(&np_normal, x, y, 1337);
+		float expected = expected_2d_results[i];
+		UASSERT(std::fabs(actual - expected) <= 0.00001);
+	}
+}
+
+void TestNoise::testNoise2dBulk()
+{
+	NoiseParams np_normal(20, 40, v3f(50, 50, 50), 9,  5, 0.6, 2.0);
+	Noise noise_normal_2d(&np_normal, 1337, 10, 10);
+	float *noisevals = noise_normal_2d.perlinMap2D(0, 0, NULL);
+
+	for (u32 i = 0; i != 10 * 10; i++) {
+		float actual   = noisevals[i];
+		float expected = expected_2d_results[i];
+		UASSERT(std::fabs(actual - expected) <= 0.00001);
+	}
+}
+
+void TestNoise::testNoise3dAtOriginWithZeroSeed()
+{
+	float actual{ noise2d(0, 0, 0) };
+	constexpr float expected{ -0.281791f };
+	UASSERT(std::fabs(actual - expected) <= 0.00001);
+}
+
+void TestNoise::testNoise3dWithMaxSeed()
+{
+	float actual{ noise3d(4096, 4096, 4096, 2147483647) };
+	constexpr float expected{ -0.775243f };
+	UASSERT(std::fabs(actual - expected) <= 0.00001);
+}
+
+void TestNoise::testNoise3dWithFunPrimes()
+{
+	float actual{ noise2d(3903, -1723, 7411) };
+	constexpr float expected{ 0.989124f };
+	UASSERT(std::fabs(actual - expected) <= 0.00001);
+}
+
+void TestNoise::testNoise3dPoint()
+{
+	NoiseParams np_normal(20, 40, v3f(50, 50, 50), 9,  5, 0.6, 2.0);
+
+	u32 i = 0;
+	for (u32 z = 0; z != 10; z++)
+	for (u32 y = 0; y != 10; y++)
+	for (u32 x = 0; x != 10; x++, i++) {
+		float actual   = NoisePerlin3D(&np_normal, x, y, z, 1337);
+		float expected = expected_3d_results[i];
+		UASSERT(std::fabs(actual - expected) <= 0.00001);
+	}
+}
+
+void TestNoise::testNoise3dBulk()
+{
+	NoiseParams np_normal(20, 40, v3f(50, 50, 50), 9, 5, 0.6, 2.0);
+	Noise noise_normal_3d(&np_normal, 1337, 10, 10, 10);
+	float *noisevals = noise_normal_3d.perlinMap3D(0, 0, 0, NULL);
+
+	for (u32 i = 0; i != 10 * 10 * 10; i++) {
+		float actual   = noisevals[i];
+		float expected = expected_3d_results[i];
+		UASSERT(std::fabs(actual - expected) <= 0.00001);
+	}
+}
+
+void TestNoise::testNoiseInvalidParams()
+{
+	bool exception_thrown = false;
+
+	try {
+		NoiseParams np_highmem(4, 70, v3f(1, 1, 1), 5, 60, 0.7, 10.0);
+		Noise noise_highmem_3d(&np_highmem, 1337, 200, 200, 200);
+		noise_highmem_3d.perlinMap3D(0, 0, 0, NULL);
+	} catch (InvalidNoiseParamsException &) {
+		exception_thrown = true;
+	}
+
+	UASSERT(exception_thrown);
+}
+
+const float TestNoise::expected_2d_results[10 * 10] = {
+	19.11726, 18.49626, 16.48476, 15.02135, 14.75713, 16.26008, 17.54822,
+	18.06860, 18.57016, 18.48407, 18.49649, 17.89160, 15.94162, 14.54901,
+	14.31298, 15.72643, 16.94669, 17.55494, 18.58796, 18.87925, 16.08101,
+	15.53764, 13.83844, 12.77139, 12.73648, 13.95632, 14.97904, 15.81829,
+	18.37694, 19.73759, 13.19182, 12.71924, 11.34560, 10.78025, 11.18980,
+	12.52303, 13.45012, 14.30001, 17.43298, 19.15244, 10.93217, 10.48625,
+	 9.30923,  9.18632, 10.16251, 12.11264, 13.19697, 13.80801, 16.39567,
+	17.66203, 10.40222,  9.86070,  8.47223,  8.45471, 10.04780, 13.54730,
+	15.33709, 15.48503, 16.46177, 16.52508, 10.80333, 10.19045,  8.59420,
+	 8.47646, 10.22676, 14.43173, 16.48353, 16.24859, 16.20863, 15.52847,
+	11.01179, 10.45209,  8.98678,  8.83986, 10.43004, 14.46054, 16.29387,
+	15.73521, 15.01744, 13.85542, 10.55201, 10.33375,  9.85102, 10.07821,
+	11.58235, 15.62046, 17.35505, 16.13181, 12.66011,  9.51853, 11.50994,
+	11.54074, 11.77989, 12.29790, 13.76139, 17.81982, 19.49008, 17.79470,
+	12.34344,  7.78363,
+};
+
+const float TestNoise::expected_3d_results[10 * 10 * 10] = {
+	19.11726, 18.01059, 16.90392, 15.79725, 16.37154, 17.18597, 18.00040,
+	18.33467, 18.50889, 18.68311, 17.85386, 16.90585, 15.95785, 15.00985,
+	15.61132, 16.43415, 17.25697, 17.95415, 18.60942, 19.26471, 16.59046,
+	15.80112, 15.01178, 14.22244, 14.85110, 15.68232, 16.51355, 17.57361,
+	18.70996, 19.84631, 15.32705, 14.69638, 14.06571, 13.43504, 14.09087,
+	14.93050, 15.77012, 17.19309, 18.81050, 20.42790, 15.06729, 14.45855,
+	13.84981, 13.24107, 14.39364, 15.79782, 17.20201, 18.42640, 19.59085,
+	20.75530, 14.95090, 14.34456, 13.73821, 13.13187, 14.84825, 16.89645,
+	18.94465, 19.89025, 20.46832, 21.04639, 14.83452, 14.23057, 13.62662,
+	13.02267, 15.30287, 17.99508, 20.68730, 21.35411, 21.34580, 21.33748,
+	15.39817, 15.03590, 14.67364, 14.31137, 16.78242, 19.65824, 22.53405,
+	22.54626, 21.60395, 20.66164, 16.18850, 16.14768, 16.10686, 16.06603,
+	18.60362, 21.50956, 24.41549, 23.64784, 21.65566, 19.66349, 16.97884,
+	17.25946, 17.54008, 17.82069, 20.42482, 23.36088, 26.29694, 24.74942,
+	21.70738, 18.66534, 18.78506, 17.51834, 16.25162, 14.98489, 15.14217,
+	15.50287, 15.86357, 16.40597, 17.00895, 17.61193, 18.20160, 16.98795,
+	15.77430, 14.56065, 14.85059, 15.35533, 15.86007, 16.63399, 17.49763,
+	18.36128, 17.61814, 16.45757, 15.29699, 14.13641, 14.55902, 15.20779,
+	15.85657, 16.86200, 17.98632, 19.11064, 17.03468, 15.92718, 14.81968,
+	13.71218, 14.26744, 15.06026, 15.85306, 17.09001, 18.47501, 19.86000,
+	16.67870, 15.86256, 15.04641, 14.23026, 15.31397, 16.66909, 18.02420,
+	18.89042, 19.59369, 20.29695, 16.35522, 15.86447, 15.37372, 14.88297,
+	16.55165, 18.52883, 20.50600, 20.91547, 20.80237, 20.68927, 16.03174,
+	15.86639, 15.70103, 15.53568, 17.78933, 20.38857, 22.98780, 22.94051,
+	22.01105, 21.08159, 16.42434, 16.61407, 16.80381, 16.99355, 19.16133,
+	21.61169, 24.06204, 23.65252, 22.28970, 20.92689, 17.05562, 17.61035,
+	18.16508, 18.71981, 20.57809, 22.62260, 24.66711, 23.92686, 22.25835,
+	20.58984, 17.68691, 18.60663, 19.52635, 20.44607, 21.99486, 23.63352,
+	25.27217, 24.20119, 22.22699, 20.25279, 18.45285, 17.02608, 15.59931,
+	14.17254, 13.91279, 13.81976, 13.72674, 14.47727, 15.50900, 16.54073,
+	18.54934, 17.07005, 15.59076, 14.11146, 14.08987, 14.27651, 14.46316,
+	15.31383, 16.38584, 17.45785, 18.64582, 17.11401, 15.58220, 14.05039,
+	14.26694, 14.73326, 15.19958, 16.15038, 17.26268, 18.37498, 18.74231,
+	17.15798, 15.57364, 13.98932, 14.44402, 15.19001, 15.93600, 16.98694,
+	18.13952, 19.29210, 18.29012, 17.26656, 16.24301, 15.21946, 16.23430,
+	17.54035, 18.84639, 19.35445, 19.59653, 19.83860, 17.75954, 17.38438,
+	17.00923, 16.63407, 18.25505, 20.16120, 22.06734, 21.94068, 21.13642,
+	20.33215, 17.22896, 17.50220, 17.77544, 18.04868, 20.27580, 22.78205,
+	25.28829, 24.52691, 22.67631, 20.82571, 17.45050, 18.19224, 18.93398,
+	19.67573, 21.54024, 23.56514, 25.59004, 24.75878, 22.97546, 21.19213,
+	17.92274, 19.07302, 20.22330, 21.37358, 22.55256, 23.73565, 24.91873,
+	24.20587, 22.86103, 21.51619, 18.39499, 19.95381, 21.51263, 23.07145,
+	23.56490, 23.90615, 24.24741, 23.65296, 22.74660, 21.84024, 18.12065,
+	16.53382, 14.94700, 13.36018, 12.68341, 12.13666, 11.58990, 12.54858,
+	14.00906, 15.46955, 18.89708, 17.15214, 15.40721, 13.66227, 13.32914,
+	13.19769, 13.06625, 13.99367, 15.27405, 16.55443, 19.67351, 17.77046,
+	15.86741, 13.96436, 13.97486, 14.25873, 14.54260, 15.43877, 16.53904,
+	17.63931, 20.44994, 18.38877, 16.32761, 14.26645, 14.62059, 15.31977,
+	16.01895, 16.88387, 17.80403, 18.72419, 19.90153, 18.67057, 17.43962,
+	16.20866, 17.15464, 18.41161, 19.66858, 19.81848, 19.59936, 19.38024,
+	19.16386, 18.90429, 18.64473, 18.38517, 19.95845, 21.79357, 23.62868,
+	22.96589, 21.47046, 19.97503, 18.42618, 19.13802, 19.84985, 20.56168,
+	22.76226, 25.17553, 27.58879, 26.11330, 23.34156, 20.56982, 18.47667,
+	19.77041, 21.06416, 22.35790, 23.91914, 25.51859, 27.11804, 25.86504,
+	23.66121, 21.45738, 18.78986, 20.53570, 22.28153, 24.02736, 24.52704,
+	24.84869, 25.17035, 24.48488, 23.46371, 22.44254, 19.10306, 21.30098,
+	23.49890, 25.69682, 25.13494, 24.17879, 23.22265, 23.10473, 23.26621,
+	23.42769, 17.93453, 16.72707, 15.51962, 14.31216, 12.96039, 11.58800,
+	10.21561, 11.29675, 13.19573, 15.09471, 18.05853, 16.85308, 15.64762,
+	14.44216, 13.72634, 13.08047, 12.43459, 13.48912, 15.11045, 16.73179,
+	18.18253, 16.97908, 15.77562, 14.57217, 14.49229, 14.57293, 14.65357,
+	15.68150, 17.02518, 18.36887, 18.30654, 17.10508, 15.90363, 14.70217,
+	15.25825, 16.06540, 16.87255, 17.87387, 18.93991, 20.00595, 17.54117,
+	17.32369, 17.10622, 16.88875, 18.07494, 19.46166, 20.84837, 21.12988,
+	21.04298, 20.95609, 16.64874, 17.55554, 18.46234, 19.36913, 21.18461,
+	23.12989, 25.07517, 24.53784, 23.17297, 21.80810, 15.75632, 17.78738,
+	19.81845, 21.84951, 24.29427, 26.79812, 29.30198, 27.94580, 25.30295,
+	22.66010, 15.98046, 18.43027, 20.88008, 23.32989, 25.21976, 27.02964,
+	28.83951, 27.75863, 25.71416, 23.66970, 16.57679, 19.21017, 21.84355,
+	24.47693, 25.41719, 26.11557, 26.81396, 26.37308, 25.55245, 24.73182,
+	17.17313, 19.99008, 22.80702, 25.62397, 25.61462, 25.20151, 24.78840,
+	24.98753, 25.39074, 25.79395, 17.76927, 17.01824, 16.26722, 15.51620,
+	13.45256, 11.20141,  8.95025, 10.14162, 12.48049, 14.81936, 17.05051,
+	16.49955, 15.94860, 15.39764, 14.28896, 13.10061, 11.91225, 13.10109,
+	15.08232, 17.06355, 16.33175, 15.98086, 15.62998, 15.27909, 15.12537,
+	14.99981, 14.87425, 16.06056, 17.68415, 19.30775, 15.61299, 15.46217,
+	15.31136, 15.16054, 15.96177, 16.89901, 17.83625, 19.02003, 20.28599,
+	21.55194, 14.61341, 15.58383, 16.55426, 17.52469, 18.99524, 20.53725,
+	22.07925, 22.56233, 22.69243, 22.82254, 13.57371, 15.79697, 18.02024,
+	20.24351, 22.34258, 24.42392, 26.50526, 26.18790, 25.07097, 23.95404,
+	12.53401, 16.01011, 19.48622, 22.96232, 25.68993, 28.31060, 30.93126,
+	29.81347, 27.44951, 25.08555, 12.98106, 16.67323, 20.36540, 24.05756,
+	26.36633, 28.47748, 30.58862, 29.76471, 27.96244, 26.16016, 13.92370,
+	17.48634, 21.04897, 24.61161, 26.15244, 27.40443, 28.65643, 28.49117,
+	27.85349, 27.21581, 14.86633, 18.29944, 21.73255, 25.16566, 25.93854,
+	26.33138, 26.72423, 27.21763, 27.74455, 28.27147, 17.60401, 17.30942,
+	17.01482, 16.72023, 13.94473, 10.81481,  7.68490,  8.98648, 11.76524,
+	14.54400, 16.04249, 16.14603, 16.24958, 16.35312, 14.85158, 13.12075,
+	11.38991, 12.71305, 15.05418, 17.39531, 14.48097, 14.98265, 15.48433,
+	15.98602, 15.75844, 15.42668, 15.09493, 16.43962, 18.34312, 20.24663,
+	12.91945, 13.81927, 14.71909, 15.61891, 16.66530, 17.73262, 18.79995,
+	20.16619, 21.63206, 23.09794, 11.68565, 13.84398, 16.00230, 18.16062,
+	19.91554, 21.61284, 23.31013, 23.99478, 24.34188, 24.68898, 10.49868,
+	14.03841, 17.57814, 21.11788, 23.50056, 25.71795, 27.93534, 27.83796,
+	26.96897, 26.09999,  9.31170, 14.23284, 19.15399, 24.07513, 27.08558,
+	29.82307, 32.56055, 31.68113, 29.59606, 27.51099,  9.98166, 14.91619,
+	19.85071, 24.78524, 27.51291, 29.92532, 32.33773, 31.77077, 30.21070,
+	28.65063, 11.27060, 15.76250, 20.25440, 24.74629, 26.88768, 28.69329,
+	30.49889, 30.60925, 30.15453, 29.69981, 12.55955, 16.60881, 20.65808,
+	24.70735, 26.26245, 27.46126, 28.66005, 29.44773, 30.09835, 30.74898,
+	15.20134, 15.53016, 15.85898, 16.18780, 13.53087, 10.44740,  7.36393,
+	 8.95806, 12.11139, 15.26472, 13.87432, 14.52378, 15.17325, 15.82272,
+	14.49093, 12.87611, 11.26130, 12.73342, 15.23453, 17.73563, 12.54730,
+	13.51741, 14.48752, 15.45763, 15.45100, 15.30483, 15.15867, 16.50878,
+	18.35766, 20.20654, 11.22027, 12.51103, 13.80179, 15.09254, 16.41106,
+	17.73355, 19.05603, 20.28415, 21.48080, 22.67745, 10.27070, 12.53633,
+	14.80195, 17.06758, 19.04654, 20.98454, 22.92254, 23.63840, 23.94687,
+	24.25534,  9.37505, 12.70901, 16.04297, 19.37693, 21.92136, 24.35300,
+	26.78465, 26.93249, 26.31907, 25.70565,  8.47939, 12.88168, 17.28398,
+	21.68627, 24.79618, 27.72146, 30.64674, 30.22658, 28.69127, 27.15597,
+	 9.77979, 13.97583, 18.17186, 22.36790, 25.18828, 27.81215, 30.43601,
+	30.34293, 29.34420, 28.34548, 11.81220, 15.37712, 18.94204, 22.50695,
+	24.75282, 26.81024, 28.86766, 29.40003, 29.42404, 29.44806, 13.84461,
+	16.77841, 19.71221, 22.64601, 24.31735, 25.80833, 27.29932, 28.45713,
+	29.50388, 30.55064, 12.05287, 13.06077, 14.06866, 15.07656, 12.81500,
+	10.08638,  7.35776,  9.30520, 12.81134, 16.31747, 11.31943, 12.47863,
+	13.63782, 14.79702, 13.82253, 12.54323, 11.26392, 12.88993, 15.48436,
+	18.07880, 10.58600, 11.89649, 13.20698, 14.51747, 14.83005, 15.00007,
+	15.17009, 16.47465, 18.15739, 19.84013,  9.85256, 11.31435, 12.77614,
+	14.23793, 15.83757, 17.45691, 19.07625, 20.05937, 20.83042, 21.60147,
+	 9.36002, 11.37275, 13.38548, 15.39822, 17.58109, 19.78828, 21.99546,
+	22.68573, 22.87036, 23.05500,  8.90189, 11.52266, 14.14343, 16.76420,
+	19.42976, 22.10172, 24.77368, 25.17519, 24.81987, 24.46455,  8.44375,
+	11.67256, 14.90137, 18.13018, 21.27843, 24.41516, 27.55190, 27.66464,
+	26.76937, 25.87411, 10.51042, 13.30769, 16.10496, 18.90222, 21.70659,
+	24.51197, 27.31734, 27.77045, 27.43945, 27.10846, 13.41869, 15.43789,
+	17.45709, 19.47628, 21.66124, 23.86989, 26.07853, 27.08170, 27.68305,
+	28.28440, 16.32697, 17.56809, 18.80922, 20.05033, 21.61590, 23.22781,
+	24.83972, 26.39296, 27.92665, 29.46033,  8.90439, 10.59137, 12.27835,
+	13.96532, 12.09914,  9.72536,  7.35159,  9.65235, 13.51128, 17.37022,
+	 8.76455, 10.43347, 12.10239, 13.77132, 13.15412, 12.21033, 11.26655,
+	13.04643, 15.73420, 18.42198,  8.62470, 10.27557, 11.92644, 13.57731,
+	14.20910, 14.69531, 15.18151, 16.44051, 17.95712, 19.47373,  8.48485,
+	10.11767, 11.75049, 13.38331, 15.26408, 17.18027, 19.09647, 19.83460,
+	20.18004, 20.52548,  8.44933, 10.20917, 11.96901, 13.72885, 16.11565,
+	18.59202, 21.06838, 21.73307, 21.79386, 21.85465,  8.42872, 10.33631,
+	12.24389, 14.15147, 16.93816, 19.85044, 22.76272, 23.41788, 23.32067,
+	23.22346,  8.40812, 10.46344, 12.51877, 14.57409, 17.76068, 21.10886,
+	24.45705, 25.10269, 24.84748, 24.59226, 11.24106, 12.63955, 14.03805,
+	15.43654, 18.22489, 21.21178, 24.19868, 25.19796, 25.53469, 25.87143,
+	15.02519, 15.49866, 15.97213, 16.44560, 18.56967, 20.92953, 23.28940,
+	24.76337, 25.94205, 27.12073, 18.80933, 18.35777, 17.90622, 17.45466,
+	18.91445, 20.64729, 22.38013, 24.32880, 26.34941, 28.37003,
+};

src/unittest/test_objdef.cpp

@@ -0,0 +1,174 @@
+/*
+Minetest
+Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
+
+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
+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 Lesser General Public License for more details.
+
+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 "exceptions.h"
+#include "objdef.h"
+
+class TestObjDef : public TestBase
+{
+public:
+	TestObjDef() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestObjDef"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testHandles();
+	void testAddGetSetClear();
+	void testClone();
+};
+
+static TestObjDef g_test_instance;
+
+void TestObjDef::runTests(IGameDef *gamedef)
+{
+	TEST(testHandles);
+	TEST(testAddGetSetClear);
+	TEST(testClone);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/* Minimal implementation of ObjDef and ObjDefManager subclass */
+
+class MyObjDef : public ObjDef
+{
+public:
+	ObjDef *clone() const
+	{
+		auto def = new MyObjDef();
+		ObjDef::cloneTo(def);
+		def->testvalue = testvalue;
+		return def;
+	};
+
+	u32 testvalue;
+};
+
+class MyObjDefManager : public ObjDefManager
+{
+public:
+	MyObjDefManager(ObjDefType type) : ObjDefManager(NULL, type){};
+	MyObjDefManager *clone() const
+	{
+		auto mgr = new MyObjDefManager();
+		ObjDefManager::cloneTo(mgr);
+		return mgr;
+	};
+
+protected:
+	MyObjDefManager(){};
+};
+
+void TestObjDef::testHandles()
+{
+	u32 uid = 0;
+	u32 index = 0;
+	ObjDefType type = OBJDEF_GENERIC;
+
+	ObjDefHandle handle = ObjDefManager::createHandle(9530, OBJDEF_ORE, 47);
+
+	UASSERTEQ(ObjDefHandle, 0xAF507B55, handle);
+
+	UASSERT(ObjDefManager::decodeHandle(handle, &index, &type, &uid));
+
+	UASSERTEQ(u32, 9530, index);
+	UASSERTEQ(u32, 47, uid);
+	UASSERTEQ(ObjDefHandle, OBJDEF_ORE, type);
+}
+
+void TestObjDef::testAddGetSetClear()
+{
+	ObjDefManager testmgr(NULL, OBJDEF_GENERIC);
+	ObjDefHandle hObj0, hObj1, hObj2, hObj3;
+	ObjDef *obj0, *obj1, *obj2, *obj3;
+
+	UASSERTEQ(ObjDefType, testmgr.getType(), OBJDEF_GENERIC);
+
+	obj0 = new MyObjDef;
+	obj0->name = "foobar";
+	hObj0 = testmgr.add(obj0);
+	UASSERT(hObj0 != OBJDEF_INVALID_HANDLE);
+	UASSERTEQ(u32, obj0->index, 0);
+
+	obj1 = new MyObjDef;
+	obj1->name = "FooBaz";
+	hObj1 = testmgr.add(obj1);
+	UASSERT(hObj1 != OBJDEF_INVALID_HANDLE);
+	UASSERTEQ(u32, obj1->index, 1);
+
+	obj2 = new MyObjDef;
+	obj2->name = "asdf";
+	hObj2 = testmgr.add(obj2);
+	UASSERT(hObj2 != OBJDEF_INVALID_HANDLE);
+	UASSERTEQ(u32, obj2->index, 2);
+
+	obj3 = new MyObjDef;
+	obj3->name = "foobaz";
+	hObj3 = testmgr.add(obj3);
+	UASSERT(hObj3 == OBJDEF_INVALID_HANDLE);
+
+	UASSERTEQ(size_t, testmgr.getNumObjects(), 3);
+
+	UASSERT(testmgr.get(hObj0) == obj0);
+	UASSERT(testmgr.getByName("FOOBAZ") == obj1);
+
+	UASSERT(testmgr.set(hObj0, obj3) == obj0);
+	UASSERT(testmgr.get(hObj0) == obj3);
+	delete obj0;
+
+	testmgr.clear();
+	UASSERTEQ(size_t, testmgr.getNumObjects(), 0);
+}
+
+void TestObjDef::testClone()
+{
+	MyObjDefManager testmgr(OBJDEF_GENERIC);
+	ObjDefManager *mgrcopy;
+	MyObjDef *obj, *temp2;
+	ObjDef *temp1;
+	ObjDefHandle hObj;
+
+	obj = new MyObjDef;
+	obj->testvalue = 0xee00ff11;
+	hObj = testmgr.add(obj);
+	UASSERT(hObj != OBJDEF_INVALID_HANDLE);
+
+	mgrcopy = testmgr.clone();
+	UASSERT(mgrcopy);
+	UASSERTEQ(ObjDefType, mgrcopy->getType(), testmgr.getType());
+	UASSERTEQ(size_t, mgrcopy->getNumObjects(), testmgr.getNumObjects());
+
+	// 1) check that the same handle is still valid on the copy
+	temp1 = mgrcopy->get(hObj);
+	UASSERT(temp1);
+	UASSERT(temp1 == mgrcopy->getRaw(0));
+	// 2) check that the copy has the correct C++ class
+	temp2 = dynamic_cast<MyObjDef *>(temp1);
+	UASSERT(temp2);
+	// 3) check that it was correctly copied
+	UASSERTEQ(u32, obj->testvalue, temp2->testvalue);
+	// 4) check that it was copied AT ALL (not the same)
+	UASSERT(obj != temp2);
+
+	testmgr.clear();
+	mgrcopy->clear();
+	delete mgrcopy;
+}

src/unittest/test_profiler.cpp

@@ -0,0 +1,73 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "profiler.h"
+
+class TestProfiler : public TestBase
+{
+public:
+	TestProfiler() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestProfiler"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testProfilerAverage();
+};
+
+static TestProfiler g_test_instance;
+
+void TestProfiler::runTests(IGameDef *gamedef)
+{
+	TEST(testProfilerAverage);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestProfiler::testProfilerAverage()
+{
+	Profiler p;
+
+	p.avg("Test1", 1.f);
+	UASSERT(p.getValue("Test1") == 1.f);
+
+	p.avg("Test1", 2.f);
+	UASSERT(p.getValue("Test1") == 1.5f);
+
+	p.avg("Test1", 3.f);
+	UASSERT(p.getValue("Test1") == 2.f);
+
+	p.avg("Test1", 486.f);
+	UASSERT(p.getValue("Test1") == 123.f);
+
+	p.avg("Test1", 8);
+	UASSERT(p.getValue("Test1") == 100.f);
+
+	p.avg("Test1", 700);
+	UASSERT(p.getValue("Test1") == 200.f);
+
+	p.avg("Test1", 10000);
+	UASSERT(p.getValue("Test1") == 1600.f);
+
+	p.avg("Test2", 123.56);
+	p.avg("Test2", 123.58);
+
+	UASSERT(p.getValue("Test2") == 123.57f);
+}

src/unittest/test_random.cpp

@@ -0,0 +1,275 @@
+ /*
+Minetest
+Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
+
+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
+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 Lesser General Public License for more details.
+
+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 <cmath>
+#include "util/numeric.h"
+#include "exceptions.h"
+#include "noise.h"
+
+class TestRandom : public TestBase {
+public:
+	TestRandom() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestRandom"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testPseudoRandom();
+	void testPseudoRandomRange();
+	void testPcgRandom();
+	void testPcgRandomRange();
+	void testPcgRandomBytes();
+	void testPcgRandomNormalDist();
+
+	static const int expected_pseudorandom_results[256];
+	static const u32 expected_pcgrandom_results[256];
+	static const u8 expected_pcgrandom_bytes_result[24];
+	static const u8 expected_pcgrandom_bytes_result2[24];
+};
+
+static TestRandom g_test_instance;
+
+void TestRandom::runTests(IGameDef *gamedef)
+{
+	TEST(testPseudoRandom);
+	TEST(testPseudoRandomRange);
+	TEST(testPcgRandom);
+	TEST(testPcgRandomRange);
+	TEST(testPcgRandomBytes);
+	TEST(testPcgRandomNormalDist);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestRandom::testPseudoRandom()
+{
+	PseudoRandom pr(814538);
+
+	for (u32 i = 0; i != 256; i++)
+		UASSERTEQ(int, pr.next(), expected_pseudorandom_results[i]);
+}
+
+
+void TestRandom::testPseudoRandomRange()
+{
+	PseudoRandom pr((int)time(NULL));
+
+	EXCEPTION_CHECK(PrngException, pr.range(2000, 6000));
+	EXCEPTION_CHECK(PrngException, pr.range(5, 1));
+
+	for (u32 i = 0; i != 32768; i++) {
+		int min = (pr.next() % 3000) - 500;
+		int max = (pr.next() % 3000) - 500;
+		if (min > max)
+			SWAP(int, min, max);
+
+		int randval = pr.range(min, max);
+		UASSERT(randval >= min);
+		UASSERT(randval <= max);
+	}
+}
+
+
+void TestRandom::testPcgRandom()
+{
+	PcgRandom pr(814538, 998877);
+
+	for (u32 i = 0; i != 256; i++)
+		UASSERTEQ(u32, pr.next(), expected_pcgrandom_results[i]);
+}
+
+
+void TestRandom::testPcgRandomRange()
+{
+	PcgRandom pr((int)time(NULL));
+
+	EXCEPTION_CHECK(PrngException, pr.range(5, 1));
+
+	// Regression test for bug 3027
+	pr.range(pr.RANDOM_MIN, pr.RANDOM_MAX);
+
+	for (u32 i = 0; i != 32768; i++) {
+		int min = (pr.next() % 3000) - 500;
+		int max = (pr.next() % 3000) - 500;
+		if (min > max)
+			SWAP(int, min, max);
+
+		int randval = pr.range(min, max);
+		UASSERT(randval >= min);
+		UASSERT(randval <= max);
+	}
+}
+
+
+void TestRandom::testPcgRandomBytes()
+{
+	char buf[32];
+	PcgRandom r(1538, 877);
+
+	memset(buf, 0, sizeof(buf));
+	r.bytes(buf + 5, 23);
+	UASSERT(memcmp(buf + 5, expected_pcgrandom_bytes_result,
+		sizeof(expected_pcgrandom_bytes_result)) == 0);
+
+	memset(buf, 0, sizeof(buf));
+	r.bytes(buf, 17);
+	UASSERT(memcmp(buf, expected_pcgrandom_bytes_result2,
+		sizeof(expected_pcgrandom_bytes_result2)) == 0);
+}
+
+
+void TestRandom::testPcgRandomNormalDist()
+{
+	static const int max = 120;
+	static const int min = -120;
+	static const int num_trials = 20;
+	static const u32 num_samples = 61000;
+	s32 bins[max - min + 1];
+	memset(bins, 0, sizeof(bins));
+
+	PcgRandom r(486179 + (int)time(NULL));
+
+	for (u32 i = 0; i != num_samples; i++) {
+		s32 randval = r.randNormalDist(min, max, num_trials);
+		UASSERT(randval <= max);
+		UASSERT(randval >= min);
+		bins[randval - min]++;
+	}
+
+	// Note that here we divide variance by the number of trials;
+	// this is because variance is a biased estimator.
+	int range      = (max - min + 1);
+	float mean     = (max + min) / 2;
+	float variance = ((range * range - 1) / 12) / num_trials;
+	float stddev   = std::sqrt(variance);
+
+	static const float prediction_intervals[] = {
+		0.68269f, // 1.0
+		0.86639f, // 1.5
+		0.95450f, // 2.0
+		0.98758f, // 2.5
+		0.99730f, // 3.0
+	};
+
+	//// Simple normality test using the 68-95-99.7% rule
+	for (u32 i = 0; i != ARRLEN(prediction_intervals); i++) {
+		float deviations = i / 2.f + 1.f;
+		int lbound = myround(mean - deviations * stddev);
+		int ubound = myround(mean + deviations * stddev);
+		UASSERT(lbound >= min);
+		UASSERT(ubound <= max);
+
+		int accum = 0;
+		for (int j = lbound; j != ubound; j++)
+			accum += bins[j - min];
+
+		float actual = (float)accum / num_samples;
+		UASSERT(std::fabs(actual - prediction_intervals[i]) < 0.02f);
+	}
+}
+
+
+const int TestRandom::expected_pseudorandom_results[256] = {
+	0x02fa, 0x60d5, 0x6c10, 0x606b, 0x098b, 0x5f1e, 0x4f56, 0x3fbd, 0x77af,
+	0x4fe9, 0x419a, 0x6fe1, 0x177b, 0x6858, 0x36f8, 0x6d83, 0x14fc, 0x2d62,
+	0x1077, 0x23e2, 0x041b, 0x7a7e, 0x5b52, 0x215d, 0x682b, 0x4716, 0x47e3,
+	0x08c0, 0x1952, 0x56ae, 0x146d, 0x4b4f, 0x239f, 0x3fd0, 0x6794, 0x7796,
+	0x7be2, 0x75b7, 0x5691, 0x28ee, 0x2656, 0x40c0, 0x133c, 0x63cd, 0x2aeb,
+	0x518f, 0x7dbc, 0x6ad8, 0x736e, 0x5b05, 0x160b, 0x589f, 0x6f64, 0x5edc,
+	0x092c, 0x0a39, 0x199e, 0x1927, 0x562b, 0x2689, 0x3ba3, 0x366f, 0x46da,
+	0x4e49, 0x0abb, 0x40a1, 0x3846, 0x40db, 0x7adb, 0x6ec1, 0x6efa, 0x01cc,
+	0x6335, 0x4352, 0x72fb, 0x4b2d, 0x509a, 0x257e, 0x2f7d, 0x5891, 0x2195,
+	0x6107, 0x5269, 0x56e3, 0x4849, 0x38f7, 0x2791, 0x04f2, 0x4e05, 0x78ff,
+	0x6bae, 0x50b3, 0x74ad, 0x31af, 0x531e, 0x7d56, 0x11c9, 0x0b5e, 0x405e,
+	0x1e15, 0x7f6a, 0x5bd3, 0x6649, 0x71b4, 0x3ec2, 0x6ab4, 0x520e, 0x6ad6,
+	0x287e, 0x10b8, 0x18f2, 0x7107, 0x46ea, 0x1d85, 0x25cc, 0x2689, 0x35c1,
+	0x3065, 0x6237, 0x3edd, 0x23d9, 0x6fb5, 0x37a1, 0x3211, 0x526a, 0x4b09,
+	0x23f1, 0x58cc, 0x2e42, 0x341f, 0x5e16, 0x3d1a, 0x5e8c, 0x7a82, 0x4635,
+	0x2bf8, 0x6577, 0x3603, 0x1daf, 0x539f, 0x2e91, 0x6bd8, 0x42d3, 0x7a93,
+	0x26e3, 0x5a91, 0x6c67, 0x1b66, 0x3ac7, 0x18bf, 0x20d8, 0x7153, 0x558d,
+	0x7262, 0x653d, 0x417d, 0x3ed3, 0x3117, 0x600d, 0x6d04, 0x719c, 0x3afd,
+	0x6ba5, 0x17c5, 0x4935, 0x346c, 0x5479, 0x6ff6, 0x1fcc, 0x1054, 0x3f14,
+	0x6266, 0x3acc, 0x3b77, 0x71d8, 0x478b, 0x20fa, 0x4e46, 0x7e77, 0x5554,
+	0x3652, 0x719c, 0x072b, 0x61ad, 0x399f, 0x621d, 0x1bba, 0x41d0, 0x7fdc,
+	0x3e6c, 0x6a2a, 0x5253, 0x094e, 0x0c10, 0x3f43, 0x73eb, 0x4c5f, 0x1f23,
+	0x12c9, 0x0902, 0x5238, 0x50c0, 0x1b77, 0x3ffd, 0x0124, 0x302a, 0x26b9,
+	0x3648, 0x30a6, 0x1abc, 0x3031, 0x4029, 0x6358, 0x6696, 0x74e8, 0x6142,
+	0x4284, 0x0c00, 0x7e50, 0x41e3, 0x3782, 0x79a5, 0x60fe, 0x2d15, 0x3ed2,
+	0x7f70, 0x2b27, 0x6366, 0x5100, 0x7c44, 0x3ee0, 0x4e76, 0x7d34, 0x3a60,
+	0x140e, 0x613d, 0x1193, 0x268d, 0x1e2f, 0x3123, 0x6d61, 0x4e0b, 0x51ce,
+	0x13bf, 0x58d4, 0x4f43, 0x05c6, 0x4d6a, 0x7eb5, 0x2921, 0x2c36, 0x1c89,
+	0x63b9, 0x1555, 0x1f41, 0x2d9f,
+};
+
+const u32 TestRandom::expected_pcgrandom_results[256] = {
+	0x48c593f8, 0x054f59f5, 0x0d062dc1, 0x23852a23, 0x7fbbc97b, 0x1f9f141e,
+	0x364e6ed8, 0x995bba58, 0xc9307dc0, 0x73fb34c4, 0xcd8de88d, 0x52e8ce08,
+	0x1c4a78e4, 0x25c0882e, 0x8a82e2e0, 0xe3bc3311, 0xb8068d42, 0x73186110,
+	0x19988df4, 0x69bd970b, 0x7214728c, 0x0aee320c, 0x2a5a536c, 0xaf48d715,
+	0x00bce504, 0xd2b8f548, 0x520df366, 0x96d8fff5, 0xa1bb510b, 0x63477049,
+	0xb85990b7, 0x7e090689, 0x275fb468, 0x50206257, 0x8bab4f8a, 0x0d6823db,
+	0x63faeaac, 0x2d92deeb, 0x2ba78024, 0x0d30f631, 0x338923a0, 0xd07248d8,
+	0xa5db62d3, 0xddba8af6, 0x0ad454e9, 0x6f0fd13a, 0xbbfde2bf, 0x91188009,
+	0x966b394d, 0xbb9d2012, 0x7e6926cb, 0x95183860, 0x5ff4c59b, 0x035f628a,
+	0xb67085ef, 0x33867e23, 0x68d1b887, 0x2e3298d7, 0x84fd0650, 0x8bc91141,
+	0x6fcb0452, 0x2836fee9, 0x2e83c0a3, 0xf1bafdc5, 0x9ff77777, 0xfdfbba87,
+	0x527aebeb, 0x423e5248, 0xd1756490, 0xe41148fa, 0x3361f7b4, 0xa2824f23,
+	0xf4e08072, 0xc50442be, 0x35adcc21, 0x36be153c, 0xc7709012, 0xf0eeb9f2,
+	0x3d73114e, 0x1c1574ee, 0x92095b9c, 0x1503d01c, 0xd6ce0677, 0x026a8ec1,
+	0x76d0084d, 0x86c23633, 0x36f75ce6, 0x08fa7bbe, 0x35f6ff2a, 0x31cc9525,
+	0x2c1a35e6, 0x8effcd62, 0xc782fa07, 0x8a86e248, 0x8fdb7a9b, 0x77246626,
+	0x5767723f, 0x3a78b699, 0xe548ce1c, 0x5820f37d, 0x148ed9b8, 0xf6796254,
+	0x32232c20, 0x392bf3a2, 0xe9af6625, 0xd40b0d88, 0x636cfa23, 0x6a5de514,
+	0xc4a69183, 0xc785c853, 0xab0de901, 0x16ae7e44, 0x376f13b5, 0x070f7f31,
+	0x34cbc93b, 0xe6184345, 0x1b7f911f, 0x631fbe4b, 0x86d6e023, 0xc689b518,
+	0x88ef4f7c, 0xddf06b45, 0xc97f18d4, 0x2aaee94b, 0x45694723, 0x6db111d2,
+	0x91974fce, 0xe33e29e2, 0xc5e99494, 0x8017e02b, 0x3ebd8143, 0x471ffb80,
+	0xc0d7ca1b, 0x4954c860, 0x48935d6a, 0xf2d27999, 0xb93d608d, 0x40696e90,
+	0x60b18162, 0x1a156998, 0x09b8bbab, 0xc80a79b6, 0x8adbcfbc, 0xc375248c,
+	0xa584e2ea, 0x5b46fe11, 0x58e84680, 0x8a8bc456, 0xd668b94f, 0x8b9035be,
+	0x278509d4, 0x6663a140, 0x81a9817a, 0xd4f9d3cf, 0x6dc5f607, 0x6ae04450,
+	0x694f22a4, 0x1d061788, 0x2e39ad8b, 0x748f4db2, 0xee569b52, 0xd157166d,
+	0xdabc161e, 0xc8d50176, 0x7e3110e5, 0x9f7d033b, 0x128df67f, 0xb0078583,
+	0xa3a75d26, 0xc1ad8011, 0x07dd89ec, 0xef04f456, 0x91bf866c, 0x6aac5306,
+	0xdd5a1573, 0xf73ff97a, 0x4e1186ad, 0xb9680680, 0xc8894515, 0xdc95a08e,
+	0xc894fd8e, 0xf84ade15, 0xd787f8c1, 0x40dcecca, 0x1b24743e, 0x1ce6ab23,
+	0x72321653, 0xb80fbaf7, 0x1bcf099b, 0x1ff26805, 0x78f66c8e, 0xf93bf51a,
+	0xfb0c06fe, 0xe50d48cf, 0x310947e0, 0x1b78804a, 0xe73e2c14, 0x8deb8381,
+	0xe576122a, 0xe5a8df39, 0x42397c5e, 0xf5503f3c, 0xbe3dbf8d, 0x1b360e5c,
+	0x9254caaf, 0x7a9f6744, 0x6d4144fa, 0xd77c65fe, 0x44ca7b12, 0xf58a4c00,
+	0x159500d0, 0x92769857, 0x7134fdd4, 0xa3fea693, 0xbd044831, 0xeded39a1,
+	0xe4570204, 0xaea37f2f, 0x9a302971, 0x620f8402, 0x1d2f3e5e, 0xf9c2f49c,
+	0x738e813a, 0xb3c92251, 0x7ecba63b, 0xbe7eebc7, 0xf800267c, 0x3fdeb760,
+	0xf12d5e7d, 0x5a18dce1, 0xb35a539c, 0xe565f057, 0x2babf38c, 0xae5800ad,
+	0x421004dd, 0x6715acb6, 0xff529b64, 0xd520d207, 0x7cb193e7, 0xe9b18e4c,
+	0xfd2a8a59, 0x47826ae3, 0x56ba43f8, 0x453b3d99, 0x8ae1675f, 0xf66f5c34,
+	0x057a6ac1, 0x010769e4, 0xa8324158, 0x410379a5, 0x5dfc8c97, 0x72848afe,
+	0x59f169e5, 0xe32acb78, 0x5dfaa9c4, 0x51bb956a,
+};
+
+const u8 TestRandom::expected_pcgrandom_bytes_result[24] = {
+	0xf3, 0x79, 0x8f, 0x31, 0xac, 0xd9, 0x34, 0xf8, 0x3c, 0x6e, 0x82, 0x37,
+	0x6b, 0x4b, 0x77, 0xe3, 0xbd, 0x0a, 0xee, 0x22, 0x79, 0x6e, 0x40, 0x00,
+};
+
+const u8 TestRandom::expected_pcgrandom_bytes_result2[24] = {
+	0x47, 0x9e, 0x08, 0x3e, 0xd4, 0x21, 0x2d, 0xf6, 0xb4, 0xb1, 0x9d, 0x7a,
+	0x60, 0x02, 0x5a, 0xb2, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};

src/unittest/test_schematic.cpp

@@ -0,0 +1,286 @@
+ /*
+Minetest
+Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
+
+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
+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 Lesser General Public License for more details.
+
+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 "mapgen/mg_schematic.h"
+#include "gamedef.h"
+#include "nodedef.h"
+
+class TestSchematic : public TestBase {
+public:
+	TestSchematic() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestSchematic"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testMtsSerializeDeserialize(const NodeDefManager *ndef);
+	void testLuaTableSerialize(const NodeDefManager *ndef);
+	void testFileSerializeDeserialize(const NodeDefManager *ndef);
+
+	static const content_t test_schem1_data[7 * 6 * 4];
+	static const content_t test_schem2_data[3 * 3 * 3];
+	static const u8 test_schem2_prob[3 * 3 * 3];
+	static const char *expected_lua_output;
+};
+
+static TestSchematic g_test_instance;
+
+void TestSchematic::runTests(IGameDef *gamedef)
+{
+	NodeDefManager *ndef =
+		(NodeDefManager *)gamedef->getNodeDefManager();
+
+	ndef->setNodeRegistrationStatus(true);
+
+	TEST(testMtsSerializeDeserialize, ndef);
+	TEST(testLuaTableSerialize, ndef);
+	TEST(testFileSerializeDeserialize, ndef);
+
+	ndef->resetNodeResolveState();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestSchematic::testMtsSerializeDeserialize(const NodeDefManager *ndef)
+{
+	static const v3s16 size(7, 6, 4);
+	static const u32 volume = size.X * size.Y * size.Z;
+
+	std::stringstream ss(std::ios_base::binary |
+		std::ios_base::in | std::ios_base::out);
+
+	Schematic schem;
+	{
+		std::vector<std::string> &names = schem.m_nodenames;
+		names.emplace_back("foo");
+		names.emplace_back("bar");
+		names.emplace_back("baz");
+		names.emplace_back("qux");
+	}
+
+	schem.flags       = 0;
+	schem.size        = size;
+	schem.schemdata   = new MapNode[volume];
+	schem.slice_probs = new u8[size.Y];
+	for (size_t i = 0; i != volume; i++)
+		schem.schemdata[i] = MapNode(test_schem1_data[i], MTSCHEM_PROB_ALWAYS, 0);
+	for (s16 y = 0; y != size.Y; y++)
+		schem.slice_probs[y] = MTSCHEM_PROB_ALWAYS;
+
+	UASSERT(schem.serializeToMts(&ss));
+
+	ss.seekg(0);
+
+	Schematic schem2;
+	UASSERT(schem2.deserializeFromMts(&ss));
+
+	{
+		std::vector<std::string> &names = schem2.m_nodenames;
+		UASSERTEQ(size_t, names.size(), 4);
+		UASSERTEQ(std::string, names[0], "foo");
+		UASSERTEQ(std::string, names[1], "bar");
+		UASSERTEQ(std::string, names[2], "baz");
+		UASSERTEQ(std::string, names[3], "qux");
+	}
+
+	UASSERT(schem2.size == size);
+	for (size_t i = 0; i != volume; i++)
+		UASSERT(schem2.schemdata[i] == schem.schemdata[i]);
+	for (s16 y = 0; y != size.Y; y++)
+		UASSERTEQ(u8, schem2.slice_probs[y], schem.slice_probs[y]);
+}
+
+
+void TestSchematic::testLuaTableSerialize(const NodeDefManager *ndef)
+{
+	static const v3s16 size(3, 3, 3);
+	static const u32 volume = size.X * size.Y * size.Z;
+
+	Schematic schem;
+
+	schem.flags       = 0;
+	schem.size        = size;
+	schem.schemdata   = new MapNode[volume];
+	schem.slice_probs = new u8[size.Y];
+	for (size_t i = 0; i != volume; i++)
+		schem.schemdata[i] = MapNode(test_schem2_data[i], test_schem2_prob[i], 0);
+	for (s16 y = 0; y != size.Y; y++)
+		schem.slice_probs[y] = MTSCHEM_PROB_ALWAYS;
+
+	std::vector<std::string> &names = schem.m_nodenames;
+	names.emplace_back("air");
+	names.emplace_back("default:lava_source");
+	names.emplace_back("default:glass");
+
+	std::ostringstream ss(std::ios_base::binary);
+
+	UASSERT(schem.serializeToLua(&ss, false, 0));
+	UASSERTEQ(std::string, ss.str(), expected_lua_output);
+}
+
+
+void TestSchematic::testFileSerializeDeserialize(const NodeDefManager *ndef)
+{
+	static const v3s16 size(3, 3, 3);
+	static const u32 volume = size.X * size.Y * size.Z;
+	static const content_t content_map[] = {
+		CONTENT_AIR,
+		t_CONTENT_STONE,
+		t_CONTENT_LAVA,
+	};
+	static const content_t content_map2[] = {
+		CONTENT_AIR,
+		t_CONTENT_STONE,
+		t_CONTENT_WATER,
+	};
+	StringMap replace_names;
+	replace_names["default:lava"] = "default:water";
+
+	Schematic schem1, schem2;
+
+	//// Construct the schematic to save
+	schem1.flags          = 0;
+	schem1.size           = size;
+	schem1.schemdata      = new MapNode[volume];
+	schem1.slice_probs    = new u8[size.Y];
+	schem1.slice_probs[0] = 80;
+	schem1.slice_probs[1] = 160;
+	schem1.slice_probs[2] = 240;
+	// Node resolving happened manually.
+	schem1.m_resolve_done = true;
+
+	for (size_t i = 0; i != volume; i++) {
+		content_t c = content_map[test_schem2_data[i]];
+		schem1.schemdata[i] = MapNode(c, test_schem2_prob[i], 0);
+	}
+
+	std::string temp_file = getTestTempFile();
+	UASSERT(schem1.saveSchematicToFile(temp_file, ndef));
+	UASSERT(schem2.loadSchematicFromFile(temp_file, ndef, &replace_names));
+
+	UASSERT(schem2.size == size);
+	UASSERT(schem2.slice_probs[0] == 80);
+	UASSERT(schem2.slice_probs[1] == 160);
+	UASSERT(schem2.slice_probs[2] == 240);
+
+	for (size_t i = 0; i != volume; i++) {
+		content_t c = content_map2[test_schem2_data[i]];
+		UASSERT(schem2.schemdata[i] == MapNode(c, test_schem2_prob[i], 0));
+	}
+}
+
+
+// Should form a cross-shaped-thing...?
+const content_t TestSchematic::test_schem1_data[7 * 6 * 4] = {
+	3, 3, 1, 1, 1, 3, 3, // Y=0, Z=0
+	3, 0, 1, 2, 1, 0, 3, // Y=1, Z=0
+	3, 0, 1, 2, 1, 0, 3, // Y=2, Z=0
+	3, 1, 1, 2, 1, 1, 3, // Y=3, Z=0
+	3, 2, 2, 2, 2, 2, 3, // Y=4, Z=0
+	3, 1, 1, 2, 1, 1, 3, // Y=5, Z=0
+
+	0, 0, 1, 1, 1, 0, 0, // Y=0, Z=1
+	0, 0, 1, 2, 1, 0, 0, // Y=1, Z=1
+	0, 0, 1, 2, 1, 0, 0, // Y=2, Z=1
+	1, 1, 1, 2, 1, 1, 1, // Y=3, Z=1
+	1, 2, 2, 2, 2, 2, 1, // Y=4, Z=1
+	1, 1, 1, 2, 1, 1, 1, // Y=5, Z=1
+
+	0, 0, 1, 1, 1, 0, 0, // Y=0, Z=2
+	0, 0, 1, 2, 1, 0, 0, // Y=1, Z=2
+	0, 0, 1, 2, 1, 0, 0, // Y=2, Z=2
+	1, 1, 1, 2, 1, 1, 1, // Y=3, Z=2
+	1, 2, 2, 2, 2, 2, 1, // Y=4, Z=2
+	1, 1, 1, 2, 1, 1, 1, // Y=5, Z=2
+
+	3, 3, 1, 1, 1, 3, 3, // Y=0, Z=3
+	3, 0, 1, 2, 1, 0, 3, // Y=1, Z=3
+	3, 0, 1, 2, 1, 0, 3, // Y=2, Z=3
+	3, 1, 1, 2, 1, 1, 3, // Y=3, Z=3
+	3, 2, 2, 2, 2, 2, 3, // Y=4, Z=3
+	3, 1, 1, 2, 1, 1, 3, // Y=5, Z=3
+};
+
+const content_t TestSchematic::test_schem2_data[3 * 3 * 3] = {
+	0, 0, 0,
+	0, 2, 0,
+	0, 0, 0,
+
+	0, 2, 0,
+	2, 1, 2,
+	0, 2, 0,
+
+	0, 0, 0,
+	0, 2, 0,
+	0, 0, 0,
+};
+
+const u8 TestSchematic::test_schem2_prob[3 * 3 * 3] = {
+	0x00, 0x00, 0x00,
+	0x00, 0xFF, 0x00,
+	0x00, 0x00, 0x00,
+
+	0x00, 0xFF, 0x00,
+	0xFF, 0xFF, 0xFF,
+	0x00, 0xFF, 0x00,
+
+	0x00, 0x00, 0x00,
+	0x00, 0xFF, 0x00,
+	0x00, 0x00, 0x00,
+};
+
+const char *TestSchematic::expected_lua_output =
+	"schematic = {\n"
+	"\tsize = {x=3, y=3, z=3},\n"
+	"\tyslice_prob = {\n"
+	"\t\t{ypos=0, prob=254},\n"
+	"\t\t{ypos=1, prob=254},\n"
+	"\t\t{ypos=2, prob=254},\n"
+	"\t},\n"
+	"\tdata = {\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"default:glass\", prob=254, param2=0, force_place=true},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"default:glass\", prob=254, param2=0, force_place=true},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"default:glass\", prob=254, param2=0, force_place=true},\n"
+	"\t\t{name=\"default:lava_source\", prob=254, param2=0, force_place=true},\n"
+	"\t\t{name=\"default:glass\", prob=254, param2=0, force_place=true},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"default:glass\", prob=254, param2=0, force_place=true},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"default:glass\", prob=254, param2=0, force_place=true},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t\t{name=\"air\", prob=0, param2=0},\n"
+	"\t},\n"
+	"}\n";

src/unittest/test_serialization.cpp

@@ -0,0 +1,439 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "util/string.h"
+#include "util/serialize.h"
+#include <cmath>
+
+class TestSerialization : public TestBase {
+public:
+	TestSerialization() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestSerialization"; }
+
+	void runTests(IGameDef *gamedef);
+	void buildTestStrings();
+
+	void testSerializeString();
+	void testSerializeLongString();
+	void testSerializeJsonString();
+	void testDeSerializeString();
+	void testDeSerializeLongString();
+	void testStreamRead();
+	void testStreamWrite();
+	void testFloatFormat();
+
+	std::string teststring2;
+	std::wstring teststring2_w;
+	std::string teststring2_w_encoded;
+
+	static const u8 test_serialized_data[12 * 11 - 2];
+};
+
+static TestSerialization g_test_instance;
+
+void TestSerialization::runTests(IGameDef *gamedef)
+{
+	buildTestStrings();
+
+	TEST(testSerializeString);
+	TEST(testDeSerializeString);
+	TEST(testSerializeLongString);
+	TEST(testDeSerializeLongString);
+	TEST(testSerializeJsonString);
+	TEST(testStreamRead);
+	TEST(testStreamWrite);
+	TEST(testFloatFormat);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// To be used like this:
+//   mkstr("Some\0string\0with\0embedded\0nuls")
+// since std::string("...") doesn't work as expected in that case.
+template<size_t N> std::string mkstr(const char (&s)[N])
+{
+	return std::string(s, N - 1);
+}
+
+void TestSerialization::buildTestStrings()
+{
+	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();
+}
+
+void TestSerialization::testSerializeString()
+{
+	// Test blank string
+	UASSERT(serializeString16("") == mkstr("\0\0"));
+
+	// Test basic string
+	UASSERT(serializeString16("Hello world!") == mkstr("\0\14Hello world!"));
+
+	// Test character range
+	UASSERT(serializeString16(teststring2) == mkstr("\1\0") + teststring2);
+}
+
+void TestSerialization::testDeSerializeString()
+{
+	// Test deserialize
+	{
+		std::istringstream is(serializeString16(teststring2), std::ios::binary);
+		UASSERT(deSerializeString16(is) == teststring2);
+		UASSERT(!is.eof());
+		is.get();
+		UASSERT(is.eof());
+	}
+
+	// Test deserialize an incomplete length specifier
+	{
+		std::istringstream is(mkstr("\x53"), std::ios::binary);
+		EXCEPTION_CHECK(SerializationError, deSerializeString16(is));
+	}
+
+	// Test deserialize a string with incomplete data
+	{
+		std::istringstream is(mkstr("\x00\x55 abcdefg"), std::ios::binary);
+		EXCEPTION_CHECK(SerializationError, deSerializeString16(is));
+	}
+}
+
+void TestSerialization::testSerializeLongString()
+{
+	// Test blank string
+	UASSERT(serializeString32("") == mkstr("\0\0\0\0"));
+
+	// Test basic string
+	UASSERT(serializeString32("Hello world!") == mkstr("\0\0\0\14Hello world!"));
+
+	// Test character range
+	UASSERT(serializeString32(teststring2) == mkstr("\0\0\1\0") + teststring2);
+}
+
+void TestSerialization::testDeSerializeLongString()
+{
+	// Test deserialize
+	{
+		std::istringstream is(serializeString32(teststring2), std::ios::binary);
+		UASSERT(deSerializeString32(is) == teststring2);
+		UASSERT(!is.eof());
+		is.get();
+		UASSERT(is.eof());
+	}
+
+	// Test deserialize an incomplete length specifier
+	{
+		std::istringstream is(mkstr("\x53"), std::ios::binary);
+		EXCEPTION_CHECK(SerializationError, deSerializeString32(is));
+	}
+
+	// Test deserialize a string with incomplete data
+	{
+		std::istringstream is(mkstr("\x00\x00\x00\x05 abc"), std::ios::binary);
+		EXCEPTION_CHECK(SerializationError, deSerializeString32(is));
+	}
+
+	// Test deserialize a string with a length too large
+	{
+		std::istringstream is(mkstr("\xFF\xFF\xFF\xFF blah"), std::ios::binary);
+		EXCEPTION_CHECK(SerializationError, deSerializeString32(is));
+	}
+}
+
+
+void TestSerialization::testSerializeJsonString()
+{
+	std::istringstream is(std::ios::binary);
+	const auto reset_is = [&] (const std::string &s) { 
+		is.clear();
+		is.str(s);
+	};
+	const auto assert_at_eof = [] (std::istream &is) {
+		is.get();
+		UASSERT(is.eof());
+	};
+
+	// Test blank string
+	UASSERTEQ(std::string, serializeJsonString(""), "\"\"");
+	reset_is("\"\"");
+	UASSERTEQ(std::string, deSerializeJsonString(is), "");
+	assert_at_eof(is);
+
+	// Test basic string
+	UASSERTEQ(std::string, serializeJsonString("Hello world!"), "\"Hello world!\"");
+	reset_is("\"Hello world!\"");
+	UASSERTEQ(std::string, deSerializeJsonString(is), "Hello world!");
+	assert_at_eof(is);
+
+	// Test optional serialization
+	const std::pair<const char*, const char*> test_pairs[] = {
+		{ "abc", "abc" },
+		{ "x y z", "\"x y z\"" },
+		{ "\"", "\"\\\"\"" },
+	};
+	for (auto it : test_pairs) {
+		UASSERTEQ(std::string, serializeJsonStringIfNeeded(it.first), it.second);
+		reset_is(it.second);
+		UASSERTEQ(std::string, deSerializeJsonStringIfNeeded(is), it.first);
+		assert_at_eof(is);
+	}
+
+	// Test all byte values
+	const std::string bs = "\\"; // MSVC fails when directly using "\\\\"
+	const std::string expected = 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, 0x5c-0x23) +
+		bs + bs + 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::string serialized = serializeJsonString(teststring2);
+	UASSERTEQ(std::string, serialized, expected);
+
+	reset_is(serialized);
+	UASSERTEQ(std::string, deSerializeJsonString(is), teststring2);
+	UASSERT(!is.eof()); // should have stopped at " so eof must not be set yet
+	assert_at_eof(is);
+
+	// Test that deserialization leaves rest of stream alone
+	std::string tmp;
+	reset_is("\"foo\"bar");
+	UASSERTEQ(std::string, deSerializeJsonString(is), "foo");
+	std::getline(is, tmp, '\0');
+	UASSERTEQ(std::string, tmp, "bar");
+
+	reset_is("\"x y z\"bar");
+	UASSERTEQ(std::string, deSerializeJsonStringIfNeeded(is), "x y z");
+	std::getline(is, tmp, '\0');
+	UASSERTEQ(std::string, tmp, "bar");
+
+	reset_is("foo bar");
+	UASSERTEQ(std::string, deSerializeJsonStringIfNeeded(is), "foo");
+	std::getline(is, tmp, '\0');
+	UASSERTEQ(std::string, tmp, " bar");
+}
+
+
+void TestSerialization::testStreamRead()
+{
+	std::string datastr(
+		(const char *)test_serialized_data,
+		sizeof(test_serialized_data));
+	std::istringstream is(datastr, std::ios_base::binary);
+
+	UASSERT(readU8(is) == 0x11);
+	UASSERT(readU16(is) == 0x2233);
+	UASSERT(readU32(is) == 0x44556677);
+	UASSERT(readU64(is) == 0x8899AABBCCDDEEFFLL);
+
+	UASSERT(readS8(is) == -128);
+	UASSERT(readS16(is) == 30000);
+	UASSERT(readS32(is) == -6);
+	UASSERT(readS64(is) == -43);
+
+	UASSERT(readF1000(is) == 53.534f);
+	UASSERT(readF1000(is) == -300000.32f);
+	UASSERT(readF1000(is) == F1000_MIN);
+	UASSERT(readF1000(is) == F1000_MAX);
+
+	UASSERT(deSerializeString16(is) == "foobar!");
+
+	UASSERT(readV2S16(is) == v2s16(500, 500));
+	UASSERT(readV3S16(is) == v3s16(4207, 604, -30));
+	UASSERT(readV2S32(is) == v2s32(1920, 1080));
+	UASSERT(readV3S32(is) == v3s32(-400, 6400054, 290549855));
+
+	UASSERT(readV3F1000(is) == v3f(500, 10024.2f, -192.54f));
+	UASSERT(readARGB8(is) == video::SColor(255, 128, 50, 128));
+
+	UASSERT(deSerializeString32(is) == "some longer string here");
+
+	UASSERT(is.rdbuf()->in_avail() == 2);
+	UASSERT(readU16(is) == 0xF00D);
+	UASSERT(is.rdbuf()->in_avail() == 0);
+}
+
+
+void TestSerialization::testStreamWrite()
+{
+	std::ostringstream os(std::ios_base::binary);
+	std::string data;
+
+	writeU8(os, 0x11);
+	writeU16(os, 0x2233);
+	writeU32(os, 0x44556677);
+	writeU64(os, 0x8899AABBCCDDEEFFLL);
+
+	writeS8(os, -128);
+	writeS16(os, 30000);
+	writeS32(os, -6);
+	writeS64(os, -43);
+
+	writeF1000(os, 53.53467f);
+	writeF1000(os, -300000.32f);
+	writeF1000(os, F1000_MIN);
+	writeF1000(os, F1000_MAX);
+
+	os << serializeString16("foobar!");
+
+	data = os.str();
+	UASSERT(data.size() < sizeof(test_serialized_data));
+	UASSERT(!memcmp(&data[0], test_serialized_data, data.size()));
+
+	writeV2S16(os, v2s16(500, 500));
+	writeV3S16(os, v3s16(4207, 604, -30));
+	writeV2S32(os, v2s32(1920, 1080));
+	writeV3S32(os, v3s32(-400, 6400054, 290549855));
+
+	writeV3F1000(os, v3f(500, 10024.2f, -192.54f));
+	writeARGB8(os, video::SColor(255, 128, 50, 128));
+
+	os << serializeString32("some longer string here");
+
+	writeU16(os, 0xF00D);
+
+	data = os.str();
+	UASSERT(data.size() == sizeof(test_serialized_data));
+	UASSERT(!memcmp(&data[0], test_serialized_data, sizeof(test_serialized_data)));
+}
+
+
+void TestSerialization::testFloatFormat()
+{
+	FloatType type = getFloatSerializationType();
+	u32 i;
+	f32 fs, fm;
+
+	// Check precision of float calculations on this platform
+	const std::unordered_map<f32, u32> float_results = {
+		{  0.0f, 0x00000000UL },
+		{  1.0f, 0x3F800000UL },
+		{ -1.0f, 0xBF800000UL },
+		{  0.1f, 0x3DCCCCCDUL },
+		{ -0.1f, 0xBDCCCCCDUL },
+		{ 1945329.25f, 0x49ED778AUL },
+		{ -23298764.f, 0xCBB1C166UL },
+		{  0.5f, 0x3F000000UL },
+		{ -0.5f, 0xBF000000UL }
+	};
+	for (const auto &v : float_results) {
+		i = f32Tou32Slow(v.first);
+		if (std::abs((s64)v.second - i) > 32) {
+			printf("Inaccurate float values on %.9g, expected 0x%X, actual 0x%X\n",
+				v.first, v.second, i);
+			UASSERT(false);
+		}
+
+		fs = u32Tof32Slow(v.second);
+		if (std::fabs(v.first - fs) > std::fabs(v.first * 0.000005f)) {
+			printf("Inaccurate float values on 0x%X, expected %.9g, actual 0x%.9g\n",
+				v.second, v.first, fs);
+			UASSERT(false);
+		}
+	}
+
+	if (type == FLOATTYPE_SLOW) {
+		// conversion using memcpy is not possible
+		// Skip exact float comparison checks below
+		return;
+	}
+
+	// The code below compares the IEEE conversion functions with a
+	// known good IEC559/IEEE754 implementation. This test neeeds
+	// IEC559 compliance in the compiler.
+#if defined(__GNUC__) && (!defined(__STDC_IEC_559__) || defined(__FAST_MATH__))
+	// GNU C++ lies about its IEC559 support when -ffast-math is active.
+	// https://gcc.gnu.org/bugzilla//show_bug.cgi?id=84949
+	bool is_iec559 = false;
+#else
+	bool is_iec559 = std::numeric_limits<f32>::is_iec559;
+#endif
+	if (!is_iec559)
+		return;
+
+	auto test_single = [&fs, &fm](const u32 &i) -> bool {
+		memcpy(&fm, &i, 4);
+		fs = u32Tof32Slow(i);
+		if (fm != fs) {
+			printf("u32Tof32Slow failed on 0x%X, expected %.9g, actual %.9g\n",
+				i, fm, fs);
+			return false;
+		}
+		if (f32Tou32Slow(fs) != i) {
+			printf("f32Tou32Slow failed on %.9g, expected 0x%X, actual 0x%X\n",
+				fs, i, f32Tou32Slow(fs));
+			return false;
+		}
+		return true;
+	};
+
+	// Use step of prime 277 to speed things up from 3 minutes to a few seconds
+	// Test from 0 to 0xFF800000UL (positive)
+	for (i = 0x00000000UL; i <= 0x7F800000UL; i += 277)
+		UASSERT(test_single(i));
+
+	// Ensure +inf and -inf are tested
+	UASSERT(test_single(0x7F800000UL));
+	UASSERT(test_single(0xFF800000UL));
+
+	// Test from 0x80000000UL to 0xFF800000UL (negative)
+	for (i = 0x80000000UL; i <= 0xFF800000UL; i += 277)
+		UASSERT(test_single(i));
+}
+
+const u8 TestSerialization::test_serialized_data[12 * 11 - 2] = {
+	0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
+	0xdd, 0xee, 0xff, 0x80, 0x75, 0x30, 0xff, 0xff, 0xff, 0xfa, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x00, 0x00, 0xd1, 0x1e, 0xee, 0x1e,
+	0x5b, 0xc0, 0x80, 0x00, 0x02, 0x80, 0x7F, 0xFF, 0xFD, 0x80, 0x00, 0x07,
+	0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72, 0x21, 0x01, 0xf4, 0x01, 0xf4, 0x10,
+	0x6f, 0x02, 0x5c, 0xff, 0xe2, 0x00, 0x00, 0x07, 0x80, 0x00, 0x00, 0x04,
+	0x38, 0xff, 0xff, 0xfe, 0x70, 0x00, 0x61, 0xa8, 0x36, 0x11, 0x51, 0x70,
+	0x5f, 0x00, 0x07, 0xa1, 0x20, 0x00, 0x98, 0xf5, 0x08, 0xff,
+	0xfd, 0x0f, 0xe4, 0xff, 0x80, 0x32, 0x80, 0x00, 0x00, 0x00, 0x17, 0x73,
+	0x6f, 0x6d, 0x65, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x73,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x65, 0x72, 0x65, 0xF0, 0x0D,
+};

src/unittest/test_server_shutdown_state.cpp

@@ -0,0 +1,120 @@
+/*
+Minetest
+Copyright (C) 2018 nerzhul, Loic BLOT <loic.blot@unix-experience.fr>
+
+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
+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 Lesser General Public License for more details.
+
+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 <server.h>
+#include "test.h"
+
+#include "util/string.h"
+#include "util/serialize.h"
+
+class FakeServer : public Server
+{
+public:
+	FakeServer() : Server("fakeworld", SubgameSpec("fakespec", "fakespec"), true,
+					Address(), true, nullptr)
+	{
+	}
+
+private:
+	void SendChatMessage(session_t peer_id, const ChatMessage &message)
+	{
+		// NOOP
+	}
+};
+
+class TestServerShutdownState : public TestBase
+{
+public:
+	TestServerShutdownState() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestServerShutdownState"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testInit();
+	void testReset();
+	void testTrigger();
+	void testTick();
+};
+
+static TestServerShutdownState g_test_instance;
+
+void TestServerShutdownState::runTests(IGameDef *gamedef)
+{
+	TEST(testInit);
+	TEST(testReset);
+	TEST(testTrigger);
+	TEST(testTick);
+}
+
+void TestServerShutdownState::testInit()
+{
+	Server::ShutdownState ss;
+	UASSERT(!ss.is_requested);
+	UASSERT(!ss.should_reconnect);
+	UASSERT(ss.message.empty());
+	UASSERT(ss.m_timer == 0.0f);
+}
+
+void TestServerShutdownState::testReset()
+{
+	Server::ShutdownState ss;
+	ss.reset();
+	UASSERT(!ss.is_requested);
+	UASSERT(!ss.should_reconnect);
+	UASSERT(ss.message.empty());
+	UASSERT(ss.m_timer == 0.0f);
+}
+
+void TestServerShutdownState::testTrigger()
+{
+	Server::ShutdownState ss;
+	ss.trigger(3.0f, "testtrigger", true);
+	UASSERT(!ss.is_requested);
+	UASSERT(ss.should_reconnect);
+	UASSERT(ss.message == "testtrigger");
+	UASSERT(ss.m_timer == 3.0f);
+}
+
+void TestServerShutdownState::testTick()
+{
+	auto fakeServer = std::make_unique<FakeServer>();
+	Server::ShutdownState ss;
+	ss.trigger(28.0f, "testtrigger", true);
+	ss.tick(0.0f, fakeServer.get());
+
+	// Tick with no time should not change anything
+	UASSERT(!ss.is_requested);
+	UASSERT(ss.should_reconnect);
+	UASSERT(ss.message == "testtrigger");
+	UASSERT(ss.m_timer == 28.0f);
+
+	// Tick 2 seconds
+	ss.tick(2.0f, fakeServer.get());
+	UASSERT(!ss.is_requested);
+	UASSERT(ss.should_reconnect);
+	UASSERT(ss.message == "testtrigger");
+	UASSERT(ss.m_timer == 26.0f);
+
+	// Tick remaining seconds + additional expire
+	ss.tick(26.1f, fakeServer.get());
+	UASSERT(ss.is_requested);
+	UASSERT(ss.should_reconnect);
+	UASSERT(ss.message == "testtrigger");
+	UASSERT(ss.m_timer == 0.0f);
+}

src/unittest/test_serveractiveobjectmgr.cpp

@@ -0,0 +1,200 @@
+/*
+Minetest
+Copyright (C) 2018 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
+
+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
+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 Lesser General Public License for more details.
+
+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 "server/activeobjectmgr.h"
+#include <algorithm>
+#include <queue>
+#include "test.h"
+
+#include "profiler.h"
+
+class TestServerActiveObject : public ServerActiveObject
+{
+public:
+	TestServerActiveObject(const v3f &p = v3f()) : ServerActiveObject(nullptr, p) {}
+	~TestServerActiveObject() = default;
+	ActiveObjectType getType() const override { return ACTIVEOBJECT_TYPE_TEST; }
+	bool getCollisionBox(aabb3f *toset) const override { return false; }
+	bool getSelectionBox(aabb3f *toset) const override { return false; }
+	bool collideWithObjects() const override { return false; }
+};
+
+class TestServerActiveObjectMgr : public TestBase
+{
+public:
+	TestServerActiveObjectMgr() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestServerActiveObjectMgr"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testFreeID();
+	void testRegisterObject();
+	void testRemoveObject();
+	void testGetObjectsInsideRadius();
+	void testGetAddedActiveObjectsAroundPos();
+};
+
+static TestServerActiveObjectMgr g_test_instance;
+
+void TestServerActiveObjectMgr::runTests(IGameDef *gamedef)
+{
+	TEST(testFreeID);
+	TEST(testRegisterObject)
+	TEST(testRemoveObject)
+	TEST(testGetObjectsInsideRadius);
+	TEST(testGetAddedActiveObjectsAroundPos);
+}
+
+void clearSAOMgr(server::ActiveObjectMgr *saomgr)
+{
+	auto clear_cb = [](ServerActiveObject *obj, u16 id) {
+		delete obj;
+		return true;
+	};
+	saomgr->clear(clear_cb);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestServerActiveObjectMgr::testFreeID()
+{
+	server::ActiveObjectMgr saomgr;
+	std::vector<u16> aoids;
+
+	u16 aoid = saomgr.getFreeId();
+	// Ensure it's not the same id
+	UASSERT(saomgr.getFreeId() != aoid);
+
+	aoids.push_back(aoid);
+
+	// Register basic objects, ensure we never found
+	for (u8 i = 0; i < UINT8_MAX; i++) {
+		// Register an object
+		auto tsao = new TestServerActiveObject();
+		saomgr.registerObject(tsao);
+		aoids.push_back(tsao->getId());
+
+		// Ensure next id is not in registered list
+		UASSERT(std::find(aoids.begin(), aoids.end(), saomgr.getFreeId()) ==
+				aoids.end());
+	}
+
+	clearSAOMgr(&saomgr);
+}
+
+void TestServerActiveObjectMgr::testRegisterObject()
+{
+	server::ActiveObjectMgr saomgr;
+	auto tsao = new TestServerActiveObject();
+	UASSERT(saomgr.registerObject(tsao));
+
+	u16 id = tsao->getId();
+
+	auto tsaoToCompare = saomgr.getActiveObject(id);
+	UASSERT(tsaoToCompare->getId() == id);
+	UASSERT(tsaoToCompare == tsao);
+
+	tsao = new TestServerActiveObject();
+	UASSERT(saomgr.registerObject(tsao));
+	UASSERT(saomgr.getActiveObject(tsao->getId()) == tsao);
+	UASSERT(saomgr.getActiveObject(tsao->getId()) != tsaoToCompare);
+
+	clearSAOMgr(&saomgr);
+}
+
+void TestServerActiveObjectMgr::testRemoveObject()
+{
+	server::ActiveObjectMgr saomgr;
+	auto tsao = new TestServerActiveObject();
+	UASSERT(saomgr.registerObject(tsao));
+
+	u16 id = tsao->getId();
+	UASSERT(saomgr.getActiveObject(id) != nullptr)
+
+	saomgr.removeObject(tsao->getId());
+	UASSERT(saomgr.getActiveObject(id) == nullptr);
+
+	clearSAOMgr(&saomgr);
+}
+
+void TestServerActiveObjectMgr::testGetObjectsInsideRadius()
+{
+	server::ActiveObjectMgr saomgr;
+	static const v3f sao_pos[] = {
+			v3f(10, 40, 10),
+			v3f(740, 100, -304),
+			v3f(-200, 100, -304),
+			v3f(740, -740, -304),
+			v3f(1500, -740, -304),
+	};
+
+	for (const auto &p : sao_pos) {
+		saomgr.registerObject(new TestServerActiveObject(p));
+	}
+
+	std::vector<ServerActiveObject *> result;
+	saomgr.getObjectsInsideRadius(v3f(), 50, result, nullptr);
+	UASSERTCMP(int, ==, result.size(), 1);
+
+	result.clear();
+	saomgr.getObjectsInsideRadius(v3f(), 750, result, nullptr);
+	UASSERTCMP(int, ==, result.size(), 2);
+
+	result.clear();
+	saomgr.getObjectsInsideRadius(v3f(), 750000, result, nullptr);
+	UASSERTCMP(int, ==, result.size(), 5);
+
+	result.clear();
+	auto include_obj_cb = [](ServerActiveObject *obj) {
+		return (obj->getBasePosition().X != 10);
+	};
+
+	saomgr.getObjectsInsideRadius(v3f(), 750000, result, include_obj_cb);
+	UASSERTCMP(int, ==, result.size(), 4);
+
+	clearSAOMgr(&saomgr);
+}
+
+void TestServerActiveObjectMgr::testGetAddedActiveObjectsAroundPos()
+{
+	server::ActiveObjectMgr saomgr;
+	static const v3f sao_pos[] = {
+			v3f(10, 40, 10),
+			v3f(740, 100, -304),
+			v3f(-200, 100, -304),
+			v3f(740, -740, -304),
+			v3f(1500, -740, -304),
+	};
+
+	for (const auto &p : sao_pos) {
+		saomgr.registerObject(new TestServerActiveObject(p));
+	}
+
+	std::queue<u16> result;
+	std::set<u16> cur_objects;
+	saomgr.getAddedActiveObjectsAroundPos(v3f(), 100, 50, cur_objects, result);
+	UASSERTCMP(int, ==, result.size(), 1);
+
+	result = std::queue<u16>();
+	cur_objects.clear();
+	saomgr.getAddedActiveObjectsAroundPos(v3f(), 740, 50, cur_objects, result);
+	UASSERTCMP(int, ==, result.size(), 2);
+
+	clearSAOMgr(&saomgr);
+}

src/unittest/test_servermodmanager.cpp

@@ -0,0 +1,201 @@
+/*
+Minetest
+Copyright (C) 2018 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
+
+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
+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 Lesser General Public License for more details.
+
+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 <algorithm>
+#include "server/mods.h"
+#include "settings.h"
+#include "test_config.h"
+#include "util/string.h"
+
+class TestServerModManager : public TestBase
+{
+public:
+	TestServerModManager() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestServerModManager"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testCreation();
+	void testIsConsistent();
+	void testUnsatisfiedMods();
+	void testGetMods();
+	void testGetModsWrongDir();
+	void testGetModspec();
+	void testGetModNamesWrongDir();
+	void testGetModNames();
+	void testGetModMediaPathsWrongDir();
+	void testGetModMediaPaths();
+};
+
+static TestServerModManager g_test_instance;
+
+void TestServerModManager::runTests(IGameDef *gamedef)
+{
+	const char *saved_env_mt_subgame_path = getenv("MINETEST_SUBGAME_PATH");
+	const char *saved_env_mt_mod_path = getenv("MINETEST_MOD_PATH");
+#ifdef WIN32
+	{
+		std::string subgame_path("MINETEST_SUBGAME_PATH=");
+		subgame_path.append(TEST_SUBGAME_PATH);
+		_putenv(subgame_path.c_str());
+
+		std::string mod_path("MINETEST_MOD_PATH=");
+		mod_path.append(TEST_MOD_PATH);
+		_putenv(mod_path.c_str());
+	}
+#else
+	setenv("MINETEST_SUBGAME_PATH", TEST_SUBGAME_PATH, 1);
+	setenv("MINETEST_MOD_PATH", TEST_MOD_PATH, 1);
+#endif
+
+	TEST(testCreation);
+	TEST(testIsConsistent);
+	TEST(testGetModsWrongDir);
+	TEST(testUnsatisfiedMods);
+	TEST(testGetMods);
+	TEST(testGetModspec);
+	TEST(testGetModNamesWrongDir);
+	TEST(testGetModNames);
+	TEST(testGetModMediaPathsWrongDir);
+	TEST(testGetModMediaPaths);
+
+#ifdef WIN32
+	{
+		std::string subgame_path("MINETEST_SUBGAME_PATH=");
+		if (saved_env_mt_subgame_path)
+			subgame_path.append(saved_env_mt_subgame_path);
+		_putenv(subgame_path.c_str());
+
+		std::string mod_path("MINETEST_MOD_PATH=");
+		if (saved_env_mt_mod_path)
+			mod_path.append(saved_env_mt_mod_path);
+		_putenv(mod_path.c_str());
+	}
+#else
+	if (saved_env_mt_subgame_path)
+		setenv("MINETEST_SUBGAME_PATH", saved_env_mt_subgame_path, 1);
+	else
+		unsetenv("MINETEST_SUBGAME_PATH");
+	if (saved_env_mt_mod_path)
+		setenv("MINETEST_MOD_PATH", saved_env_mt_mod_path, 1);
+	else
+		unsetenv("MINETEST_MOD_PATH");
+#endif
+}
+
+void TestServerModManager::testCreation()
+{
+	std::string path = std::string(TEST_WORLDDIR) + DIR_DELIM + "world.mt";
+	Settings world_config;
+	world_config.set("gameid", "devtest");
+	world_config.set("load_mod_test_mod", "true");
+	UASSERTEQ(bool, world_config.updateConfigFile(path.c_str()), true);
+	ServerModManager sm(TEST_WORLDDIR);
+}
+
+void TestServerModManager::testGetModsWrongDir()
+{
+	// Test in non worlddir to ensure no mods are found
+	ServerModManager sm(std::string(TEST_WORLDDIR) + DIR_DELIM + "..");
+	UASSERTEQ(bool, sm.getMods().empty(), true);
+}
+
+void TestServerModManager::testUnsatisfiedMods()
+{
+	ServerModManager sm(std::string(TEST_WORLDDIR));
+	UASSERTEQ(bool, sm.getUnsatisfiedMods().empty(), true);
+}
+
+void TestServerModManager::testIsConsistent()
+{
+	ServerModManager sm(std::string(TEST_WORLDDIR));
+	UASSERTEQ(bool, sm.isConsistent(), true);
+}
+
+void TestServerModManager::testGetMods()
+{
+	ServerModManager sm(std::string(TEST_WORLDDIR));
+	const auto &mods = sm.getMods();
+	UASSERTEQ(bool, mods.empty(), false);
+
+	// Ensure we found basenodes mod (part of devtest)
+	// and test_mod (for testing MINETEST_MOD_PATH).
+	bool default_found = false;
+	bool test_mod_found = false;
+	for (const auto &m : mods) {
+		if (m.name == "basenodes")
+			default_found = true;
+		if (m.name == "test_mod")
+			test_mod_found = true;
+
+		// Verify if paths are not empty
+		UASSERTEQ(bool, m.path.empty(), false);
+	}
+
+	UASSERTEQ(bool, default_found, true);
+	UASSERTEQ(bool, test_mod_found, true);
+}
+
+void TestServerModManager::testGetModspec()
+{
+	ServerModManager sm(std::string(TEST_WORLDDIR));
+	UASSERTEQ(const ModSpec *, sm.getModSpec("wrongmod"), NULL);
+	UASSERT(sm.getModSpec("basenodes") != NULL);
+}
+
+void TestServerModManager::testGetModNamesWrongDir()
+{
+	ServerModManager sm(std::string(TEST_WORLDDIR) + DIR_DELIM + "..");
+	std::vector<std::string> result;
+	sm.getModNames(result);
+	UASSERTEQ(bool, result.empty(), true);
+}
+
+void TestServerModManager::testGetModNames()
+{
+	ServerModManager sm(std::string(TEST_WORLDDIR));
+	std::vector<std::string> result;
+	sm.getModNames(result);
+	UASSERTEQ(bool, result.empty(), false);
+	UASSERT(std::find(result.begin(), result.end(), "basenodes") != result.end());
+}
+
+void TestServerModManager::testGetModMediaPathsWrongDir()
+{
+	ServerModManager sm(std::string(TEST_WORLDDIR) + DIR_DELIM + "..");
+	std::vector<std::string> result;
+	sm.getModsMediaPaths(result);
+	UASSERTEQ(bool, result.empty(), true);
+}
+
+void TestServerModManager::testGetModMediaPaths()
+{
+	ServerModManager sm(std::string(TEST_WORLDDIR));
+	std::vector<std::string> result;
+	sm.getModsMediaPaths(result);
+	UASSERTEQ(bool, result.empty(), false);
+
+	// Test media overriding:
+	// unittests depends on basenodes to override default_dirt.png,
+	// thus the unittests texture path must come first in the returned media paths to take priority
+	auto it = std::find(result.begin(), result.end(), sm.getModSpec("unittests")->path + DIR_DELIM + "textures");
+	UASSERT(it != result.end());
+	UASSERT(std::find(++it, result.end(), sm.getModSpec("basenodes")->path + DIR_DELIM + "textures") != result.end());
+}

src/unittest/test_settings.cpp

@@ -0,0 +1,296 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 <cmath>
+#include "settings.h"
+#include "defaultsettings.h"
+#include "noise.h"
+
+class TestSettings : public TestBase {
+public:
+	TestSettings() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestSettings"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testAllSettings();
+	void testDefaults();
+	void testFlagDesc();
+
+	static const char *config_text_before;
+	static const std::string config_text_after;
+};
+
+static TestSettings g_test_instance;
+
+void TestSettings::runTests(IGameDef *gamedef)
+{
+	TEST(testAllSettings);
+	TEST(testDefaults);
+	TEST(testFlagDesc);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+const char *TestSettings::config_text_before =
+	"leet = 1337\n"
+	"leetleet = 13371337\n"
+	"leetleet_neg = -13371337\n"
+	"floaty_thing = 1.1\n"
+	"stringy_thing = asd /( ¤%&(/\" BLÖÄRP\n"
+	"coord = (1, 2, 4.5)\n"
+	"      # this is just a comment\n"
+	"this is an invalid line\n"
+	"asdf = {\n"
+	"	a   = 5\n"
+	"	bb  = 2.5\n"
+	"	ccc = \"\"\"\n"
+	"testy\n"
+	"   testa   \n"
+	"\"\"\"\n"
+	"\n"
+	"}\n"
+	"blarg = \"\"\" \n"
+	"some multiline text\n"
+	"     with leading whitespace!\n"
+	"\"\"\"\n"
+	"np_terrain = 5, 40, (250, 250, 250), 12341, 5, 0.7, 2.4\n"
+	"zoop = true\n"
+	"[dummy_eof_end_tag]\n";
+
+const std::string TestSettings::config_text_after =
+	"leet = 1337\n"
+	"leetleet = 13371337\n"
+	"leetleet_neg = -13371337\n"
+	"floaty_thing = 1.1\n"
+	"stringy_thing = asd /( ¤%&(/\" BLÖÄRP\n"
+	"coord = (1, 2, 4.5)\n"
+	"      # this is just a comment\n"
+	"this is an invalid line\n"
+	"asdf = {\n"
+	"	a   = 5\n"
+	"	bb  = 2.5\n"
+	"	ccc = \"\"\"\n"
+	"testy\n"
+	"   testa   \n"
+	"\"\"\"\n"
+	"\n"
+	"}\n"
+	"blarg = \"\"\" \n"
+	"some multiline text\n"
+	"     with leading whitespace!\n"
+	"\"\"\"\n"
+	"np_terrain = {\n"
+	"	flags = defaults\n"
+	"	lacunarity = 2.4\n"
+	"	octaves = 6\n"
+	"	offset = 3.5\n"
+	"	persistence = 0.7\n"
+	"	scale = 40\n"
+	"	seed = 12341\n"
+	"	spread = (250,250,250)\n"
+	"}\n"
+	"zoop = true\n"
+	"coord2 = (1,2,3.3)\n"
+	"floaty_thing_2 = 1.2\n"
+	"groupy_thing = {\n"
+	"	animals = cute\n"
+	"	num_apples = 4\n"
+	"	num_oranges = 53\n"
+	"}\n"
+	"[dummy_eof_end_tag]";
+
+void compare_settings(const std::string &name, Settings *a, Settings *b)
+{
+	auto keys = a->getNames();
+	Settings *group1, *group2;
+	std::string value1, value2;
+	for (auto &key : keys) {
+		if (a->getGroupNoEx(key, group1)) {
+			UASSERT(b->getGroupNoEx(key, group2));
+
+			compare_settings(name + "->" + key, group1, group2);
+			continue;
+		}
+
+		UASSERT(b->getNoEx(key, value1));
+		// For identification
+		value1 = name + "->" + key + "=" + value1;
+		value2 = name + "->" + key + "=" + a->get(key);
+		UASSERTCMP(std::string, ==, value2, value1);
+	}
+}
+
+void TestSettings::testAllSettings()
+{
+	try {
+	Settings s("[dummy_eof_end_tag]");
+
+	// Test reading of settings
+	std::istringstream is(config_text_before);
+	s.parseConfigLines(is);
+
+	UASSERT(s.getS32("leet") == 1337);
+	UASSERT(s.getS16("leetleet") == 32767);
+	UASSERT(s.getS16("leetleet_neg") == -32768);
+
+	// Not sure if 1.1 is an exact value as a float, but doesn't matter
+	UASSERT(fabs(s.getFloat("floaty_thing") - 1.1) < 0.001);
+	UASSERT(s.get("stringy_thing") == "asd /( ¤%&(/\" BLÖÄRP");
+	UASSERT(fabs(s.getV3F("coord").X - 1.0) < 0.001);
+	UASSERT(fabs(s.getV3F("coord").Y - 2.0) < 0.001);
+	UASSERT(fabs(s.getV3F("coord").Z - 4.5) < 0.001);
+
+	// Test the setting of settings too
+	s.setFloat("floaty_thing_2", 1.2);
+	s.setV3F("coord2", v3f(1, 2, 3.3));
+	UASSERT(s.get("floaty_thing_2").substr(0,3) == "1.2");
+	UASSERT(fabs(s.getFloat("floaty_thing_2") - 1.2) < 0.001);
+	UASSERT(fabs(s.getV3F("coord2").X - 1.0) < 0.001);
+	UASSERT(fabs(s.getV3F("coord2").Y - 2.0) < 0.001);
+	UASSERT(fabs(s.getV3F("coord2").Z - 3.3) < 0.001);
+
+	// Test settings groups
+	Settings *group = s.getGroup("asdf");
+	UASSERT(group != NULL);
+	UASSERT(s.getGroupNoEx("zoop", group) == false);
+	UASSERT(group->getS16("a") == 5);
+	UASSERT(fabs(group->getFloat("bb") - 2.5) < 0.001);
+
+	Settings group3;
+	group3.set("cat", "meow");
+	group3.set("dog", "woof");
+
+	Settings group2;
+	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(std::fabs(np.offset - 5) < 0.001f);
+	UASSERT(std::fabs(np.scale - 40) < 0.001f);
+	UASSERT(std::fabs(np.spread.X - 250) < 0.001f);
+	UASSERT(std::fabs(np.spread.Y - 250) < 0.001f);
+	UASSERT(std::fabs(np.spread.Z - 250) < 0.001f);
+	UASSERT(np.seed == 12341);
+	UASSERT(np.octaves == 5);
+	UASSERT(std::fabs(np.persist - 0.7) < 0.001f);
+
+	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);
+
+	{
+		// Confirm settings
+		Settings s2("[dummy_eof_end_tag]");
+		std::istringstream is(config_text_after, std::ios_base::binary);
+		UASSERT(s2.parseConfigLines(is) == true);
+
+		compare_settings("(main)", &s, &s2);
+	}
+
+	} catch (SettingNotFoundException &e) {
+		UASSERT(!"Setting not found!");
+	}
+}
+
+void TestSettings::testDefaults()
+{
+	Settings *game = Settings::createLayer(SL_GAME);
+	Settings *def = Settings::getLayer(SL_DEFAULTS);
+
+	def->set("name", "FooBar");
+	UASSERT(def->get("name") == "FooBar");
+	UASSERT(game->get("name") == "FooBar");
+
+	game->set("name", "Baz");
+	UASSERT(game->get("name") == "Baz");
+
+	delete game;
+
+	// Restore default settings
+	delete Settings::getLayer(SL_DEFAULTS);
+	set_default_settings();
+}
+
+void TestSettings::testFlagDesc()
+{
+	Settings &s = *Settings::createLayer(SL_GAME);
+	FlagDesc flagdesc[] = {
+		{ "biomes",  0x01 },
+		{ "trees",   0x02 },
+		{ "jungles", 0x04 },
+		{ "oranges", 0x08 },
+		{ "tables",  0x10 },
+		{ nullptr,      0 }
+	};
+
+	// Enabled: biomes, jungles, oranges (default)
+	s.setDefault("test_desc", flagdesc, readFlagString(
+		"biomes,notrees,jungles,oranges", flagdesc, nullptr));
+	UASSERT(s.getFlagStr("test_desc", flagdesc, nullptr) == (0x01 | 0x04 | 0x08));
+
+	// Enabled: jungles, oranges, tables
+	s.set("test_desc", "nobiomes,tables");
+	UASSERT(s.getFlagStr("test_desc", flagdesc, nullptr) == (0x04 | 0x08 | 0x10));
+
+	// Enabled: (nothing)
+	s.set("test_desc", "nobiomes,nojungles,nooranges,notables");
+	UASSERT(s.getFlagStr("test_desc", flagdesc, nullptr) == 0x00);
+
+	// Numeric flag tests (override)
+	// Enabled: trees, tables
+	s.setDefault("test_flags", flagdesc, 0x02 | 0x10);
+	UASSERT(s.getFlagStr("test_flags", flagdesc, nullptr) == (0x02 | 0x10));
+
+	// Enabled: tables
+	s.set("test_flags", "16");
+	UASSERT(s.getFlagStr("test_flags", flagdesc, nullptr) == 0x10);
+
+	delete &s;
+}

src/unittest/test_socket.cpp

@@ -0,0 +1,149 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "log.h"
+#include "settings.h"
+#include "network/socket.h"
+
+class TestSocket : public TestBase {
+public:
+	TestSocket()
+	{
+		if (INTERNET_SIMULATOR == false)
+			TestManager::registerTestModule(this);
+	}
+
+	const char *getName() { return "TestSocket"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testIPv4Socket();
+	void testIPv6Socket();
+
+	static const int port = 30003;
+};
+
+static TestSocket g_test_instance;
+
+void TestSocket::runTests(IGameDef *gamedef)
+{
+	TEST(testIPv4Socket);
+
+	if (g_settings->getBool("enable_ipv6"))
+		TEST(testIPv6Socket);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestSocket::testIPv4Socket()
+{
+	Address address(0, 0, 0, 0, port);
+	Address bind_addr(0, 0, 0, 0, port);
+
+	/*
+	 * Try to use the bind_address for servers with no localhost address
+	 * For example: FreeBSD jails
+	 */
+	std::string bind_str = g_settings->get("bind_address");
+	try {
+		bind_addr.Resolve(bind_str.c_str());
+
+		if (!bind_addr.isIPv6()) {
+			address = bind_addr;
+		}
+	} catch (ResolveError &e) {
+	}
+
+	UDPSocket socket(false);
+	socket.Bind(address);
+
+	const char sendbuffer[] = "hello world!";
+	/*
+	 * If there is a bind address, use it.
+	 * It's useful in container environments
+	 */
+	if (address != Address(0, 0, 0, 0, port))
+		socket.Send(address, sendbuffer, sizeof(sendbuffer));
+	else
+		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);
+
+	if (address != Address(0, 0, 0, 0, port)) {
+		UASSERT(sender.getAddress().s_addr ==
+				address.getAddress().s_addr);
+	} else {
+		UASSERT(sender.getAddress().s_addr ==
+				Address(127, 0, 0, 1, 0).getAddress().s_addr);
+	}
+}
+
+void TestSocket::testIPv6Socket()
+{
+	Address address6((IPv6AddressBytes *)NULL, port);
+	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;
+		return;
+	}
+
+	const char sendbuffer[] = "hello world!";
+	IPv6AddressBytes bytes;
+	bytes.bytes[15] = 1;
+
+	socket6.Bind(address6);
+
+	{
+		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().s6_addr,
+				Address(&bytes, 0).getAddress6().s6_addr, 16) == 0);
+	}
+}

src/unittest/test_threading.cpp

@@ -0,0 +1,158 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 <atomic>
+#include "threading/semaphore.h"
+#include "threading/thread.h"
+
+
+class TestThreading : public TestBase {
+public:
+	TestThreading() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestThreading"; }
+	void runTests(IGameDef *gamedef);
+
+	void testStartStopWait();
+	void testAtomicSemaphoreThread();
+};
+
+static TestThreading g_test_instance;
+
+void TestThreading::runTests(IGameDef *gamedef)
+{
+	TEST(testStartStopWait);
+	TEST(testAtomicSemaphoreThread);
+}
+
+class SimpleTestThread : public Thread {
+public:
+	SimpleTestThread(unsigned int interval) :
+		Thread("SimpleTest"),
+		m_interval(interval)
+	{
+	}
+
+private:
+	void *run()
+	{
+		void *retval = this;
+
+		if (isCurrentThread() == false)
+			retval = (void *)0xBAD;
+
+		while (!stopRequested())
+			sleep_ms(m_interval);
+
+		return retval;
+	}
+
+	unsigned int m_interval;
+};
+
+void TestThreading::testStartStopWait()
+{
+	void *thread_retval;
+	SimpleTestThread *thread = new SimpleTestThread(25);
+
+	// Try this a couple times, since a Thread should be reusable after waiting
+	for (size_t i = 0; i != 5; i++) {
+		// Can't wait() on a joined, stopped thread
+		UASSERT(thread->wait() == false);
+
+		// start() should work the first time, but not the second.
+		UASSERT(thread->start() == true);
+		UASSERT(thread->start() == false);
+
+		UASSERT(thread->isRunning() == true);
+		UASSERT(thread->isCurrentThread() == false);
+
+		// Let it loop a few times...
+		sleep_ms(70);
+
+		// It's still running, so the return value shouldn't be available to us.
+		UASSERT(thread->getReturnValue(&thread_retval) == false);
+
+		// stop() should always succeed
+		UASSERT(thread->stop() == true);
+
+		// wait() only needs to wait the first time - the other two are no-ops.
+		UASSERT(thread->wait() == true);
+		UASSERT(thread->wait() == false);
+		UASSERT(thread->wait() == false);
+
+		// Now that the thread is stopped, we should be able to get the
+		// return value, and it should be the object itself.
+		thread_retval = NULL;
+		UASSERT(thread->getReturnValue(&thread_retval) == true);
+		UASSERT(thread_retval == thread);
+	}
+
+	delete thread;
+}
+
+
+
+class AtomicTestThread : public Thread {
+public:
+	AtomicTestThread(std::atomic<u32> &v, Semaphore &trigger) :
+		Thread("AtomicTest"),
+		val(v),
+		trigger(trigger)
+	{
+	}
+
+private:
+	void *run()
+	{
+		trigger.wait();
+		for (u32 i = 0; i < 0x10000; ++i)
+			++val;
+		return NULL;
+	}
+
+	std::atomic<u32> &val;
+	Semaphore &trigger;
+};
+
+
+void TestThreading::testAtomicSemaphoreThread()
+{
+	std::atomic<u32> val;
+	val = 0;
+	Semaphore trigger;
+	static const u8 num_threads = 4;
+
+	AtomicTestThread *threads[num_threads];
+	for (auto &thread : threads) {
+		thread = new AtomicTestThread(val, trigger);
+		UASSERT(thread->start());
+	}
+
+	trigger.post(num_threads);
+
+	for (AtomicTestThread *thread : threads) {
+		thread->wait();
+		delete thread;
+	}
+
+	UASSERT(val == num_threads * 0x10000);
+}
+

src/unittest/test_utilities.cpp

@@ -0,0 +1,638 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 <cmath>
+#include "util/enriched_string.h"
+#include "util/numeric.h"
+#include "util/string.h"
+#include "util/base64.h"
+
+class TestUtilities : public TestBase {
+public:
+	TestUtilities() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestUtilities"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testAngleWrapAround();
+	void testWrapDegrees_0_360_v3f();
+	void testLowercase();
+	void testTrim();
+	void testIsYes();
+	void testRemoveStringEnd();
+	void testUrlEncode();
+	void testUrlDecode();
+	void testPadString();
+	void testStartsWith();
+	void testStrEqual();
+	void testStrToIntConversion();
+	void testStringReplace();
+	void testStringAllowed();
+	void testAsciiPrintableHelper();
+	void testUTF8();
+	void testRemoveEscapes();
+	void testWrapRows();
+	void testEnrichedString();
+	void testIsNumber();
+	void testIsPowerOfTwo();
+	void testMyround();
+	void testStringJoin();
+	void testEulerConversion();
+	void testBase64();
+	void testSanitizeDirName();
+};
+
+static TestUtilities g_test_instance;
+
+void TestUtilities::runTests(IGameDef *gamedef)
+{
+	TEST(testAngleWrapAround);
+	TEST(testWrapDegrees_0_360_v3f);
+	TEST(testLowercase);
+	TEST(testTrim);
+	TEST(testIsYes);
+	TEST(testRemoveStringEnd);
+	TEST(testUrlEncode);
+	TEST(testUrlDecode);
+	TEST(testPadString);
+	TEST(testStartsWith);
+	TEST(testStrEqual);
+	TEST(testStrToIntConversion);
+	TEST(testStringReplace);
+	TEST(testStringAllowed);
+	TEST(testAsciiPrintableHelper);
+	TEST(testUTF8);
+	TEST(testRemoveEscapes);
+	TEST(testWrapRows);
+	TEST(testEnrichedString);
+	TEST(testIsNumber);
+	TEST(testIsPowerOfTwo);
+	TEST(testMyround);
+	TEST(testStringJoin);
+	TEST(testEulerConversion);
+	TEST(testBase64);
+	TEST(testSanitizeDirName);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline float ref_WrapDegrees180(float f)
+{
+	// This is a slower alternative to the wrapDegrees_180() function;
+	// used as a reference for testing
+	float value = fmodf(f + 180, 360);
+	if (value < 0)
+		value += 360;
+	return value - 180;
+}
+
+
+inline float ref_WrapDegrees_0_360(float f)
+{
+	// This is a slower alternative to the wrapDegrees_0_360() function;
+	// used as a reference for testing
+	float value = fmodf(f, 360);
+	if (value < 0)
+		value += 360;
+	return value < 0 ? value + 360 : value;
+}
+
+
+void TestUtilities::testAngleWrapAround() {
+    UASSERT(fabs(modulo360f(100.0) - 100.0) < 0.001);
+    UASSERT(fabs(modulo360f(720.5) - 0.5) < 0.001);
+    UASSERT(fabs(modulo360f(-0.5) - (-0.5)) < 0.001);
+    UASSERT(fabs(modulo360f(-365.5) - (-5.5)) < 0.001);
+
+    for (float f = -720; f <= -360; f += 0.25) {
+        UASSERT(std::fabs(modulo360f(f) - modulo360f(f + 360)) < 0.001);
+    }
+
+    for (float f = -1440; f <= 1440; f += 0.25) {
+        UASSERT(std::fabs(modulo360f(f) - fmodf(f, 360)) < 0.001);
+        UASSERT(std::fabs(wrapDegrees_180(f) - ref_WrapDegrees180(f)) < 0.001);
+        UASSERT(std::fabs(wrapDegrees_0_360(f) - ref_WrapDegrees_0_360(f)) < 0.001);
+        UASSERT(wrapDegrees_0_360(
+                std::fabs(wrapDegrees_180(f) - wrapDegrees_0_360(f))) < 0.001);
+    }
+
+}
+
+void TestUtilities::testWrapDegrees_0_360_v3f()
+{
+    // only x test with little step
+	for (float x = -720.f; x <= 720; x += 0.05) {
+        v3f r = wrapDegrees_0_360_v3f(v3f(x, 0, 0));
+        UASSERT(r.X >= 0.0f && r.X < 360.0f)
+        UASSERT(r.Y == 0.0f)
+        UASSERT(r.Z == 0.0f)
+    }
+
+    // only y test with little step
+    for (float y = -720.f; y <= 720; y += 0.05) {
+        v3f r = wrapDegrees_0_360_v3f(v3f(0, y, 0));
+        UASSERT(r.X == 0.0f)
+        UASSERT(r.Y >= 0.0f && r.Y < 360.0f)
+        UASSERT(r.Z == 0.0f)
+    }
+
+    // only z test with little step
+    for (float z = -720.f; z <= 720; z += 0.05) {
+        v3f r = wrapDegrees_0_360_v3f(v3f(0, 0, z));
+        UASSERT(r.X == 0.0f)
+        UASSERT(r.Y == 0.0f)
+        UASSERT(r.Z >= 0.0f && r.Z < 360.0f)
+	}
+
+    // test the whole coordinate translation
+    for (float x = -720.f; x <= 720; x += 2.5) {
+        for (float y = -720.f; y <= 720; y += 2.5) {
+            for (float z = -720.f; z <= 720; z += 2.5) {
+                v3f r = wrapDegrees_0_360_v3f(v3f(x, y, z));
+                UASSERT(r.X >= 0.0f && r.X < 360.0f)
+                UASSERT(r.Y >= 0.0f && r.Y < 360.0f)
+                UASSERT(r.Z >= 0.0f && r.Z < 360.0f)
+            }
+        }
+    }
+}
+
+
+void TestUtilities::testLowercase()
+{
+	UASSERT(lowercase("Foo bAR") == "foo bar");
+	UASSERT(lowercase("eeeeeeaaaaaaaaaaaààààà") == "eeeeeeaaaaaaaaaaaààààà");
+	UASSERT(lowercase("MINETEST-powa") == "minetest-powa");
+}
+
+
+void TestUtilities::testTrim()
+{
+	UASSERT(trim("") == "");
+	UASSERT(trim("dirt_with_grass") == "dirt_with_grass");
+	UASSERT(trim("\n \t\r  Foo bAR  \r\n\t\t  ") == "Foo bAR");
+	UASSERT(trim("\n \t\r    \r\n\t\t  ") == "");
+	UASSERT(trim("  a") == "a");
+	UASSERT(trim("a   ") == "a");
+}
+
+
+void TestUtilities::testIsYes()
+{
+	UASSERT(is_yes("YeS") == true);
+	UASSERT(is_yes("") == false);
+	UASSERT(is_yes("FAlse") == false);
+	UASSERT(is_yes("-1") == true);
+	UASSERT(is_yes("0") == false);
+	UASSERT(is_yes("1") == true);
+	UASSERT(is_yes("2") == true);
+}
+
+
+void TestUtilities::testRemoveStringEnd()
+{
+	const char *ends[] = {"abc", "c", "bc", "", NULL};
+	UASSERT(removeStringEnd("abc", ends) == "");
+	UASSERT(removeStringEnd("bc", ends) == "b");
+	UASSERT(removeStringEnd("12c", ends) == "12");
+	UASSERT(removeStringEnd("foo", ends) == "");
+}
+
+
+void TestUtilities::testUrlEncode()
+{
+	UASSERT(urlencode("\"Aardvarks lurk, OK?\"")
+			== "%22Aardvarks%20lurk%2C%20OK%3F%22");
+}
+
+
+void TestUtilities::testUrlDecode()
+{
+	UASSERT(urldecode("%22Aardvarks%20lurk%2C%20OK%3F%22")
+			== "\"Aardvarks lurk, OK?\"");
+}
+
+
+void TestUtilities::testPadString()
+{
+	UASSERT(padStringRight("hello", 8) == "hello   ");
+}
+
+void TestUtilities::testStartsWith()
+{
+	UASSERT(str_starts_with(std::string(), std::string()) == true);
+	UASSERT(str_starts_with(std::string("the sharp pickaxe"),
+		std::string()) == true);
+	UASSERT(str_starts_with(std::string("the sharp pickaxe"),
+		std::string("the")) == true);
+	UASSERT(str_starts_with(std::string("the sharp pickaxe"),
+		std::string("The")) == false);
+	UASSERT(str_starts_with(std::string("the sharp pickaxe"),
+		std::string("The"), true) == true);
+	UASSERT(str_starts_with(std::string("T"), std::string("The")) == false);
+}
+
+void TestUtilities::testStrEqual()
+{
+	UASSERT(str_equal(utf8_to_wide("abc"), utf8_to_wide("abc")));
+	UASSERT(str_equal(utf8_to_wide("ABC"), utf8_to_wide("abc"), true));
+}
+
+
+void TestUtilities::testStrToIntConversion()
+{
+	UASSERT(mystoi("123", 0, 1000) == 123);
+	UASSERT(mystoi("123", 0, 10) == 10);
+}
+
+
+void TestUtilities::testStringReplace()
+{
+	std::string test_str;
+	test_str = "Hello there";
+	str_replace(test_str, "there", "world");
+	UASSERT(test_str == "Hello world");
+	test_str = "ThisAisAaAtest";
+	str_replace(test_str, 'A', ' ');
+	UASSERT(test_str == "This is a test");
+}
+
+
+void TestUtilities::testStringAllowed()
+{
+	UASSERT(string_allowed("hello", "abcdefghijklmno") == true);
+	UASSERT(string_allowed("123", "abcdefghijklmno") == false);
+	UASSERT(string_allowed_blacklist("hello", "123") == true);
+	UASSERT(string_allowed_blacklist("hello123", "123") == false);
+}
+
+void TestUtilities::testAsciiPrintableHelper()
+{
+	UASSERT(IS_ASCII_PRINTABLE_CHAR('e') == true);
+	UASSERT(IS_ASCII_PRINTABLE_CHAR('\0') == false);
+
+	// Ensures that there is no cutting off going on...
+	// If there were, 331 would be cut to 75 in this example
+	// and 73 is a valid ASCII char.
+	int ch = 331;
+	UASSERT(IS_ASCII_PRINTABLE_CHAR(ch) == false);
+}
+
+void TestUtilities::testUTF8()
+{
+	UASSERT(utf8_to_wide("¤") == L"¤");
+
+	UASSERT(wide_to_utf8(L"¤") == "¤");
+
+	UASSERTEQ(std::string, wide_to_utf8(utf8_to_wide("")), "");
+	UASSERTEQ(std::string, wide_to_utf8(utf8_to_wide("the shovel dug a crumbly node!")),
+		"the shovel dug a crumbly node!");
+	UASSERTEQ(std::string, wide_to_utf8(utf8_to_wide("-ä-")),
+		"-ä-");
+	UASSERTEQ(std::string, wide_to_utf8(utf8_to_wide("-\xF0\xA0\x80\x8B-")),
+		"-\xF0\xA0\x80\x8B-");
+
+}
+
+void TestUtilities::testRemoveEscapes()
+{
+	UASSERT(unescape_enriched<wchar_t>(
+		L"abc\x1bXdef") == L"abcdef");
+	UASSERT(unescape_enriched<wchar_t>(
+		L"abc\x1b(escaped)def") == L"abcdef");
+	UASSERT(unescape_enriched<wchar_t>(
+		L"abc\x1b((escaped with parenthesis\\))def") == L"abcdef");
+	UASSERT(unescape_enriched<wchar_t>(
+		L"abc\x1b(incomplete") == L"abc");
+	UASSERT(unescape_enriched<wchar_t>(
+		L"escape at the end\x1b") == L"escape at the end");
+	// Nested escapes not supported
+	UASSERT(unescape_enriched<wchar_t>(
+		L"abc\x1b(outer \x1b(inner escape)escape)def") == L"abcescape)def");
+}
+
+void TestUtilities::testWrapRows()
+{
+	UASSERT(wrap_rows("12345678",4) == "1234\n5678");
+	// test that wrap_rows doesn't wrap inside multibyte sequences
+	{
+		const unsigned char s[] = {
+			0x2f, 0x68, 0x6f, 0x6d, 0x65, 0x2f, 0x72, 0x61, 0x70, 0x74, 0x6f,
+			0x72, 0x2f, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82, 0x2f,
+			0x6d, 0x69, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x62, 0x69,
+			0x6e, 0x2f, 0x2e, 0x2e, 0};
+		std::string str((char *)s);
+		UASSERT(utf8_to_wide(wrap_rows(str, 20)) != L"<invalid UTF-8 string>");
+	};
+	{
+		const unsigned char s[] = {
+			0x74, 0x65, 0x73, 0x74, 0x20, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x81,
+			0xd1, 0x82, 0x20, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82,
+			0x20, 0xd1, 0x82, 0xd0, 0xb5, 0xd1, 0x81, 0xd1, 0x82, 0};
+		std::string str((char *)s);
+		UASSERT(utf8_to_wide(wrap_rows(str, 8)) != L"<invalid UTF-8 string>");
+	}
+}
+
+void TestUtilities::testEnrichedString()
+{
+	EnrichedString str(L"Test bar");
+	irr::video::SColor color(0xFF, 0, 0, 0xFF);
+
+	UASSERT(str.substr(1, 3).getString() == L"est");
+	str += L" BUZZ";
+	UASSERT(str.substr(9, std::string::npos).getString() == L"BUZZ");
+	str.setDefaultColor(color); // Blue foreground
+	UASSERT(str.getColors()[5] == color);
+	// Green background, then white and yellow text
+	str = L"\x1b(b@#0F0)Regular \x1b(c@#FF0)yellow";
+	UASSERT(str.getColors()[2] == 0xFFFFFFFF);
+	str.setDefaultColor(color); // Blue foreground
+	UASSERT(str.getColors()[13] == 0xFFFFFF00); // Still yellow text
+	UASSERT(str.getBackground() == 0xFF00FF00); // Green background
+}
+
+void TestUtilities::testIsNumber()
+{
+	UASSERT(is_number("123") == true);
+	UASSERT(is_number("") == false);
+	UASSERT(is_number("123a") == false);
+}
+
+
+void TestUtilities::testIsPowerOfTwo()
+{
+	UASSERT(is_power_of_two(0) == false);
+	UASSERT(is_power_of_two(1) == true);
+	UASSERT(is_power_of_two(2) == true);
+	UASSERT(is_power_of_two(3) == false);
+	for (int exponent = 2; exponent <= 31; ++exponent) {
+		UASSERT(is_power_of_two((1U << exponent) - 1) == false);
+		UASSERT(is_power_of_two((1U << exponent)) == true);
+		UASSERT(is_power_of_two((1U << exponent) + 1) == false);
+	}
+	UASSERT(is_power_of_two(U32_MAX) == false);
+}
+
+void TestUtilities::testMyround()
+{
+	UASSERT(myround(4.6f) == 5);
+	UASSERT(myround(1.2f) == 1);
+	UASSERT(myround(-3.1f) == -3);
+	UASSERT(myround(-6.5f) == -7);
+}
+
+void TestUtilities::testStringJoin()
+{
+	std::vector<std::string> input;
+	UASSERT(str_join(input, ",") == "");
+
+	input.emplace_back("one");
+	UASSERT(str_join(input, ",") == "one");
+
+	input.emplace_back("two");
+	UASSERT(str_join(input, ",") == "one,two");
+
+	input.emplace_back("three");
+	UASSERT(str_join(input, ",") == "one,two,three");
+
+	input[1] = "";
+	UASSERT(str_join(input, ",") == "one,,three");
+
+	input[1] = "two";
+	UASSERT(str_join(input, " and ") == "one and two and three");
+}
+
+
+static bool within(const f32 value1, const f32 value2, const f32 precision)
+{
+	return std::fabs(value1 - value2) <= precision;
+}
+
+static bool within(const v3f &v1, const v3f &v2, const f32 precision)
+{
+	return within(v1.X, v2.X, precision) && within(v1.Y, v2.Y, precision)
+		&& within(v1.Z, v2.Z, precision);
+}
+
+static bool within(const core::matrix4 &m1, const core::matrix4 &m2,
+		const f32 precision)
+{
+	const f32 *M1 = m1.pointer();
+	const f32 *M2 = m2.pointer();
+	for (int i = 0; i < 16; i++)
+		if (! within(M1[i], M2[i], precision))
+			return false;
+	return true;
+}
+
+static bool roundTripsDeg(const v3f &v, const f32 precision)
+{
+	core::matrix4 m;
+	setPitchYawRoll(m, v);
+	return within(v, getPitchYawRoll(m), precision);
+}
+
+void TestUtilities::testEulerConversion()
+{
+	// This test may fail on non-IEEE systems.
+	// Low tolerance is 4 ulp(1.0) for binary floats with 24 bit mantissa.
+	// (ulp = unit in the last place; ulp(1.0) = 2^-23).
+	const f32 tolL = 4.76837158203125e-7f;
+	// High tolerance is 2 ulp(180.0), needed for numbers in degrees.
+	// ulp(180.0) = 2^-16
+	const f32 tolH = 3.0517578125e-5f;
+	v3f v1, v2;
+	core::matrix4 m1, m2;
+	const f32 *M1 = m1.pointer();
+	const f32 *M2 = m2.pointer();
+
+	// Check that the radians version and the degrees version
+	// produce the same results. Check also that the conversion
+	// works both ways for these values.
+	v1 = v3f(M_PI/3.0, M_PI/5.0, M_PI/4.0);
+	v2 = v3f(60.0f, 36.0f, 45.0f);
+	setPitchYawRollRad(m1, v1);
+	setPitchYawRoll(m2, v2);
+	UASSERT(within(m1, m2, tolL));
+	UASSERT(within(getPitchYawRollRad(m1), v1, tolL));
+	UASSERT(within(getPitchYawRoll(m2), v2, tolH));
+
+	// Check the rotation matrix produced.
+	UASSERT(within(M1[0], 0.932004869f, tolL));
+	UASSERT(within(M1[1], 0.353553385f, tolL));
+	UASSERT(within(M1[2], 0.0797927827f, tolL));
+	UASSERT(within(M1[4], -0.21211791f, tolL));
+	UASSERT(within(M1[5], 0.353553355f, tolL));
+	UASSERT(within(M1[6], 0.911046684f, tolL));
+	UASSERT(within(M1[8], 0.293892622f, tolL));
+	UASSERT(within(M1[9], -0.866025448f, tolL));
+	UASSERT(within(M1[10], 0.404508471f, tolL));
+
+	// Check that the matrix is still homogeneous with no translation
+	UASSERT(M1[3] == 0.0f);
+	UASSERT(M1[7] == 0.0f);
+	UASSERT(M1[11] == 0.0f);
+	UASSERT(M1[12] == 0.0f);
+	UASSERT(M1[13] == 0.0f);
+	UASSERT(M1[14] == 0.0f);
+	UASSERT(M1[15] == 1.0f);
+	UASSERT(M2[3] == 0.0f);
+	UASSERT(M2[7] == 0.0f);
+	UASSERT(M2[11] == 0.0f);
+	UASSERT(M2[12] == 0.0f);
+	UASSERT(M2[13] == 0.0f);
+	UASSERT(M2[14] == 0.0f);
+	UASSERT(M2[15] == 1.0f);
+
+	// Compare to Irrlicht's results. To be comparable, the
+	// angles must come in a different order and the matrix
+	// elements to compare are different too.
+	m2.setRotationRadians(v3f(v1.Z, v1.X, v1.Y));
+	UASSERT(within(M1[0], M2[5], tolL));
+	UASSERT(within(M1[1], M2[6], tolL));
+	UASSERT(within(M1[2], M2[4], tolL));
+
+	UASSERT(within(M1[4], M2[9], tolL));
+	UASSERT(within(M1[5], M2[10], tolL));
+	UASSERT(within(M1[6], M2[8], tolL));
+
+	UASSERT(within(M1[8], M2[1], tolL));
+	UASSERT(within(M1[9], M2[2], tolL));
+	UASSERT(within(M1[10], M2[0], tolL));
+
+	// Check that Eulers that produce near gimbal-lock still round-trip
+	UASSERT(roundTripsDeg(v3f(89.9999f, 17.f, 0.f), tolH));
+	UASSERT(roundTripsDeg(v3f(89.9999f, 0.f, 19.f), tolH));
+	UASSERT(roundTripsDeg(v3f(89.9999f, 17.f, 19.f), tolH));
+
+	// Check that Eulers at an angle > 90 degrees may not round-trip...
+	v1 = v3f(90.00001f, 1.f, 1.f);
+	setPitchYawRoll(m1, v1);
+	v2 = getPitchYawRoll(m1);
+	//UASSERT(within(v1, v2, tolL)); // this is typically false
+	// ... however the rotation matrix is the same for both
+	setPitchYawRoll(m2, v2);
+	UASSERT(within(m1, m2, tolL));
+}
+
+void TestUtilities::testBase64()
+{
+	// Test character set
+	UASSERT(base64_is_valid("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+		"abcdefghijklmnopqrstuvwxyz"
+		"0123456789+/") == true);
+	UASSERT(base64_is_valid("/+9876543210"
+		"zyxwvutsrqponmlkjihgfedcba"
+		"ZYXWVUTSRQPONMLKJIHGFEDCBA") == true);
+	UASSERT(base64_is_valid("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+		"abcdefghijklmnopqrstuvwxyz"
+		"0123456789+.") == false);
+	UASSERT(base64_is_valid("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+		"abcdefghijklmnopqrstuvwxyz"
+		"0123456789 /") == false);
+
+	// Test empty string
+	UASSERT(base64_is_valid("") == true);
+
+	// Test different lengths, with and without padding,
+	// with correct and incorrect padding
+	UASSERT(base64_is_valid("A") == false);
+	UASSERT(base64_is_valid("AA") == true);
+	UASSERT(base64_is_valid("AAA") == true);
+	UASSERT(base64_is_valid("AAAA") == true);
+	UASSERT(base64_is_valid("AAAAA") == false);
+	UASSERT(base64_is_valid("AAAAAA") == true);
+	UASSERT(base64_is_valid("AAAAAAA") == true);
+	UASSERT(base64_is_valid("AAAAAAAA") == true);
+	UASSERT(base64_is_valid("A===") == false);
+	UASSERT(base64_is_valid("AA==") == true);
+	UASSERT(base64_is_valid("AAA=") == true);
+	UASSERT(base64_is_valid("AAAA") == true);
+	UASSERT(base64_is_valid("AAAA====") == false);
+	UASSERT(base64_is_valid("AAAAA===") == false);
+	UASSERT(base64_is_valid("AAAAAA==") == true);
+	UASSERT(base64_is_valid("AAAAAAA=") == true);
+	UASSERT(base64_is_valid("AAAAAAA==") == false);
+	UASSERT(base64_is_valid("AAAAAAA===") == false);
+	UASSERT(base64_is_valid("AAAAAAA====") == false);
+	UASSERT(base64_is_valid("AAAAAAAA") == true);
+	UASSERT(base64_is_valid("AAAAAAAA=") == false);
+	UASSERT(base64_is_valid("AAAAAAAA==") == false);
+	UASSERT(base64_is_valid("AAAAAAAA===") == false);
+	UASSERT(base64_is_valid("AAAAAAAA====") == false);
+
+	// Test if canonical encoding
+	// Last character limitations, length % 4 == 3
+	UASSERT(base64_is_valid("AAB") == false);
+	UASSERT(base64_is_valid("AAE") == true);
+	UASSERT(base64_is_valid("AAQ") == true);
+	UASSERT(base64_is_valid("AAB=") == false);
+	UASSERT(base64_is_valid("AAE=") == true);
+	UASSERT(base64_is_valid("AAQ=") == true);
+	UASSERT(base64_is_valid("AAAAAAB=") == false);
+	UASSERT(base64_is_valid("AAAAAAE=") == true);
+	UASSERT(base64_is_valid("AAAAAAQ=") == true);
+	// Last character limitations, length % 4 == 2
+	UASSERT(base64_is_valid("AB") == false);
+	UASSERT(base64_is_valid("AE") == false);
+	UASSERT(base64_is_valid("AQ") == true);
+	UASSERT(base64_is_valid("AB==") == false);
+	UASSERT(base64_is_valid("AE==") == false);
+	UASSERT(base64_is_valid("AQ==") == true);
+	UASSERT(base64_is_valid("AAAAAB==") == false);
+	UASSERT(base64_is_valid("AAAAAE==") == false);
+	UASSERT(base64_is_valid("AAAAAQ==") == true);
+
+	// Extraneous character present
+	UASSERT(base64_is_valid(".") == false);
+	UASSERT(base64_is_valid("A.") == false);
+	UASSERT(base64_is_valid("AA.") == false);
+	UASSERT(base64_is_valid("AAA.") == false);
+	UASSERT(base64_is_valid("AAAA.") == false);
+	UASSERT(base64_is_valid("AAAAA.") == false);
+	UASSERT(base64_is_valid("A.A") == false);
+	UASSERT(base64_is_valid("AA.A") == false);
+	UASSERT(base64_is_valid("AAA.A") == false);
+	UASSERT(base64_is_valid("AAAA.A") == false);
+	UASSERT(base64_is_valid("AAAAA.A") == false);
+	UASSERT(base64_is_valid("\xE1""AAA") == false);
+
+	// Padding in wrong position
+	UASSERT(base64_is_valid("A=A") == false);
+	UASSERT(base64_is_valid("AA=A") == false);
+	UASSERT(base64_is_valid("AAA=A") == false);
+	UASSERT(base64_is_valid("AAAA=A") == false);
+	UASSERT(base64_is_valid("AAAAA=A") == false);
+}
+
+
+void TestUtilities::testSanitizeDirName()
+{
+	UASSERT(sanitizeDirName("a", "~") == "a");
+	UASSERT(sanitizeDirName("  ", "~") == "__");
+	UASSERT(sanitizeDirName(" a ", "~") == "_a_");
+	UASSERT(sanitizeDirName("COM1", "~") == "~COM1");
+	UASSERT(sanitizeDirName("COM1", ":") == "_COM1");
+	UASSERT(sanitizeDirName("cOm\u00B2", "~") == "~cOm\u00B2");
+	UASSERT(sanitizeDirName("cOnIn$", "~") == "~cOnIn$");
+	UASSERT(sanitizeDirName(" cOnIn$ ", "~") == "_cOnIn$_");
+}

src/unittest/test_voxelalgorithms.cpp

@@ -0,0 +1,101 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 "gamedef.h"
+#include "voxelalgorithms.h"
+#include "util/numeric.h"
+
+class TestVoxelAlgorithms : public TestBase {
+public:
+	TestVoxelAlgorithms() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestVoxelAlgorithms"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testVoxelLineIterator(const NodeDefManager *ndef);
+};
+
+static TestVoxelAlgorithms g_test_instance;
+
+void TestVoxelAlgorithms::runTests(IGameDef *gamedef)
+{
+	const NodeDefManager *ndef = gamedef->getNodeDefManager();
+
+	TEST(testVoxelLineIterator, ndef);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestVoxelAlgorithms::testVoxelLineIterator(const NodeDefManager *ndef)
+{
+	// Test some lines
+	// Do not test lines that start or end on the border of
+	// two voxels as rounding errors can make the test fail!
+	std::vector<core::line3d<f32> > lines;
+	for (f32 x = -9.1; x < 9; x += 3.124) {
+	for (f32 y = -9.2; y < 9; y += 3.123) {
+	for (f32 z = -9.3; z < 9; z += 3.122) {
+		lines.emplace_back(-x, -y, -z, x, y, z);
+	}
+	}
+	}
+	lines.emplace_back(0, 0, 0, 0, 0, 0);
+	// Test every line
+	std::vector<core::line3d<f32> >::iterator it = lines.begin();
+	for (; it < lines.end(); it++) {
+		core::line3d<f32> l = *it;
+
+		// Initialize test
+		voxalgo::VoxelLineIterator iterator(l.start, l.getVector());
+
+		//Test the first voxel
+		v3s16 start_voxel = floatToInt(l.start, 1);
+		UASSERT(iterator.m_current_node_pos == start_voxel);
+
+		// Values for testing
+		v3s16 end_voxel = floatToInt(l.end, 1);
+		v3s16 voxel_vector = end_voxel - start_voxel;
+		int nodecount = abs(voxel_vector.X) + abs(voxel_vector.Y)
+			+ abs(voxel_vector.Z);
+		int actual_nodecount = 0;
+		v3s16 old_voxel = iterator.m_current_node_pos;
+
+		while (iterator.hasNext()) {
+			iterator.next();
+			actual_nodecount++;
+			v3s16 new_voxel = iterator.m_current_node_pos;
+			// This must be a neighbor of the old voxel
+			UASSERTEQ(f32, (new_voxel - old_voxel).getLengthSQ(), 1);
+			// The line must intersect with the voxel
+			v3f voxel_center = intToFloat(iterator.m_current_node_pos, 1);
+			aabb3f box(voxel_center - v3f(0.5, 0.5, 0.5),
+				voxel_center + v3f(0.5, 0.5, 0.5));
+			UASSERT(box.intersectsWithLine(l));
+			// Update old voxel
+			old_voxel = new_voxel;
+		}
+
+		// Test last node
+		UASSERT(iterator.m_current_node_pos == end_voxel);
+		// Test node count
+		UASSERTEQ(int, actual_nodecount, nodecount);
+	}
+}

src/unittest/test_voxelarea.cpp

@@ -0,0 +1,388 @@
+/*
+Minetest
+Copyright (C) 2018 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
+
+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
+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 Lesser General Public License for more details.
+
+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 "voxel.h"
+
+class TestVoxelArea : public TestBase
+{
+public:
+	TestVoxelArea() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestVoxelArea"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void test_addarea();
+	void test_pad();
+	void test_extent();
+	void test_volume();
+	void test_contains_voxelarea();
+	void test_contains_point();
+	void test_contains_i();
+	void test_equal();
+	void test_plus();
+	void test_minor();
+	void test_index_xyz_all_pos();
+	void test_index_xyz_x_neg();
+	void test_index_xyz_y_neg();
+	void test_index_xyz_z_neg();
+	void test_index_xyz_xy_neg();
+	void test_index_xyz_xz_neg();
+	void test_index_xyz_yz_neg();
+	void test_index_xyz_all_neg();
+	void test_index_v3s16_all_pos();
+	void test_index_v3s16_x_neg();
+	void test_index_v3s16_y_neg();
+	void test_index_v3s16_z_neg();
+	void test_index_v3s16_xy_neg();
+	void test_index_v3s16_xz_neg();
+	void test_index_v3s16_yz_neg();
+	void test_index_v3s16_all_neg();
+	void test_add_x();
+	void test_add_y();
+	void test_add_z();
+	void test_add_p();
+};
+
+static TestVoxelArea g_test_instance;
+
+void TestVoxelArea::runTests(IGameDef *gamedef)
+{
+	TEST(test_addarea);
+	TEST(test_pad);
+	TEST(test_extent);
+	TEST(test_volume);
+	TEST(test_contains_voxelarea);
+	TEST(test_contains_point);
+	TEST(test_contains_i);
+	TEST(test_equal);
+	TEST(test_plus);
+	TEST(test_minor);
+	TEST(test_index_xyz_all_pos);
+	TEST(test_index_xyz_x_neg);
+	TEST(test_index_xyz_y_neg);
+	TEST(test_index_xyz_z_neg);
+	TEST(test_index_xyz_xy_neg);
+	TEST(test_index_xyz_xz_neg);
+	TEST(test_index_xyz_yz_neg);
+	TEST(test_index_xyz_all_neg);
+	TEST(test_index_v3s16_all_pos);
+	TEST(test_index_v3s16_x_neg);
+	TEST(test_index_v3s16_y_neg);
+	TEST(test_index_v3s16_z_neg);
+	TEST(test_index_v3s16_xy_neg);
+	TEST(test_index_v3s16_xz_neg);
+	TEST(test_index_v3s16_yz_neg);
+	TEST(test_index_v3s16_all_neg);
+	TEST(test_add_x);
+	TEST(test_add_y);
+	TEST(test_add_z);
+	TEST(test_add_p);
+}
+
+void TestVoxelArea::test_addarea()
+{
+	VoxelArea v1(v3s16(-1447, 8854, -875), v3s16(-147, -9547, 669));
+	VoxelArea v2(v3s16(-887, 4445, -5478), v3s16(447, -8779, 4778));
+
+	v1.addArea(v2);
+	UASSERT(v1.MinEdge == v3s16(-1447, 4445, -5478));
+	UASSERT(v1.MaxEdge == v3s16(447, -8779, 4778));
+}
+
+void TestVoxelArea::test_pad()
+{
+	VoxelArea v1(v3s16(-1447, 8854, -875), v3s16(-147, -9547, 669));
+	v1.pad(v3s16(100, 200, 300));
+
+	UASSERT(v1.MinEdge == v3s16(-1547, 8654, -1175));
+	UASSERT(v1.MaxEdge == v3s16(-47, -9347, 969));
+}
+
+void TestVoxelArea::test_extent()
+{
+	VoxelArea v1(v3s16(-1337, -547, -789), v3s16(-147, 447, 669));
+	UASSERT(v1.getExtent() == v3s16(1191, 995, 1459));
+
+	VoxelArea v2(v3s16(32493, -32507, 32752), v3s16(32508, -32492, 32767));
+	UASSERT(v2.getExtent() == v3s16(16, 16, 16));
+}
+
+void TestVoxelArea::test_volume()
+{
+	VoxelArea v1(v3s16(-1337, -547, -789), v3s16(-147, 447, 669));
+	UASSERTEQ(s32, v1.getVolume(), 1728980655);
+
+	VoxelArea v2(v3s16(32493, -32507, 32752), v3s16(32508, -32492, 32767));
+	UASSERTEQ(s32, v2.getVolume(), 4096);
+}
+
+void TestVoxelArea::test_contains_voxelarea()
+{
+	VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
+	UASSERTEQ(bool, v1.contains(VoxelArea(v3s16(-200, 10, 10), v3s16(-150, 10, 10))),
+			true);
+	UASSERTEQ(bool, v1.contains(VoxelArea(v3s16(-2550, 10, 10), v3s16(10, 10, 10))),
+			false);
+	UASSERTEQ(bool, v1.contains(VoxelArea(v3s16(-10, 10, 10), v3s16(3500, 10, 10))),
+			false);
+	UASSERTEQ(bool,
+			v1.contains(VoxelArea(
+					v3s16(-800, -400, 669), v3s16(-500, 200, 669))),
+			true);
+	UASSERTEQ(bool,
+			v1.contains(VoxelArea(
+					v3s16(-800, -400, 670), v3s16(-500, 200, 670))),
+			false);
+}
+
+void TestVoxelArea::test_contains_point()
+{
+	VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
+	UASSERTEQ(bool, v1.contains(v3s16(-200, 10, 10)), true);
+	UASSERTEQ(bool, v1.contains(v3s16(-10000, 10, 10)), false);
+	UASSERTEQ(bool, v1.contains(v3s16(-100, 10000, 10)), false);
+	UASSERTEQ(bool, v1.contains(v3s16(-100, 100, 10000)), false);
+	UASSERTEQ(bool, v1.contains(v3s16(-100, 100, -10000)), false);
+	UASSERTEQ(bool, v1.contains(v3s16(10000, 100, 10)), false);
+}
+
+void TestVoxelArea::test_contains_i()
+{
+	VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
+	UASSERTEQ(bool, v1.contains(10), true);
+	UASSERTEQ(bool, v1.contains(v1.getVolume()), false);
+	UASSERTEQ(bool, v1.contains(v1.getVolume() - 1), true);
+	UASSERTEQ(bool, v1.contains(v1.getVolume() + 1), false);
+	UASSERTEQ(bool, v1.contains(-1), false)
+
+	VoxelArea v2(v3s16(10, 10, 10), v3s16(30, 30, 30));
+	UASSERTEQ(bool, v2.contains(10), true);
+	UASSERTEQ(bool, v2.contains(0), true);
+	UASSERTEQ(bool, v2.contains(-1), false);
+}
+
+void TestVoxelArea::test_equal()
+{
+	VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
+	UASSERTEQ(bool, v1 == VoxelArea(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669)),
+			true);
+	UASSERTEQ(bool, v1 == VoxelArea(v3s16(0, 0, 0), v3s16(-147, 750, 669)), false);
+	UASSERTEQ(bool, v1 == VoxelArea(v3s16(0, 0, 0), v3s16(-147, 750, 669)), false);
+	UASSERTEQ(bool, v1 == VoxelArea(v3s16(0, 0, 0), v3s16(0, 0, 0)), false);
+}
+
+void TestVoxelArea::test_plus()
+{
+	VoxelArea v1(v3s16(-10, -10, -10), v3s16(100, 100, 100));
+	UASSERT(v1 + v3s16(10, 0, 0) ==
+			VoxelArea(v3s16(0, -10, -10), v3s16(110, 100, 100)));
+	UASSERT(v1 + v3s16(10, -10, 0) ==
+			VoxelArea(v3s16(0, -20, -10), v3s16(110, 90, 100)));
+	UASSERT(v1 + v3s16(0, 0, 35) ==
+			VoxelArea(v3s16(-10, -10, 25), v3s16(100, 100, 135)));
+}
+
+void TestVoxelArea::test_minor()
+{
+	VoxelArea v1(v3s16(-10, -10, -10), v3s16(100, 100, 100));
+	UASSERT(v1 - v3s16(10, 0, 0) ==
+			VoxelArea(v3s16(-20, -10, -10), v3s16(90, 100, 100)));
+	UASSERT(v1 - v3s16(10, -10, 0) ==
+			VoxelArea(v3s16(-20, 0, -10), v3s16(90, 110, 100)));
+	UASSERT(v1 - v3s16(0, 0, 35) ==
+			VoxelArea(v3s16(-10, -10, -45), v3s16(100, 100, 65)));
+}
+
+void TestVoxelArea::test_index_xyz_all_pos()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(156, 25, 236), 155);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(156, 25, 236), 1267138774);
+}
+
+void TestVoxelArea::test_index_xyz_x_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(-147, 25, 366), -148);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(-147, 25, 366), -870244825);
+}
+
+void TestVoxelArea::test_index_xyz_y_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(247, -269, 100), 246);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(247, -269, 100), -989760747);
+}
+
+void TestVoxelArea::test_index_xyz_z_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(244, 336, -887), 243);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(244, 336, -887), -191478876);
+}
+
+void TestVoxelArea::test_index_xyz_xy_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(-365, -47, 6978), -366);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(-365, -47, 6978), 1493679101);
+}
+
+void TestVoxelArea::test_index_xyz_yz_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(66, -58, -789), 65);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(66, -58, -789), 1435362734);
+}
+
+void TestVoxelArea::test_index_xyz_xz_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(-36, 589, -992), -37);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(-36, 589, -992), -1934371362);
+}
+
+void TestVoxelArea::test_index_xyz_all_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(-88, -99, -1474), -89);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(-88, -99, -1474), -1343473846);
+}
+
+void TestVoxelArea::test_index_v3s16_all_pos()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(v3s16(156, 25, 236)), 155);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(v3s16(156, 25, 236)), 1267138774);
+}
+
+void TestVoxelArea::test_index_v3s16_x_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(v3s16(-147, 25, 366)), -148);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(v3s16(-147, 25, 366)), -870244825);
+}
+
+void TestVoxelArea::test_index_v3s16_y_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(v3s16(247, -269, 100)), 246);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(v3s16(247, -269, 100)), -989760747);
+}
+
+void TestVoxelArea::test_index_v3s16_z_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(v3s16(244, 336, -887)), 243);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(v3s16(244, 336, -887)), -191478876);
+}
+
+void TestVoxelArea::test_index_v3s16_xy_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(v3s16(-365, -47, 6978)), -366);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(v3s16(-365, -47, 6978)), 1493679101);
+}
+
+void TestVoxelArea::test_index_v3s16_yz_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(v3s16(66, -58, -789)), 65);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(v3s16(66, -58, -789)), 1435362734);
+}
+
+void TestVoxelArea::test_index_v3s16_xz_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(v3s16(-36, 589, -992)), -37);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(v3s16(-36, 589, -992)), -1934371362);
+}
+
+void TestVoxelArea::test_index_v3s16_all_neg()
+{
+	VoxelArea v1;
+	UASSERTEQ(s32, v1.index(v3s16(-88, -99, -1474)), -89);
+
+	VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
+	UASSERTEQ(s32, v2.index(v3s16(-88, -99, -1474)), -1343473846);
+}
+
+void TestVoxelArea::test_add_x()
+{
+	v3s16 extent;
+	u32 i = 4;
+	VoxelArea::add_x(extent, i, 8);
+	UASSERTEQ(u32, i, 12)
+}
+
+void TestVoxelArea::test_add_y()
+{
+	v3s16 extent(740, 16, 87);
+	u32 i = 8;
+	VoxelArea::add_y(extent, i, 88);
+	UASSERTEQ(u32, i, 65128)
+}
+
+void TestVoxelArea::test_add_z()
+{
+	v3s16 extent(114, 80, 256);
+	u32 i = 4;
+	VoxelArea::add_z(extent, i, 8);
+	UASSERTEQ(u32, i, 72964)
+}
+
+void TestVoxelArea::test_add_p()
+{
+	v3s16 extent(33, 14, 742);
+	v3s16 a(15, 12, 369);
+	u32 i = 4;
+	VoxelArea::add_p(extent, i, a);
+	UASSERTEQ(u32, i, 170893)
+}

src/unittest/test_voxelmanipulator.cpp

@@ -0,0 +1,108 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+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
+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 Lesser General Public License for more details.
+
+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 <algorithm>
+
+#include "gamedef.h"
+#include "log.h"
+#include "voxel.h"
+
+class TestVoxelManipulator : public TestBase {
+public:
+	TestVoxelManipulator() { TestManager::registerTestModule(this); }
+	const char *getName() { return "TestVoxelManipulator"; }
+
+	void runTests(IGameDef *gamedef);
+
+	void testVoxelArea();
+	void testVoxelManipulator(const NodeDefManager *nodedef);
+};
+
+static TestVoxelManipulator g_test_instance;
+
+void TestVoxelManipulator::runTests(IGameDef *gamedef)
+{
+	TEST(testVoxelArea);
+	TEST(testVoxelManipulator, gamedef->getNodeDefManager());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TestVoxelManipulator::testVoxelArea()
+{
+	VoxelArea a(v3s16(-1,-1,-1), v3s16(1,1,1));
+	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));
+
+	std::list<VoxelArea> aa;
+	d.diff(c, aa);
+
+	// Correct results
+	std::vector<VoxelArea> results;
+	results.emplace_back(v3s16(-2,-2,-3), v3s16(3,2,-3));
+	results.emplace_back(v3s16(3,-2,-2), v3s16(3,2,2));
+
+	UASSERT(aa.size() == results.size());
+
+	infostream<<"Result of diff:"<<std::endl;
+	for (std::list<VoxelArea>::const_iterator
+			it = aa.begin(); it != aa.end(); ++it) {
+		it->print(infostream);
+		infostream << std::endl;
+
+		std::vector<VoxelArea>::iterator j;
+		j = std::find(results.begin(), results.end(), *it);
+		UASSERT(j != results.end());
+		results.erase(j);
+	}
+}
+
+
+void TestVoxelManipulator::testVoxelManipulator(const NodeDefManager *nodedef)
+{
+	VoxelManipulator v;
+
+	v.print(infostream, nodedef);
+
+	infostream << "*** Setting (-1,0,-1)=2 ***" << std::endl;
+	v.setNodeNoRef(v3s16(-1,0,-1), MapNode(t_CONTENT_GRASS));
+
+	v.print(infostream, nodedef);
+	UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == t_CONTENT_GRASS);
+
+	infostream << "*** Reading from inexistent (0,0,-1) ***" << std::endl;
+
+	EXCEPTION_CHECK(InvalidPositionException, v.getNode(v3s16(0,0,-1)));
+	v.print(infostream, nodedef);
+
+	infostream << "*** Adding area ***" << std::endl;
+
+	VoxelArea a(v3s16(-1,-1,-1), v3s16(1,1,1));
+	v.addArea(a);
+	v.print(infostream, nodedef);
+
+	UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == t_CONTENT_GRASS);
+	EXCEPTION_CHECK(InvalidPositionException, v.getNode(v3s16(0,1,1)));
+}