Merge branch 'master' into master

21 files changed, 2849 insertions, 1247 deletions

diff --git a/src/unittest/test.cpp b/src/unittest/test.cpp
index 0f6b36649..55471746a 100644
--- a/src/unittest/test.cpp
+++ b/src/unittest/test.cpp
@@ -41,7 +41,8 @@ content_t t_CONTENT_BRICK;
 //// TestGameDef
 ////
 
-class TestGameDef : public IGameDef {
+class TestGameDef : public IGameDef
+{
 public:
 	TestGameDef();
 	~TestGameDef();
@@ -69,13 +70,17 @@ public:
 		static std::vector<ModSpec> testmodspec;
 		return testmodspec;
 	}
-	virtual const ModSpec* getModSpec(const std::string &modname) const { return NULL; }
+	virtual const ModSpec *getModSpec(const std::string &modname) const
+	{
+		return NULL;
+	}
 	virtual std::string getModStoragePath() const { return "."; }
 	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);
+	bool sendModChannelMessage(
+			const std::string &channel, const std::string &message);
 	ModChannel *getModChannel(const std::string &channel)
 	{
 		return m_modchannel_mgr->getModChannel(channel);
@@ -94,9 +99,7 @@ private:
 	std::unique_ptr<ModChannelMgr> m_modchannel_mgr;
 };
 
-
-TestGameDef::TestGameDef() :
-	m_modchannel_mgr(new ModChannelMgr())
+TestGameDef::TestGameDef() : m_modchannel_mgr(new ModChannelMgr())
 {
 	m_itemdef = createItemDefManager();
 	m_nodedef = createNodeDefManager();
@@ -104,14 +107,12 @@ TestGameDef::TestGameDef() :
 	defineSomeNodes();
 }
 
-
 TestGameDef::~TestGameDef()
 {
 	delete m_itemdef;
 	delete m_nodedef;
 }
 
-
 void TestGameDef::defineSomeNodes()
 {
 	IWritableItemDefManager *idef = (IWritableItemDefManager *)m_itemdef;
@@ -127,9 +128,9 @@ void TestGameDef::defineSomeNodes()
 	itemdef.description = "Stone";
 	itemdef.groups["cracky"] = 3;
 	itemdef.inventory_image = "[inventorycube"
-		"{default_stone.png"
-		"{default_stone.png"
-		"{default_stone.png";
+				  "{default_stone.png"
+				  "{default_stone.png"
+				  "{default_stone.png";
 	f = ContentFeatures();
 	f.name = itemdef.name;
 	for (TileDef &tiledef : f.tiledef)
@@ -145,14 +146,14 @@ void TestGameDef::defineSomeNodes()
 	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";
+				  "{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++)
+	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);
@@ -167,7 +168,7 @@ void TestGameDef::defineSomeNodes()
 	f.param_type = CPT_LIGHT;
 	f.light_propagates = true;
 	f.sunlight_propagates = true;
-	f.light_source = LIGHT_MAX-1;
+	f.light_source = LIGHT_MAX - 1;
 	idef->registerItem(itemdef);
 	t_CONTENT_TORCH = ndef->set(f.name, f);
 
@@ -177,9 +178,9 @@ void TestGameDef::defineSomeNodes()
 	itemdef.name = "default:water";
 	itemdef.description = "Water";
 	itemdef.inventory_image = "[inventorycube"
-		"{default_water.png"
-		"{default_water.png"
-		"{default_water.png";
+				  "{default_water.png"
+				  "{default_water.png"
+				  "{default_water.png";
 	f = ContentFeatures();
 	f.name = itemdef.name;
 	f.alpha = 128;
@@ -198,15 +199,15 @@ void TestGameDef::defineSomeNodes()
 	itemdef.name = "default:lava";
 	itemdef.description = "Lava";
 	itemdef.inventory_image = "[inventorycube"
-		"{default_lava.png"
-		"{default_lava.png"
-		"{default_lava.png";
+				  "{default_lava.png"
+				  "{default_lava.png"
+				  "{default_lava.png";
 	f = ContentFeatures();
 	f.name = itemdef.name;
 	f.alpha = 128;
 	f.liquid_type = LIQUID_SOURCE;
 	f.liquid_viscosity = 7;
-	f.light_source = LIGHT_MAX-1;
+	f.light_source = LIGHT_MAX - 1;
 	f.is_ground_content = true;
 	f.groups["liquids"] = 3;
 	for (TileDef &tiledef : f.tiledef)
@@ -214,7 +215,6 @@ void TestGameDef::defineSomeNodes()
 	idef->registerItem(itemdef);
 	t_CONTENT_LAVA = ndef->set(f.name, f);
 
-
 	//// Brick
 	itemdef = ItemDefinition();
 	itemdef.type = ITEM_NODE;
@@ -222,9 +222,9 @@ void TestGameDef::defineSomeNodes()
 	itemdef.description = "Brick";
 	itemdef.groups["cracky"] = 3;
 	itemdef.inventory_image = "[inventorycube"
-		"{default_brick.png"
-		"{default_brick.png"
-		"{default_brick.png";
+				  "{default_brick.png"
+				  "{default_brick.png"
+				  "{default_brick.png";
 	f = ContentFeatures();
 	f.name = itemdef.name;
 	for (TileDef &tiledef : f.tiledef)
@@ -244,8 +244,8 @@ 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)
+bool TestGameDef::sendModChannelMessage(
+		const std::string &channel, const std::string &message)
 {
 	if (!m_modchannel_mgr->channelRegistered(channel))
 		return false;
@@ -264,9 +264,9 @@ bool run_tests()
 
 	g_logger.setLevelSilenced(LL_ERROR, true);
 
-	u32 num_modules_failed     = 0;
+	u32 num_modules_failed = 0;
 	u32 num_total_tests_failed = 0;
-	u32 num_total_tests_run    = 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))
@@ -282,16 +282,15 @@ bool run_tests()
 
 	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;
+	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;
 }
@@ -305,14 +304,13 @@ 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;
+		  << (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);
@@ -343,7 +341,6 @@ std::string TestBase::getTestTempFile()
 	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
diff --git a/src/unittest/test.h b/src/unittest/test.h
index 1102f6d33..efc5b71bf 100644
--- a/src/unittest/test.h
+++ b/src/unittest/test.h
@@ -27,81 +27,86 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "filesys.h"
 #include "mapnode.h"
 
-class TestFailedException : public std::exception {
+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;                 \
-}
+#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();                            \
+#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();                                     \
+#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 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);            \
-}
+#define EXCEPTION_CHECK(EType, code)                                                     \
+	{                                                                                \
+		bool exception_thrown = false;                                           \
+		try {                                                                    \
+			code;                                                            \
+		} catch (EType & e) {                                                    \
+			exception_thrown = true;                                         \
+		}                                                                        \
+		UASSERT(exception_thrown);                                               \
+	}
 
 class IGameDef;
 
-class TestBase {
+class TestBase
+{
 public:
 	bool testModule(IGameDef *gamedef);
 	std::string getTestTempDirectory();
@@ -117,7 +122,8 @@ private:
 	std::string m_test_dir;
 };
 
-class TestManager {
+class TestManager
+{
 public:
 	static std::vector<TestBase *> &getTestModules()
 	{
diff --git a/src/unittest/test_areastore.cpp b/src/unittest/test_areastore.cpp
index 691cd69d2..96a83cf25 100644
--- a/src/unittest/test_areastore.cpp
+++ b/src/unittest/test_areastore.cpp
@@ -21,7 +21,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "util/areastore.h"
 
-class TestAreaStore : public TestBase {
+class TestAreaStore : public TestBase
+{
 public:
 	TestAreaStore() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestAreaStore"; }
@@ -139,21 +140,22 @@ void TestAreaStore::testSerialization()
 	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
+	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);
 
@@ -170,4 +172,3 @@ void TestAreaStore::testSerialization()
 
 	UASSERTEQ(u32, c.id, 2);
 }
-
diff --git a/src/unittest/test_collision.cpp b/src/unittest/test_collision.cpp
index 2f39c2489..c47349721 100644
--- a/src/unittest/test_collision.cpp
+++ b/src/unittest/test_collision.cpp
@@ -21,7 +21,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "collision.h"
 
-class TestCollision : public TestBase {
+class TestCollision : public TestBase
+{
 public:
 	TestCollision() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestCollision"; }
@@ -43,138 +44,166 @@ void TestCollision::runTests(IGameDef *gamedef)
 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);
-		}
+		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);
-		}
+				// 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+
+				// 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);
-		}
-	}
+				// 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);
+				}
+			}
 }
diff --git a/src/unittest/test_compression.cpp b/src/unittest/test_compression.cpp
index dfcadd4b2..a572d7437 100644
--- a/src/unittest/test_compression.cpp
+++ b/src/unittest/test_compression.cpp
@@ -27,7 +27,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "nodedef.h"
 #include "noise.h"
 
-class TestCompression : public TestBase {
+class TestCompression : public TestBase
+{
 public:
 	TestCompression() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestCompression"; }
@@ -56,20 +57,20 @@ void TestCompression::runTests(IGameDef *gamedef)
 void TestCompression::testRLECompression()
 {
 	SharedBuffer<u8> fromdata(4);
-	fromdata[0]=1;
-	fromdata[1]=5;
-	fromdata[2]=5;
-	fromdata[3]=1;
+	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 << "str_out.size()=" << str_out.size() << std::endl;
 	infostream << "TestCompress: 1,5,5,1 -> ";
 	for (char i : str_out)
-		infostream << (u32) i << ",";
+		infostream << (u32)i << ",";
 	infostream << std::endl;
 
 	UASSERT(str_out.size() == 10);
@@ -93,7 +94,7 @@ void TestCompression::testRLECompression()
 
 	infostream << "decompress: ";
 	for (char i : str_out2)
-		infostream << (u32) i << ",";
+		infostream << (u32)i << ",";
 	infostream << std::endl;
 
 	UASSERTEQ(size_t, str_out2.size(), fromdata.getSize());
@@ -105,20 +106,20 @@ void TestCompression::testRLECompression()
 void TestCompression::testZlibCompression()
 {
 	SharedBuffer<u8> fromdata(4);
-	fromdata[0]=1;
-	fromdata[1]=5;
-	fromdata[2]=5;
-	fromdata[3]=1;
+	fromdata[0] = 1;
+	fromdata[1] = 5;
+	fromdata[2] = 5;
+	fromdata[3] = 1;
 
 	std::ostringstream os(std::ios_base::binary);
 	compress(fromdata, os, SER_FMT_VER_HIGHEST_READ);
 
 	std::string str_out = os.str();
 
-	infostream << "str_out.size()=" << str_out.size() <<std::endl;
+	infostream << "str_out.size()=" << str_out.size() << std::endl;
 	infostream << "TestCompress: 1,5,5,1 -> ";
 	for (char i : str_out)
-		infostream << (u32) i << ",";
+		infostream << (u32)i << ",";
 	infostream << std::endl;
 
 	std::istringstream is(str_out, std::ios_base::binary);
@@ -129,7 +130,7 @@ void TestCompression::testZlibCompression()
 
 	infostream << "decompress: ";
 	for (char i : str_out2)
-		infostream << (u32) i << ",";
+		infostream << (u32)i << ",";
 	infostream << std::endl;
 
 	UASSERTEQ(size_t, str_out2.size(), fromdata.getSize());
@@ -141,11 +142,11 @@ void TestCompression::testZlibCompression()
 void TestCompression::testZlibLargeData()
 {
 	infostream << "Test: Testing zlib wrappers with a large amount "
-		"of pseudorandom data" << std::endl;
+		      "of pseudorandom data"
+		   << std::endl;
 
 	u32 size = 50000;
-	infostream << "Test: Input size of large compressZlib is "
-		<< size << std::endl;
+	infostream << "Test: Input size of large compressZlib is " << size << std::endl;
 
 	std::string data_in;
 	data_in.resize(size);
@@ -156,21 +157,21 @@ void TestCompression::testZlibLargeData()
 	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;
+		   << 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;
+		   << 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]);
+				"index out[%i]=%i differs from in[%i]=%i", i,
+				str_decompressed[i], i, data_in[i]);
 	}
 }
 
@@ -183,10 +184,8 @@ void TestCompression::testZlibLimit()
 
 	// test around buffer borders
 	u32 bufsize = 16384; // as in implementation
-	for (int s = -1; s <= 1; s++)
-	{
-		for (int l = -1; l <= 1; l++)
-		{
+	for (int s = -1; s <= 1; s++) {
+		for (int l = -1; l <= 1; l++) {
 			_testZlibLimit(bufsize + s, bufsize + l);
 		}
 	}
@@ -198,10 +197,11 @@ void TestCompression::testZlibLimit()
 void TestCompression::_testZlibLimit(u32 size, u32 limit)
 {
 	infostream << "Test: Testing zlib wrappers with a decompression "
-		"memory limit of " << limit << std::endl;
+		      "memory limit of "
+		   << limit << std::endl;
 
-	infostream << "Test: Input size of compressZlib for limit is "
-		<< size << 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;
@@ -215,21 +215,20 @@ void TestCompression::_testZlibLimit(u32 size, u32 limit)
 	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;
+		   << 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;
+		   << 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]);
+				"index out[%i]=%i differs from in[%i]=%i", i,
+				str_decompressed[i], i, data_in[i]);
 	}
 }
-
diff --git a/src/unittest/test_connection.cpp b/src/unittest/test_connection.cpp
index c5e4085e1..dc25a70af 100644
--- a/src/unittest/test_connection.cpp
+++ b/src/unittest/test_connection.cpp
@@ -27,7 +27,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "network/networkpacket.h"
 #include "network/socket.h"
 
-class TestConnection : public TestBase {
+class TestConnection : public TestBase
+{
 public:
 	TestConnection()
 	{
@@ -59,16 +60,20 @@ struct Handler : public con::PeerHandler
 
 	void peerAdded(con::Peer *peer)
 	{
-		infostream << "Handler(" << name << ")::peerAdded(): "
-			"id=" << peer->id << std::endl;
+		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;
+		infostream << "Handler(" << name
+			   << ")::deletingPeer(): "
+			      "id="
+			   << peer->id << ", timeout=" << timeout << std::endl;
 		last_id = peer->id;
 		count--;
 	}
@@ -86,11 +91,10 @@ void TestConnection::testHelpers()
 	u8 channel = 2;
 	SharedBuffer<u8> data1(1);
 	data1[0] = 100;
-	Address a(127,0,0,1, 10);
+	Address a(127, 0, 0, 1, 10);
 	const u16 seqnum = 34352;
 
-	con::BufferedPacket p1 = con::makePacket(a, data1,
-			proto_id, peer_id, channel);
+	con::BufferedPacket p1 = con::makePacket(a, data1, proto_id, peer_id, channel);
 	/*
 		We should now have a packet with this data:
 		Header:
@@ -105,7 +109,7 @@ void TestConnection::testHelpers()
 	UASSERT(readU8(&p1.data[6]) == channel);
 	UASSERT(readU8(&p1.data[7]) == data1[0]);
 
-	//infostream<<"initial data1[0]="<<((u32)data1[0]&0xff)<<std::endl;
+	// infostream<<"initial data1[0]="<<((u32)data1[0]&0xff)<<std::endl;
 
 	SharedBuffer<u8> p2 = con::makeReliablePacket(data1, seqnum);
 
@@ -121,7 +125,6 @@ void TestConnection::testHelpers()
 	UASSERT(readU8(&p2[3]) == data1[0]);
 }
 
-
 void TestConnection::testConnectSendReceive()
 {
 	/*
@@ -181,7 +184,7 @@ void TestConnection::testConnectSendReceive()
 		infostream << "** running client.Receive()" << std::endl;
 		client.Receive(&pkt);
 		infostream << "** Client received: peer_id=" << pkt.getPeerId()
-			<< ", size=" << pkt.getSize() << std::endl;
+			   << ", size=" << pkt.getSize() << std::endl;
 	} catch (con::NoIncomingDataException &e) {
 	}
 
@@ -198,8 +201,7 @@ void TestConnection::testConnectSendReceive()
 		infostream << "** running server.Receive()" << std::endl;
 		server.Receive(&pkt);
 		infostream << "** Server received: peer_id=" << pkt.getPeerId()
-				<< ", size=" << pkt.getSize()
-				<< std::endl;
+			   << ", size=" << pkt.getSize() << std::endl;
 	} catch (con::NoIncomingDataException &e) {
 		// No actual data received, but the client has
 		// probably been connected
@@ -212,7 +214,7 @@ void TestConnection::testConnectSendReceive()
 	UASSERT(hand_server.count == 1);
 	UASSERT(hand_server.last_id == 2);
 
-	//sleep_ms(50);
+	// sleep_ms(50);
 
 	while (client.Connected() == false) {
 		try {
@@ -220,7 +222,7 @@ void TestConnection::testConnectSendReceive()
 			infostream << "** running client.Receive()" << std::endl;
 			client.Receive(&pkt);
 			infostream << "** Client received: peer_id=" << pkt.getPeerId()
-				<< ", size=" << pkt.getSize() << std::endl;
+				   << ", size=" << pkt.getSize() << std::endl;
 		} catch (con::NoIncomingDataException &e) {
 		}
 		sleep_ms(50);
@@ -233,8 +235,7 @@ void TestConnection::testConnectSendReceive()
 		infostream << "** running server.Receive()" << std::endl;
 		server.Receive(&pkt);
 		infostream << "** Server received: peer_id=" << pkt.getPeerId()
-				<< ", size=" << pkt.getSize()
-				<< std::endl;
+			   << ", size=" << pkt.getSize() << std::endl;
 	} catch (con::NoIncomingDataException &e) {
 	}
 
@@ -243,11 +244,11 @@ void TestConnection::testConnectSendReceive()
 	*/
 	{
 		NetworkPacket pkt;
-		pkt.putRawPacket((u8*) "Hello World !", 14, 0);
+		pkt.putRawPacket((u8 *)"Hello World !", 14, 0);
 
 		SharedBuffer<u8> sentdata = pkt.oldForgePacket();
 
-		infostream<<"** running client.Send()"<<std::endl;
+		infostream << "** running client.Send()" << std::endl;
 		client.Send(PEER_ID_SERVER, 0, &pkt, true);
 
 		sleep_ms(50);
@@ -256,9 +257,8 @@ void TestConnection::testConnectSendReceive()
 		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;
+			   << ", size=" << pkt.getSize()
+			   << ", data=" << (const char *)pkt.getU8Ptr(0) << std::endl;
 
 		SharedBuffer<u8> recvdata = pkt.oldForgePacket();
 
@@ -272,8 +272,8 @@ void TestConnection::testConnectSendReceive()
 	{
 		const int datasize = 30000;
 		NetworkPacket pkt(0, datasize);
-		for (u16 i=0; i<datasize; i++) {
-			pkt << (u8) i/4;
+		for (u16 i = 0; i < datasize; i++) {
+			pkt << (u8)i / 4;
 		}
 
 		infostream << "Sending data (size=" << datasize << "):";
@@ -282,8 +282,8 @@ void TestConnection::testConnectSendReceive()
 				infostream << " ";
 			char buf[10];
 			porting::mt_snprintf(buf, sizeof(buf), "%.2X",
-				((int)((const char *)pkt.getU8Ptr(0))[i]) & 0xff);
-			infostream<<buf;
+					((int)((const char *)pkt.getU8Ptr(0))[i]) & 0xff);
+			infostream << buf;
 		}
 		if (datasize > 20)
 			infostream << "...";
@@ -293,7 +293,7 @@ void TestConnection::testConnectSendReceive()
 
 		server.Send(peer_id_client, 0, &pkt, true);
 
-		//sleep_ms(3000);
+		// sleep_ms(3000);
 
 		SharedBuffer<u8> recvdata;
 		infostream << "** running client.Receive()" << std::endl;
@@ -317,14 +317,15 @@ void TestConnection::testConnectSendReceive()
 		}
 		UASSERT(received);
 		infostream << "** Client received: peer_id=" << peer_id
-			<< ", size=" << size << std::endl;
+			   << ", 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);
+			porting::mt_snprintf(buf, sizeof(buf), "%.2X",
+					((int)(recvdata[i])) & 0xff);
 			infostream << buf;
 		}
 		if (size > 20)
diff --git a/src/unittest/test_filepath.cpp b/src/unittest/test_filepath.cpp
index ac2d69b5a..dea290ab6 100644
--- a/src/unittest/test_filepath.cpp
+++ b/src/unittest/test_filepath.cpp
@@ -26,7 +26,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "nodedef.h"
 #include "noise.h"
 
-class TestFilePath : public TestBase {
+class TestFilePath : public TestBase
+{
 public:
 	TestFilePath() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestFilePath"; }
@@ -65,15 +66,14 @@ std::string p(std::string path)
 		}
 	}
 
-	#ifdef _WIN32
+#ifdef _WIN32
 	if (path[0] == '\\')
 		path = "C:" + path;
-	#endif
+#endif
 
 	return path;
 }
 
-
 void TestFilePath::testIsDirDelimiter()
 {
 	UASSERT(fs::IsDirDelimiter('/') == true);
@@ -86,23 +86,22 @@ void TestFilePath::testIsDirDelimiter()
 #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"),
+			"",
+			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
@@ -114,55 +113,51 @@ void TestFilePath::testPathStartsWith()
 			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},
+			{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);
+		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;
@@ -199,7 +194,6 @@ void TestFilePath::testRemoveLastPathComponent()
 	UASSERT(removed == p("home/user/minetest/bin/../worlds/world1"));
 }
 
-
 void TestFilePath::testRemoveLastPathComponentWithTrailingDelimiter()
 {
 	std::string path, result, removed;
@@ -235,7 +229,6 @@ void TestFilePath::testRemoveLastPathComponentWithTrailingDelimiter()
 	UASSERT(removed == p("home/user/minetest/bin/../worlds/world1"));
 }
 
-
 void TestFilePath::testRemoveRelativePathComponent()
 {
 	std::string path, result, removed;
diff --git a/src/unittest/test_inventory.cpp b/src/unittest/test_inventory.cpp
index 5f71636c4..3359a75fa 100644
--- a/src/unittest/test_inventory.cpp
+++ b/src/unittest/test_inventory.cpp
@@ -24,7 +24,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "gamedef.h"
 #include "inventory.h"
 
-class TestInventory : public TestBase {
+class TestInventory : public TestBase
+{
 public:
 	TestInventory() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestInventory"; }
@@ -80,47 +81,44 @@ void TestInventory::testSerializeDeserialize(IItemDefManager *idef)
 	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";
+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";
diff --git a/src/unittest/test_keycode.cpp b/src/unittest/test_keycode.cpp
index 3813af949..f9ba568e0 100644
--- a/src/unittest/test_keycode.cpp
+++ b/src/unittest/test_keycode.cpp
@@ -23,7 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "exceptions.h"
 #include "client/keycode.h"
 
-class TestKeycode : public TestBase {
+class TestKeycode : public TestBase
+{
 public:
 	TestKeycode() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestKeycode"; }
@@ -114,7 +115,8 @@ void TestKeycode::testCompare()
 	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
+	// 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'=';
diff --git a/src/unittest/test_map_settings_manager.cpp b/src/unittest/test_map_settings_manager.cpp
index 0a5c971b9..c4edc1f06 100644
--- a/src/unittest/test_map_settings_manager.cpp
+++ b/src/unittest/test_map_settings_manager.cpp
@@ -1,4 +1,4 @@
- /*
+/*
 Minetest
 Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
 
@@ -25,7 +25,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "util/sha1.h"
 #include "map_settings_manager.h"
 
-class TestMapSettingsManager : public TestBase {
+class TestMapSettingsManager : public TestBase
+{
 public:
 	TestMapSettingsManager() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestMapSettingsManager"; }
@@ -51,7 +52,6 @@ void TestMapSettingsManager::runTests(IGameDef *gamedef)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-
 void check_noise_params(const NoiseParams *np1, const NoiseParams *np2)
 {
 	UASSERTEQ(float, np1->offset, np2->offset);
@@ -64,7 +64,6 @@ void check_noise_params(const NoiseParams *np1, const NoiseParams *np2)
 	UASSERTEQ(u32, np1->flags, np2->flags);
 }
 
-
 std::string read_file_to_string(const std::string &filepath)
 {
 	std::string buf;
@@ -89,7 +88,6 @@ std::string read_file_to_string(const std::string &filepath)
 	return buf;
 }
 
-
 void TestMapSettingsManager::makeUserConfig(Settings *conf)
 {
 	conf->set("mg_name", "v7");
@@ -101,17 +99,17 @@ void TestMapSettingsManager::makeUserConfig(Settings *conf)
 	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";
+	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);
@@ -125,7 +123,6 @@ std::string TestMapSettingsManager::makeMetaFile(bool make_corrupt)
 	return metafile;
 }
 
-
 void TestMapSettingsManager::testMapSettingsManager()
 {
 	Settings user_settings;
@@ -150,7 +147,7 @@ void TestMapSettingsManager::testMapSettingsManager()
 	UASSERT(mgr.getMapSetting("water_level", &value));
 	UASSERT(value == "20");
 
-    // Pretend we have some mapgen settings configured from the scripting
+	// 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));
@@ -158,10 +155,12 @@ void TestMapSettingsManager::testMapSettingsManager()
 	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);
+	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_filler_depth", &script_np_filler_depth, true);
 	mgr.setMapSettingNoiseParams("mgv5_np_height", &script_np_height);
 	mgr.setMapSettingNoiseParams("mgv5_np_factor", &script_np_factor);
 
@@ -209,12 +208,11 @@ void TestMapSettingsManager::testMapSettingsManager()
 #endif
 }
 
-
 void TestMapSettingsManager::testMapMetaSaveLoad()
 {
 	Settings conf;
-	std::string path = getTestTempDirectory()
-		+ DIR_DELIM + "foobar" + DIR_DELIM + "map_meta.txt";
+	std::string path = getTestTempDirectory() + DIR_DELIM + "foobar" + DIR_DELIM +
+			   "map_meta.txt";
 
 	// Create a set of mapgen params and save them to map meta
 	conf.set("seed", "12345");
@@ -239,7 +237,6 @@ void TestMapSettingsManager::testMapMetaSaveLoad()
 	UASSERTEQ(s16, params2->water_level, 5);
 }
 
-
 void TestMapSettingsManager::testMapMetaFailures()
 {
 	std::string test_mapmeta_path;
diff --git a/src/unittest/test_noderesolver.cpp b/src/unittest/test_noderesolver.cpp
index 28da43620..b8ef758f0 100644
--- a/src/unittest/test_noderesolver.cpp
+++ b/src/unittest/test_noderesolver.cpp
@@ -26,8 +26,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include <algorithm>
 
-
-class TestNodeResolver : public TestBase {
+class TestNodeResolver : public TestBase
+{
 public:
 	TestNodeResolver() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestNodeResolver"; }
@@ -44,8 +44,7 @@ static TestNodeResolver g_test_instance;
 
 void TestNodeResolver::runTests(IGameDef *gamedef)
 {
-	NodeDefManager *ndef =
-		(NodeDefManager *)gamedef->getNodeDefManager();
+	NodeDefManager *ndef = (NodeDefManager *)gamedef->getNodeDefManager();
 
 	ndef->resetNodeResolveState();
 	TEST(testNodeResolving, ndef);
@@ -54,7 +53,8 @@ void TestNodeResolver::runTests(IGameDef *gamedef)
 	TEST(testPendingResolveCancellation, ndef);
 }
 
-class Foobar : public NodeResolver {
+class Foobar : public NodeResolver
+{
 public:
 	void resolveNodeNames();
 
@@ -69,7 +69,8 @@ public:
 	std::vector<content_t> test_nr_list_empty;
 };
 
-class Foobaz : public NodeResolver {
+class Foobaz : public NodeResolver
+{
 public:
 	void resolveNodeNames();
 
@@ -84,26 +85,23 @@ 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_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_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;
@@ -147,9 +145,9 @@ void TestNodeResolver::testNodeResolving(NodeDefManager *ndef)
 
 	// 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,
+			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++)
@@ -157,31 +155,30 @@ void TestNodeResolver::testNodeResolving(NodeDefManager *ndef)
 
 	// 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,
+			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]));
+				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,
+			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]);
+				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;
diff --git a/src/unittest/test_noise.cpp b/src/unittest/test_noise.cpp
index 421f3b66e..419e6710f 100644
--- a/src/unittest/test_noise.cpp
+++ b/src/unittest/test_noise.cpp
@@ -23,7 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "exceptions.h"
 #include "noise.h"
 
-class TestNoise : public TestBase {
+class TestNoise : public TestBase
+{
 public:
 	TestNoise() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestNoise"; }
@@ -55,25 +56,25 @@ void TestNoise::runTests(IGameDef *gamedef)
 
 void TestNoise::testNoise2dPoint()
 {
-	NoiseParams np_normal(20, 40, v3f(50, 50, 50), 9,  5, 0.6, 2.0);
+	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);
-	}
+		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);
+	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 actual = noisevals[i];
 		float expected = expected_2d_results[i];
 		UASSERT(std::fabs(actual - expected) <= 0.00001);
 	}
@@ -81,16 +82,16 @@ void TestNoise::testNoise2dBulk()
 
 void TestNoise::testNoise3dPoint()
 {
-	NoiseParams np_normal(20, 40, v3f(50, 50, 50), 9,  5, 0.6, 2.0);
+	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);
-	}
+		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()
@@ -100,7 +101,7 @@ void TestNoise::testNoise3dBulk()
 	float *noisevals = noise_normal_3d.perlinMap3D(0, 0, 0, NULL);
 
 	for (u32 i = 0; i != 10 * 10 * 10; i++) {
-		float actual   = noisevals[i];
+		float actual = noisevals[i];
 		float expected = expected_3d_results[i];
 		UASSERT(std::fabs(actual - expected) <= 0.00001);
 	}
@@ -122,165 +123,1107 @@ void TestNoise::testNoiseInvalidParams()
 }
 
 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,
+		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,
+		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,
 };
diff --git a/src/unittest/test_random.cpp b/src/unittest/test_random.cpp
index 14de764e1..5a73e38fa 100644
--- a/src/unittest/test_random.cpp
+++ b/src/unittest/test_random.cpp
@@ -1,4 +1,4 @@
- /*
+/*
 Minetest
 Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
 
@@ -24,7 +24,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "exceptions.h"
 #include "noise.h"
 
-class TestRandom : public TestBase {
+class TestRandom : public TestBase
+{
 public:
 	TestRandom() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestRandom"; }
@@ -66,7 +67,6 @@ void TestRandom::testPseudoRandom()
 		UASSERTEQ(int, pr.next(), expected_pseudorandom_results[i]);
 }
 
-
 void TestRandom::testPseudoRandomRange()
 {
 	PseudoRandom pr((int)time(NULL));
@@ -86,7 +86,6 @@ void TestRandom::testPseudoRandomRange()
 	}
 }
 
-
 void TestRandom::testPcgRandom()
 {
 	PcgRandom pr(814538, 998877);
@@ -95,7 +94,6 @@ void TestRandom::testPcgRandom()
 		UASSERTEQ(u32, pr.next(), expected_pcgrandom_results[i]);
 }
 
-
 void TestRandom::testPcgRandomRange()
 {
 	PcgRandom pr((int)time(NULL));
@@ -117,7 +115,6 @@ void TestRandom::testPcgRandomRange()
 	}
 }
 
-
 void TestRandom::testPcgRandomBytes()
 {
 	char buf[32];
@@ -126,15 +123,14 @@ void TestRandom::testPcgRandomBytes()
 	memset(buf, 0, sizeof(buf));
 	r.bytes(buf + 5, 23);
 	UASSERT(memcmp(buf + 5, expected_pcgrandom_bytes_result,
-		sizeof(expected_pcgrandom_bytes_result)) == 0);
+				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);
+				sizeof(expected_pcgrandom_bytes_result2)) == 0);
 }
 
-
 void TestRandom::testPcgRandomNormalDist()
 {
 	static const int max = 120;
@@ -155,17 +151,17 @@ void TestRandom::testPcgRandomNormalDist()
 
 	// 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;
+	int range = (max - min + 1);
+	float mean = (max + min) / 2;
 	float variance = ((range * range - 1) / 12) / num_trials;
-	float stddev   = std::sqrt(variance);
+	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
+			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
@@ -185,91 +181,574 @@ void TestRandom::testPcgRandomNormalDist()
 	}
 }
 
-
 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,
+		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,
+		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,
+		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,
+		0x47,
+		0x9e,
+		0x08,
+		0x3e,
+		0xd4,
+		0x21,
+		0x2d,
+		0xf6,
+		0xb4,
+		0xb1,
+		0x9d,
+		0x7a,
+		0x60,
+		0x02,
+		0x5a,
+		0xb2,
+		0x11,
+		0x00,
+		0x00,
+		0x00,
+		0x00,
+		0x00,
+		0x00,
+		0x00,
 };
diff --git a/src/unittest/test_schematic.cpp b/src/unittest/test_schematic.cpp
index da4ce50d2..cee5abdd8 100644
--- a/src/unittest/test_schematic.cpp
+++ b/src/unittest/test_schematic.cpp
@@ -1,4 +1,4 @@
- /*
+/*
 Minetest
 Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
 
@@ -23,7 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "gamedef.h"
 #include "nodedef.h"
 
-class TestSchematic : public TestBase {
+class TestSchematic : public TestBase
+{
 public:
 	TestSchematic() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestSchematic"; }
@@ -44,8 +45,7 @@ static TestSchematic g_test_instance;
 
 void TestSchematic::runTests(IGameDef *gamedef)
 {
-	NodeDefManager *ndef =
-		(NodeDefManager *)gamedef->getNodeDefManager();
+	NodeDefManager *ndef = (NodeDefManager *)gamedef->getNodeDefManager();
 
 	ndef->setNodeRegistrationStatus(true);
 
@@ -63,8 +63,8 @@ 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);
+	std::stringstream ss(
+			std::ios_base::binary | std::ios_base::in | std::ios_base::out);
 
 	std::vector<std::string> names;
 	names.emplace_back("foo");
@@ -74,9 +74,9 @@ void TestSchematic::testMtsSerializeDeserialize(const NodeDefManager *ndef)
 
 	Schematic schem, schem2;
 
-	schem.flags       = 0;
-	schem.size        = size;
-	schem.schemdata   = new MapNode[volume];
+	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);
@@ -103,7 +103,6 @@ void TestSchematic::testMtsSerializeDeserialize(const NodeDefManager *ndef)
 		UASSERTEQ(u8, schem2.slice_probs[y], schem.slice_probs[y]);
 }
 
-
 void TestSchematic::testLuaTableSerialize(const NodeDefManager *ndef)
 {
 	static const v3s16 size(3, 3, 3);
@@ -111,9 +110,9 @@ void TestSchematic::testLuaTableSerialize(const NodeDefManager *ndef)
 
 	Schematic schem;
 
-	schem.flags       = 0;
-	schem.size        = size;
-	schem.schemdata   = new MapNode[volume];
+	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);
@@ -131,20 +130,19 @@ void TestSchematic::testLuaTableSerialize(const NodeDefManager *ndef)
 	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,
+			CONTENT_AIR,
+			t_CONTENT_STONE,
+			t_CONTENT_LAVA,
 	};
 	static const content_t content_map2[] = {
-		CONTENT_AIR,
-		t_CONTENT_STONE,
-		t_CONTENT_WATER,
+			CONTENT_AIR,
+			t_CONTENT_STONE,
+			t_CONTENT_WATER,
 	};
 	StringMap replace_names;
 	replace_names["default:lava"] = "default:water";
@@ -152,10 +150,10 @@ void TestSchematic::testFileSerializeDeserialize(const NodeDefManager *ndef)
 	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.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;
@@ -180,101 +178,137 @@ void TestSchematic::testFileSerializeDeserialize(const NodeDefManager *ndef)
 	}
 }
 
-
 // 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
+		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,
+		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,
+		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";
+		"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";
diff --git a/src/unittest/test_serialization.cpp b/src/unittest/test_serialization.cpp
index 51e28f144..80a92f65e 100644
--- a/src/unittest/test_serialization.cpp
+++ b/src/unittest/test_serialization.cpp
@@ -23,7 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "util/serialize.h"
 #include <cmath>
 
-class TestSerialization : public TestBase {
+class TestSerialization : public TestBase
+{
 public:
 	TestSerialization() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestSerialization"; }
@@ -80,7 +81,7 @@ void TestSerialization::runTests(IGameDef *gamedef)
 // 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])
+template <size_t N> std::string mkstr(const char (&s)[N])
 {
 	return std::string(s, N - 1);
 }
@@ -143,18 +144,19 @@ void TestSerialization::testSerializeWideString()
 
 	// Test basic string
 	UASSERT(serializeWideString(utf8_to_wide("Hello world!")) ==
-		mkstr("\0\14\0H\0e\0l\0l\0o\0 \0w\0o\0r\0l\0d\0!"));
+			mkstr("\0\14\0H\0e\0l\0l\0o\0 \0w\0o\0r\0l\0d\0!"));
 
 	// Test character range
 	UASSERT(serializeWideString(teststring2_w) ==
-		mkstr("\1\0") + teststring2_w_encoded);
+			mkstr("\1\0") + teststring2_w_encoded);
 }
 
 void TestSerialization::testDeSerializeWideString()
 {
 	// Test deserialize
 	{
-		std::istringstream is(serializeWideString(teststring2_w), std::ios::binary);
+		std::istringstream is(
+				serializeWideString(teststring2_w), std::ios::binary);
 		UASSERT(deSerializeWideString(is) == teststring2_w);
 		UASSERT(!is.eof());
 		is.get();
@@ -169,13 +171,15 @@ void TestSerialization::testDeSerializeWideString()
 
 	// Test deserialize a string with an incomplete character
 	{
-		std::istringstream is(mkstr("\x00\x07\0a\0b\0c\0d\0e\0f\0"), std::ios::binary);
+		std::istringstream is(
+				mkstr("\x00\x07\0a\0b\0c\0d\0e\0f\0"), std::ios::binary);
 		EXCEPTION_CHECK(SerializationError, deSerializeWideString(is));
 	}
 
 	// Test deserialize a string with incomplete data
 	{
-		std::istringstream is(mkstr("\x00\x08\0a\0b\0c\0d\0e\0f"), std::ios::binary);
+		std::istringstream is(
+				mkstr("\x00\x08\0a\0b\0c\0d\0e\0f"), std::ios::binary);
 		EXCEPTION_CHECK(SerializationError, deSerializeWideString(is));
 	}
 }
@@ -222,7 +226,6 @@ void TestSerialization::testDeSerializeLongString()
 	}
 }
 
-
 void TestSerialization::testSerializeJsonString()
 {
 	// Test blank string
@@ -234,31 +237,52 @@ void TestSerialization::testSerializeJsonString()
 	// MSVC fails when directly using "\\\\"
 	std::string backslash = "\\";
 	UASSERT(serializeJsonString(teststring2) ==
-		mkstr("\"") +
-		"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007" +
-		"\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f" +
-		"\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017" +
-		"\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f" +
-		" !\\\"" + teststring2.substr(0x23, 0x2f-0x23) +
-		"\\/" + teststring2.substr(0x30, 0x5c-0x30) +
-		backslash + backslash + teststring2.substr(0x5d, 0x7f-0x5d) + "\\u007f" +
-		"\\u0080\\u0081\\u0082\\u0083\\u0084\\u0085\\u0086\\u0087" +
-		"\\u0088\\u0089\\u008a\\u008b\\u008c\\u008d\\u008e\\u008f" +
-		"\\u0090\\u0091\\u0092\\u0093\\u0094\\u0095\\u0096\\u0097" +
-		"\\u0098\\u0099\\u009a\\u009b\\u009c\\u009d\\u009e\\u009f" +
-		"\\u00a0\\u00a1\\u00a2\\u00a3\\u00a4\\u00a5\\u00a6\\u00a7" +
-		"\\u00a8\\u00a9\\u00aa\\u00ab\\u00ac\\u00ad\\u00ae\\u00af" +
-		"\\u00b0\\u00b1\\u00b2\\u00b3\\u00b4\\u00b5\\u00b6\\u00b7" +
-		"\\u00b8\\u00b9\\u00ba\\u00bb\\u00bc\\u00bd\\u00be\\u00bf" +
-		"\\u00c0\\u00c1\\u00c2\\u00c3\\u00c4\\u00c5\\u00c6\\u00c7" +
-		"\\u00c8\\u00c9\\u00ca\\u00cb\\u00cc\\u00cd\\u00ce\\u00cf" +
-		"\\u00d0\\u00d1\\u00d2\\u00d3\\u00d4\\u00d5\\u00d6\\u00d7" +
-		"\\u00d8\\u00d9\\u00da\\u00db\\u00dc\\u00dd\\u00de\\u00df" +
-		"\\u00e0\\u00e1\\u00e2\\u00e3\\u00e4\\u00e5\\u00e6\\u00e7" +
-		"\\u00e8\\u00e9\\u00ea\\u00eb\\u00ec\\u00ed\\u00ee\\u00ef" +
-		"\\u00f0\\u00f1\\u00f2\\u00f3\\u00f4\\u00f5\\u00f6\\u00f7" +
-		"\\u00f8\\u00f9\\u00fa\\u00fb\\u00fc\\u00fd\\u00fe\\u00ff" +
-		"\"");
+			mkstr("\"") +
+					"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u000"
+					"6\\u0007" +
+					"\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f" +
+					"\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u001"
+					"6\\u0017" +
+					"\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001"
+					"e\\u001f" +
+					" !\\\"" + teststring2.substr(0x23, 0x2f - 0x23) +
+					"\\/" + teststring2.substr(0x30, 0x5c - 0x30) +
+					backslash + backslash +
+					teststring2.substr(0x5d, 0x7f - 0x5d) +
+					"\\u007f" +
+					"\\u0080\\u0081\\u0082\\u0083\\u0084\\u0085\\u008"
+					"6\\u0087" +
+					"\\u0088\\u0089\\u008a\\u008b\\u008c\\u008d\\u008"
+					"e\\u008f" +
+					"\\u0090\\u0091\\u0092\\u0093\\u0094\\u0095\\u009"
+					"6\\u0097" +
+					"\\u0098\\u0099\\u009a\\u009b\\u009c\\u009d\\u009"
+					"e\\u009f" +
+					"\\u00a0\\u00a1\\u00a2\\u00a3\\u00a4\\u00a5\\u00a"
+					"6\\u00a7" +
+					"\\u00a8\\u00a9\\u00aa\\u00ab\\u00ac\\u00ad\\u00a"
+					"e\\u00af" +
+					"\\u00b0\\u00b1\\u00b2\\u00b3\\u00b4\\u00b5\\u00b"
+					"6\\u00b7" +
+					"\\u00b8\\u00b9\\u00ba\\u00bb\\u00bc\\u00bd\\u00b"
+					"e\\u00bf" +
+					"\\u00c0\\u00c1\\u00c2\\u00c3\\u00c4\\u00c5\\u00c"
+					"6\\u00c7" +
+					"\\u00c8\\u00c9\\u00ca\\u00cb\\u00cc\\u00cd\\u00c"
+					"e\\u00cf" +
+					"\\u00d0\\u00d1\\u00d2\\u00d3\\u00d4\\u00d5\\u00d"
+					"6\\u00d7" +
+					"\\u00d8\\u00d9\\u00da\\u00db\\u00dc\\u00dd\\u00d"
+					"e\\u00df" +
+					"\\u00e0\\u00e1\\u00e2\\u00e3\\u00e4\\u00e5\\u00e"
+					"6\\u00e7" +
+					"\\u00e8\\u00e9\\u00ea\\u00eb\\u00ec\\u00ed\\u00e"
+					"e\\u00ef" +
+					"\\u00f0\\u00f1\\u00f2\\u00f3\\u00f4\\u00f5\\u00f"
+					"6\\u00f7" +
+					"\\u00f8\\u00f9\\u00fa\\u00fb\\u00fc\\u00fd\\u00f"
+					"e\\u00ff" +
+					"\"");
 
 	// Test deserialize
 	std::istringstream is(serializeJsonString(teststring2), std::ios::binary);
@@ -275,24 +299,21 @@ void TestSerialization::testSerializeHex()
 	UASSERT(serializeHexString("", true) == "");
 
 	// Test basic string
-	UASSERT(serializeHexString("Hello world!") ==
-		"48656c6c6f20776f726c6421");
+	UASSERT(serializeHexString("Hello world!") == "48656c6c6f20776f726c6421");
 	UASSERT(serializeHexString("Hello world!", true) ==
-		"48 65 6c 6c 6f 20 77 6f 72 6c 64 21");
+			"48 65 6c 6c 6f 20 77 6f 72 6c 64 21");
 
 	// Test binary string
 	UASSERT(serializeHexString(mkstr("\x00\x0a\xb0\x63\x1f\x00\xff")) ==
-		"000ab0631f00ff");
+			"000ab0631f00ff");
 	UASSERT(serializeHexString(mkstr("\x00\x0a\xb0\x63\x1f\x00\xff"), true) ==
-		"00 0a b0 63 1f 00 ff");
+			"00 0a b0 63 1f 00 ff");
 }
 
-
 void TestSerialization::testStreamRead()
 {
 	std::string datastr(
-		(const char *)test_serialized_data,
-		sizeof(test_serialized_data));
+			(const char *)test_serialized_data, sizeof(test_serialized_data));
 	std::istringstream is(datastr, std::ios_base::binary);
 
 	UASSERT(readU8(is) == 0x11);
@@ -329,7 +350,6 @@ void TestSerialization::testStreamRead()
 	UASSERT(is.rdbuf()->in_avail() == 0);
 }
 
-
 void TestSerialization::testStreamWrite()
 {
 	std::ostringstream os(std::ios_base::binary);
@@ -375,7 +395,6 @@ void TestSerialization::testStreamWrite()
 	UASSERT(!memcmp(&data[0], test_serialized_data, sizeof(test_serialized_data)));
 }
 
-
 void TestSerialization::testVecPut()
 {
 	std::vector<u8> buf;
@@ -415,7 +434,6 @@ void TestSerialization::testVecPut()
 	UASSERT(!memcmp(&buf[0], test_serialized_data, sizeof(test_serialized_data)));
 }
 
-
 void TestSerialization::testStringLengthLimits()
 {
 	std::vector<u8> buf;
@@ -434,7 +452,6 @@ void TestSerialization::testStringLengthLimits()
 	putWideString(&buf, too_long_wide);
 }
 
-
 void TestSerialization::testBufReader()
 {
 	u8 u8_data;
@@ -526,8 +543,7 @@ void TestSerialization::testBufReader()
 	EXCEPTION_CHECK(SerializationError, buf.getString());
 	EXCEPTION_CHECK(SerializationError, buf.getWideString());
 	EXCEPTION_CHECK(SerializationError, buf.getLongString());
-	EXCEPTION_CHECK(SerializationError,
-		buf.getRawData(raw_data, sizeof(raw_data)));
+	EXCEPTION_CHECK(SerializationError, buf.getRawData(raw_data, sizeof(raw_data)));
 
 	// See if we can skip backwards
 	buf.pos = 5;
@@ -632,29 +648,25 @@ void TestSerialization::testFloatFormat()
 	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 }
-	};
+	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);
+			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);
+			printf("Inaccurate float values on 0x%X, expected %.9g, actual "
+			       "0x%.9g\n",
+					v.second, v.first, fs);
 			UASSERT(false);
 		}
 	}
@@ -682,13 +694,15 @@ void TestSerialization::testFloatFormat()
 		memcpy(&fm, &i, 4);
 		fs = u32Tof32Slow(i);
 		if (fm != fs) {
-			printf("u32Tof32Slow failed on 0x%X, expected %.9g, actual %.9g\n",
-				i, 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));
+			printf("f32Tou32Slow failed on %.9g, expected 0x%X, actual "
+			       "0x%X\n",
+					fs, i, f32Tou32Slow(fs));
 			return false;
 		}
 		return true;
@@ -709,17 +723,152 @@ void TestSerialization::testFloatFormat()
 }
 
 const u8 TestSerialization::test_serialized_data[12 * 13 - 8] = {
-	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, 0x08, 0x00,
-	0x02, 0x00, 0x7e, 0x00,  'w', 0x00,  'o', 0x00,  'o', 0x00,  'f', 0x00, // \x02~woof~\x5455
-	0x7e, 0x54, 0x55, 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,
+		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,
+		0x08,
+		0x00,
+		0x02,
+		0x00,
+		0x7e,
+		0x00,
+		'w',
+		0x00,
+		'o',
+		0x00,
+		'o',
+		0x00,
+		'f',
+		0x00, // \x02~woof~\x5455
+		0x7e,
+		0x54,
+		0x55,
+		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,
 };
diff --git a/src/unittest/test_settings.cpp b/src/unittest/test_settings.cpp
index aa56f3e06..17c7c6745 100644
--- a/src/unittest/test_settings.cpp
+++ b/src/unittest/test_settings.cpp
@@ -23,7 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "settings.h"
 #include "noise.h"
 
-class TestSettings : public TestBase {
+class TestSettings : public TestBase
+{
 public:
 	TestSettings() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestSettings"; }
@@ -48,161 +49,161 @@ void TestSettings::runTests(IGameDef *gamedef)
 ////////////////////////////////////////////////////////////////////////////////
 
 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";
+		"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";
 
 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";
+		"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";
 
 void TestSettings::testAllSettings()
 {
 	try {
-	Settings s;
-
-	// 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 = new Settings;
-	group3->set("cat", "meow");
-	group3->set("dog", "woof");
-
-	Settings *group2 = new Settings;
-	group2->setS16("num_apples", 4);
-	group2->setS16("num_oranges", 53);
-	group2->setGroup("animals", group3);
-	group2->set("animals", "cute"); //destroys group 3
-	s.setGroup("groupy_thing", group2);
-
-	// Test set failure conditions
-	UASSERT(s.set("Zoop = Poop\nsome_other_setting", "false") == false);
-	UASSERT(s.set("sneaky", "\"\"\"\njabberwocky = false") == false);
-	UASSERT(s.set("hehe", "asdfasdf\n\"\"\"\nsomething = false") == false);
-
-	// Test multiline settings
-	UASSERT(group->get("ccc") == "testy\n   testa   ");
-
-	UASSERT(s.get("blarg") ==
-		"some multiline text\n"
-		"     with leading whitespace!");
-
-	// Test NoiseParams
-	UASSERT(s.getEntry("np_terrain").is_group == false);
-
-	NoiseParams np;
-	UASSERT(s.getNoiseParams("np_terrain", np) == true);
-	UASSERT(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);
-	//printf(">>>> expected config:\n%s\n", TEST_CONFIG_TEXT_AFTER);
-	//printf(">>>> actual config:\n%s\n", os.str().c_str());
+		Settings s;
+
+		// 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 = new Settings;
+		group3->set("cat", "meow");
+		group3->set("dog", "woof");
+
+		Settings *group2 = new Settings;
+		group2->setS16("num_apples", 4);
+		group2->setS16("num_oranges", 53);
+		group2->setGroup("animals", group3);
+		group2->set("animals", "cute"); // destroys group 3
+		s.setGroup("groupy_thing", group2);
+
+		// Test set failure conditions
+		UASSERT(s.set("Zoop = Poop\nsome_other_setting", "false") == false);
+		UASSERT(s.set("sneaky", "\"\"\"\njabberwocky = false") == false);
+		UASSERT(s.set("hehe", "asdfasdf\n\"\"\"\nsomething = false") == false);
+
+		// Test multiline settings
+		UASSERT(group->get("ccc") == "testy\n   testa   ");
+
+		UASSERT(s.get("blarg") == "some multiline text\n"
+					  "     with leading whitespace!");
+
+		// Test NoiseParams
+		UASSERT(s.getEntry("np_terrain").is_group == false);
+
+		NoiseParams np;
+		UASSERT(s.getNoiseParams("np_terrain", np) == true);
+		UASSERT(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);
+		// printf(">>>> expected config:\n%s\n", TEST_CONFIG_TEXT_AFTER);
+		// printf(">>>> actual config:\n%s\n", os.str().c_str());
 #if __cplusplus < 201103L
-	// This test only works in older C++ versions than C++11 because we use unordered_map
-	UASSERT(os.str() == config_text_after);
+		// This test only works in older C++ versions than C++11 because we use
+		// unordered_map
+		UASSERT(os.str() == config_text_after);
 #endif
 	} catch (SettingNotFoundException &e) {
 		UASSERT(!"Setting not found!");
@@ -212,18 +213,13 @@ void TestSettings::testAllSettings()
 void TestSettings::testFlagDesc()
 {
 	Settings s;
-	FlagDesc flagdesc[] = {
-		{ "biomes",  0x01 },
-		{ "trees",   0x02 },
-		{ "jungles", 0x04 },
-		{ "oranges", 0x08 },
-		{ "tables",  0x10 },
-		{ nullptr,      0 }
-	};
+	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));
+	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
diff --git a/src/unittest/test_socket.cpp b/src/unittest/test_socket.cpp
index 6d5cf334d..30623874e 100644
--- a/src/unittest/test_socket.cpp
+++ b/src/unittest/test_socket.cpp
@@ -23,7 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "settings.h"
 #include "network/socket.h"
 
-class TestSocket : public TestBase {
+class TestSocket : public TestBase
+{
 public:
 	TestSocket()
 	{
@@ -87,13 +88,13 @@ void TestSocket::testIPv4Socket()
 
 	sleep_ms(50);
 
-	char rcvbuffer[256] = { 0 };
+	char rcvbuffer[256] = {0};
 	Address sender;
 	for (;;) {
 		if (socket.Receive(sender, rcvbuffer, sizeof(rcvbuffer)) < 0)
 			break;
 	}
-	//FIXME: This fails on some systems
+	// FIXME: This fails on some systems
 	UASSERT(strncmp(sendbuffer, rcvbuffer, sizeof(sendbuffer)) == 0);
 
 	if (address != Address(0, 0, 0, 0, port)) {
@@ -133,19 +134,21 @@ void TestSocket::testIPv6Socket()
 
 		sleep_ms(50);
 
-		char rcvbuffer[256] = { 0 };
+		char rcvbuffer[256] = {0};
 		Address sender;
 
-		for(;;) {
+		for (;;) {
 			if (socket6.Receive(sender, rcvbuffer, sizeof(rcvbuffer)) < 0)
 				break;
 		}
-		//FIXME: This fails on some systems
+		// FIXME: This fails on some systems
 		UASSERT(strncmp(sendbuffer, rcvbuffer, sizeof(sendbuffer)) == 0);
 		UASSERT(memcmp(sender.getAddress6().sin6_addr.s6_addr,
-				Address(&bytes, 0).getAddress6().sin6_addr.s6_addr, 16) == 0);
+					Address(&bytes, 0)
+							.getAddress6()
+							.sin6_addr.s6_addr,
+					16) == 0);
 	} catch (SendFailedException &e) {
-		errorstream << "IPv6 support enabled but not available!"
-					<< std::endl;
+		errorstream << "IPv6 support enabled but not available!" << std::endl;
 	}
 }
diff --git a/src/unittest/test_threading.cpp b/src/unittest/test_threading.cpp
index 8d4d814fd..76aff3fb0 100644
--- a/src/unittest/test_threading.cpp
+++ b/src/unittest/test_threading.cpp
@@ -23,8 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "threading/semaphore.h"
 #include "threading/thread.h"
 
-
-class TestThreading : public TestBase {
+class TestThreading : public TestBase
+{
 public:
 	TestThreading() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestThreading"; }
@@ -44,11 +44,11 @@ void TestThreading::runTests(IGameDef *gamedef)
 	TEST(testAtomicSemaphoreThread);
 }
 
-class SimpleTestThread : public Thread {
+class SimpleTestThread : public Thread
+{
 public:
 	SimpleTestThread(unsigned int interval) :
-		Thread("SimpleTest"),
-		m_interval(interval)
+			Thread("SimpleTest"), m_interval(interval)
 	{
 	}
 
@@ -110,7 +110,6 @@ void TestThreading::testStartStopWait()
 	delete thread;
 }
 
-
 void TestThreading::testThreadKill()
 {
 	SimpleTestThread *thread = new SimpleTestThread(300);
@@ -134,13 +133,11 @@ void TestThreading::testThreadKill()
 	delete thread;
 }
 
-
-class AtomicTestThread : public Thread {
+class AtomicTestThread : public Thread
+{
 public:
 	AtomicTestThread(std::atomic<u32> &v, Semaphore &trigger) :
-		Thread("AtomicTest"),
-		val(v),
-		trigger(trigger)
+			Thread("AtomicTest"), val(v), trigger(trigger)
 	{
 	}
 
@@ -157,7 +154,6 @@ private:
 	Semaphore &trigger;
 };
 
-
 void TestThreading::testAtomicSemaphoreThread()
 {
 	std::atomic<u32> val;
@@ -180,4 +176,3 @@ void TestThreading::testAtomicSemaphoreThread()
 
 	UASSERT(val == num_threads * 0x10000);
 }
-
diff --git a/src/unittest/test_utilities.cpp b/src/unittest/test_utilities.cpp
index 447b591e1..a24f7dd3e 100644
--- a/src/unittest/test_utilities.cpp
+++ b/src/unittest/test_utilities.cpp
@@ -24,7 +24,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "util/numeric.h"
 #include "util/string.h"
 
-class TestUtilities : public TestBase {
+class TestUtilities : public TestBase
+{
 public:
 	TestUtilities() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestUtilities"; }
@@ -101,7 +102,6 @@ inline float ref_WrapDegrees180(float f)
 	return value - 180;
 }
 
-
 inline float ref_WrapDegrees_0_360(float f)
 {
 	// This is a slower alternative to the wrapDegrees_0_360() function;
@@ -112,66 +112,65 @@ inline float ref_WrapDegrees_0_360(float f)
 	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);
 
-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);
-    }
+	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
+	// 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)
+		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)
 	}
 
-    // 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)
-            }
-        }
-    }
-}
+	// 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()
 {
@@ -180,7 +179,6 @@ void TestUtilities::testLowercase()
 	UASSERT(lowercase("MINETEST-powa") == "minetest-powa");
 }
 
-
 void TestUtilities::testTrim()
 {
 	UASSERT(trim("") == "");
@@ -189,7 +187,6 @@ void TestUtilities::testTrim()
 	UASSERT(trim("\n \t\r    \r\n\t\t  ") == "");
 }
 
-
 void TestUtilities::testIsYes()
 {
 	UASSERT(is_yes("YeS") == true);
@@ -201,7 +198,6 @@ void TestUtilities::testIsYes()
 	UASSERT(is_yes("2") == true);
 }
 
-
 void TestUtilities::testRemoveStringEnd()
 {
 	const char *ends[] = {"abc", "c", "bc", "", NULL};
@@ -211,21 +207,18 @@ void TestUtilities::testRemoveStringEnd()
 	UASSERT(removeStringEnd("foo", ends) == "");
 }
 
-
 void TestUtilities::testUrlEncode()
 {
-	UASSERT(urlencode("\"Aardvarks lurk, OK?\"")
-			== "%22Aardvarks%20lurk%2C%20OK%3F%22");
+	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?\"");
+	UASSERT(urldecode("%22Aardvarks%20lurk%2C%20OK%3F%22") ==
+			"\"Aardvarks lurk, OK?\"");
 }
 
-
 void TestUtilities::testPadString()
 {
 	UASSERT(padStringRight("hello", 8) == "hello   ");
@@ -234,14 +227,13 @@ void TestUtilities::testPadString()
 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("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);
 }
 
@@ -251,7 +243,6 @@ void TestUtilities::testStrEqual()
 	UASSERT(str_equal(narrow_to_wide("ABC"), narrow_to_wide("abc"), true));
 }
 
-
 void TestUtilities::testStringTrim()
 {
 	UASSERT(trim("  a") == "a");
@@ -260,14 +251,12 @@ void TestUtilities::testStringTrim()
 	UASSERT(trim("") == "");
 }
 
-
 void TestUtilities::testStrToIntConversion()
 {
 	UASSERT(mystoi("123", 0, 1000) == 123);
 	UASSERT(mystoi("123", 0, 10) == 10);
 }
 
-
 void TestUtilities::testStringReplace()
 {
 	std::string test_str;
@@ -279,7 +268,6 @@ void TestUtilities::testStringReplace()
 	UASSERT(test_str == "This is a test");
 }
 
-
 void TestUtilities::testStringAllowed()
 {
 	UASSERT(string_allowed("hello", "abcdefghijklmno") == true);
@@ -303,45 +291,43 @@ void TestUtilities::testAsciiPrintableHelper()
 void TestUtilities::testUTF8()
 {
 	UASSERT(wide_to_utf8(utf8_to_wide("")) == "");
-	UASSERT(wide_to_utf8(utf8_to_wide("the shovel dug a crumbly node!"))
-		== "the shovel dug a crumbly node!");
+	UASSERT(wide_to_utf8(utf8_to_wide("the shovel dug a crumbly node!")) ==
+			"the shovel dug a crumbly node!");
 }
 
 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");
+	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");
+				L"abc\x1b(outer \x1b(inner escape)escape)def") ==
+			L"abcescape)def");
 }
 
 void TestUtilities::testWrapRows()
 {
-	UASSERT(wrap_rows("12345678",4) == "1234\n5678");
+	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};
+		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};
+		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>");
 	}
@@ -360,7 +346,7 @@ void TestUtilities::testEnrichedString()
 	// 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
+	str.setDefaultColor(color);		    // Blue foreground
 	UASSERT(str.getColors()[13] == 0xFFFFFF00); // Still yellow text
 	UASSERT(str.getBackground() == 0xFF00FF00); // Green background
 }
@@ -372,7 +358,6 @@ void TestUtilities::testIsNumber()
 	UASSERT(is_number("123a") == false);
 }
 
-
 void TestUtilities::testIsPowerOfTwo()
 {
 	UASSERT(is_power_of_two(0) == false);
@@ -416,7 +401,6 @@ void TestUtilities::testStringJoin()
 	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;
@@ -424,17 +408,16 @@ static bool within(const f32 value1, const f32 value2, const f32 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);
+	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)
+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))
+		if (!within(M1[i], M2[i], precision))
 			return false;
 	return true;
 }
@@ -463,7 +446,7 @@ void TestUtilities::testEulerConversion()
 	// 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);
+	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);
@@ -523,7 +506,7 @@ void TestUtilities::testEulerConversion()
 	v1 = v3f(90.00001f, 1.f, 1.f);
 	setPitchYawRoll(m1, v1);
 	v2 = getPitchYawRoll(m1);
-	//UASSERT(within(v1, v2, tolL)); // this is typically false
+	// 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));
diff --git a/src/unittest/test_voxelalgorithms.cpp b/src/unittest/test_voxelalgorithms.cpp
index 0ffd24b7d..c259fd7f1 100644
--- a/src/unittest/test_voxelalgorithms.cpp
+++ b/src/unittest/test_voxelalgorithms.cpp
@@ -23,7 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "voxelalgorithms.h"
 #include "util/numeric.h"
 
-class TestVoxelAlgorithms : public TestBase {
+class TestVoxelAlgorithms : public TestBase
+{
 public:
 	TestVoxelAlgorithms() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestVoxelAlgorithms"; }
@@ -49,32 +50,32 @@ 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;
+	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);
-	}
-	}
+		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();
+	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
+		// 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 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;
 
@@ -87,7 +88,7 @@ void TestVoxelAlgorithms::testVoxelLineIterator(const NodeDefManager *ndef)
 			// 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));
+					voxel_center + v3f(0.5, 0.5, 0.5));
 			UASSERT(box.intersectsWithLine(l));
 			// Update old voxel
 			old_voxel = new_voxel;
diff --git a/src/unittest/test_voxelmanipulator.cpp b/src/unittest/test_voxelmanipulator.cpp
index acc2707e7..c31eb799d 100644
--- a/src/unittest/test_voxelmanipulator.cpp
+++ b/src/unittest/test_voxelmanipulator.cpp
@@ -25,7 +25,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "log.h"
 #include "voxel.h"
 
-class TestVoxelManipulator : public TestBase {
+class TestVoxelManipulator : public TestBase
+{
 public:
 	TestVoxelManipulator() { TestManager::registerTestModule(this); }
 	const char *getName() { return "TestVoxelManipulator"; }
@@ -48,27 +49,26 @@ void TestVoxelManipulator::runTests(IGameDef *gamedef)
 
 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 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));
+	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));
+	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));
+	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) {
+	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;
 
@@ -79,7 +79,6 @@ void TestVoxelManipulator::testVoxelArea()
 	}
 }
 
-
 void TestVoxelManipulator::testVoxelManipulator(const NodeDefManager *nodedef)
 {
 	VoxelManipulator v;
@@ -87,22 +86,22 @@ void TestVoxelManipulator::testVoxelManipulator(const NodeDefManager *nodedef)
 	v.print(infostream, nodedef);
 
 	infostream << "*** Setting (-1,0,-1)=2 ***" << std::endl;
-	v.setNodeNoRef(v3s16(-1,0,-1), MapNode(t_CONTENT_GRASS));
+	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);
+	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)));
+	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));
+	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)));
+	UASSERT(v.getNode(v3s16(-1, 0, -1)).getContent() == t_CONTENT_GRASS);
+	EXCEPTION_CHECK(InvalidPositionException, v.getNode(v3s16(0, 1, 1)));
 }