conversion to c by gemini 4 argon

Game/UnitTest/WorldUnitTest.c

@@ -0,0 +1,171 @@
+#include <UnitTest/WorldUnitTest.h>
+
+#if JULIET_DEBUG
+
+#include <Core/Common/CoreUtils.h>
+#include <Core/Common/serialization.h>
+#include <Core/HAL/IO/IOStream.h>
+#include <Core/Logging/LogManager.h>
+#include <Core/Logging/LogTypes.h>
+#include <Core/Memory/MemoryArena.h>
+#include <Core/Thread/ThreadContext.h>
+#include <Data/World.h>
+#include <Entity/Entity.h>
+#include <Entity/entity_types.h>
+#include <game.h>
+
+internal void TestEntityAllocationAndWiring(void)
+{
+    Log(LogLevel_Message, LogCategory_Game, "[UnitTest] Running TestEntityAllocationAndWiring...");
+
+    TempArena tempArena = scratch_begin(NULL, 0);
+
+    GameState* gameState = GetGameState();
+    World      testWorld = { 0 };
+    gameState->World     = &testWorld;
+    InitWorld(&testWorld, tempArena.Arena);
+
+    InitEntityManager(&testWorld);
+    EntityManager* manager = testWorld.EntityManager;
+
+    // 1. Allocate Inert Entity via allocate_entity
+    Entity* base_entity = allocate_entity(manager, ClassKind(Inert));
+    Assert(base_entity != NULL);
+    Assert(base_entity->ID == 0); // Pure memory allocator leaves ID unassigned (0) until MakeEntity or deserialization
+    base_entity->ID = ++g_entity_manager_id;
+    Assert(base_entity->ID > 0);
+    Assert(base_entity->derived_kind == ClassKind(Inert));
+    Assert(base_entity->derived != NULL);
+    Assert(base_entity->is_dirty == true);
+
+    // 2. Validate mutual back-pointer wiring
+    EntityTemplate* derived = (EntityTemplate*)base_entity->derived;
+    Assert(derived->base == base_entity);
+
+    // 3. DownCast verification
+    Inert* inert = DownCastEntity(Inert, base_entity);
+    Assert(inert != NULL);
+    Assert(inert->base == base_entity);
+
+    // 4. Validate typed array tracking
+    typed_entity_array* inert_array = &manager->by_type[ENTITY(Inert)];
+    Assert(inert_array->count == 1);
+    Assert(inert_array->array == derived);
+
+    ShutdownEntityManager();
+    ShutdownWorld(&testWorld);
+
+    gameState->World = NULL;
+
+    scratch_end(tempArena);
+
+    Log(LogLevel_Message, LogCategory_Game, "[UnitTest] PASSED: TestEntityAllocationAndWiring");
+}
+
+internal void TestInPlaceDeserialization(void)
+{
+    Log(LogLevel_Message, LogCategory_Game, "[UnitTest] Running TestInPlaceDeserialization...");
+    TempArena tempArena = scratch_begin(NULL, 0);
+
+    GameState* gameState = GetGameState();
+    World      testWorld = { 0 };
+    gameState->World     = &testWorld;
+    InitWorld(&testWorld, tempArena.Arena);
+
+    InitEntityManager(&testWorld);
+    EntityManager* manager = testWorld.EntityManager;
+    // 1. In-memory .jasset text fixture (no streams or files needed)
+    String     asset_content = ConstString("; Class\n"
+                                           "Inert\n"
+                                           "; version\n"
+                                           "1\n"
+                                           "; class_version\n"
+                                           "1\n"
+                                           "; id\n"
+                                           "42\n"
+                                           "; position\n"
+                                           "12.5 -44.0 108.2 1.0\n"
+                                           "; MeshInstance\n"
+                                           "42\n");
+    ByteBuffer buffer        = { .Data = (Byte*)asset_content.Str, .Size = asset_content.Size };
+    // 2. Tokenize into Archive
+    Archive load_ar = { 0 };
+    load_ar.arena   = tempArena.Arena;
+    load_ar.loading = true;
+    load_ar.base    = tokenize_archive(tempArena.Arena, buffer);
+    // 3. Deserialize in-place
+    Entity* loaded_base = deserialize_entity(&load_ar, manager);
+    // 4. Verify in-place allocations and values
+    Assert(loaded_base != NULL);
+    Assert(loaded_base->ID == 42);
+    Assert(g_entity_manager_id > 42); // Generator counter advanced past loaded ID
+    Assert(loaded_base->position.x == 12.5f);
+    Assert(loaded_base->position.y == -44.0f);
+    Assert(loaded_base->position.z == 108.2f);
+    Assert(loaded_base->is_dirty == false);
+    Inert* loaded_inert = DownCastEntity(Inert, loaded_base);
+    Assert(loaded_inert != NULL);
+    Assert(loaded_inert->base == loaded_base);
+    Assert(loaded_inert->MeshInstance == 42);
+    ShutdownEntityManager();
+    ShutdownWorld(&testWorld);
+
+    gameState->World = NULL;
+
+    scratch_end(tempArena);
+    Log(LogLevel_Message, LogCategory_Game, "[UnitTest] PASSED: TestInPlaceDeserialization");
+}
+
+internal void TestDirtyTrackingLifecycle(void)
+{
+    Log(LogLevel_Message, LogCategory_Game, "[UnitTest] Running TestDirtyTrackingLifecycle...");
+
+    TempArena tempArena = scratch_begin(NULL, 0);
+
+    GameState* gameState = GetGameState();
+    World      testWorld = { 0 };
+    gameState->World     = &testWorld;
+    InitWorld(&testWorld, tempArena.Arena);
+
+    InitEntityManager(&testWorld);
+    EntityManager* manager = testWorld.EntityManager;
+
+    Entity* entity = allocate_entity(manager, ClassKind(Inert));
+    Assert(entity->is_dirty == true);
+
+    // TODO : proper save and mutation
+    // Simulate save
+    entity->is_dirty = false;
+    Assert(entity->is_dirty == false);
+
+    // Simulate mutation
+    entity->position.x += 1.0f;
+    entity->is_dirty = true;
+    Assert(entity->is_dirty == true);
+
+    ShutdownEntityManager();
+    ShutdownWorld(&testWorld);
+
+    gameState->World = NULL;
+
+    scratch_end(tempArena);
+    Log(LogLevel_Message, LogCategory_Game, "[UnitTest] PASSED: TestDirtyTrackingLifecycle");
+}
+
+void UnitTest_WorldUnitTest(void)
+{
+    Log(LogLevel_Message, LogCategory_Game, "==================================================");
+    Log(LogLevel_Message, LogCategory_Game, "Starting Entity Allocation & Lifecycle Unit Tests");
+    Log(LogLevel_Message, LogCategory_Game, "==================================================");
+
+    TestEntityAllocationAndWiring();
+    TestInPlaceDeserialization();
+    // TestSwapAndPopPointerFixup(); // Deferred to Entity_Removal_Brainstorm.md
+    TestDirtyTrackingLifecycle();
+
+    Log(LogLevel_Message, LogCategory_Game, "==================================================");
+    Log(LogLevel_Message, LogCategory_Game, "All Entity Lifecycle Unit Tests PASSED Successfully");
+    Log(LogLevel_Message, LogCategory_Game, "==================================================");
+}
+
+#endif

Game/UnitTest/WorldUnitTest.cpp

@@ -1,173 +0,0 @@
-#include <UnitTest/WorldUnitTest.h>
-
-#if JULIET_DEBUG
-
-#include <Core/Common/CoreUtils.h>
-#include <Core/Common/serialization.h>
-#include <Core/HAL/IO/IOStream.h>
-#include <Core/Logging/LogManager.h>
-#include <Core/Logging/LogTypes.h>
-#include <Core/Memory/MemoryArena.h>
-#include <Core/Thread/ThreadContext.h>
-#include <Data/World.h>
-#include <Entity/entity_types.h>
-#include <game.h>
-
-namespace UnitTest
-{
-    internal void TestEntityAllocationAndWiring()
-    {
-        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestEntityAllocationAndWiring...");
-
-        TempArena tempArena = scratch_begin(nullptr, 0);
-
-        GameState* gameState = GetGameState();
-        World      testWorld{};
-        gameState->World = &testWorld;
-        InitWorld(&testWorld, tempArena.Arena);
-
-        InitEntityManager(&testWorld);
-        EntityManager& manager = *testWorld.EntityManager;
-
-        // 1. Allocate Inert Entity via AllocateEntity
-        Entity* base_entity = allocate_entity(manager, Inert::kind);
-        Assert(base_entity != nullptr);
-        Assert(base_entity->ID == 0); // Pure memory allocator leaves ID unassigned (0) until MakeEntity or deserialization
-        base_entity->ID = ++EntityManager::ID;
-        Assert(base_entity->ID > 0);
-        Assert(base_entity->derived_kind == Inert::kind);
-        Assert(base_entity->derived != nullptr);
-        Assert(base_entity->is_dirty == true);
-
-        // 2. Validate mutual back-pointer wiring
-        auto* derived = reinterpret_cast<EntityTemplate*>(base_entity->derived);
-        Assert(derived->base == base_entity);
-
-        // 3. DownCast verification
-        Inert* inert = DownCast<Inert>(base_entity);
-        Assert(inert != nullptr);
-        Assert(inert->base == base_entity);
-
-        // 4. Validate typed array tracking
-        typed_entity_array& inert_array = manager.by_type[ENTITY(Inert)];
-        Assert(inert_array.count == 1);
-        Assert(inert_array.array == derived);
-
-        ShutdownEntityManager();
-        ShutdownWorld(&testWorld);
-
-        gameState->World = nullptr;
-
-        scratch_end(tempArena);
-
-        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestEntityAllocationAndWiring");
-    }
-
-    internal void TestInPlaceDeserialization()
-    {
-        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestInPlaceDeserialization...");
-        TempArena tempArena = scratch_begin(nullptr, 0);
-
-        GameState* gameState = GetGameState();
-        World      testWorld{};
-        gameState->World = &testWorld;
-        InitWorld(&testWorld, tempArena.Arena);
-
-        InitEntityManager(&testWorld);
-        EntityManager& manager = *testWorld.EntityManager;
-        // 1. In-memory .jasset text fixture (no streams or files needed)
-        String     asset_content = ConstString("; Class\n"
-                                                   "Inert\n"
-                                                   "; version\n"
-                                                   "1\n"
-                                                   "; class_version\n"
-                                                   "1\n"
-                                                   "; id\n"
-                                                   "42\n"
-                                                   "; position\n"
-                                                   "12.5 -44.0 108.2 1.0\n"
-                                                   "; MeshInstance\n"
-                                                   "42\n");
-        ByteBuffer buffer        = { .Data = reinterpret_cast<Byte*>(asset_content.Str), .Size = asset_content.Size };
-        // 2. Tokenize into Archive
-        Archive load_ar = {};
-        load_ar.arena   = tempArena.Arena;
-        load_ar.loading = true;
-        load_ar.base    = tokenize_archive(tempArena.Arena, buffer);
-        // 3. Deserialize in-place
-        Entity* loaded_base = deserialize_entity(load_ar, manager);
-        // 4. Verify in-place allocations and values
-        Assert(loaded_base != nullptr);
-        Assert(loaded_base->ID == 42);
-        Assert(EntityManager::ID > 42); // Generator counter advanced past loaded ID
-        Assert(loaded_base->position.x == 12.5f);
-        Assert(loaded_base->position.y == -44.0f);
-        Assert(loaded_base->position.z == 108.2f);
-        Assert(loaded_base->is_dirty == false);
-        Inert* loaded_inert = DownCast<Inert>(loaded_base);
-        Assert(loaded_inert != nullptr);
-        Assert(loaded_inert->base == loaded_base);
-        Assert(loaded_inert->MeshInstance == 42);
-        ShutdownEntityManager();
-        ShutdownWorld(&testWorld);
-
-        gameState->World = nullptr;
-
-        scratch_end(tempArena);
-        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestInPlaceDeserialization");
-    }
-
-    internal void TestDirtyTrackingLifecycle()
-    {
-        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] Running TestDirtyTrackingLifecycle...");
-
-        TempArena tempArena = scratch_begin(nullptr, 0);
-
-        GameState* gameState = GetGameState();
-        World      testWorld{};
-        gameState->World = &testWorld;
-        InitWorld(&testWorld, tempArena.Arena);
-
-        InitEntityManager(&testWorld);
-        EntityManager& manager = *testWorld.EntityManager;
-
-        Entity* entity = allocate_entity(manager, Inert::kind);
-        Assert(entity->is_dirty == true);
-
-        // TODO : proper save and mutation
-        // Simulate save
-        entity->is_dirty = false;
-        Assert(entity->is_dirty == false);
-
-        // Simulate mutation
-        entity->position.x += 1.0f;
-        entity->is_dirty = true;
-        Assert(entity->is_dirty == true);
-
-        ShutdownEntityManager();
-        ShutdownWorld(&testWorld);
-
-        gameState->World = nullptr;
-
-        scratch_end(tempArena);
-        Log(LogLevel::Message, LogCategory::Game, "[UnitTest] PASSED: TestDirtyTrackingLifecycle");
-    }
-
-    void WorldUnitTest()
-    {
-        Log(LogLevel::Message, LogCategory::Game, "==================================================");
-        Log(LogLevel::Message, LogCategory::Game, "Starting Entity Allocation & Lifecycle Unit Tests");
-        Log(LogLevel::Message, LogCategory::Game, "==================================================");
-
-        TestEntityAllocationAndWiring();
-        TestInPlaceDeserialization();
-        // TestSwapAndPopPointerFixup(); // Deferred to Entity_Removal_Brainstorm.md
-        TestDirtyTrackingLifecycle();
-
-        Log(LogLevel::Message, LogCategory::Game, "==================================================");
-        Log(LogLevel::Message, LogCategory::Game, "All Entity Lifecycle Unit Tests PASSED Successfully");
-        Log(LogLevel::Message, LogCategory::Game, "==================================================");
-    }
-} // namespace UnitTest
-
-#endif

Game/UnitTest/WorldUnitTest.h

@@ -4,9 +4,6 @@
 
 #if JULIET_DEBUG
 
-namespace UnitTest
-{
-    void WorldUnitTest();
-} // namespace UnitTest
+void UnitTest_WorldUnitTest(void);
 
 #endif