From 9fbba0e01a5e89ce4b4be940539b6b05a7fb3931 Mon Sep 17 00:00:00 2001
From: Robin Voetter <robin@voetter.nl>
Date: Sat, 13 Jan 2024 18:44:44 +0100
Subject: [PATCH] spirv: update tests

---
 test/behavior/align.zig                                  | 7 +++----
 test/behavior/array.zig                                  | 2 --
 test/behavior/basic.zig                                  | 1 +
 .../builtin_functions_returning_void_or_noreturn.zig     | 1 +
 test/behavior/cast.zig                                   | 7 +------
 test/behavior/destructure.zig                            | 1 +
 test/behavior/duplicated_test_names.zig                  | 2 ++
 test/behavior/eval.zig                                   | 1 -
 test/behavior/export_builtin.zig                         | 3 ---
 test/behavior/export_keyword.zig                         | 1 +
 test/behavior/extern.zig                                 | 2 ++
 test/behavior/for.zig                                    | 1 +
 test/behavior/globals.zig                                | 2 --
 test/behavior/hasdecl.zig                                | 5 +++++
 test/behavior/import.zig                                 | 9 +++++++++
 test/behavior/int_div.zig                                | 2 ++
 test/behavior/math.zig                                   | 3 ---
 test/behavior/namespace_depends_on_compile_var.zig       | 2 ++
 test/behavior/optional.zig                               | 1 +
 test/behavior/pub_enum.zig                               | 4 ++++
 test/behavior/slice_sentinel_comptime.zig                | 2 ++
 test/behavior/struct.zig                                 | 4 ++--
 test/behavior/switch_on_captured_error.zig               | 4 ++++
 test/behavior/tuple.zig                                  | 1 -
 test/behavior/union.zig                                  | 3 ++-
 test/behavior/vector.zig                                 | 1 -
 test/behavior/wrapping_arithmetic.zig                    | 6 ++++++
 27 files changed, 52 insertions(+), 26 deletions(-)

diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index 03109b1e8d7beffd6fac5e021997ecab3980da44..e00fbe67443f0bf13281cc15d06f69653beaead3 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -18,7 +18,6 @@ test "global variable alignment" {
 test "large alignment of local constant" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
 
     const x: f32 align(128) = 12.34;
     try std.testing.expect(@intFromPtr(&x) % 128 == 0);
@@ -27,7 +26,7 @@ test "large alignment of local constant" {
 test "slicing array of length 1 can not assume runtime index is always zero" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
 
     var runtime_index: usize = 1;
     _ = &runtime_index;
@@ -512,7 +511,7 @@ test "struct field explicit alignment" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
 
     const S = struct {
         const Node = struct {
@@ -581,7 +580,7 @@ test "comptime alloc alignment" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
     if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch == .x86) {
         // https://github.com/ziglang/zig/issues/18034
         return error.SkipZigTest;
diff --git a/test/behavior/array.zig b/test/behavior/array.zig
index 75141c6bd13aca1b6101dee568fa8ff51be9de43..5e3a9fb52f995c9311a2d4adf3cf14b53de381b6 100644
--- a/test/behavior/array.zig
+++ b/test/behavior/array.zig
@@ -768,8 +768,6 @@ test "array init with no result pointer sets field result types" {
 }
 
 test "runtime side-effects in comptime-known array init" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     var side_effects: u4 = 0;
     const init = [4]u4{
         blk: {
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 42792f4acad5c309f3670edc664e94928a9b17c2..9747206a760cc509fc381459a8fe2c451e70fdd8 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -1222,6 +1222,7 @@ test "integer compare" {
 
 test "reference to inferred local variable works as expected" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const Crasher = struct {
         lets_crash: u64 = 0,
diff --git a/test/behavior/builtin_functions_returning_void_or_noreturn.zig b/test/behavior/builtin_functions_returning_void_or_noreturn.zig
index 1eb2ef3049ffb8ee649908098a48157fcc39e658..48cf0bc5c6e3de4ba9fe8aeb3c80acbeb92e9a15 100644
--- a/test/behavior/builtin_functions_returning_void_or_noreturn.zig
+++ b/test/behavior/builtin_functions_returning_void_or_noreturn.zig
@@ -11,6 +11,7 @@ test {
     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; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var val: u8 = undefined;
     try testing.expectEqual({}, @atomicStore(u8, &val, 0, .Unordered));
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index c59a9803c092a69cb95128ca41d2405ffad1c1e8..d691949bae3f78301b6d271aa3a845f22541d54e 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -759,6 +759,7 @@ test "peer type resolution: error union and error set" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const a: error{Three} = undefined;
     const b: error{ One, Two }!u32 = undefined;
@@ -1730,7 +1731,6 @@ test "peer type resolution: array with smaller child type and vector with larger
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     var arr: [2]u8 = .{ 0, 1 };
     var vec: @Vector(2, u64) = .{ 2, 3 };
@@ -2318,7 +2318,6 @@ test "@floatCast on vector" {
     if (builtin.zig_backend == .stage2_aarch64) 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_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     const S = struct {
@@ -2339,7 +2338,6 @@ test "@ptrFromInt on vector" {
     if (builtin.zig_backend == .stage2_aarch64) 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_spirv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -2363,7 +2361,6 @@ test "@intFromPtr on vector" {
     if (builtin.zig_backend == .stage2_aarch64) 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_spirv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -2387,7 +2384,6 @@ test "@floatFromInt on vector" {
     if (builtin.zig_backend == .stage2_aarch64) 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_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     const S = struct {
@@ -2408,7 +2404,6 @@ test "@intFromFloat on vector" {
     if (builtin.zig_backend == .stage2_aarch64) 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_spirv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/destructure.zig b/test/behavior/destructure.zig
index c2a5ca329a5513145e294ad5194a4fedded39524..1c249ed8d505d68c981ec1b2fa802c62c9804a8e 100644
--- a/test/behavior/destructure.zig
+++ b/test/behavior/destructure.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const assert = std.debug.assert;
 const expect = std.testing.expect;
 
diff --git a/test/behavior/duplicated_test_names.zig b/test/behavior/duplicated_test_names.zig
index 52930ea31819c042a6e3077fc7fd0bacaed5bf92..81b9ebdf50ceaa21b7f8c9953bb9257bd8fa079c 100644
--- a/test/behavior/duplicated_test_names.zig
+++ b/test/behavior/duplicated_test_names.zig
@@ -15,5 +15,7 @@ comptime {
 test "thingy" {}
 
 test thingy {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     if (thingy(1, 2) != 3) unreachable;
 }
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 078fae519af48a0d6bc0266e0c69eda14e5fa9ab..5fdfacf2dbb694d5c9a9fc7b4dff304790f4a2b7 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -489,7 +489,6 @@ test "comptime bitwise operators" {
 
 test "comptime shlWithOverflow" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0];
     var a = ~@as(u64, 0);
diff --git a/test/behavior/export_builtin.zig b/test/behavior/export_builtin.zig
index e3ea1f7e0be94857ddbe78850cd825db29bc0c64..6755a127f5c807b4a526e57d9d3dc60b0689b139 100644
--- a/test/behavior/export_builtin.zig
+++ b/test/behavior/export_builtin.zig
@@ -6,7 +6,6 @@ test "exporting enum type and value" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         const E = enum(c_int) { one, two };
@@ -22,7 +21,6 @@ test "exporting with internal linkage" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         fn foo() callconv(.C) void {}
@@ -37,7 +35,6 @@ test "exporting using field access" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         const Inner = struct {
diff --git a/test/behavior/export_keyword.zig b/test/behavior/export_keyword.zig
index 34228c8e7fa71fb6d327c4e34c27972885cc974e..a6baf6d1a598ee9e50901a1b088e3ea8ffbf1801 100644
--- a/test/behavior/export_keyword.zig
+++ b/test/behavior/export_keyword.zig
@@ -23,6 +23,7 @@ const PackedUnion = packed union {
 
 test "packed struct, enum, union parameters in extern function" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     testPackedStuff(&(PackedStruct{
         .a = 1,
diff --git a/test/behavior/extern.zig b/test/behavior/extern.zig
index af9c86e3beba8a8a40883b811c5b4cd40d59afc7..65bc517210afc4df688cae4605e8b8201e4ab8d1 100644
--- a/test/behavior/extern.zig
+++ b/test/behavior/extern.zig
@@ -5,6 +5,7 @@ const expect = std.testing.expect;
 test "anyopaque extern symbol" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const a = @extern(*anyopaque, .{ .name = "a_mystery_symbol" });
     const b: *i32 = @alignCast(@ptrCast(a));
@@ -17,6 +18,7 @@ test "function extern symbol" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const a = @extern(*const fn () callconv(.C) i32, .{ .name = "a_mystery_function" });
     try expect(a() == 4567);
diff --git a/test/behavior/for.zig b/test/behavior/for.zig
index 53e21f5ce518004ece277a1e8f6a93d7c819eb00..4fd0b577503e8788803ebfaf0b414d4296d502ce 100644
--- a/test/behavior/for.zig
+++ b/test/behavior/for.zig
@@ -456,6 +456,7 @@ test "inline for on tuple pointer" {
     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_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct { u32, u32, u32 };
     var s: S = .{ 100, 200, 300 };
diff --git a/test/behavior/globals.zig b/test/behavior/globals.zig
index 25968ba4242d7a695528208e16b940eebd4d740c..bf4651218340783ccfec58aa30d8deaa430d6863 100644
--- a/test/behavior/globals.zig
+++ b/test/behavior/globals.zig
@@ -8,7 +8,6 @@ test "store to global array" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try expect(pos[1] == 0.0);
     pos = [2]f32{ 0.0, 1.0 };
@@ -21,7 +20,6 @@ test "store to global vector" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try expect(vpos[1] == 0.0);
     vpos = @Vector(2, f32){ 0.0, 1.0 };
diff --git a/test/behavior/hasdecl.zig b/test/behavior/hasdecl.zig
index e297979ba2a0d19ca8e0cb18588541df8174a76b..4ab521ceef5583efd367e6c23d6442a00fce95d4 100644
--- a/test/behavior/hasdecl.zig
+++ b/test/behavior/hasdecl.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 const Foo = @import("hasdecl/foo.zig");
@@ -11,6 +12,8 @@ const Bar = struct {
 };
 
 test "@hasDecl" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     try expect(@hasDecl(Foo, "public_thing"));
     try expect(!@hasDecl(Foo, "private_thing"));
     try expect(!@hasDecl(Foo, "no_thing"));
@@ -21,6 +24,8 @@ test "@hasDecl" {
 }
 
 test "@hasDecl using a sliced string literal" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     try expect(@hasDecl(@This(), "std") == true);
     try expect(@hasDecl(@This(), "std"[0..0]) == false);
     try expect(@hasDecl(@This(), "std"[0..1]) == false);
diff --git a/test/behavior/import.zig b/test/behavior/import.zig
index c36aea7d2a9526c4070bd8b7e58a4c1ba4841d97..c2bb39983dfd52389870ab8938d563608eb8b4aa 100644
--- a/test/behavior/import.zig
+++ b/test/behavior/import.zig
@@ -1,17 +1,24 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 const a_namespace = @import("import/a_namespace.zig");
 
 test "call fn via namespace lookup" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     try expect(@as(i32, 1234) == a_namespace.foo());
 }
 
 test "importing the same thing gives the same import" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     try expect(@import("std") == @import("std"));
 }
 
 test "import in non-toplevel scope" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const S = struct {
         usingnamespace @import("import/a_namespace.zig");
     };
@@ -19,5 +26,7 @@ test "import in non-toplevel scope" {
 }
 
 test "import empty file" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     _ = @import("import/empty.zig");
 }
diff --git a/test/behavior/int_div.zig b/test/behavior/int_div.zig
index bc570434cec90a9488359aa8231cb4472d3dc505..19329f1176c840ea1caca7140f0b014c632c02d4 100644
--- a/test/behavior/int_div.zig
+++ b/test/behavior/int_div.zig
@@ -6,6 +6,7 @@ test "integer division" {
     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_spirv64) return error.SkipZigTest;
 
     try testDivision();
     try comptime testDivision();
@@ -96,6 +97,7 @@ test "large integer division" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     {
         var numerator: u256 = 99999999999999999997315645440;
diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index dc4d5f894a764485275a2c82459b4e13b67361f5..e637bc8ac1cac2148d45e32fd4d24cc6cabc2e39 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -602,7 +602,6 @@ fn testUnsignedNegationWrappingEval(x: u16) !void {
 test "negation wrapping" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     try expectEqual(@as(u1, 1), negateWrap(u1, 1));
 }
@@ -770,7 +769,6 @@ test "@addWithOverflow" {
 test "small int addition" {
     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_spirv64) return error.SkipZigTest;
 
     var x: u2 = 0;
     try expect(x == 0);
@@ -1564,7 +1562,6 @@ test "vector integer addition" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/namespace_depends_on_compile_var.zig b/test/behavior/namespace_depends_on_compile_var.zig
index 84b7e21d384c6728a1b0318b11eab91fad58f460..a115f557ab46b5fa8b34b20e2e79337356da998a 100644
--- a/test/behavior/namespace_depends_on_compile_var.zig
+++ b/test/behavior/namespace_depends_on_compile_var.zig
@@ -3,6 +3,8 @@ const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 test "namespace depends on compile var" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     if (some_namespace.a_bool) {
         try expect(some_namespace.a_bool);
     } else {
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index 3da78aea0a744e7882e5a83fb278190a0bd22cb6..32ba8ff8d3e199fee3abe00e816f7ce9f40922c9 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -451,6 +451,7 @@ test "Optional slice passed to function" {
     if (builtin.zig_backend == .stage2_aarch64) 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_spirv64) return error.SkipZigTest;
 
     const S = struct {
         fn foo(a: ?[]const u8) !void {
diff --git a/test/behavior/pub_enum.zig b/test/behavior/pub_enum.zig
index e17546157db49e1eea6e586f0e098b4f5fda1c88..c0935b78be2d65afb20e8626019e7e9a1a9b3d0a 100644
--- a/test/behavior/pub_enum.zig
+++ b/test/behavior/pub_enum.zig
@@ -3,6 +3,8 @@ const other = @import("pub_enum/other.zig");
 const expect = @import("std").testing.expect;
 
 test "pub enum" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     try pubEnumTest(other.APubEnum.Two);
 }
 fn pubEnumTest(foo: other.APubEnum) !void {
@@ -10,5 +12,7 @@ fn pubEnumTest(foo: other.APubEnum) !void {
 }
 
 test "cast with imported symbol" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     try expect(@as(other.size_t, 42) == 42);
 }
diff --git a/test/behavior/slice_sentinel_comptime.zig b/test/behavior/slice_sentinel_comptime.zig
index 31b7e2349eeb45f1098833f3c58f44d7b8cac8ca..51cf7d428bee8e0ebd51e8e2efa202ebaeff64fb 100644
--- a/test/behavior/slice_sentinel_comptime.zig
+++ b/test/behavior/slice_sentinel_comptime.zig
@@ -1,3 +1,5 @@
+const builtin = @import("builtin");
+
 test "comptime slice-sentinel in bounds (unterminated)" {
     // array
     comptime {
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index c74d6344ddb2bb349639826b3952c052ad3b24e5..37d201288ae2e160a6d47f1f2acbf3a1905d2dd8 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -1744,8 +1744,6 @@ test "struct init with no result pointer sets field result types" {
 }
 
 test "runtime side-effects in comptime-known struct init" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
     var side_effects: u4 = 0;
     const S = struct { a: u4, b: u4, c: u4, d: u4 };
     const init = S{
@@ -2056,6 +2054,8 @@ test "struct field default value is a call" {
 }
 
 test "aggregate initializers should allow initializing comptime fields, verifying equality" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     var x: u32 = 15;
     _ = &x;
     const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });
diff --git a/test/behavior/switch_on_captured_error.zig b/test/behavior/switch_on_captured_error.zig
index b6b422ba93cd12c996aa2c5297138e9850014605..f5ba762559fade8e2d445814eb218a6e66e0dfe0 100644
--- a/test/behavior/switch_on_captured_error.zig
+++ b/test/behavior/switch_on_captured_error.zig
@@ -5,6 +5,8 @@ const expectError = std.testing.expectError;
 const expectEqual = std.testing.expectEqual;
 
 test "switch on error union catch capture" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const S = struct {
         const Error = error{ A, B, C };
         fn doTheTest() !void {
@@ -257,6 +259,8 @@ test "switch on error union catch capture" {
 }
 
 test "switch on error union if else capture" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const S = struct {
         const Error = error{ A, B, C };
         fn doTheTest() !void {
diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig
index dd0f7f1007ea3c6e28cc19bf9cb5b7e01150ae6a..0e382b3a9d82326d474a135df748e95cdedf38ec 100644
--- a/test/behavior/tuple.zig
+++ b/test/behavior/tuple.zig
@@ -483,7 +483,6 @@ test "empty tuple type" {
 
 test "tuple with comptime fields with non empty initializer" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const a: struct { comptime comptime_int = 0 } = .{0};
     _ = a;
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index bff21c1b6f2156222cdb1a8b2be4768c6e2d2fd0..fa050d36be24f2fe638c62e3f7ba4aae70075209 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1119,6 +1119,7 @@ test "@unionInit on union with tag but no fields" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         const Type = enum(u8) { no_op = 105 };
@@ -2059,7 +2060,6 @@ test "store of comptime reinterpreted memory to packed union" {
 
 test "union field is a pointer to an aligned version of itself" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const E = union {
         next: *align(1) @This(),
@@ -2181,6 +2181,7 @@ test "create union(enum) from other union(enum)" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const string = "hello world";
     const TempRef = struct {
diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index 9aedac66e5c5fa92db1a8e1f10a4e802256ae5ce..07a695d61d87a48e1ec051a720a16757f491f155 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -1060,7 +1060,6 @@ test "@addWithOverflow" {
     if (builtin.zig_backend == .stage2_aarch64) 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_spirv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/wrapping_arithmetic.zig b/test/behavior/wrapping_arithmetic.zig
index 23ebcfaf61ca47aeedf9494b4f142fe5435fb110..2733edad7178c4b54e4cd4f06e87c22cd5145d20 100644
--- a/test/behavior/wrapping_arithmetic.zig
+++ b/test/behavior/wrapping_arithmetic.zig
@@ -5,6 +5,8 @@ const maxInt = std.math.maxInt;
 const expect = std.testing.expect;
 
 test "wrapping add" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             try testWrapAdd(i8, -3, 10, 7);
@@ -40,6 +42,8 @@ test "wrapping add" {
 }
 
 test "wrapping subtraction" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     const S = struct {
         fn doTheTest() !void {
             try testWrapSub(i8, -3, 10, -13);
@@ -73,6 +77,8 @@ test "wrapping subtraction" {
 }
 
 test "wrapping multiplication" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
     // TODO: once #9660 has been solved, remove this line
     if (builtin.cpu.arch == .wasm32) return error.SkipZigTest;
 
-- 
2.54.0