Add tests for LDF parsing and serialization. Cleanup LDF (#1062)

* Add tests and cleanup LDF header

Also implements a speedup by using overloaded operators to put numbers directly to a stream as opposed to doing to_string first.

Stage 2 of re-write

Reduce scoping
Add further optimizations
Fix more edge cases
Split out tests to many smaller ones

Use EXPECT_NO_THROW

Add edge cases to test

Added these first with the before to confirm they failed, and now will be adding the remaining fixes needed to make the tests pass.

Add edge case testing for LDF strings

Add further tests

Use characters instead of char*

Update AMFDeserializeTests.cpp

Add null tests

* Add Test Fixture for dCommon

* Add speed test

* Convert to using string_view

* Add explanation on early return

* Remove "testing" code

tests/dCommonTests/CMakeLists.txt

@@ -3,6 +3,7 @@ set(DCOMMONTEST_SOURCES
 	"TestLDFFormat.cpp"
 	"TestNiPoint3.cpp"
 	"TestEncoding.cpp"
+	"dCommonDependencies.cpp"
 )
 
 # Set our executable

tests/dCommonTests/TestLDFFormat.cpp

@@ -1,25 +1,252 @@
 #include "LDFFormat.h"
+
 #include <gtest/gtest.h>
 
-/**
- * @brief Test parsing an LDF value
- */
-TEST(dCommonTests, LDFTest) {
-	// Create
-	auto* data = LDFBaseData::DataFromString("KEY=0:VALUE");
+#include "Game.h"
+#include "dCommonDependencies.h"
+#include "dLogger.h"
 
-	// Check that the data type is correct
+class LDFTests : public dCommonDependenciesTest {
+protected:
+	void SetUp() override {
+		SetUpDependencies();
+	}
+
+	void TearDown() override {
+		TearDownDependencies();
+	}
+};
+
+#define LdfUniquePtr std::unique_ptr<LDFBaseData>  
+
+// Suite of tests for parsing LDF values
+
+TEST_F(LDFTests, LDFUTF16Test) {
+	std::string testWord = "KEY=0:IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ";
+	LdfUniquePtr data(LDFBaseData::DataFromString(testWord));
+	ASSERT_NE(data, nullptr);
 	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;
+	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
+	ASSERT_EQ(data->GetString(), testWord);
 }
+
+TEST_F(LDFTests, LDFUTF16EmptyTest) {
+	std::string testWord = "KEY=0:";
+	LdfUniquePtr data(LDFBaseData::DataFromString(testWord));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"");
+	ASSERT_EQ(data->GetString(), testWord);
+}
+
+TEST_F(LDFTests, LDFUTF16ColonTest) {
+	std::string testWord = "KEY=0:::";
+	LdfUniquePtr data(LDFBaseData::DataFromString(testWord));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"::");
+	ASSERT_EQ(data->GetString(), testWord);
+}
+
+TEST_F(LDFTests, LDFUTF16EqualsTest) {
+	std::string testWord = "KEY=0:==";
+	LdfUniquePtr data(LDFBaseData::DataFromString(testWord));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"==");
+	ASSERT_EQ(data->GetString(), testWord);
+}
+
+TEST_F(LDFTests, LDFS32Test) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=1:-15"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_S32);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<int32_t>*)data.get())->GetValue(), -15);
+	ASSERT_EQ(data->GetString(), "KEY=1:-15");
+}
+TEST_F(LDFTests, LDFU32Test) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=5:15"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<uint32_t>*)data.get())->GetValue(), 15);
+	ASSERT_EQ(data->GetString(), "KEY=5:15");
+}
+
+TEST_F(LDFTests, LDFU32TrueTest) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=5:true"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<uint32_t>*)data.get())->GetValue(), 1);
+	ASSERT_EQ(data->GetString(), "KEY=5:1");
+}
+
+TEST_F(LDFTests, LDFU32FalseTest) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=5:false"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<uint32_t>*)data.get())->GetValue(), 0);
+	ASSERT_EQ(data->GetString(), "KEY=5:0");
+}
+
+
+// Use find since floats and doubles generally have appended 0s
+TEST_F(LDFTests, LDFFloatTest) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=3:15.5"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_FLOAT);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<float>*)data.get())->GetValue(), 15.5f);
+	ASSERT_EQ(data->GetString().find("KEY=3:15.5"), 0);
+}
+
+TEST_F(LDFTests, LDFDoubleTest) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=4:15.5"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_DOUBLE);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<double>*)data.get())->GetValue(), 15.5);
+	ASSERT_EQ(data->GetString().find("KEY=4:15.5"), 0);
+}
+
+
+TEST_F(LDFTests, LDFBoolTrueTest) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=7:true"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<bool>*)data.get())->GetValue(), true);
+	ASSERT_EQ(data->GetString(), "KEY=7:1");
+}
+
+TEST_F(LDFTests, LDFBoolFalseTest) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=7:false"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<bool>*)data.get())->GetValue(), false);
+	ASSERT_EQ(data->GetString(), "KEY=7:0");
+}
+
+TEST_F(LDFTests, LDFBoolIntTest) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=7:3"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<bool>*)data.get())->GetValue(), true);
+	ASSERT_EQ(data->GetString(), "KEY=7:1");
+}
+
+TEST_F(LDFTests, LDFU64Test) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=8:15"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U64);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<uint64_t>*)data.get())->GetValue(), 15);
+	ASSERT_EQ(data->GetString(), "KEY=8:15");
+}
+
+TEST_F(LDFTests, LDFLWOOBJIDTest) {
+	LdfUniquePtr data(LDFBaseData::DataFromString("KEY=9:15"));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_OBJID);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<uint64_t>*)data.get())->GetValue(), 15);
+	ASSERT_EQ(data->GetString(), "KEY=9:15");
+}
+
+TEST_F(LDFTests, LDFUTF8Test) {
+	std::string testWord = "KEY=13:IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ";
+	LdfUniquePtr data(LDFBaseData::DataFromString(testWord));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
+	ASSERT_EQ(data->GetString(), testWord);
+}
+
+TEST_F(LDFTests, LDFUTF8EmptyTest) {
+	std::string testWord = "KEY=13:";
+	LdfUniquePtr data(LDFBaseData::DataFromString(testWord));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "");
+	ASSERT_EQ(data->GetString(), testWord);
+}
+
+TEST_F(LDFTests, LDFUTF8ColonsTest) {
+	std::string testWord = "KEY=13:::";
+	LdfUniquePtr data(LDFBaseData::DataFromString(testWord));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "::");
+	ASSERT_EQ(data->GetString(), testWord);
+}
+TEST_F(LDFTests, LDFUTF8EqualsTest) {
+	std::string testWord = "KEY=13:==";
+	LdfUniquePtr data(LDFBaseData::DataFromString(testWord));
+	ASSERT_NE(data, nullptr);
+	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
+	ASSERT_EQ(data->GetKey(), u"KEY");
+	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "==");
+	ASSERT_EQ(data->GetString(), testWord);
+}
+
+
+TEST_F(LDFTests, LDFParseEdgeCaseTest) {
+	std::vector<std::string> tests = {
+		// Test undefined data
+		"", // Empty
+		"=", // Only equals sign
+		":", // Only colon
+		"=:", // Only colon and equals sign
+
+		// Test no LDFType
+		"KEY=:", // No LDF Type
+		"KEY=:44", // No LDF Type, but has value
+	
+		// Test invalid values, but valid types
+		"key=1:", // no value for int32 
+		"key=1:banana", // invalid value for int32 
+		"key=3:", // No value for float
+		"key=3:banana", // invalid for float
+		"key=4:", // No value for double
+		"key=4:banana", // invalid for double
+		"key=5:", // No value for U32
+		"key=5:banana", // invalid for U32
+		"key=7:", // No value for bool
+		"key=7:banana", // invalid for bool
+		"key=8:", // No value for U64
+		"key=8:banana", // invalid for U64
+		"key=9:", // No value for LWOOBJID
+		"key=9:banana", // invalid for LWOOBJID
+
+		// Test invalid LDF types
+		"key=14:value", // invalid LDF type
+		"key=-1:value", // invalid LDF type
+		"key=-2:value", // invalid LDF type (no enum definition)
+		"key=Garbage:value", // invalid LDF type
+	};
+	for (auto testString : tests) {
+		Game::logger->Log("LDFTests", "Testing LDF Parsing of invalid string (%s)", testString.c_str());
+		EXPECT_NO_THROW(LDFBaseData::DataFromString(testString));
+	}
+}
+
+#ifdef PERF_TEST
+
+TEST_F(LDFTests, LDFSpeedTest) {
+	std::string keyToTest = "KEY=0:IAmA weird string with :::: and s";
+	for (int i = 0; i < 10000; i++) LDFBaseData::DataFromString(keyToTest);
+}
+
+#endif //PERF

tests/dCommonTests/dCommonDependencies.cpp

@@ -0,0 +1,7 @@
+#include "Game.h"
+
+class dLogger;
+namespace Game
+{
+	dLogger* logger;
+} // namespace Game

tests/dCommonTests/dCommonDependencies.h

@@ -0,0 +1,26 @@
+#ifndef __DCOMMONDEPENDENCIES__H__
+#define __DCOMMONDEPENDENCIES__H__
+
+#include "Game.h"
+#include "dLogger.h"
+#include "dServer.h"
+#include "EntityInfo.h"
+#include "EntityManager.h"
+#include "dConfig.h"
+#include <gtest/gtest.h>
+
+class dCommonDependenciesTest : public ::testing::Test {
+protected:
+	void SetUpDependencies() {
+		Game::logger = new dLogger("./testing.log", true, true);
+	}
+
+	void TearDownDependencies() {
+		if (Game::logger) {
+			Game::logger->Flush();
+			delete Game::logger;
+		}
+	}
+};
+
+#endif  //!__DCOMMONDEPENDENCIES__H__