Updating to zig 0.15.1

1 files changed, 0 insertions, 616 deletions

diff --git a/vendor/zgui/libs/imgui_test_engine/imgui_te_context.h b/vendor/zgui/libs/imgui_test_engine/imgui_te_context.h
deleted file mode 100644
index a469f60..0000000
--- a/vendor/zgui/libs/imgui_test_engine/imgui_te_context.h
+++ /dev/null
@@ -1,616 +0,0 @@
-// dear imgui test engine
-// (context when a running test + end user automation API)
-// This is the main (if not only) interface that your Tests will be using.
-
-#pragma once
-
-#include "imgui.h"
-#include "imgui_internal.h"     // ImGuiAxis, ImGuiItemStatusFlags, ImGuiInputSource, ImGuiWindow
-#include "imgui_te_engine.h"    // ImGuiTestStatus, ImGuiTestRunFlags, ImGuiTestActiveFunc, ImGuiTestItemInfo, ImGuiTestLogFlags
-
-/*
-
-Index of this file:
-// [SECTION] Header mess, warnings
-// [SECTION] Forward declarations
-// [SECTION] ImGuiTestRef
-// [SECTION] Helper keys
-// [SECTION] ImGuiTestContext related Flags/Enumerations
-// [SECTION] ImGuiTestGenericVars, ImGuiTestGenericItemStatus
-// [SECTION] ImGuiTestContext
-// [SECTION] Debugging macros: IM_SUSPEND_TESTFUNC()
-// [SECTION] Testing/Checking macros: IM_CHECK(), IM_ERRORF() etc.
-
-*/
-
-//-------------------------------------------------------------------------
-// [SECTION] Header mess, warnings
-//-------------------------------------------------------------------------
-
-// Undo some of the damage done by <windows.h>
-#ifdef Yield
-#undef Yield
-#endif
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunknown-pragmas"                // warning: unknown warning group 'xxx'
-#elif defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"                          // warning: unknown option after '#pragma GCC diagnostic' kind
-#pragma GCC diagnostic ignored "-Wclass-memaccess"                  // [__GNUC__ >= 8] warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead
-#endif
-
-//-------------------------------------------------------------------------
-// [SECTION] Forward declarations
-//-------------------------------------------------------------------------
-
-// This file
-typedef int ImGuiTestOpFlags;       // Flags: See ImGuiTestOpFlags_
-
-// External: imgui
-struct ImGuiDockNode;
-struct ImGuiTabBar;
-struct ImGuiWindow;
-
-// External: test engine
-struct ImGuiTest;                   // A test registered with IM_REGISTER_TEST()
-struct ImGuiTestEngine;             // Test Engine Instance (opaque)
-struct ImGuiTestEngineIO;           // Test Engine IO structure (configuration flags, state)
-struct ImGuiTestItemInfo;           // Information gathered about an item: label, status, bounding box etc.
-struct ImGuiTestItemList;           // Result of an GatherItems() query
-struct ImGuiTestInputs;             // Test Engine Simulated Inputs structure (opaque)
-struct ImGuiTestGatherTask;         // Test Engine task for scanning/finding items
-struct ImGuiCaptureArgs;            // Parameters for ctx->CaptureXXX functions
-enum ImGuiTestVerboseLevel : int;
-
-//-------------------------------------------------------------------------
-// [SECTION] ImGuiTestRef
-//-------------------------------------------------------------------------
-
-// Weak reference to an Item/Window given an hashed ID _or_ a string path ID.
-// This is most often passed as argument to function and generally has a very short lifetime.
-// Documentation: https://github.com/ocornut/imgui_test_engine/wiki/Named-References
-// (SUGGESTION: add those constructors to "VA Step Filter" (Visual Assist) or a .natstepfilter file (Visual Studio) so they are skipped by F11 (StepInto)
-struct IMGUI_API ImGuiTestRef
-{
-    ImGuiID         ID;             // Pre-hashed ID
-    const char*     Path;           // Relative or absolute path (string pointed to, not owned, as our lifetime is very short)
-
-    ImGuiTestRef()                  { ID = 0; Path = NULL; }
-    ImGuiTestRef(ImGuiID id)        { ID = id; Path = NULL; }
-    ImGuiTestRef(const char* path)  { ID = 0; Path = path; }
-    bool IsEmpty() const            { return ID == 0 && (Path == NULL || Path[0] == 0); }
-};
-
-// Debug helper to output a string showing the Path, ID or Debug Label based on what is available (some items only have ID as we couldn't find/store a Path)
-// (The size is arbitrary, this is only used for logging info the user/debugger)
-struct IMGUI_API ImGuiTestRefDesc
-{
-    char            Buf[80];
-
-    const char* c_str()             { return Buf; }
-    ImGuiTestRefDesc(const ImGuiTestRef& ref, const ImGuiTestItemInfo* item);
-};
-
-//-------------------------------------------------------------------------
-// [SECTION] ImGuiTestContext related Flags/Enumerations
-//-------------------------------------------------------------------------
-
-// Named actions. Generally you will call the named helpers e.g. ItemClick(). This is used by shared/low-level functions such as ItemAction().
-enum ImGuiTestAction
-{
-    ImGuiTestAction_Unknown = 0,
-    ImGuiTestAction_Hover,          // Move mouse
-    ImGuiTestAction_Click,          // Move mouse and click
-    ImGuiTestAction_DoubleClick,    // Move mouse and double-click
-    ImGuiTestAction_Check,          // Check item if unchecked (Checkbox, MenuItem or any widget reporting ImGuiItemStatusFlags_Checkable)
-    ImGuiTestAction_Uncheck,        // Uncheck item if checked
-    ImGuiTestAction_Open,           // Open item if closed (TreeNode, BeginMenu or any widget reporting ImGuiItemStatusFlags_Openable)
-    ImGuiTestAction_Close,          // Close item if opened
-    ImGuiTestAction_Input,          // Start text inputing into a field (e.g. CTRL+Click on Drags/Slider, click on InputText etc.)
-    ImGuiTestAction_NavActivate,    // Activate item with navigation
-    ImGuiTestAction_COUNT
-};
-
-// Generic flags for many ImGuiTestContext functions
-enum ImGuiTestOpFlags_
-{
-    ImGuiTestOpFlags_None               = 0,
-    ImGuiTestOpFlags_NoCheckHoveredId   = 1 << 1,   // Don't check for HoveredId after aiming for a widget. A few situations may want this: while e.g. dragging or another items prevents hovering, or for items that don't use ItemHoverable()
-    ImGuiTestOpFlags_NoError            = 1 << 2,   // Don't abort/error e.g. if the item cannot be found or the operation doesn't succeed.
-    ImGuiTestOpFlags_NoFocusWindow      = 1 << 3,   // Don't focus window when aiming at an item
-    ImGuiTestOpFlags_NoAutoUncollapse   = 1 << 4,   // Disable automatically uncollapsing windows (useful when specifically testing Collapsing behaviors)
-    ImGuiTestOpFlags_NoAutoOpenFullPath = 1 << 5,   // Disable automatically opening intermediaries (e.g. ItemClick("Hello/OK") will automatically first open "Hello" if "OK" isn't found. Only works if ref is a string path.
-    ImGuiTestOpFlags_IsSecondAttempt    = 1 << 6,   // Used by recursing functions to indicate a second attempt
-    ImGuiTestOpFlags_MoveToEdgeL        = 1 << 7,   // Simple Dumb aiming helpers to test widget that care about clicking position. May need to replace will better functionalities.
-    ImGuiTestOpFlags_MoveToEdgeR        = 1 << 8,
-    ImGuiTestOpFlags_MoveToEdgeU        = 1 << 9,
-    ImGuiTestOpFlags_MoveToEdgeD        = 1 << 10,
-};
-
-// Advanced filtering for ItemActionAll()
-struct IMGUI_API ImGuiTestActionFilter
-{
-    int                     MaxDepth;
-    int                     MaxPasses;
-    const int*              MaxItemCountPerDepth;
-    ImGuiItemStatusFlags    RequireAllStatusFlags;
-    ImGuiItemStatusFlags    RequireAnyStatusFlags;
-
-    ImGuiTestActionFilter() { MaxDepth = -1; MaxPasses = -1; MaxItemCountPerDepth = NULL; RequireAllStatusFlags = RequireAnyStatusFlags = 0; }
-};
-
-//-------------------------------------------------------------------------
-// [SECTION] ImGuiTestGenericVars, ImGuiTestGenericItemStatus
-//-------------------------------------------------------------------------
-
-// Helper struct to store various query-able state of an item.
-// This facilitate interactions between GuiFunc and TestFunc, since those state are frequently used.
-struct IMGUI_API ImGuiTestGenericItemStatus
-{
-    int     RetValue;               // return value
-    int     Hovered;                // result of IsItemHovered()
-    int     Active;                 // result of IsItemActive()
-    int     Focused;                // result of IsItemFocused()
-    int     Clicked;                // result of IsItemClicked()
-    int     Visible;                // result of IsItemVisible()
-    int     Edited;                 // result of IsItemEdited()
-    int     Activated;              // result of IsItemActivated()
-    int     Deactivated;            // result of IsItemDeactivated()
-    int     DeactivatedAfterEdit;   // result of IsItemDeactivatedAfterEdit()
-
-    ImGuiTestGenericItemStatus()        { Clear(); }
-    void Clear()                        { memset(this, 0, sizeof(*this)); }
-    void QuerySet(bool ret_val = false) { Clear(); QueryInc(ret_val); }
-    void QueryInc(bool ret_val = false) { RetValue += ret_val; Hovered += ImGui::IsItemHovered(); Active += ImGui::IsItemActive(); Focused += ImGui::IsItemFocused(); Clicked += ImGui::IsItemClicked(); Visible += ImGui::IsItemVisible(); Edited += ImGui::IsItemEdited(); Activated += ImGui::IsItemActivated(); Deactivated += ImGui::IsItemDeactivated(); DeactivatedAfterEdit += ImGui::IsItemDeactivatedAfterEdit(); }
-};
-
-// Generic structure with various storage fields.
-// This is useful for tests to quickly share data between GuiFunc and TestFunc without creating custom data structure.
-// If those fields are not enough: using test->SetVarsDataType<>() + ctx->GetVars<>() it is possible to store custom data.
-struct IMGUI_API ImGuiTestGenericVars
-{
-    // Generic storage with a bit of semantic to make user/test code look neater
-    int                     Step;
-    int                     Count;
-    ImGuiID                 DockId;
-    ImGuiID                 OwnerId;
-    ImGuiWindowFlags        WindowFlags;
-    ImGuiTableFlags         TableFlags;
-    ImGuiPopupFlags         PopupFlags;
-    ImGuiTestGenericItemStatus  Status;
-    bool                    ShowWindow1, ShowWindow2;
-    bool                    UseClipper;
-    bool                    UseViewports;
-    float                   Width;
-    ImVec2                  Pos;
-    ImVec2                  Size;
-    ImVec2                  Pivot;
-    ImVec4                  Color1, Color2;
-
-    // Generic unnamed storage
-    int                     Int1, Int2, IntArray[10];
-    float                   Float1, Float2, FloatArray[10];
-    bool                    Bool1, Bool2, BoolArray[10];
-    ImGuiID                 Id, IdArray[10];
-    char                    Str1[256], Str2[256];
-
-    ImGuiTestGenericVars()  { Clear(); }
-    void Clear()            { memset(this, 0, sizeof(*this)); }
-};
-
-//-------------------------------------------------------------------------
-// [SECTION] ImGuiTestContext
-// Context for a running ImGuiTest
-// This is the interface that most tests will interact with.
-//-------------------------------------------------------------------------
-
-struct IMGUI_API ImGuiTestContext
-{
-    // User variables
-    ImGuiTestGenericVars    GenericVars;                            // Generic variables holder for convenience.
-    void*                   UserVars = NULL;                        // Access using ctx->GetVars<Type>(). Setup with test->SetVarsDataType<>().
-
-    // Public fields
-    ImGuiContext*           UiContext = NULL;                       // UI context
-    ImGuiTestEngineIO*      EngineIO = NULL;                        // Test Engine IO/settings
-    ImGuiTest*              Test = NULL;                            // Test currently running
-    ImGuiTestOutput*        TestOutput = NULL;                      // Test output (generally == &Test->Output)
-    ImGuiTestOpFlags        OpFlags = ImGuiTestOpFlags_None;        // Flags affecting all operation (supported: ImGuiTestOpFlags_NoAutoUncollapse)
-    int                     PerfStressAmount = 0;                   // Convenience copy of engine->IO.PerfStressAmount
-    int                     FrameCount = 0;                         // Test frame count (restarts from zero every time)
-    int                     FirstTestFrameCount = 0;                // First frame where TestFunc is running (after warm-up frame). This is generally -1 or 0 depending on whether we have warm up enabled
-    bool                    FirstGuiFrame = false;
-    bool                    HasDock = false;                        // #ifdef IMGUI_HAS_DOCK expressed in an easier to test value
-    ImGuiCaptureArgs*       CaptureArgs = NULL;                     // Capture settings used by ctx->Capture*() functions
-
-    //-------------------------------------------------------------------------
-    // [Internal Fields]
-    //-------------------------------------------------------------------------
-
-    ImGuiTestEngine*        Engine = NULL;
-    ImGuiTestInputs*        Inputs = NULL;
-    ImGuiTestRunFlags       RunFlags = ImGuiTestRunFlags_None;
-    ImGuiTestActiveFunc     ActiveFunc = ImGuiTestActiveFunc_None;  // None/GuiFunc/TestFunc
-    double                  RunningTime = 0.0;                      // Amount of wall clock time the Test has been running. Used by safety watchdog.
-    int                     ActionDepth = 0;                        // Nested depth of ctx-> function calls (used to decorate log)
-    int                     CaptureCounter = 0;                     // Number of captures
-    int                     ErrorCounter = 0;                       // Number of errors (generally this maxxes at 1 as most functions will early out)
-    bool                    Abort = false;
-    double                  PerfRefDt = -1.0;
-    int                     PerfIterations = 400;                   // Number of frames for PerfCapture() measurements
-    char                    RefStr[256] = { 0 };                    // Reference window/path over which all named references are based
-    ImGuiID                 RefID = 0;                              // Reference ID over which all named references are based
-    ImGuiID                 RefWindowID = 0;                        // ID of a window that contains RefID item
-    ImGuiInputSource        InputMode = ImGuiInputSource_Mouse;     // Prefer interacting with mouse/keyboard/gamepad
-    ImVector<char>          Clipboard;                              // Private clipboard for the test instance
-    ImVector<ImGuiWindow*>  ForeignWindowsToHide;
-    ImGuiTestItemInfo       DummyItemInfoNull;                      // Storage for ItemInfoNull()
-    bool                    CachedLinesPrintedToTTY = false;
-
-    //-------------------------------------------------------------------------
-    // Public API
-    //-------------------------------------------------------------------------
-
-    // Main control
-    void            RecoverFromUiContextErrors();
-    void            Finish(ImGuiTestStatus status = ImGuiTestStatus_Success);                       // Set test status and stop running. Usually called when running test logic from GuiFunc() only.
-    ImGuiTestStatus RunChildTest(const char* test_name, ImGuiTestRunFlags flags = 0);               // [Experimental] Run another test from the current test.
-    template <typename T> T& GetVars()      { IM_ASSERT(UserVars != NULL); return *(T*)(UserVars); }// Campanion to using t->SetVarsDataType<>(). FIXME: Assert to compare sizes
-
-    // Main status queries
-    bool        IsError() const             { return TestOutput->Status == ImGuiTestStatus_Error || Abort; }
-    bool        IsWarmUpGuiFrame() const    { return FrameCount < FirstTestFrameCount; }    // Unless test->Flags has ImGuiTestFlags_NoGuiWarmUp, we run GuiFunc() twice before running TestFunc(). Those frames are called "WarmUp" frames.
-    bool        IsFirstGuiFrame() const     { return FirstGuiFrame; }
-    bool        IsFirstTestFrame() const    { return FrameCount == FirstTestFrameCount; }   // First frame where TestFunc is running (after warm-up frame).
-    bool        IsGuiFuncOnly() const       { return (RunFlags & ImGuiTestRunFlags_GuiFuncOnly) != 0; }
-
-    // Debugging
-    bool        SuspendTestFunc(const char* file = NULL, int line = 0);             // [DEBUG] Generally called via IM_SUSPEND_TESTFUNC
-
-    // Logging
-    void        LogEx(ImGuiTestVerboseLevel level, ImGuiTestLogFlags flags, const char* fmt, ...) IM_FMTARGS(4);
-    void        LogExV(ImGuiTestVerboseLevel level, ImGuiTestLogFlags flags, const char* fmt, va_list args) IM_FMTLIST(4);
-    void        LogToTTY(ImGuiTestVerboseLevel level, const char* message, const char* message_end = NULL);
-    void        LogToDebugger(ImGuiTestVerboseLevel level, const char* message);
-    void        LogDebug(const char* fmt, ...)      IM_FMTARGS(2);  // ImGuiTestVerboseLevel_Debug or ImGuiTestVerboseLevel_Trace depending on context depth
-    void        LogInfo(const char* fmt, ...)       IM_FMTARGS(2);  // ImGuiTestVerboseLevel_Info
-    void        LogWarning(const char* fmt, ...)    IM_FMTARGS(2);  // ImGuiTestVerboseLevel_Warning
-    void        LogError(const char* fmt, ...)      IM_FMTARGS(2);  // ImGuiTestVerboseLevel_Error
-    void        LogBasicUiState();
-    void        LogItemList(ImGuiTestItemList* list);
-
-    // Yield, Timing
-    void        Yield(int count = 1);
-    void        YieldUntil(int frame_count);
-    void        Sleep(float time_in_second);            // Sleep for a given simulation time, unless in Fast mode
-    void        SleepShort();                           // Standard short delay of io.ActionDelayShort (~0.15f), unless in Fast mode.
-    void        SleepStandard();                        // Standard regular delay of io.ActionDelayStandard (~0.40f), unless in Fast mode.
-    void        SleepNoSkip(float time_in_second, float framestep_in_second);
-
-    // Base Reference
-    // - ItemClick("Window/Button")                --> click "Window/Button"
-    // - SetRef("Window"), ItemClick("Button")     --> click "Window/Button"
-    // - SetRef("Window"), ItemClick("/Button")    --> click "Window/Button"
-    // - SetRef("Window"), ItemClick("//Button")   --> click "/Button"
-    // - SetRef("//$FOCUSED"), ItemClick("Button") --> click "Button" in focused window.
-    // See https://github.com/ocornut/imgui_test_engine/wiki/Named-References about using ImGuiTestRef in all ImGuiTestContext functions.
-    // Note: SetRef() may take multiple frames to complete if specified ref is an item id.
-    void        SetRef(ImGuiTestRef ref);
-    void        SetRef(ImGuiWindow* window); // Shortcut to SetRef(window->Name) which works for ChildWindow (see code)
-    ImGuiTestRef GetRef();
-
-    // Windows
-    ImGuiTestItemInfo* WindowInfo(ImGuiTestRef window_ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
-    void        WindowClose(ImGuiTestRef window_ref);
-    void        WindowCollapse(ImGuiTestRef window_ref, bool collapsed);
-    void        WindowFocus(ImGuiTestRef window_ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
-    void        WindowBringToFront(ImGuiTestRef window_ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
-    void        WindowMove(ImGuiTestRef window_ref, ImVec2 pos, ImVec2 pivot = ImVec2(0.0f, 0.0f), ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
-    void        WindowResize(ImGuiTestRef window_ref, ImVec2 sz);
-    bool        WindowTeleportToMakePosVisible(ImGuiTestRef window_ref, ImVec2 pos_in_window);
-    ImGuiWindow*GetWindowByRef(ImGuiTestRef window_ref);
-
-    // Popups
-    void        PopupCloseOne();
-    void        PopupCloseAll();
-    ImGuiID     PopupGetWindowID(ImGuiTestRef ref);
-
-    // Get hash for a decorated ID Path.
-    // Note: for windows you may use WindowInfo()
-    ImGuiID     GetID(ImGuiTestRef ref);
-    ImGuiID     GetID(ImGuiTestRef ref, ImGuiTestRef seed_ref);
-
-    // Miscellaneous helpers
-    ImVec2      GetPosOnVoid(ImGuiViewport* viewport);                              // Find a point that has no windows // FIXME: This needs error return and flag to enable/disable forcefully finding void.
-    ImVec2      GetWindowTitlebarPoint(ImGuiTestRef window_ref);                    // Return a clickable point on window title-bar (window tab for docked windows).
-    ImVec2      GetMainMonitorWorkPos();                                            // Work pos and size of main viewport when viewports are disabled, or work pos and size of monitor containing main viewport when viewports are enabled.
-    ImVec2      GetMainMonitorWorkSize();
-
-    // Screenshot/Video Captures
-    void        CaptureReset();                                                     // Reset state (use when doing multiple captures)
-    void        CaptureSetExtension(const char* ext);                               // Set capture file format (otherwise for video this default to EngineIO->VideoCaptureExtension)
-    bool        CaptureAddWindow(ImGuiTestRef ref);                                 // Add window to be captured (default to capture everything)
-    void        CaptureScreenshotWindow(ImGuiTestRef ref, int capture_flags = 0);   // Trigger a screen capture of a single window (== CaptureAddWindow() + CaptureScreenshot())
-    bool        CaptureScreenshot(int capture_flags = 0);                           // Trigger a screen capture
-    bool        CaptureBeginVideo();                                                // Start a video capture
-    bool        CaptureEndVideo();
-
-    // Mouse inputs
-    void        MouseMove(ImGuiTestRef ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
-    void        MouseMoveToPos(ImVec2 pos);
-    void        MouseTeleportToPos(ImVec2 pos);
-    void        MouseClick(ImGuiMouseButton button = 0);
-    void        MouseClickMulti(ImGuiMouseButton button, int count);
-    void        MouseDoubleClick(ImGuiMouseButton button = 0);
-    void        MouseDown(ImGuiMouseButton button = 0);
-    void        MouseUp(ImGuiMouseButton button = 0);
-    void        MouseLiftDragThreshold(ImGuiMouseButton button = 0);
-    void        MouseDragWithDelta(ImVec2 delta, ImGuiMouseButton button = 0);
-    void        MouseWheel(ImVec2 delta);
-    void        MouseWheelX(float dx) { MouseWheel(ImVec2(dx, 0.0f)); }
-    void        MouseWheelY(float dy) { MouseWheel(ImVec2(0.0f, dy)); }
-    void        MouseMoveToVoid(ImGuiViewport* viewport = NULL);
-    void        MouseClickOnVoid(ImGuiMouseButton button = 0, ImGuiViewport* viewport = NULL);
-    ImGuiWindow*FindHoveredWindowAtPos(const ImVec2& pos);
-    bool        FindExistingVoidPosOnViewport(ImGuiViewport* viewport, ImVec2* out);
-
-    // Mouse inputs: Viewports
-    // - This is automatically called by SetRef() and any mouse action taking an item reference (e.g. ItemClick("button"), MouseClick("button"))
-    // - But when using raw position directy e.g. MouseMoveToPos() / MouseTeleportToPos() without referring to the parent window before, this needs to be set.
-    void        MouseSetViewport(ImGuiWindow* window);
-    void        MouseSetViewportID(ImGuiID viewport_id);
-
-    // Keyboard inputs
-    void        KeyDown(ImGuiKeyChord key_chord);
-    void        KeyUp(ImGuiKeyChord key_chord);
-    void        KeyPress(ImGuiKeyChord key_chord, int count = 1);
-    void        KeyHold(ImGuiKeyChord key_chord, float time);
-    void        KeySetEx(ImGuiKeyChord key_chord, bool is_down, float time);
-    void        KeyChars(const char* chars);                // Input characters
-    void        KeyCharsAppend(const char* chars);          // Input characters at end of field
-    void        KeyCharsAppendEnter(const char* chars);     // Input characters at end of field, press Enter
-    void        KeyCharsReplace(const char* chars);         // Delete existing field then input characters
-    void        KeyCharsReplaceEnter(const char* chars);    // Delete existing field then input characters, press Enter
-
-    // Navigation inputs
-    // FIXME: Need some redesign/refactoring:
-    // - This was initially intended to: replace mouse action with keyboard/gamepad
-    // - Abstract keyboard vs gamepad actions
-    // However this is widely inconsistent and unfinished at this point.
-    void        SetInputMode(ImGuiInputSource input_mode);  // Mouse or Keyboard or Gamepad. In Keyboard or Gamepad mode, actions such as ItemClick or ItemInput are using nav facilities instead of Mouse.
-    void        NavMoveTo(ImGuiTestRef ref);
-    void        NavActivate();                              // Activate current selected item: activate button, tweak sliders/drags. Equivalent of pressing Space on keyboard, ImGuiKey_GamepadFaceUp on a gamepad.
-    void        NavInput();                                 // Input into select item: input sliders/drags. Equivalent of pressing Enter on keyboard, ImGuiKey_GamepadFaceDown on a gamepad.
-
-    // Scrolling
-    void        ScrollTo(ImGuiTestRef ref, ImGuiAxis axis, float scroll_v, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
-    void        ScrollToX(ImGuiTestRef ref, float scroll_x) { ScrollTo(ref, ImGuiAxis_X, scroll_x); }
-    void        ScrollToY(ImGuiTestRef ref, float scroll_y) { ScrollTo(ref, ImGuiAxis_Y, scroll_y); }
-    void        ScrollToTop(ImGuiTestRef ref);
-    void        ScrollToBottom(ImGuiTestRef ref);
-    void        ScrollToItem(ImGuiTestRef ref, ImGuiAxis axis, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
-    void        ScrollToItemX(ImGuiTestRef ref);
-    void        ScrollToItemY(ImGuiTestRef ref);
-    void        ScrollToTabItem(ImGuiTabBar* tab_bar, ImGuiID tab_id);
-    bool        ScrollErrorCheck(ImGuiAxis axis, float expected, float actual, int* remaining_attempts);
-    void        ScrollVerifyScrollMax(ImGuiTestRef ref);
-
-    // Low-level queries
-    // - ItemInfo queries never returns a NULL pointer, instead they return an empty instance (info->IsEmpty(), info->ID == 0) and set contexted as errored.
-    // - You can use ImGuiTestOpFlags_NoError to do a query without marking context as errored. This is what ItemExists() does.
-    ImGuiTestItemInfo*  ItemInfo(ImGuiTestRef ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
-    ImGuiTestItemInfo*  ItemInfoOpenFullPath(ImGuiTestRef ref, ImGuiTestOpFlags flags = ImGuiTestOpFlags_None);
-    ImGuiID             ItemInfoHandleWildcardSearch(const char* wildcard_prefix_start, const char* wildcard_prefix_end, const char* wildcard_suffix_start);
-    ImGuiTestItemInfo*  ItemInfoNull();
-    void                GatherItems(ImGuiTestItemList* out_list, ImGuiTestRef parent, int depth = -1);
-
-    // Item/Widgets manipulation
-    void        ItemAction(ImGuiTestAction action, ImGuiTestRef ref, ImGuiTestOpFlags flags = 0, void* action_arg = NULL);
-    void        ItemClick(ImGuiTestRef ref, ImGuiMouseButton button = 0, ImGuiTestOpFlags flags = 0) { ItemAction(ImGuiTestAction_Click, ref, flags, (void*)(size_t)button); }
-    void        ItemDoubleClick(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)           { ItemAction(ImGuiTestAction_DoubleClick, ref, flags); }
-    void        ItemCheck(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)                 { ItemAction(ImGuiTestAction_Check, ref, flags); }
-    void        ItemUncheck(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)               { ItemAction(ImGuiTestAction_Uncheck, ref, flags); }
-    void        ItemOpen(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)                  { ItemAction(ImGuiTestAction_Open, ref, flags); }
-    void        ItemClose(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)                 { ItemAction(ImGuiTestAction_Close, ref, flags); }
-    void        ItemInput(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)                 { ItemAction(ImGuiTestAction_Input, ref, flags); }
-    void        ItemNavActivate(ImGuiTestRef ref, ImGuiTestOpFlags flags = 0)           { ItemAction(ImGuiTestAction_NavActivate, ref, flags); }
-    bool        ItemOpenFullPath(ImGuiTestRef);
-
-    // Item/Widgets: Batch actions over an entire scope
-    void        ItemActionAll(ImGuiTestAction action, ImGuiTestRef ref_parent, const ImGuiTestActionFilter* filter = NULL);
-    void        ItemOpenAll(ImGuiTestRef ref_parent, int depth = -1, int passes = -1);
-    void        ItemCloseAll(ImGuiTestRef ref_parent, int depth = -1, int passes = -1);
-
-    // Item/Widgets: Helpers to easily set a value
-    void        ItemInputValue(ImGuiTestRef ref, int v);
-    void        ItemInputValue(ImGuiTestRef ref, float f);
-    void        ItemInputValue(ImGuiTestRef ref, const char* str);
-
-    // Item/Widgets: Drag and Mouse operations
-    void        ItemHold(ImGuiTestRef ref, float time);
-    void        ItemHoldForFrames(ImGuiTestRef ref, int frames);
-    void        ItemDragOverAndHold(ImGuiTestRef ref_src, ImGuiTestRef ref_dst);
-    void        ItemDragAndDrop(ImGuiTestRef ref_src, ImGuiTestRef ref_dst, ImGuiMouseButton button = 0);
-    void        ItemDragWithDelta(ImGuiTestRef ref_src, ImVec2 pos_delta);
-
-    // Item/Widgets: Status query
-    bool        ItemExists(ImGuiTestRef ref);
-    bool        ItemIsChecked(ImGuiTestRef ref);
-    bool        ItemIsOpened(ImGuiTestRef ref);
-    void        ItemVerifyCheckedIfAlive(ImGuiTestRef ref, bool checked);
-
-    // Helpers for Tab Bars widgets
-    void        TabClose(ImGuiTestRef ref);
-    bool        TabBarCompareOrder(ImGuiTabBar* tab_bar, const char** tab_order);
-
-    // Helpers for MenuBar and Menus widgets
-    // - e.g. MenuCheck("File/Options/Enable grid");
-    void        MenuAction(ImGuiTestAction action, ImGuiTestRef ref);
-    void        MenuActionAll(ImGuiTestAction action, ImGuiTestRef ref_parent);
-    void        MenuClick(ImGuiTestRef ref)                 { MenuAction(ImGuiTestAction_Click, ref); }
-    void        MenuCheck(ImGuiTestRef ref)                 { MenuAction(ImGuiTestAction_Check, ref); }
-    void        MenuUncheck(ImGuiTestRef ref)               { MenuAction(ImGuiTestAction_Uncheck, ref); }
-    void        MenuCheckAll(ImGuiTestRef ref_parent)       { MenuActionAll(ImGuiTestAction_Check, ref_parent); }
-    void        MenuUncheckAll(ImGuiTestRef ref_parent)     { MenuActionAll(ImGuiTestAction_Uncheck, ref_parent); }
-
-    // Helpers for Combo Boxes
-    void        ComboClick(ImGuiTestRef ref);
-    void        ComboClickAll(ImGuiTestRef ref);
-
-    // Helpers for Tables
-    void                        TableOpenContextMenu(ImGuiTestRef ref, int column_n = -1);
-    ImGuiSortDirection          TableClickHeader(ImGuiTestRef ref, const char* label, ImGuiKeyChord key_mods = 0);
-    void                        TableSetColumnEnabled(ImGuiTestRef ref, const char* label, bool enabled);
-    void                        TableResizeColumn(ImGuiTestRef ref, int column_n, float width);
-    const ImGuiTableSortSpecs*  TableGetSortSpecs(ImGuiTestRef ref);
-
-    // Viewports
-    // IMPORTANT: Those function may alter Platform state (unless using the "Mock Viewport" backend). Use carefully.
-    // Those are mostly useful to simulate OS actions and testing of viewport-specific features, may not be useful to most users.
-#ifdef IMGUI_HAS_VIEWPORT
-    //void      ViewportPlatform_SetWindowPos(ImGuiViewport* viewport, const ImVec2& pos);
-    //void      ViewportPlatform_SetWindowSize(ImGuiViewport* viewport, const ImVec2& size);
-    void        ViewportPlatform_SetWindowFocus(ImGuiViewport* viewport);
-    void        ViewportPlatform_CloseWindow(ImGuiViewport* viewport);
-#endif
-
-    // Docking
-#ifdef IMGUI_HAS_DOCK
-    void        DockClear(const char* window_name, ...);
-    void        DockInto(ImGuiTestRef src_id, ImGuiTestRef dst_id, ImGuiDir split_dir = ImGuiDir_None, bool is_outer_docking = false, ImGuiTestOpFlags flags = 0);
-    void        UndockNode(ImGuiID dock_id);
-    void        UndockWindow(const char* window_name);
-    bool        WindowIsUndockedOrStandalone(ImGuiWindow* window);
-    bool        DockIdIsUndockedOrStandalone(ImGuiID dock_id);
-    void        DockNodeHideTabBar(ImGuiDockNode* node, bool hidden);
-#endif
-
-    // Performances Measurement (use along with Dear ImGui Perf Tool)
-    void        PerfCalcRef();
-    void        PerfCapture(const char* category = NULL, const char* test_name = NULL, const char* csv_file = NULL);
-
-    // Obsolete functions
-#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
-    // Obsoleted 2022/10/11
-    ImGuiID     GetIDByInt(int n);                                      // Prefer using "$$123"
-    ImGuiID     GetIDByInt(int n, ImGuiTestRef seed_ref);
-    ImGuiID     GetIDByPtr(void* p);                                    // Prefer using "$$(ptr)0xFFFFFFFF"
-    ImGuiID     GetIDByPtr(void* p, ImGuiTestRef seed_ref);
-    // Obsoleted 2022/09/26
-    void        KeyModDown(ImGuiModFlags mods)  { KeyDown(mods); }
-    void        KeyModUp(ImGuiModFlags mods)    { KeyUp(mods); }
-    void        KeyModPress(ImGuiModFlags mods) { KeyPress(mods); }
-#endif
-
-    // [Internal]
-    // FIXME: Aim to remove this system...
-    void        ForeignWindowsHideOverPos(ImVec2 pos, ImGuiWindow** ignore_list);
-    void        ForeignWindowsUnhideAll();
-};
-
-//-------------------------------------------------------------------------
-// [SECTION] Debugging macros (IM_SUSPEND_TESTFUNC)
-//-------------------------------------------------------------------------
-
-// Debug: Temporarily suspend TestFunc to let user interactively inspect the GUI state (user will need to press the "Continue" button to resume TestFunc execution)
-#define IM_SUSPEND_TESTFUNC()               do { if (ctx->SuspendTestFunc(__FILE__, __LINE__)) return; } while (0)
-
-//-------------------------------------------------------------------------
-// [SECTION] Testing/Checking macros: IM_CHECK(), IM_ERRORF() etc.
-//-------------------------------------------------------------------------
-
-// Helpers used by IM_CHECK_OP() macros.
-// ImGuiTestEngine_GetTempStringBuilder() returns a shared instance of ImGuiTextBuffer to recycle memory allocations
-template<typename T> void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, T v) { buf->append("???"); IM_UNUSED(v); } // FIXME-TESTS: Could improve with some template magic
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, const char* v) { buf->appendf("\"%s\"", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, bool v)        { buf->append(v ? "true" : "false"); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImS8 v)        { buf->appendf("%d", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImU8 v)        { buf->appendf("%u", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImS16 v)       { buf->appendf("%hd", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImU16 v)       { buf->appendf("%hu", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImS32 v)       { buf->appendf("%d", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImU32 v)       { buf->appendf("0x%08X", v); } // Assuming ImGuiID
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImS64 v)       { buf->appendf("%lld", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImU64 v)       { buf->appendf("%llu", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, float v)       { buf->appendf("%.3f", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, double v)      { buf->appendf("%f", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImVec2 v)      { buf->appendf("(%.3f, %.3f)", v.x, v.y); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, const void* v) { buf->appendf("%p", v); }
-template<> inline void ImGuiTestEngineUtil_appendf_auto(ImGuiTextBuffer* buf, ImGuiWindow* v){ if (v) buf->appendf("\"%s\"", v->Name); else buf->append("NULL"); }
-
-// We embed every macro in a do {} while(0) statement as a trick to allow using them as regular single statement, e.g. if (XXX) IM_CHECK(A); else IM_CHECK(B)
-// We leave the IM_DEBUG_BREAK() outside of the check function to step out faster when using a debugger. It also has the benefit of being lighter than an IM_ASSERT().
-#define IM_CHECK(_EXPR)                     do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, res, #_EXPR))          { IM_DEBUG_BREAK(); } if (!res) return; } while (0)
-#define IM_CHECK_NO_RET(_EXPR)              do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, res, #_EXPR))          { IM_DEBUG_BREAK(); } } while (0)
-#define IM_CHECK_SILENT(_EXPR)              do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_SilentSuccess, res, #_EXPR)) { IM_DEBUG_BREAK(); } if (!res) return; } while (0)
-#define IM_CHECK_RETV(_EXPR,_RETV)          do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, res, #_EXPR))          { IM_DEBUG_BREAK(); } if (!res) return _RETV; } while (0)
-#define IM_CHECK_SILENT_RETV(_EXPR,_RETV)   do { bool res = (bool)(_EXPR); if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_SilentSuccess, res, #_EXPR)) { IM_DEBUG_BREAK(); } if (!res) return _RETV; } while (0)
-#define IM_ERRORF(_FMT,...)                 do { if (ImGuiTestEngine_Error(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, _FMT, __VA_ARGS__))                              { IM_DEBUG_BREAK(); } } while (0)
-#define IM_ERRORF_NOHDR(_FMT,...)           do { if (ImGuiTestEngine_Error(NULL, NULL, 0, ImGuiTestCheckFlags_None, _FMT, __VA_ARGS__))                                             { IM_DEBUG_BREAK(); } } while (0)
-
-// Those macros allow us to print out the values of both LHS and RHS expressions involved in a check.
-#define IM_CHECK_OP(_LHS, _RHS, _OP, _RETURN)                   \
-    do                                                          \
-    {                                                           \
-        auto __lhs = _LHS;  /* Cache to avoid side effects */   \
-        auto __rhs = _RHS;                                      \
-        bool __res = __lhs _OP __rhs;                           \
-        ImGuiTextBuffer* expr_buf = ImGuiTestEngine_GetTempStringBuilder(); \
-        expr_buf->append(#_LHS " [");                           \
-        ImGuiTestEngineUtil_appendf_auto(expr_buf, __lhs);      \
-        expr_buf->append("] " #_OP " " #_RHS " [");             \
-        ImGuiTestEngineUtil_appendf_auto(expr_buf, __rhs);      \
-        expr_buf->append("]");                                  \
-        if (ImGuiTestEngine_Check(__FILE__, __func__, __LINE__, ImGuiTestCheckFlags_None, __res, expr_buf->c_str())) \
-            IM_ASSERT(__res);                                   \
-        if (_RETURN && !__res)                                  \
-            return;                                             \
-    } while (0)
-
-#define IM_CHECK_STR_OP(_LHS, _RHS, _OP, _RETURN, _FLAGS)       \
-    do                                                          \
-    {                                                           \
-        bool __res;                                             \
-        if (ImGuiTestEngine_CheckStrOp(__FILE__, __func__, __LINE__, _FLAGS, #_OP, #_LHS, _LHS, #_RHS, _RHS, &__res)) \
-            IM_ASSERT(__res);                                   \
-        if (_RETURN && !__res)                                  \
-            return;                                             \
-    } while (0)
-
-// Scalar compares
-#define IM_CHECK_EQ(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, ==, true)   // Equal
-#define IM_CHECK_NE(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, !=, true)   // Not Equal
-#define IM_CHECK_LT(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, < , true)   // Less Than
-#define IM_CHECK_LE(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, <=, true)   // Less or Equal
-#define IM_CHECK_GT(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, > , true)   // Greater Than
-#define IM_CHECK_GE(_LHS, _RHS)                     IM_CHECK_OP(_LHS, _RHS, >=, true)   // Greater or Equal
-
-// Scalar compares, without return on failure
-#define IM_CHECK_EQ_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, ==, false)  // Equal
-#define IM_CHECK_NE_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, !=, false)  // Not Equal
-#define IM_CHECK_LT_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, < , false)  // Less Than
-#define IM_CHECK_LE_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, <=, false)  // Less or Equal
-#define IM_CHECK_GT_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, > , false)  // Greater Than
-#define IM_CHECK_GE_NO_RET(_LHS, _RHS)              IM_CHECK_OP(_LHS, _RHS, >=, false)  // Greater or Equal
-
-// String compares
-#define IM_CHECK_STR_EQ(_LHS, _RHS)                 IM_CHECK_STR_OP(_LHS, _RHS, ==, true, ImGuiTestCheckFlags_None)
-#define IM_CHECK_STR_NE(_LHS, _RHS)                 IM_CHECK_STR_OP(_LHS, _RHS, !=, true, ImGuiTestCheckFlags_None)
-#define IM_CHECK_STR_EQ_NO_RET(_LHS, _RHS)          IM_CHECK_STR_OP(_LHS, _RHS, ==, false, ImGuiTestCheckFlags_None)
-#define IM_CHECK_STR_NE_NO_RET(_LHS, _RHS)          IM_CHECK_STR_OP(_LHS, _RHS, !=, false, ImGuiTestCheckFlags_None)
-#define IM_CHECK_STR_EQ_SILENT(_LHS, _RHS)          IM_CHECK_STR_OP(_LHS, _RHS, ==, true, ImGuiTestCheckFlags_SilentSuccess)
-
-// Floating point compares
-#define IM_CHECK_FLOAT_EQ_EPS(_LHS, _RHS)           IM_CHECK_LE(ImFabs(_LHS - (_RHS)), FLT_EPSILON)   // Float Equal
-#define IM_CHECK_FLOAT_NEAR(_LHS, _RHS, _EPS)       IM_CHECK_LE(ImFabs(_LHS - (_RHS)), _EPS)
-#define IM_CHECK_FLOAT_NEAR_NO_RET(_LHS, _RHS, _E)  IM_CHECK_LE_NO_RET(ImFabs(_LHS - (_RHS)), _E)
-
-//-------------------------------------------------------------------------
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#elif defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif