From 1f9b827badb2de4c4eaae11c0d02242ec90af7f6 Mon Sep 17 00:00:00 2001 From: Nic Gaffney Date: Mon, 13 Oct 2025 01:19:27 -0500 Subject: Updating to zig 0.15.1 --- .../zgui/libs/imgui_test_engine/imgui_te_context.h | 616 --------------------- 1 file changed, 616 deletions(-) delete mode 100644 vendor/zgui/libs/imgui_test_engine/imgui_te_context.h (limited to 'vendor/zgui/libs/imgui_test_engine/imgui_te_context.h') 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 -#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(). 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 Clipboard; // Private clipboard for the test instance - ImVector 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 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 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 -- cgit v1.2.3