Implement GTest and change windows output path

Implement GTest as a testing infrastructure.
Make windows output binaries to the build folder instead of the release type folder (potentially issue further down the line)
Add a simple unit test for DestroyableComponent

tests/dCommonTests/AMFDeserializeTests.cpp

@@ -0,0 +1,445 @@
+#include <fstream>
+#include <memory>
+#include <gtest/gtest.h>
+
+#include "AMFDeserialize.h"
+#include "AMFFormat.h"
+
+/**
+ * Helper method that all tests use to get their respective AMF.
+ */
+std::unique_ptr<AMFValue> ReadFromBitStream(RakNet::BitStream* bitStream) {
+	AMFDeserialize deserializer;
+	std::unique_ptr<AMFValue> returnValue(deserializer.Read(bitStream));
+	return returnValue;
+}
+
+/**
+ * @brief Test reading an AMFUndefined value from a BitStream.
+ */
+TEST(dCommonTests, AMFDeserializeAMFUndefinedTest) {
+	CBITSTREAM
+	bitStream.Write<uint8_t>(0x00);
+	std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+	ASSERT_EQ(res->GetValueType(), AMFValueType::AMFUndefined);
+}
+
+/**
+ * @brief Test reading an AMFNull value from a BitStream.
+ *
+ */
+TEST(dCommonTests, AMFDeserializeAMFNullTest) {
+	CBITSTREAM
+	bitStream.Write<uint8_t>(0x01);
+	std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+	ASSERT_EQ(res->GetValueType(), AMFValueType::AMFNull);
+}
+
+/**
+ * @brief Test reading an AMFFalse value from a BitStream.
+ */
+TEST(dCommonTests, AMFDeserializeAMFFalseTest) {
+	CBITSTREAM
+	bitStream.Write<uint8_t>(0x02);
+	std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+	ASSERT_EQ(res->GetValueType(), AMFValueType::AMFFalse);
+}
+
+/**
+ * @brief Test reading an AMFTrue value from a BitStream.
+ */
+TEST(dCommonTests, AMFDeserializeAMFTrueTest) {
+	CBITSTREAM
+	bitStream.Write<uint8_t>(0x03);
+	std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+	ASSERT_EQ(res->GetValueType(), AMFValueType::AMFTrue);
+}
+
+/**
+ * @brief Test reading an AMFInteger value from a BitStream.
+ */
+TEST(dCommonTests, AMFDeserializeAMFIntegerTest) {
+	CBITSTREAM
+	{
+		bitStream.Write<uint8_t>(0x04);
+		// 127 == 01111111
+		bitStream.Write<uint8_t>(127);
+		std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+		ASSERT_EQ(res->GetValueType(), AMFValueType::AMFInteger);
+		// Check that the max value of a byte can be read correctly
+		ASSERT_EQ(static_cast<AMFIntegerValue*>(res.get())->GetIntegerValue(), 127);
+	}
+	bitStream.Reset();
+	{
+		bitStream.Write<uint8_t>(0x04);
+		bitStream.Write<uint32_t>(UINT32_MAX);
+		std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+		ASSERT_EQ(res->GetValueType(), AMFValueType::AMFInteger);
+		// Check that we can read the maximum value correctly
+		ASSERT_EQ(static_cast<AMFIntegerValue*>(res.get())->GetIntegerValue(), 536870911);
+	}
+	bitStream.Reset();
+	{
+		bitStream.Write<uint8_t>(0x04);
+		// 131 == 10000011
+		bitStream.Write<uint8_t>(131);
+		// 255 == 11111111
+		bitStream.Write<uint8_t>(255);
+		// 127 == 01111111
+		bitStream.Write<uint8_t>(127);
+		std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+		ASSERT_EQ(res->GetValueType(), AMFValueType::AMFInteger);
+		// Check that short max can be read correctly
+		ASSERT_EQ(static_cast<AMFIntegerValue*>(res.get())->GetIntegerValue(), UINT16_MAX);
+	}
+	bitStream.Reset();
+	{
+		bitStream.Write<uint8_t>(0x04);
+		// 255 == 11111111
+		bitStream.Write<uint8_t>(255);
+		// 127 == 01111111
+		bitStream.Write<uint8_t>(127);
+		std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+		ASSERT_EQ(res->GetValueType(), AMFValueType::AMFInteger);
+		// Check that 2 byte max can be read correctly
+		ASSERT_EQ(static_cast<AMFIntegerValue*>(res.get())->GetIntegerValue(), 16383);
+	}
+}
+
+/**
+ * @brief Test reading an AMFDouble value from a BitStream.
+ */
+TEST(dCommonTests, AMFDeserializeAMFDoubleTest) {
+	CBITSTREAM
+	bitStream.Write<uint8_t>(0x05);
+	bitStream.Write<double>(25346.4f);
+	std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+	ASSERT_EQ(res->GetValueType(), AMFValueType::AMFDouble);
+	ASSERT_EQ(static_cast<AMFDoubleValue*>(res.get())->GetDoubleValue(), 25346.4f);
+}
+
+/**
+ * @brief Test reading an AMFString value from a BitStream.
+ */
+TEST(dCommonTests, AMFDeserializeAMFStringTest) {
+	CBITSTREAM
+	bitStream.Write<uint8_t>(0x06);
+	bitStream.Write<uint8_t>(0x0F);
+	std::string toWrite = "stateID";
+	for (auto e : toWrite) bitStream.Write<char>(e);
+	std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+	ASSERT_EQ(res->GetValueType(), AMFValueType::AMFString);
+	ASSERT_EQ(static_cast<AMFStringValue*>(res.get())->GetStringValue(), "stateID");
+}
+
+/**
+ * @brief Test reading an AMFArray value from a BitStream.
+ */
+TEST(dCommonTests, AMFDeserializeAMFArrayTest) {
+	CBITSTREAM
+	// Test empty AMFArray
+	bitStream.Write<uint8_t>(0x09);
+	bitStream.Write<uint8_t>(0x01);
+	bitStream.Write<uint8_t>(0x01);
+	{
+		std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+		ASSERT_EQ(res->GetValueType(), AMFValueType::AMFArray);
+		ASSERT_EQ(static_cast<AMFArrayValue*>(res.get())->GetAssociativeMap().size(), 0);
+		ASSERT_EQ(static_cast<AMFArrayValue*>(res.get())->GetDenseArray().size(), 0);
+	}
+	bitStream.Reset();
+	// Test a key'd value and dense value
+	bitStream.Write<uint8_t>(0x09);
+	bitStream.Write<uint8_t>(0x03);
+	bitStream.Write<uint8_t>(0x15);
+	for (auto e : "BehaviorID") if (e != '\0') bitStream.Write<char>(e);
+	bitStream.Write<uint8_t>(0x06);
+	bitStream.Write<uint8_t>(0x0B);
+	for (auto e : "10447") if (e != '\0') bitStream.Write<char>(e);
+	bitStream.Write<uint8_t>(0x01);
+	bitStream.Write<uint8_t>(0x06);
+	bitStream.Write<uint8_t>(0x0B);
+	for (auto e : "10447") if (e != '\0') bitStream.Write<char>(e);
+	{
+		std::unique_ptr<AMFValue> res(ReadFromBitStream(&bitStream));
+		ASSERT_EQ(res->GetValueType(), AMFValueType::AMFArray);
+		ASSERT_EQ(static_cast<AMFArrayValue*>(res.get())->GetAssociativeMap().size(), 1);
+		ASSERT_EQ(static_cast<AMFArrayValue*>(res.get())->GetDenseArray().size(), 1);
+		ASSERT_EQ(static_cast<AMFArrayValue*>(res.get())->FindValue<AMFStringValue>("BehaviorID")->GetStringValue(), "10447");
+		ASSERT_EQ(static_cast<AMFArrayValue*>(res.get())->GetValueAt<AMFStringValue>(0)->GetStringValue(), "10447");
+	}
+}
+
+/**
+ * @brief This test checks that if we recieve an unimplemented AMFValueType
+ * we correctly throw an error and can actch it.
+ *
+ */
+#pragma message("-- The AMFDeserializeUnimplementedValuesTest causes a known memory leak of 880 bytes since it throws errors! --")
+TEST(dCommonTests, AMFDeserializeUnimplementedValuesTest) {
+	std::vector<AMFValueType> unimplementedValues = {
+		AMFValueType::AMFXMLDoc,
+		AMFValueType::AMFDate,
+		AMFValueType::AMFObject,
+		AMFValueType::AMFXML,
+		AMFValueType::AMFByteArray,
+		AMFValueType::AMFVectorInt,
+		AMFValueType::AMFVectorUInt,
+		AMFValueType::AMFVectorDouble,
+		AMFValueType::AMFVectorObject,
+		AMFValueType::AMFDictionary
+	};
+	// Run unimplemented tests to check that errors are thrown if
+	// unimplemented AMF values are attempted to be parsed.
+	std::ifstream fileStream;
+	fileStream.open("AMFBitStreamUnimplementedTest.bin", std::ios::binary);
+
+	// Read a test BitStream from a file
+	std::vector<char> baseBitStream;
+	char byte = 0;
+	while (fileStream.get(byte)) {
+		baseBitStream.push_back(byte);
+	}
+
+	fileStream.close();
+
+	for (auto amfValueType : unimplementedValues) {
+		RakNet::BitStream testBitStream;
+		for (auto element : baseBitStream) {
+			testBitStream.Write(element);
+		}
+		testBitStream.Write(amfValueType);
+		bool caughtException = false;
+		try {
+			ReadFromBitStream(&testBitStream);
+		} catch (AMFValueType unimplementedValueType) {
+			caughtException = true;
+		}
+
+		ASSERT_EQ(caughtException, true);
+	}
+}
+
+/**
+ * @brief Test reading a packet capture from live from a BitStream
+ */
+TEST(dCommonTests, AMFDeserializeLivePacketTest) {
+	std::ifstream testFileStream;
+	testFileStream.open("AMFBitStreamTest.bin", std::ios::binary);
+
+	// Read a test BitStream from a file
+	RakNet::BitStream testBitStream;
+	char byte = 0;
+	while (testFileStream.get(byte)) {
+		testBitStream.Write<char>(byte);
+	}
+
+	testFileStream.close();
+
+	auto resultFromFn = ReadFromBitStream(&testBitStream);
+	auto result = static_cast<AMFArrayValue*>(resultFromFn.get());
+	// Test the outermost array
+
+	ASSERT_EQ(result->FindValue<AMFStringValue>("BehaviorID")->GetStringValue(), "10447");
+	ASSERT_EQ(result->FindValue<AMFStringValue>("objectID")->GetStringValue(), "288300744895913279");
+
+	// Test the execution state array
+	auto executionState = result->FindValue<AMFArrayValue>("executionState");
+
+	ASSERT_NE(executionState, nullptr);
+
+	auto strips = executionState->FindValue<AMFArrayValue>("strips")->GetDenseArray();
+
+	ASSERT_EQ(strips.size(), 1);
+
+	auto stripsPosition0 = dynamic_cast<AMFArrayValue*>(strips[0]);
+
+	auto actionIndex = stripsPosition0->FindValue<AMFDoubleValue>("actionIndex");
+
+	ASSERT_EQ(actionIndex->GetDoubleValue(), 0.0f);
+
+	auto stripIDExecution = stripsPosition0->FindValue<AMFDoubleValue>("id");
+
+	ASSERT_EQ(stripIDExecution->GetDoubleValue(), 0.0f);
+
+	auto stateIDExecution = executionState->FindValue<AMFDoubleValue>("stateID");
+
+	ASSERT_EQ(stateIDExecution->GetDoubleValue(), 0.0f);
+
+	auto states = result->FindValue<AMFArrayValue>("states")->GetDenseArray();
+
+	ASSERT_EQ(states.size(), 1);
+
+	auto firstState = dynamic_cast<AMFArrayValue*>(states[0]);
+
+	auto stateID = firstState->FindValue<AMFDoubleValue>("id");
+
+	ASSERT_EQ(stateID->GetDoubleValue(), 0.0f);
+
+	auto stripsInState = firstState->FindValue<AMFArrayValue>("strips")->GetDenseArray();
+
+	ASSERT_EQ(stripsInState.size(), 1);
+
+	auto firstStrip = dynamic_cast<AMFArrayValue*>(stripsInState[0]);
+
+	auto actionsInFirstStrip = firstStrip->FindValue<AMFArrayValue>("actions")->GetDenseArray();
+
+	ASSERT_EQ(actionsInFirstStrip.size(), 3);
+
+	auto actionID = firstStrip->FindValue<AMFDoubleValue>("id");
+
+	ASSERT_EQ(actionID->GetDoubleValue(), 0.0f);
+
+	auto uiArray = firstStrip->FindValue<AMFArrayValue>("ui");
+
+	auto xPos = uiArray->FindValue<AMFDoubleValue>("x");
+	auto yPos = uiArray->FindValue<AMFDoubleValue>("y");
+
+	ASSERT_EQ(xPos->GetDoubleValue(), 103.0f);
+	ASSERT_EQ(yPos->GetDoubleValue(), 82.0f);
+
+	auto stripID = firstStrip->FindValue<AMFDoubleValue>("id");
+
+	ASSERT_EQ(stripID->GetDoubleValue(), 0.0f);
+
+	auto firstAction = dynamic_cast<AMFArrayValue*>(actionsInFirstStrip[0]);
+
+	auto firstType = firstAction->FindValue<AMFStringValue>("Type");
+
+	ASSERT_EQ(firstType->GetStringValue(), "OnInteract");
+
+	auto firstCallback = firstAction->FindValue<AMFStringValue>("__callbackID__");
+
+	ASSERT_EQ(firstCallback->GetStringValue(), "");
+
+	auto secondAction = dynamic_cast<AMFArrayValue*>(actionsInFirstStrip[1]);
+
+	auto secondType = secondAction->FindValue<AMFStringValue>("Type");
+
+	ASSERT_EQ(secondType->GetStringValue(), "FlyUp");
+
+	auto secondCallback = secondAction->FindValue<AMFStringValue>("__callbackID__");
+
+	ASSERT_EQ(secondCallback->GetStringValue(), "");
+
+	auto secondDistance = secondAction->FindValue<AMFDoubleValue>("Distance");
+
+	ASSERT_EQ(secondDistance->GetDoubleValue(), 25.0f);
+
+	auto thirdAction = dynamic_cast<AMFArrayValue*>(actionsInFirstStrip[2]);
+
+	auto thirdType = thirdAction->FindValue<AMFStringValue>("Type");
+
+	ASSERT_EQ(thirdType->GetStringValue(), "FlyDown");
+
+	auto thirdCallback = thirdAction->FindValue<AMFStringValue>("__callbackID__");
+
+	ASSERT_EQ(thirdCallback->GetStringValue(), "");
+
+	auto thirdDistance = thirdAction->FindValue<AMFDoubleValue>("Distance");
+
+	ASSERT_EQ(thirdDistance->GetDoubleValue(), 25.0f);
+}
+
+/**
+ * @brief Tests that having no BitStream returns a nullptr.
+ */
+TEST(dCommonTests, AMFDeserializeNullTest) {
+	auto result = ReadFromBitStream(nullptr);
+	ASSERT_EQ(result.get(), nullptr);
+}
+
+TEST(dCommonTests, AMFBadConversionTest) {
+	std::ifstream testFileStream;
+	testFileStream.open("AMFBitStreamTest.bin", std::ios::binary);
+
+	// Read a test BitStream from a file
+	RakNet::BitStream testBitStream;
+	char byte = 0;
+	while (testFileStream.get(byte)) {
+		testBitStream.Write<char>(byte);
+	}
+
+	testFileStream.close();
+
+	auto resultFromFn = ReadFromBitStream(&testBitStream);
+	auto result = static_cast<AMFArrayValue*>(resultFromFn.get());
+
+	// Actually a string value.
+	ASSERT_EQ(result->FindValue<AMFDoubleValue>("BehaviorID"), nullptr);
+
+	// Does not exist in the associative portion
+	ASSERT_EQ(result->FindValue<AMFNullValue>("DOES_NOT_EXIST"), nullptr);
+
+	result->PushBackValue(new AMFTrueValue());
+
+	// Exists and is correct type
+	ASSERT_NE(result->GetValueAt<AMFTrueValue>(0), nullptr);
+
+	// Value exists but is wrong typing
+	ASSERT_EQ(result->GetValueAt<AMFFalseValue>(0), nullptr);
+
+	// Value is out of bounds
+	ASSERT_EQ(result->GetValueAt<AMFTrueValue>(1), nullptr);
+}
+
+/**
+ * Below is the AMF that is in the AMFBitStreamTest.bin file that we are reading in
+ * from a bitstream to test.
+args: amf3!
+{
+	"objectID": "288300744895913279",
+	"BehaviorID": "10447",
+	"executionState": amf3!
+	{
+		"strips": amf3!
+		[
+			amf3!
+			{
+				"actionIndex": 0.0,
+				"id": 0.0,
+			},
+		],
+		"stateID": 0.0,
+	},
+	"states": amf3!
+	[
+		amf3!
+		{
+			"id": 0.0,
+			"strips": amf3!
+			[
+				amf3!
+				{
+					"actions": amf3!
+					[
+						amf3!
+						{
+							"Type": "OnInteract",
+							"__callbackID__": "",
+						},
+						amf3!
+						{
+							"Distance": 25.0,
+							"Type": "FlyUp",
+							"__callbackID__": "",
+						},
+						amf3!
+						{
+							"Distance": 25.0,
+							"Type": "FlyDown",
+							"__callbackID__": "",
+						},
+					],
+					"id": 0.0,
+					"ui": amf3!
+					{
+						"x": 103.0,
+						"y": 82.0,
+					},
+				},
+			],
+		},
+	],
+}
+ */

tests/dCommonTests/CMakeLists.txt

@@ -0,0 +1,19 @@
+set(DCOMMONTEST_SOURCES
+	"AMFDeserializeTests.cpp"
+	"TestLDFFormat.cpp"
+	"TestNiPoint3.cpp"
+	"TestEncoding.cpp"
+)
+
+# Set our executable
+add_executable(dCommonTests ${DCOMMONTEST_SOURCES})
+
+# Link needed libraries
+target_link_libraries(dCommonTests ${COMMON_LIBRARIES} GTest::gtest_main)
+
+# Copy test files to testing directory
+add_subdirectory(TestBitStreams)
+file(COPY ${TESTBITSTREAMS} DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+# Discover the tests
+gtest_discover_tests(dCommonTests)

tests/dCommonTests/TestBitStreams/AMFBitStreamUnimplementedTest.bin

@@ -0,0 +1 @@
+	
BehaviorID

tests/dCommonTests/TestBitStreams/CMakeLists.txt

@@ -0,0 +1,11 @@
+set(TESTBITSTREAMS
+	"AMFBitStreamTest.bin"
+	"AMFBitStreamUnimplementedTest.bin"
+)
+
+# Get the folder name and prepend it to the files above
+get_filename_component(thisFolderName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+list(TRANSFORM TESTBITSTREAMS PREPEND "${thisFolderName}/")
+
+# Export our list of files
+set(TESTBITSTREAMS ${TESTBITSTREAMS} PARENT_SCOPE)

tests/dCommonTests/TestEncoding.cpp

@@ -0,0 +1,68 @@
+#include <string>
+#include <gtest/gtest.h>
+#include <string_view>
+
+#include "GeneralUtils.h"
+
+class EncodingTest : public ::testing::Test {
+protected:
+	std::string originalWord;
+	std::string_view originalWordSv;
+	uint32_t out;
+};
+
+TEST_F(EncodingTest, TestEncodingHello) {
+	originalWord = "Hello World!";
+	originalWordSv = originalWord;
+
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, 'H');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, 'e');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, 'l');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, 'l');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, 'o');
+	EXPECT_EQ(GeneralUtils::_NextUTF8Char(originalWordSv, out), true);
+
+	EXPECT_EQ(GeneralUtils::UTF8ToUTF16("Hello World!"), u"Hello World!");
+};
+
+TEST_F(EncodingTest, TestEncodingUmlaut) {
+	originalWord = u8"Frühling";
+	originalWordSv = originalWord;
+
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'F');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'r');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'ü');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'h');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'l');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'i');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'n');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'g');
+	EXPECT_EQ(GeneralUtils::_NextUTF8Char(originalWordSv, out), false);
+
+	EXPECT_EQ(GeneralUtils::UTF8ToUTF16("Frühling"), u"Frühling");
+};
+
+TEST_F(EncodingTest, TestEncodingChinese) {
+	originalWord = "中文字";
+	originalWordSv = originalWord;
+
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'中');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'文');
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, U'字');
+	EXPECT_EQ(GeneralUtils::_NextUTF8Char(originalWordSv, out), false);
+
+	EXPECT_EQ(GeneralUtils::UTF8ToUTF16("中文字"), u"中文字");
+};
+
+TEST_F(EncodingTest, TestEncodingEmoji) {
+	originalWord = "👨‍⚖️";
+	originalWordSv = originalWord;
+
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, 0x1F468);
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, 0x200D);
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, 0x2696);
+	GeneralUtils::_NextUTF8Char(originalWordSv, out); EXPECT_EQ(out, 0xFE0F);
+	EXPECT_EQ(GeneralUtils::_NextUTF8Char(originalWordSv, out), false);
+
+	EXPECT_EQ(GeneralUtils::UTF8ToUTF16("👨‍⚖️"), u"👨‍⚖️");
+};

tests/dCommonTests/TestLDFFormat.cpp

@@ -0,0 +1,25 @@
+#include "LDFFormat.h"
+#include <gtest/gtest.h>
+
+/**
+ * @brief Test parsing an LDF value
+ */
+TEST(dCommonTests, LDFTest) {
+	// Create
+	auto* data = LDFBaseData::DataFromString("KEY=0:VALUE");
+
+	// Check that the data type is correct
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
+
+	// Check that the key is correct
+	ASSERT_EQ(data->GetKey(), u"KEY");
+
+	// Check that the value is correct
+	ASSERT_EQ(((LDFData<std::u16string>*)data)->GetValue(), u"VALUE");
+
+	// Check that the serialization is correct
+	ASSERT_EQ(data->GetString(), "KEY=0:VALUE");
+
+	// Cleanup the object
+	delete data;
+}

tests/dCommonTests/TestNiPoint3.cpp

@@ -0,0 +1,14 @@
+#include <gtest/gtest.h>
+
+#include "NiPoint3.h"
+
+/**
+ * @brief Basic test for NiPoint3 functionality
+ *
+ */
+TEST(dCommonTests, NiPoint3Test) {
+	// Check that Unitize works
+	ASSERT_EQ(NiPoint3(3, 0, 0).Unitize(), NiPoint3::UNIT_X);
+	// Check what unitize does to a vector of length 0
+	ASSERT_EQ(NiPoint3::ZERO.Unitize(), NiPoint3::ZERO);
+}