Externalized cPrefabPiecePool self-test.

CMakeLists.txt

@@ -197,13 +197,53 @@ if(${SELF_TEST})
 	add_subdirectory (tests)
 endif()
 
-# Put project into solution folders in MSVC:
+# Put projects into solution folders in MSVC:
 if (MSVC)
-	set_target_properties(event_core event_extra expat jsoncpp lua luaexpat mbedtls sqlite SQLiteCpp tolualib zlib PROPERTIES FOLDER Lib)
-	set_target_properties(luaproxy tolua PROPERTIES FOLDER Support)
+	set_target_properties(
+		event_core
+		event_extra
+		expat
+		jsoncpp
+		lua
+		luaexpat
+		mbedtls
+		sqlite
+		SQLiteCpp
+		tolualib
+		zlib
+		PROPERTIES FOLDER Lib
+	)
+	set_target_properties(
+		luaproxy
+		tolua
+		PROPERTIES FOLDER Support
+	)
 	if (${SELF_TEST})
-		set_target_properties(Network PROPERTIES FOLDER Lib)
-		set_target_properties(arraystocoords-exe coordinates-exe copies-exe copyblocks-exe creatable-exe EchoServer Google-exe ChunkBuffer NameLookup PROPERTIES FOLDER Tests)
+		set_target_properties(
+			Network
+			PROPERTIES FOLDER Lib
+		)
+		set_target_properties(
+			arraystocoords-exe
+			ChunkBuffer
+			coordinates-exe
+			copies-exe
+			copyblocks-exe
+			creatable-exe
+			EchoServer
+			Google-exe
+			LoadablePieces
+			NameLookup
+			PROPERTIES FOLDER Tests
+		)
+	endif()
+
+	if(${BUILD_TOOLS})
+		set_target_properties(
+			MCADefrag
+			ProtoProxy
+			PROPERTIES FOLDER Tools
+		)
 	endif()
 endif()
 

src/Bindings/BindingsProcessor.lua

@@ -98,7 +98,9 @@ local function OutputLuaStateHelpers(a_Package)
 		f:write("// This file expects to be included form inside the cLuaState class definition\n")
 		f:write("\n\n\n\n\n")
 		for _, item in ipairs(types) do
-			f:write("void Push(" .. item.name .. " * a_Value);\n")
+			if not(g_HasCustomPushImplementation[item.name]) then
+				f:write("void Push(" .. item.name .. " * a_Value);\n")
+			end
 		end
 		for _, item in ipairs(types) do
 			f:write("bool GetStackValue(int a_StackPos, Ptr" .. item.lname .. " & a_ReturnedVal);\n")

src/Bindings/LuaState.h

@@ -242,13 +242,14 @@ public:
 
 	// Push a simple value onto the stack (keep alpha-sorted):
 	void Push(bool a_Value);
+	void Push(cEntity * a_Entity);
+	void Push(cLuaServerHandle * a_ServerHandle);
+	void Push(cLuaTCPLink * a_TCPLink);
+	void Push(cLuaUDPEndpoint * a_UDPEndpoint);
 	void Push(double a_Value);
 	void Push(int a_Value);
 	void Push(void * a_Ptr);
 	void Push(std::chrono::milliseconds a_time);
-	void Push(cLuaServerHandle * a_ServerHandle);
-	void Push(cLuaTCPLink * a_TCPLink);
-	void Push(cLuaUDPEndpoint * a_UDPEndpoint);
 	
 	// GetStackValue() retrieves the value at a_StackPos, if it is a valid type. If not, a_Value is unchanged.
 	// Returns whether value was changed

src/Blocks/BlockHandler.cpp

@@ -427,6 +427,7 @@ void cBlockHandler::NeighborChanged(cChunkInterface & a_ChunkInterface, int a_Bl
 
 
 
+
 void cBlockHandler::ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta)
 {
 	// Setting the meta to a_BlockMeta keeps most textures. The few other blocks have to override this.

src/Generating/CMakeLists.txt

@@ -101,5 +101,5 @@ endif()
 if(NOT MSVC)
 	add_library(Generating ${SRCS} ${HDRS})
 
-	target_link_libraries(Generating OSSupport Blocks)
+	target_link_libraries(Generating OSSupport Blocks Bindings)
 endif()

src/Generating/PrefabPiecePool.cpp

@@ -24,33 +24,6 @@
 
 
 
-#if SELF_TEST
-static class cPrefabPiecePoolTest
-{
-public:
-	cPrefabPiecePoolTest(void)
-	{
-		cSelfTests::Get().Register(cSelfTests::SelfTestFunction(cPrefabPiecePoolTest::TestLoading), "PrefabPiecePool loading test");
-	}
-
-	static void TestLoading(void)
-	{
-		cPrefabPiecePool test;
-		auto res = test.LoadFromFile("test.cubeset", true);
-		if (!res)
-		{
-			LOGWARNING("Loading from file \"test.cubeset\" failed.");
-			return;
-		}
-		LOG("Loaded %u pieces and %u starting pieces", static_cast<unsigned>(test.GetAllPiecesCount()), static_cast<unsigned>(test.GetStartingPiecesCount()));
-	}
-} g_Test;
-#endif
-
-
-
-
-
 /** Returns the map of string => eMergeStrategy used when translating cubeset file merge strategies. */
 static std::map<AString, cBlockArea::eMergeStrategy> & GetMergeStrategyMap(void)
 {
@@ -173,6 +146,7 @@ bool cPrefabPiecePool::LoadFromFile(const AString & a_FileName, bool a_LogWarnin
 	cFile f;
 	if (!f.Open(a_FileName, cFile::fmRead))
 	{
+		CONDWARNING(a_LogWarnings, "Cannot open file %s for reading", a_FileName.c_str());
 		return false;
 	}
 	char buf[4096];
@@ -184,6 +158,7 @@ bool cPrefabPiecePool::LoadFromFile(const AString & a_FileName, bool a_LogWarnin
 	{
 		return LoadFromCubesetFile(a_FileName, a_LogWarnings);
 	}
+	CONDWARNING(a_LogWarnings, "Cannot load prefabs from file %s, unknown file format", a_FileName.c_str());
 	return false;
 }
 

src/Globals.h

@@ -261,14 +261,15 @@ template class SizeChecker<UInt8,  1>;
 
 
 
+// Common headers (part 1, without macros):
+#include "StringUtils.h"
+#include "OSSupport/CriticalSection.h"
+#include "OSSupport/Event.h"
+#include "OSSupport/File.h"
+#include "OSSupport/StackTrace.h"
+
 #ifndef TEST_GLOBALS
-	// Common headers (part 1, without macros):
-	#include "StringUtils.h"
-	#include "OSSupport/CriticalSection.h"
-	#include "OSSupport/Event.h"
-	#include "OSSupport/File.h"
 	#include "Logger.h"
-	#include "OSSupport/StackTrace.h"
 #else
 	// Logging functions
 void inline LOGERROR(const char * a_Format, ...) FORMATSTRING(1, 2);
@@ -315,6 +316,9 @@ void inline LOG(const char * a_Format, ...)
 	va_end(argList);
 }
 
+#define LOGINFO LOG
+#define LOGWARN LOGWARNING
+
 #endif
 
 

src/WorldStorage/CMakeLists.txt

@@ -14,7 +14,8 @@ SET (SRCS
 	ScoreboardSerializer.cpp
 	StatSerializer.cpp
 	WSSAnvil.cpp
-	WorldStorage.cpp)
+	WorldStorage.cpp
+)
 
 SET (HDRS
 	EnchantmentSerializer.h
@@ -26,7 +27,8 @@ SET (HDRS
 	ScoreboardSerializer.h
 	StatSerializer.h
 	WSSAnvil.h
-	WorldStorage.h)
+	WorldStorage.h
+)
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
     set_source_files_properties(EnchantmentSerializer.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")

src/WorldStorage/SchematicFileSerializer.cpp

@@ -238,27 +238,27 @@ bool cSchematicFileSerializer::LoadFromSchematicNBT(cBlockArea & a_BlockArea, cP
 	}
 
 	// Copy the block types and metas:
-	size_t NumBytes = a_BlockArea.GetBlockCount();
-	if (a_NBT.GetDataLength(TBlockTypes) < NumBytes)
+	size_t NumTypeBytes = a_BlockArea.GetBlockCount();
+	if (a_NBT.GetDataLength(TBlockTypes) < NumTypeBytes)
 	{
-		LOG("BlockTypes truncated in the schematic file (exp %d, got %d bytes). Loading partial.",
-			(int)NumBytes, (int)a_NBT.GetDataLength(TBlockTypes)
+		LOG("BlockTypes truncated in the schematic file (exp %u, got %u bytes). Loading partial.",
+			static_cast<unsigned>(NumTypeBytes), static_cast<unsigned>(a_NBT.GetDataLength(TBlockTypes))
 		);
-		NumBytes = a_NBT.GetDataLength(TBlockTypes);
+		NumTypeBytes = a_NBT.GetDataLength(TBlockTypes);
 	}
-	memcpy(a_BlockArea.m_BlockTypes, a_NBT.GetData(TBlockTypes), NumBytes);
+	memcpy(a_BlockArea.m_BlockTypes, a_NBT.GetData(TBlockTypes), NumTypeBytes);
 	
 	if (AreMetasPresent)
 	{
-		size_t NumBytes = a_BlockArea.GetBlockCount();
-		if (a_NBT.GetDataLength(TBlockMetas) < NumBytes)
+		size_t NumMetaBytes = a_BlockArea.GetBlockCount();
+		if (a_NBT.GetDataLength(TBlockMetas) < NumMetaBytes)
 		{
-			LOG("BlockMetas truncated in the schematic file (exp %d, got %d bytes). Loading partial.",
-				(int)NumBytes, (int)a_NBT.GetDataLength(TBlockMetas)
+			LOG("BlockMetas truncated in the schematic file (exp %u, got %u bytes). Loading partial.",
+				static_cast<unsigned>(NumMetaBytes), static_cast<unsigned>(a_NBT.GetDataLength(TBlockMetas))
 			);
-			NumBytes = a_NBT.GetDataLength(TBlockMetas);
+			NumMetaBytes = a_NBT.GetDataLength(TBlockMetas);
 		}
-		memcpy(a_BlockArea.m_BlockMetas, a_NBT.GetData(TBlockMetas), NumBytes);
+		memcpy(a_BlockArea.m_BlockMetas, a_NBT.GetData(TBlockMetas), NumMetaBytes);
 	}
 	
 	return true;

tests/CMakeLists.txt

@@ -6,3 +6,4 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 add_subdirectory(ChunkData)
 add_subdirectory(Network)
+add_subdirectory(LoadablePieces)

tests/LoadablePieces/Bindings.h

@@ -0,0 +1,15 @@
+
+// Bindings.h
+
+// Dummy include file needed for LuaState to compile successfully
+
+
+
+
+struct lua_State;
+
+int tolua_AllToLua_open(lua_State * a_LuaState);
+
+
+
+

tests/LoadablePieces/CMakeLists.txt

@@ -0,0 +1,93 @@
+cmake_minimum_required (VERSION 2.6) 
+
+enable_testing()
+
+include_directories(${CMAKE_SOURCE_DIR}/src/)
+include_directories(${CMAKE_SOURCE_DIR}/lib/)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+add_definitions(-DTEST_GLOBALS=1)
+
+set (SHARED_SRCS
+	${CMAKE_SOURCE_DIR}/src/BlockArea.cpp
+	${CMAKE_SOURCE_DIR}/src/Cuboid.cpp
+	${CMAKE_SOURCE_DIR}/src/ChunkData.cpp
+	${CMAKE_SOURCE_DIR}/src/StringCompression.cpp
+	${CMAKE_SOURCE_DIR}/src/StringUtils.cpp
+
+	${CMAKE_SOURCE_DIR}/src/Bindings/LuaState.cpp
+
+	${CMAKE_SOURCE_DIR}/src/Generating/ChunkDesc.cpp
+	${CMAKE_SOURCE_DIR}/src/Generating/PieceGenerator.cpp
+	${CMAKE_SOURCE_DIR}/src/Generating/Prefab.cpp
+	${CMAKE_SOURCE_DIR}/src/Generating/PrefabPiecePool.cpp
+
+	${CMAKE_SOURCE_DIR}/src/Noise/Noise.cpp
+
+	${CMAKE_SOURCE_DIR}/src/OSSupport/CriticalSection.cpp
+	${CMAKE_SOURCE_DIR}/src/OSSupport/Event.cpp
+	${CMAKE_SOURCE_DIR}/src/OSSupport/File.cpp
+	${CMAKE_SOURCE_DIR}/src/OSSupport/GZipFile.cpp
+	${CMAKE_SOURCE_DIR}/src/OSSupport/StackTrace.cpp
+
+	${CMAKE_SOURCE_DIR}/src/WorldStorage/FastNBT.cpp
+	${CMAKE_SOURCE_DIR}/src/WorldStorage/SchematicFileSerializer.cpp
+)
+
+set (SHARED_HDRS
+	${CMAKE_SOURCE_DIR}/src/BlockArea.h
+	${CMAKE_SOURCE_DIR}/src/Cuboid.h
+	${CMAKE_SOURCE_DIR}/src/ChunkData.h
+	${CMAKE_SOURCE_DIR}/src/Globals.h
+	${CMAKE_SOURCE_DIR}/src/StringCompression.h
+	${CMAKE_SOURCE_DIR}/src/StringUtils.h
+
+	${CMAKE_SOURCE_DIR}/src/Bindings/LuaState.h
+
+	${CMAKE_SOURCE_DIR}/src/Generating/ChunkDesc.h
+	${CMAKE_SOURCE_DIR}/src/Generating/PieceGenerator.h
+	${CMAKE_SOURCE_DIR}/src/Generating/Prefab.h
+	${CMAKE_SOURCE_DIR}/src/Generating/PrefabPiecePool.h
+
+	${CMAKE_SOURCE_DIR}/src/Noise/Noise.h
+
+	${CMAKE_SOURCE_DIR}/src/OSSupport/CriticalSection.h
+	${CMAKE_SOURCE_DIR}/src/OSSupport/Event.h
+	${CMAKE_SOURCE_DIR}/src/OSSupport/File.h
+	${CMAKE_SOURCE_DIR}/src/OSSupport/GZipFile.h
+	${CMAKE_SOURCE_DIR}/src/OSSupport/StackTrace.h
+
+	${CMAKE_SOURCE_DIR}/src/WorldStorage/FastNBT.h
+	${CMAKE_SOURCE_DIR}/src/WorldStorage/SchematicFileSerializer.h
+)
+
+set (SRCS
+	LoadablePieces.cpp
+	Stubs.cpp
+	LuaState_Typedefs.inc
+	LuaState_Declaration.inc
+	Bindings.h
+)
+
+
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+	add_flags_cxx("-Wno-error=conversion -Wno-error=old-style-cast")
+	add_flags_cxx("-Wno-error=global-constructors")
+endif()
+
+
+if (MSVC)
+	# Add the MSVC-specific LeakFinder sources:
+	list (APPEND SHARED_SRCS ${CMAKE_SOURCE_DIR}/src/LeakFinder.cpp ${CMAKE_SOURCE_DIR}/src/StackWalker.cpp)
+	list (APPEND SHARED_HDRS ${CMAKE_SOURCE_DIR}/src/LeakFinder.h   ${CMAKE_SOURCE_DIR}/src/StackWalker.h)
+endif()
+
+source_group("Shared" FILES ${SHARED_SRCS} ${SHARED_HDRS})
+source_group("Sources" FILES ${SRCS})
+add_executable(LoadablePieces ${SRCS} ${SHARED_SRCS} ${SHARED_HDRS})
+target_link_libraries(LoadablePieces tolualib zlib)
+add_test(NAME LoadablePieces-test WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND LoadablePieces)
+
+
+
+

tests/LoadablePieces/LoadablePieces.cpp

@@ -0,0 +1,57 @@
+
+// LoadablePieces.cpp
+
+// Implements the LoadablePieces test main entrypoint
+
+#include "Globals.h"
+#ifdef _WIN32
+	#include <direct.h>
+	#define GetCurrentFolder _getcwd
+#else
+	#include <unistd.h>
+	#define GetCurrentFolder getcwd
+#endif
+#include "Generating/PrefabPiecePool.h"
+
+
+
+
+
+static int DoTest(void)
+{
+	cPrefabPiecePool test;
+	auto res = test.LoadFromFile("Test.cubeset", true);
+	if (!res)
+	{
+		LOGWARNING("Loading from file \"Test.cubeset\" failed.");
+		return 1;
+	}
+	LOG("Loaded %u regular pieces and %u starting pieces", static_cast<unsigned>(test.GetAllPiecesCount()), static_cast<unsigned>(test.GetStartingPiecesCount()));
+
+	// Check that we loaded all the pieces:
+	testassert(test.GetAllPiecesCount() == 1);
+	testassert(test.GetStartingPiecesCount() == 1);
+
+	return 0;
+}
+
+
+
+
+
+int main(int argc, char * argv[])
+{
+	// Print the current directory for reference:
+	char folder[FILENAME_MAX];
+	GetCurrentFolder(folder, sizeof(folder));
+	LOG("Running cPrefabPiecePool test from folder \"%s\".", folder);
+
+	// Run the test:
+	int res = DoTest();
+	LOG("cPrefabPiecePool loading test done: %s", (res == 0) ? "success" : "failure");
+	return res;
+}
+
+
+
+

tests/LoadablePieces/LuaState_Declaration.inc

@@ -0,0 +1,4 @@
+
+// LuaState_Declaration.inc
+
+// Dummy include file needed for LuaState to compile successfully

tests/LoadablePieces/LuaState_Typedefs.inc

@@ -0,0 +1,19 @@
+
+// LuaState_Typedefs.inc
+
+// Dummy include file needed for LuaState to compile successfully
+
+
+
+
+
+// Forward-declare classes that are used in the API but never called:
+struct HTTPRequest;
+struct HTTPTemplateRequest;
+class cPluginLua;
+class cBoundingBox;
+template <typename T> class cItemCallback;
+class cEntity;
+
+
+

tests/LoadablePieces/Stubs.cpp

@@ -0,0 +1,283 @@
+
+// Stubs.cpp
+
+// Implements stubs of various MCServer methods that are needed for linking but not for runtime
+// This is required so that we don't bring in the entire MCServer via dependencies
+
+#include "Globals.h"
+#include "BlockInfo.h"
+#include "SelfTests.h"
+#include "Bindings.h"
+#include "Bindings/DeprecatedBindings.h"
+#include "Bindings/ManualBindings.h"
+#include "BlockEntities/BlockEntity.h"
+#include "Blocks/BlockHandler.h"
+#include "Generating/ChunkDesc.h"
+
+
+
+
+
+// fwd:
+struct lua_State;
+
+
+
+
+
+// Prototypes, needed by clang:
+extern "C" int luaopen_lsqlite3(lua_State * a_LuaState);
+extern "C" int luaopen_lxp(lua_State * a_LuaState);
+
+
+
+
+
+void cManualBindings::Bind(lua_State * a_LuaState)
+{
+}
+
+
+
+
+
+void DeprecatedBindings::Bind(lua_State * a_LuaState)
+{
+}
+
+
+
+
+
+int tolua_AllToLua_open(lua_State * a_LuaState)
+{
+	return 0;
+}
+
+
+
+
+
+extern "C" int luaopen_lsqlite3(lua_State * a_LuaState)
+{
+	return 0;
+}
+
+
+
+
+
+extern "C" int luaopen_lxp(lua_State * a_LuaState)
+{
+	return 0;
+}
+
+
+
+
+
+cBlockInfo::~cBlockInfo()
+{
+}
+
+
+
+
+
+void cBlockInfo::Initialize(cBlockInfo::cBlockInfoArray & a_BlockInfos)
+{
+	// The piece-loading code uses the handlers for rotations, so we need valid handlers
+	// Insert dummy handlers:
+	for (size_t i = 0; i < ARRAYCOUNT(a_BlockInfos); i++)
+	{
+		a_BlockInfos[i].m_Handler = new cBlockHandler(static_cast<BLOCKTYPE>(i));
+	}
+}
+
+
+
+
+
+cBlockHandler::cBlockHandler(BLOCKTYPE a_BlockType)
+{
+}
+
+
+
+
+
+bool cBlockHandler::GetPlacementBlockTypeMeta(
+	cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+	int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
+	int a_CursorX, int a_CursorY, int a_CursorZ,
+	BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+)
+{
+	return true;
+}
+
+
+
+
+
+void cBlockHandler::OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnPlacedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, const sSetBlock & a_BlockChange)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnPlaced(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::NeighborChanged(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta)
+{
+}
+
+
+
+
+
+void cBlockHandler::DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, bool a_CanDrop)
+{
+}
+
+
+
+
+
+bool cBlockHandler::CanBeAt(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ, const cChunk & a_Chunk)
+{
+	return true;
+}
+
+
+
+
+
+bool cBlockHandler::CanDirtGrowGrass(NIBBLETYPE a_Meta)
+{
+	return true;
+}
+
+
+
+
+
+bool cBlockHandler::IsUseable()
+{
+	return false;
+}
+
+
+
+
+
+bool cBlockHandler::IsClickedThrough(void)
+{
+	return false;
+}
+
+
+
+
+
+bool cBlockHandler::DoesIgnoreBuildCollision(void)
+{
+	return (m_BlockType == E_BLOCK_AIR);
+}
+
+
+
+
+
+bool cBlockHandler::DoesDropOnUnsuitable(void)
+{
+	return true;
+}
+
+
+
+
+
+void cBlockHandler::Check(cChunkInterface & a_ChunkInterface, cBlockPluginInterface & a_PluginInterface, int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk)
+{
+}
+
+
+
+
+
+cBlockEntity * cBlockEntity::CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
+{
+	return nullptr;
+}
+
+
+
+
+
+cSelfTests::cSelfTests(void):
+	m_AllowRegistering(true)
+{
+}
+
+
+
+
+
+cSelfTests & cSelfTests::Get(void)
+{
+	static cSelfTests singleton;
+	return singleton;
+}
+
+
+
+
+
+void cSelfTests::Register(cSelfTests::SelfTestFunction a_TestFn, const AString & a_TestName)
+{
+}
+
+
+
+

tests/LoadablePieces/Test.cubeset

@@ -0,0 +1,154 @@
+
+-- Test.cubeset
+
+-- This simple cubeset file is used for testing the cPrefabPiecePool loader.
+
+
+
+
+
+Cubeset =
+{
+	Metadata =
+	{
+		CubesetFormatVersion = 1,
+	},
+
+	Pieces =
+	{
+		-- One piece with inline definition:
+		{
+			Size =
+			{
+				x = 4,
+				y = 4,
+				z = 4,
+			},
+			Hitbox =
+			{
+				MinX = 0,
+				MinY = 0,
+				MinZ = 0,
+				MaxX = 3,
+				MaxY = 3,
+				MaxZ = 3,
+			},
+			BlockDefinitions =
+			{
+				".:  0: 0",  -- air
+				"a:  1: 0",  -- stone
+				"b: 24: 0",  -- sandstone
+				"c:  8: 0",  -- water
+				"d: 85: 0",  -- fence
+				"m: 19: 0",  -- sponge
+			},
+			BlockData =
+			{
+				-- Level 0
+				"aaaa",  --  0
+				"aaaa",  --  1
+				"aaaa",  --  2
+				"aaaa",  --  3
+
+				-- Level 1
+				"bbbb",  --  0
+				"bccb",  --  1
+				"bccb",  --  2
+				"bbbb",  --  3
+
+				-- Level 2
+				"bbbb",  --  0
+				"bccb",  --  1
+				"bccb",  --  2
+				"bbbb",  --  3
+
+				-- Level 3
+				"bbbb",  --  0
+				"bccb",  --  1
+				"bccb",  --  2
+				"bbbb",  --  3
+			},
+			Connectors =
+			{
+				{
+					Type = 2,
+					RelX = 2,
+					RelY = 2,
+					RelZ = 0,
+					Direction = 2,  -- Z-
+				},
+				{
+					Type = 2,
+					RelX = 0,
+					RelY = 2,
+					RelZ = 1,
+					Direction = 4,  -- X-
+				},
+				{
+					Type = 2,
+					RelX = 1,
+					RelY = 2,
+					RelZ = 3,
+					Direction = 3,  -- Z+
+				},
+				{
+					Type = 2,
+					RelX = 3,
+					RelY = 2,
+					RelZ = 2,
+					Direction = 5,  -- X+
+				},
+			},
+			Metadata =
+			{
+				["DefaultWeight"] = "100",
+				["AllowedRotations"] = "7",
+				["MergeStrategy"] = "msSpongePrint",
+				["IsStarting"] = "1",
+				["DepthWeight"] = "",
+				["ShouldExpandFloor"] = "1",
+				["MoveToGround"] = "1",
+				["AddWeightIfSame"] = "0",
+			},
+		},
+
+		-- One piece with external definition:
+		{
+			Hitbox =
+			{
+				MinX = 0,
+				MinY = 0,
+				MinZ = 0,
+				MaxX = 3,
+				MaxY = 3,
+				MaxZ = 3,
+			},
+			SchematicFileName = "Test1.schematic",
+			Connectors =
+			{
+				{
+					Type = 2,
+					RelX = 2,
+					RelY = 2,
+					RelZ = 0,
+					Direction = 2,  -- Z-
+				},
+			},
+			Metadata =
+			{
+				["DefaultWeight"] = "100",
+				["AllowedRotations"] = "7",
+				["MergeStrategy"] = "msSpongePrint",
+				["IsStarting"] = "0",
+				["DepthWeight"] = "",
+				["ShouldExpandFloor"] = "1",
+				["MoveToGround"] = "0",
+				["AddWeightIfSame"] = "0",
+			},
+		},
+	},  -- Pieces
+}
+
+
+
+