diff options
Diffstat (limited to 'vendor/zgui/libs/imgui_test_engine/imgui_te_engine.h')
| -rw-r--r-- | vendor/zgui/libs/imgui_test_engine/imgui_te_engine.h | 429 |
1 files changed, 0 insertions, 429 deletions
diff --git a/vendor/zgui/libs/imgui_test_engine/imgui_te_engine.h b/vendor/zgui/libs/imgui_test_engine/imgui_te_engine.h deleted file mode 100644 index c5a585d..0000000 --- a/vendor/zgui/libs/imgui_test_engine/imgui_te_engine.h +++ /dev/null @@ -1,429 +0,0 @@ -// dear imgui test engine -// (core) -// This is the interface that your initial setup (app init, main loop) will mostly be using. -// Actual tests will mostly use the interface of imgui_te_context.h - -#pragma once - -#include "imgui.h" -#include "imgui_internal.h" // ImPool<>, ImRect, ImGuiItemStatusFlags, ImFormatString -#include "imgui_te_utils.h" // ImFuncPtr -#include "imgui_capture_tool.h" // ImGuiScreenCaptureFunc - -//------------------------------------------------------------------------- -// Forward Declarations -//------------------------------------------------------------------------- - -struct ImGuiTest; // Data for a test registered with IM_REGISTER_TEST() -struct ImGuiTestContext; // Context while a test is running -struct ImGuiTestCoroutineInterface; // Interface to expose coroutine functions (imgui_te_coroutine provides a default implementation for C++11 using std::thread, but you may use your own) -struct ImGuiTestEngine; // Test engine instance -struct ImGuiTestEngineIO; // Test engine public I/O -struct ImGuiTestItemInfo; // Info queried from item (id, geometry, status flags, debug label) -struct ImGuiTestItemList; // A list of items -struct ImGuiTestInputs; // Simulated user inputs (will be fed into ImGuiIO by the test engine) -struct ImGuiTestRunTask; // A queued test (test + runflags) - -typedef int ImGuiTestFlags; // Flags: See ImGuiTestFlags_ -typedef int ImGuiTestCheckFlags; // Flags: See ImGuiTestCheckFlags_ -typedef int ImGuiTestLogFlags; // Flags: See ImGuiTestLogFlags_ -typedef int ImGuiTestRunFlags; // Flags: See ImGuiTestRunFlags_ - -enum ImGuiTestActiveFunc : int; -enum ImGuiTestGroup : int; -enum ImGuiTestRunSpeed : int; -enum ImGuiTestStatus : int; -enum ImGuiTestVerboseLevel : int; -enum ImGuiTestEngineExportFormat : int; - -//------------------------------------------------------------------------- -// Types -//------------------------------------------------------------------------- - -// Stored in ImGuiTestContext: where we are currently running GuiFunc or TestFunc -enum ImGuiTestActiveFunc : int -{ - ImGuiTestActiveFunc_None, - ImGuiTestActiveFunc_GuiFunc, - ImGuiTestActiveFunc_TestFunc -}; - -enum ImGuiTestRunSpeed : int -{ - ImGuiTestRunSpeed_Fast = 0, // Run tests as fast as possible (teleport mouse, skip delays, etc.) - ImGuiTestRunSpeed_Normal = 1, // Run tests at human watchable speed (for debugging) - ImGuiTestRunSpeed_Cinematic = 2, // Run tests with pauses between actions (for e.g. tutorials) - ImGuiTestRunSpeed_COUNT -}; - -enum ImGuiTestVerboseLevel : int -{ - ImGuiTestVerboseLevel_Silent = 0, // -v0 - ImGuiTestVerboseLevel_Error = 1, // -v1 - ImGuiTestVerboseLevel_Warning = 2, // -v2 - ImGuiTestVerboseLevel_Info = 3, // -v3 - ImGuiTestVerboseLevel_Debug = 4, // -v4 - ImGuiTestVerboseLevel_Trace = 5, - ImGuiTestVerboseLevel_COUNT -}; - -// Test status (stored in ImGuiTest) -enum ImGuiTestStatus : int -{ - ImGuiTestStatus_Unknown = -1, - ImGuiTestStatus_Success = 0, - ImGuiTestStatus_Queued = 1, - ImGuiTestStatus_Running = 2, - ImGuiTestStatus_Error = 3, - ImGuiTestStatus_Suspended = 4, - ImGuiTestStatus_COUNT -}; - -// Test group: this is mostly used to categorize tests in our testing UI. (Stored in ImGuiTest) -enum ImGuiTestGroup : int -{ - ImGuiTestGroup_Unknown = -1, - ImGuiTestGroup_Tests = 0, - ImGuiTestGroup_Perfs = 1, - ImGuiTestGroup_COUNT -}; - -// Flags (stored in ImGuiTest) -enum ImGuiTestFlags_ -{ - ImGuiTestFlags_None = 0, - ImGuiTestFlags_NoGuiWarmUp = 1 << 0, // Disable running the GUI func for 2 frames before starting test code. For tests which absolutely need to start before GuiFunc. - ImGuiTestFlags_NoAutoFinish = 1 << 1, // By default, tests with no TestFunc (only a GuiFunc) will end after warmup. Setting this require test to call ctx->Finish(). - ImGuiTestFlags_NoRecoveryWarnings = 1 << 2 // Disable state recovery warnings (missing End/Pop calls etc.) for tests which may rely on those. - //ImGuiTestFlags_RequireViewports = 1 << 10 -}; - -// Flags for IM_CHECK* macros. -enum ImGuiTestCheckFlags_ -{ - ImGuiTestCheckFlags_None = 0, - ImGuiTestCheckFlags_SilentSuccess = 1 << 0 -}; - -// Flags for ImGuiTestContext::Log* functions. -enum ImGuiTestLogFlags_ -{ - ImGuiTestLogFlags_None = 0, - ImGuiTestLogFlags_NoHeader = 1 << 0 // Do not display frame count and depth padding -}; - -enum ImGuiTestRunFlags_ -{ - ImGuiTestRunFlags_None = 0, - ImGuiTestRunFlags_GuiFuncDisable = 1 << 0, // Used internally to temporarily disable the GUI func (at the end of a test, etc) - ImGuiTestRunFlags_GuiFuncOnly = 1 << 1, // Set when user selects "Run GUI func" - ImGuiTestRunFlags_NoSuccessMsg = 1 << 2, - ImGuiTestRunFlags_EnableRawInputs = 1 << 3, // Disable input submission to let test submission raw input event (in order to test e.g. IO queue) - ImGuiTestRunFlags_RunFromGui = 1 << 4, // Test ran manually from GUI, will disable watchdog. - ImGuiTestRunFlags_RunFromCommandLine= 1 << 5, // Test queued from command-line. - - // Flags for ImGuiTestContext::RunChildTest() - ImGuiTestRunFlags_NoError = 1 << 10, - ImGuiTestRunFlags_ShareVars = 1 << 11, // Share generic vars and custom vars between child and parent tests (custom vars need to be same type) - ImGuiTestRunFlags_ShareTestContext = 1 << 12, // Share ImGuiTestContext instead of creating a new one (unsure what purpose this may be useful for yet) - // TODO: Add GuiFunc options -}; - -//------------------------------------------------------------------------- -// Functions -//------------------------------------------------------------------------- - -// Hooks for core imgui/ library (generally called via macros) -extern void ImGuiTestEngineHook_ItemAdd(ImGuiContext* ui_ctx, ImGuiID id, const ImRect& bb, const ImGuiLastItemData* item_data); -#if IMGUI_VERSION_NUM < 18934 -extern void ImGuiTestEngineHook_ItemAdd(ImGuiContext* ui_ctx, const ImRect& bb, ImGuiID id); -#endif -#ifdef IMGUI_HAS_IMSTR -extern void ImGuiTestEngineHook_ItemInfo(ImGuiContext* ui_ctx, ImGuiID id, ImStrv label, ImGuiItemStatusFlags flags); -#else -extern void ImGuiTestEngineHook_ItemInfo(ImGuiContext* ui_ctx, ImGuiID id, const char* label, ImGuiItemStatusFlags flags); -#endif -extern void ImGuiTestEngineHook_Log(ImGuiContext* ui_ctx, const char* fmt, ...); -extern const char* ImGuiTestEngine_FindItemDebugLabel(ImGuiContext* ui_ctx, ImGuiID id); - -// Functions (generally called via IM_CHECK() macros) -IMGUI_API bool ImGuiTestEngine_Check(const char* file, const char* func, int line, ImGuiTestCheckFlags flags, bool result, const char* expr); -IMGUI_API bool ImGuiTestEngine_CheckStrOp(const char* file, const char* func, int line, ImGuiTestCheckFlags flags, const char* op, const char* lhs_var, const char* lhs_value, const char* rhs_var, const char* rhs_value, bool* out_result); -IMGUI_API bool ImGuiTestEngine_Error(const char* file, const char* func, int line, ImGuiTestCheckFlags flags, const char* fmt, ...); -IMGUI_API void ImGuiTestEngine_AssertLog(const char* expr, const char* file, const char* function, int line); -IMGUI_API ImGuiTextBuffer* ImGuiTestEngine_GetTempStringBuilder(); - -//------------------------------------------------------------------------- -// ImGuiTestEngine API -//------------------------------------------------------------------------- - -// Functions: Initialization -IMGUI_API ImGuiTestEngine* ImGuiTestEngine_CreateContext(); // Create test engine -IMGUI_API void ImGuiTestEngine_DestroyContext(ImGuiTestEngine* engine); // Destroy test engine. Call after ImGui::DestroyContext() so test engine specific ini data gets saved. -IMGUI_API void ImGuiTestEngine_Start(ImGuiTestEngine* engine, ImGuiContext* ui_ctx); // Bind to a dear imgui context. Start coroutine. -IMGUI_API void ImGuiTestEngine_Stop(ImGuiTestEngine* engine); // Stop coroutine and export if any. (Unbind will lazily happen on context shutdown) -IMGUI_API void ImGuiTestEngine_PostSwap(ImGuiTestEngine* engine); // Call every frame after framebuffer swap, will process screen capture and call test_io.ScreenCaptureFunc() -IMGUI_API ImGuiTestEngineIO& ImGuiTestEngine_GetIO(ImGuiTestEngine* engine); - -// Macros: Register Test -#define IM_REGISTER_TEST(_ENGINE, _CATEGORY, _NAME) ImGuiTestEngine_RegisterTest(_ENGINE, _CATEGORY, _NAME, __FILE__, __LINE__) -IMGUI_API ImGuiTest* ImGuiTestEngine_RegisterTest(ImGuiTestEngine* engine, const char* category, const char* name, const char* src_file = NULL, int src_line = 0); // Prefer calling IM_REGISTER_TEST() - -// Functions: Main -IMGUI_API void ImGuiTestEngine_QueueTest(ImGuiTestEngine* engine, ImGuiTest* test, ImGuiTestRunFlags run_flags = 0); -IMGUI_API void ImGuiTestEngine_QueueTests(ImGuiTestEngine* engine, ImGuiTestGroup group, const char* filter = NULL, ImGuiTestRunFlags run_flags = 0); -IMGUI_API bool ImGuiTestEngine_TryAbortEngine(ImGuiTestEngine* engine); -IMGUI_API void ImGuiTestEngine_AbortCurrentTest(ImGuiTestEngine* engine); -IMGUI_API ImGuiTest* ImGuiTestEngine_FindTestByName(ImGuiTestEngine* engine, const char* category, const char* name); - -// Functions: Status Queries -// FIXME: Clarify API to avoid function calls vs raw bools in ImGuiTestEngineIO -IMGUI_API bool ImGuiTestEngine_IsTestQueueEmpty(ImGuiTestEngine* engine); -IMGUI_API bool ImGuiTestEngine_IsUsingSimulatedInputs(ImGuiTestEngine* engine); -IMGUI_API void ImGuiTestEngine_GetResult(ImGuiTestEngine* engine, int& count_tested, int& success_count); -IMGUI_API void ImGuiTestEngine_GetTestList(ImGuiTestEngine* engine, ImVector<ImGuiTest*>* out_tests); -IMGUI_API void ImGuiTestEngine_GetTestQueue(ImGuiTestEngine* engine, ImVector<ImGuiTestRunTask>* out_tests); - -// Functions: Crash Handling -// Ensure past test results are properly exported even if application crash during a test. -IMGUI_API void ImGuiTestEngine_InstallDefaultCrashHandler(); // Install default crash handler (if you don't have one) -IMGUI_API void ImGuiTestEngine_CrashHandler(); // Default crash handler, should be called from a custom crash handler if such exists - -//----------------------------------------------------------------------------- -// IO structure to configure the test engine -//----------------------------------------------------------------------------- - -// Function bound to right-clicking on a test and selecting "Open source" in the UI -// - Easy: you can make this function call OS shell to "open" the file (e.g. ImOsOpenInShell() helper). -// - Better: bind this function to a custom setup which can pass line number to a text editor (e.g. see 'imgui_test_suite/tools/win32_open_with_sublime.cmd' example) -typedef void (ImGuiTestEngineSrcFileOpenFunc)(const char* filename, int line_no, void* user_data); - -struct IMGUI_API ImGuiTestEngineIO -{ - //------------------------------------------------------------------------- - // Functions - //------------------------------------------------------------------------- - - // Options: Functions - ImGuiTestCoroutineInterface* CoroutineFuncs = NULL; // (Required) Coroutine functions (see imgui_te_coroutines.h) - ImFuncPtr(ImGuiTestEngineSrcFileOpenFunc) SrcFileOpenFunc = NULL; // (Optional) To open source files from test engine UI - ImFuncPtr(ImGuiScreenCaptureFunc) ScreenCaptureFunc = NULL; // (Optional) To capture graphics output (application _MUST_ call ImGuiTestEngine_PostSwap() function after swapping is framebuffer) - void* SrcFileOpenUserData = NULL; // (Optional) User data for SrcFileOpenFunc - void* ScreenCaptureUserData = NULL; // (Optional) User data for ScreenCaptureFunc - - // Options: Main - bool ConfigSavedSettings = true; // Load/Save settings in main context .ini file. - ImGuiTestRunSpeed ConfigRunSpeed = ImGuiTestRunSpeed_Fast; // Run tests in fast/normal/cinematic mode - bool ConfigStopOnError = false; // Stop queued tests on test error - bool ConfigBreakOnError = false; // Break debugger on test error by calling IM_DEBUG_BREAK() - bool ConfigKeepGuiFunc = false; // Keep test GUI running at the end of the test - ImGuiTestVerboseLevel ConfigVerboseLevel = ImGuiTestVerboseLevel_Warning; - ImGuiTestVerboseLevel ConfigVerboseLevelOnError = ImGuiTestVerboseLevel_Info; - bool ConfigLogToTTY = false; - bool ConfigLogToDebugger = false; - bool ConfigRestoreFocusAfterTests = true;// Restore focus back after running tests - bool ConfigCaptureEnabled = true; // Master enable flags for capturing and saving captures. Disable to avoid e.g. lengthy saving of large PNG files. - bool ConfigCaptureOnError = false; - bool ConfigNoThrottle = false; // Disable vsync for performance measurement or fast test running - bool ConfigMouseDrawCursor = true; // Enable drawing of Dear ImGui software mouse cursor when running tests - float ConfigFixedDeltaTime = 0.0f; // Use fixed delta time instead of calculating it from wall clock - int PerfStressAmount = 1; // Integer to scale the amount of items submitted in test - char GitBranchName[64] = ""; // e.g. fill in branch name (e.g. recorded in perf samples .csv) - - // Options: Speed of user simulation - float MouseSpeed = 600.0f; // Mouse speed (pixel/second) when not running in fast mode - float MouseWobble = 0.25f; // (0.0f..1.0f) How much wobble to apply to the mouse (pixels per pixel of move distance) when not running in fast mode - float ScrollSpeed = 1400.0f; // Scroll speed (pixel/second) when not running in fast mode - float TypingSpeed = 20.0f; // Char input speed (characters/second) when not running in fast mode - float ActionDelayShort = 0.15f; // Time between short actions - float ActionDelayStandard = 0.40f; // Time between most actions - - // Options: Screen/video capture - char VideoCaptureEncoderPath[256] = ""; // Video encoder executable path, e.g. "path/to/ffmpeg.exe". - char VideoCaptureEncoderParams[256] = "";// Video encoder parameters for .MP4 captures, e.g. see IMGUI_CAPTURE_DEFAULT_VIDEO_PARAMS_FOR_FFMPEG - char GifCaptureEncoderParams[512] = ""; // Video encoder parameters for .GIF captures, e.g. see IMGUI_CAPTURE_DEFAULT_GIF_PARAMS_FOR_FFMPEG - char VideoCaptureExtension[8] = ".mp4"; // Video file extension (default, may be overridden by test). - - // Options: Watchdog. Set values to FLT_MAX to disable. - // Interactive GUI applications that may be slower tend to use higher values. - float ConfigWatchdogWarning = 30.0f; // Warn when a test exceed this time (in second) - float ConfigWatchdogKillTest = 60.0f; // Attempt to stop running a test when exceeding this time (in second) - float ConfigWatchdogKillApp = FLT_MAX; // Stop application when exceeding this time (in second) - - // Options: Export - // While you can manually call ImGuiTestEngine_Export(), registering filename/format here ensure the crash handler will always export if application crash. - const char* ExportResultsFilename = NULL; - ImGuiTestEngineExportFormat ExportResultsFormat = (ImGuiTestEngineExportFormat)0; - - // Options: Sanity Checks - bool CheckDrawDataIntegrity = false; // Check ImDrawData integrity (buffer count, etc.). Currently cheap but may become a slow operation. - - //------------------------------------------------------------------------- - // Output - //------------------------------------------------------------------------- - - // Output: State of test engine - bool IsRunningTests = false; - bool IsRequestingMaxAppSpeed = false; // When running in fast mode: request app to skip vsync or even skip rendering if it wants - bool IsCapturing = false; // Capture is in progress -}; - -//------------------------------------------------------------------------- -// ImGuiTestItemInfo -//------------------------------------------------------------------------- - -// Information about a given item or window, result of an ItemInfo() or WindowInfo() query -struct ImGuiTestItemInfo -{ - int RefCount : 8; // User can increment this if they want to hold on the result pointer across frames, otherwise the task will be GC-ed. - unsigned int NavLayer : 1; // Nav layer of the item (ImGuiNavLayer) - int Depth : 16; // Depth from requested parent id. 0 == ID is immediate child of requested parent id. - int TimestampMain = -1; // Timestamp of main result (all fields) - int TimestampStatus = -1; // Timestamp of StatusFlags - ImGuiID ID = 0; // Item ID - ImGuiID ParentID = 0; // Item Parent ID (value at top of the ID stack) - ImGuiWindow* Window = NULL; // Item Window - ImRect RectFull = ImRect(); // Item Rectangle - ImRect RectClipped = ImRect(); // Item Rectangle (clipped with window->ClipRect at time of item submission) - ImGuiItemFlags InFlags = 0; // Item flags - ImGuiItemStatusFlags StatusFlags = 0; // Item Status flags (fully updated for some items only, compare TimestampStatus to FrameCount) - char DebugLabel[32] = {}; // Shortened label for debugging purpose - - ImGuiTestItemInfo() { RefCount = 0; NavLayer = 0; Depth = 0; } - bool IsEmpty() const { return ID == 0; } -}; - -// Result of an GatherItems() query -struct IMGUI_API ImGuiTestItemList -{ - ImPool<ImGuiTestItemInfo> Pool; - - void Clear() { Pool.Clear(); } - void Reserve(int capacity) { Pool.Reserve(capacity); } - int GetSize() const { return Pool.GetMapSize(); } - const ImGuiTestItemInfo* GetByIndex(int n) { return Pool.GetByIndex(n); } - const ImGuiTestItemInfo* GetByID(ImGuiID id) { return Pool.GetByKey(id); } - - // For range-for - size_t size() const { return (size_t)Pool.GetMapSize(); } - const ImGuiTestItemInfo* begin() const { return Pool.Buf.begin(); } - const ImGuiTestItemInfo* end() const { return Pool.Buf.end(); } - const ImGuiTestItemInfo* operator[] (size_t n) { return &Pool.Buf[(int)n]; } -}; - -//------------------------------------------------------------------------- -// ImGuiTestLog: store textual output of one given Test. -//------------------------------------------------------------------------- - -struct IMGUI_API ImGuiTestLogLineInfo -{ - ImGuiTestVerboseLevel Level; - int LineOffset; -}; - -struct IMGUI_API ImGuiTestLog -{ - ImGuiTextBuffer Buffer; - ImVector<ImGuiTestLogLineInfo> LineInfo; - int CountPerLevel[ImGuiTestVerboseLevel_COUNT] = {}; - - // Functions - ImGuiTestLog() {} - bool IsEmpty() const { return Buffer.empty(); } - void Clear(); - - // Extract log contents filtered per log-level. - // Output: - // - If 'buffer != NULL': all extracted lines are appended to 'buffer'. Use 'buffer->c_str()' on your side to obtain the text. - // - Return value: number of lines extracted (should be equivalent to number of '\n' inside buffer->c_str()). - // - You may call the function with buffer == NULL to only obtain a count without getting the data. - // Verbose levels are inclusive: - // - To get ONLY Error: Use level_min == ImGuiTestVerboseLevel_Error, level_max = ImGuiTestVerboseLevel_Error - // - To get ONLY Error and Warnings: Use level_min == ImGuiTestVerboseLevel_Error, level_max = ImGuiTestVerboseLevel_Warning - // - To get All Errors, Warnings, Debug... Use level_min == ImGuiTestVerboseLevel_Error, level_max = ImGuiTestVerboseLevel_Trace - int ExtractLinesForVerboseLevels(ImGuiTestVerboseLevel level_min, ImGuiTestVerboseLevel level_max, ImGuiTextBuffer* out_buffer); - - // [Internal] - void UpdateLineOffsets(ImGuiTestEngineIO* engine_io, ImGuiTestVerboseLevel level, const char* start); -}; - -//------------------------------------------------------------------------- -// ImGuiTest -//------------------------------------------------------------------------- - -typedef void (ImGuiTestGuiFunc)(ImGuiTestContext* ctx); -typedef void (ImGuiTestTestFunc)(ImGuiTestContext* ctx); - -// Wraps a placement new of a given type (where 'buffer' is the allocated memory) -typedef void (ImGuiTestVarsConstructor)(void* buffer); -typedef void (ImGuiTestVarsPostConstructor)(ImGuiTestContext* ctx, void* ptr, void* fn); -typedef void (ImGuiTestVarsDestructor)(void* ptr); - -// Storage for the output of a test run -struct IMGUI_API ImGuiTestOutput -{ - ImGuiTestStatus Status = ImGuiTestStatus_Unknown; - ImGuiTestLog Log; - ImU64 StartTime = 0; - ImU64 EndTime = 0; -}; - -// Storage for one test -struct IMGUI_API ImGuiTest -{ - // Test Definition - const char* Category = NULL; // Literal, not owned - const char* Name = NULL; // Literal, generally not owned unless NameOwned=true - ImGuiTestGroup Group = ImGuiTestGroup_Unknown; // Coarse groups: 'Tests' or 'Perf' - bool NameOwned = false; // - const char* SourceFile = NULL; // __FILE__ - int SourceLine = 0; // __LINE__ - int SourceLineEnd = 0; // Calculated by ImGuiTestEngine_StartCalcSourceLineEnds() - int ArgVariant = 0; // User parameter. Generally we use it to run variations of a same test by sharing GuiFunc/TestFunc - ImGuiTestFlags Flags = ImGuiTestFlags_None; // See ImGuiTestFlags_ - ImFuncPtr(ImGuiTestGuiFunc) GuiFunc = NULL; // GUI function (optional if your test are running over an existing GUI application) - ImFuncPtr(ImGuiTestTestFunc) TestFunc = NULL; // Test function - void* UserData = NULL; // General purpose user data (if assigning capturing lambdas on GuiFunc/TestFunc you may not need to use this) - //ImVector<ImGuiTestRunTask> Dependencies; // Registered via AddDependencyTest(), ran automatically before our test. This is a simpler wrapper to calling ctx->RunChildTest() - - // Last Test Output/Status - // (this is the only part that may change after registration) - ImGuiTestOutput Output; - - // User variables (which are instantiated when running the test) - // Setup after test registration with SetVarsDataType<>(), access instance during test with GetVars<>(). - // This is mostly useful to communicate between GuiFunc and TestFunc. If you don't use both you may not want to use it! - size_t VarsSize = 0; - ImGuiTestVarsConstructor* VarsConstructor = NULL; - ImGuiTestVarsPostConstructor* VarsPostConstructor = NULL; // To override constructor default (in case the default are problematic on the first GuiFunc frame) - void* VarsPostConstructorUserFn = NULL; - ImGuiTestVarsDestructor* VarsDestructor = NULL; - - // Functions - ImGuiTest() {} - ~ImGuiTest(); - - void SetOwnedName(const char* name); - - template <typename T> - void SetVarsDataType(void(*post_initialize)(ImGuiTestContext* ctx, T& vars) = NULL) - { - VarsSize = sizeof(T); - VarsConstructor = [](void* ptr) { IM_PLACEMENT_NEW(ptr) T; }; - VarsDestructor = [](void* ptr) { IM_UNUSED(ptr); reinterpret_cast<T*>(ptr)->~T(); }; - if (post_initialize != NULL) - { - VarsPostConstructorUserFn = (void*)post_initialize; - VarsPostConstructor = [](ImGuiTestContext* ctx, void* ptr, void* fn) { ((void (*)(ImGuiTestContext*, T&))(fn))(ctx, *(T*)ptr); }; - } - } -}; - -// Stored in test queue -struct IMGUI_API ImGuiTestRunTask -{ - ImGuiTest* Test = NULL; - ImGuiTestRunFlags RunFlags = ImGuiTestRunFlags_None; -}; - -//------------------------------------------------------------------------- |