Commit 9fbba0e01a5e89ce4b4be940539b6b05a7fb3931 | zig

author	Robin Voetter <robin@voetter.nl> 2024-01-13 18:44:44+01:00
committer	Robin Voetter <robin@voetter.nl> 2024-02-04 19:09:33+01:00
log	9fbba0e01a5e89ce4b4be940539b6b05a7fb3931
tree	1d2fb941e27f7b6cfe7b541407b0971daf051d0e
parent	1d548aa2aab472f14013e67e29c6d898a7b31998
signature	Signed by SSH key SHA256:ZS52FNyUv2WUXvO4njmVaFVO46RHojFuOrxRc4LuKzg

spirv: update tests

27 files changed, 52 insertions(+), 26 deletions(-)

test/behavior/align.zig+3-4

...	...	@@ -18,7 +18,6 @@ test "global variable alignment" {
18	18	test "large alignment of local constant" {
19	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
20	20	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
21		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
22	21
23	22	const x: f32 align(128) = 12.34;
24	23	try std.testing.expect(@intFromPtr(&x) % 128 == 0);
...	...	@@ -27,7 +26,7 @@ test "large alignment of local constant" {
27	26	test "slicing array of length 1 can not assume runtime index is always zero" {
28	27	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
29	28	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
30		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	29	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
31	30
32	31	var runtime_index: usize = 1;
33	32	_ = &runtime_index;
...	...	@@ -512,7 +511,7 @@ test "struct field explicit alignment" {
512	511	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
513	512	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
514	513	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
515		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	514	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
516	515
517	516	const S = struct {
518	517	const Node = struct {
...	...	@@ -581,7 +580,7 @@ test "comptime alloc alignment" {
581	580	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
582	581	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
583	582	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
584		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	583	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
585	584	if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch == .x86) {
586	585	// https://github.com/ziglang/zig/issues/18034
587	586	return error.SkipZigTest;

test/behavior/array.zig-2

...	...	@@ -768,8 +768,6 @@ test "array init with no result pointer sets field result types" {
768	768	}
769	769
770	770	test "runtime side-effects in comptime-known array init" {
771		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
772
773	771	var side_effects: u4 = 0;
774	772	const init = [4]u4{
775	773	blk: {

test/behavior/basic.zig+1

...	...	@@ -1222,6 +1222,7 @@ test "integer compare" {
1222	1222
1223	1223	test "reference to inferred local variable works as expected" {
1224	1224	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1225	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1225	1226
1226	1227	const Crasher = struct {
1227	1228	lets_crash: u64 = 0,

test/behavior/builtin_functions_returning_void_or_noreturn.zig+1

...	...	@@ -11,6 +11,7 @@ test {
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14	15
15	16	var val: u8 = undefined;
16	17	try testing.expectEqual({}, @atomicStore(u8, &val, 0, .Unordered));

test/behavior/cast.zig+1-6

...	...	@@ -759,6 +759,7 @@ test "peer type resolution: error union and error set" {
759	759	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
760	760	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
761	761	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	762	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
762	763
763	764	const a: error{Three} = undefined;
764	765	const b: error{ One, Two }!u32 = undefined;
...	...	@@ -1730,7 +1731,6 @@ test "peer type resolution: array with smaller child type and vector with larger
1730	1731	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1731	1732	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1732	1733	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1733		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
1734	1734
1735	1735	var arr: [2]u8 = .{ 0, 1 };
1736	1736	var vec: @Vector(2, u64) = .{ 2, 3 };
...	...	@@ -2318,7 +2318,6 @@ test "@floatCast on vector" {
2318	2318	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2319	2319	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2320	2320	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2321		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2322	2321	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
2323	2322
2324	2323	const S = struct {
...	...	@@ -2339,7 +2338,6 @@ test "@ptrFromInt on vector" {
2339	2338	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2340	2339	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2341	2340	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2342		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2343	2341
2344	2342	const S = struct {
2345	2343	fn doTheTest() !void {
...	...	@@ -2363,7 +2361,6 @@ test "@intFromPtr on vector" {
2363	2361	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2364	2362	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2365	2363	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2366		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2367	2364
2368	2365	const S = struct {
2369	2366	fn doTheTest() !void {
...	...	@@ -2387,7 +2384,6 @@ test "@floatFromInt on vector" {
2387	2384	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2388	2385	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2389	2386	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2390		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2391	2387	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
2392	2388
2393	2389	const S = struct {
...	...	@@ -2408,7 +2404,6 @@ test "@intFromFloat on vector" {
2408	2404	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2409	2405	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2410	2406	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2411		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2412	2407
2413	2408	const S = struct {
2414	2409	fn doTheTest() !void {

test/behavior/destructure.zig+1

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const assert = std.debug.assert;
3	4	const expect = std.testing.expect;
4	5

test/behavior/duplicated_test_names.zig+2

...	...	@@ -15,5 +15,7 @@ comptime {
15	15	test "thingy" {}
16	16
17	17	test thingy {
	18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	19
18	20	if (thingy(1, 2) != 3) unreachable;
19	21	}

test/behavior/eval.zig-1

...	...	@@ -489,7 +489,6 @@ test "comptime bitwise operators" {
489	489
490	490	test "comptime shlWithOverflow" {
491	491	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
492		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
493	492
494	493	const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0];
495	494	var a = ~@as(u64, 0);

test/behavior/export_builtin.zig-3

...	...	@@ -6,7 +6,6 @@ test "exporting enum type and value" {
6	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
9		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	9
11	10	const S = struct {
12	11	const E = enum(c_int) { one, two };
...	...	@@ -22,7 +21,6 @@ test "exporting with internal linkage" {
22	21	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
23	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
24	23	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
25		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
26	24
27	25	const S = struct {
28	26	fn foo() callconv(.C) void {}
...	...	@@ -37,7 +35,6 @@ test "exporting using field access" {
37	35	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
38	36	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
39	37	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
40		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
41	38
42	39	const S = struct {
43	40	const Inner = struct {

test/behavior/export_keyword.zig+1

...	...	@@ -23,6 +23,7 @@ const PackedUnion = packed union {
23	23
24	24	test "packed struct, enum, union parameters in extern function" {
25	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	26	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
26	27
27	28	testPackedStuff(&(PackedStruct{
28	29	.a = 1,

test/behavior/extern.zig+2

...	...	@@ -5,6 +5,7 @@ const expect = std.testing.expect;
5	5	test "anyopaque extern symbol" {
6	6	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9
9	10	const a = @extern(*anyopaque, .{ .name = "a_mystery_symbol" });
10	11	const b: *i32 = @alignCast(@ptrCast(a));
...	...	@@ -17,6 +18,7 @@ test "function extern symbol" {
17	18	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
18	19	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
19	20	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
	21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20	22
21	23	const a = @extern(*const fn () callconv(.C) i32, .{ .name = "a_mystery_function" });
22	24	try expect(a() == 4567);

test/behavior/for.zig+1

...	...	@@ -456,6 +456,7 @@ test "inline for on tuple pointer" {
456	456	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
457	457	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
458	458	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	459	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
459	460
460	461	const S = struct { u32, u32, u32 };
461	462	var s: S = .{ 100, 200, 300 };

test/behavior/globals.zig-2

...	...	@@ -8,7 +8,6 @@ test "store to global array" {
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10	10	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
11		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	11
13	12	try expect(pos[1] == 0.0);
14	13	pos = [2]f32{ 0.0, 1.0 };
...	...	@@ -21,7 +20,6 @@ test "store to global vector" {
21	20	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
22	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23	22	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
24		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
25	23
26	24	try expect(vpos[1] == 0.0);
27	25	vpos = @Vector(2, f32){ 0.0, 1.0 };

test/behavior/hasdecl.zig+5

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const expect = std.testing.expect;
3	4
4	5	const Foo = @import("hasdecl/foo.zig");
...	...	@@ -11,6 +12,8 @@ const Bar = struct {
11	12	};
12	13
13	14	test "@hasDecl" {
	15	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	16
14	17	try expect(@hasDecl(Foo, "public_thing"));
15	18	try expect(!@hasDecl(Foo, "private_thing"));
16	19	try expect(!@hasDecl(Foo, "no_thing"));
...	...	@@ -21,6 +24,8 @@ test "@hasDecl" {
21	24	}
22	25
23	26	test "@hasDecl using a sliced string literal" {
	27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	28
24	29	try expect(@hasDecl(@This(), "std") == true);
25	30	try expect(@hasDecl(@This(), "std"[0..0]) == false);
26	31	try expect(@hasDecl(@This(), "std"[0..1]) == false);

test/behavior/import.zig+9

...	...	@@ -1,17 +1,24 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const expect = std.testing.expect;
3	4	const expectEqual = std.testing.expectEqual;
4	5	const a_namespace = @import("import/a_namespace.zig");
5	6
6	7	test "call fn via namespace lookup" {
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9
7	10	try expect(@as(i32, 1234) == a_namespace.foo());
8	11	}
9	12
10	13	test "importing the same thing gives the same import" {
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	15
11	16	try expect(@import("std") == @import("std"));
12	17	}
13	18
14	19	test "import in non-toplevel scope" {
	20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	21
15	22	const S = struct {
16	23	usingnamespace @import("import/a_namespace.zig");
17	24	};
...	...	@@ -19,5 +26,7 @@ test "import in non-toplevel scope" {
19	26	}
20	27
21	28	test "import empty file" {
	29	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	30
22	31	_ = @import("import/empty.zig");
23	32	}

test/behavior/int_div.zig+2

...	...	@@ -6,6 +6,7 @@ test "integer division" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	try testDivision();
11	12	try comptime testDivision();
...	...	@@ -96,6 +97,7 @@ test "large integer division" {
96	97	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
97	98	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
98	99	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
	100	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
99	101
100	102	{
101	103	var numerator: u256 = 99999999999999999997315645440;

test/behavior/math.zig-3

...	...	@@ -602,7 +602,6 @@ fn testUnsignedNegationWrappingEval(x: u16) !void {
602	602	test "negation wrapping" {
603	603	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
604	604	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
605		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
606	605
607	606	try expectEqual(@as(u1, 1), negateWrap(u1, 1));
608	607	}
...	...	@@ -770,7 +769,6 @@ test "@addWithOverflow" {
770	769	test "small int addition" {
771	770	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
772	771	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
773		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
774	772
775	773	var x: u2 = 0;
776	774	try expect(x == 0);
...	...	@@ -1564,7 +1562,6 @@ test "vector integer addition" {
1564	1562	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1565	1563	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1566	1564	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1567		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1568	1565
1569	1566	const S = struct {
1570	1567	fn doTheTest() !void {

test/behavior/namespace_depends_on_compile_var.zig+2

...	...	@@ -3,6 +3,8 @@ const builtin = @import("builtin");
3	3	const expect = std.testing.expect;
4	4
5	5	test "namespace depends on compile var" {
	6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	7
6	8	if (some_namespace.a_bool) {
7	9	try expect(some_namespace.a_bool);
8	10	} else {

test/behavior/optional.zig+1

...	...	@@ -451,6 +451,7 @@ test "Optional slice passed to function" {
451	451	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
452	452	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
453	453	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	454	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
454	455
455	456	const S = struct {
456	457	fn foo(a: ?[]const u8) !void {

test/behavior/pub_enum.zig+4

...	...	@@ -3,6 +3,8 @@ const other = @import("pub_enum/other.zig");
3	3	const expect = @import("std").testing.expect;
4	4
5	5	test "pub enum" {
	6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	7
6	8	try pubEnumTest(other.APubEnum.Two);
7	9	}
8	10	fn pubEnumTest(foo: other.APubEnum) !void {
...	...	@@ -10,5 +12,7 @@ fn pubEnumTest(foo: other.APubEnum) !void {
10	12	}
11	13
12	14	test "cast with imported symbol" {
	15	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	16
13	17	try expect(@as(other.size_t, 42) == 42);
14	18	}

test/behavior/slice_sentinel_comptime.zig+2

...	...	@@ -1,3 +1,5 @@
	1	const builtin = @import("builtin");
	2
1	3	test "comptime slice-sentinel in bounds (unterminated)" {
2	4	// array
3	5	comptime {

test/behavior/struct.zig+2-2

...	...	@@ -1744,8 +1744,6 @@ test "struct init with no result pointer sets field result types" {
1744	1744	}
1745	1745
1746	1746	test "runtime side-effects in comptime-known struct init" {
1747		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1748
1749	1747	var side_effects: u4 = 0;
1750	1748	const S = struct { a: u4, b: u4, c: u4, d: u4 };
1751	1749	const init = S{
...	...	@@ -2056,6 +2054,8 @@ test "struct field default value is a call" {
2056	2054	}
2057	2055
2058	2056	test "aggregate initializers should allow initializing comptime fields, verifying equality" {
	2057	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2058
2059	2059	var x: u32 = 15;
2060	2060	_ = &x;
2061	2061	const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });

test/behavior/switch_on_captured_error.zig+4

...	...	@@ -5,6 +5,8 @@ const expectError = std.testing.expectError;
5	5	const expectEqual = std.testing.expectEqual;
6	6
7	7	test "switch on error union catch capture" {
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9
8	10	const S = struct {
9	11	const Error = error{ A, B, C };
10	12	fn doTheTest() !void {
...	...	@@ -257,6 +259,8 @@ test "switch on error union catch capture" {
257	259	}
258	260
259	261	test "switch on error union if else capture" {
	262	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	263
260	264	const S = struct {
261	265	const Error = error{ A, B, C };
262	266	fn doTheTest() !void {

test/behavior/tuple.zig-1

...	...	@@ -483,7 +483,6 @@ test "empty tuple type" {
483	483
484	484	test "tuple with comptime fields with non empty initializer" {
485	485	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
486		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
487	486
488	487	const a: struct { comptime comptime_int = 0 } = .{0};
489	488	_ = a;

test/behavior/union.zig+2-1

...	...	@@ -1119,6 +1119,7 @@ test "@unionInit on union with tag but no fields" {
1119	1119	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1120	1120	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1121	1121	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1122	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1122	1123
1123	1124	const S = struct {
1124	1125	const Type = enum(u8) { no_op = 105 };
...	...	@@ -2059,7 +2060,6 @@ test "store of comptime reinterpreted memory to packed union" {
2059	2060
2060	2061	test "union field is a pointer to an aligned version of itself" {
2061	2062	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2062		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2063	2063
2064	2064	const E = union {
2065	2065	next: *align(1) @This(),
...	...	@@ -2181,6 +2181,7 @@ test "create union(enum) from other union(enum)" {
2181	2181	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
2182	2182	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2183	2183	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	2184	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2184	2185
2185	2186	const string = "hello world";
2186	2187	const TempRef = struct {

test/behavior/vector.zig-1

...	...	@@ -1060,7 +1060,6 @@ test "@addWithOverflow" {
1060	1060	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1061	1061	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1062	1062	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1063		// if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1064	1063
1065	1064	const S = struct {
1066	1065	fn doTheTest() !void {

test/behavior/wrapping_arithmetic.zig+6

...	...	@@ -5,6 +5,8 @@ const maxInt = std.math.maxInt;
5	5	const expect = std.testing.expect;
6	6
7	7	test "wrapping add" {
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9
8	10	const S = struct {
9	11	fn doTheTest() !void {
10	12	try testWrapAdd(i8, -3, 10, 7);
...	...	@@ -40,6 +42,8 @@ test "wrapping add" {
40	42	}
41	43
42	44	test "wrapping subtraction" {
	45	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	46
43	47	const S = struct {
44	48	fn doTheTest() !void {
45	49	try testWrapSub(i8, -3, 10, -13);
...	...	@@ -73,6 +77,8 @@ test "wrapping subtraction" {
73	77	}
74	78
75	79	test "wrapping multiplication" {
	80	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	81
76	82	// TODO: once #9660 has been solved, remove this line
77	83	if (builtin.cpu.arch == .wasm32) return error.SkipZigTest;
78	84