dungeon_object_rendering_e2e_tests.cc

Go to the documentation of this file.

 
#define IMGUI_DEFINE_MATH_OPERATORS
 
#include <gtest/gtest.h>
 
#include "imgui.h"
#include "imgui_test_engine/imgui_te_context.h"
#include "imgui_test_engine/imgui_te_engine.h"
#include "imgui_test_engine/imgui_te_ui.h"
 
#include "app/core/controller.h"
#include "app/core/window.h"
#include "app/editor/dungeon/dungeon_editor_v2.h"
#include "app/rom.h"
#include "app/zelda3/dungeon/room.h"
#include "app/zelda3/dungeon/room_object.h"
#include "test_utils.h"
 
namespace yaze {
namespace test {
 
class DungeonObjectRenderingE2ETests : public TestRomManager::BoundRomTest {
 protected:
  void SetUp() override {
    BoundRomTest::SetUp();
 
    // Initialize test environment
    rom_ = std::shared_ptr<Rom>(rom(), [](Rom*) {});
    
    dungeon_editor_ = std::make_unique<editor::DungeonEditorV2>();
    dungeon_editor_->set_rom(rom_.get());
    ASSERT_TRUE(dungeon_editor_->Load().ok());
    
    // Initialize imgui test engine
    engine_ = ImGuiTestEngine_CreateContext();
    ImGuiTestEngineIO& test_io = ImGuiTestEngine_GetIO(engine_);
    test_io.ConfigVerboseLevel = ImGuiTestVerboseLevel_Info;
    test_io.ConfigVerboseLevelOnError = ImGuiTestVerboseLevel_Debug;
    test_io.ConfigRunSpeed = ImGuiTestRunSpeed_Fast;
    
    ImGuiTestEngine_Start(engine_, ImGui::GetCurrentContext());
    
    // Register all test cases
    RegisterAllTests();
  }
  
  void TearDown() override {
    if (engine_) {
      ImGuiTestEngine_Stop(engine_);
      ImGuiTestEngine_DestroyContext(engine_);
      engine_ = nullptr;
    }
    dungeon_editor_.reset();
    rom_.reset();
    BoundRomTest::TearDown();
  }
  
  void RegisterAllTests();
  
  // Test registration helpers
  void RegisterObjectBrowserTests();
  void RegisterObjectPlacementTests();
  void RegisterObjectSelectionTests();
  void RegisterLayerManagementTests();
  void RegisterSaveWorkflowTests();
  void RegisterRenderingQualityTests();
  void RegisterPerformanceTests();
  
  ImGuiTestEngine* engine_ = nullptr;
  std::shared_ptr<Rom> rom_;
  std::unique_ptr<editor::DungeonEditorV2> dungeon_editor_;
};
 
// =============================================================================
// OBJECT BROWSER TESTS
// =============================================================================
 
void DungeonObjectRenderingE2ETests::RegisterObjectBrowserTests() {
  ImGuiTest* test = IM_REGISTER_TEST(engine_, "DungeonObjectRendering", "ObjectBrowser_NavigateCategories");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    // Render dungeon editor UI
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Open dungeon editor window
    ctx->SetRef("Dungeon Editor");
    
    // Navigate to object selector
    ctx->ItemClick("Object Selector##tab");
    ctx->Yield();
    
    // Test category tabs
    const char* categories[] = {
      "Type1##tab",
      "Type2##tab", 
      "Type3##tab",
      "All##tab"
    };
    
    for (const char* category : categories) {
      ctx->ItemClick(category);
      ctx->Yield();
      
      // Verify object list is visible and has content
      ctx->ItemExists("AssetBrowser##child");
      
      // Try scrolling the list
      ctx->ItemClick("AssetBrowser##child");
      ctx->KeyPress(ImGuiKey_DownArrow, 5);
      ctx->Yield();
    }
  };
  test->UserData = this;
}
 
void RegisterObjectBrowserTests_SelectObject(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "ObjectBrowser_SelectObject");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    ctx->SetRef("Dungeon Editor");
    
    // Navigate to object selector
    ctx->ItemClick("Object Selector##tab");
    ctx->Yield();
    
    // Select Type1 category
    ctx->ItemClick("Type1##tab");
    ctx->Yield();
    
    // Click on first object in list (wall object 0x10)
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    // Verify object details window appears
    ctx->SetRef("Object Details");
    ctx->ItemExists("Object ID: 0x10");
    
    // Verify preview canvas shows object
    ctx->SetRef("Dungeon Editor/PreviewCanvas");
    ctx->ItemExists("**/canvas##child");
  };
  test->UserData = self;
}
 
void RegisterObjectBrowserTests_SearchFilter(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "ObjectBrowser_SearchFilter");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    ctx->SetRef("Dungeon Editor/Object Selector");
    
    // Type in search box
    ctx->ItemClick("Search##input");
    ctx->KeyCharsAppend("0x10");
    ctx->Yield();
    
    // Verify filtered results
    ctx->ItemExists("Object_0x10");
    ctx->ItemVerifyNotExists("Object_0x20");
    
    // Clear search
    ctx->ItemClick("Clear##button");
    ctx->Yield();
    
    // Verify full list restored
    ctx->ItemExists("Object_0x10");
    ctx->ItemExists("Object_0x20");
  };
  test->UserData = self;
}
 
// =============================================================================
// OBJECT PLACEMENT TESTS
// =============================================================================
 
void DungeonObjectRenderingE2ETests::RegisterObjectPlacementTests() {
  ImGuiTest* test = IM_REGISTER_TEST(engine_, "DungeonObjectRendering", "ObjectPlacement_MouseClick");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    ctx->SetRef("Dungeon Editor");
    
    // Select an object (wall 0x10)
    ctx->ItemClick("Object Selector##tab");
    ctx->Yield();
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    // Switch to main canvas
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("Canvas##tab");
    ctx->Yield();
    
    // Click on canvas to place object
    ctx->SetRef("Dungeon Editor/Canvas");
    // TODO: fix this
    // ImVec2 canvas_center = ctx->ItemRectCenter("canvas##child");
    // ctx->MouseMove(canvas_center);
    // ctx->Yield();
    
    // Verify preview is visible
    // (Actual verification would check rendering)
    
    ctx->MouseClick();
    ctx->Yield();
    
    // Verify object was placed
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("Room Objects##tab");
    ctx->Yield();
    
    // Check object appears in list
    ctx->ItemExists("Object ID: 0x10");
  };
  test->UserData = this;
}
 
void RegisterObjectPlacementTests_SnapToGrid(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "ObjectPlacement_SnapToGrid");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    ctx->SetRef("Dungeon Editor");
    
    // Enable snap to grid
    ctx->ItemClick("Options##menu");
    ctx->ItemClick("Snap to Grid##checkbox");
    ctx->Yield();
    
    // Select object
    ctx->ItemClick("Object Selector##tab");
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    // Place object at arbitrary position
    ctx->SetRef("Dungeon Editor/Canvas");
    ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
    ctx->MouseMove(ImVec2(canvas_pos.x + 37, canvas_pos.y + 49));
    ctx->MouseClick();
    ctx->Yield();
    
    // Verify object was placed at snapped position (32, 48)
    ctx->SetRef("Dungeon Editor/Object Details");
    ctx->ItemVerifyValue("X Position", 32);
    ctx->ItemVerifyValue("Y Position", 48);
  };
  test->UserData = self;
}
 
void RegisterObjectPlacementTests_MultipleObjects(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "ObjectPlacement_MultipleObjects");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    ctx->SetRef("Dungeon Editor");
    
    // Place 5 different objects
    const uint16_t object_ids[] = {0x10, 0x11, 0x20, 0x100, 0xF99};
    
    for (int i = 0; i < 5; i++) {
      // Select object
      ctx->ItemClick("Object Selector##tab");
      ctx->SetRef("AssetBrowser");
      ctx->ItemClick(ImGuiTestRef_Str("Object_0x%02X", object_ids[i]));
      ctx->Yield();
      
      // Place at different position
      ctx->SetRef("Dungeon Editor/Canvas");
      ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
      ctx->MouseMove(ImVec2(canvas_pos.x + (i * 32), canvas_pos.y + (i * 32)));
      ctx->MouseClick();
      ctx->Yield();
    }
    
    // Verify all 5 objects in room
    ctx->SetRef("Dungeon Editor/Room Objects");
    ctx->ItemExists("Object Count: 5");
  };
  test->UserData = self;
}
 
// =============================================================================
// OBJECT SELECTION AND MANIPULATION TESTS
// =============================================================================
 
void DungeonObjectRenderingE2ETests::RegisterObjectSelectionTests() {
  ImGuiTest* test = IM_REGISTER_TEST(engine_, "DungeonObjectRendering", "ObjectSelection_Click");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // First place an object
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("Object Selector##tab");
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    ctx->SetRef("Dungeon Editor/Canvas");
    ImVec2 canvas_center = ctx->ItemRectCenter("canvas##child");
    ctx->MouseMove(canvas_center);
    ctx->MouseClick();
    ctx->Yield();
    
    // Now try to select it
    ctx->MouseMove(canvas_center);
    ctx->MouseClick();
    ctx->Yield();
    
    // Verify object is selected
    ctx->SetRef("Dungeon Editor/Object Details");
    ctx->ItemExists("Selected Object");
    ctx->ItemVerifyValue("Object ID", 0x10);
  };
  test->UserData = this;
}
 
void RegisterObjectSelectionTests_MultiSelect(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "ObjectSelection_MultiSelect");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Place 3 objects in a line
    ctx->SetRef("Dungeon Editor");
    for (int i = 0; i < 3; i++) {
      ctx->ItemClick("Object Selector##tab");
      ctx->SetRef("AssetBrowser");
      ctx->ItemClick("Object_0x10");
      ctx->Yield();
      
      ctx->SetRef("Dungeon Editor/Canvas");
      ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
      ctx->MouseMove(ImVec2(canvas_pos.x + (i * 32) + 16, canvas_pos.y + 16));
      ctx->MouseClick();
      ctx->Yield();
    }
    
    // Ctrl+drag to select all
    ctx->KeyDown(ImGuiKey_LeftCtrl);
    ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
    ctx->MouseMove(ImVec2(canvas_pos.x, canvas_pos.y));
    ctx->MouseDown();
    ctx->MouseMove(ImVec2(canvas_pos.x + 100, canvas_pos.y + 50));
    ctx->MouseUp();
    ctx->KeyUp(ImGuiKey_LeftCtrl);
    ctx->Yield();
    
    // Verify 3 objects selected
    ctx->SetRef("Dungeon Editor");
    ctx->ItemVerifyValue("Selected Objects", 3);
  };
  test->UserData = self;
}
 
void RegisterObjectSelectionTests_MoveObject(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "ObjectSelection_MoveObject");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Place object at (16, 16)
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("Object Selector##tab");
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    ctx->SetRef("Dungeon Editor/Canvas");
    ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
    ImVec2 initial_pos = ImVec2(canvas_pos.x + 16, canvas_pos.y + 16);
    ctx->MouseMove(initial_pos);
    ctx->MouseClick();
    ctx->Yield();
    
    // Select and drag to (48, 48)
    ctx->MouseMove(initial_pos);
    ctx->MouseClick();
    ctx->MouseDown();
    ctx->MouseMove(ImVec2(canvas_pos.x + 48, canvas_pos.y + 48));
    ctx->MouseUp();
    ctx->Yield();
    
    // Verify new position
    ctx->SetRef("Dungeon Editor/Object Details");
    ctx->ItemVerifyValue("X Position", 48);
    ctx->ItemVerifyValue("Y Position", 48);
  };
  test->UserData = self;
}
 
void RegisterObjectSelectionTests_DeleteObject(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "ObjectSelection_DeleteObject");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Place object
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("Object Selector##tab");
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    ctx->SetRef("Dungeon Editor/Canvas");
    ImVec2 canvas_center = ctx->ItemRectCenter("canvas##child");
    ctx->MouseMove(canvas_center);
    ctx->MouseClick();
    ctx->Yield();
    
    // Select object
    ctx->MouseClick();
    ctx->Yield();
    
    // Delete with Delete key
    ctx->KeyPress(ImGuiKey_Delete);
    ctx->Yield();
    
    // Verify object removed
    ctx->SetRef("Dungeon Editor/Room Objects");
    ctx->ItemVerifyValue("Object Count", 0);
  };
  test->UserData = self;
}
 
// =============================================================================
// LAYER MANAGEMENT TESTS
// =============================================================================
 
void DungeonObjectRenderingE2ETests::RegisterLayerManagementTests() {
  ImGuiTest* test = IM_REGISTER_TEST(engine_, "DungeonObjectRendering", "LayerManagement_ToggleVisibility");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    ctx->SetRef("Dungeon Editor");
    
    // Open layer management panel
    ctx->ItemClick("Layers##tab");
    ctx->Yield();
    
    // Toggle Layer 1 visibility
    ctx->ItemClick("Layer 1 Visible##checkbox");
    ctx->Yield();
    
    // Verify checkbox state
    ctx->ItemVerifyValue("Layer 1 Visible##checkbox", false);
    
    // Toggle back on
    ctx->ItemClick("Layer 1 Visible##checkbox");
    ctx->Yield();
    
    ctx->ItemVerifyValue("Layer 1 Visible##checkbox", true);
  };
  test->UserData = this;
}
 
void RegisterLayerManagementTests_PlaceOnLayers(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "LayerManagement_PlaceOnLayers");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    ctx->SetRef("Dungeon Editor");
    
    // Place object on Layer 0
    ctx->ItemClick("Layers##tab");
    ctx->ItemClick("Layer 0##radio");
    ctx->Yield();
    
    ctx->ItemClick("Object Selector##tab");
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    ctx->SetRef("Dungeon Editor/Canvas");
    ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
    ctx->MouseMove(ImVec2(canvas_pos.x + 16, canvas_pos.y + 16));
    ctx->MouseClick();
    ctx->Yield();
    
    // Verify object on Layer 0
    ctx->SetRef("Dungeon Editor/Object Details");
    ctx->ItemVerifyValue("Layer", 0);
    
    // Switch to Layer 1 and place another object
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("Layers##tab");
    ctx->ItemClick("Layer 1##radio");
    ctx->Yield();
    
    ctx->ItemClick("Object Selector##tab");
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x20");
    ctx->Yield();
    
    ctx->SetRef("Dungeon Editor/Canvas");
    ctx->MouseMove(ImVec2(canvas_pos.x + 48, canvas_pos.y + 48));
    ctx->MouseClick();
    ctx->Yield();
    
    // Verify object on Layer 1
    ctx->SetRef("Dungeon Editor/Object Details");
    ctx->ItemVerifyValue("Layer", 1);
  };
  test->UserData = self;
}
 
void RegisterLayerManagementTests_RenderingOrder(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "LayerManagement_RenderingOrder");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Place 3 objects at same position on different layers
    ctx->SetRef("Dungeon Editor");
    
    for (int layer = 0; layer < 3; layer++) {
      ctx->ItemClick("Layers##tab");
      ctx->ItemClick(ImGuiTestRef_Str("Layer %d##radio", layer));
      ctx->Yield();
      
      ctx->ItemClick("Object Selector##tab");
      ctx->SetRef("AssetBrowser");
      ctx->ItemClick(ImGuiTestRef_Str("Object_0x%02X", 0x10 + layer));
      ctx->Yield();
      
      ctx->SetRef("Dungeon Editor/Canvas");
      ImVec2 canvas_center = ctx->ItemRectCenter("canvas##child");
      ctx->MouseMove(canvas_center);
      ctx->MouseClick();
      ctx->Yield();
    }
    
    // Verify all 3 objects exist
    ctx->SetRef("Dungeon Editor/Room Objects");
    ctx->ItemVerifyValue("Object Count", 3);
    
    // Visual verification would be done with snapshot comparison
    // Here we just verify the objects are in the right layers
    ctx->ItemExists("Layer 0: 1 object");
    ctx->ItemExists("Layer 1: 1 object");
    ctx->ItemExists("Layer 2: 1 object");
  };
  test->UserData = self;
}
 
// =============================================================================
// SAVE/LOAD WORKFLOW TESTS
// =============================================================================
 
void DungeonObjectRenderingE2ETests::RegisterSaveWorkflowTests() {
  ImGuiTest* test = IM_REGISTER_TEST(engine_, "DungeonObjectRendering", "SaveWorkflow_SaveRoom");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Place an object
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("Object Selector##tab");
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    ctx->SetRef("Dungeon Editor/Canvas");
    ImVec2 canvas_center = ctx->ItemRectCenter("canvas##child");
    ctx->MouseMove(canvas_center);
    ctx->MouseClick();
    ctx->Yield();
    
    // Save room
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("File##menu");
    ctx->ItemClick("Save Room##menuitem");
    ctx->Yield();
    
    // Verify save success message
    ctx->ItemExists("Save successful");
  };
  test->UserData = this;
}
 
void RegisterSaveWorkflowTests_RoundTrip(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "SaveWorkflow_RoundTrip");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Place object with specific properties
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("Object Selector##tab");
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    ctx->SetRef("Dungeon Editor/Canvas");
    ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
    ctx->MouseMove(ImVec2(canvas_pos.x + 64, canvas_pos.y + 96));
    ctx->MouseClick();
    ctx->Yield();
    
    // Verify initial state
    ctx->SetRef("Dungeon Editor/Object Details");
    int initial_x = ctx->ItemGetValue<int>("X Position");
    int initial_y = ctx->ItemGetValue<int>("Y Position");
    int initial_id = ctx->ItemGetValue<int>("Object ID");
    
    // Save room
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("File##menu");
    ctx->ItemClick("Save Room##menuitem");
    ctx->Yield();
    
    // Reload room
    ctx->ItemClick("File##menu");
    ctx->ItemClick("Reload Room##menuitem");
    ctx->Yield();
    
    // Verify object persisted with same properties
    ctx->SetRef("Dungeon Editor/Object Details");
    ctx->ItemVerifyValue("X Position", initial_x);
    ctx->ItemVerifyValue("Y Position", initial_y);
    ctx->ItemVerifyValue("Object ID", initial_id);
  };
  test->UserData = self;
}
 
void RegisterSaveWorkflowTests_MultipleTypes(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "SaveWorkflow_MultipleTypes");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Place one of each object type
    const uint16_t object_ids[] = {
      0x10,   // Type1
      0x125,  // Type2
      0xF99   // Type3 (chest)
    };
    
    ctx->SetRef("Dungeon Editor");
    
    for (int i = 0; i < 3; i++) {
      ctx->ItemClick("Object Selector##tab");
      ctx->SetRef("AssetBrowser");
      ctx->ItemClick(ImGuiTestRef_Str("Object_0x%02X", object_ids[i]));
      ctx->Yield();
      
      ctx->SetRef("Dungeon Editor/Canvas");
      ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
      ctx->MouseMove(ImVec2(canvas_pos.x + (i * 32), canvas_pos.y + (i * 32)));
      ctx->MouseClick();
      ctx->Yield();
    }
    
    // Save and reload
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("File##menu");
    ctx->ItemClick("Save Room##menuitem");
    ctx->Yield();
    
    ctx->ItemClick("File##menu");
    ctx->ItemClick("Reload Room##menuitem");
    ctx->Yield();
    
    // Verify all 3 objects reloaded
    ctx->SetRef("Dungeon Editor/Room Objects");
    ctx->ItemVerifyValue("Object Count", 3);
    
    // Verify each object type
    for (int i = 0; i < 3; i++) {
      ctx->ItemExists(ImGuiTestRef_Str("Object ID: 0x%02X", object_ids[i]));
    }
  };
  test->UserData = self;
}
 
// =============================================================================
// RENDERING QUALITY TESTS
// =============================================================================
 
void DungeonObjectRenderingE2ETests::RegisterRenderingQualityTests() {
  ImGuiTest* test = IM_REGISTER_TEST(engine_, "DungeonObjectRendering", "RenderingQuality_AllTypes");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // This would typically involve visual snapshot comparison
    // For now, we verify objects are placed and rendered without errors
    
    const uint16_t object_ids[] = {
      0x10, 0x11, 0x20,  // Type1 objects
      0x100, 0x125,      // Type2 objects
      0xF99, 0xFB1       // Type3 objects
    };
    
    ctx->SetRef("Dungeon Editor");
    
    for (int i = 0; i < 7; i++) {
      ctx->ItemClick("Object Selector##tab");
      ctx->SetRef("AssetBrowser");
      ctx->ItemClick(ImGuiTestRef_Str("Object_0x%02X", object_ids[i]));
      ctx->Yield();
      
      ctx->SetRef("Dungeon Editor/Canvas");
      ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
      ctx->MouseMove(ImVec2(canvas_pos.x + ((i % 4) * 48), canvas_pos.y + ((i / 4) * 48)));
      ctx->MouseClick();
      ctx->Yield();
    }
    
    // Verify all objects rendered without errors
    ctx->SetRef("Dungeon Editor/Room Objects");
    ctx->ItemVerifyValue("Object Count", 7);
    ctx->ItemVerifyNotExists("Rendering Error");
  };
  test->UserData = this;
}
 
void RegisterRenderingQualityTests_Palettes(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "RenderingQuality_Palettes");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Place an object
    ctx->SetRef("Dungeon Editor");
    ctx->ItemClick("Object Selector##tab");
    ctx->SetRef("AssetBrowser");
    ctx->ItemClick("Object_0x10");
    ctx->Yield();
    
    ctx->SetRef("Dungeon Editor/Canvas");
    ImVec2 canvas_center = ctx->ItemRectCenter("canvas##child");
    ctx->MouseMove(canvas_center);
    ctx->MouseClick();
    ctx->Yield();
    
    // Switch palettes and verify rendering
    const int palette_ids[] = {0, 1, 2, 3, 4, 5};
    
    for (int palette : palette_ids) {
      ctx->SetRef("Dungeon Editor");
      ctx->ItemClick("Options##menu");
      ctx->ItemInput("Palette##input", palette);
      ctx->Yield();
      
      // Verify no rendering errors
      ctx->ItemVerifyNotExists("Rendering Error");
    }
  };
  test->UserData = self;
}
 
void RegisterRenderingQualityTests_ComplexRoom(DungeonObjectRenderingE2ETests* self) {
  ImGuiTest* test = IM_REGISTER_TEST(self->engine_, "DungeonObjectRendering", "RenderingQuality_ComplexRoom");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    // Place many objects to create complex room
    ctx->SetRef("Dungeon Editor");
    
    // Place wall perimeter (Type1 objects)
    for (int x = 0; x < 16; x++) {
      for (int side = 0; side < 2; side++) {
        ctx->ItemClick("Object Selector##tab");
        ctx->SetRef("AssetBrowser");
        ctx->ItemClick("Object_0x10");
        ctx->Yield();
        
        ctx->SetRef("Dungeon Editor/Canvas");
        ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
        int y = side == 0 ? 0 : 10;
        ctx->MouseMove(ImVec2(canvas_pos.x + (x * 16), canvas_pos.y + (y * 16)));
        ctx->MouseClick();
        ctx->Yield();
      }
    }
    
    // Add some decorative objects
    const uint16_t decorative_objects[] = {0x20, 0x21, 0xF99};
    for (int i = 0; i < 3; i++) {
      ctx->ItemClick("Object Selector##tab");
      ctx->SetRef("AssetBrowser");
      ctx->ItemClick(ImGuiTestRef_Str("Object_0x%02X", decorative_objects[i]));
      ctx->Yield();
      
      ctx->SetRef("Dungeon Editor/Canvas");
      ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
      ctx->MouseMove(ImVec2(canvas_pos.x + (i * 64) + 32, canvas_pos.y + 80));
      ctx->MouseClick();
      ctx->Yield();
    }
    
    // Verify all objects rendered
    ctx->SetRef("Dungeon Editor/Room Objects");
    ctx->ItemVerifyValue("Object Count", 35);  // 32 walls + 3 decorative
    
    // Verify no performance issues (frame time < 16ms for 60fps)
    ctx->SetRef("Dungeon Editor");
    ctx->ItemVerifyLessThan("Frame Time (ms)", 16.0f);
  };
  test->UserData = self;
}
 
// =============================================================================
// PERFORMANCE TESTS
// =============================================================================
 
void DungeonObjectRenderingE2ETests::RegisterPerformanceTests() {
  ImGuiTest* test = IM_REGISTER_TEST(engine_, "DungeonObjectRendering", "Performance_LargeRoom");
  test->GuiFunc = [](ImGuiTestContext* ctx) {
    auto* self = (DungeonObjectRenderingE2ETests*)ctx->UserData;
    self->dungeon_editor_->Update();
  };
  test->TestFunc = [](ImGuiTestContext* ctx) {
    ctx->SetRef("Dungeon Editor");
    
    // Place 100 objects
    for (int i = 0; i < 100; i++) {
      ctx->ItemClick("Object Selector##tab");
      ctx->SetRef("AssetBrowser");
      ctx->ItemClick("Object_0x10");
      ctx->Yield();
      
      ctx->SetRef("Dungeon Editor/Canvas");
      ImVec2 canvas_pos = ctx->ItemRectMin("canvas##child");
      ctx->MouseMove(ImVec2(
        canvas_pos.x + ((i % 16) * 16),
        canvas_pos.y + ((i / 16) * 16)
      ));
      ctx->MouseClick();
      ctx->Yield();
    }
    
    // Measure rendering performance
    ctx->SetRef("Dungeon Editor");
    float frame_time = ctx->ItemGetValue<float>("Frame Time (ms)");
    
    // Verify acceptable performance (< 16ms for 60fps)
    IM_CHECK_LT(frame_time, 16.0f);
    
    // Verify object count
    ctx->SetRef("Dungeon Editor/Room Objects");
    ctx->ItemVerifyValue("Object Count", 100);
  };
  test->UserData = this;
}
 
// =============================================================================
// TEST REGISTRATION
// =============================================================================
 
void DungeonObjectRenderingE2ETests::RegisterAllTests() {
  RegisterObjectBrowserTests();
  RegisterObjectPlacementTests();
  RegisterObjectSelectionTests();
  RegisterLayerManagementTests();
  RegisterSaveWorkflowTests();
  RegisterRenderingQualityTests();
  RegisterPerformanceTests();
  
  // Register additional helper tests
  RegisterObjectBrowserTests_SelectObject(this);
  RegisterObjectBrowserTests_SearchFilter(this);
  RegisterObjectPlacementTests_SnapToGrid(this);
  RegisterObjectPlacementTests_MultipleObjects(this);
  RegisterObjectSelectionTests_MultiSelect(this);
  RegisterObjectSelectionTests_MoveObject(this);
  RegisterObjectSelectionTests_DeleteObject(this);
  RegisterLayerManagementTests_PlaceOnLayers(this);
  RegisterLayerManagementTests_RenderingOrder(this);
  RegisterSaveWorkflowTests_RoundTrip(this);
  RegisterSaveWorkflowTests_MultipleTypes(this);
  RegisterRenderingQualityTests_Palettes(this);
  RegisterRenderingQualityTests_ComplexRoom(this);
}
 
// =============================================================================
// TEST FIXTURE INTEGRATION
// =============================================================================
 
TEST_F(DungeonObjectRenderingE2ETests, RunAllTests) {
  // Run all registered tests
  ImGuiTestEngine_QueueTests(engine_, ImGuiTestGroup_Tests, nullptr, nullptr);
  ImGuiTestEngine_Run(engine_);
  
  // Verify all tests passed
  ImGuiTestEngineIO& test_io = ImGuiTestEngine_GetIO(engine_);
  EXPECT_EQ(test_io.TestsFailedCount, 0) 
    << "Some E2E tests failed. Check test engine output for details.";
}
 
}  // namespace test
}  // namespace yaze