zig

commit b45984ec809a09d94f1a982c1bbccc7ab9e2d678 (tree)
parent 669dae140c63b1bf4dbae6634145529333cd8371
Author: Andrew Kelley <andrew@ziglang.org>
Date:   Mon, 22 Dec 2025 23:48:24 -0800

test-incremental: respect the wine, qemu, etc build flags

Diffstat:
M
test/tests.zig
 | 
5
+++++
M
tools/incr-check.zig
 | 
62
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----

2 files changed, 62 insertions(+), 5 deletions(-)
diff --git a/test/tests.zig b/test/tests.zig
@@ -2706,6 +2706,11 @@ pub fn addIncrementalTests(b: *std.Build, test_step: *Step) !void {
         run.addFileArg(b.path("test/incremental/").path(b, entry.path));
         run.addArgs(&.{ "--zig-lib-dir", b.fmt("{f}", .{b.graph.zig_lib_directory}) });
 
+        if (b.enable_qemu) run.addArg("-fqemu");
+        if (b.enable_wine) run.addArg("-fwine");
+        if (b.enable_wasmtime) run.addArg("-fwasmtime");
+        if (b.enable_darling) run.addArg("-fdarling");
+
         run.addCheck(.{ .expect_term = .{ .Exited = 0 } });
 
         test_step.dependOn(&run.step);
diff --git a/tools/incr-check.zig b/tools/incr-check.zig
@@ -27,6 +27,10 @@ pub fn main() !void {
     var debug_dwarf = false;
     var debug_link = false;
     var preserve_tmp = false;
+    var enable_qemu: bool = false;
+    var enable_wine: bool = false;
+    var enable_wasmtime: bool = false;
+    var enable_darling: bool = false;
 
     var arg_it = try std.process.argsWithAllocator(arena);
     _ = arg_it.skip();
@@ -42,6 +46,14 @@ pub fn main() !void {
                 debug_link = true;
             } else if (std.mem.eql(u8, arg, "--preserve-tmp")) {
                 preserve_tmp = true;
+            } else if (std.mem.eql(u8, arg, "-fqemu")) {
+                enable_qemu = true;
+            } else if (std.mem.eql(u8, arg, "-fwine")) {
+                enable_wine = true;
+            } else if (std.mem.eql(u8, arg, "-fwasmtime")) {
+                enable_wasmtime = true;
+            } else if (std.mem.eql(u8, arg, "-fdarling")) {
+                enable_darling = true;
             } else if (std.mem.eql(u8, arg, "--zig-cc-binary")) {
                 opt_cc_zig = arg_it.next() orelse fatal("expect arg after '--zig-cc-binary'\n{s}", .{usage});
             } else {
@@ -196,6 +208,10 @@ pub fn main() !void {
             .allow_stderr = debug_log_verbose,
             .preserve_tmp_on_fatal = preserve_tmp,
             .cc_child_args = &cc_child_args,
+            .enable_qemu = enable_qemu,
+            .enable_wine = enable_wine,
+            .enable_wasmtime = enable_wasmtime,
+            .enable_darling = enable_darling,
         };
 
         try child.spawn(io);
@@ -243,6 +259,11 @@ const Eval = struct {
     /// The arguments `out.c in.c` must be appended before spawning the subprocess.
     cc_child_args: *std.ArrayList([]const u8),
 
+    enable_qemu: bool,
+    enable_wine: bool,
+    enable_wasmtime: bool,
+    enable_darling: bool,
+
     const StreamEnum = enum { stdout, stderr };
     const Poller = Io.Poller(StreamEnum);
 
@@ -439,7 +460,7 @@ const Eval = struct {
         const io = eval.io;
 
         var argv_buf: [2][]const u8 = undefined;
-        const argv: []const []const u8, const is_foreign: bool = switch (std.zig.system.getExternalExecutor(
+        const argv: []const []const u8, const is_foreign: bool = sw: switch (std.zig.system.getExternalExecutor(
             io,
             &eval.host,
             &eval.target.resolved,
@@ -459,10 +480,41 @@ const Eval = struct {
                 argv_buf[0] = binary_path;
                 break :argv .{ argv_buf[0..1], false };
             },
-            .qemu, .wine, .wasmtime, .darling => |executor_cmd| argv: {
-                argv_buf[0] = executor_cmd;
-                argv_buf[1] = binary_path;
-                break :argv .{ argv_buf[0..2], true };
+            .qemu => |executor_cmd| argv: {
+                if (eval.enable_qemu) {
+                    argv_buf[0] = executor_cmd;
+                    argv_buf[1] = binary_path;
+                    break :argv .{ argv_buf[0..2], true };
+                } else {
+                    continue :sw .bad_os_or_cpu;
+                }
+            },
+            .wine => |executor_cmd| argv: {
+                if (eval.enable_wine) {
+                    argv_buf[0] = executor_cmd;
+                    argv_buf[1] = binary_path;
+                    break :argv .{ argv_buf[0..2], true };
+                } else {
+                    continue :sw .bad_os_or_cpu;
+                }
+            },
+            .wasmtime => |executor_cmd| argv: {
+                if (eval.enable_wasmtime) {
+                    argv_buf[0] = executor_cmd;
+                    argv_buf[1] = binary_path;
+                    break :argv .{ argv_buf[0..2], true };
+                } else {
+                    continue :sw .bad_os_or_cpu;
+                }
+            },
+            .darling => |executor_cmd| argv: {
+                if (eval.enable_darling) {
+                    argv_buf[0] = executor_cmd;
+                    argv_buf[1] = binary_path;
+                    break :argv .{ argv_buf[0..2], true };
+                } else {
+                    continue :sw .bad_os_or_cpu;
+                }
             },
         };