overworld_ui_tests.cc

Go to the documentation of this file.

#include "app/test/overworld_ui_tests.h"
 
#if defined(YAZE_ENABLE_IMGUI_TEST_ENGINE) && YAZE_ENABLE_IMGUI_TEST_ENGINE
 
#include <string>
 
#include "imgui.h"
#if __has_include("imgui_test_engine/imgui_te_context.h")
#include "imgui_test_engine/imgui_te_context.h"
#elif __has_include("imgui_te_context.h")
#include "imgui_te_context.h"
#else
#error "ImGui Test Engine context header not found"
#endif
 
#if __has_include("imgui_test_engine/imgui_te_engine.h")
#include "imgui_test_engine/imgui_te_engine.h"
#elif __has_include("imgui_te_engine.h")
#include "imgui_te_engine.h"
#else
#error "ImGui Test Engine engine header not found"
#endif
 
namespace yaze::test {
 
namespace {
 
void EnsureTile16PanelOpenAndFocused(ImGuiTestContext* ctx) {
  ctx->SetRef("Tile16 Editor");
  if (ctx->GetWindowByRef("") == nullptr) {
    ctx->KeyPress(ImGuiMod_Ctrl | ImGuiKey_T);
    ctx->Yield(4);
  }
 
  ctx->SetRef("Tile16 Editor");
  IM_CHECK(ctx->GetWindowByRef("") != nullptr);
  ctx->WindowFocus("");
  ctx->Yield(2);
}
 
void ExpectActiveQuadrant(ImGuiTestContext* ctx, const char* label) {
  const std::string pattern = std::string("**/Active ") + label + ":*";
  IM_CHECK(ctx->ItemExists(pattern.c_str()));
}
 
void ExpectBrushPalette(ImGuiTestContext* ctx, int palette) {
  const std::string pattern =
      std::string("**/*Brush Palette: ") + std::to_string(palette) + "*";
  IM_CHECK(ctx->ItemExists(pattern.c_str()));
}
 
}  // namespace
 
// ============================================================================
// Test: Keyboard shortcut mode switching
//
// The overworld editor uses number keys (1, 2) and letter keys (B, F)
// to switch between Mouse, Draw Tile, and Fill Tile modes. These shortcuts
// are handled in OverworldEditor::HandleKeyboardShortcuts() and delegate
// to TilePaintingManager for B/F.
//
// These tests verify that pressing each shortcut key doesn't crash the
// application. Actual mode state verification would require accessing
// the OverworldEditor's internal state, which we defer to unit tests.
// ============================================================================
 
static void RegisterKeyboardShortcutTests(ImGuiTestEngine* engine) {
  // Test: Key '1' (Mouse mode) doesn't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "mouse_mode_key_1");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiKey_1);
      ctx->Yield(3);
    };
  }
 
  // Test: Key '2' (Draw Tile mode) doesn't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "draw_mode_key_2");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiKey_2);
      ctx->Yield(3);
      // Restore mouse mode
      ctx->KeyPress(ImGuiKey_1);
      ctx->Yield(1);
    };
  }
 
  // Test: Key 'B' (Brush toggle) doesn't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "brush_toggle_key_b");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiKey_B);
      ctx->Yield(3);
      // Toggle back
      ctx->KeyPress(ImGuiKey_B);
      ctx->Yield(1);
    };
  }
 
  // Test: Key 'F' (Fill tool) doesn't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "fill_tool_key_f");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiKey_F);
      ctx->Yield(3);
      // Toggle back
      ctx->KeyPress(ImGuiKey_F);
      ctx->Yield(1);
    };
  }
 
  // Test: Key 'I' (Eyedropper / pick tile16) doesn't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "eyedropper_key_i");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiKey_I);
      ctx->Yield(3);
    };
  }
 
  // Test: Ctrl+L (Lock map toggle) doesn't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "lock_toggle_ctrl_l");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiMod_Ctrl | ImGuiKey_L);
      ctx->Yield(3);
      // Toggle back
      ctx->KeyPress(ImGuiMod_Ctrl | ImGuiKey_L);
      ctx->Yield(1);
    };
  }
 
  // Test: F11 (Fullscreen toggle) doesn't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "fullscreen_toggle_f11");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiKey_F11);
      ctx->Yield(3);
      // Toggle back
      ctx->KeyPress(ImGuiKey_F11);
      ctx->Yield(1);
    };
  }
 
  // Test: Ctrl+Z (Undo) doesn't crash when no undo history
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "undo_no_crash");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiMod_Ctrl | ImGuiKey_Z);
      ctx->Yield(3);
    };
  }
 
  // Test: Ctrl+Y (Redo) doesn't crash when no redo history
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "redo_no_crash");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiMod_Ctrl | ImGuiKey_Y);
      ctx->Yield(3);
    };
  }
 
  // Test: Ctrl+T (Toggle Tile16 Editor panel) doesn't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_keys", "tile16_editor_ctrl_t");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      ctx->KeyPress(ImGuiMod_Ctrl | ImGuiKey_T);
      ctx->Yield(3);
      // Toggle back
      ctx->KeyPress(ImGuiMod_Ctrl | ImGuiKey_T);
      ctx->Yield(1);
    };
  }
 
  // Test: Keys 1..4 update tile16 quadrant focus in panel state text.
  {
    ImGuiTest* test = IM_REGISTER_TEST(engine, "overworld_keys",
                                       "tile16_quadrant_hotkeys_apply_focus");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      EnsureTile16PanelOpenAndFocused(ctx);
 
      struct QuadrantStep {
        ImGuiKey key;
        const char* label;
      };
      const QuadrantStep steps[] = {
          {ImGuiKey_1, "TL"},
          {ImGuiKey_2, "TR"},
          {ImGuiKey_3, "BL"},
          {ImGuiKey_4, "BR"},
      };
 
      for (const auto& step : steps) {
        ctx->KeyPress(step.key);
        ctx->Yield(2);
        ExpectActiveQuadrant(ctx, step.label);
      }
 
      ctx->KeyPress(ImGuiMod_Ctrl | ImGuiKey_T);
      ctx->Yield(2);
    };
  }
 
  // Test: Ctrl+1..8 update brush palette while preserving active quadrant.
  {
    ImGuiTest* test = IM_REGISTER_TEST(
        engine, "overworld_keys", "tile16_ctrl_numeric_hotkeys_palette_rows");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      EnsureTile16PanelOpenAndFocused(ctx);
 
      ctx->KeyPress(ImGuiKey_4);
      ctx->Yield(2);
      ExpectActiveQuadrant(ctx, "BR");
 
      for (int palette = 0; palette < 8; ++palette) {
        const ImGuiKey number_key = static_cast<ImGuiKey>(ImGuiKey_1 + palette);
        ctx->KeyPress(ImGuiMod_Ctrl | number_key);
        ctx->Yield(2);
        ExpectBrushPalette(ctx, palette);
        ExpectActiveQuadrant(ctx, "BR");
      }
 
      ctx->KeyPress(ImGuiMod_Ctrl | ImGuiKey_T);
      ctx->Yield(2);
    };
  }
}
 
// ============================================================================
// Test: Entity editing mode shortcuts (3-8 keys)
//
// Keys 3-8 activate different entity editing modes:
//   3 = Entrances, 4 = Exits, 5 = Items,
//   6 = Sprites, 7 = Transports, 8 = Music
// ============================================================================
 
static void RegisterEntityModeTests(ImGuiTestEngine* engine) {
  // Test: Entity mode keys (3-8) don't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_entity", "mode_keys_3_to_8");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      // Cycle through all entity modes
      ctx->KeyPress(ImGuiKey_3);  // Entrances
      ctx->Yield(2);
      ctx->KeyPress(ImGuiKey_4);  // Exits
      ctx->Yield(2);
      ctx->KeyPress(ImGuiKey_5);  // Items
      ctx->Yield(2);
      ctx->KeyPress(ImGuiKey_6);  // Sprites
      ctx->Yield(2);
      ctx->KeyPress(ImGuiKey_7);  // Transports
      ctx->Yield(2);
      ctx->KeyPress(ImGuiKey_8);  // Music
      ctx->Yield(2);
      // Return to mouse mode
      ctx->KeyPress(ImGuiKey_1);
      ctx->Yield(1);
    };
  }
}
 
// ============================================================================
// Test: Mode switching round-trips
//
// Verifies that cycling through all editing modes and returning to Mouse
// mode doesn't leave the editor in a broken state.
// ============================================================================
 
static void RegisterModeRoundTripTests(ImGuiTestEngine* engine) {
  // Test: Full mode cycle (Mouse -> Draw -> Fill -> Mouse) is stable
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_modes", "full_mode_cycle");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      // Start in mouse mode
      ctx->KeyPress(ImGuiKey_1);
      ctx->Yield(2);
 
      // Switch to draw tile
      ctx->KeyPress(ImGuiKey_2);
      ctx->Yield(2);
 
      // Switch to fill via F
      ctx->KeyPress(ImGuiKey_F);
      ctx->Yield(2);
 
      // Toggle brush via B (should go to draw tile)
      ctx->KeyPress(ImGuiKey_B);
      ctx->Yield(2);
 
      // Toggle brush again (should go back to mouse)
      ctx->KeyPress(ImGuiKey_B);
      ctx->Yield(2);
 
      // Back to mouse mode explicitly
      ctx->KeyPress(ImGuiKey_1);
      ctx->Yield(3);
    };
  }
 
  // Test: Rapid mode switching doesn't crash
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_modes", "rapid_mode_switch");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      for (int i = 0; i < 10; ++i) {
        ctx->KeyPress(ImGuiKey_B);
        ctx->Yield(1);
      }
      // Settle back to mouse
      ctx->KeyPress(ImGuiKey_1);
      ctx->Yield(3);
    };
  }
}
 
// ============================================================================
// Test: Canvas navigation smoke tests
//
// These exercise CanvasNavigationManager methods indirectly through the
// keyboard shortcuts and UI interactions. The actual methods tested:
//   - HandleOverworldPan (via middle-click drag simulation)
//   - HandleOverworldZoom (via the zoom step mechanism)
//   - ResetOverworldView (not directly bound to a key, but used internally)
//
// Note: Mouse-based pan/zoom requires pixel-precise ImGui interaction that
// the test engine handles through its coroutine system.
// ============================================================================
 
static void RegisterCanvasNavigationTests(ImGuiTestEngine* engine) {
  // Test: Multiple frames of rendering without interaction is stable
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_canvas", "idle_frames_stable");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      // Just yield several frames to verify the overworld editor
      // renders stably without any interaction
      ctx->Yield(10);
    };
  }
}
 
// ============================================================================
// Test: World combo selector smoke tests
//
// The toolbar has a world selector combo (Light World, Dark World, Special).
// These tests verify the combo exists but don't change world since that
// triggers heavy map reloading that depends on ROM state.
// ============================================================================
 
static void RegisterWorldSelectorTests(ImGuiTestEngine* engine) {
  // Test: Overworld editor remains stable after multiple frame yields
  {
    ImGuiTest* test =
        IM_REGISTER_TEST(engine, "overworld_toolbar", "toolbar_renders_stable");
    test->TestFunc = [](ImGuiTestContext* ctx) {
      // Render several frames to verify toolbar doesn't crash
      ctx->Yield(5);
      // The toolbar "CanvasToolbar" table renders every frame when
      // ROM is loaded and overworld is initialized
    };
  }
}
 
// ============================================================================
// Public registration entry point
// ============================================================================
 
void RegisterOverworldUITests(ImGuiTestEngine* engine) {
  if (engine == nullptr)
    return;
  RegisterKeyboardShortcutTests(engine);
  RegisterEntityModeTests(engine);
  RegisterModeRoundTripTests(engine);
  RegisterCanvasNavigationTests(engine);
  RegisterWorldSelectorTests(engine);
}
 
}  // namespace yaze::test
 
#else  // !YAZE_ENABLE_IMGUI_TEST_ENGINE
 
namespace yaze::test {
void RegisterOverworldUITests(ImGuiTestEngine* /*engine*/) {}
}  // namespace yaze::test
 
#endif  // YAZE_ENABLE_IMGUI_TEST_ENGINE