1 files changed, 255 insertions, 0 deletions
diff --git a/vendor/zgui/src/te.zig b/vendor/zgui/src/te.zig
new file mode 100644
index 0000000..efd1eab
--- /dev/null
+++ b/vendor/zgui/src/te.zig
@@ -0,0 +1,255 @@
+const std = @import("std");
+const zgui = @import("gui.zig");
+const te_enabled = @import("zgui_options").with_te;
+
+pub const Actions = enum(c_int) {
+    unknown = 0,
+    /// Move mouse
+    hover,
+    /// Move mouse and click
+    click,
+    /// Move mouse and double-click
+    double_click,
+    /// Check item if unchecked (Checkbox, MenuItem or any widget reporting ImGuiItemStatusFlags_Checkable)
+    check,
+    /// Uncheck item if checked
+    uncheck,
+    /// Open item if closed (TreeNode, BeginMenu or any widget reporting ImGuiItemStatusFlags_Openable)
+    open,
+    /// Close item if opened
+    close,
+    /// Start text inputing into a field (e.g. CTRL+Click on Drags/Slider, click on InputText etc.)
+    input,
+    /// Activate item with navigation
+    nav_activate,
+};
+
+pub const TestRunFlags = packed struct(c_int) {
+    /// Used internally to temporarily disable the GUI func (at the end of a test, etc)
+    gui_func_disable: bool = false,
+    /// Set when user selects "Run GUI func"
+    gui_func_only: bool = false,
+    no_success_mgs: bool = false,
+    no_stop_on_error: bool = false,
+    no_break_on_error: bool = false,
+    /// Disable input submission to let test submission raw input event (in order to test e.g. IO queue)
+    enable_raw_inputs: bool = false,
+    manual_run: bool = false,
+    command_line: bool = false,
+    _padding: u24 = 0,
+};
+
+pub const TestOpFlags = packed struct(c_int) {
+    // 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()
+    no_check_hovered_id: bool = false,
+    /// Don't abort/error e.g. if the item cannot be found or the operation doesn't succeed.
+    no_error: bool = false,
+    /// Don't focus window when aiming at an item
+    no_focus_window: bool = false,
+    /// Disable automatically uncollapsing windows (useful when specifically testing Collapsing behaviors)
+    no_auto_uncollapse: bool = false,
+    /// 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.
+    no_auto_open_full_path: bool = false,
+    /// Used by recursing functions to indicate a second attempt
+    is_second_attempt: bool = false,
+    move_to_edge_l: bool = false, // Simple Dumb aiming helpers to test widget that care about clicking position. May need to replace will better functionalities.
+    move_to_edge_r: bool = false,
+    move_to_edge_u: bool = false,
+    move_to_edge_d: bool = false,
+    _padding: u22 = 0,
+};
+
+pub const CheckFlags = packed struct(c_int) {
+    silent_success: bool = false,
+    _padding: u31 = 0,
+};
+
+pub const RunSpeed = enum(c_int) {
+    /// Run tests as fast as possible (teleport mouse, skip delays, etc.)
+    fast = 0,
+    /// Run tests at human watchable speed (for debugging)
+    normal = 1,
+    /// Run tests with pauses between actions (for e.g. tutorials)
+    cinematic = 2,
+};
+
+pub const TestGroup = enum(c_int) {
+    unknown = -1,
+    tests = 0,
+    perfs = 1,
+};
+
+pub const Test = anyopaque;
+
+pub const TestEngine = opaque {
+    pub fn registerTest(
+        engine: *TestEngine,
+        category: [:0]const u8,
+        name: [:0]const u8,
+        src: std.builtin.SourceLocation,
+        comptime Callbacks: type,
+    ) *Test {
+        return zguiTe_RegisterTest(
+            engine,
+            category.ptr,
+            name.ptr,
+            src.file.ptr,
+            @intCast(src.line),
+            if (std.meta.hasFn(Callbacks, "gui"))
+                struct {
+                    fn f(context: *TestContext) callconv(.C) void {
+                        Callbacks.gui(context) catch undefined;
+                    }
+                }.f
+            else
+                null,
+            if (std.meta.hasFn(Callbacks, "run"))
+                struct {
+                    fn f(context: *TestContext) callconv(.C) void {
+                        Callbacks.run(context) catch undefined;
+                    }
+                }.f
+            else
+                null,
+        );
+    }
+
+    pub const showTestEngineWindows = zguiTe_ShowTestEngineWindows;
+    extern fn zguiTe_ShowTestEngineWindows(engine: *TestEngine, p_open: ?*bool) void;
+
+    pub const setRunSpeed = zguiTe_EngineSetRunSpeed;
+    extern fn zguiTe_EngineSetRunSpeed(engine: *TestEngine, speed: RunSpeed) void;
+
+    pub const stop = zguiTe_Stop;
+    extern fn zguiTe_Stop(engine: *TestEngine) void;
+
+    pub const tryAbortEngine = zguiTe_TryAbortEngine;
+    extern fn zguiTe_TryAbortEngine(engine: *TestEngine) void;
+
+    pub const postSwap = zguiTe_PostSwap;
+    extern fn zguiTe_PostSwap(engine: *TestEngine) void;
+
+    pub const isTestQueueEmpty = zguiTe_IsTestQueueEmpty;
+    extern fn zguiTe_IsTestQueueEmpty(engine: *TestEngine) bool;
+
+    pub const getResult = zguiTe_GetResult;
+    extern fn zguiTe_GetResult(engine: *TestEngine, count_tested: *c_int, count_success: *c_int) void;
+
+    pub const printResultSummary = zguiTe_PrintResultSummary;
+    extern fn zguiTe_PrintResultSummary(engine: *TestEngine) void;
+
+    pub fn queueTests(engine: *TestEngine, group: TestGroup, filter_str: [:0]const u8, run_flags: TestRunFlags) void {
+        zguiTe_QueueTests(engine, group, filter_str.ptr, run_flags);
+    }
+    extern fn zguiTe_QueueTests(engine: *TestEngine, group: TestGroup, filter_str: [*]const u8, run_flags: TestRunFlags) void;
+
+    pub fn exportJunitResult(engine: *TestEngine, filename: [:0]const u8) void {
+        zguiTe_EngineExportJunitResult(engine, filename.ptr);
+    }
+    extern fn zguiTe_EngineExportJunitResult(engine: *TestEngine, filename: [*]const u8) void;
+};
+
+pub const TestContext = opaque {
+    pub fn setRef(ctx: *TestContext, ref: [:0]const u8) void {
+        return zguiTe_ContextSetRef(ctx, ref.ptr);
+    }
+
+    pub fn windowFocus(ctx: *TestContext, ref: [:0]const u8) void {
+        return zguiTe_ContextWindowFocus(ctx, ref.ptr);
+    }
+
+    pub fn yield(ctx: *TestContext, frame_count: i32) void {
+        return zguiTe_ContextYield(ctx, frame_count);
+    }
+
+    pub fn itemAction(ctx: *TestContext, action: Actions, ref: [:0]const u8, flags: TestOpFlags, action_arg: ?*anyopaque) void {
+        return zguiTe_ContextItemAction(ctx, action, ref.ptr, flags, action_arg);
+    }
+
+    pub fn itemInputStrValue(ctx: *TestContext, ref: [:0]const u8, value: [:0]const u8) void {
+        return zguiTe_ContextItemInputStrValue(ctx, ref.ptr, value.ptr);
+    }
+
+    pub fn itemInputIntValue(ctx: *TestContext, ref: [:0]const u8, value: i32) void {
+        return zguiTe_ContextItemInputIntValue(ctx, ref.ptr, value);
+    }
+
+    pub fn itemInputFloatValue(ctx: *TestContext, ref: [:0]const u8, value: f32) void {
+        return zguiTe_ContextItemInputFloatValue(ctx, ref.ptr, value);
+    }
+
+    pub fn menuAction(ctx: *TestContext, action: Actions, ref: [*]const u8) void {
+        return zguiTe_ContextMenuAction(ctx, action, ref);
+    }
+
+    pub fn dragAndDrop(ctx: *TestContext, ref_src: [:0]const u8, ref_dst: [:0]const u8, button: zgui.MouseButton) void {
+        return zguiTe_ContextDragAndDrop(ctx, ref_src.ptr, ref_dst.ptr, button);
+    }
+
+    pub fn keyDown(ctx: *TestContext, key_chord: c_int) void {
+        return zguiTe_ContextKeyDown(ctx, key_chord);
+    }
+
+    pub fn keyUp(ctx: *TestContext, key_chord: c_int) void {
+        return zguiTe_ContextKeyUp(ctx, key_chord);
+    }
+
+    extern fn zguiTe_ContextSetRef(ctx: *TestContext, ref: [*]const u8) void;
+    extern fn zguiTe_ContextWindowFocus(ctx: *TestContext, ref: [*]const u8) void;
+    extern fn zguiTe_ContextYield(ctx: *TestContext, frame_count: c_int) void;
+    extern fn zguiTe_ContextMenuAction(ctx: *TestContext, action: Actions, ref: [*]const u8) void;
+    extern fn zguiTe_ContextItemAction(ctx: *TestContext, action: Actions, ref: [*]const u8, flags: TestOpFlags, action_arg: ?*anyopaque) void;
+    extern fn zguiTe_ContextItemInputStrValue(ctx: *TestContext, ref: [*]const u8, value: [*]const u8) void;
+    extern fn zguiTe_ContextItemInputIntValue(ctx: *TestContext, ref: [*]const u8, value: i32) void;
+    extern fn zguiTe_ContextItemInputFloatValue(ctx: *TestContext, ref: [*]const u8, value: f32) void;
+    extern fn zguiTe_ContextDragAndDrop(ctx: *TestContext, ref_src: [*]const u8, ref_dst: [*]const u8, button: zgui.MouseButton) void;
+    extern fn zguiTe_ContextKeyDown(ctx: *TestContext, key_chord: c_int) void;
+    extern fn zguiTe_ContextKeyUp(ctx: *TestContext, key_chord: c_int) void;
+};
+
+const ImGuiTestGuiFunc = fn (context: *TestContext) callconv(.C) void;
+const ImGuiTestTestFunc = fn (context: *TestContext) callconv(.C) void;
+
+pub const createContext = zguiTe_CreateContext;
+extern fn zguiTe_CreateContext() *TestEngine;
+
+pub const destroyContext = zguiTe_DestroyContext;
+extern fn zguiTe_DestroyContext(engine: *TestEngine) void;
+
+extern fn zguiTe_Check(filename: [*]const u8, func: [*]const u8, line: u32, flags: CheckFlags, resul: bool, expr: [*]const u8) bool;
+
+pub fn check(src: std.builtin.SourceLocation, flags: CheckFlags, resul: bool, expr: [:0]const u8) bool {
+    return zguiTe_Check(src.file.ptr, src.fn_name.ptr, src.line, flags, resul, expr.ptr);
+}
+
+pub extern fn zguiTe_RegisterTest(
+    engine: *TestEngine,
+    category: [*]const u8,
+    name: [*]const u8,
+    src: [*]const u8,
+    src_line: c_int,
+    gui_fce: ?*const ImGuiTestGuiFunc,
+    gui_test_fce: ?*const ImGuiTestTestFunc,
+) *Test;
+
+pub fn checkTestError(
+    src: std.builtin.SourceLocation,
+    err: anyerror,
+) void {
+    var buff: [128:0]u8 = undefined;
+    const msg = std.fmt.bufPrintZ(&buff, "Assert error: {}", .{err}) catch undefined;
+    _ = zguiTe_Check(src.file.ptr, src.fn_name.ptr, src.line, .{}, false, msg.ptr);
+}
+
+var _te_engine: ?*TestEngine = null;
+pub fn getTestEngine() ?*TestEngine {
+    return _te_engine;
+}
+
+pub fn init() void {
+    _te_engine = createContext();
+}
+
+pub fn deinit() void {
+    destroyContext(_te_engine.?);
+}