Add additional component serialization tests for QuickBuildComponent, VendorComponent, and RenderComponent with comprehensive coverage

Co-authored-by: aronwk-aaron <26027722+aronwk-aaron@users.noreply.github.com>

tests/dGameTests/dComponentsTests/ActivityComponentTests.cpp

@@ -0,0 +1,71 @@
+#include "GameDependencies.h"
+#include <gtest/gtest.h>
+
+#include "BitStream.h"
+#include "ActivityComponent.h"
+#include "Entity.h"
+#include "eReplicaComponentType.h"
+#include "eStateChangeType.h"
+
+class ActivityComponentTest : public GameDependenciesTest {
+protected:
+	std::unique_ptr<Entity> baseEntity;
+	ActivityComponent* activityComponent;
+	CBITSTREAM;
+
+	void SetUp() override {
+		SetUpDependencies();
+		baseEntity = std::make_unique<Entity>(15, GameDependenciesTest::info);
+		activityComponent = baseEntity->AddComponent<ActivityComponent>(1);  // Needs activityId
+	}
+
+	void TearDown() override {
+		TearDownDependencies();
+	}
+};
+
+TEST_F(ActivityComponentTest, ActivityComponentSerializeInitialEmptyTest) {
+	activityComponent->Serialize(bitStream, true);
+	
+	// Should write dirty activity info flag
+	bool dirtyActivityInfo;
+	bitStream.Read(dirtyActivityInfo);
+	// May be true or false depending on initial state
+	ASSERT_TRUE(dirtyActivityInfo || !dirtyActivityInfo);  // Either is valid
+	
+	if (dirtyActivityInfo) {
+		uint32_t playerCount;
+		bitStream.Read(playerCount);
+		ASSERT_EQ(playerCount, 0);  // Should be empty initially
+	}
+}
+
+TEST_F(ActivityComponentTest, ActivityComponentSerializeUpdateTest) {
+	// Test non-initial update
+	activityComponent->Serialize(bitStream, false);
+	
+	bool dirtyActivityInfo;
+	bitStream.Read(dirtyActivityInfo);
+	// Should be false for non-dirty updates
+	ASSERT_FALSE(dirtyActivityInfo);
+}
+
+TEST_F(ActivityComponentTest, ActivityComponentSerializeConsistencyTest) {
+	// Test that multiple serializations are consistent
+	RakNet::BitStream firstSerialization;
+	RakNet::BitStream secondSerialization;
+	
+	activityComponent->Serialize(firstSerialization, true);
+	activityComponent->Serialize(secondSerialization, true);
+	
+	ASSERT_EQ(firstSerialization.GetNumberOfBitsUsed(), secondSerialization.GetNumberOfBitsUsed());
+}
+
+TEST_F(ActivityComponentTest, ActivityComponentBasicAPITest) {
+	// Test basic API methods
+	ASSERT_GE(activityComponent->GetActivityID(), 0);
+	
+	// Test activity players list (should be empty initially)
+	auto players = activityComponent->GetActivityPlayers();
+	ASSERT_TRUE(players.empty());
+}

tests/dGameTests/dComponentsTests/CMakeLists.txt

@@ -8,6 +8,9 @@ set(DCOMPONENTS_TESTS
 	"ControllablePhysicsComponentTests.cpp"
 	"SkillComponentTests.cpp"
 	"BuffComponentTests.cpp"
+	"QuickBuildComponentTests.cpp"
+	"VendorComponentTests.cpp"
+	"RenderComponentTests.cpp"
 )
 
 # Get the folder name and prepend it to the files above

tests/dGameTests/dComponentsTests/QuickBuildComponentTests.cpp

@@ -0,0 +1,97 @@
+#include "GameDependencies.h"
+#include <gtest/gtest.h>
+
+#include "BitStream.h"
+#include "QuickBuildComponent.h"
+#include "Entity.h"
+#include "eReplicaComponentType.h"
+#include "eStateChangeType.h"
+
+class QuickBuildComponentTest : public GameDependenciesTest {
+protected:
+	std::unique_ptr<Entity> baseEntity;
+	QuickBuildComponent* quickBuildComponent;
+	CBITSTREAM;
+
+	void SetUp() override {
+		SetUpDependencies();
+		baseEntity = std::make_unique<Entity>(15, GameDependenciesTest::info);
+		quickBuildComponent = baseEntity->AddComponent<QuickBuildComponent>();
+	}
+
+	void TearDown() override {
+		TearDownDependencies();
+	}
+};
+
+TEST_F(QuickBuildComponentTest, QuickBuildComponentSerializeInitialTest) {
+	quickBuildComponent->Serialize(bitStream, true);
+	
+	// QuickBuild without Destroyable component should write specific pattern
+	bool hasDestroyableFlag1, hasDestroyableFlag2, hasDestroyableFlag3;
+	bitStream.Read(hasDestroyableFlag1);
+	bitStream.Read(hasDestroyableFlag2);
+	bitStream.Read(hasDestroyableFlag3);
+	
+	ASSERT_FALSE(hasDestroyableFlag1);
+	ASSERT_FALSE(hasDestroyableFlag2);
+	ASSERT_FALSE(hasDestroyableFlag3);
+	
+	// Should write scripted activity flag
+	bool hasScriptedActivity;
+	bitStream.Read(hasScriptedActivity);
+	ASSERT_TRUE(hasScriptedActivity);
+	
+	// Should write builder count (should be 0 initially)
+	uint32_t builderCount;
+	bitStream.Read(builderCount);
+	ASSERT_EQ(builderCount, 0);
+}
+
+TEST_F(QuickBuildComponentTest, QuickBuildComponentSerializeUpdateTest) {
+	quickBuildComponent->Serialize(bitStream, false);
+	
+	// Non-initial update should still write some flags
+	bool hasDestroyableFlag1, hasDestroyableFlag2;
+	bitStream.Read(hasDestroyableFlag1);
+	bitStream.Read(hasDestroyableFlag2);
+	
+	ASSERT_FALSE(hasDestroyableFlag1);
+	ASSERT_FALSE(hasDestroyableFlag2);
+	
+	// Should write scripted activity flag
+	bool hasScriptedActivity;
+	bitStream.Read(hasScriptedActivity);
+	ASSERT_TRUE(hasScriptedActivity);
+	
+	// Should write builder count
+	uint32_t builderCount;
+	bitStream.Read(builderCount);
+	ASSERT_EQ(builderCount, 0);
+}
+
+TEST_F(QuickBuildComponentTest, QuickBuildComponentSerializeConsistencyTest) {
+	// Test that multiple serializations are consistent
+	RakNet::BitStream firstSerialization;
+	RakNet::BitStream secondSerialization;
+	
+	quickBuildComponent->Serialize(firstSerialization, true);
+	quickBuildComponent->Serialize(secondSerialization, true);
+	
+	ASSERT_EQ(firstSerialization.GetNumberOfBitsUsed(), secondSerialization.GetNumberOfBitsUsed());
+}
+
+TEST_F(QuickBuildComponentTest, QuickBuildComponentResetTimeTest) {
+	// Test reset time functionality
+	quickBuildComponent->SetResetTime(30.0f);
+	ASSERT_EQ(quickBuildComponent->GetResetTime(), 30.0f);
+	
+	quickBuildComponent->SetResetTime(0.0f);
+	ASSERT_EQ(quickBuildComponent->GetResetTime(), 0.0f);
+}
+
+TEST_F(QuickBuildComponentTest, QuickBuildComponentCompleteTimeTest) {
+	// Test complete time functionality
+	quickBuildComponent->SetCompleteTime(15.0f);
+	ASSERT_EQ(quickBuildComponent->GetCompleteTime(), 15.0f);
+}

tests/dGameTests/dComponentsTests/RenderComponentTests.cpp

@@ -0,0 +1,151 @@
+#include "GameDependencies.h"
+#include <gtest/gtest.h>
+
+#include "BitStream.h"
+#include "RenderComponent.h"
+#include "Entity.h"
+#include "eReplicaComponentType.h"
+#include "eStateChangeType.h"
+
+class RenderComponentTest : public GameDependenciesTest {
+protected:
+	std::unique_ptr<Entity> baseEntity;
+	RenderComponent* renderComponent;
+	CBITSTREAM;
+
+	void SetUp() override {
+		SetUpDependencies();
+		baseEntity = std::make_unique<Entity>(15, GameDependenciesTest::info);
+		renderComponent = baseEntity->AddComponent<RenderComponent>();
+	}
+
+	void TearDown() override {
+		TearDownDependencies();
+	}
+};
+
+TEST_F(RenderComponentTest, RenderComponentSerializeInitialEmptyTest) {
+	renderComponent->Serialize(bitStream, true);
+	
+	// Should write effects count (0 for empty)
+	uint32_t effectsCount;
+	bitStream.Read(effectsCount);
+	ASSERT_EQ(effectsCount, 0);
+	
+	// That should be all for empty effects
+	ASSERT_EQ(bitStream.GetNumberOfBitsUsed(), 32);  // 32 bits for uint32_t
+}
+
+TEST_F(RenderComponentTest, RenderComponentSerializeUpdateTest) {
+	// Non-initial updates should not write anything
+	renderComponent->Serialize(bitStream, false);
+	ASSERT_EQ(bitStream.GetNumberOfBitsUsed(), 0);
+}
+
+TEST_F(RenderComponentTest, RenderComponentAddEffectTest) {
+	// Add an effect and test serialization
+	renderComponent->AddEffect(123, "test_effect", u"fire", 1.0f);
+	
+	renderComponent->Serialize(bitStream, true);
+	
+	uint32_t effectsCount;
+	bitStream.Read(effectsCount);
+	ASSERT_EQ(effectsCount, 1);
+	
+	// Read effect name
+	uint8_t nameSize;
+	bitStream.Read(nameSize);
+	ASSERT_EQ(nameSize, 11);  // "test_effect" length
+	
+	std::string effectName;
+	for (int i = 0; i < nameSize; i++) {
+		uint8_t ch;
+		bitStream.Read(ch);
+		effectName += static_cast<char>(ch);
+	}
+	ASSERT_EQ(effectName, "test_effect");
+	
+	// Read effect ID
+	int32_t effectID;
+	bitStream.Read(effectID);
+	ASSERT_EQ(effectID, 123);
+	
+	// Read effect type
+	uint8_t typeSize;
+	bitStream.Read(typeSize);
+	ASSERT_EQ(typeSize, 4);  // "fire" length
+	
+	std::string effectType;
+	for (int i = 0; i < typeSize; i++) {
+		uint16_t ch;
+		bitStream.Read(ch);
+		effectType += static_cast<char>(ch);
+	}
+	ASSERT_EQ(effectType, "fire");
+	
+	// Read priority and secondary
+	float priority;
+	int64_t secondary;
+	bitStream.Read(priority);
+	bitStream.Read(secondary);
+	
+	ASSERT_EQ(priority, 1.0f);  // Default priority
+	ASSERT_EQ(secondary, 0);   // Default secondary
+}
+
+TEST_F(RenderComponentTest, RenderComponentMultipleEffectsTest) {
+	// Add multiple effects
+	renderComponent->AddEffect(100, "effect1", u"water", 1.0f);
+	renderComponent->AddEffect(200, "effect2", u"earth", 1.0f);
+	
+	renderComponent->Serialize(bitStream, true);
+	
+	uint32_t effectsCount;
+	bitStream.Read(effectsCount);
+	ASSERT_EQ(effectsCount, 2);
+	
+	// Just verify we can read both effects without crashing
+	for (uint32_t i = 0; i < effectsCount; i++) {
+		uint8_t nameSize;
+		bitStream.Read(nameSize);
+		
+		if (nameSize > 0) {
+			// Skip name bytes
+			for (int j = 0; j < nameSize; j++) {
+				uint8_t ch;
+				bitStream.Read(ch);
+			}
+			
+			int32_t effectID;
+			bitStream.Read(effectID);
+			ASSERT_TRUE(effectID == 100 || effectID == 200);
+			
+			uint8_t typeSize;
+			bitStream.Read(typeSize);
+			
+			// Skip type bytes
+			for (int j = 0; j < typeSize; j++) {
+				uint16_t ch;
+				bitStream.Read(ch);
+			}
+			
+			float priority;
+			int64_t secondary;
+			bitStream.Read(priority);
+			bitStream.Read(secondary);
+		}
+	}
+}
+
+TEST_F(RenderComponentTest, RenderComponentSerializeConsistencyTest) {
+	// Test consistency with effects
+	renderComponent->AddEffect(456, "consistent", u"air", 1.0f);
+	
+	RakNet::BitStream firstSerialization;
+	RakNet::BitStream secondSerialization;
+	
+	renderComponent->Serialize(firstSerialization, true);
+	renderComponent->Serialize(secondSerialization, true);
+	
+	ASSERT_EQ(firstSerialization.GetNumberOfBitsUsed(), secondSerialization.GetNumberOfBitsUsed());
+}

tests/dGameTests/dComponentsTests/ScriptComponentTests.cpp

@@ -0,0 +1,66 @@
+#include "GameDependencies.h"
+#include <gtest/gtest.h>
+
+#include "BitStream.h"
+#include "ScriptComponent.h"
+#include "Entity.h"
+#include "eReplicaComponentType.h"
+#include "eStateChangeType.h"
+
+class ScriptComponentTest : public GameDependenciesTest {
+protected:
+	std::unique_ptr<Entity> baseEntity;
+	ScriptComponent* scriptComponent;
+	CBITSTREAM;
+
+	void SetUp() override {
+		SetUpDependencies();
+		baseEntity = std::make_unique<Entity>(15, GameDependenciesTest::info);
+		scriptComponent = baseEntity->AddComponent<ScriptComponent>();
+	}
+
+	void TearDown() override {
+		TearDownDependencies();
+	}
+};
+
+TEST_F(ScriptComponentTest, ScriptComponentSerializeInitialEmptyTest) {
+	scriptComponent->Serialize(bitStream, true);
+	
+	// Should write network settings flag (false for empty)
+	bool hasNetworkSettings;
+	bitStream.Read(hasNetworkSettings);
+	ASSERT_FALSE(hasNetworkSettings);
+	
+	// That should be all for empty network settings
+	ASSERT_EQ(bitStream.GetNumberOfBitsUsed(), 1);
+}
+
+TEST_F(ScriptComponentTest, ScriptComponentSerializeUpdateTest) {
+	// Non-initial updates should not write anything for ScriptComponent
+	scriptComponent->Serialize(bitStream, false);
+	ASSERT_EQ(bitStream.GetNumberOfBitsUsed(), 0);
+}
+
+TEST_F(ScriptComponentTest, ScriptComponentSerializeConsistencyTest) {
+	// Test that multiple initial serializations are consistent
+	RakNet::BitStream firstSerialization;
+	RakNet::BitStream secondSerialization;
+	
+	scriptComponent->Serialize(firstSerialization, true);
+	scriptComponent->Serialize(secondSerialization, true);
+	
+	ASSERT_EQ(firstSerialization.GetNumberOfBitsUsed(), secondSerialization.GetNumberOfBitsUsed());
+	ASSERT_EQ(firstSerialization.GetNumberOfBitsUsed(), 1);
+}
+
+TEST_F(ScriptComponentTest, ScriptComponentSerializedFlagTest) {
+	// Test the serialized flag functionality
+	ASSERT_FALSE(scriptComponent->GetSerialized());
+	
+	scriptComponent->SetSerialized(true);
+	ASSERT_TRUE(scriptComponent->GetSerialized());
+	
+	scriptComponent->SetSerialized(false);
+	ASSERT_FALSE(scriptComponent->GetSerialized());
+}

tests/dGameTests/dComponentsTests/VendorComponentTests.cpp

@@ -0,0 +1,103 @@
+#include "GameDependencies.h"
+#include <gtest/gtest.h>
+
+#include "BitStream.h"
+#include "VendorComponent.h"
+#include "Entity.h"
+#include "eReplicaComponentType.h"
+#include "eStateChangeType.h"
+
+class VendorComponentTest : public GameDependenciesTest {
+protected:
+	std::unique_ptr<Entity> baseEntity;
+	VendorComponent* vendorComponent;
+	CBITSTREAM;
+
+	void SetUp() override {
+		SetUpDependencies();
+		baseEntity = std::make_unique<Entity>(15, GameDependenciesTest::info);
+		vendorComponent = baseEntity->AddComponent<VendorComponent>();
+	}
+
+	void TearDown() override {
+		TearDownDependencies();
+	}
+};
+
+TEST_F(VendorComponentTest, VendorComponentSerializeInitialTest) {
+	vendorComponent->Serialize(bitStream, true);
+	
+	// Should always write true for initial update
+	bool hasVendorUpdate;
+	bitStream.Read(hasVendorUpdate);
+	ASSERT_TRUE(hasVendorUpdate);
+	
+	// Should write standard and multi cost flags
+	bool hasStandardCostItems, hasMultiCostItems;
+	bitStream.Read(hasStandardCostItems);
+	bitStream.Read(hasMultiCostItems);
+	
+	// Default values should be false
+	ASSERT_FALSE(hasStandardCostItems);
+	ASSERT_FALSE(hasMultiCostItems);
+}
+
+TEST_F(VendorComponentTest, VendorComponentSerializeUpdateTest) {
+	// Test non-initial update without dirty flag
+	vendorComponent->Serialize(bitStream, false);
+	
+	bool hasVendorUpdate;
+	bitStream.Read(hasVendorUpdate);
+	ASSERT_FALSE(hasVendorUpdate);  // Not dirty, should be false
+}
+
+TEST_F(VendorComponentTest, VendorComponentDirtyFlagTest) {
+	// Set some values to make it dirty
+	vendorComponent->SetHasStandardCostItems(true);
+	vendorComponent->SetHasMultiCostItems(true);
+	
+	vendorComponent->Serialize(bitStream, false);
+	
+	bool hasVendorUpdate;
+	bitStream.Read(hasVendorUpdate);
+	ASSERT_TRUE(hasVendorUpdate);  // Should be dirty and have update
+	
+	bool hasStandardCostItems, hasMultiCostItems;
+	bitStream.Read(hasStandardCostItems);
+	bitStream.Read(hasMultiCostItems);
+	
+	ASSERT_TRUE(hasStandardCostItems);
+	ASSERT_TRUE(hasMultiCostItems);
+}
+
+TEST_F(VendorComponentTest, VendorComponentSerializeConsistencyTest) {
+	// Test that multiple initial serializations are consistent
+	RakNet::BitStream firstSerialization;
+	RakNet::BitStream secondSerialization;
+	
+	vendorComponent->Serialize(firstSerialization, true);
+	vendorComponent->Serialize(secondSerialization, true);
+	
+	ASSERT_EQ(firstSerialization.GetNumberOfBitsUsed(), secondSerialization.GetNumberOfBitsUsed());
+}
+
+TEST_F(VendorComponentTest, VendorComponentCostItemsTest) {
+	// Test setting cost items flags - these are private members
+	// We can only test the serialization behavior
+	vendorComponent->SetHasStandardCostItems(true);
+	vendorComponent->SetHasMultiCostItems(true);
+	
+	// Test serialization with flags set
+	vendorComponent->Serialize(bitStream, true);
+	
+	bool hasVendorUpdate;
+	bitStream.Read(hasVendorUpdate);
+	ASSERT_TRUE(hasVendorUpdate);
+	
+	bool hasStandardCostItems, hasMultiCostItems;
+	bitStream.Read(hasStandardCostItems);
+	bitStream.Read(hasMultiCostItems);
+	
+	ASSERT_TRUE(hasStandardCostItems);
+	ASSERT_TRUE(hasMultiCostItems);
+}