Add backend preferences regression test

Add a focused regression test and supporting plumbing for the renderer backend selector. A new test script (src/imiv/tools/imiv_backend_preferences_regression.py) exercises the Preferences backend combo and verifies requested/next_launch/restart semantics; CMake registers a ctest (imiv_backend_preferences_regression) when a build contains multiple compiled backends.

Test-engine and state improvements: include backend state in viewer-state JSON (active, requested, next_launch, restart_required, compiled/not_compiled), add compiled_backend_count() and header exposure, and pass active_backend into test-engine JSON writer. Enhance the test engine with register_test_engine_item_label and XML attributes (set_ref, item_click) to support targeted interactions.

Other changes: Preferences UI registers item labels for testing, main window title now shows OIIO version, README and multi-backend docs updated, and a test image asset added.

Author: ssh4net

src/imiv/CMakeLists.txt

@@ -731,6 +731,20 @@ if (_imiv_selected_renderer STREQUAL "")
     endif ()
 endif ()
 
+set (_imiv_enabled_backend_count 0)
+if (_imiv_enabled_vulkan)
+    math (EXPR _imiv_enabled_backend_count
+          "${_imiv_enabled_backend_count} + 1")
+endif ()
+if (_imiv_enabled_metal)
+    math (EXPR _imiv_enabled_backend_count
+          "${_imiv_enabled_backend_count} + 1")
+endif ()
+if (_imiv_enabled_opengl)
+    math (EXPR _imiv_enabled_backend_count
+          "${_imiv_enabled_backend_count} + 1")
+endif ()
+
 set (_imiv_renderer_is_vulkan OFF)
 set (_imiv_renderer_is_metal OFF)
 set (_imiv_renderer_is_opengl OFF)
@@ -1318,6 +1332,25 @@ if (TARGET imiv
             LABELS "imiv;gui"
             TIMEOUT 360)
 
+    if (_imiv_enabled_backend_count GREATER 1)
+        add_test (
+            NAME imiv_backend_preferences_regression
+            COMMAND
+                "${Python3_EXECUTABLE}"
+                "${CMAKE_CURRENT_SOURCE_DIR}/tools/imiv_backend_preferences_regression.py"
+                --bin "$<TARGET_FILE:imiv>"
+                --cwd "$<TARGET_FILE_DIR:imiv>"
+                ${_imiv_ctest_default_backend_args}
+                --env-script "${CMAKE_BINARY_DIR}/imiv_env.sh"
+                --out-dir "${CMAKE_BINARY_DIR}/imiv_captures/backend_preferences_regression"
+                --open "${PROJECT_SOURCE_DIR}/ASWF/logos/openimageio-stacked-gradient.png")
+        set_tests_properties (
+            imiv_backend_preferences_regression PROPERTIES
+                LABELS "imiv;gui;imiv_backend"
+                TIMEOUT 180
+                SKIP_RETURN_CODE 77)
+    endif ()
+
     if (OIIO_IMIV_ADD_BACKEND_VERIFY_CTEST)
         if (_imiv_enabled_vulkan)
             add_test (

src/imiv/README.md

@@ -108,6 +108,12 @@ cmake -S . -B build_u \
 ctest --test-dir build_u -N | rg imiv_backend_verify
 ```
 
+Focused backend-selector regression from a multi-backend build:
+
+```bash
+ctest --test-dir build_u -V -R '^imiv_backend_preferences_regression$'
+```
+
 Main output logs:
 
 - `verify_smoke.log`

src/imiv/imiv_app.cpp

@@ -42,6 +42,7 @@
 #include <OpenImageIO/imagebuf.h>
 #include <OpenImageIO/imagecache.h>
 #include <OpenImageIO/imageio.h>
+#include <OpenImageIO/oiioversion.h>
 #include <OpenImageIO/strutil.h>
 #include <OpenImageIO/sysutil.h>
 
@@ -148,6 +149,12 @@ namespace {
             return config.requested_backend;
         return sanitize_backend_kind(ui_state.renderer_backend);
     }
+
+    std::string build_main_window_title(BackendKind active_backend)
+    {
+        return Strutil::fmt::format("ImIv v.{} [{}]", OIIO_VERSION_STRING,
+                                    backend_cli_name(active_backend));
+    }
 }  // namespace
 
 
@@ -223,8 +230,9 @@ run(const AppConfig& config)
         return EXIT_FAILURE;
     }
 
+    const std::string window_title = build_main_window_title(active_backend);
     GLFWwindow* window = platform_glfw_create_main_window(
-        active_backend, 1600, 900, "imiv", startup_error);
+        active_backend, 1600, 900, window_title.c_str(), startup_error);
     if (window == nullptr) {
         print(stderr, "imiv: {}\n", startup_error);
         platform_glfw_terminate();
@@ -494,7 +502,8 @@ run(const AppConfig& config)
 #endif
 
 #if defined(IMGUI_ENABLE_TEST_ENGINE)
-    ViewerStateJsonWriteContext test_engine_state_ctx = { &viewer, &ui_state };
+    ViewerStateJsonWriteContext test_engine_state_ctx = { &viewer, &ui_state,
+                                                          active_backend };
     TestEngineHooks test_engine_hooks;
     test_engine_hooks.image_window_title       = image_window_title();
     test_engine_hooks.screen_capture           = renderer_screen_capture;

src/imiv/imiv_aux_windows.cpp

@@ -291,6 +291,7 @@ draw_preferences_window(PlaceholderUiState& ui, bool& show_window,
             backend_label += " (not built)";
         }
         if (ImGui::BeginCombo("Renderer backend", backend_label.c_str())) {
+            register_test_engine_item_label("Renderer backend", true);
             const bool auto_selected = requested_backend == BackendKind::Auto;
             if (ImGui::Selectable("Auto", auto_selected)) {
                 ui.renderer_backend = static_cast<int>(BackendKind::Auto);
@@ -312,6 +313,8 @@ draw_preferences_window(PlaceholderUiState& ui, bool& show_window,
                     ImGui::SetItemDefaultFocus();
             }
             ImGui::EndCombo();
+        } else {
+            register_test_engine_item_label("Renderer backend", true);
         }
         ImGui::TextUnformatted("Current backend");
         ImGui::SameLine();

src/imiv/imiv_backend.cpp

@@ -186,4 +186,15 @@ compiled_backend_info()
     return info;
 }
 
+size_t
+compiled_backend_count()
+{
+    size_t count = 0;
+    for (const BackendInfo& info : compiled_backend_info()) {
+        if (info.compiled)
+            ++count;
+    }
+    return count;
+}
+
 }  // namespace Imiv

src/imiv/imiv_backend.h

@@ -40,5 +40,7 @@ bool
 backend_kind_is_compiled(BackendKind kind);
 const std::array<BackendInfo, 3>&
 compiled_backend_info();
+size_t
+compiled_backend_count();
 
 }  // namespace Imiv

src/imiv/imiv_frame.cpp

@@ -5,6 +5,7 @@
 #include "imiv_frame.h"
 
 #include "imiv_actions.h"
+#include "imiv_backend.h"
 #include "imiv_drag_drop.h"
 #include "imiv_image_view.h"
 #include "imiv_menu.h"
@@ -322,6 +323,49 @@ test_engine_json_write_ocio_state(FILE* f, const PlaceholderUiState& ui_state)
     std::fputs("\n    }\n  }", f);
 }
 
+void
+test_engine_json_write_backend_state(FILE* f, const PlaceholderUiState& ui_state,
+                                     BackendKind active_backend)
+{
+    const BackendKind requested_backend = sanitize_backend_kind(
+        ui_state.renderer_backend);
+    const BackendKind next_launch_backend = resolve_backend_request(
+        requested_backend);
+    const bool requested_backend_compiled
+        = requested_backend == BackendKind::Auto
+          || backend_kind_is_compiled(requested_backend);
+
+    std::vector<std::string> compiled_backends;
+    std::vector<std::string> unavailable_backends;
+    compiled_backends.reserve(compiled_backend_info().size());
+    unavailable_backends.reserve(compiled_backend_info().size());
+    for (const BackendInfo& info : compiled_backend_info()) {
+        if (info.compiled)
+            compiled_backends.emplace_back(info.cli_name);
+        else
+            unavailable_backends.emplace_back(info.cli_name);
+    }
+
+    std::fputs(",\n  \"backend\": {\n", f);
+    std::fputs("    \"active\": ", f);
+    test_engine_json_write_escaped(f, backend_cli_name(active_backend));
+    std::fputs(",\n    \"active_runtime\": ", f);
+    test_engine_json_write_escaped(f, backend_runtime_name(active_backend));
+    std::fputs(",\n    \"requested\": ", f);
+    test_engine_json_write_escaped(f, backend_cli_name(requested_backend));
+    std::fputs(",\n    \"next_launch\": ", f);
+    test_engine_json_write_escaped(f, backend_cli_name(next_launch_backend));
+    std::fputs(",\n    \"requested_compiled\": ", f);
+    std::fputs(requested_backend_compiled ? "true" : "false", f);
+    std::fputs(",\n    \"restart_required\": ", f);
+    std::fputs(next_launch_backend != active_backend ? "true" : "false", f);
+    std::fputs(",\n    \"compiled\": ", f);
+    test_engine_json_write_string_array(f, compiled_backends);
+    std::fputs(",\n    \"not_compiled\": ", f);
+    test_engine_json_write_string_array(f, unavailable_backends);
+    std::fputs("\n  }", f);
+}
+
 bool
 write_test_engine_viewer_state_json(const std::filesystem::path& out_path,
                                     void* user_data, std::string& error_message)
@@ -407,6 +451,7 @@ write_test_engine_viewer_state_json(const std::filesystem::path& out_path,
         test_engine_json_write_escaped(f, viewer.area_probe_lines[i].c_str());
     }
     std::fputs("]", f);
+    test_engine_json_write_backend_state(f, ui_state, ctx->active_backend);
     test_engine_json_write_ocio_state(f, ui_state);
     std::fputs("\n}\n", f);
     std::fflush(f);

src/imiv/imiv_frame.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "imiv_backend.h"
 #include "imiv_renderer.h"
 #include "imiv_ui.h"
 
@@ -33,6 +34,7 @@ struct DeveloperUiState {
 struct ViewerStateJsonWriteContext {
     const ViewerState* viewer          = nullptr;
     const PlaceholderUiState* ui_state = nullptr;
+    BackendKind active_backend         = BackendKind::Auto;
 };
 
 bool

src/imiv/imiv_test_engine.cpp

@@ -131,6 +131,8 @@ namespace {
         int post_action_delay_frames = 0;
         bool has_key_chord           = false;
         ImGuiKeyChord key_chord      = 0;
+        std::string set_ref;
+        std::string item_click_ref;
         TestEngineMouseTargetMode mouse_target_mode
             = TestEngineMouseTargetMode::None;
         float mouse_x        = 0.0f;
@@ -298,6 +300,15 @@ namespace {
                 step.action.has_key_chord = true;
             }
 
+            const pugi::xml_attribute item_click_attr = step_node.attribute(
+                "item_click");
+            if (item_click_attr && item_click_attr.as_string()[0] != '\0')
+                step.action.item_click_ref = item_click_attr.as_string();
+            const pugi::xml_attribute set_ref_attr = step_node.attribute(
+                "set_ref");
+            if (set_ref_attr && set_ref_attr.as_string()[0] != '\0')
+                step.action.set_ref = set_ref_attr.as_string();
+
             if (parse_float_pair_attr(step_node.attribute("mouse_pos"),
                                       step.action.mouse_x,
                                       step.action.mouse_y)) {
@@ -978,6 +989,16 @@ namespace {
             ctx->Yield(1);
         }
 
+        if (!action.set_ref.empty()) {
+            ctx->SetRef(action.set_ref.c_str());
+            ctx->Yield(1);
+        }
+
+        if (!action.item_click_ref.empty()) {
+            ctx->ItemClick(action.item_click_ref.c_str());
+            ctx->Yield(1);
+        }
+
         ImVec2 mouse_pos(0.0f, 0.0f);
         if (resolve_action_mouse_pos(action, mouse_pos)) {
             ctx->MouseMoveToPos(mouse_pos);
@@ -1721,4 +1742,36 @@ register_layout_dump_synthetic_rect(const char* kind, const char* label,
 #endif
 }
 
+void
+register_test_engine_item_label(const char* label, bool openable)
+{
+#if defined(IMGUI_ENABLE_TEST_ENGINE)
+    if (label == nullptr || label[0] == '\0')
+        return;
+    ImGuiContext* ui_ctx = ImGui::GetCurrentContext();
+    if (ui_ctx == nullptr)
+        return;
+    const ImVec2 min = ImGui::GetItemRectMin();
+    const ImVec2 max = ImGui::GetItemRectMax();
+    if (max.x <= min.x || max.y <= min.y)
+        return;
+    const int ordinal = ++g_layout_dump_synthetic_item_counter;
+    char id_source[128] = {};
+    std::snprintf(id_source, sizeof(id_source), "##imiv_test_item_%d",
+                  ordinal);
+    const ImGuiID id = ImGui::GetID(id_source);
+    if (id == 0)
+        return;
+    const ImRect bb(min, max);
+    ImGuiItemStatusFlags flags = ImGuiItemStatusFlags_None;
+    if (openable)
+        flags |= ImGuiItemStatusFlags_Openable;
+    ImGuiTestEngineHook_ItemAdd(ui_ctx, id, bb, nullptr);
+    ImGuiTestEngineHook_ItemInfo(ui_ctx, id, label, flags);
+#else
+    (void)label;
+    (void)openable;
+#endif
+}
+
 }  // namespace Imiv

src/imiv/imiv_test_engine.h

@@ -84,5 +84,7 @@ register_layout_dump_synthetic_item(const char* kind, const char* label);
 void
 register_layout_dump_synthetic_rect(const char* kind, const char* label,
                                     const ImVec2& min, const ImVec2& max);
+void
+register_test_engine_item_label(const char* label, bool openable = false);
 
 }  // namespace Imiv