From 65b95b0af42b3da0aaa86c9448e32e8aca388a17 Mon Sep 17 00:00:00 2001 From: Ali Cheraghi Date: Sun, 13 Sep 2026 16:41:22 +0330 Subject: [PATCH] add unskip_spirv_tests.zig tool --- test/behavior/addrspace_and_linksection.zig | 4 + test/behavior/align.zig | 1 + test/behavior/array.zig | 2 +- test/behavior/basic.zig | 6 + test/behavior/bitcast.zig | 1 - test/behavior/call.zig | 2 + test/behavior/comptime_memory.zig | 2 + test/behavior/decl_literals.zig | 1 - test/behavior/defer.zig | 1 + test/behavior/enum.zig | 1 - test/behavior/error.zig | 4 +- test/behavior/eval.zig | 13 + test/behavior/export_builtin.zig | 2 + test/behavior/floatop.zig | 7 - test/behavior/generics.zig | 1 + test/behavior/globals.zig | 6 +- test/behavior/if.zig | 1 + test/behavior/inline_switch.zig | 2 - test/behavior/ir_block_deps.zig | 1 - test/behavior/math.zig | 1 + test/behavior/null.zig | 1 + test/behavior/optional.zig | 6 +- test/behavior/packed-struct.zig | 9 - test/behavior/pointers.zig | 2 + test/behavior/shuffle.zig | 1 - test/behavior/sizeof_and_typeof.zig | 1 + test/behavior/slice.zig | 3 +- test/behavior/splat.zig | 1 + test/behavior/struct.zig | 7 +- test/behavior/switch.zig | 11 +- test/behavior/switch_loop.zig | 2 - test/behavior/switch_prong_implicit_cast.zig | 1 - test/behavior/threadlocal.zig | 1 - test/behavior/tuple.zig | 2 + test/behavior/type.zig | 2 + test/behavior/union.zig | 14 +- test/behavior/vector.zig | 1 - test/behavior/while.zig | 5 + test/standalone/build.zig | 1 + tools/unskip_spirv_tests.zig | 264 +++++++++++++++++++ 40 files changed, 331 insertions(+), 63 deletions(-) create mode 100644 tools/unskip_spirv_tests.zig diff --git a/test/behavior/addrspace_and_linksection.zig b/test/behavior/addrspace_and_linksection.zig index 5af04595baa0005f47bd9c35e0cd1833f0c895b8..a340ee4b6e79c55dc75cef12e4255abccccc9fb9 100644 --- a/test/behavior/addrspace_and_linksection.zig +++ b/test/behavior/addrspace_and_linksection.zig @@ -12,6 +12,8 @@ const var_linksection = linksections.?[1]; const fn_linksection = linksections.?[2]; test "addrspace on container-level const" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const S = struct { const a: u32 addrspace(.generic) = 123; fn check(ptr: anytype) !void { @@ -47,6 +49,8 @@ test "addrspace and linksection on container-level const" { } test "addrspace on container-level var" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const S = struct { var a: u32 addrspace(.generic) = 123; fn check(ptr: anytype) !void { diff --git a/test/behavior/align.zig b/test/behavior/align.zig index c9294e953b8d2c907a8b86e2c6b5916b1d75941a..b3333c2d233d7ed448338dea9a9b9a6220594244 100644 --- a/test/behavior/align.zig +++ b/test/behavior/align.zig @@ -467,6 +467,7 @@ var default_aligned_global = DefaultAligned{ }; test "read 128-bit field from default aligned struct in global memory" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/array.zig b/test/behavior/array.zig index 6c228f76eba5fed6d0899a74e0a5544cb94efa66..dfafeeaf271ae03bf3e02553ffe9873d795cfb58 100644 --- a/test/behavior/array.zig +++ b/test/behavior/array.zig @@ -582,6 +582,7 @@ test "array with comptime-only element type" { } test "tuple to array handles sentinel" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO @@ -936,7 +937,6 @@ test "accessing multidimensional global array at comptime" { test "union that needs padding bytes inside an array" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 42c85b0487e2d024adf394300c165feaa126d325..07bf89c9348748786f7b337e5cee3084d8f18b98 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -60,6 +60,7 @@ const g1: i32 = 1233 + 1; var g2: i32 = 0; test "global variables" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try expect(g2 == 0); @@ -683,6 +684,7 @@ var gdt = [_]GDTEntry{ var global_ptr = &gdt[0]; test "global constant is loaded with a runtime-known index" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO const S = struct { @@ -999,6 +1001,8 @@ test "generic function uses return type of other generic function" { } test "const alloc with comptime-known initializer is made comptime-known" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const S = struct { a: bool, b: [2]u8, @@ -1079,6 +1083,8 @@ test "inline call of function with a switch inside the return statement" { } test "pointer to zero sized global is mutable" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const S = struct { const Thing = struct {}; diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig index d790d68416add0ba62603eaabaa691d1bdfe9c32..e0bac5c59aa8caca367af85a394b61d32bc94058 100644 --- a/test/behavior/bitcast.zig +++ b/test/behavior/bitcast.zig @@ -110,7 +110,6 @@ test "@bitCast packed structs at runtime and comptime" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const Full = packed struct { number: u16, diff --git a/test/behavior/call.zig b/test/behavior/call.zig index 5f2b24b6b72eadd8dfffa6998ee996e292ed381c..b096123a3d3c8af6dfe1b6e994a4f1809724fb2c 100644 --- a/test/behavior/call.zig +++ b/test/behavior/call.zig @@ -538,6 +538,8 @@ test "call function pointer in comptime field" { } test "generic function pointer can be called" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const S = struct { var ok = false; fn foo(x: anytype) void { diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig index 2e4989a7e6ee1f0065469b23aa04e631a7b56c6b..979e6a3752e533596d7f1c5bb1a5af4e33a40b49 100644 --- a/test/behavior/comptime_memory.zig +++ b/test/behavior/comptime_memory.zig @@ -431,6 +431,8 @@ test "type pun @ptrFromInt" { } test "type pun null pointer-like optional" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const p: ?*u8 = null; // note that expectEqual hides the bug try testing.expect(@as(*const ?*i8, @ptrCast(&p)).* == null); diff --git a/test/behavior/decl_literals.zig b/test/behavior/decl_literals.zig index 5d237778757f3c2f2a3faa160668f26debfee9f9..08576cf4a6980ee7e855627094513a59cf780544 100644 --- a/test/behavior/decl_literals.zig +++ b/test/behavior/decl_literals.zig @@ -35,7 +35,6 @@ test "decl literal with pointer" { test "call decl literal with optional" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { x: u32, diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig index 1a999c32c01a30dfe4c0cf98cdca5642c8b83511..be22d37ea2f9c71f5fd44dbbb5db099136e4cf14 100644 --- a/test/behavior/defer.zig +++ b/test/behavior/defer.zig @@ -89,6 +89,7 @@ fn runSomeErrorDefers(x: bool) !bool { } test "mixing normal and error defers" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index fb3501d4541d006092b270d4b5cf2bf85ca686c1..6eacd6a5194dd16f116f4b7bab0cfe12c5faa8e0 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -930,7 +930,6 @@ test "constant enum initialization with differing sizes" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try test3_1(test3_foo); try test3_2(test3_bar); } diff --git a/test/behavior/error.zig b/test/behavior/error.zig index ab8d8ddf1d70d7916304ec513faa3a0a84a7d003..53c4614d6965927691943ade8f359833f74d5a73 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -524,7 +524,6 @@ test "function pointer with return type that is error union with payload which i } test "return result loc as peer result loc in inferred error set function" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO @@ -783,6 +782,7 @@ const NoReturn = struct { }; test "error union of noreturn used with if" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; @@ -796,6 +796,7 @@ test "error union of noreturn used with if" { } test "error union of noreturn used with try" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; @@ -806,6 +807,7 @@ test "error union of noreturn used with try" { } test "error union of noreturn used with catch" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig index f86ab963d2a4ea5dd0cec5493f583ac672a174e7..50e264c1df6fbfc7bdbc3c8c8e0784f33f642ed3 100644 --- a/test/behavior/eval.zig +++ b/test/behavior/eval.zig @@ -5,6 +5,8 @@ const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; test "compile time recursion" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + try expect(some_data.len == 21); } var some_data: [@as(usize, @intCast(fibonacci(7)))]u8 = undefined; @@ -388,6 +390,7 @@ test "return 0 from function that has u0 return type" { } test "statically initialized struct" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO st_init_str_foo.x += 1; @@ -927,6 +930,7 @@ test "closure capture type of runtime-known var" { } test "comptime break passing through runtime condition converted to runtime break" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO const S = struct { @@ -959,6 +963,7 @@ test "comptime break passing through runtime condition converted to runtime brea } test "comptime break to outer loop passing through runtime condition converted to runtime break" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO @@ -1158,6 +1163,8 @@ test "repeated value is correctly expanded" { } test "value in if block is comptime-known" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const first = blk: { const s = if (false) "a" else "b"; break :blk "foo" ++ s; @@ -1266,6 +1273,8 @@ test "continue in inline for inside a comptime switch" { } test "length of global array is determinable at comptime" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const S = struct { var bytes: [1024]u8 = undefined; @@ -1313,6 +1322,7 @@ test "continue nested inline for loop in named block expr" { } test "x and false is comptime-known false" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO const T = struct { @@ -1340,6 +1350,7 @@ test "x and false is comptime-known false" { } test "x or true is comptime-known true" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO const T = struct { @@ -1401,6 +1412,8 @@ test "comptime function turns function value to function pointer" { } test "container level const and var have unique addresses" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const S = struct { x: i32, y: i32, diff --git a/test/behavior/export_builtin.zig b/test/behavior/export_builtin.zig index 0381e9645488d4565a56c16630c9e937e152df61..84187b403168c6ee2e786ea0e51f1fccf3c447c8 100644 --- a/test/behavior/export_builtin.zig +++ b/test/behavior/export_builtin.zig @@ -4,6 +4,7 @@ const expect = std.testing.expect; test "exporting enum value" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { const E = enum(c_int) { one, two }; @@ -29,6 +30,7 @@ test "exporting with internal linkage" { test "exporting using namespace access" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { const Inner = struct { diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig index dbd2deb0fd5c4ef49546d1ef0f533211c642de01..cb6910fdaf2c1caf3c95737f538a1deea88fe2ff 100644 --- a/test/behavior/floatop.zig +++ b/test/behavior/floatop.zig @@ -464,7 +464,6 @@ test "@sqrt with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testSqrtWithVectors(); try comptime testSqrtWithVectors(); @@ -532,7 +531,6 @@ test "@sin with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testSinWithVectors(); try comptime testSinWithVectors(); @@ -600,7 +598,6 @@ test "@cos with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testCosWithVectors(); try comptime testCosWithVectors(); @@ -668,7 +665,6 @@ test "@tan with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testTanWithVectors(); try comptime testTanWithVectors(); @@ -740,7 +736,6 @@ test "@exp with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testExpWithVectors(); try comptime testExpWithVectors(); @@ -807,7 +802,6 @@ test "@exp2 with @vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testExp2WithVectors(); try comptime testExp2WithVectors(); @@ -939,7 +933,6 @@ test "@log2 with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/13681 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64 and diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig index e17ea4fdd682672e5315832c936993dce36355ae..a30529a193a20693b87158fe7ad90079c1f00c8b 100644 --- a/test/behavior/generics.zig +++ b/test/behavior/generics.zig @@ -516,6 +516,7 @@ test "comptime callconv(.c) function ptr uses comptime type argument" { } test "call generic function with from function called by the generic function" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/globals.zig b/test/behavior/globals.zig index eab88cdfbdc4da73079c041fdc71cde54ba16821..bb3ba105e92d324d6b2b58b8c49f6ee643d82594 100644 --- a/test/behavior/globals.zig +++ b/test/behavior/globals.zig @@ -4,6 +4,7 @@ const expect = std.testing.expect; var pos = [2]f32{ 0.0, 0.0 }; test "store to global array" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; @@ -14,6 +15,7 @@ test "store to global array" { var vpos = @Vector(2, f32){ 0.0, 0.0 }; test "store to global vector" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; @@ -66,8 +68,6 @@ test "global loads can affect liveness" { } test "global const can be self-referential" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { self: *const @This(), x: u32, @@ -112,8 +112,6 @@ test "global var can be self-referential" { } test "global const can be indirectly self-referential" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { other: *const @This(), x: u32, diff --git a/test/behavior/if.zig b/test/behavior/if.zig index 78151da211bc9103f15d7f69dc43c31c7d5f63a9..449c6e4c5f4d73e5e1f8e84b4435df11d608da87 100644 --- a/test/behavior/if.zig +++ b/test/behavior/if.zig @@ -44,6 +44,7 @@ var global_with_val: anyerror!u32 = 0; var global_with_err: anyerror!u32 = error.SomeError; test "unwrap mutable global var" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (global_with_val) |v| { diff --git a/test/behavior/inline_switch.zig b/test/behavior/inline_switch.zig index 676ef30874b6fa4685f70ae5a8cb31118a89a208..54c41f4fac3bd5c1a386a95b55a590c257aa1afe 100644 --- a/test/behavior/inline_switch.zig +++ b/test/behavior/inline_switch.zig @@ -4,7 +4,6 @@ const builtin = @import("builtin"); test "inline scalar prongs" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; var x: usize = 0; switch (x) { @@ -19,7 +18,6 @@ test "inline scalar prongs" { test "inline prong ranges" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; var x: usize = 0; _ = &x; diff --git a/test/behavior/ir_block_deps.zig b/test/behavior/ir_block_deps.zig index d4218387ecd6987feaaa1c751947b2b27e8fb01f..4708af87f4bd27060125a8e2c0e111e0996badab 100644 --- a/test/behavior/ir_block_deps.zig +++ b/test/behavior/ir_block_deps.zig @@ -19,7 +19,6 @@ fn getErrInt() anyerror!i32 { test "ir block deps" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try expect((foo(1) catch unreachable) == 0); diff --git a/test/behavior/math.zig b/test/behavior/math.zig index 259b9dfe7c3aa908713374a60e21116d6e1edb73..88d83ba60d052ef5da1c23f8226325e41c885f8c 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -2570,6 +2570,7 @@ test "partially-runtime integer vector division would be illegal if vector eleme if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; var lhs: @Vector(2, i8) = .{ -128, 5 }; diff --git a/test/behavior/null.zig b/test/behavior/null.zig index 7b6806428d7fdecd2cc381fabe1b16126967226c..ba9ce5127b9539b2e00b85486d33ac28a141d3de 100644 --- a/test/behavior/null.zig +++ b/test/behavior/null.zig @@ -183,6 +183,7 @@ const SillyStruct = struct { const here_is_a_null_literal = SillyStruct{ .context = null }; test "unwrap optional which is field of global var" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig index 4d54d96ad9bb702e85228464f02664aa3187824d..4a6695fd5ec46df9bb5abb5b86de558a4a136ab6 100644 --- a/test/behavior/optional.zig +++ b/test/behavior/optional.zig @@ -319,7 +319,6 @@ test "assigning to an unwrapped optional field in an inline loop" { test "coerce an anon struct literal to optional struct" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { const Struct = struct { @@ -388,7 +387,6 @@ test "0-bit child type coerced to optional" { test "array of optional unaligned types" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const Enum = enum { one, two, three }; @@ -477,6 +475,7 @@ const NoReturn = struct { }; test "optional of noreturn used with if" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO NoReturn.a = 64; @@ -488,6 +487,7 @@ test "optional of noreturn used with if" { } test "optional of noreturn used with orelse" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO NoReturn.a = 64; @@ -652,8 +652,6 @@ test "result location initialization of optional with OPV payload" { } test "global comptime only optional" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { const @"null": ?*type = null; const @"void": ?*const type = &void; diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig index 045c19767454b64d970fe6c7a46dafcb9b2a1ac4..82256ba7782d503b1c476a28785841aba3bf4bbc 100644 --- a/test/behavior/packed-struct.zig +++ b/test/behavior/packed-struct.zig @@ -794,7 +794,6 @@ test "nested packed struct at non-zero offset 2" { test "runtime init of unnamed packed struct type" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; var z: u8 = 123; _ = &z; @@ -889,7 +888,6 @@ test "store undefined to packed result location" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; var x: u4 = 0; _ = &x; @@ -910,7 +908,6 @@ test "bitcast back and forth" { // Originally reported at https://github.com/ziglang/zig/issues/14200 test "field access of packed struct smaller than its abi size inside struct initialized with rls" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO const S = struct { @@ -1006,7 +1003,6 @@ test "packed struct acts as a namespace" { test "assignment to non-byte-aligned field in packed struct" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO const Frame = packed struct { @@ -1046,7 +1042,6 @@ test "load flag from packed struct in union" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const A = packed struct { @@ -1168,7 +1163,6 @@ test "packed struct equality" { test "packed struct equality ignores padding bits" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = packed struct { b: bool }; var s: S = undefined; @@ -1178,7 +1172,6 @@ test "packed struct equality ignores padding bits" { } test "packed struct with signed field" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; var s: packed struct { @@ -1193,7 +1186,6 @@ test "packed struct with signed field" { test "assign packed struct initialized with RLS to packed struct literal field" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const Inner = packed struct { x: u17 }; const Outer = packed struct { inner: Inner, x: u15 }; @@ -1209,7 +1201,6 @@ test "assign packed struct initialized with RLS to packed struct literal field" test "packed struct store of comparison result" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO const S1 = packed struct { diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig index 7f75454495996b29620880b5ee180d8261261970..23b976f02ac63e4bdd418fd6d8a512e930fb8dd7 100644 --- a/test/behavior/pointers.zig +++ b/test/behavior/pointers.zig @@ -642,6 +642,8 @@ test "result type preserved through multiple references" { } test "result type found through optional pointer" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const ptr1: ?*const u32 = &@intCast(123); const ptr2: ?[]const u8 = &.{ @intCast(123), @truncate(0xABCD) }; try expect(ptr1.?.* == 123); diff --git a/test/behavior/shuffle.zig b/test/behavior/shuffle.zig index e61e8f17a8d940c94b054228894bf6d799aa4c8d..0ba5f6f72882c0f3e5ec029198b429f99f7810dd 100644 --- a/test/behavior/shuffle.zig +++ b/test/behavior/shuffle.zig @@ -176,7 +176,6 @@ test "@shuffle u0" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { fn doTheTest() !void { diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig index 96b17e2151712787ebf63f4f1cc7b8cbaecaf139..9e881ff480fbad959f7c8479ec771786c88881bc 100644 --- a/test/behavior/sizeof_and_typeof.zig +++ b/test/behavior/sizeof_and_typeof.zig @@ -134,6 +134,7 @@ test "@TypeOf() has no runtime side effects" { } test "branching logic inside @TypeOf" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; const S = struct { diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig index e3685562e5259913edfcd99590a1452bbafb7075..a08e134cb75a554598372275d7381c973ed435fb 100644 --- a/test/behavior/slice.zig +++ b/test/behavior/slice.zig @@ -254,8 +254,6 @@ test "slicing pointer by length" { const x = @as([*]i32, @ptrFromInt(0x1000))[0..0x500]; const y = x[0x100..]; test "compile time slice of pointer to hard coded address" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - try expect(@intFromPtr(x) == 0x1000); try expect(x.len == 0x500); @@ -858,6 +856,7 @@ test "slice len modification at comptime" { } test "slice field ptr const" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const const_slice: []const u8 = "string"; const const_ptr_const_slice = &const_slice; diff --git a/test/behavior/splat.zig b/test/behavior/splat.zig index 7ffb02017d456c7a854021251d6e567d7395ddca..859dfd8634e8ce9cd6d425194d182740b44d87ac 100644 --- a/test/behavior/splat.zig +++ b/test/behavior/splat.zig @@ -92,6 +92,7 @@ test "splat with an error union or optional result type" { } test "read/write through global variable array of struct fields initialized via splat" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index 2aa7920ab4b17ae56df165a880d3242e3a3fedb0..00a42d3b384540b891f4962a3add671b453064da 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -443,6 +443,7 @@ test "packed struct 24bits" { } test "runtime struct initialization of bitfield" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO @@ -714,6 +715,7 @@ test "packed struct with u0 field access" { } test "access to global struct fields" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO g_foo.bar.value = 42; @@ -943,7 +945,6 @@ test "tuple element initialized with fn call" { } test "struct with union field" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO @@ -1081,7 +1082,6 @@ test "anon init through error unions and optionals" { test "anon init through optional" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { a: u32, @@ -1760,6 +1760,8 @@ test "circular dependency through pointer field of a struct" { } test "field calls do not force struct field init resolution" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const S = struct { x: u32 = blk: { _ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution @@ -1985,6 +1987,7 @@ test "assignment of field with padding" { } test "initiate global variable with runtime value" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig index c5ffdfa3e1872bfa58edb53b414b523660e9a9bb..25eb5159357c06134f6b8e2f3fa5276528b7d4c4 100644 --- a/test/behavior/switch.zig +++ b/test/behavior/switch.zig @@ -252,6 +252,7 @@ fn poll() void { } test "switch on global mutable var isn't constant-folded" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO while (state < 2) { @@ -270,7 +271,6 @@ test "switch prong with variable" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 }); try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 }); @@ -294,7 +294,6 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) !void { test "switch on enum using pointer capture" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testSwitchEnumPtrCapture(); try comptime testSwitchEnumPtrCapture(); @@ -570,7 +569,6 @@ test "switch with null and T peer types and inferred result location type" { test "switch prongs with cases with identical payload types" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const Union = union(enum) { A: usize, @@ -726,7 +724,6 @@ test "switch on error set with single else" { test "switch capture copies its payload" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -788,7 +785,6 @@ test "enum value without tag name used as switch item" { } test "switch item sizeof" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { fn doTheTest() !void { var a: usize = 0; @@ -817,8 +813,6 @@ test "comptime inline switch" { } test "switch capture peer type resolution" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const U = union(enum) { a: u32, b: u64, @@ -835,7 +829,6 @@ test "switch capture peer type resolution" { test "switch capture peer type resolution for in-memory coercible payloads" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const T1 = c_int; const t1_info = @typeInfo(T1).int; @@ -1166,8 +1159,6 @@ test "switch with uninstantiable union fields" { } test "switch with tag capture" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const U = union(enum) { a, b: i32, diff --git a/test/behavior/switch_loop.zig b/test/behavior/switch_loop.zig index caaea13e7f8aa3571a0f3f34c7b05b0ee37eea3b..f45ef3ef4113b493fc434f75ba1fe5c6a0111945 100644 --- a/test/behavior/switch_loop.zig +++ b/test/behavior/switch_loop.zig @@ -96,7 +96,6 @@ test "switch loop on tagged union" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const S = struct { @@ -291,7 +290,6 @@ test "switch loop with discarded tag capture" { } test "switch loop with single catch-all prong" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { const E = enum { a, b, c }; const U = union(E) { a: u32, b: u16, c: u8 }; diff --git a/test/behavior/switch_prong_implicit_cast.zig b/test/behavior/switch_prong_implicit_cast.zig index aab365f027ea17273c77e05bf96da48cfbedd612..0de343898df9a5b0a47b381bd25d45c0d265cb91 100644 --- a/test/behavior/switch_prong_implicit_cast.zig +++ b/test/behavior/switch_prong_implicit_cast.zig @@ -18,7 +18,6 @@ test "switch prong implicit cast" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const result = switch (foo(2) catch unreachable) { FormValue.One => false, diff --git a/test/behavior/threadlocal.zig b/test/behavior/threadlocal.zig index ec1ce0b62677b9cbb4988814e4c69f94ae65548c..9c888bf762dd521cd3a6d53e0faebffe02d13bc0 100644 --- a/test/behavior/threadlocal.zig +++ b/test/behavior/threadlocal.zig @@ -6,7 +6,6 @@ test "thread local variable" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO const S = struct { diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig index 1d6ec8a6e43e70e2472777143cec18e586c3397f..6be6c65fb51292a7982337dab704dadb6b4336e4 100644 --- a/test/behavior/tuple.zig +++ b/test/behavior/tuple.zig @@ -548,6 +548,8 @@ test "OPV tuple fields aren't comptime" { } test "array of tuples that end with a zero-bit field followed by padding" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const S = struct { var foo: [2]struct { u32, u8, void } = .{ .{ 1, 2, {} }, .{ 3, 4, {} } }; }; diff --git a/test/behavior/type.zig b/test/behavior/type.zig index 875e77ffcb037bce22bf124d5ecea3689913d163..5f310bd4729aeb51b755e50a1eafa4d38d8e5c82 100644 --- a/test/behavior/type.zig +++ b/test/behavior/type.zig @@ -406,6 +406,8 @@ test "matching captures causes opaque equivalence" { } test "reify enum where fields refers to part of array" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const field_names: [3][]const u8 = .{ "foo", "bar", undefined }; const field_values: [3]u8 = .{ undefined, 0, 1 }; const E = @Enum(u8, .exhaustive, field_names[0..2], field_values[1..3]); diff --git a/test/behavior/union.zig b/test/behavior/union.zig index 0ba364aabe557a0bac5832d285cc4595dc9cec25..083da4df4bf67ae8b6d36a4a5dd3d1394f1f8ff4 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -442,6 +442,7 @@ const Foo1 = union(enum) { var glbl: Foo1 = undefined; test "global union with single field is correctly initialized" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO @@ -551,7 +552,6 @@ const Baz = enum { A, B, C, D }; test "tagged union type" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const foo1 = TaggedFoo{ .One = 13 }; const foo2 = TaggedFoo{ @@ -576,7 +576,6 @@ test "tagged union as return value" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; switch (returnAnInt(13)) { TaggedFoo.One => |value| try expect(value == 13), @@ -619,7 +618,6 @@ test "union(enum(u32)) with specified and unspecified tag values" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; comptime assert(Tag(Tag(MultipleChoice2)) == u32); try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); @@ -709,7 +707,6 @@ test "union with only 1 field casted to its enum type which has enum value speci test "@intFromEnum works on unions" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const Bar = union(enum) { A: bool, @@ -793,7 +790,6 @@ test "@unionInit stored to a const" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { const U = union(enum) { @@ -823,7 +819,6 @@ test "@unionInit stored to a const" { test "@unionInit can modify a union type" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const UnionInitEnum = union(enum) { Boolean: bool, @@ -846,7 +841,6 @@ test "@unionInit can modify a union type" { test "@unionInit can modify a pointer value" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const UnionInitEnum = union(enum) { Boolean: bool, @@ -954,7 +948,6 @@ test "function call result coerces from tagged union to the tag" { test "switching on non exhaustive union" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { const E = enum(u8) { @@ -1256,7 +1249,6 @@ test "@unionInit uses tag value instead of field index" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const E = enum(u8) { b = 255, a = 3, @@ -1414,6 +1406,8 @@ test "reinterpreting enum value inside packed union" { } test "access the tag of a global tagged union" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + const U = union(enum) { a, b: u8, @@ -2005,7 +1999,6 @@ test "circular dependency through pointer field of a union" { test "pass nested union with rls" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const Union = union(enum) { a: u32, @@ -2052,7 +2045,6 @@ test "runtime union init, most-aligned field != largest" { test "copied union field doesn't alias source" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const U = union(enum) { array: [10]u32, diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig index 0566293f9066147a7a717866b2be28f739555fb2..912b189f3926f43eced3fd093592db8d26a8c7fd 100644 --- a/test/behavior/vector.zig +++ b/test/behavior/vector.zig @@ -378,7 +378,6 @@ test "array of non-abi-sized integer to vector of same type" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { fn doTheTest() !void { diff --git a/test/behavior/while.zig b/test/behavior/while.zig index d62495589b9458a441aaed0000514f60a0942528..f08c045c831cdb2b2cecd99c6b968c2b869b8cf1 100644 --- a/test/behavior/while.zig +++ b/test/behavior/while.zig @@ -122,6 +122,8 @@ test "while copies its payload" { } test "continue and break" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + try runContinueAndBreakTest(); try expect(continue_and_break_counter == 8); } @@ -140,6 +142,7 @@ fn runContinueAndBreakTest() !void { } test "while with optional as condition" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; @@ -153,6 +156,7 @@ test "while with optional as condition" { } test "while with optional as condition with else" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; @@ -171,6 +175,7 @@ test "while with optional as condition with else" { } test "while with error union condition" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; diff --git a/test/standalone/build.zig b/test/standalone/build.zig index fa1c4186abcd7da988acfcda5ca30ed966d62a80..ab4262c8b90686517cf32f90b7b99263c72d3969 100644 --- a/test/standalone/build.zig +++ b/test/standalone/build.zig @@ -44,6 +44,7 @@ pub fn build(b: *std.Build) void { "../../tools/generate_linux_syscalls.zig", "../../tools/process_headers.zig", "../../tools/migrate_langref.zig", + "../../tools/unskip_spirv_tests.zig", "../../tools/update-linux-headers.zig", "../../tools/update_clang_options.zig", "../../tools/update_cpu_features.zig", diff --git a/tools/unskip_spirv_tests.zig b/tools/unskip_spirv_tests.zig new file mode 100644 index 0000000000000000000000000000000000000000..a3100d9846bf9897c570a7c0c09fe710a899034a --- /dev/null +++ b/tools/unskip_spirv_tests.zig @@ -0,0 +1,264 @@ +const std = @import("std"); +const Io = std.Io; +const Allocator = std.mem.Allocator; +const Ast = std.zig.Ast; + +const usage = + \\Usage: unskip_spirv_tests [test/behavior/*.zig ...] + \\ + \\For example: + \\zig run tools/unskip_spirv_tests.zig -- zig-out/bin/zig \ + \\ ../zig-spirv-test-executor/src/test_runner.zig \ + \\ ../zig-spirv-test-executor/zig-out/bin/zig-spirv-test-executor [files...] + \\ + \\Runs every behavior test that is skipped on stage2_spirv in isolation and + \\removes the skip if the test passes. + \\ +; + +const Test = struct { + body: Ast.Node.Index, + name: []const u8, + skip: ?Ast.Node.Index, +}; + +pub fn main(init: std.process.Init) !void { + const io = init.io; + const arena = init.arena.allocator(); + + var args = try init.minimal.args.iterateAllocator(arena); + _ = args.skip(); + const zig = args.next() orelse std.process.fatal(usage, .{}); + const test_runner = args.next() orelse std.process.fatal(usage, .{}); + const test_cmd = args.next() orelse std.process.fatal(usage, .{}); + + var files: std.ArrayList([]const u8) = .empty; + while (args.next()) |path| try files.append(arena, path); + + if (files.items.len == 0) { + var dir = try Io.Dir.openDir(.cwd(), io, "test/behavior", .{ .iterate = true }); + defer dir.close(io); + + var it = dir.iterate(); + while (try it.next(io)) |entry| { + if (entry.kind != .file or !std.mem.endsWith(u8, entry.name, ".zig")) continue; + const path = try std.fs.path.join(arena, &.{ "test/behavior", entry.name }); + const source = try Io.Dir.readFileAlloc(.cwd(), io, path, arena, .unlimited); + if (std.mem.find(u8, source, "stage2_spirv") != null) { + try files.append(arena, path); + } + } + } + + var stdout_buffer: [4096]u8 = undefined; + var stdout_writer = Io.File.stdout().writer(io, &stdout_buffer); + const stdout = &stdout_writer.interface; + + const progress = std.Progress.start(io, .{ .estimated_total_items = files.items.len }); + const cache_dir = init.environ_map.get("ZIG_LOCAL_CACHE_DIR") orelse ".zig-cache"; + const variant_dir = try std.fs.path.join(arena, &.{ cache_dir, "unskip" }); + try Io.Dir.createDirPath(.cwd(), io, variant_dir); + + var failures: std.array_hash_map.String(std.ArrayList([]const u8)) = .empty; + var total_removed: usize = 0; + var files_changed: usize = 0; + for (files.items) |path| { + const basename = std.fs.path.basename(path); + const source = try Io.Dir.readFileAlloc(.cwd(), io, path, arena, .unlimited); + const ast = try Ast.parse(arena, try arena.dupeSentinel(u8, source, 0), .{}); + if (ast.errors.len != 0) std.process.fatal("{s}: parse error", .{path}); + + var tests: std.ArrayList(Test) = .empty; + var skips: usize = 0; + for (ast.rootDecls()) |decl| { + if (ast.nodeTag(decl) != .test_decl) continue; + const name_token, const body = ast.nodeData(decl).opt_token_and_node; + const token = name_token.unwrap() orelse continue; + const name = if (ast.tokenTag(token) == .string_literal) + try std.zig.string_literal.parseAlloc(arena, ast.tokenSlice(token)) + else + ast.tokenSlice(token); + + var buffer: [2]Ast.Node.Index = undefined; + const skip: ?Ast.Node.Index = for (ast.blockStatements(&buffer, body) orelse &.{}) |statement| { + const if_full = ast.fullIf(statement) orelse continue; + if (ast.nodeTag(if_full.ast.cond_expr) != .equal_equal) continue; + _, const rhs = ast.nodeData(if_full.ast.cond_expr).node_and_node; + if (!std.mem.eql(u8, ast.getNodeSource(rhs), ".stage2_spirv")) continue; + if (ast.nodeTag(if_full.ast.then_expr) != .@"return") continue; + const value = ast.nodeData(if_full.ast.then_expr).opt_node.unwrap() orelse continue; + if (!std.mem.eql(u8, ast.getNodeSource(value), "error.SkipZigTest")) continue; + break statement; + } else null; + skips += @intFromBool(skip != null); + + try tests.append(arena, .{ .body = body, .name = name, .skip = skip }); + } + + if (skips == 0) { + progress.completeOne(); + continue; + } + + const file_node = progress.start(basename, skips); + defer file_node.end(); + const variant_path = try std.fs.path.join(arena, &.{ variant_dir, basename }); + + var removed: Ast.Render.Fixups = .{}; + for (tests.items) |candidate| { + const skip = candidate.skip orelse continue; + const test_node = file_node.start(candidate.name, 0); + defer test_node.end(); + + var fixups: Ast.Render.Fixups = .{}; + try fixups.omit_nodes.put(arena, skip, {}); + for (tests.items) |other| { + if (other.body == candidate.body) continue; + try fixups.replace_nodes_with_string.put(arena, other.body, "{ return error.SkipZigTest; }"); + } + + var variant: Io.Writer.Allocating = .init(arena); + try ast.render(arena, &variant.writer, fixups); + try Io.Dir.writeFile(.cwd(), io, .{ .sub_path = variant_path, .data = variant.written() }); + + const signature: []const u8 = signature: { + const result = std.process.run(arena, io, .{ + .argv = &.{ + zig, "test", variant_path, + "--test-runner", test_runner, "-target", + "spirv64-vulkan", "-mcpu", "vulkan_v1_2+variable_pointers+int64", + "-fno-llvm", "--zig-lib-dir", "lib", + "--test-cmd", test_cmd, "--test-cmd-bin", + }, + .timeout = .{ .duration = .{ .raw = .fromSeconds(120), .clock = .awake } }, + .progress_node = test_node, + }) catch |err| switch (err) { + error.Timeout => break :signature "timeout", + else => |e| return e, + }; + + if (result.term.success()) { + try removed.omit_nodes.put(arena, skip, {}); + std.debug.print("{s}: removed skip for {s}\n", .{ basename, candidate.name }); + continue; + } + + const output = try std.mem.concat(arena, u8, &.{ result.stdout, result.stderr }); + var lines = std.mem.splitScalar(u8, output, '\n'); + while (lines.next()) |line| { + const rest = std.mem.cutPrefix(u8, line, "error: line ") orelse continue; + const colon = std.mem.findScalar(u8, rest, ':') orelse continue; + if (!allDigits(rest[0..colon])) continue; + break :signature try normalize(arena, "spirv-val: ", rest[colon + 1 ..]); + } + lines.reset(); + + while (lines.next()) |line| { + const rest = std.mem.cutPrefix(u8, line, "thread ") orelse continue; + const panic = std.mem.find(u8, rest, " panic: ") orelse continue; + if (std.mem.findScalar(u8, rest[0..panic], ' ') != null) continue; + break :signature try normalize(arena, "panic: ", rest[panic + " panic: ".len ..]); + } + lines.reset(); + + while (lines.next()) |line| { + const marker = std.mem.find(u8, line, ": error: ") orelse continue; + const location = line[0..marker]; + const line_colon = std.mem.findScalarLast(u8, location, ':') orelse continue; + const file_colon = std.mem.findScalarLast(u8, location[0..line_colon], ':') orelse continue; + if (std.mem.findScalar(u8, location[0..file_colon], ' ') != null) continue; + if (!allDigits(location[file_colon + 1 .. line_colon])) continue; + if (!allDigits(location[line_colon + 1 ..])) continue; + const message = line[marker + ": error: ".len ..]; + break :signature try normalize(arena, "compile error: ", message); + } + lines.reset(); + + while (lines.next()) |line| { + const rest = std.mem.cutPrefix(u8, line, "error: ") orelse continue; + break :signature try normalize(arena, "error: ", rest); + } + + if (std.mem.trim(u8, output, &std.ascii.whitespace).len > 0) { + break :signature "unknown failure (no error: line found)"; + } + break :signature "no output"; + }; + + const gop = try failures.getOrPut(arena, signature); + if (!gop.found_existing) gop.value_ptr.* = .empty; + const failed_test = try std.fmt.allocPrint(arena, "{s} :: {s}", .{ basename, candidate.name }); + try gop.value_ptr.append(arena, failed_test); + } + + std.debug.print("{s}: {d}/{d} skips removed\n", .{ basename, removed.omit_nodes.count(), skips }); + Io.Dir.deleteFile(.cwd(), io, variant_path) catch {}; + if (removed.omit_nodes.count() == 0) continue; + + var final: Io.Writer.Allocating = .init(arena); + try ast.render(arena, &final.writer, removed); + const rendered = try Ast.parse(arena, try arena.dupeSentinel(u8, final.written(), 0), .{}); + const formatted = try rendered.renderAlloc(arena); + try Io.Dir.writeFile(.cwd(), io, .{ .sub_path = path, .data = formatted }); + total_removed += removed.omit_nodes.count(); + files_changed += 1; + } + + progress.end(); + + try stdout.print("\nDone: removed {d} spirv skips across {d} files\n", .{ total_removed, files_changed }); + if (failures.count() > 0) { + var total_failures: usize = 0; + for (failures.values()) |failed_tests| total_failures += failed_tests.items.len; + try stdout.print("\nMost common blockers ({d} failing attempts, {d} unique signatures):\n", .{ + total_failures, + failures.count(), + }); + + const Ctx = struct { + failed_tests: []const std.ArrayList([]const u8), + + pub fn lessThan(ctx: @This(), a: usize, b: usize) bool { + return ctx.failed_tests[a].items.len > ctx.failed_tests[b].items.len; + } + }; + failures.sort(Ctx{ .failed_tests = failures.values() }); + + for (failures.keys()[0..@min(failures.count(), 30)], failures.values()) |signature, failed_tests| { + const count = failed_tests.items.len; + const percent = @as(f64, @floatFromInt(count)) * 100 / @as(f64, @floatFromInt(total_failures)); + try stdout.print("{d:4} ({d:5.1}%) {s}\n", .{ count, percent, signature }); + for (failed_tests.items) |failed_test| try stdout.print(" {s}\n", .{failed_test}); + } + } + try stdout.flush(); +} + +fn allDigits(text: []const u8) bool { + if (text.len == 0) return false; + for (text) |c| if (!std.ascii.isDigit(c)) return false; + return true; +} + +fn normalize(arena: Allocator, prefix: []const u8, message: []const u8) ![]u8 { + const source = try arena.dupeSentinel(u8, std.mem.trim(u8, message, &std.ascii.whitespace), 0); + var out: std.ArrayList(u8) = .empty; + try out.appendSlice(arena, prefix); + var tokenizer: std.zig.Tokenizer = .init(source); + var end: usize = 0; + while (true) { + const token = tokenizer.next(); + if (token.tag == .eof) break; + try out.appendSlice(arena, source[end..token.loc.start]); + end = token.loc.end; + const text = source[token.loc.start..token.loc.end]; + try out.appendSlice(arena, switch (token.tag) { + .number_literal => "", + .char_literal, .string_literal => "", + .identifier => if (token.loc.start > 0 and source[token.loc.start - 1] == '%') "" else text, + else => text, + }); + } + try out.appendSlice(arena, source[end..]); + return out.items[0..@min(out.items.len, prefix.len + 200)]; +} -- 2.54.0