From 6de457211fe4f261fab6c30f652f833ed2a144b5 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Thu, 27 Apr 2023 03:24:48 -0400 Subject: behavior: update affected tests for the x86_64 backend --- test/behavior/basic.zig | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 437b1b1373..86fc61c2c9 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -363,7 +363,8 @@ fn hereIsAnOpaqueType(ptr: *OpaqueA) *OpaqueA { } test "take address of parameter" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and + comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO 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 @@ -391,7 +392,8 @@ test "array 2D const double ptr" { 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; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and + comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO const rect_2d_vertexes = [_][1]f32{ @@ -405,7 +407,8 @@ test "array 2D const double ptr with offset" { 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; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and + comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; const rect_2d_vertexes = [_][2]f32{ @@ -419,7 +422,8 @@ test "array 3D const double ptr with offset" { 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; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and + comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO const rect_3d_vertexes = [_][2][2]f32{ -- cgit v1.2.3 From 36a39267b89583ad1dded42a54de90a7f9b5eacf Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Tue, 2 May 2023 21:01:59 -0400 Subject: x86_64: fix feature confusion --- src/arch/x86_64/CodeGen.zig | 7 ++++++- test/behavior/basic.zig | 8 -------- test/behavior/bugs/13069.zig | 2 -- test/behavior/cast.zig | 5 ----- test/behavior/enum.zig | 2 -- test/behavior/eval.zig | 2 -- test/behavior/floatop.zig | 10 ---------- test/behavior/fn.zig | 4 ---- test/behavior/generics.zig | 4 ---- test/behavior/math.zig | 2 -- test/behavior/maximum_minimum.zig | 4 ---- test/behavior/pointers.zig | 4 ---- test/behavior/struct.zig | 2 -- test/behavior/switch.zig | 2 -- test/behavior/union.zig | 14 -------------- 15 files changed, 6 insertions(+), 66 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig index 5685357108..9487cc33c2 100644 --- a/src/arch/x86_64/CodeGen.zig +++ b/src/arch/x86_64/CodeGen.zig @@ -5879,7 +5879,12 @@ fn genBinOpMir(self: *Self, mir_tag: Mir.Inst.Tag, ty: Type, dst_mcv: MCValue, s .load_got, .load_tlv, => { - const addr_reg = try self.copyToTmpRegister(ty, src_mcv.address()); + var ptr_pl = Type.Payload.ElemType{ + .base = .{ .tag = .single_const_pointer }, + .data = ty, + }; + const ptr_ty = Type.initPayload(&ptr_pl.base); + const addr_reg = try self.copyToTmpRegister(ptr_ty, src_mcv.address()); return self.genBinOpMir(mir_tag, ty, dst_mcv, .{ .indirect = .{ .reg = addr_reg }, }); diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 86fc61c2c9..6fdd309371 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -363,8 +363,6 @@ fn hereIsAnOpaqueType(ptr: *OpaqueA) *OpaqueA { } test "take address of parameter" { - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO 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 @@ -392,8 +390,6 @@ test "array 2D const double ptr" { 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; - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO const rect_2d_vertexes = [_][1]f32{ @@ -407,8 +403,6 @@ test "array 2D const double ptr with offset" { 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; - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; const rect_2d_vertexes = [_][2]f32{ @@ -422,8 +416,6 @@ test "array 3D const double ptr with offset" { 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; - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO const rect_3d_vertexes = [_][2][2]f32{ diff --git a/test/behavior/bugs/13069.zig b/test/behavior/bugs/13069.zig index 1c2526ef2a..41c5906ee6 100644 --- a/test/behavior/bugs/13069.zig +++ b/test/behavior/bugs/13069.zig @@ -6,8 +6,6 @@ test { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO var opt_x: ?[3]f32 = [_]f32{0.0} ** 3; diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index cbf1712f67..039e0a3d17 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -95,9 +95,6 @@ test "comptime_int @intToFloat" { test "@intToFloat" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO @@ -636,8 +633,6 @@ test "vector casts" { } test "@floatCast cast down" { - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) 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_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index 26b941bcdc..5f0037f6dc 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -940,8 +940,6 @@ test "constant enum initialization with differing sizes" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO try test3_1(test3_foo); try test3_2(test3_bar); diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig index c7285ef8a8..b12fcc7afa 100644 --- a/test/behavior/eval.zig +++ b/test/behavior/eval.zig @@ -535,8 +535,6 @@ test "static eval list init" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO try expect(static_vec3.data[2] == 1.0); try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0); diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig index ecf1473d14..b98d782da1 100644 --- a/test/behavior/floatop.zig +++ b/test/behavior/floatop.zig @@ -96,8 +96,6 @@ test "negative f128 floatToInt at compile-time" { } test "@sqrt" { - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) 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_sparc64) return error.SkipZigTest; // TODO @@ -905,8 +903,6 @@ test "negation f16" { } test "negation f32" { - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) 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_sparc64) return error.SkipZigTest; // TODO @@ -926,8 +922,6 @@ test "negation f32" { } test "negation f64" { - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) 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_sparc64) return error.SkipZigTest; // TODO @@ -1062,8 +1056,6 @@ test "nan negation f16" { } test "nan negation f32" { - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) 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_sparc64) return error.SkipZigTest; // TODO @@ -1083,8 +1075,6 @@ test "nan negation f32" { test "nan negation f64" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) 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_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig index 71b7b36c21..4ff5e20378 100644 --- a/test/behavior/fn.zig +++ b/test/behavior/fn.zig @@ -338,8 +338,6 @@ test "function call with anon list literal" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -360,8 +358,6 @@ test "function call with anon list literal - 2D" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig index 367f2113d9..e7c053e36c 100644 --- a/test/behavior/generics.zig +++ b/test/behavior/generics.zig @@ -59,8 +59,6 @@ test "fn with comptime args" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO try expect(gimmeTheBigOne(1234, 5678) == 5678); try expect(shouldCallSameInstance(34, 12) == 34); @@ -71,8 +69,6 @@ test "anytype params" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO try expect(max_i32(12, 34) == 34); try expect(max_f64(1.2, 3.4) == 3.4); diff --git a/test/behavior/math.zig b/test/behavior/math.zig index 01b927b913..f9c9f43927 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -203,8 +203,6 @@ test "float equality" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const x: f64 = 0.012; const y: f64 = x + 1.0; diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig index d7b93c56c0..e6a8553e8c 100644 --- a/test/behavior/maximum_minimum.zig +++ b/test/behavior/maximum_minimum.zig @@ -8,8 +8,6 @@ test "@max" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -56,8 +54,6 @@ test "@min" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig index 0bd8388660..cfce97b550 100644 --- a/test/behavior/pointers.zig +++ b/test/behavior/pointers.zig @@ -206,8 +206,6 @@ test "allowzero pointer and slice" { } test "assign null directly to C pointer and test null equality" { - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) 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_sparc64) return error.SkipZigTest; // TODO @@ -346,8 +344,6 @@ test "pointer sentinel with +inf" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index d5972b9161..0ca7f70de1 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -744,8 +744,6 @@ var g_foo: S0 = S0.init(); test "packed struct with fp fields" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) 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_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig index 5e2d6d28c1..a32a762e04 100644 --- a/test/behavior/switch.zig +++ b/test/behavior/switch.zig @@ -230,8 +230,6 @@ test "switch prong with variable" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 }); try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 }); diff --git a/test/behavior/union.zig b/test/behavior/union.zig index d8989c21f0..41842f5bc5 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -14,8 +14,6 @@ test "basic unions with floats" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO var foo = FooWithFloats{ .int = 1 }; try expect(foo.int == 1); @@ -31,8 +29,6 @@ test "init union with runtime value - floats" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO var foo: FooWithFloats = undefined; @@ -220,8 +216,6 @@ test "union with specified enum tag" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO try doTest(); comptime try doTest(); @@ -231,8 +225,6 @@ test "packed union generates correctly aligned type" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const U = packed union { f1: *const fn () error{TestUnexpectedResult}!void, @@ -910,8 +902,6 @@ test "anonymous union literal syntax" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const S = struct { const Number = union { @@ -1064,8 +1054,6 @@ test "containers with single-field enums" { 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_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const S = struct { const A = union(enum) { f1 }; @@ -1524,8 +1512,6 @@ test "reinterpreting enum value inside packed union" { 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_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and - comptime !std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sse, .sse2, .sse4_1 })) return error.SkipZigTest; // TODO const U = packed union { tag: enum { a, b }, -- cgit v1.2.3 From 5a3eca5d4ca42f92abe60040e21ffd8e307d8466 Mon Sep 17 00:00:00 2001 From: Dominic <4678790+dweiller@users.noreply.github.com> Date: Mon, 8 May 2023 17:59:06 +1000 Subject: Disallow named test decls with duplicate names --- lib/std/fmt.zig | 75 +++++++++++----------- lib/std/hash_map.zig | 34 +++++----- lib/std/io/reader.zig | 23 +++---- lib/std/math/big/int_test.zig | 13 ++-- lib/std/math/big/rational.zig | 52 +++++++-------- lib/std/net/test.zig | 2 +- lib/std/priority_dequeue.zig | 4 +- lib/std/zig/parser_test.zig | 8 +-- src/Module.zig | 26 +++++++- test/behavior.zig | 1 + test/behavior/basic.zig | 2 +- test/behavior/comptime_memory.zig | 2 +- test/behavior/duplicated_test_names.zig | 17 +++++ test/behavior/vector.zig | 14 ---- .../invalid_duplicate_test_decl_name.zig | 10 +++ 15 files changed, 158 insertions(+), 125 deletions(-) create mode 100644 test/behavior/duplicated_test_names.zig create mode 100644 test/cases/compile_errors/invalid_duplicate_test_decl_name.zig (limited to 'test/behavior/basic.zig') diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig index cf791df1a6..c3ccd75d27 100644 --- a/lib/std/fmt.zig +++ b/lib/std/fmt.zig @@ -2244,8 +2244,8 @@ test "struct" { field: u8, }; const value = Struct{ .field = 42 }; - try expectFmt("struct: Struct{ .field = 42 }\n", "struct: {}\n", .{value}); - try expectFmt("struct: Struct{ .field = 42 }\n", "struct: {}\n", .{&value}); + try expectFmt("struct: fmt.test.struct.Struct{ .field = 42 }\n", "struct: {}\n", .{value}); + try expectFmt("struct: fmt.test.struct.Struct{ .field = 42 }\n", "struct: {}\n", .{&value}); } { const Struct = struct { @@ -2253,8 +2253,24 @@ test "struct" { b: u1, }; const value = Struct{ .a = 0, .b = 1 }; - try expectFmt("struct: Struct{ .a = 0, .b = 1 }\n", "struct: {}\n", .{value}); + try expectFmt("struct: fmt.test.struct.Struct{ .a = 0, .b = 1 }\n", "struct: {}\n", .{value}); } + + const S = struct { + a: u32, + b: anyerror, + }; + + const inst = S{ + .a = 456, + .b = error.Unused, + }; + + try expectFmt("fmt.test.struct.S{ .a = 456, .b = error.Unused }", "{}", .{inst}); + // Tuples + try expectFmt("{ }", "{}", .{.{}}); + try expectFmt("{ -1 }", "{}", .{.{-1}}); + try expectFmt("{ -1, 42, 2.5e+04 }", "{}", .{.{ -1, 42, 0.25e5 }}); } test "enum" { @@ -2263,13 +2279,26 @@ test "enum" { Two, }; const value = Enum.Two; - try expectFmt("enum: Enum.Two\n", "enum: {}\n", .{value}); - try expectFmt("enum: Enum.Two\n", "enum: {}\n", .{&value}); - try expectFmt("enum: Enum.One\n", "enum: {}\n", .{Enum.One}); - try expectFmt("enum: Enum.Two\n", "enum: {}\n", .{Enum.Two}); + try expectFmt("enum: fmt.test.enum.Enum.Two\n", "enum: {}\n", .{value}); + try expectFmt("enum: fmt.test.enum.Enum.Two\n", "enum: {}\n", .{&value}); + try expectFmt("enum: fmt.test.enum.Enum.One\n", "enum: {}\n", .{Enum.One}); + try expectFmt("enum: fmt.test.enum.Enum.Two\n", "enum: {}\n", .{Enum.Two}); // test very large enum to verify ct branch quota is large enough - try expectFmt("enum: os.windows.win32error.Win32Error.INVALID_FUNCTION\n", "enum: {}\n", .{std.os.windows.Win32Error.INVALID_FUNCTION}); + // TODO: https://github.com/ziglang/zig/issues/15609 + if (!((builtin.cpu.arch == .wasm32) and builtin.mode == .Debug)) { + try expectFmt("enum: os.windows.win32error.Win32Error.INVALID_FUNCTION\n", "enum: {}\n", .{std.os.windows.Win32Error.INVALID_FUNCTION}); + } + + const E = enum { + One, + Two, + Three, + }; + + const inst = E.Two; + + try expectFmt("fmt.test.enum.E.Two", "{}", .{inst}); } test "non-exhaustive enum" { @@ -2445,24 +2474,6 @@ test "custom" { try expectFmt("dim: 10.200x2.220\n", "dim: {d}\n", .{value}); } -test "struct" { - const S = struct { - a: u32, - b: anyerror, - }; - - const inst = S{ - .a = 456, - .b = error.Unused, - }; - - try expectFmt("fmt.test.struct.S{ .a = 456, .b = error.Unused }", "{}", .{inst}); - // Tuples - try expectFmt("{ }", "{}", .{.{}}); - try expectFmt("{ -1 }", "{}", .{.{-1}}); - try expectFmt("{ -1, 42, 2.5e+04 }", "{}", .{.{ -1, 42, 0.25e5 }}); -} - test "union" { const TU = union(enum) { float: f32, @@ -2493,18 +2504,6 @@ test "union" { try std.testing.expect(mem.eql(u8, eu_result[0..18], "fmt.test.union.EU@")); } -test "enum" { - const E = enum { - One, - Two, - Three, - }; - - const inst = E.Two; - - try expectFmt("fmt.test.enum.E.Two", "{}", .{inst}); -} - test "struct.self-referential" { const S = struct { const SelfType = @This(); diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig index df3446a2c0..91f5682831 100644 --- a/lib/std/hash_map.zig +++ b/lib/std/hash_map.zig @@ -1741,6 +1741,22 @@ test "std.hash_map clone" { try expectEqual(b.get(1).?, 1); try expectEqual(b.get(2).?, 2); try expectEqual(b.get(3).?, 3); + + var original = AutoHashMap(i32, i32).init(std.testing.allocator); + defer original.deinit(); + + var i: u8 = 0; + while (i < 10) : (i += 1) { + try original.putNoClobber(i, i * 10); + } + + var copy = try original.clone(); + defer copy.deinit(); + + i = 0; + while (i < 10) : (i += 1) { + try testing.expect(copy.get(i).? == i * 10); + } } test "std.hash_map ensureTotalCapacity with existing elements" { @@ -2072,24 +2088,6 @@ test "std.hash_map basic hash map usage" { try testing.expect(map.remove(3) == true); } -test "std.hash_map clone" { - var original = AutoHashMap(i32, i32).init(std.testing.allocator); - defer original.deinit(); - - var i: u8 = 0; - while (i < 10) : (i += 1) { - try original.putNoClobber(i, i * 10); - } - - var copy = try original.clone(); - defer copy.deinit(); - - i = 0; - while (i < 10) : (i += 1) { - try testing.expect(copy.get(i).? == i * 10); - } -} - test "std.hash_map getOrPutAdapted" { const AdaptedContext = struct { fn eql(self: @This(), adapted_key: []const u8, test_key: u64) bool { diff --git a/lib/std/io/reader.zig b/lib/std/io/reader.zig index 65b7a086c5..0b88e6b31a 100644 --- a/lib/std/io/reader.zig +++ b/lib/std/io/reader.zig @@ -553,10 +553,18 @@ test "Reader.readUntilDelimiter returns StreamTooLong, then bytes read until the } test "Reader.readUntilDelimiter returns EndOfStream" { - var buf: [5]u8 = undefined; - var fis = std.io.fixedBufferStream(""); - const reader = fis.reader(); - try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n')); + { + var buf: [5]u8 = undefined; + var fis = std.io.fixedBufferStream(""); + const reader = fis.reader(); + try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n')); + } + { + var buf: [5]u8 = undefined; + var fis = std.io.fixedBufferStream("1234"); + const reader = fis.reader(); + try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n')); + } } test "Reader.readUntilDelimiter returns bytes read until delimiter, then EndOfStream" { @@ -567,13 +575,6 @@ test "Reader.readUntilDelimiter returns bytes read until delimiter, then EndOfSt try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n')); } -test "Reader.readUntilDelimiter returns EndOfStream" { - var buf: [5]u8 = undefined; - var fis = std.io.fixedBufferStream("1234"); - const reader = fis.reader(); - try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n')); -} - test "Reader.readUntilDelimiter returns StreamTooLong, then EndOfStream" { var buf: [5]u8 = undefined; var fis = std.io.fixedBufferStream("12345"); diff --git a/lib/std/math/big/int_test.zig b/lib/std/math/big/int_test.zig index 0066ce9940..25f9815f9d 100644 --- a/lib/std/math/big/int_test.zig +++ b/lib/std/math/big/int_test.zig @@ -2012,15 +2012,10 @@ test "big.int shift-right negative" { defer arg2.deinit(); try a.shiftRight(&arg2, 10); try testing.expect((try a.to(i32)) == -1); // -5 >> 10 == -1 -} -test "big.int shift-right negative" { - var a = try Managed.init(testing.allocator); - defer a.deinit(); - - var arg = try Managed.initSet(testing.allocator, -10); - defer arg.deinit(); - try a.shiftRight(&arg, 1232); + var arg3 = try Managed.initSet(testing.allocator, -10); + defer arg3.deinit(); + try a.shiftRight(&arg3, 1232); try testing.expect((try a.to(i32)) == -1); // -10 >> 1232 == -1 } @@ -2483,7 +2478,7 @@ test "big.int gcd non-one small" { try testing.expect((try r.to(u32)) == 1); } -test "big.int gcd non-one small" { +test "big.int gcd non-one medium" { var a = try Managed.initSet(testing.allocator, 4864); defer a.deinit(); var b = try Managed.initSet(testing.allocator, 3458); diff --git a/lib/std/math/big/rational.zig b/lib/std/math/big/rational.zig index c3609a6fa2..cdc33e351d 100644 --- a/lib/std/math/big/rational.zig +++ b/lib/std/math/big/rational.zig @@ -782,36 +782,38 @@ test "big.rational mul" { } test "big.rational div" { - var a = try Rational.init(testing.allocator); - defer a.deinit(); - var b = try Rational.init(testing.allocator); - defer b.deinit(); - var r = try Rational.init(testing.allocator); - defer r.deinit(); + { + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var b = try Rational.init(testing.allocator); + defer b.deinit(); + var r = try Rational.init(testing.allocator); + defer r.deinit(); - try a.setRatio(78923, 23341); - try b.setRatio(123097, 12441414); - try a.div(a, b); + try a.setRatio(78923, 23341); + try b.setRatio(123097, 12441414); + try a.div(a, b); - try r.setRatio(75531824394, 221015929); - try testing.expect((try a.order(r)) == .eq); -} + try r.setRatio(75531824394, 221015929); + try testing.expect((try a.order(r)) == .eq); + } -test "big.rational div" { - var a = try Rational.init(testing.allocator); - defer a.deinit(); - var r = try Rational.init(testing.allocator); - defer r.deinit(); + { + var a = try Rational.init(testing.allocator); + defer a.deinit(); + var r = try Rational.init(testing.allocator); + defer r.deinit(); - try a.setRatio(78923, 23341); - a.invert(); + try a.setRatio(78923, 23341); + a.invert(); - try r.setRatio(23341, 78923); - try testing.expect((try a.order(r)) == .eq); + try r.setRatio(23341, 78923); + try testing.expect((try a.order(r)) == .eq); - try a.setRatio(-78923, 23341); - a.invert(); + try a.setRatio(-78923, 23341); + a.invert(); - try r.setRatio(-23341, 78923); - try testing.expect((try a.order(r)) == .eq); + try r.setRatio(-23341, 78923); + try testing.expect((try a.order(r)) == .eq); + } } diff --git a/lib/std/net/test.zig b/lib/std/net/test.zig index 9923e4932b..817d6c2593 100644 --- a/lib/std/net/test.zig +++ b/lib/std/net/test.zig @@ -182,7 +182,7 @@ test "listen on a port, send bytes, receive bytes" { try testing.expectEqualSlices(u8, "Hello world!", buf[0..n]); } -test "listen on a port, send bytes, receive bytes" { +test "listen on a port, send bytes, receive bytes, async-only" { if (!std.io.is_async) return error.SkipZigTest; if (builtin.os.tag != .linux and !builtin.os.tag.isDarwin()) { diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig index db55be3804..05e3d7e58b 100644 --- a/lib/std/priority_dequeue.zig +++ b/lib/std/priority_dequeue.zig @@ -633,7 +633,7 @@ test "std.PriorityDequeue: peekMax" { try expect(queue.peekMax().? == 9); } -test "std.PriorityDequeue: sift up with odd indices" { +test "std.PriorityDequeue: sift up with odd indices, removeMin" { var queue = PDQ.init(testing.allocator, {}); defer queue.deinit(); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; @@ -647,7 +647,7 @@ test "std.PriorityDequeue: sift up with odd indices" { } } -test "std.PriorityDequeue: sift up with odd indices" { +test "std.PriorityDequeue: sift up with odd indices, removeMax" { var queue = PDQ.init(testing.allocator, {}); defer queue.deinit(); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig index ced57ebf5c..21785278ec 100644 --- a/lib/std/zig/parser_test.zig +++ b/lib/std/zig/parser_test.zig @@ -1240,7 +1240,7 @@ test "zig fmt: infix operator and then multiline string literal" { ); } -test "zig fmt: infix operator and then multiline string literal" { +test "zig fmt: infix operator and then multiline string literal over multiple lines" { try testCanonical( \\const x = "" ++ \\ \\ hi0 @@ -4310,7 +4310,7 @@ test "zig fmt: comptime before comptime field" { }); } -test "zig fmt: invalid else branch statement" { +test "zig fmt: invalid doc comments on comptime and test blocks" { try testError( \\/// This is a doc comment for a comptime block. \\comptime {} @@ -5191,7 +5191,7 @@ test "zig fmt: preserve container doc comment in container without trailing comm ); } -test "zig fmt: make single-line if no trailing comma" { +test "zig fmt: make single-line if no trailing comma, fmt: off" { try testCanonical( \\// Test trailing comma syntax \\// zig fmt: off @@ -5270,7 +5270,7 @@ test "zig fmt: variable initialized with ==" { , &.{.wrong_equal_var_decl}); } -test "zig fmt: missing const/var before local variable" { +test "zig fmt: missing const/var before local variable in comptime block" { try testError( \\comptime { \\ z: u32; diff --git a/src/Module.zig b/src/Module.zig index 538c716bc3..6a33990463 100644 --- a/src/Module.zig +++ b/src/Module.zig @@ -5280,6 +5280,9 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err } }, }; + var must_free_decl_name = true; + defer if (must_free_decl_name) gpa.free(decl_name); + const is_exported = export_bit and decl_name_index != 0; if (kind == .@"usingnamespace") try namespace.usingnamespace_set.ensureUnusedCapacity(gpa, 1); @@ -5296,6 +5299,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err const new_decl = mod.declPtr(new_decl_index); new_decl.kind = kind; new_decl.name = decl_name; + must_free_decl_name = false; if (kind == .@"usingnamespace") { namespace.usingnamespace_set.putAssumeCapacity(new_decl_index, is_pub); } @@ -5339,9 +5343,29 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err new_decl.alive = true; // This Decl corresponds to an AST node and therefore always alive. return; } - gpa.free(decl_name); const decl_index = gop.key_ptr.*; const decl = mod.declPtr(decl_index); + if (kind == .@"test") { + const src_loc = SrcLoc{ + .file_scope = decl.getFileScope(), + .parent_decl_node = decl.src_node, + .lazy = .{ .token_offset = 1 }, + }; + const msg = try ErrorMsg.create( + gpa, + src_loc, + "found test declaration with duplicate name: {s}", + .{decl_name}, + ); + errdefer msg.destroy(gpa); + try mod.failed_decls.putNoClobber(gpa, decl_index, msg); + const other_src_loc = SrcLoc{ + .file_scope = namespace.file_scope, + .parent_decl_node = decl_node, + .lazy = .{ .token_offset = 1 }, + }; + try mod.errNoteNonLazy(other_src_loc, msg, "other test here", .{}); + } log.debug("scan existing {*} ({s}) of {*}", .{ decl, decl.name, namespace }); // Update the AST node of the decl; even if its contents are unchanged, it may // have been re-ordered. diff --git a/test/behavior.zig b/test/behavior.zig index 70293bf45d..24652b6612 100644 --- a/test/behavior.zig +++ b/test/behavior.zig @@ -150,6 +150,7 @@ test { _ = @import("behavior/comptime_memory.zig"); _ = @import("behavior/const_slice_child.zig"); _ = @import("behavior/decltest.zig"); + _ = @import("behavior/duplicated_test_names.zig"); _ = @import("behavior/defer.zig"); _ = @import("behavior/empty_tuple_fields.zig"); _ = @import("behavior/empty_union.zig"); diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 6fdd309371..8727d0dd41 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -203,7 +203,7 @@ test "multiline string comments at multiple places" { try expect(mem.eql(u8, s1, s2)); } -test "string concatenation" { +test "string concatenation simple" { try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED")); } diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig index 5c3012d1dc..ea7a67651c 100644 --- a/test/behavior/comptime_memory.zig +++ b/test/behavior/comptime_memory.zig @@ -45,7 +45,7 @@ test "type pun signed and unsigned as offset many pointer" { } } -test "type pun signed and unsigned as array pointer" { +test "type pun signed and unsigned as array pointer with pointer arithemtic" { if (true) { // TODO https://github.com/ziglang/zig/issues/9646 return error.SkipZigTest; diff --git a/test/behavior/duplicated_test_names.zig b/test/behavior/duplicated_test_names.zig new file mode 100644 index 0000000000..d59945ce30 --- /dev/null +++ b/test/behavior/duplicated_test_names.zig @@ -0,0 +1,17 @@ +const Namespace = struct { + test "thingy" {} +}; + +fn thingy(a: usize, b: usize) usize { + return a + b; +} + +comptime { + _ = Namespace; +} + +test "thingy" {} + +test thingy { + if (thingy(1, 2) != 3) unreachable; +} diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig index 2c55af5f85..b0e717d131 100644 --- a/test/behavior/vector.zig +++ b/test/behavior/vector.zig @@ -1129,20 +1129,6 @@ test "array of vectors is copied" { try std.testing.expectEqual(points2[6], Vec3{ -345, -311, 381 }); } -test "byte vector initialized in inline function" { - const S = struct { - inline fn boolx4(e0: bool, e1: bool, e2: bool, e3: bool) @Vector(4, bool) { - return .{ e0, e1, e2, e3 }; - } - - fn all(vb: @Vector(4, bool)) bool { - return @reduce(.And, vb); - } - }; - - try expect(S.all(S.boolx4(true, true, true, true))); -} - test "byte vector initialized in inline function" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO diff --git a/test/cases/compile_errors/invalid_duplicate_test_decl_name.zig b/test/cases/compile_errors/invalid_duplicate_test_decl_name.zig new file mode 100644 index 0000000000..e27bbe7c1a --- /dev/null +++ b/test/cases/compile_errors/invalid_duplicate_test_decl_name.zig @@ -0,0 +1,10 @@ +test "thingy" {} +test "thingy" {} + +// error +// backend=stage2 +// target=native +// is_test=1 +// +// :1:6: error: found test declaration with duplicate name: test.thingy +// :2:6: note: other test here -- cgit v1.2.3 From 297b5d1074008b52a8d08a32c9f3281542105bdd Mon Sep 17 00:00:00 2001 From: r00ster91 Date: Mon, 1 May 2023 19:15:51 +0200 Subject: fix `[x]u65529` and above overflowing ``` $ cat overflow.zig test { var a: [1]u65535 = undefined; _ = a; } $ zig-out/bin/zig test overflow.zig thread 290266 panic: integer overflow zig/src/type.zig:3604:55: 0xada43d in intAbiAlignment (zig) std.math.ceilPowerOfTwoPromote(u16, (bits + 7) / 8), ^ zig/src/type.zig:3598:42: 0xadd4ea in intAbiSize (zig) const alignment = intAbiAlignment(bits, target); ^ zig/src/type.zig:3500:61: 0x92be91 in abiSizeAdvanced (zig) return AbiSizeAdvanced{ .scalar = intAbiSize(bits, target) }; ^ zig/src/type.zig:3385:62: 0x928933 in abiSizeAdvanced (zig) switch (try payload.elem_type.abiSizeAdvanced(target, strat)) { ^ zig/src/type.zig:3268:32: 0x92c012 in abiSize (zig) return (abiSizeAdvanced(ty, target, .eager) catch unreachable).scalar; ^ ``` This is only noticed in a debug build of zig and silently does the wrong thing and overflows in release builds. This happened to `[x]u65529` and above because of the ` + 7` on a `u16`. --- src/type.zig | 4 ++-- test/behavior/basic.zig | 21 +++++++++++++++++++++ 2 files changed, 23 insertions(+), 2 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/src/type.zig b/src/type.zig index c9a6f49d3e..6122afda62 100644 --- a/src/type.zig +++ b/src/type.zig @@ -3596,12 +3596,12 @@ pub const Type = extern union { fn intAbiSize(bits: u16, target: Target) u64 { const alignment = intAbiAlignment(bits, target); - return std.mem.alignForwardGeneric(u64, (bits + 7) / 8, alignment); + return std.mem.alignForwardGeneric(u64, @intCast(u16, (@as(u17, bits) + 7) / 8), alignment); } fn intAbiAlignment(bits: u16, target: Target) u32 { return @min( - std.math.ceilPowerOfTwoPromote(u16, (bits + 7) / 8), + std.math.ceilPowerOfTwoPromote(u16, @intCast(u16, (@as(u17, bits) + 7) / 8)), target.maxIntAlignment(), ); } diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 8727d0dd41..073be26288 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -1124,3 +1124,24 @@ test "runtime-known globals initialized with undefined" { try expect(S.s[0] == 1); try expect(S.s[4] == 5); } + +test "arrays and vectors with big integers" { + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + + // TODO: only aarch64-windows didn't pass in the PR that added this code. + // figure out why if you can run this target. + if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64) return error.SkipZigTest; + + inline for (.{ u65528, u65529, u65535 }) |Int| { + var a: [1]Int = undefined; + a[0] = std.math.maxInt(Int); + try expect(a[0] == comptime std.math.maxInt(Int)); + var b: @Vector(1, Int) = undefined; + b[0] = std.math.maxInt(Int); + try expect(b[0] == comptime std.math.maxInt(Int)); + } +} -- cgit v1.2.3 From 0a7f8c2e013f24aa6c94093400fe6377ab74b4e1 Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Tue, 9 May 2023 15:30:14 +0300 Subject: Sema: return const pointers from ref inits Closes #12189 --- src/Sema.zig | 25 ++++++++++++++++--------- test/behavior/basic.zig | 7 +++++++ 2 files changed, 23 insertions(+), 9 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/src/Sema.zig b/src/Sema.zig index 225a6c5bff..d3749efce3 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -252,7 +252,6 @@ pub const Block = struct { // TODO is_comptime and comptime_reason should probably be merged together. is_comptime: bool, is_typeof: bool = false, - is_coerce_result_ptr: bool = false, /// Keep track of the active error return trace index around blocks so that we can correctly /// pop the error trace upon block exit. @@ -2469,7 +2468,6 @@ fn zirCoerceResultPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE // kind of transformations to make on the result pointer. var trash_block = block.makeSubBlock(); trash_block.is_comptime = false; - trash_block.is_coerce_result_ptr = true; defer trash_block.instructions.deinit(sema.gpa); const dummy_ptr = try trash_block.addTy(.alloc, sema.typeOf(ptr)); @@ -2579,6 +2577,9 @@ fn coerceResultPtr( .array_to_slice => { return sema.fail(block, src, "TODO coerce_result_ptr array_to_slice", .{}); }, + .get_union_tag => { + return sema.fail(block, src, "TODO coerce_result_ptr get_union_tag", .{}); + }, else => { if (std.debug.runtime_safety) { std.debug.panic("unexpected AIR tag for coerce_result_ptr: {}", .{ @@ -3563,6 +3564,13 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro )); } + return sema.makePtrConst(block, alloc); +} + +fn makePtrConst(sema: *Sema, block: *Block, alloc: Air.Inst.Ref) CompileError!Air.Inst.Ref { + const alloc_ty = sema.typeOf(alloc); + + var ptr_info = alloc_ty.ptrInfo().data; ptr_info.mutable = false; const const_ptr_ty = try Type.ptr(sema.arena, sema.mod, ptr_info); @@ -3831,7 +3839,6 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com var trash_block = block.makeSubBlock(); trash_block.is_comptime = false; - trash_block.is_coerce_result_ptr = true; defer trash_block.instructions.deinit(gpa); const mut_final_ptr_ty = try Type.ptr(sema.arena, sema.mod, .{ @@ -17773,7 +17780,7 @@ fn zirStructInit( try sema.storePtr(block, src, field_ptr, init_inst); const new_tag = try sema.addConstant(resolved_ty.unionTagTypeHypothetical(), tag_val); _ = try block.addBinOp(.set_union_tag, alloc, new_tag); - return alloc; + return sema.makePtrConst(block, alloc); } try sema.requireRuntimeBlock(block, src, null); @@ -17900,7 +17907,7 @@ fn finishStructInit( try sema.storePtr(block, dest_src, field_ptr, field_init); } - return alloc; + return sema.makePtrConst(block, alloc); } try sema.requireRuntimeBlock(block, dest_src, null); @@ -18017,7 +18024,7 @@ fn zirStructInitAnon( } } - return alloc; + return sema.makePtrConst(block, alloc); } const element_refs = try sema.arena.alloc(Air.Inst.Ref, types.len); @@ -18120,7 +18127,7 @@ fn zirArrayInit( const elem_ptr = try block.addPtrElemPtrTypeRef(alloc, index, elem_ptr_ty_ref); _ = try block.addBinOp(.store, elem_ptr, arg); } - return alloc; + return sema.makePtrConst(block, alloc); } const elem_ptr_ty = try Type.ptr(sema.arena, sema.mod, .{ @@ -18135,7 +18142,7 @@ fn zirArrayInit( const elem_ptr = try block.addPtrElemPtrTypeRef(alloc, index, elem_ptr_ty_ref); _ = try block.addBinOp(.store, elem_ptr, arg); } - return alloc; + return sema.makePtrConst(block, alloc); } return block.addAggregateInit(array_ty, resolved_args); @@ -18213,7 +18220,7 @@ fn zirArrayInitAnon( } } - return alloc; + return sema.makePtrConst(block, alloc); } const element_refs = try sema.arena.alloc(Air.Inst.Ref, operands.len); diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 073be26288..5b8ca80198 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -1145,3 +1145,10 @@ test "arrays and vectors with big integers" { try expect(b[0] == comptime std.math.maxInt(Int)); } } + +test "pointer to struct literal with runtime field is constant" { + const S = struct { data: usize }; + var runtime_zero: usize = 0; + const ptr = &S{ .data = runtime_zero }; + try expect(@typeInfo(@TypeOf(ptr)).Pointer.is_const); +} -- cgit v1.2.3 From ccc490ef6876291ed3df5e945e7df913018c32af Mon Sep 17 00:00:00 2001 From: Ali Chraghi Date: Thu, 11 May 2023 09:23:34 +0330 Subject: setup spirv backend in behavior tests --- lib/std/builtin.zig | 3 + src/Compilation.zig | 1 + test/behavior.zig | 3 +- test/behavior/align.zig | 23 ++++++ test/behavior/array.zig | 30 ++++++++ test/behavior/asm.zig | 4 + test/behavior/atomics.zig | 15 ++++ test/behavior/basic.zig | 55 ++++++++++++++ test/behavior/bit_shifting.zig | 1 + test/behavior/bitcast.zig | 15 ++++ test/behavior/bitreverse.zig | 5 ++ test/behavior/bool.zig | 3 + test/behavior/bugs/10138.zig | 1 + test/behavior/bugs/10147.zig | 1 + test/behavior/bugs/10684.zig | 1 + test/behavior/bugs/1076.zig | 1 + test/behavior/bugs/10970.zig | 1 + test/behavior/bugs/11046.zig | 1 + test/behavior/bugs/11100.zig | 4 + test/behavior/bugs/11139.zig | 1 + test/behavior/bugs/11165.zig | 2 + test/behavior/bugs/11179.zig | 1 + test/behavior/bugs/11213.zig | 2 + test/behavior/bugs/11787.zig | 1 + test/behavior/bugs/11816.zig | 1 + test/behavior/bugs/11995.zig | 2 + test/behavior/bugs/12000.zig | 2 + test/behavior/bugs/12025.zig | 4 + test/behavior/bugs/12033.zig | 3 + test/behavior/bugs/12043.zig | 3 + test/behavior/bugs/12051.zig | 2 + test/behavior/bugs/12092.zig | 2 + test/behavior/bugs/12119.zig | 2 + test/behavior/bugs/12142.zig | 2 + test/behavior/bugs/12450.zig | 2 + test/behavior/bugs/12551.zig | 1 + test/behavior/bugs/12571.zig | 1 + test/behavior/bugs/12644.zig | 3 + test/behavior/bugs/12680.zig | 1 + test/behavior/bugs/1277.zig | 1 + test/behavior/bugs/12776.zig | 1 + test/behavior/bugs/12801-2.zig | 1 + test/behavior/bugs/12890.zig | 1 + test/behavior/bugs/12891.zig | 14 ++++ test/behavior/bugs/12928.zig | 8 ++ test/behavior/bugs/12972.zig | 1 + test/behavior/bugs/12984.zig | 1 + test/behavior/bugs/13064.zig | 1 + test/behavior/bugs/13065.zig | 1 + test/behavior/bugs/13068.zig | 1 + test/behavior/bugs/13069.zig | 1 + test/behavior/bugs/13113.zig | 2 + test/behavior/bugs/13128.zig | 1 + test/behavior/bugs/13159.zig | 2 + test/behavior/bugs/13285.zig | 1 + test/behavior/bugs/13366.zig | 1 + test/behavior/bugs/13664.zig | 1 + test/behavior/bugs/13785.zig | 1 + test/behavior/bugs/1381.zig | 1 + test/behavior/bugs/1442.zig | 2 + test/behavior/bugs/14854.zig | 3 + test/behavior/bugs/1500.zig | 2 + test/behavior/bugs/1607.zig | 2 + test/behavior/bugs/1735.zig | 2 + test/behavior/bugs/1741.zig | 1 + test/behavior/bugs/1851.zig | 1 + test/behavior/bugs/1914.zig | 4 + test/behavior/bugs/2006.zig | 1 + test/behavior/bugs/2114.zig | 1 + test/behavior/bugs/2578.zig | 1 + test/behavior/bugs/2622.zig | 1 + test/behavior/bugs/2692.zig | 1 + test/behavior/bugs/3007.zig | 1 + test/behavior/bugs/3046.zig | 1 + test/behavior/bugs/3112.zig | 2 + test/behavior/bugs/3367.zig | 2 + test/behavior/bugs/3742.zig | 2 + test/behavior/bugs/3779.zig | 5 ++ test/behavior/bugs/421.zig | 1 + test/behavior/bugs/4328.zig | 5 ++ test/behavior/bugs/4954.zig | 1 + test/behavior/bugs/529.zig | 1 + test/behavior/bugs/5398.zig | 1 + test/behavior/bugs/6047.zig | 1 + test/behavior/bugs/6456.zig | 1 + test/behavior/bugs/656.zig | 2 + test/behavior/bugs/6781.zig | 1 + test/behavior/bugs/6905.zig | 1 + test/behavior/bugs/6947.zig | 1 + test/behavior/bugs/7047.zig | 3 + test/behavior/bugs/718.zig | 1 + test/behavior/bugs/7187.zig | 2 + test/behavior/bugs/726.zig | 2 + test/behavior/bugs/7325.zig | 1 + test/behavior/bugs/8277.zig | 2 + test/behavior/bugs/828.zig | 1 + test/behavior/bugs/8646.zig | 1 + test/behavior/bugs/920.zig | 1 + test/behavior/bugs/9584.zig | 1 + test/behavior/byteswap.zig | 4 + test/behavior/byval_arg_var.zig | 1 + test/behavior/call.zig | 12 +++ test/behavior/cast.zig | 88 ++++++++++++++++++++++ test/behavior/cast_int.zig | 1 + test/behavior/const_slice_child.zig | 1 + test/behavior/decltest.zig | 4 + test/behavior/defer.zig | 9 +++ test/behavior/duplicated_test_names.zig | 4 + test/behavior/empty_tuple_fields.zig | 2 + test/behavior/empty_union.zig | 6 ++ test/behavior/enum.zig | 23 ++++++ test/behavior/error.zig | 39 ++++++++++ test/behavior/eval.zig | 54 +++++++++++++ test/behavior/field_parent_ptr.zig | 7 ++ test/behavior/floatop.zig | 51 +++++++++++++ test/behavior/fn.zig | 33 ++++++++ test/behavior/fn_delegation.zig | 1 + test/behavior/fn_in_struct_in_comptime.zig | 3 + test/behavior/for.zig | 22 ++++++ test/behavior/generics.zig | 24 ++++++ test/behavior/if.zig | 5 ++ test/behavior/inline_switch.zig | 5 ++ test/behavior/int128.zig | 5 ++ test/behavior/int_comparison_elision.zig | 2 + test/behavior/inttoptr.zig | 1 + test/behavior/ir_block_deps.zig | 1 + test/behavior/lower_strlit_to_vector.zig | 1 + test/behavior/math.zig | 42 +++++++++++ test/behavior/maximum_minimum.zig | 11 +++ test/behavior/member_func.zig | 2 + test/behavior/memcpy.zig | 2 + test/behavior/memset.zig | 7 ++ test/behavior/merge_error_sets.zig | 1 + test/behavior/muladd.zig | 9 +++ test/behavior/null.zig | 7 ++ test/behavior/optional.zig | 25 ++++++ test/behavior/packed-struct.zig | 17 +++++ .../packed_struct_explicit_backing_int.zig | 1 + test/behavior/pointers.zig | 23 ++++++ test/behavior/popcount.zig | 3 + test/behavior/prefetch.zig | 3 + test/behavior/ptrcast.zig | 6 ++ test/behavior/pub_enum.zig | 3 + .../ref_var_in_if_after_if_2nd_switch_prong.zig | 1 + test/behavior/reflection.zig | 1 + test/behavior/return_address.zig | 2 + test/behavior/saturating_arithmetic.zig | 7 ++ test/behavior/select.zig | 2 + test/behavior/shuffle.zig | 3 + test/behavior/sizeof_and_typeof.zig | 8 ++ test/behavior/slice.zig | 33 +++++++- test/behavior/src.zig | 3 + test/behavior/struct.zig | 53 +++++++++++++ test/behavior/struct_contains_null_ptr_itself.zig | 1 + test/behavior/struct_contains_slice_of_itself.zig | 2 + test/behavior/switch.zig | 18 +++++ test/behavior/switch_prong_err_enum.zig | 1 + test/behavior/switch_prong_implicit_cast.zig | 1 + test/behavior/this.zig | 3 + test/behavior/threadlocal.zig | 3 + test/behavior/translate_c_macros.zig | 16 ++++ test/behavior/truncate.zig | 1 + test/behavior/try.zig | 5 ++ test/behavior/tuple.zig | 16 ++++ test/behavior/tuple_declarations.zig | 2 + test/behavior/type.zig | 5 ++ test/behavior/type_info.zig | 10 +++ test/behavior/typename.zig | 8 ++ test/behavior/undefined.zig | 3 + test/behavior/underscore.zig | 1 + test/behavior/union.zig | 61 +++++++++++++++ test/behavior/union_with_members.zig | 1 + test/behavior/usingnamespace.zig | 1 + test/behavior/var_args.zig | 8 ++ test/behavior/vector.zig | 43 +++++++++++ test/behavior/void.zig | 2 + test/behavior/while.zig | 20 +++++ test/behavior/widening.zig | 7 ++ 178 files changed, 1235 insertions(+), 2 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index ea513ae87e..684432bd40 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -836,6 +836,9 @@ pub const CompilerBackend = enum(u64) { /// The reference implementation self-hosted compiler of Zig, using the /// sparc64 backend. stage2_sparc64 = 10, + /// The reference implementation self-hosted compiler of Zig, using the + /// spirv backend. + stage2_spirv64 = 11, _, }; diff --git a/src/Compilation.zig b/src/Compilation.zig index a5b785cc67..1b6d805bb3 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -5076,6 +5076,7 @@ pub fn getZigBackend(comp: Compilation) std.builtin.CompilerBackend { .aarch64, .aarch64_be, .aarch64_32 => .stage2_aarch64, .riscv64 => .stage2_riscv64, .sparc64 => .stage2_sparc64, + .spirv64 => .stage2_spirv64, else => .other, }; } diff --git a/test/behavior.zig b/test/behavior.zig index 24652b6612..34783ce2e1 100644 --- a/test/behavior.zig +++ b/test/behavior.zig @@ -241,7 +241,8 @@ test { builtin.zig_backend != .stage2_x86_64 and builtin.zig_backend != .stage2_aarch64 and builtin.zig_backend != .stage2_wasm and - builtin.zig_backend != .stage2_c) + builtin.zig_backend != .stage2_c and + builtin.zig_backend != .stage2_spirv64) { _ = @import("behavior/bugs/13063.zig"); _ = @import("behavior/bugs/11227.zig"); diff --git a/test/behavior/align.zig b/test/behavior/align.zig index bfc9997dd2..4bd6666696 100644 --- a/test/behavior/align.zig +++ b/test/behavior/align.zig @@ -19,6 +19,7 @@ test "slicing array of length 1 can not assume runtime index is always zero" { if (builtin.zig_backend == .stage2_wasm) 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; var runtime_index: usize = 1; const slice = @as(*align(4) [1]u8, &foo)[runtime_index..]; @@ -32,6 +33,8 @@ test "default alignment allows unspecified in type syntax" { } test "implicitly decreasing pointer alignment" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const a: u32 align(4) = 3; const b: u32 align(8) = 4; try expect(addUnaligned(&a, &b) == 7); @@ -42,6 +45,8 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 { } test "@alignCast pointers" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var x: u32 align(4) = 1; expectsOnly1(&x); try expect(x == 2); @@ -214,6 +219,8 @@ test "alignment and size of structs with 128-bit fields" { } test "@ptrCast preserves alignment of bigger source" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var x: u32 align(16) = 1234; const ptr = @ptrCast(*u8, &x); try expect(@TypeOf(ptr) == *align(16) u8); @@ -231,6 +238,7 @@ fn fnWithAlignedStack() i32 { test "implicitly decreasing slice alignment" { 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; const a: u32 align(4) = 3; const b: u32 align(8) = 4; @@ -256,6 +264,7 @@ test "@alignCast slices" { 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; var array align(4) = [_]u32{ 1, 1 }; const slice = array[0..]; @@ -273,6 +282,7 @@ test "return error union with 128-bit integer" { 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 expect(3 == try give()); } @@ -284,6 +294,7 @@ test "page aligned array on stack" { 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; if (builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/13679 @@ -329,6 +340,7 @@ test "implicitly decreasing fn alignment" { 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; // function alignment is a compile error on wasm32/wasm64 if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest; @@ -352,6 +364,7 @@ test "@alignCast functions" { 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; // function alignment is a compile error on wasm32/wasm64 if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest; @@ -395,6 +408,7 @@ test "function align expression depends on generic parameter" { test "function callconv expression depends on generic parameter" { 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 { @@ -412,6 +426,7 @@ test "function callconv expression depends on generic parameter" { test "runtime-known array index has best alignment possible" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // take full advantage of over-alignment var array align(4) = [_]u8{ 1, 2, 3, 4 }; @@ -451,6 +466,8 @@ fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void { } test "alignment of function with c calling convention" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var runtime_nothing = ¬hing; const casted1 = @ptrCast(*const u8, runtime_nothing); const casted2 = @ptrCast(*const fn () callconv(.C) void, casted1); @@ -468,6 +485,7 @@ test "read 128-bit field from default aligned struct in stack memory" { 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; var default_aligned = DefaultAligned{ .nevermind = 1, @@ -485,6 +503,7 @@ test "read 128-bit field from default aligned struct in global memory" { 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 expect(12 == default_aligned_global.badguy); } @@ -493,6 +512,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; const S = struct { const Node = struct { @@ -537,6 +557,7 @@ test "align(N) on functions" { 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // This is not supported on MSVC if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) { @@ -558,6 +579,7 @@ test "comptime alloc alignment" { if (builtin.zig_backend == .stage2_aarch64) 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; comptime var bytes1 = [_]u8{0}; _ = bytes1; @@ -570,6 +592,7 @@ test "comptime alloc alignment" { test "@alignCast null" { 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; var ptr: ?*anyopaque = null; const aligned: ?*anyopaque = @alignCast(@alignOf(?*anyopaque), ptr); diff --git a/test/behavior/array.zig b/test/behavior/array.zig index 6cf0ab9e1d..fec8a7ac8a 100644 --- a/test/behavior/array.zig +++ b/test/behavior/array.zig @@ -21,6 +21,7 @@ test "arrays" { 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; var array: [5]u32 = undefined; @@ -48,6 +49,7 @@ fn getArrayLen(a: []const u32) usize { test "array concat with undefined" { 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 { fn doTheTest() !void { @@ -72,6 +74,7 @@ test "array concat with tuple" { 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 array: [2]u8 = .{ 1, 2 }; { @@ -86,6 +89,8 @@ test "array concat with tuple" { test "array init with concat" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const a = 'a'; var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' }; try expect(std.mem.eql(u8, &i, "abcd")); @@ -94,6 +99,7 @@ test "array init with concat" { test "array init with mult" { 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; const a = 'a'; var i: [8]u8 = [2]u8{ a, 'b' } ** 4; @@ -135,6 +141,7 @@ test "array literal with specified size" { 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; var array = [2]u8{ 1, 2 }; try expect(array[0] == 1); @@ -156,6 +163,7 @@ test "array len field" { test "array with sentinels" { 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; const S = struct { fn doTheTest(is_ct: bool) !void { @@ -193,6 +201,7 @@ test "nested arrays of strings" { 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; const array_of_strings = [_][]const u8{ "hello", "this", "is", "my", "thing" }; for (array_of_strings, 0..) |s, i| { @@ -222,6 +231,7 @@ test "nested arrays of integers" { test "implicit comptime in array type size" { 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; var arr: [plusOne(10)]bool = undefined; try expect(arr.len == 11); @@ -234,6 +244,7 @@ fn plusOne(x: u32) u32 { test "single-item pointer to array indexing and slicing" { 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; try testSingleItemPtrArrayIndexSlice(); comptime try testSingleItemPtrArrayIndexSlice(); @@ -259,6 +270,7 @@ fn doSomeMangling(array: *[4]u8) void { test "implicit cast zero sized array ptr to slice" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; { var b = "".*; @@ -276,6 +288,7 @@ test "anonymous list literal syntax" { 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; const S = struct { fn doTheTest() !void { @@ -296,6 +309,7 @@ const Str = struct { a: []Sub }; test "set global var array via slice embedded in struct" { 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; var s = Str{ .a = s_array[0..] }; @@ -312,6 +326,7 @@ test "read/write through global variable array of struct fields initialized via 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -332,6 +347,7 @@ test "read/write through global variable array of struct fields initialized via test "implicit cast single-item pointer" { 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; try testImplicitCastSingleItemPtr(); comptime try testImplicitCastSingleItemPtr(); @@ -351,6 +367,7 @@ fn testArrayByValAtComptime(b: [2]u8) u8 { test "comptime evaluating function that takes array by value" { 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; const arr = [_]u8{ 1, 2 }; const x = comptime testArrayByValAtComptime(arr); @@ -362,6 +379,7 @@ test "comptime evaluating function that takes array by value" { test "runtime initialize array elem and then implicit cast to slice" { 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; var two: i32 = 2; const x: []const i32 = &[_]i32{two}; @@ -371,6 +389,7 @@ test "runtime initialize array elem and then implicit cast to slice" { test "array literal as argument to function" { 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; const S = struct { fn entry(two: i32) !void { @@ -399,6 +418,7 @@ test "double nested array to const slice cast in array literal" { 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_spirv64) return error.SkipZigTest; const S = struct { fn entry(two: i32) !void { @@ -460,6 +480,7 @@ test "anonymous literal in array" { 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_spirv64) return error.SkipZigTest; const S = struct { const Foo = struct { @@ -484,6 +505,7 @@ test "anonymous literal in array" { test "access the null element of a null terminated array" { 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; const S = struct { fn doTheTest() !void { @@ -501,6 +523,7 @@ test "type deduction for array subscript expression" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -519,6 +542,7 @@ test "sentinel element count towards the ABI size calculation" { 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 { @@ -542,6 +566,7 @@ test "sentinel element count towards the ABI size calculation" { test "zero-sized array with recursive type definition" { 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 U = struct { fn foo(comptime T: type, comptime n: usize) type { @@ -564,6 +589,7 @@ test "type coercion of anon struct literal to array" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { const U = union { @@ -596,6 +622,7 @@ test "type coercion of pointer to anon struct literal to pointer to array" { 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 { const U = union { @@ -634,6 +661,7 @@ test "tuple to array handles sentinel" { 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 { const a = .{ 1, 2, 3 }; @@ -646,6 +674,7 @@ test "array init of container level array variable" { 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 { var pair: [2]usize = .{ 1, 2 }; @@ -676,6 +705,7 @@ test "array of array agregate init" { 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; var a = [1]u32{11} ** 10; var b = [1][10]u32{a} ** 2; diff --git a/test/behavior/asm.zig b/test/behavior/asm.zig index b242374ef8..5c446e5f85 100644 --- a/test/behavior/asm.zig +++ b/test/behavior/asm.zig @@ -24,6 +24,7 @@ test "module level assembly" { 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_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly @@ -38,6 +39,7 @@ test "output constraint modifiers" { 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_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly @@ -61,6 +63,7 @@ test "alternative constraints" { 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_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly @@ -79,6 +82,7 @@ test "sized integer/float in asm input" { 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_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly diff --git a/test/behavior/atomics.zig b/test/behavior/atomics.zig index 56854d43d8..d1b51207a4 100644 --- a/test/behavior/atomics.zig +++ b/test/behavior/atomics.zig @@ -14,6 +14,7 @@ test "cmpxchg" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCmpxchg(); comptime try testCmpxchg(); @@ -39,6 +40,7 @@ fn testCmpxchg() !void { test "fence" { 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; var x: i32 = 1234; @fence(.SeqCst); @@ -49,6 +51,7 @@ test "atomicrmw and atomicload" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var data: u8 = 200; try testAtomicRmw(&data); @@ -76,6 +79,7 @@ test "cmpxchg with ptr" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var data1: i32 = 1234; var data2: i32 = 5678; @@ -100,6 +104,7 @@ test "cmpxchg with ignored result" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: i32 = 1234; @@ -115,6 +120,7 @@ test "128-bit cmpxchg" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try test_u128_cmpxchg(); comptime try test_u128_cmpxchg(); @@ -143,6 +149,7 @@ test "cmpxchg on a global variable" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { // https://github.com/ziglang/zig/issues/10627 @@ -157,6 +164,7 @@ test "atomic load and rmw with enum" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const Value = enum(u8) { a, b, c }; var x = Value.a; @@ -173,6 +181,7 @@ test "atomic store" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: u32 = 0; @atomicStore(u32, &x, 1, .SeqCst); @@ -185,6 +194,7 @@ test "atomic store comptime" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime try testAtomicStore(); try testAtomicStore(); @@ -203,6 +213,7 @@ test "atomicrmw with floats" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { // https://github.com/ziglang/zig/issues/10627 @@ -231,6 +242,7 @@ test "atomicrmw with ints" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testAtomicRmwInts(); comptime try testAtomicRmwInts(); @@ -301,6 +313,7 @@ test "atomicrmw with 128-bit ints" { 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_spirv64) return error.SkipZigTest; // TODO "ld.lld: undefined symbol: __sync_lock_test_and_set_16" on -mcpu x86_64 if (builtin.cpu.arch == .x86_64 and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; @@ -376,6 +389,7 @@ test "atomics with different types" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testAtomicsWithType(bool, true, false); @@ -404,6 +418,7 @@ test "return @atomicStore, using it as a void value" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { const A = struct { diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 073be26288..db08442510 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -42,6 +42,7 @@ test "truncate to non-power-of-two integers from 128-bit" { 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; try testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010101, 0x01); try testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010110, 0x00); @@ -81,6 +82,8 @@ test "type equality" { } test "pointer dereferencing" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var x = @as(i32, 3); const y = &x; @@ -131,18 +134,21 @@ fn first4KeysOfHomeRow() []const u8 { test "return string from function" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu")); } test "hex escape" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello")); } test "multiline string" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -155,6 +161,7 @@ test "multiline string" { test "multiline string comments at start" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = //\\one @@ -167,6 +174,7 @@ test "multiline string comments at start" { test "multiline string comments at end" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -179,6 +187,7 @@ test "multiline string comments at end" { test "multiline string comments in middle" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -191,6 +200,7 @@ test "multiline string comments in middle" { test "multiline string comments at multiple places" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -204,11 +214,14 @@ test "multiline string comments at multiple places" { } test "string concatenation simple" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED")); } test "array mult operator" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, "ab" ** 5, "ababababab")); } @@ -218,6 +231,7 @@ const OpaqueB = opaque {}; test "opaque types" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(*OpaqueA != *OpaqueB); @@ -289,6 +303,8 @@ test "function closes over local const" { } test "volatile load and store" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var number: i32 = 1234; const ptr = @as(*volatile i32, &number); ptr.* += 1; @@ -304,6 +320,7 @@ fn fB() []const u8 { test "call function pointer in struct" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, f3(true), "a")); try expect(mem.eql(u8, f3(false), "b")); @@ -327,6 +344,7 @@ const FnPtrWrapper = struct { test "const ptr from var variable" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: u64 = undefined; var y: u64 = undefined; @@ -345,6 +363,7 @@ test "call result of if else expression" { 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 expect(mem.eql(u8, f2(true), "a")); try expect(mem.eql(u8, f2(false), "b")); @@ -354,6 +373,8 @@ fn f2(x: bool) []const u8 { } test "variable is allowed to be a pointer to an opaque type" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var x: i32 = 1234; _ = hereIsAnOpaqueType(@ptrCast(*OpaqueA, &x)); } @@ -366,6 +387,7 @@ test "take address of parameter" { 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 testTakeAddressOfParameter(12.34); } @@ -375,6 +397,8 @@ fn testTakeAddressOfParameter(f: f32) !void { } test "pointer to void return type" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try testPointerToVoidReturnType(); } fn testPointerToVoidReturnType() anyerror!void { @@ -391,6 +415,7 @@ test "array 2D const double ptr" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const rect_2d_vertexes = [_][1]f32{ [_]f32{1.0}, @@ -404,6 +429,7 @@ test "array 2D const double ptr with offset" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const rect_2d_vertexes = [_][2]f32{ [_]f32{ 3.0, 4.239 }, @@ -417,6 +443,7 @@ test "array 3D const double ptr with offset" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const rect_3d_vertexes = [_][2][2]f32{ [_][2]f32{ @@ -450,6 +477,7 @@ fn nine() u8 { test "struct inside function" { 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; try testStructInFn(); comptime try testStructInFn(); @@ -471,6 +499,7 @@ fn testStructInFn() !void { test "fn call returning scalar optional in equality expression" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(getNull() == null); } @@ -481,6 +510,7 @@ fn getNull() ?*i32 { test "global variable assignment with optional unwrapping with var initialized to undefined" { 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; const S = struct { var data: i32 = 1234; @@ -569,11 +599,15 @@ test "comptime cast fn to ptr" { } test "equality compare fn ptrs" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var a = &emptyFn; try expect(a == a); } test "self reference through fn ptr field" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { const A = struct { f: *const fn (A) u8, @@ -591,6 +625,7 @@ test "self reference through fn ptr field" { test "global variable initialized to global variable array element" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(global_ptr == &gdt[0]); } @@ -622,6 +657,7 @@ test "global constant is loaded with a runtime-known index" { test "multiline string literal is null terminated" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -636,6 +672,7 @@ test "string escapes" { 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 expectEqualStrings("\"", "\x22"); try expectEqualStrings("\'", "\x27"); @@ -653,6 +690,8 @@ test "explicit cast optional pointers" { } test "pointer comparison" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const a = @as([]const u8, "a"); const b = &a; try expect(ptrEql(b, b)); @@ -665,6 +704,7 @@ test "string concatenation" { 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; const a = "OK" ++ " IT " ++ "WORKED"; const b = "OK IT WORKED"; @@ -692,6 +732,7 @@ test "comptime manyptr concatenation" { 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; const s = "epic"; const actual = manyptrConcat(s); @@ -713,6 +754,7 @@ test "result location is optional inside error union" { 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 x = maybe(true) catch unreachable; try expect(x.? == 42); @@ -728,6 +770,7 @@ fn maybe(x: bool) anyerror!?u32 { test "auto created variables have correct alignment" { 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 { fn foo(str: [*]const u8) u32 { @@ -748,6 +791,7 @@ test "extern variable with non-pointer opaque 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_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @export(var_to_export, .{ .name = "opaque_extern_var" }); try expect(@ptrCast(*align(1) u32, &opaque_extern_var).* == 42); @@ -830,6 +874,7 @@ test "labeled block implicitly ends in a break" { test "catch in block has correct result location" { 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; const S = struct { fn open() error{A}!@This() { @@ -847,6 +892,8 @@ test "catch in block has correct result location" { } test "labeled block with runtime branch forwards its result location type to break statements" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const E = enum { a, b }; var a = false; const e: E = blk: { @@ -1004,6 +1051,7 @@ comptime { test "switch inside @as gets correct type" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: u32 = 0; var b: [2]u32 = undefined; @@ -1014,6 +1062,8 @@ test "switch inside @as gets correct type" { } test "inline call of function with a switch inside the return statement" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { inline fn foo(x: anytype) @TypeOf(x) { return switch (x) { @@ -1029,6 +1079,7 @@ test "namespace lookup ignores decl causing the lookup" { if (builtin.zig_backend == .stage2_wasm) 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; if (builtin.zig_backend == .stage2_llvm) { // regressed with LLVM 15 @@ -1096,6 +1147,7 @@ test "returning an opaque type from a function" { test "orelse coercion as function argument" { 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 Loc = struct { start: i32 = -1 }; const Container = struct { @@ -1112,6 +1164,8 @@ test "orelse coercion as function argument" { } test "runtime-known globals initialized with undefined" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var vp: [*]u32 = undefined; @@ -1131,6 +1185,7 @@ test "arrays and vectors with big integers" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO: only aarch64-windows didn't pass in the PR that added this code. // figure out why if you can run this target. diff --git a/test/behavior/bit_shifting.zig b/test/behavior/bit_shifting.zig index 8ad71400fe..03eb4433e1 100644 --- a/test/behavior/bit_shifting.zig +++ b/test/behavior/bit_shifting.zig @@ -64,6 +64,7 @@ test "sharded table" { 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; // realistic 16-way sharding try testShardedTable(u32, 4, 8); diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig index ecb4ddf678..2dcba00c40 100644 --- a/test/behavior/bitcast.zig +++ b/test/behavior/bitcast.zig @@ -9,6 +9,7 @@ const native_endian = builtin.target.cpu.arch.endian(); test "@bitCast iX -> uX (32, 64)" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const bit_values = [_]usize{ 32, 64 }; @@ -22,6 +23,7 @@ test "@bitCast iX -> uX (8, 16, 128)" { 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; const bit_values = [_]usize{ 8, 16, 128 }; @@ -37,6 +39,7 @@ test "@bitCast iX -> uX exotic integers" { 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; const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 }; @@ -83,6 +86,7 @@ test "bitcast uX to bytes" { 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; const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 }; inline for (bit_values) |bits| { @@ -150,6 +154,8 @@ test "bitcast literal [4]u8 param to u32" { } test "bitcast generates a temporary value" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var y = @as(u16, 0x55AA); const x = @bitCast(u16, @bitCast([2]u8, y)); try expect(y == x); @@ -159,6 +165,7 @@ 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_spirv64) return error.SkipZigTest; const Full = packed struct { number: u16, @@ -184,6 +191,7 @@ test "@bitCast packed structs at runtime and comptime" { test "@bitCast extern structs at runtime and comptime" { 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; const Full = extern struct { number: u16, @@ -216,6 +224,7 @@ test "bitcast packed struct to integer and back" { 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; const LevelUpMove = packed struct { move_id: u9, @@ -237,6 +246,7 @@ test "bitcast packed struct to integer and back" { test "implicit cast to error union by returning" { 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; const S = struct { fn entry() !void { @@ -292,6 +302,7 @@ test "@bitCast packed struct of floats" { 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; const Foo = packed struct { a: f16 = 0, @@ -328,6 +339,7 @@ test "comptime @bitCast packed struct to int and back" { 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; if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) { // https://github.com/ziglang/zig/issues/13782 @@ -368,6 +380,7 @@ test "comptime bitcast with fields following f80" { 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; const FloatT = extern struct { f: f80, x: u128 align(16) }; const x: FloatT = .{ .f = 0.5, .x = 123 }; @@ -383,6 +396,7 @@ test "bitcast vector to integer and back" { if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14; var x = @splat(16, true); @@ -408,6 +422,7 @@ test "bitcast nan float does modify signaling bit" { if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO: https://github.com/ziglang/zig/issues/14366 if (builtin.cpu.arch == .arm and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig index 9a24090c0e..87cea942d0 100644 --- a/test/behavior/bitreverse.zig +++ b/test/behavior/bitreverse.zig @@ -5,6 +5,7 @@ const minInt = std.math.minInt; test "@bitReverse large exotic integer" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624); } @@ -15,6 +16,7 @@ test "@bitReverse" { 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; comptime try testBitReverse(); try testBitReverse(); @@ -100,6 +102,7 @@ test "bitReverse vectors u8" { 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; comptime try vector8(); try vector8(); @@ -118,6 +121,7 @@ test "bitReverse vectors u16" { 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; comptime try vector16(); try vector16(); @@ -136,6 +140,7 @@ test "bitReverse vectors u24" { 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; comptime try vector24(); try vector24(); diff --git a/test/behavior/bool.zig b/test/behavior/bool.zig index a4e0ab499a..d216d72a05 100644 --- a/test/behavior/bool.zig +++ b/test/behavior/bool.zig @@ -1,4 +1,5 @@ const std = @import("std"); +const builtin = @import("builtin"); const expect = std.testing.expect; test "bool literals" { @@ -7,6 +8,8 @@ test "bool literals" { } test "cast bool to int" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const t = true; const f = false; try expect(@boolToInt(t) == @as(u32, 1)); diff --git a/test/behavior/bugs/10138.zig b/test/behavior/bugs/10138.zig index 88dc5acde7..1ea2954777 100644 --- a/test/behavior/bugs/10138.zig +++ b/test/behavior/bugs/10138.zig @@ -5,6 +5,7 @@ test "registers get overwritten when ignoring return" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.cpu.arch != .x86_64 or builtin.os.tag != .linux) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const fd = open(); _ = write(fd, "a", 1); diff --git a/test/behavior/bugs/10147.zig b/test/behavior/bugs/10147.zig index 77c513caa6..a1fe9bff68 100644 --- a/test/behavior/bugs/10147.zig +++ b/test/behavior/bugs/10147.zig @@ -7,6 +7,7 @@ test "test calling @clz on both vector and scalar inputs" { 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; var x: u32 = 0x1; var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 }; diff --git a/test/behavior/bugs/10684.zig b/test/behavior/bugs/10684.zig index ef104a3f0c..e7033eec8f 100644 --- a/test/behavior/bugs/10684.zig +++ b/test/behavior/bugs/10684.zig @@ -7,6 +7,7 @@ test "slicing slices" { 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 foo = "1234"; const bar = foo[0..4]; diff --git a/test/behavior/bugs/1076.zig b/test/behavior/bugs/1076.zig index ba2b61e3db..3eb07695cb 100644 --- a/test/behavior/bugs/1076.zig +++ b/test/behavior/bugs/1076.zig @@ -6,6 +6,7 @@ const expect = std.testing.expect; test "comptime code should not modify constant data" { 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; try testCastPtrOfArrayToSliceAndPtr(); comptime try testCastPtrOfArrayToSliceAndPtr(); diff --git a/test/behavior/bugs/10970.zig b/test/behavior/bugs/10970.zig index 539dfaff71..008242196c 100644 --- a/test/behavior/bugs/10970.zig +++ b/test/behavior/bugs/10970.zig @@ -7,6 +7,7 @@ test "breaking from a loop in an if statement" { 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; var cond = true; const opt = while (cond) { diff --git a/test/behavior/bugs/11046.zig b/test/behavior/bugs/11046.zig index a13e02e45c..6bf6041a65 100644 --- a/test/behavior/bugs/11046.zig +++ b/test/behavior/bugs/11046.zig @@ -13,6 +13,7 @@ test "fixed" { 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; bar() catch |err| switch (err) { error.Foo => {}, // error: expected (inferred error set of bar), found error{Foo} diff --git a/test/behavior/bugs/11100.zig b/test/behavior/bugs/11100.zig index cacc770ef0..1a55b94510 100644 --- a/test/behavior/bugs/11100.zig +++ b/test/behavior/bugs/11100.zig @@ -1,4 +1,6 @@ const std = @import("std"); +const builtin = @import("builtin"); + pub fn do() bool { inline for (.{"a"}) |_| { if (true) return false; @@ -7,5 +9,7 @@ pub fn do() bool { } test "bug" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try std.testing.expect(!do()); } diff --git a/test/behavior/bugs/11139.zig b/test/behavior/bugs/11139.zig index 572b2aed72..e04960c24b 100644 --- a/test/behavior/bugs/11139.zig +++ b/test/behavior/bugs/11139.zig @@ -6,6 +6,7 @@ test "store array of array of structs at comptime" { 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; try expect(storeArrayOfArrayOfStructs() == 15); comptime try expect(storeArrayOfArrayOfStructs() == 15); diff --git a/test/behavior/bugs/11165.zig b/test/behavior/bugs/11165.zig index e23861ddc1..129b605100 100644 --- a/test/behavior/bugs/11165.zig +++ b/test/behavior/bugs/11165.zig @@ -2,6 +2,7 @@ const builtin = @import("builtin"); test "bytes" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { a: u32, @@ -23,6 +24,7 @@ test "bytes" { test "aggregate" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { a: u32, diff --git a/test/behavior/bugs/11179.zig b/test/behavior/bugs/11179.zig index 84fa6183f3..ca3a27c5d1 100644 --- a/test/behavior/bugs/11179.zig +++ b/test/behavior/bugs/11179.zig @@ -1,4 +1,5 @@ const std = @import("std"); +const builtin = @import("builtin"); const Type = std.builtin.Type; test "Tuple" { diff --git a/test/behavior/bugs/11213.zig b/test/behavior/bugs/11213.zig index 7f13b6efd8..875c12697b 100644 --- a/test/behavior/bugs/11213.zig +++ b/test/behavior/bugs/11213.zig @@ -3,6 +3,8 @@ const builtin = @import("builtin"); const testing = std.testing; test { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const g: error{Test}!void = error.Test; var v: u32 = 0; diff --git a/test/behavior/bugs/11787.zig b/test/behavior/bugs/11787.zig index 6d17730a47..47af7a350a 100644 --- a/test/behavior/bugs/11787.zig +++ b/test/behavior/bugs/11787.zig @@ -7,6 +7,7 @@ test "slicing zero length array field of struct" { 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 S = struct { a: [0]usize, diff --git a/test/behavior/bugs/11816.zig b/test/behavior/bugs/11816.zig index cb548ef2e9..6061d668f3 100644 --- a/test/behavior/bugs/11816.zig +++ b/test/behavior/bugs/11816.zig @@ -4,6 +4,7 @@ const builtin = @import("builtin"); test { 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; var x: u32 = 3; const val: usize = while (true) switch (x) { diff --git a/test/behavior/bugs/11995.zig b/test/behavior/bugs/11995.zig index 255a366fb2..0ee8e56214 100644 --- a/test/behavior/bugs/11995.zig +++ b/test/behavior/bugs/11995.zig @@ -22,6 +22,8 @@ test { 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; + var string: [5]u8 = "hello".*; const arg_data = wuffs_base__slice_u8{ .ptr = @ptrCast([*c]u8, &string), .len = string.len }; var arg_meta = wuffs_base__io_buffer_meta{ .wi = 1, .ri = 2, .pos = 3, .closed = true }; diff --git a/test/behavior/bugs/12000.zig b/test/behavior/bugs/12000.zig index a823ce6a0a..808ca061b8 100644 --- a/test/behavior/bugs/12000.zig +++ b/test/behavior/bugs/12000.zig @@ -10,6 +10,8 @@ test { 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; + var t: T = .{ .next = null }; try std.testing.expect(t.next == null); } diff --git a/test/behavior/bugs/12025.zig b/test/behavior/bugs/12025.zig index 7b1804cf20..aa293aa6b5 100644 --- a/test/behavior/bugs/12025.zig +++ b/test/behavior/bugs/12025.zig @@ -1,4 +1,8 @@ +const builtin = @import("builtin"); + test { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + comptime var st = .{ .foo = &1, .bar = &2, diff --git a/test/behavior/bugs/12033.zig b/test/behavior/bugs/12033.zig index 563ed8e79b..dfe583f156 100644 --- a/test/behavior/bugs/12033.zig +++ b/test/behavior/bugs/12033.zig @@ -1,6 +1,9 @@ const std = @import("std"); +const builtin = @import("builtin"); test { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const string = "Hello!\x00World!"; try std.testing.expect(@TypeOf(string) == *const [13:0]u8); diff --git a/test/behavior/bugs/12043.zig b/test/behavior/bugs/12043.zig index 2b0d4d062d..835b2f6b4e 100644 --- a/test/behavior/bugs/12043.zig +++ b/test/behavior/bugs/12043.zig @@ -1,4 +1,5 @@ const std = @import("std"); +const builtin = @import("builtin"); const expect = std.testing.expect; var ok = false; @@ -6,6 +7,8 @@ fn foo(x: anytype) void { ok = x; } test { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const x = &foo; x(true); try expect(ok); diff --git a/test/behavior/bugs/12051.zig b/test/behavior/bugs/12051.zig index 2b2765358b..5509ab97cd 100644 --- a/test/behavior/bugs/12051.zig +++ b/test/behavior/bugs/12051.zig @@ -7,6 +7,8 @@ test { 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 x = X{}; try std.testing.expectEqual(@as(u16, 0), x.y.a); try std.testing.expectEqual(false, x.y.b); diff --git a/test/behavior/bugs/12092.zig b/test/behavior/bugs/12092.zig index 216138d748..434da854f8 100644 --- a/test/behavior/bugs/12092.zig +++ b/test/behavior/bugs/12092.zig @@ -18,6 +18,8 @@ test { 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; + var baz: u32 = 24; try takeFoo(&.{ .a = .{ diff --git a/test/behavior/bugs/12119.zig b/test/behavior/bugs/12119.zig index 8c734ad6d6..bb5167a3da 100644 --- a/test/behavior/bugs/12119.zig +++ b/test/behavior/bugs/12119.zig @@ -9,6 +9,8 @@ test { 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 zerox32: u8x32 = [_]u8{0} ** 32; const bigsum: u32x8 = @bitCast(u32x8, zerox32); try std.testing.expectEqual(0, @reduce(.Add, bigsum)); diff --git a/test/behavior/bugs/12142.zig b/test/behavior/bugs/12142.zig index 1efbd0dbb4..e5c022bf18 100644 --- a/test/behavior/bugs/12142.zig +++ b/test/behavior/bugs/12142.zig @@ -23,6 +23,8 @@ test { 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 test_struct = Test{ .holders = &.{ Holder{ diff --git a/test/behavior/bugs/12450.zig b/test/behavior/bugs/12450.zig index 4d0c7cd9a1..368f055d05 100644 --- a/test/behavior/bugs/12450.zig +++ b/test/behavior/bugs/12450.zig @@ -14,6 +14,8 @@ test { 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; + var f1: *align(16) Foo = @alignCast(16, @ptrCast(*align(1) Foo, &buffer[0])); try expect(@typeInfo(@TypeOf(f1)).Pointer.alignment == 16); try expect(@ptrToInt(f1) == @ptrToInt(&f1.a)); diff --git a/test/behavior/bugs/12551.zig b/test/behavior/bugs/12551.zig index df01e5cbdd..b2a79c0847 100644 --- a/test/behavior/bugs/12551.zig +++ b/test/behavior/bugs/12551.zig @@ -4,6 +4,7 @@ const builtin = @import("builtin"); test { 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; try std.testing.expect(for ([1]u8{0}) |x| { if (x == 0) break true; diff --git a/test/behavior/bugs/12571.zig b/test/behavior/bugs/12571.zig index 7b717369a6..f474c32824 100644 --- a/test/behavior/bugs/12571.zig +++ b/test/behavior/bugs/12571.zig @@ -14,6 +14,7 @@ const Entry = packed struct { test { 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 frame = Frame{ .num = 0x7FDE }; var entry = Entry{ .other = 0, .frame = .{ .num = 0xFFFFF } }; diff --git a/test/behavior/bugs/12644.zig b/test/behavior/bugs/12644.zig index 36874c12cb..3c0cc5656f 100644 --- a/test/behavior/bugs/12644.zig +++ b/test/behavior/bugs/12644.zig @@ -1,4 +1,5 @@ const std = @import("std"); +const builtin = @import("builtin"); inline fn foo(comptime T: type) !T { return error.AnError; @@ -9,6 +10,8 @@ fn main0() !void { } test "issue12644" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + main0() catch |e| { try std.testing.expect(e == error.AnError); }; diff --git a/test/behavior/bugs/12680.zig b/test/behavior/bugs/12680.zig index 362e03f8a8..b86a015e68 100644 --- a/test/behavior/bugs/12680.zig +++ b/test/behavior/bugs/12680.zig @@ -11,6 +11,7 @@ test "export a function twice" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.os.tag == .macos and builtin.zig_backend == .stage2_c) { // TODO: test.c: error: aliases are not supported on darwin return error.SkipZigTest; diff --git a/test/behavior/bugs/1277.zig b/test/behavior/bugs/1277.zig index 0dbf339f4d..64f8430cdb 100644 --- a/test/behavior/bugs/1277.zig +++ b/test/behavior/bugs/1277.zig @@ -16,6 +16,7 @@ test "don't emit an LLVM global for a const function when it's in an optional in if (builtin.zig_backend == .stage2_arm) 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; try std.testing.expect(s.f.?() == 1234); } diff --git a/test/behavior/bugs/12776.zig b/test/behavior/bugs/12776.zig index 95158f5ee3..2061d6e804 100644 --- a/test/behavior/bugs/12776.zig +++ b/test/behavior/bugs/12776.zig @@ -32,6 +32,7 @@ test { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_x86_64) { // Careful enabling this test, fails randomly. return error.SkipZigTest; diff --git a/test/behavior/bugs/12801-2.zig b/test/behavior/bugs/12801-2.zig index 5ae701a55c..e6243487b0 100644 --- a/test/behavior/bugs/12801-2.zig +++ b/test/behavior/bugs/12801-2.zig @@ -18,6 +18,7 @@ test { 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 a: Auto = .{ .offset = 16, .capacity = Auto.capacity }; try std.testing.expect(a.capacity() == 32); diff --git a/test/behavior/bugs/12890.zig b/test/behavior/bugs/12890.zig index 1316c2745e..a832f14cef 100644 --- a/test/behavior/bugs/12890.zig +++ b/test/behavior/bugs/12890.zig @@ -11,6 +11,7 @@ fn a(b: []u3, c: u3) void { test { 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; var arr: [8]u3 = undefined; a(&arr, 5); diff --git a/test/behavior/bugs/12891.zig b/test/behavior/bugs/12891.zig index 354d9e856e..9987a494e0 100644 --- a/test/behavior/bugs/12891.zig +++ b/test/behavior/bugs/12891.zig @@ -7,21 +7,29 @@ test "issue12891" { try std.testing.expect(i < f); } test "nan" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const f = comptime std.math.nan(f64); var i: usize = 0; try std.testing.expect(!(f < i)); } test "inf" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const f = comptime std.math.inf(f64); var i: usize = 0; try std.testing.expect(f > i); } test "-inf < 0" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const f = comptime -std.math.inf(f64); var i: usize = 0; try std.testing.expect(f < i); } test "inf >= 1" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const f = comptime std.math.inf(f64); var i: usize = 1; try std.testing.expect(f >= i); @@ -29,6 +37,7 @@ test "inf >= 1" { test "isNan(nan * 1)" { 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 nan_times_one = comptime std.math.nan(f64) * 1; try std.testing.expect(std.math.isNan(nan_times_one)); @@ -36,6 +45,7 @@ test "isNan(nan * 1)" { test "runtime isNan(nan * 1)" { 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 nan_times_one = std.math.nan(f64) * 1; try std.testing.expect(std.math.isNan(nan_times_one)); @@ -43,6 +53,7 @@ test "runtime isNan(nan * 1)" { test "isNan(nan * 0)" { 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 nan_times_zero = comptime std.math.nan(f64) * 0; try std.testing.expect(std.math.isNan(nan_times_zero)); @@ -52,6 +63,7 @@ test "isNan(nan * 0)" { test "isNan(inf * 0)" { 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 inf_times_zero = comptime std.math.inf(f64) * 0; try std.testing.expect(std.math.isNan(inf_times_zero)); @@ -61,6 +73,7 @@ test "isNan(inf * 0)" { test "runtime isNan(nan * 0)" { 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 nan_times_zero = std.math.nan(f64) * 0; try std.testing.expect(std.math.isNan(nan_times_zero)); @@ -70,6 +83,7 @@ test "runtime isNan(nan * 0)" { test "runtime isNan(inf * 0)" { 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 inf_times_zero = std.math.inf(f64) * 0; try std.testing.expect(std.math.isNan(inf_times_zero)); diff --git a/test/behavior/bugs/12928.zig b/test/behavior/bugs/12928.zig index 56eca8cf60..dd5a7761d7 100644 --- a/test/behavior/bugs/12928.zig +++ b/test/behavior/bugs/12928.zig @@ -1,5 +1,7 @@ const std = @import("std"); +const builtin = @import("builtin"); const expect = std.testing.expect; + const A = extern struct { value: *volatile B, }; @@ -7,11 +9,15 @@ const B = extern struct { a: u32, b: i32, }; + test { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var a: *A = undefined; try expect(@TypeOf(&a.value.a) == *volatile u32); try expect(@TypeOf(&a.value.b) == *volatile i32); } + const C = extern struct { value: *volatile D, }; @@ -20,6 +26,8 @@ const D = extern union { b: i32, }; test { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var c: *C = undefined; try expect(@TypeOf(&c.value.a) == *volatile u32); try expect(@TypeOf(&c.value.b) == *volatile i32); diff --git a/test/behavior/bugs/12972.zig b/test/behavior/bugs/12972.zig index 3c256a19f8..329e993ab8 100644 --- a/test/behavior/bugs/12972.zig +++ b/test/behavior/bugs/12972.zig @@ -6,6 +6,7 @@ test { 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 c: u8 = 42; f(&[_:null]?u8{c}); diff --git a/test/behavior/bugs/12984.zig b/test/behavior/bugs/12984.zig index 75f2747eda..0b144ed159 100644 --- a/test/behavior/bugs/12984.zig +++ b/test/behavior/bugs/12984.zig @@ -14,6 +14,7 @@ pub const CustomDraw = DeleagateWithContext(fn (?OnConfirm) void); test "simple test" { 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; var c: CustomDraw = undefined; _ = c; diff --git a/test/behavior/bugs/13064.zig b/test/behavior/bugs/13064.zig index a6fea11e86..f997bb46b9 100644 --- a/test/behavior/bugs/13064.zig +++ b/test/behavior/bugs/13064.zig @@ -6,6 +6,7 @@ test { 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; var x: [10][10]u32 = undefined; diff --git a/test/behavior/bugs/13065.zig b/test/behavior/bugs/13065.zig index 74f1d01c8c..d6c63db84b 100644 --- a/test/behavior/bugs/13065.zig +++ b/test/behavior/bugs/13065.zig @@ -11,6 +11,7 @@ test { 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; var x = U{ .array = undefined }; diff --git a/test/behavior/bugs/13068.zig b/test/behavior/bugs/13068.zig index bfe6164e27..046a27cc15 100644 --- a/test/behavior/bugs/13068.zig +++ b/test/behavior/bugs/13068.zig @@ -9,6 +9,7 @@ test { 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; list.items.len = 0; } diff --git a/test/behavior/bugs/13069.zig b/test/behavior/bugs/13069.zig index 41c5906ee6..916f3ba800 100644 --- a/test/behavior/bugs/13069.zig +++ b/test/behavior/bugs/13069.zig @@ -6,6 +6,7 @@ test { 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; var opt_x: ?[3]f32 = [_]f32{0.0} ** 3; diff --git a/test/behavior/bugs/13113.zig b/test/behavior/bugs/13113.zig index f9e0c8e7bb..72ab0f9f5e 100644 --- a/test/behavior/bugs/13113.zig +++ b/test/behavior/bugs/13113.zig @@ -11,6 +11,8 @@ test { 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 foo = Foo{ .a = 1, .b = 2, diff --git a/test/behavior/bugs/13128.zig b/test/behavior/bugs/13128.zig index 26f8510328..a378b42818 100644 --- a/test/behavior/bugs/13128.zig +++ b/test/behavior/bugs/13128.zig @@ -17,6 +17,7 @@ test "runtime union init, most-aligned field != largest" { if (builtin.zig_backend == .stage2_x86_64) 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; var x: u8 = 1; try foo(.{ .x = x }); diff --git a/test/behavior/bugs/13159.zig b/test/behavior/bugs/13159.zig index c394839731..6f8ae1842f 100644 --- a/test/behavior/bugs/13159.zig +++ b/test/behavior/bugs/13159.zig @@ -11,6 +11,8 @@ const Bar = packed struct { test { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var foo = Bar.Baz.fizz; try expect(foo == .fizz); } diff --git a/test/behavior/bugs/13285.zig b/test/behavior/bugs/13285.zig index 15ebfa5804..b87020bf46 100644 --- a/test/behavior/bugs/13285.zig +++ b/test/behavior/bugs/13285.zig @@ -6,6 +6,7 @@ const Crasher = struct { test { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: Crasher = undefined; var crasher_ptr = &a; diff --git a/test/behavior/bugs/13366.zig b/test/behavior/bugs/13366.zig index ff90ee00c3..cec015cc40 100644 --- a/test/behavior/bugs/13366.zig +++ b/test/behavior/bugs/13366.zig @@ -18,6 +18,7 @@ test { 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; var a: u32 = 16; var reason = .{ .c_import = .{ .a = a } }; diff --git a/test/behavior/bugs/13664.zig b/test/behavior/bugs/13664.zig index 16ebb6ed68..7171a89f29 100644 --- a/test/behavior/bugs/13664.zig +++ b/test/behavior/bugs/13664.zig @@ -18,6 +18,7 @@ test { 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 timestamp: i64 = value(); const id = ID{ .fields = Fields{ diff --git a/test/behavior/bugs/13785.zig b/test/behavior/bugs/13785.zig index 463cdbec68..53d03f5413 100644 --- a/test/behavior/bugs/13785.zig +++ b/test/behavior/bugs/13785.zig @@ -6,6 +6,7 @@ test { 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; var a: u8 = 0; try std.io.null_writer.print("\n{} {}\n", .{ a, S{} }); diff --git a/test/behavior/bugs/1381.zig b/test/behavior/bugs/1381.zig index ef34dc6410..aa349b4d13 100644 --- a/test/behavior/bugs/1381.zig +++ b/test/behavior/bugs/1381.zig @@ -17,6 +17,7 @@ test "union that needs padding bytes inside an array" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var as = [_]A{ A{ .B = B{ .D = 1 } }, diff --git a/test/behavior/bugs/1442.zig b/test/behavior/bugs/1442.zig index f9bef6ec50..7ce138dfd7 100644 --- a/test/behavior/bugs/1442.zig +++ b/test/behavior/bugs/1442.zig @@ -10,6 +10,8 @@ test "const error union field 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; + var union_or_err: anyerror!Union = Union{ .Color = 1234 }; try std.testing.expect((union_or_err catch unreachable).Color == 1234); } diff --git a/test/behavior/bugs/14854.zig b/test/behavior/bugs/14854.zig index b34dd49406..9c877bc688 100644 --- a/test/behavior/bugs/14854.zig +++ b/test/behavior/bugs/14854.zig @@ -1,6 +1,9 @@ const testing = @import("std").testing; +const builtin = @import("builtin"); test { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try testing.expect(getGeneric(u8, getU8) == 123); } diff --git a/test/behavior/bugs/1500.zig b/test/behavior/bugs/1500.zig index cc12c5d0be..3a6246b2c9 100644 --- a/test/behavior/bugs/1500.zig +++ b/test/behavior/bugs/1500.zig @@ -6,6 +6,8 @@ const A = struct { const B = *const fn (A) void; test "allow these dependencies" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var a: A = undefined; var b: B = undefined; if (false) { diff --git a/test/behavior/bugs/1607.zig b/test/behavior/bugs/1607.zig index a60a406b75..31904ec3fd 100644 --- a/test/behavior/bugs/1607.zig +++ b/test/behavior/bugs/1607.zig @@ -14,6 +14,8 @@ test "slices pointing at the same address as 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try checkAddress(&a); comptime try checkAddress(&a); } diff --git a/test/behavior/bugs/1735.zig b/test/behavior/bugs/1735.zig index 12600ccef9..78fd59e41e 100644 --- a/test/behavior/bugs/1735.zig +++ b/test/behavior/bugs/1735.zig @@ -44,6 +44,8 @@ const a = struct { test "initialization" { 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; + var t = a.init(); try std.testing.expect(t.foo.len == 0); } diff --git a/test/behavior/bugs/1741.zig b/test/behavior/bugs/1741.zig index 63de6e83dc..6c36ba5e15 100644 --- a/test/behavior/bugs/1741.zig +++ b/test/behavior/bugs/1741.zig @@ -5,6 +5,7 @@ test "fixed" { if (builtin.zig_backend == .stage2_wasm) 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 x: f32 align(128) = 12.34; try std.testing.expect(@ptrToInt(&x) % 128 == 0); diff --git a/test/behavior/bugs/1851.zig b/test/behavior/bugs/1851.zig index cf7c7ced28..4af02feaca 100644 --- a/test/behavior/bugs/1851.zig +++ b/test/behavior/bugs/1851.zig @@ -7,6 +7,7 @@ test "allocation and looping over 3-byte integer" { 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_llvm and builtin.os.tag == .macos) { return error.SkipZigTest; // TODO diff --git a/test/behavior/bugs/1914.zig b/test/behavior/bugs/1914.zig index bd3f830e60..14f4b0be27 100644 --- a/test/behavior/bugs/1914.zig +++ b/test/behavior/bugs/1914.zig @@ -12,6 +12,8 @@ const b_list: []B = &[_]B{}; const a = A{ .b_list_pointer = &b_list }; test "segfault bug" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const assert = std.debug.assert; const obj = B{ .a_pointer = &a }; assert(obj.a_pointer == &a); // this makes zig crash @@ -28,5 +30,7 @@ pub const B2 = struct { var b_value = B2{ .pointer_array = &[_]*A2{} }; test "basic stuff" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + std.debug.assert(&b_value == &b_value); } diff --git a/test/behavior/bugs/2006.zig b/test/behavior/bugs/2006.zig index 3a4e61b11d..40f03d5b0b 100644 --- a/test/behavior/bugs/2006.zig +++ b/test/behavior/bugs/2006.zig @@ -7,6 +7,7 @@ const S = struct { }; test "bug 2006" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: S = undefined; a = S{ .p = undefined }; diff --git a/test/behavior/bugs/2114.zig b/test/behavior/bugs/2114.zig index 3ad4a97b80..265de399f7 100644 --- a/test/behavior/bugs/2114.zig +++ b/test/behavior/bugs/2114.zig @@ -14,6 +14,7 @@ test "fixed" { 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; try testCtz(); comptime try testCtz(); diff --git a/test/behavior/bugs/2578.zig b/test/behavior/bugs/2578.zig index ff8ba141fa..9cf34e980d 100644 --- a/test/behavior/bugs/2578.zig +++ b/test/behavior/bugs/2578.zig @@ -15,6 +15,7 @@ test "fixed" { 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_spirv64) return error.SkipZigTest; bar(t); } diff --git a/test/behavior/bugs/2622.zig b/test/behavior/bugs/2622.zig index 89130a3974..d3d2b078e2 100644 --- a/test/behavior/bugs/2622.zig +++ b/test/behavior/bugs/2622.zig @@ -7,6 +7,7 @@ test "reslice of undefined global var slice" { 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; var mem: [100]u8 = [_]u8{0} ** 100; buf = &mem; diff --git a/test/behavior/bugs/2692.zig b/test/behavior/bugs/2692.zig index d89b3b5449..0eed28b2e7 100644 --- a/test/behavior/bugs/2692.zig +++ b/test/behavior/bugs/2692.zig @@ -7,6 +7,7 @@ fn foo(a: []u8) void { test "address of 0 length array" { 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; var pt: [0]u8 = undefined; foo(&pt); diff --git a/test/behavior/bugs/3007.zig b/test/behavior/bugs/3007.zig index 3ae1562e9b..7adec60a3b 100644 --- a/test/behavior/bugs/3007.zig +++ b/test/behavior/bugs/3007.zig @@ -22,6 +22,7 @@ test "fixed" { 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_spirv64) return error.SkipZigTest; default_foo = get_foo() catch null; // This Line try std.testing.expect(!default_foo.?.free); diff --git a/test/behavior/bugs/3046.zig b/test/behavior/bugs/3046.zig index 24e18043a0..683ece874e 100644 --- a/test/behavior/bugs/3046.zig +++ b/test/behavior/bugs/3046.zig @@ -16,6 +16,7 @@ test "fixed" { 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; some_struct = SomeStruct{ .field = couldFail() catch @as(i32, 0), diff --git a/test/behavior/bugs/3112.zig b/test/behavior/bugs/3112.zig index 0b0f767e77..b1dc2e2908 100644 --- a/test/behavior/bugs/3112.zig +++ b/test/behavior/bugs/3112.zig @@ -15,6 +15,8 @@ test "zig test crash" { 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; + var global: State = undefined; global.enter = prev; global.enter(null); diff --git a/test/behavior/bugs/3367.zig b/test/behavior/bugs/3367.zig index 68b7d90ae8..775e918f63 100644 --- a/test/behavior/bugs/3367.zig +++ b/test/behavior/bugs/3367.zig @@ -10,6 +10,8 @@ const Mixin = struct { }; test "container member access usingnamespace decls" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var foo = Foo{}; foo.two(); } diff --git a/test/behavior/bugs/3742.zig b/test/behavior/bugs/3742.zig index 1ee88b8b64..09d209912e 100644 --- a/test/behavior/bugs/3742.zig +++ b/test/behavior/bugs/3742.zig @@ -40,5 +40,7 @@ test "fixed" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + ArgSerializer.serializeCommand(GET.init("banana")); } diff --git a/test/behavior/bugs/3779.zig b/test/behavior/bugs/3779.zig index c2bd103118..2b1dad5de0 100644 --- a/test/behavior/bugs/3779.zig +++ b/test/behavior/bugs/3779.zig @@ -8,6 +8,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name; test "@tagName() returns a string literal" { 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; try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name)); try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name)); @@ -21,6 +22,7 @@ const ptr_error_name: [*:0]const u8 = error_name; test "@errorName() returns a string literal" { 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; try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name)); try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name)); @@ -34,6 +36,7 @@ const ptr_type_name: [*:0]const u8 = type_name; test "@typeName() returns a string literal" { 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; try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name)); try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name)); @@ -47,6 +50,7 @@ const expected_contents = "hello zig\n"; test "@embedFile() returns a string literal" { 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; try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents)); try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents)); @@ -61,6 +65,7 @@ fn testFnForSrc() std.builtin.SourceLocation { test "@src() returns a struct containing 0-terminated string slices" { 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 src = testFnForSrc(); try std.testing.expect([:0]const u8 == @TypeOf(src.file)); diff --git a/test/behavior/bugs/421.zig b/test/behavior/bugs/421.zig index 69ecbd2331..f44cee37a9 100644 --- a/test/behavior/bugs/421.zig +++ b/test/behavior/bugs/421.zig @@ -5,6 +5,7 @@ test "bitCast to array" { 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; comptime try testBitCastArray(); try testBitCastArray(); diff --git a/test/behavior/bugs/4328.zig b/test/behavior/bugs/4328.zig index 924a8cb909..89eb4d4fd0 100644 --- a/test/behavior/bugs/4328.zig +++ b/test/behavior/bugs/4328.zig @@ -17,6 +17,8 @@ const S = extern struct { }; test "Extern function calls in @TypeOf" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const Test = struct { fn test_fn_1(a: anytype, b: anytype) @TypeOf(c_printf("%d %s\n", a, b)) { return 0; @@ -37,6 +39,8 @@ test "Extern function calls in @TypeOf" { } test "Peer resolution of extern function calls in @TypeOf" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const Test = struct { fn test_fn() @TypeOf(c_ftell(null), c_fputs(null, null)) { return 0; @@ -54,6 +58,7 @@ test "Peer resolution of extern function calls in @TypeOf" { test "Extern function calls, dereferences and field access in @TypeOf" { 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; const Test = struct { fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) { diff --git a/test/behavior/bugs/4954.zig b/test/behavior/bugs/4954.zig index 8cae03d314..15c3185fa9 100644 --- a/test/behavior/bugs/4954.zig +++ b/test/behavior/bugs/4954.zig @@ -8,6 +8,7 @@ test "crash" { 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; var buf: [4096]u8 = undefined; f(&buf); diff --git a/test/behavior/bugs/529.zig b/test/behavior/bugs/529.zig index 3319d06c95..a2e330055a 100644 --- a/test/behavior/bugs/529.zig +++ b/test/behavior/bugs/529.zig @@ -16,6 +16,7 @@ test "issue 529 fixed" { 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; @import("529_other_file.zig").issue529(null); issue529(null); diff --git a/test/behavior/bugs/5398.zig b/test/behavior/bugs/5398.zig index 6f75bd9436..4dc4ab8d19 100644 --- a/test/behavior/bugs/5398.zig +++ b/test/behavior/bugs/5398.zig @@ -22,6 +22,7 @@ test "assignment of field with padding" { 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; renderable = Renderable{ .mesh = Mesh{ .id = 0 }, diff --git a/test/behavior/bugs/6047.zig b/test/behavior/bugs/6047.zig index d3c2c8349c..54e1fd20d6 100644 --- a/test/behavior/bugs/6047.zig +++ b/test/behavior/bugs/6047.zig @@ -14,6 +14,7 @@ test "`try`ing an if/else expression" { 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; try @import("std").testing.expectError(error.Test, getError2()); } diff --git a/test/behavior/bugs/6456.zig b/test/behavior/bugs/6456.zig index 3dbec7bc70..1eef9c7f75 100644 --- a/test/behavior/bugs/6456.zig +++ b/test/behavior/bugs/6456.zig @@ -13,6 +13,7 @@ const text = test "issue 6456" { 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; comptime { var fields: []const StructField = &[0]StructField{}; diff --git a/test/behavior/bugs/656.zig b/test/behavior/bugs/656.zig index 216c9d8e1c..161da66964 100644 --- a/test/behavior/bugs/656.zig +++ b/test/behavior/bugs/656.zig @@ -14,6 +14,8 @@ test "optional if after an if in a switch prong of a switch with 2 prongs in an 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 foo(false, true); } diff --git a/test/behavior/bugs/6781.zig b/test/behavior/bugs/6781.zig index dd12bf2a93..2f5d7a3807 100644 --- a/test/behavior/bugs/6781.zig +++ b/test/behavior/bugs/6781.zig @@ -68,6 +68,7 @@ test "fixed" { 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; var buffer align(@alignOf(JournalHeader)) = [_]u8{0} ** 65536; var entry = std.mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]); diff --git a/test/behavior/bugs/6905.zig b/test/behavior/bugs/6905.zig index 4f308ede22..5792713c89 100644 --- a/test/behavior/bugs/6905.zig +++ b/test/behavior/bugs/6905.zig @@ -6,6 +6,7 @@ test "sentinel-terminated 0-length slices" { 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; var u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 }; diff --git a/test/behavior/bugs/6947.zig b/test/behavior/bugs/6947.zig index c2b538c3fa..9aff7b992e 100644 --- a/test/behavior/bugs/6947.zig +++ b/test/behavior/bugs/6947.zig @@ -9,6 +9,7 @@ test { 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; var slice: []void = undefined; destroy(&slice[0]); diff --git a/test/behavior/bugs/7047.zig b/test/behavior/bugs/7047.zig index a60a7d2bbb..a7a0966935 100644 --- a/test/behavior/bugs/7047.zig +++ b/test/behavior/bugs/7047.zig @@ -1,4 +1,5 @@ const std = @import("std"); +const builtin = @import("builtin"); const U = union(enum) { T: type, @@ -14,6 +15,8 @@ fn S(comptime query: U) type { } test "compiler doesn't consider equal unions with different 'type' payload" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const s1 = S(U{ .T = u32 }).tag(); try std.testing.expectEqual(u32, s1); diff --git a/test/behavior/bugs/718.zig b/test/behavior/bugs/718.zig index 1c88908f75..b0f0d1ec52 100644 --- a/test/behavior/bugs/718.zig +++ b/test/behavior/bugs/718.zig @@ -13,6 +13,7 @@ test "zero keys with @memset" { 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; @memset(@ptrCast([*]u8, &keys)[0..@sizeOf(@TypeOf(keys))], 0); try expect(!keys.up); diff --git a/test/behavior/bugs/7187.zig b/test/behavior/bugs/7187.zig index bb2e82af89..be593d7fad 100644 --- a/test/behavior/bugs/7187.zig +++ b/test/behavior/bugs/7187.zig @@ -3,6 +3,8 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "miscompilation with bool return type" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var x: usize = 1; var y: bool = getFalse(); _ = y; diff --git a/test/behavior/bugs/726.zig b/test/behavior/bugs/726.zig index cc5c2a5fb7..0cd8abc1cf 100644 --- a/test/behavior/bugs/726.zig +++ b/test/behavior/bugs/726.zig @@ -5,6 +5,7 @@ test "@ptrCast from const to nullable" { 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; const c: u8 = 4; var x: ?*const u8 = @ptrCast(?*const u8, &c); @@ -15,6 +16,7 @@ test "@ptrCast from var in empty struct to nullable" { 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; const container = struct { var c: u8 = 4; diff --git a/test/behavior/bugs/7325.zig b/test/behavior/bugs/7325.zig index 23550a512d..5c0c55a644 100644 --- a/test/behavior/bugs/7325.zig +++ b/test/behavior/bugs/7325.zig @@ -82,6 +82,7 @@ test { 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; var param: ParamType = .{ .one_of = .{ .name = "name" }, diff --git a/test/behavior/bugs/8277.zig b/test/behavior/bugs/8277.zig index 8d64d49223..149962d996 100644 --- a/test/behavior/bugs/8277.zig +++ b/test/behavior/bugs/8277.zig @@ -2,6 +2,8 @@ const std = @import("std"); const builtin = @import("builtin"); test "@sizeOf reified union zero-size payload fields" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + comptime { try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union {})))); try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union { a: void })))); diff --git a/test/behavior/bugs/828.zig b/test/behavior/bugs/828.zig index 220d98ce09..a0ac00817d 100644 --- a/test/behavior/bugs/828.zig +++ b/test/behavior/bugs/828.zig @@ -31,6 +31,7 @@ fn constCount(comptime cb: *const CountBy, comptime unused: u32) void { test "comptime struct return should not return the same instance" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; //the first parameter must be passed by reference to trigger the bug //a second parameter is required to trigger the bug diff --git a/test/behavior/bugs/8646.zig b/test/behavior/bugs/8646.zig index da9359a60a..1bd81f799f 100644 --- a/test/behavior/bugs/8646.zig +++ b/test/behavior/bugs/8646.zig @@ -11,6 +11,7 @@ test { 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; try std.testing.expect(array[0].len == 1); try std.testing.expectEqualStrings("hello", array[0][0]); diff --git a/test/behavior/bugs/920.zig b/test/behavior/bugs/920.zig index b1c9bc07a3..8a9bf51512 100644 --- a/test/behavior/bugs/920.zig +++ b/test/behavior/bugs/920.zig @@ -62,6 +62,7 @@ test "bug 920 fixed" { 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 NormalDist1 = blk: { break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case); diff --git a/test/behavior/bugs/9584.zig b/test/behavior/bugs/9584.zig index 307f1689bf..49139db899 100644 --- a/test/behavior/bugs/9584.zig +++ b/test/behavior/bugs/9584.zig @@ -47,6 +47,7 @@ test { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var flags = A{ .a = false, diff --git a/test/behavior/byteswap.zig b/test/behavior/byteswap.zig index 8bd6fec6e3..e779626765 100644 --- a/test/behavior/byteswap.zig +++ b/test/behavior/byteswap.zig @@ -8,6 +8,7 @@ test "@byteSwap integers" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const ByteSwapIntTest = struct { fn run() !void { @@ -66,6 +67,7 @@ test "@byteSwap vectors u8" { 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; comptime try vector8(); try vector8(); @@ -84,6 +86,7 @@ test "@byteSwap vectors u16" { 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; comptime try vector16(); try vector16(); @@ -102,6 +105,7 @@ test "@byteSwap vectors u24" { 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; comptime try vector24(); try vector24(); diff --git a/test/behavior/byval_arg_var.zig b/test/behavior/byval_arg_var.zig index 01b5f90ef7..3a82ca86ad 100644 --- a/test/behavior/byval_arg_var.zig +++ b/test/behavior/byval_arg_var.zig @@ -5,6 +5,7 @@ var result: []const u8 = "wrong"; test "pass string literal byvalue to a generic var param" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; start(); blowUpStack(10); diff --git a/test/behavior/call.zig b/test/behavior/call.zig index ab947f69dd..e7d59d7e75 100644 --- a/test/behavior/call.zig +++ b/test/behavior/call.zig @@ -24,6 +24,7 @@ test "basic invocations" { 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 foo = struct { fn foo() i32 { @@ -56,6 +57,7 @@ test "tuple parameters" { 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 add = struct { fn add(a: i32, b: i32) i32 { @@ -88,6 +90,7 @@ test "result location of function call argument through runtime condition and st 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 E = enum { a, b }; const S = struct { @@ -106,6 +109,7 @@ test "result location of function call argument through runtime condition and st test "function call with 40 arguments" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(thirty_nine: i32) !void { @@ -265,6 +269,7 @@ test "forced tail call" { if (builtin.zig_backend == .stage2_wasm) 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; if (builtin.zig_backend == .stage2_llvm) { // Only attempt this test on targets we know have tail call support in LLVM. @@ -298,6 +303,7 @@ test "inline call preserves tail call" { if (builtin.zig_backend == .stage2_wasm) 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; if (builtin.zig_backend == .stage2_llvm) { // Only attempt this test on targets we know have tail call support in LLVM. @@ -329,6 +335,7 @@ test "inline call preserves tail call" { test "inline call doesn't re-evaluate non generic struct" { 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 S = struct { fn foo(f: struct { a: u8, b: u8 }) !void { @@ -367,6 +374,8 @@ test "Enum constructed by @Type passed as generic argument" { } test "generic function with generic function parameter" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn f(comptime a: fn (anytype) anyerror!void, b: anytype) anyerror!void { try a(b); @@ -379,6 +388,8 @@ test "generic function with generic function parameter" { } test "recursive inline call with comptime known argument" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { inline fn foo(x: i32) i32 { if (x <= 0) { @@ -395,6 +406,7 @@ test "recursive inline call with comptime known argument" { test "inline while with @call" { 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 S = struct { fn inc(a: *u32) void { diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index 039e0a3d17..20f84184a0 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -97,6 +97,7 @@ test "@intToFloat" { 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 { @@ -119,6 +120,7 @@ test "@intToFloat(f80)" { 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; const S = struct { fn doTheTest(comptime Int: type) !void { @@ -154,6 +156,7 @@ test "@floatToInt" { if (builtin.zig_backend == .stage2_x86_64) 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; try testFloatToInts(); comptime try testFloatToInts(); @@ -176,6 +179,7 @@ fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) !void { test "implicitly cast indirect pointer to maybe-indirect pointer" { 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; const S = struct { const Self = @This(); @@ -204,12 +208,16 @@ test "implicitly cast indirect pointer to maybe-indirect pointer" { } test "@intCast comptime_int" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const result = @intCast(i32, 1234); try expect(@TypeOf(result) == i32); try expect(result == 1234); } test "@floatCast comptime_int and comptime_float" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + { const result = @floatCast(f16, 1234); try expect(@TypeOf(result) == f16); @@ -236,6 +244,7 @@ test "coerce undefined to optional" { 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 expect(MakeType(void).getNull() == null); try expect(MakeType(void).getNonNull() != null); @@ -256,6 +265,7 @@ fn MakeType(comptime T: type) type { test "implicit cast from *[N]T to [*c]T" { 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; var x: [4]u16 = [4]u16{ 0, 1, 2, 3 }; var y: [*c]u16 = &x; @@ -267,6 +277,8 @@ test "implicit cast from *[N]T to [*c]T" { } test "*usize to *void" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var i = @as(usize, 0); var v = @ptrCast(*void, &i); v.* = {}; @@ -317,6 +329,7 @@ test "peer result null and comptime_int" { test "*const ?[*]const T to [*c]const [*c]const T" { 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; var array = [_]u8{ 'o', 'k' }; const opt_array_ptr: ?[*]const u8 = &array; @@ -329,6 +342,7 @@ test "*const ?[*]const T to [*c]const [*c]const T" { test "array coersion to undefined at runtime" { 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; @setRuntimeSafety(true); @@ -359,6 +373,7 @@ test "return u8 coercing into ?u32 return type" { 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; const S = struct { fn doTheTest() !void { @@ -380,6 +395,7 @@ test "cast from ?[*]T to ??[*]T" { test "peer type unsigned int to signed" { 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; var w: u31 = 5; var x: u8 = 7; @@ -392,6 +408,7 @@ test "peer type unsigned int to signed" { test "expected [*c]const u8, found [*:0]const u8" { 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; var a: [*:0]const u8 = "hello"; var b: [*c]const u8 = a; @@ -403,6 +420,7 @@ test "explicit cast from integer to error 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_spirv64) return error.SkipZigTest; try testCastIntToErr(error.ItBroke); comptime try testCastIntToErr(error.ItBroke); @@ -417,6 +435,7 @@ test "peer resolve array and const slice" { 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_spirv64) return error.SkipZigTest; try testPeerResolveArrayConstSlice(true); comptime try testPeerResolveArrayConstSlice(true); @@ -432,6 +451,7 @@ test "implicitly cast from T to anyerror!?T" { 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 castToOptionalTypeError(1); comptime try castToOptionalTypeError(1); @@ -457,6 +477,7 @@ fn castToOptionalTypeError(z: i32) !void { test "implicitly cast from [0]T to anyerror![]T" { 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; try testCastZeroArrayToErrSliceMut(); comptime try testCastZeroArrayToErrSliceMut(); @@ -474,6 +495,7 @@ test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() anyerror!void { @@ -505,6 +527,7 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 { test "implicit cast from *const [N]T to []const T" { 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; try testCastConstArrayRefToConstSlice(); comptime try testCastConstArrayRefToConstSlice(); @@ -530,6 +553,7 @@ fn testCastConstArrayRefToConstSlice() !void { test "peer type resolution: error and [N]T" { 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; try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); comptime try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); @@ -554,6 +578,7 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 { test "single-item pointer of array to slice to unknown length pointer" { 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; try testCastPtrOfArrayToSliceAndPtr(); comptime try testCastPtrOfArrayToSliceAndPtr(); @@ -583,6 +608,7 @@ fn testCastPtrOfArrayToSliceAndPtr() !void { test "cast *[1][*]const u8 to [*]const ?[*]const u8" { 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; const window_name = [1][*]const u8{"window name"}; const x: [*]const ?[*]const u8 = &window_name; @@ -595,6 +621,7 @@ test "vector casts" { 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 { @@ -636,6 +663,7 @@ test "@floatCast cast down" { 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; { var double: f64 = 0.001534; @@ -652,6 +680,7 @@ test "@floatCast cast down" { test "peer type resolution: unreachable, error set, unreachable" { 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 Error = error{ FileDescriptorAlreadyPresentInSet, @@ -686,6 +715,7 @@ test "peer type resolution: error set supersets" { 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 a: error{ One, Two } = undefined; const b: error{One} = undefined; @@ -715,6 +745,7 @@ test "peer type resolution: disjoint error sets" { 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{ One, Two } = undefined; const b: error{Three} = undefined; @@ -744,6 +775,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; @@ -777,6 +809,7 @@ test "peer type resolution: error union after non-error" { 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: u32 = undefined; const b: error{ One, Two }!u32 = undefined; @@ -810,6 +843,7 @@ test "peer cast *[0]T to E![]const T" { 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; var buffer: [5]u8 = "abcde".*; var buf: anyerror![]const u8 = buffer[0..]; @@ -824,6 +858,7 @@ test "peer cast *[0]T to []const T" { 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; var buffer: [5]u8 = "abcde".*; var buf: []const u8 = buffer[0..]; @@ -834,6 +869,7 @@ test "peer cast *[0]T to []const T" { test "peer cast *[N]T to [*]T" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var array = [4:99]i32{ 1, 2, 3, 4 }; var dest: [*]i32 = undefined; @@ -845,6 +881,7 @@ test "peer resolution of string literals" { 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_spirv64) return error.SkipZigTest; const S = struct { const E = enum { a, b, c, d }; @@ -866,6 +903,7 @@ test "peer resolution of string literals" { test "peer cast [:x]T to []T" { 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; const S = struct { fn doTheTest() !void { @@ -882,6 +920,7 @@ test "peer cast [:x]T to []T" { test "peer cast [N:x]T to [N]T" { 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; const S = struct { fn doTheTest() !void { @@ -897,6 +936,7 @@ test "peer cast [N:x]T to [N]T" { test "peer cast *[N:x]T to *[N]T" { 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 { fn doTheTest() !void { @@ -912,6 +952,7 @@ test "peer cast *[N:x]T to *[N]T" { test "peer cast [*:x]T to [*]T" { 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 { fn doTheTest() !void { @@ -932,6 +973,7 @@ test "peer cast [:x]T to [*:x]T" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -952,6 +994,7 @@ test "peer cast [:x]T to [*:x]T" { test "peer type resolution implicit cast to return type" { 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; const S = struct { fn doTheTest() !void { @@ -972,6 +1015,7 @@ test "peer type resolution implicit cast to return type" { test "peer type resolution implicit cast to variable type" { 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; const S = struct { fn doTheTest() !void { @@ -996,6 +1040,7 @@ test "variable initialization uses result locations properly with regards to the test "cast between C pointer with different but compatible types" { 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 { fn foo(arg: [*]c_ushort) u16 { @@ -1013,6 +1058,7 @@ test "cast between C pointer with different but compatible types" { test "peer type resolve string lit with sentinel-terminated mutable slice" { 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; var array: [4:0]u8 = undefined; array[4] = 0; // TODO remove this when #4372 is solved @@ -1022,6 +1068,8 @@ test "peer type resolve string lit with sentinel-terminated mutable slice" { } test "peer type resolve array pointers, one of them const" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var array1: [4]u8 = undefined; const array2: [5]u8 = undefined; comptime try expect(@TypeOf(&array1, &array2) == []const u8); @@ -1029,6 +1077,8 @@ test "peer type resolve array pointers, one of them const" { } test "peer type resolve array pointer and unknown pointer" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const const_array: [4]u8 = undefined; var array: [4]u8 = undefined; var const_ptr: [*]const u8 = undefined; @@ -1048,6 +1098,8 @@ test "peer type resolve array pointer and unknown pointer" { } test "comptime float casts" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const a = @intToFloat(comptime_float, 1); try expect(a == 1); try expect(@TypeOf(a) == comptime_float); @@ -1078,6 +1130,7 @@ test "implicit cast from [*]T to ?*anyopaque" { 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_spirv64) return error.SkipZigTest; var a = [_]u8{ 3, 2, 1 }; var runtime_zero: usize = 0; @@ -1093,6 +1146,8 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void { } test "compile time int to ptr of function" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try foobar(FUNCTION_CONSTANT); } @@ -1109,6 +1164,7 @@ test "implicit ptr to *anyopaque" { 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_spirv64) return error.SkipZigTest; var a: u32 = 1; var ptr: *align(@alignOf(u32)) anyopaque = &a; @@ -1122,6 +1178,7 @@ test "implicit ptr to *anyopaque" { test "return null from fn() anyerror!?&T" { 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; const a = returnNullFromOptionalTypeErrorRef(); const b = returnNullLitFromOptionalTypeErrorRef(); @@ -1138,6 +1195,7 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A { test "peer type resolution: [0]u8 and []const u8" { 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; try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0); try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1); @@ -1158,6 +1216,7 @@ test "implicitly cast from [N]T to ?[]const T" { 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_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, castToOptionalSlice().?, "hi")); comptime try expect(mem.eql(u8, castToOptionalSlice().?, "hi")); @@ -1172,6 +1231,7 @@ test "cast u128 to f128 and back" { 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; comptime try testCast128(); try testCast128(); @@ -1193,6 +1253,7 @@ test "implicit cast from *[N]T to ?[*]T" { 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_spirv64) return error.SkipZigTest; var x: ?[*]u16 = null; var y: [4]u16 = [4]u16{ 0, 1, 2, 3 }; @@ -1208,6 +1269,7 @@ test "implicit cast from *T to ?*anyopaque" { 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_spirv64) return error.SkipZigTest; var a: u8 = 1; incrementVoidPtrValue(&a); @@ -1221,6 +1283,7 @@ fn incrementVoidPtrValue(value: ?*anyopaque) void { test "implicit cast *[0]T to E![]const u8" { 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; var x = @as(anyerror![]const u8, &[0]u8{}); try expect((x catch unreachable).len == 0); @@ -1228,10 +1291,14 @@ test "implicit cast *[0]T to E![]const u8" { var global_array: [4]u8 = undefined; test "cast from array reference to fn: comptime fn ptr" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const f = @ptrCast(*align(1) const fn () callconv(.C) void, &global_array); try expect(@ptrToInt(f) == @ptrToInt(&global_array)); } test "cast from array reference to fn: runtime fn ptr" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var f = @ptrCast(*align(1) const fn () callconv(.C) void, &global_array); try expect(@ptrToInt(f) == @ptrToInt(&global_array)); } @@ -1240,6 +1307,7 @@ test "*const [N]null u8 to ?[]const u8" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1253,6 +1321,8 @@ test "*const [N]null u8 to ?[]const u8" { } test "cast between [*c]T and ?[*:0]T on fn parameter" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { const Handler = ?fn ([*c]const u8) callconv(.C) void; fn addCallback(comptime handler: Handler) void { @@ -1275,12 +1345,15 @@ test "assignment to optional pointer result loc" { 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_spirv64) return error.SkipZigTest; var foo: struct { ptr: ?*anyopaque } = .{ .ptr = &global_struct }; try expect(foo.ptr.? == @ptrCast(*anyopaque, &global_struct)); } test "cast between *[N]void and []void" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var a: [4]void = undefined; var b: []void = &a; try expect(b.len == 4); @@ -1289,6 +1362,7 @@ test "cast between *[N]void and []void" { test "peer resolve arrays of different size to const slice" { 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; try expect(mem.eql(u8, boolToStr(true), "true")); try expect(mem.eql(u8, boolToStr(false), "false")); @@ -1305,6 +1379,7 @@ test "cast f16 to wider types" { if (builtin.zig_backend == .stage2_x86_64) 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; const S = struct { fn doTheTest() !void { @@ -1324,6 +1399,7 @@ test "cast f128 to narrower types" { if (builtin.zig_backend == .stage2_x86_64) 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; const S = struct { fn doTheTest() !void { @@ -1341,6 +1417,7 @@ test "peer type resolution: unreachable, null, slice" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(num: usize, word: []const u8) !void { @@ -1380,6 +1457,7 @@ test "cast compatible optional types" { 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; var a: ?[:0]const u8 = null; var b: ?[]const u8 = a; @@ -1389,6 +1467,7 @@ test "cast compatible optional types" { test "coerce undefined single-item pointer of array to error union of slice" { 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 = @as([*]u8, undefined)[0..0]; var b: error{a}![]const u8 = a; @@ -1398,6 +1477,7 @@ test "coerce undefined single-item pointer of array to error union of slice" { test "pointer to empty struct literal to mutable slice" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: []i32 = &.{}; try expect(x.len == 0); @@ -1409,6 +1489,7 @@ test "coerce between pointers of compatible differently-named floats" { if (builtin.zig_backend == .stage2_x86_64) 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; if (builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12396 @@ -1463,6 +1544,7 @@ test "cast typed undefined to int" { test "implicit cast from [:0]T to [*c]T" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: [:0]const u8 = "foo"; var b: [*c]const u8 = a; @@ -1485,6 +1567,7 @@ test "bitcast packed struct with u0" { test "optional pointer coerced to optional allowzero pointer" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var p: ?*u32 = undefined; var q: ?*allowzero u32 = undefined; @@ -1494,6 +1577,8 @@ test "optional pointer coerced to optional allowzero pointer" { } test "single item pointer to pointer to array to slice" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var x: i32 = 1234; try expect(@as([]const i32, @as(*[1]i32, &x))[0] == 1234); const z1 = @as([]const i32, @as(*[1]i32, &x)); @@ -1502,6 +1587,7 @@ test "single item pointer to pointer to array to slice" { test "peer type resolution forms error union" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var foo: i32 = 123; const result = if (foo < 0) switch (-foo) { @@ -1528,6 +1614,8 @@ test "@volatileCast without a result location" { } test "coercion from single-item pointer to @as to slice" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var x: u32 = 1; // Why the following line gets a compile error? diff --git a/test/behavior/cast_int.zig b/test/behavior/cast_int.zig index fef31c1822..c04c300d45 100644 --- a/test/behavior/cast_int.zig +++ b/test/behavior/cast_int.zig @@ -8,6 +8,7 @@ test "@intCast i32 to u7" { 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; var x: u128 = maxInt(u128); var y: i32 = 120; diff --git a/test/behavior/const_slice_child.zig b/test/behavior/const_slice_child.zig index 35bc007d84..68c6863bcd 100644 --- a/test/behavior/const_slice_child.zig +++ b/test/behavior/const_slice_child.zig @@ -10,6 +10,7 @@ test "const slice child" { 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 strs = [_][*]const u8{ "one", "two", "three" }; argv = &strs; diff --git a/test/behavior/decltest.zig b/test/behavior/decltest.zig index f731f80fb2..7aa8fb6318 100644 --- a/test/behavior/decltest.zig +++ b/test/behavior/decltest.zig @@ -1,7 +1,11 @@ +const builtin = @import("builtin"); + pub fn the_add_function(a: u32, b: u32) u32 { return a + b; } test the_add_function { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (the_add_function(1, 2) != 3) unreachable; } diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig index c5ea12aff0..5aa8c2f02b 100644 --- a/test/behavior/defer.zig +++ b/test/behavior/defer.zig @@ -5,6 +5,8 @@ const expectEqual = std.testing.expectEqual; const expectError = std.testing.expectError; test "break and continue inside loop inside defer expression" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + testBreakContInDefer(10); comptime testBreakContInDefer(10); } @@ -21,6 +23,8 @@ fn testBreakContInDefer(x: usize) void { } test "defer and labeled break" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var i = @as(usize, 0); blk: { @@ -34,6 +38,7 @@ test "defer and labeled break" { test "errdefer does not apply to fn inside fn" { 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 (testNestedFnErrDefer()) |_| @panic("expected error") else |e| try expect(e == error.Bad); } @@ -53,6 +58,7 @@ test "return variable while defer expression in scope to modify it" { 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; const S = struct { fn doTheTest() !void { @@ -94,6 +100,7 @@ test "mixing normal and error defers" { 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; try expect(runSomeErrorDefers(true) catch unreachable); try expect(result[0] == 'c'); @@ -113,6 +120,7 @@ test "errdefer with payload" { 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() !i32 { @@ -132,6 +140,7 @@ test "errdefer with payload" { test "simple else prong doesn't emit an error for unreachable else prong" { 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; const S = struct { fn foo() error{Foo}!void { diff --git a/test/behavior/duplicated_test_names.zig b/test/behavior/duplicated_test_names.zig index d59945ce30..81b9ebdf50 100644 --- a/test/behavior/duplicated_test_names.zig +++ b/test/behavior/duplicated_test_names.zig @@ -1,3 +1,5 @@ +const builtin = @import("builtin"); + const Namespace = struct { test "thingy" {} }; @@ -13,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/empty_tuple_fields.zig b/test/behavior/empty_tuple_fields.zig index 9f1d4dee1a..a7a3d27e02 100644 --- a/test/behavior/empty_tuple_fields.zig +++ b/test/behavior/empty_tuple_fields.zig @@ -4,6 +4,7 @@ const builtin = @import("builtin"); test "empty file level struct" { 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 T = @import("empty_file_level_struct.zig"); const info = @typeInfo(T); @@ -15,6 +16,7 @@ test "empty file level struct" { test "empty file level union" { 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 T = @import("empty_file_level_union.zig"); const info = @typeInfo(T); diff --git a/test/behavior/empty_union.zig b/test/behavior/empty_union.zig index c91fa16d0c..54ad52df63 100644 --- a/test/behavior/empty_union.zig +++ b/test/behavior/empty_union.zig @@ -12,6 +12,7 @@ test "switch on empty enum" { test "switch on empty enum with a specified tag type" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const E = enum(u8) {}; var e: E = undefined; @@ -21,6 +22,7 @@ test "switch on empty enum with a specified tag type" { test "switch on empty auto numbered tagged union" { 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_spirv64) return error.SkipZigTest; const U = union(enum(u8)) {}; var u: U = undefined; @@ -50,6 +52,8 @@ test "empty extern union" { } test "empty union passed as argument" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const U = union(enum) { fn f(u: @This()) void { switch (u) {} @@ -59,6 +63,8 @@ test "empty union passed as argument" { } test "empty enum passed as argument" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const E = enum { fn f(e: @This()) void { switch (e) {} diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index 5f0037f6dc..a9322ec1b2 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -27,6 +27,7 @@ const IntToEnumNumber = enum { Zero, One, Two, Three, Four }; test "int to enum" { 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; try testIntToEnumEval(3); } @@ -575,6 +576,8 @@ test "enum literal equality" { } test "enum literal cast to enum" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const Color = enum { Auto, Off, On }; var color1: Color = .Auto; @@ -617,6 +620,7 @@ test "enum with specified tag values" { test "non-exhaustive enum" { 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; const S = struct { const E = enum(u8) { a, b, _ }; @@ -659,6 +663,8 @@ test "non-exhaustive enum" { } test "empty non-exhaustive enum" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { const E = enum(u8) { _ }; @@ -680,6 +686,7 @@ test "empty non-exhaustive enum" { test "single field non-exhaustive enum" { 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; const S = struct { const E = enum(u8) { a, _ }; @@ -852,6 +859,8 @@ fn doALoopThing(id: EnumWithOneMember) void { } test "comparison operator on enum with one member is comptime-known" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + doALoopThing(EnumWithOneMember.Eof); } @@ -865,6 +874,8 @@ test "switch on enum with one member is comptime-known" { } test "method call on an enum" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { const E = enum { one, @@ -904,6 +915,7 @@ test "enum literal casting to tagged union" { 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; const Arch = union(enum) { x86_64, @@ -929,6 +941,7 @@ const Bar = enum { A, B, C, D }; test "enum literal casting to error union with payload enum" { 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; var bar: error{B}!Bar = undefined; bar = .B; // should never cast to the error set @@ -940,6 +953,7 @@ test "constant enum initialization with differing sizes" { 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; try test3_1(test3_foo); try test3_2(test3_bar); @@ -982,6 +996,7 @@ test "@tagName" { 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; try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); comptime try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); @@ -997,6 +1012,7 @@ test "@tagName non-exhaustive enum" { 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; try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); comptime try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); @@ -1007,6 +1023,7 @@ test "@tagName is null-terminated" { 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; const S = struct { fn doTheTest(n: BareNumber) !void { @@ -1021,6 +1038,7 @@ test "tag name with assigned enum values" { 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; const LocalFoo = enum(u8) { A = 1, @@ -1033,6 +1051,7 @@ test "tag name with assigned enum values" { test "@tagName on enum literals" { 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; try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); @@ -1042,6 +1061,7 @@ test "enum literal casting to optional" { 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; var bar: ?Bar = undefined; bar = .B; @@ -1070,6 +1090,7 @@ test "bit field access with enum fields" { 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; var data = bit_field_1; try expect(getA(&data) == A.Two); @@ -1110,6 +1131,7 @@ test "tag name functions are unique" { 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; { const E = enum { a, b }; @@ -1128,6 +1150,7 @@ test "tag name functions are unique" { test "size of enum with only one tag which has explicit integer tag type" { 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; const E = enum(u8) { nope = 10 }; const S0 = struct { e: E }; diff --git a/test/behavior/error.zig b/test/behavior/error.zig index 91b5561d62..54d53eec4a 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -16,12 +16,14 @@ fn expectError(expected_err: anyerror, observed_err_union: anytype) !void { } test "error values" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a = @errorToInt(error.err1); const b = @errorToInt(error.err2); try expect(a != b); } test "redefinition of error values allowed" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; shouldBeNotEqual(error.AnError, error.SecondError); } fn shouldBeNotEqual(a: anyerror, b: anyerror) void { @@ -30,6 +32,7 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void { test "error binary operator" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a = errBinaryOperatorG(true) catch 3; const b = errBinaryOperatorG(false) catch 3; @@ -61,12 +64,14 @@ pub fn baz() anyerror!i32 { test "error wrapping" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect((baz() catch unreachable) == 15); } test "unwrap simple value from error" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const i = unwrapSimpleValueFromErrorDo() catch unreachable; try expect(i == 13); @@ -77,6 +82,7 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize { test "error return in assignment" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; doErrReturnInAssignment() catch unreachable; } @@ -99,6 +105,7 @@ test "syntax: optional operator in front of error union operator" { test "widen cast integer payload of error union function call" { 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; const S = struct { fn errorable() !u64 { @@ -124,6 +131,7 @@ test "debug info for optional error set" { test "implicit cast to optional to error union to return result loc" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -144,11 +152,13 @@ test "implicit cast to optional to error union to return result loc" { } test "fn returning empty error set can be passed as fn returning any error" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; entry(); comptime entry(); } test "fn returning empty error set can be passed as fn returning any error - pointer" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; entryPtr(); comptime entryPtr(); } @@ -216,6 +226,7 @@ fn testErrorSetType() !void { test "explicit error set cast" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testExplicitErrorSetCast(Set1.A); comptime try testExplicitErrorSetCast(Set1.A); @@ -234,6 +245,7 @@ fn testExplicitErrorSetCast(set1: Set1) !void { test "comptime test error for empty error set" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testComptimeTestErrorEmptySet(1234); comptime try testComptimeTestErrorEmptySet(1234); @@ -269,6 +281,7 @@ test "inferred empty error set comptime catch" { } test "error inference with an empty set" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { const Struct = struct { pub fn func() (error{})!usize { @@ -291,6 +304,7 @@ test "error inference with an empty set" { test "error union peer type resolution" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testErrorUnionPeerTypeResolution(1); } @@ -322,6 +336,7 @@ fn quux_1() !i32 { test "error: Zero sized error set returned with value payload crash" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; _ = try foo3(0); _ = comptime try foo3(0); @@ -334,6 +349,7 @@ fn foo3(b: usize) Error!usize { test "error: Infer error set from literals" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; _ = nullLiteral("n") catch |err| handleErrors(err); _ = floatLiteral("n") catch |err| handleErrors(err); @@ -373,6 +389,7 @@ test "nested error union function call in optional unwrap" { 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 Foo = struct { @@ -419,6 +436,7 @@ test "nested error union function call in optional unwrap" { test "return function call to error set from error union function" { 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 { fn errorable() anyerror!i32 { @@ -437,6 +455,7 @@ test "optional error set is the same size as error set" { 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; comptime try expect(@sizeOf(?anyerror) == @sizeOf(anyerror)); comptime try expect(@alignOf(?anyerror) == @alignOf(anyerror)); @@ -452,6 +471,7 @@ test "optional error set is the same size as error set" { test "nested catch" { 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 { fn entry() !void { @@ -476,6 +496,7 @@ test "nested catch" { test "function pointer with return type that is error union with payload which is pointer of parent struct" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { const Foo = struct { @@ -501,6 +522,7 @@ test "return result loc as peer result loc in inferred error set 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 doTheTest() !void { @@ -532,6 +554,7 @@ test "error payload type is correctly resolved" { 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 MyIntWrapper = struct { const Self = @This(); @@ -561,6 +584,7 @@ test "@errorName" { 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; try expect(mem.eql(u8, @errorName(error.AnError), "AnError")); try expect(mem.eql(u8, @errorName(error.ALongerErrorName), "ALongerErrorName")); @@ -574,6 +598,7 @@ test "@errorName sentinel length matches slice length" { 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; const name = testBuiltinErrorName(error.FooBar); const length: usize = 6; @@ -647,6 +672,7 @@ test "peer type resolution of two different error unions" { } test "coerce error set to the current inferred error set" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn foo() !void { var a = false; @@ -665,6 +691,7 @@ test "error union payload is properly aligned" { 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 { a: u128, @@ -697,6 +724,7 @@ test "ret_ptr doesn't cause own inferred error set to be resolved" { test "simple else prong allowed even when all errors handled" { 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; const S = struct { fn foo() !u8 { @@ -725,6 +753,7 @@ test "pointer to error union payload" { 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; var err_union: anyerror!u8 = 15; @@ -758,6 +787,7 @@ test "error union of noreturn used with if" { 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; NoReturn.a = 64; if (NoReturn.loop()) { @@ -772,6 +802,7 @@ test "error union of noreturn used with try" { 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; NoReturn.a = 64; const err = NoReturn.testTry(); @@ -783,6 +814,7 @@ test "error union of noreturn used with catch" { 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; NoReturn.a = 64; const err = NoReturn.testCatch(); @@ -793,6 +825,7 @@ test "alignment of wrapping an error union payload" { 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; const S = struct { const I = extern struct { x: i128 }; @@ -807,6 +840,7 @@ test "alignment of wrapping an error union payload" { test "compare error union and error set" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: anyerror = error.Foo; var b: anyerror!u32 = error.Bar; @@ -835,6 +869,8 @@ fn non_errorable() void { } test "catch within a function that calls no errorable functions" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + non_errorable(); } @@ -842,6 +878,7 @@ test "error from comptime string" { 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 name = "Weird error name!"; const S = struct { @@ -865,6 +902,7 @@ test "field access of anyerror results in smaller error set" { test "optional error union return type" { 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 S = struct { fn foo() ?anyerror!u32 { @@ -878,6 +916,7 @@ test "optional error union return type" { test "optional error set return type" { 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 E = error{ A, B }; const S = struct { diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig index b12fcc7afa..f4c75149a8 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_spirv64) return error.SkipZigTest; + try expect(some_data.len == 21); } var some_data: [@intCast(usize, fibonacci(7))]u8 = undefined; @@ -21,6 +23,7 @@ test "static add one" { 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; try expect(should_be_1235 == 1235); } @@ -45,6 +48,8 @@ test "inline variable gets result of const if" { } test "static function evaluation" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(statically_added_number == 3); } const statically_added_number = staticAdd(1, 2); @@ -72,6 +77,7 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 { test "constant expressions" { 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; var array: [array_size]u8 = undefined; try expect(@sizeOf(@TypeOf(array)) == 20); @@ -140,6 +146,7 @@ test "pointer to type" { test "a type constructed in a global expression" { 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; var l: List = undefined; l.array[0] = 10; @@ -198,6 +205,8 @@ test "@setEvalBranchQuota" { } test "constant struct with negation" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(vertices[0].x == @as(f32, -0.6)); } const Vertex = struct { @@ -302,6 +311,8 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 { } test "comptime iterate over fn ptr list" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(performFn('t', 1) == 6); try expect(performFn('o', 0) == 1); try expect(performFn('w', 99) == 99); @@ -340,6 +351,7 @@ fn doesAlotT(comptime T: type, value: usize) T { test "@setEvalBranchQuota at same scope as generic function call" { 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; try expect(doesAlotT(u32, 2) == 2); } @@ -376,6 +388,8 @@ test "zero extend from u0 to u1" { } test "return 0 from function that has u0 return type" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn foo_zero() u0 { return 0; @@ -391,6 +405,7 @@ test "return 0 from function that has u0 return type" { test "statically initialized struct" { 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; st_init_str_foo.x += 1; try expect(st_init_str_foo.x == 14); @@ -405,6 +420,8 @@ var st_init_str_foo = StInitStrFoo{ }; test "inline for with same type but different values" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var res: usize = 0; inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| { var a: T = undefined; @@ -440,6 +457,7 @@ test "binary math operator in partially inlined function" { 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; var s: [4]u32 = undefined; var b: [16]u8 = undefined; @@ -459,6 +477,7 @@ test "comptime shl" { 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; var a: u128 = 3; var b: u7 = 63; @@ -486,6 +505,7 @@ test "comptime bitwise operators" { test "comptime shlWithOverflow" { 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_spirv64) return error.SkipZigTest; const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0]; var a = ~@as(u64, 0); @@ -497,6 +517,7 @@ test "comptime shlWithOverflow" { test "const ptr to variable data changes at runtime" { 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; try expect(foo_ref.name[0] == 'a'); foo_ref.name = "b"; @@ -516,6 +537,7 @@ test "runtime 128 bit integer division" { 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; var a: u128 = 152313999999999991610955792383; var b: u128 = 10000000000000000000; @@ -526,6 +548,7 @@ test "runtime 128 bit integer division" { test "@tagName of @typeInfo" { 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 str = @tagName(@typeInfo(u8)); try expect(std.mem.eql(u8, str, "Int")); @@ -535,6 +558,7 @@ test "static eval list init" { 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; try expect(static_vec3.data[2] == 1.0); try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0); @@ -566,6 +590,7 @@ test "inlined loop has array literal with elided runtime scope on first iteratio test "ptr to local array argument at comptime" { 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; comptime { var bytes: [10]u8 = undefined; @@ -602,6 +627,7 @@ const hi1 = "hi"; const hi2 = hi1; test "const global shares pointer with other same one" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try assertEqualPtrs(&hi1[0], &hi2[0]); comptime try expect(&hi1[0] == &hi2[0]); @@ -637,6 +663,8 @@ pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type { } test "comptime function with mutable pointer is not memoized" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + comptime { var x: i32 = 1; const ptr = &x; @@ -728,6 +756,7 @@ test "array concatenation of function calls" { 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; var a = oneItem(3) ++ oneItem(4); try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 })); @@ -737,6 +766,7 @@ test "array multiplication of function calls" { 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; var a = oneItem(3) ** scalar(2); try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 })); @@ -754,6 +784,7 @@ test "array concatenation peer resolves element types - value" { 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; var a = [2]u3{ 1, 7 }; var b = [3]u8{ 200, 225, 255 }; @@ -770,6 +801,7 @@ test "array concatenation peer resolves element types - pointer" { 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; var a = [2]u3{ 1, 7 }; var b = [3]u8{ 200, 225, 255 }; @@ -788,6 +820,7 @@ test "array concatenation sets the sentinel - value" { 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; var a = [2]u3{ 1, 7 }; var b = [3:69]u8{ 200, 225, 255 }; @@ -805,6 +838,7 @@ test "array concatenation sets the sentinel - value" { test "array concatenation sets the sentinel - pointer" { 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; var a = [2]u3{ 1, 7 }; var b = [3:69]u8{ 200, 225, 255 }; @@ -825,6 +859,7 @@ test "array multiplication sets the sentinel - value" { 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; var a = [2:7]u3{ 1, 6 }; var b = a ** 2; @@ -841,6 +876,7 @@ test "array multiplication sets the sentinel - pointer" { 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; var a = [2:7]u3{ 1, 6 }; var b = &a ** 2; @@ -965,6 +1001,7 @@ test "closure capture type of runtime-known parameter" { test "comptime break passing through runtime condition converted to runtime break" { 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 { @@ -998,6 +1035,7 @@ test "comptime break to outer loop passing through runtime condition converted t 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 { @@ -1069,6 +1107,7 @@ test "comptime break operand passing through runtime switch converted to runtime test "no dependency loop for alignment of self struct" { 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 { fn doTheTest() !void { @@ -1106,6 +1145,7 @@ test "no dependency loop for alignment of self struct" { test "no dependency loop for alignment of self bare union" { 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 { fn doTheTest() !void { @@ -1143,6 +1183,7 @@ test "no dependency loop for alignment of self bare union" { test "no dependency loop for alignment of self tagged union" { 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 { fn doTheTest() !void { @@ -1186,6 +1227,7 @@ test "storing an array of type in a field" { 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 { @@ -1214,6 +1256,7 @@ test "storing an array of type in a field" { test "pass pointer to field of comptime-only type as a runtime parameter" { 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 Mixed = struct { @@ -1331,6 +1374,7 @@ test "lazy value is resolved as slice operand" { 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 A = struct { a: u32 }; var a: [512]u64 = undefined; @@ -1388,6 +1432,7 @@ test "inline for inside a runtime condition" { test "continue in inline for inside a comptime switch" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const arr = .{ 1, 2, 3 }; var count: u8 = 0; @@ -1453,6 +1498,7 @@ test "continue nested inline for loop in named block expr" { test "x and false is comptime-known false" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const T = struct { var x: u32 = 0; @@ -1480,6 +1526,7 @@ test "x and false is comptime-known false" { test "x or true is comptime-known true" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const T = struct { var x: u32 = 0; @@ -1510,6 +1557,7 @@ test "non-optional and optional array elements concatenated" { 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; const array = [1]u8{'A'} ++ [1]?u8{null}; var index: usize = 0; @@ -1540,6 +1588,8 @@ test "comptime function turns function value to function pointer" { } test "container level const and var have unique addresses" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { x: i32, y: i32, @@ -1596,6 +1646,8 @@ test "result of nested switch assigned to variable" { } test "inline for loop of functions returning error unions" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const T1 = struct { fn v() error{}!usize { return 1; @@ -1649,6 +1701,8 @@ test "early exit in container level const" { } test "@inComptime" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn inComptime() bool { return @inComptime(); diff --git a/test/behavior/field_parent_ptr.zig b/test/behavior/field_parent_ptr.zig index c56bcad0d2..1310b96678 100644 --- a/test/behavior/field_parent_ptr.zig +++ b/test/behavior/field_parent_ptr.zig @@ -4,6 +4,8 @@ const builtin = @import("builtin"); test "@fieldParentPtr non-first field" { 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 testParentFieldPtr(&foo.c); comptime try testParentFieldPtr(&foo.c); } @@ -12,6 +14,8 @@ test "@fieldParentPtr first field" { if (builtin.zig_backend == .stage2_x86_64) 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 testParentFieldPtrFirst(&foo.a); comptime try testParentFieldPtrFirst(&foo.a); } @@ -51,6 +55,7 @@ test "@fieldParentPtr untagged union" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFieldParentPtrUnion(&bar.c); comptime try testFieldParentPtrUnion(&bar.c); @@ -78,6 +83,7 @@ test "@fieldParentPtr tagged union" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFieldParentPtrTaggedUnion(&bar_tagged.c); comptime try testFieldParentPtrTaggedUnion(&bar_tagged.c); @@ -105,6 +111,7 @@ test "@fieldParentPtr extern union" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFieldParentPtrExternUnion(&bar_extern.c); comptime try testFieldParentPtrExternUnion(&bar_extern.c); diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig index 242c8dabe5..d2035c656f 100644 --- a/test/behavior/floatop.zig +++ b/test/behavior/floatop.zig @@ -58,6 +58,7 @@ test "different sized float comparisons" { 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; try testDifferentSizedFloatComparisons(); comptime try testDifferentSizedFloatComparisons(); @@ -101,6 +102,7 @@ test "@sqrt" { 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; comptime try testSqrt(); try testSqrt(); @@ -138,6 +140,7 @@ test "@sqrt with vectors" { 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_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime try testSqrtWithVectors(); try testSqrtWithVectors(); @@ -157,6 +160,7 @@ test "more @sqrt f16 tests" { 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; // TODO these are not all passing at comptime try expect(@sqrt(@as(f16, 0.0)) == 0.0); @@ -181,6 +185,7 @@ test "another, possibly redundant @sqrt test" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testSqrtLegacy(f64, 12.0); comptime try testSqrtLegacy(f64, 12.0); @@ -207,6 +212,7 @@ test "@sin" { 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; comptime try testSin(); try testSin(); @@ -227,6 +233,7 @@ test "@sin with vectors" { if (builtin.zig_backend == .stage2_x86_64) 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; comptime try testSinWithVectors(); try testSinWithVectors(); @@ -246,6 +253,7 @@ test "@cos" { 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; comptime try testCos(); try testCos(); @@ -266,6 +274,7 @@ test "@cos with vectors" { if (builtin.zig_backend == .stage2_x86_64) 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; comptime try testCosWithVectors(); try testCosWithVectors(); @@ -285,6 +294,7 @@ test "@exp" { 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; comptime try testExp(); try testExp(); @@ -304,6 +314,7 @@ test "@exp with vectors" { if (builtin.zig_backend == .stage2_x86_64) 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; comptime try testExpWithVectors(); try testExpWithVectors(); @@ -323,6 +334,7 @@ test "@exp2" { 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; comptime try testExp2(); try testExp2(); @@ -342,6 +354,7 @@ test "@exp2 with @vectors" { if (builtin.zig_backend == .stage2_x86_64) 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; comptime try testExp2WithVectors(); try testExp2WithVectors(); @@ -361,6 +374,7 @@ test "@log" { 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; comptime try testLog(); try testLog(); @@ -392,6 +406,7 @@ test "@log with @vectors" { 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; { var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; @@ -408,6 +423,7 @@ test "@log2" { 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; comptime try testLog2(); try testLog2(); @@ -427,6 +443,7 @@ test "@log2 with vectors" { if (builtin.zig_backend == .stage2_x86_64) 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; // https://github.com/ziglang/zig/issues/13681 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64 and @@ -450,6 +467,7 @@ test "@log10" { 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; comptime try testLog10(); try testLog10(); @@ -469,6 +487,7 @@ test "@log10 with vectors" { if (builtin.zig_backend == .stage2_x86_64) 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; comptime try testLog10WithVectors(); try testLog10WithVectors(); @@ -487,6 +506,7 @@ test "@fabs" { 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; comptime try testFabs(); try testFabs(); @@ -515,6 +535,7 @@ test "@fabs with vectors" { if (builtin.zig_backend == .stage2_x86_64) 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; comptime try testFabsWithVectors(); try testFabsWithVectors(); @@ -534,6 +555,7 @@ test "another, possibly redundant, @fabs test" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFabsLegacy(f128, 12.0); comptime try testFabsLegacy(f128, 12.0); @@ -555,6 +577,7 @@ test "@fabs f80" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFabsLegacy(f80, 12.0); comptime try testFabsLegacy(f80, 12.0); @@ -571,6 +594,7 @@ test "a third @fabs test, surely there should not be three fabs tests" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| { // normals @@ -598,6 +622,7 @@ test "@floor" { 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; comptime try testFloor(); try testFloor(); @@ -622,6 +647,7 @@ test "@floor with vectors" { !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) 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; comptime try testFloorWithVectors(); try testFloorWithVectors(); @@ -640,6 +666,7 @@ test "another, possibly redundant, @floor test" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFloorLegacy(f64, 12.0); comptime try testFloorLegacy(f64, 12.0); @@ -659,6 +686,7 @@ test "@floor f80" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12602 @@ -674,6 +702,7 @@ test "@floor f128" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFloorLegacy(f128, 12.0); comptime try testFloorLegacy(f128, 12.0); @@ -689,6 +718,7 @@ test "@ceil" { 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; comptime try testCeil(); try testCeil(); @@ -713,6 +743,7 @@ test "@ceil with vectors" { !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) 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; comptime try testCeilWithVectors(); try testCeilWithVectors(); @@ -731,6 +762,7 @@ test "another, possibly redundant, @ceil test" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCeilLegacy(f64, 12.0); comptime try testCeilLegacy(f64, 12.0); @@ -750,6 +782,7 @@ test "@ceil f80" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12602 @@ -765,6 +798,7 @@ test "@ceil f128" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCeilLegacy(f128, 12.0); comptime try testCeilLegacy(f128, 12.0); @@ -804,6 +838,7 @@ test "@trunc with vectors" { !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) 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; comptime try testTruncWithVectors(); try testTruncWithVectors(); @@ -822,6 +857,7 @@ test "another, possibly redundant, @trunc test" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testTruncLegacy(f64, 12.0); comptime try testTruncLegacy(f64, 12.0); @@ -841,6 +877,7 @@ test "@trunc f80" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12602 @@ -862,6 +899,7 @@ test "@trunc f128" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testTruncLegacy(f128, 12.0); comptime try testTruncLegacy(f128, 12.0); @@ -886,6 +924,7 @@ test "negation f16" { 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.os.tag == .freebsd) { // TODO file issue to track this failure @@ -910,6 +949,7 @@ test "negation f32" { 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 { fn doTheTest() !void { @@ -929,6 +969,7 @@ test "negation f64" { 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 { fn doTheTest() !void { @@ -950,6 +991,7 @@ test "negation f80" { if (builtin.zig_backend == .stage2_aarch64) 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; const S = struct { fn doTheTest() !void { @@ -971,6 +1013,7 @@ test "negation f128" { if (builtin.zig_backend == .stage2_aarch64) 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; const S = struct { fn doTheTest() !void { @@ -989,6 +1032,7 @@ test "negation f128" { test "eval @setFloatMode at compile-time" { 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 result = comptime fnWithFloatMode(); try expect(result == 1234.0); @@ -1014,6 +1058,7 @@ test "comptime fixed-width float zero divided by zero produces NaN" { 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; inline for (.{ f16, f32, f64, f80, f128 }) |F| { try expect(math.isNan(@as(F, 0) / @as(F, 0))); @@ -1025,6 +1070,7 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" { 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; inline for (.{ f16, f32, f64, f80, f128 }) |F| { const pos = @as(F, 1) / @as(F, 0); @@ -1044,6 +1090,7 @@ test "nan negation f16" { 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 nan_comptime = comptime math.nan(f16); const neg_nan_comptime = -nan_comptime; @@ -1062,6 +1109,7 @@ test "nan negation f32" { 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 nan_comptime = comptime math.nan(f32); const neg_nan_comptime = -nan_comptime; @@ -1081,6 +1129,7 @@ test "nan negation f64" { 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 nan_comptime = comptime math.nan(f64); const neg_nan_comptime = -nan_comptime; @@ -1101,6 +1150,7 @@ test "nan negation f128" { 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 nan_comptime = comptime math.nan(f128); const neg_nan_comptime = -nan_comptime; @@ -1121,6 +1171,7 @@ test "nan negation f80" { 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 nan_comptime = comptime math.nan(f80); const neg_nan_comptime = -nan_comptime; diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig index 4ff5e20378..53f964c70a 100644 --- a/test/behavior/fn.zig +++ b/test/behavior/fn.zig @@ -5,6 +5,8 @@ const expect = testing.expect; const expectEqual = testing.expectEqual; test "params" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(testParamsAdd(22, 11) == 33); } fn testParamsAdd(a: i32, b: i32) i32 { @@ -12,6 +14,8 @@ fn testParamsAdd(a: i32, b: i32) i32 { } test "local variables" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + testLocVars(2); } fn testLocVars(b: i32) void { @@ -20,6 +24,8 @@ fn testLocVars(b: i32) void { } test "mutable local variables" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var zero: i32 = 0; try expect(zero == 0); @@ -51,6 +57,8 @@ test "weird function name" { } test "assign inline fn to const variable" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const a = inlineFn; a(); } @@ -68,6 +76,8 @@ fn outer(y: u32) *const fn (u32) u32 { } test "return inner function which references comptime variable of outer function" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var func = outer(10); try expect(func(3) == 7); } @@ -99,6 +109,7 @@ test "inline function call that calls optional function pointer, return pointer 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; const S = struct { field: u32, @@ -144,6 +155,7 @@ fn fnWithUnreachable() noreturn { test "extern struct with stdcallcc fn pointer" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = extern struct { ptr: *const fn () callconv(if (builtin.target.cpu.arch == .x86) .Stdcall else .C) i32, @@ -174,12 +186,14 @@ test "function with complex callconv and return type expressions" { 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; try expect(fComplexCallconvRet(3).x == 9); } test "pass by non-copying value" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3); } @@ -195,6 +209,7 @@ fn addPointCoords(pt: Point) i32 { test "pass by non-copying value through var arg" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3); } @@ -206,6 +221,7 @@ fn addPointCoordsVar(pt: anytype) !i32 { test "pass by non-copying value as method" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var pt = Point2{ .x = 1, .y = 2 }; try expect(pt.addPointCoords() == 3); @@ -222,6 +238,7 @@ const Point2 = struct { test "pass by non-copying value as method, which is generic" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var pt = Point3{ .x = 1, .y = 2 }; try expect(pt.addPointCoords(i32) == 3); @@ -239,6 +256,7 @@ const Point3 = struct { test "pass by non-copying value as method, at comptime" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime { var pt = Point2{ .x = 1, .y = 2 }; @@ -250,6 +268,7 @@ test "implicit cast fn call result to optional in field result" { 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; const S = struct { fn entry() !void { @@ -276,6 +295,7 @@ test "implicit cast fn call result to optional in field result" { test "void parameters" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try voidFun(1, void{}, 2, {}); } @@ -301,6 +321,7 @@ test "function pointers" { 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 fns = [_]*const @TypeOf(fn1){ &fn1, @@ -338,6 +359,7 @@ test "function call with anon list literal" { 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 { fn doTheTest() !void { @@ -358,6 +380,7 @@ test "function call with anon list literal - 2D" { 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 { fn doTheTest() !void { @@ -376,6 +399,8 @@ test "function call with anon list literal - 2D" { } test "ability to give comptime types and non comptime types to same parameter" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn doTheTest() !void { var x: i32 = 1; @@ -393,6 +418,8 @@ test "ability to give comptime types and non comptime types to same parameter" { } test "function with inferred error set but returning no error" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn foo() !void {} }; @@ -403,6 +430,7 @@ test "function with inferred error set but returning no error" { test "import passed byref to function in return type" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn get() @import("std").ArrayListUnmanaged(i32) { @@ -419,6 +447,7 @@ test "implicit cast function to function ptr" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S1 = struct { export fn someFunctionThatReturnsAValue() c_int { @@ -437,6 +466,7 @@ test "implicit cast function to function ptr" { test "method call with optional and error union first param" { 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 { x: i32 = 1234, @@ -456,6 +486,7 @@ test "method call with optional and error union first param" { test "method call with optional pointer first param" { 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 { x: i32 = 1234, @@ -475,6 +506,7 @@ test "using @ptrCast on function pointers" { 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 A = struct { data: [4]u8 }; @@ -512,6 +544,7 @@ test "function returns function returning type" { test "peer type resolution of inferred error set with non-void payload" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn openDataFile(mode: enum { read, write }) !u32 { diff --git a/test/behavior/fn_delegation.zig b/test/behavior/fn_delegation.zig index 95dbfeb4b2..d7a2ba2125 100644 --- a/test/behavior/fn_delegation.zig +++ b/test/behavior/fn_delegation.zig @@ -34,6 +34,7 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 { test "fn delegation" { 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 foo = Foo{}; try expect(foo.one() == 11); diff --git a/test/behavior/fn_in_struct_in_comptime.zig b/test/behavior/fn_in_struct_in_comptime.zig index ee8e98ad1c..427b08e6a4 100644 --- a/test/behavior/fn_in_struct_in_comptime.zig +++ b/test/behavior/fn_in_struct_in_comptime.zig @@ -1,3 +1,4 @@ +const builtin = @import("builtin"); const expect = @import("std").testing.expect; fn get_foo() fn (*u8) usize { @@ -12,6 +13,8 @@ fn get_foo() fn (*u8) usize { } test "define a function in an anonymous struct in comptime" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const foo = get_foo(); try expect(foo(@intToPtr(*u8, 12345)) == 12345); } diff --git a/test/behavior/for.zig b/test/behavior/for.zig index b3d82fd255..8c9eeb083e 100644 --- a/test/behavior/for.zig +++ b/test/behavior/for.zig @@ -7,6 +7,7 @@ const mem = std.mem; test "continue in for loop" { 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; const array = [_]i32{ 1, 2, 3, 4, 5 }; var sum: i32 = 0; @@ -21,6 +22,8 @@ test "continue in for loop" { } test "break from outer for loop" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try testBreakOuter(); comptime try testBreakOuter(); } @@ -38,6 +41,8 @@ fn testBreakOuter() !void { } test "continue outer for loop" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try testContinueOuter(); comptime try testContinueOuter(); } @@ -69,6 +74,7 @@ test "basic for loop" { 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; const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3; @@ -112,6 +118,7 @@ test "for with null and T peer types and inferred result location type" { 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; const S = struct { fn doTheTest(slice: []const u8) !void { @@ -132,6 +139,7 @@ test "for with null and T peer types and inferred result location type" { test "2 break statements and an else" { 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; const S = struct { fn entry(t: bool, f: bool) !void { @@ -153,6 +161,7 @@ test "for loop with pointer elem var" { 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 source = "abcdefg"; var target: [source.len]u8 = undefined; @@ -179,6 +188,7 @@ fn mangleString(s: []u8) void { test "for copies its payload" { 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 { fn doTheTest() !void { @@ -198,6 +208,7 @@ test "for on slice with allowzero ptr" { 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(slice: []const u8) !void { @@ -213,6 +224,7 @@ test "for on slice with allowzero ptr" { test "else continue outer for" { 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; var i: usize = 6; var buf: [5]u8 = undefined; @@ -226,6 +238,7 @@ test "else continue outer for" { test "for loop with else branch" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; { var x = [_]u32{ 1, 2 }; @@ -248,6 +261,7 @@ test "for loop with else branch" { test "count over fixed range" { 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_spirv64) return error.SkipZigTest; var sum: usize = 0; for (0..6) |i| { @@ -260,6 +274,7 @@ test "count over fixed range" { test "two counters" { 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_spirv64) return error.SkipZigTest; var sum: usize = 0; for (0..10, 10..20) |i, j| { @@ -273,6 +288,7 @@ test "two counters" { test "1-based counter and ptr to array" { 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_spirv64) return error.SkipZigTest; var ok: usize = 0; @@ -306,6 +322,7 @@ test "slice and two counters, one is offset and one is runtime" { 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 slice: []const u8 = "blah"; var start: usize = 0; @@ -334,6 +351,7 @@ test "two slices, one captured by-ref" { 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; var buf: [10]u8 = undefined; const slice1: []const u8 = "blah"; @@ -353,6 +371,7 @@ test "raw pointer and slice" { 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; var buf: [10]u8 = undefined; const slice: []const u8 = "blah"; @@ -372,6 +391,7 @@ test "raw pointer and counter" { 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; var buf: [10]u8 = undefined; const ptr: [*]u8 = &buf; @@ -390,6 +410,7 @@ test "inline for with slice as the comptime-known" { 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 comptime_slice = "hello"; var runtime_i: usize = 3; @@ -420,6 +441,7 @@ test "inline for with counter as the comptime-known" { 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; var runtime_slice = "hello"; var runtime_i: usize = 3; diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig index e7c053e36c..e8d064154b 100644 --- a/test/behavior/generics.zig +++ b/test/behavior/generics.zig @@ -5,6 +5,8 @@ const expect = testing.expect; const expectEqual = testing.expectEqual; test "one param, explicit comptime" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var x: usize = 0; x += checkSize(i32); x += checkSize(bool); @@ -19,6 +21,7 @@ fn checkSize(comptime T: type) usize { test "simple generic fn" { 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; try expect(max(i32, 3, -1) == 3); try expect(max(u8, 1, 100) == 100); @@ -59,6 +62,7 @@ test "fn with comptime args" { 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; try expect(gimmeTheBigOne(1234, 5678) == 5678); try expect(shouldCallSameInstance(34, 12) == 34); @@ -69,6 +73,7 @@ test "anytype params" { 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; try expect(max_i32(12, 34) == 34); try expect(max_f64(1.2, 3.4) == 3.4); @@ -93,6 +98,7 @@ fn max_f64(a: f64, b: f64) f64 { test "type constructed by comptime function call" { 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; var l: SimpleList(10) = undefined; l.array[0] = 10; @@ -116,6 +122,7 @@ test "function with return type type" { 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; var list: List(i32) = undefined; var list2: List(i32) = undefined; @@ -147,6 +154,8 @@ fn GenericDataThing(comptime count: isize) type { } test "use generic param in generic param" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(aGenericFn(i32, 3, 4) == 7); } fn aGenericFn(comptime T: type, comptime a: T, b: T) T { @@ -157,6 +166,7 @@ test "generic fn with implicit cast" { 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; try expect(getFirstByte(u8, &[_]u8{13}) == 13); try expect(getFirstByte(u16, &[_]u16{ @@ -175,6 +185,7 @@ test "generic fn keeps non-generic parameter types" { 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; const A = 128; @@ -209,6 +220,7 @@ fn foo2(arg: anytype) bool { test "generic struct" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a1 = GenNode(i32){ .value = 13, @@ -249,6 +261,7 @@ test "generic function instantiation turns into comptime call" { 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 { @@ -298,6 +311,7 @@ test "generic function with void and comptime parameter" { test "anonymous struct return type referencing comptime parameter" { 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 { pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } { @@ -316,6 +330,7 @@ test "generic function instantiation non-duplicates" { 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.os.tag == .wasi) return error.SkipZigTest; const S = struct { @@ -351,6 +366,8 @@ test "generic instantiation of tagged union with only one field" { } test "nested generic function" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn foo(comptime T: type, callback: *const fn (user_data: T) anyerror!void, data: T) anyerror!void { try callback(data); @@ -366,6 +383,8 @@ test "nested generic function" { } test "extern function used as generic parameter" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { extern fn usedAsGenericParameterFoo() void; extern fn usedAsGenericParameterBar() void; @@ -393,6 +412,8 @@ test "generic struct as parameter type" { } test "slice as parameter type" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn internComptimeString(comptime str: []const u8) *const []const u8 { return &struct { @@ -407,6 +428,8 @@ test "slice as parameter type" { } test "null sentinel pointer passed as generic argument" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn doTheTest(a: anytype) !void { try std.testing.expect(@ptrToInt(a) == 8); @@ -417,6 +440,7 @@ test "null sentinel pointer passed as generic argument" { test "generic function passed as comptime argument" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doMath(comptime f: fn (type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void { diff --git a/test/behavior/if.zig b/test/behavior/if.zig index 2294a2bcfd..7369435cd3 100644 --- a/test/behavior/if.zig +++ b/test/behavior/if.zig @@ -45,6 +45,7 @@ var global_with_err: anyerror!u32 = error.SomeError; test "unwrap mutable global var" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (global_with_val) |v| { try expect(v == 0); @@ -70,6 +71,8 @@ test "labeled break inside comptime if inside runtime if" { } test "const result loc, runtime if cond, else unreachable" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const Num = enum { One, Two }; var t = true; @@ -115,6 +118,7 @@ test "if peer expressions inferred optional type" { 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; var self: []const u8 = "abcdef"; var index: usize = 0; @@ -132,6 +136,7 @@ test "if-else expression with runtime condition result location is inferred opti 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; const A = struct { b: u64, c: u64 }; var d: bool = true; diff --git a/test/behavior/inline_switch.zig b/test/behavior/inline_switch.zig index 6e5013d83b..426026d826 100644 --- a/test/behavior/inline_switch.zig +++ b/test/behavior/inline_switch.zig @@ -47,6 +47,7 @@ test "inline switch unions" { 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; var x: U = .a; switch (x) { @@ -72,6 +73,7 @@ test "inline switch unions" { test "inline else bool" { 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; var a = true; switch (a) { @@ -83,6 +85,7 @@ test "inline else bool" { test "inline else error" { 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 Err = error{ a, b, c }; var a = Err.a; @@ -138,6 +141,8 @@ test "inline else int all values" { } test "inline switch capture is set when switch operand is comptime known" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const U2 = union(enum) { a: u32, }; diff --git a/test/behavior/int128.zig b/test/behavior/int128.zig index b21a480a16..c4ace7c4c0 100644 --- a/test/behavior/int128.zig +++ b/test/behavior/int128.zig @@ -8,6 +8,7 @@ test "uint128" { 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; var buff: u128 = maxInt(u128); try expect(buff == maxInt(u128)); @@ -26,6 +27,7 @@ test "undefined 128 bit int" { 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; @setRuntimeSafety(true); @@ -43,6 +45,7 @@ test "int128" { 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; var buff: i128 = -1; try expect(buff < 0 and (buff + 1) == 0); @@ -66,6 +69,7 @@ test "truncate int128" { 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; { var buff: u128 = maxInt(u128); @@ -87,6 +91,7 @@ test "shift int128" { 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 types = .{ u128, i128 }; inline for (types) |t| { diff --git a/test/behavior/int_comparison_elision.zig b/test/behavior/int_comparison_elision.zig index ea26f02b7e..ecaa176ebb 100644 --- a/test/behavior/int_comparison_elision.zig +++ b/test/behavior/int_comparison_elision.zig @@ -4,6 +4,8 @@ const maxInt = std.math.maxInt; const builtin = @import("builtin"); test "int comparison elision" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + testIntEdges(u0); testIntEdges(i0); testIntEdges(u1); diff --git a/test/behavior/inttoptr.zig b/test/behavior/inttoptr.zig index 29a263b2ce..a05ed83b9b 100644 --- a/test/behavior/inttoptr.zig +++ b/test/behavior/inttoptr.zig @@ -14,6 +14,7 @@ test "mutate through ptr initialized with constant intToPtr value" { 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; forceCompilerAnalyzeBranchHardCodedPtrDereference(false); } diff --git a/test/behavior/ir_block_deps.zig b/test/behavior/ir_block_deps.zig index a46ad2d8a8..136f23409b 100644 --- a/test/behavior/ir_block_deps.zig +++ b/test/behavior/ir_block_deps.zig @@ -21,6 +21,7 @@ test "ir block deps" { 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_spirv64) return error.SkipZigTest; try expect((foo(1) catch unreachable) == 0); try expect((foo(2) catch unreachable) == 0); diff --git a/test/behavior/lower_strlit_to_vector.zig b/test/behavior/lower_strlit_to_vector.zig index 948d708aa7..41faad14c0 100644 --- a/test/behavior/lower_strlit_to_vector.zig +++ b/test/behavior/lower_strlit_to_vector.zig @@ -6,6 +6,7 @@ test "strlit to vector" { 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_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const strlit = "0123456789abcdef0123456789ABCDEF"; const vec_from_strlit: @Vector(32, u8) = strlit.*; diff --git a/test/behavior/math.zig b/test/behavior/math.zig index 0e1e14a228..991521b62c 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -11,6 +11,7 @@ const math = std.math; test "assignment operators" { 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 i: u32 = 0; i += 5; @@ -64,6 +65,7 @@ test "@clz" { 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; try testClz(); comptime try testClz(); @@ -82,6 +84,7 @@ test "@clz big ints" { 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; try testClzBigInts(); comptime try testClzBigInts(); @@ -102,6 +105,7 @@ test "@clz vectors" { 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; try testClzVectors(); comptime try testClzVectors(); @@ -142,6 +146,7 @@ test "@ctz" { 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; try testCtz(); comptime try testCtz(); @@ -164,6 +169,7 @@ test "@ctz vectors" { 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_llvm and builtin.cpu.arch == .aarch64) { // This regressed with LLVM 14: @@ -204,6 +210,7 @@ test "float equality" { 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 x: f64 = 0.012; const y: f64 = x + 1.0; @@ -381,6 +388,7 @@ test "binary not 128-bit" { 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; try expect(comptime x: { break :x ~@as(u128, 0x55555555_55555555_55555555_55555555) == 0xaaaaaaaa_aaaaaaaa_aaaaaaaa_aaaaaaaa; @@ -404,6 +412,7 @@ test "division" { 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; try testDivision(); comptime try testDivision(); @@ -484,6 +493,7 @@ test "division half-precision floats" { 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; try testDivisionFP16(); comptime try testDivisionFP16(); @@ -564,6 +574,7 @@ 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)); } @@ -604,6 +615,8 @@ test "bit shift a u1" { } test "truncating shift right" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try testShrTrunc(maxInt(u16)); comptime try testShrTrunc(maxInt(u16)); } @@ -618,6 +631,7 @@ test "f128" { 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; try test_f128(); comptime try test_f128(); @@ -647,6 +661,7 @@ test "128-bit multiplication" { 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; { var a: i128 = 3; @@ -672,6 +687,7 @@ 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; { var a: u8 = 250; @@ -717,6 +733,7 @@ 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); @@ -738,6 +755,7 @@ test "small int addition" { test "basic @mulWithOverflow" { 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; { var a: u8 = 86; @@ -768,6 +786,7 @@ test "extensive @mulWithOverflow" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; { var a: u5 = 3; @@ -932,6 +951,7 @@ test "@mulWithOverflow bitsize > 32" { 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; { var a: u62 = 3; @@ -990,6 +1010,7 @@ test "@subWithOverflow" { 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; { var a: u8 = 1; @@ -1037,6 +1058,8 @@ test "@shlWithOverflow" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + { var a: u4 = 2; var b: u2 = 1; @@ -1114,6 +1137,8 @@ test "overflow arithmetic with u0 values" { } test "allow signed integer division/remainder when values are comptime-known and positive or exact" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(5 / 3 == 1); try expect(-5 / -3 == 1); try expect(-6 / 3 == -2); @@ -1132,6 +1157,7 @@ test "quad hex float literal parsing accurate" { 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 a: f128 = 0x1.1111222233334444555566667777p+0; @@ -1232,6 +1258,8 @@ fn testShlTrunc(x: u16) !void { } test "exact shift left" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try testShlExact(0b00110101); comptime try testShlExact(0b00110101); } @@ -1241,6 +1269,8 @@ fn testShlExact(x: u8) !void { } test "exact shift right" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try testShrExact(0b10110100); comptime try testShrExact(0b10110100); } @@ -1280,6 +1310,7 @@ test "remainder division" { 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_x86_64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { @@ -1316,6 +1347,7 @@ test "float remainder division using @rem" { 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_x86_64) return error.SkipZigTest; // TODO comptime try frem(f16); @@ -1359,6 +1391,7 @@ test "float modulo division using @mod" { 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; comptime try fmod(f16); comptime try fmod(f32); @@ -1401,6 +1434,7 @@ test "@round" { 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; try testRound(f64, 12.0); comptime try testRound(f64, 12.0); @@ -1421,6 +1455,7 @@ test "@round f80" { 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; try testRound(f80, 12.0); comptime try testRound(f80, 12.0); @@ -1432,6 +1467,7 @@ test "@round f128" { 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; try testRound(f128, 12.0); comptime try testRound(f128, 12.0); @@ -1449,6 +1485,7 @@ 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 { @@ -1470,6 +1507,7 @@ test "NaN comparison" { 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; try testNanEqNan(f16); try testNanEqNan(f32); @@ -1487,6 +1525,7 @@ test "NaN comparison f80" { 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; try testNanEqNan(f80); comptime try testNanEqNan(f80); @@ -1509,6 +1548,7 @@ test "vector comparison" { 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 { @@ -1538,6 +1578,7 @@ test "signed zeros are represented properly" { 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 { fn doTheTest() !void { @@ -1573,6 +1614,7 @@ test "absFloat" { 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; try testAbsFloat(); comptime try testAbsFloat(); diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig index 1bd3723fca..6496e00afd 100644 --- a/test/behavior/maximum_minimum.zig +++ b/test/behavior/maximum_minimum.zig @@ -8,6 +8,7 @@ test "@max" { 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 { fn doTheTest() !void { @@ -27,6 +28,7 @@ test "@max on vectors" { 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 { fn doTheTest() !void { @@ -54,6 +56,7 @@ test "@min" { 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 { @@ -73,6 +76,7 @@ test "@min for vectors" { 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 { @@ -122,6 +126,8 @@ test "@min/max for floats" { } test "@min/@max on lazy values" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const A = extern struct { u8_4: [4]u8 }; const B = extern struct { u8_16: [16]u8 }; const size = @max(@sizeOf(A), @sizeOf(B)); @@ -129,6 +135,8 @@ test "@min/@max on lazy values" { } test "@min/@max more than two arguments" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const x: u32 = 30; const y: u32 = 10; const z: u32 = 20; @@ -142,6 +150,7 @@ test "@min/@max more than two vector arguments" { 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 x: @Vector(2, u32) = .{ 3, 2 }; const y: @Vector(2, u32) = .{ 4, 1 }; @@ -154,6 +163,7 @@ test "@min/@max notices bounds" { 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; var x: u16 = 20; const y = 30; @@ -172,6 +182,7 @@ test "@min/@max notices vector bounds" { 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; var x: @Vector(2, u16) = .{ 140, 40 }; const y: @Vector(2, u64) = .{ 5, 100 }; diff --git a/test/behavior/member_func.zig b/test/behavior/member_func.zig index e7b19d5c01..3e3635af98 100644 --- a/test/behavior/member_func.zig +++ b/test/behavior/member_func.zig @@ -30,6 +30,7 @@ test "standard field calls" { 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; try expect(HasFuncs.one(0) == 1); try expect(HasFuncs.two(0) == 2); @@ -73,6 +74,7 @@ test "@field field calls" { 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; try expect(@field(HasFuncs, "one")(0) == 1); try expect(@field(HasFuncs, "two")(0) == 2); diff --git a/test/behavior/memcpy.zig b/test/behavior/memcpy.zig index 1d99a7163b..66657b26c9 100644 --- a/test/behavior/memcpy.zig +++ b/test/behavior/memcpy.zig @@ -6,6 +6,7 @@ test "memcpy and memset intrinsics" { 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 testMemcpyMemset(); try comptime testMemcpyMemset(); @@ -27,6 +28,7 @@ test "@memcpy with both operands single-ptr-to-array, one is null-terminated" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testMemcpyBothSinglePtrArrayOneIsNullTerminated(); try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated(); diff --git a/test/behavior/memset.zig b/test/behavior/memset.zig index 076e1f17d9..e111b5c523 100644 --- a/test/behavior/memset.zig +++ b/test/behavior/memset.zig @@ -6,6 +6,7 @@ test "@memset on array pointers" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) { // TODO: implement memset when element ABI size > 1 return error.SkipZigTest; @@ -38,6 +39,7 @@ test "@memset on slices" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) { // TODO: implement memset when element ABI size > 1 // TODO: implement memset on slices @@ -75,6 +77,7 @@ test "memset with bool element" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; var buf: [5]bool = undefined; @@ -87,6 +90,7 @@ test "memset with 1-byte struct element" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; const S = struct { x: bool }; @@ -100,6 +104,7 @@ test "memset with 1-byte array element" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; const A = [1]bool; @@ -113,6 +118,7 @@ test "memset with large array element, runtime known" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; @@ -131,6 +137,7 @@ test "memset with large array element, comptime known" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; diff --git a/test/behavior/merge_error_sets.zig b/test/behavior/merge_error_sets.zig index 492cb27699..62aa77fb18 100644 --- a/test/behavior/merge_error_sets.zig +++ b/test/behavior/merge_error_sets.zig @@ -13,6 +13,7 @@ fn foo() C!void { test "merge error sets" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (foo()) { @panic("unexpected"); diff --git a/test/behavior/muladd.zig b/test/behavior/muladd.zig index 199f117e7b..c4e1dd1c30 100644 --- a/test/behavior/muladd.zig +++ b/test/behavior/muladd.zig @@ -10,6 +10,7 @@ test "@mulAdd" { 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; comptime try testMulAdd(); try testMulAdd(); @@ -35,6 +36,7 @@ test "@mulAdd f16" { 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; comptime try testMulAdd16(); try testMulAdd16(); @@ -53,6 +55,7 @@ test "@mulAdd f80" { 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; comptime try testMulAdd80(); try testMulAdd80(); @@ -71,6 +74,7 @@ test "@mulAdd f128" { 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; comptime try testMulAdd128(); try testMulAdd128(); @@ -101,6 +105,7 @@ test "vector f16" { 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; comptime try vector16(); try vector16(); @@ -124,6 +129,7 @@ test "vector f32" { 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; comptime try vector32(); try vector32(); @@ -147,6 +153,7 @@ test "vector f64" { 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; comptime try vector64(); try vector64(); @@ -169,6 +176,7 @@ test "vector f80" { 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; comptime try vector80(); try vector80(); @@ -192,6 +200,7 @@ test "vector f128" { 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; comptime try vector128(); try vector128(); diff --git a/test/behavior/null.zig b/test/behavior/null.zig index 6ef51cf3bd..d4fcd8360d 100644 --- a/test/behavior/null.zig +++ b/test/behavior/null.zig @@ -32,6 +32,7 @@ test "test maybe object and get a pointer to the inner value" { 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; var maybe_bool: ?bool = true; @@ -52,6 +53,7 @@ test "maybe return" { 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; try maybeReturnImpl(); comptime try maybeReturnImpl(); @@ -82,6 +84,7 @@ fn testTestNullRuntime(x: ?i32) !void { test "optional void" { 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 optionalVoidImpl(); comptime try optionalVoidImpl(); @@ -105,6 +108,7 @@ const Empty = struct {}; test "optional struct{}" { 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 optionalEmptyStructImpl(); _ = comptime try optionalEmptyStructImpl(); @@ -130,6 +134,7 @@ test "null with default unwrap" { test "optional pointer to 0 bit type null value at runtime" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const EmptyStruct = struct {}; var x: ?*EmptyStruct = null; @@ -140,6 +145,7 @@ test "if var maybe pointer" { 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; try expect(shouldBeAPlus1(Particle{ .a = 14, @@ -183,6 +189,7 @@ test "unwrap optional which is field of global var" { 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; struct_with_optional.field = null; if (struct_with_optional.field) |payload| { diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig index 8dcd252125..34d8337608 100644 --- a/test/behavior/optional.zig +++ b/test/behavior/optional.zig @@ -8,6 +8,7 @@ const expectEqualStrings = std.testing.expectEqualStrings; test "passing an optional integer as a parameter" { 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 entry() bool { @@ -27,6 +28,7 @@ pub const EmptyStruct = struct {}; test "optional pointer to size zero struct" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var e = EmptyStruct{}; var o: ?*EmptyStruct = &e; @@ -34,6 +36,8 @@ test "optional pointer to size zero struct" { } test "equality compare optional pointers" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try testNullPtrsEql(); comptime try testNullPtrsEql(); } @@ -58,6 +62,7 @@ test "optional with void 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_spirv64) return error.SkipZigTest; const Foo = struct { x: ?void, @@ -71,6 +76,7 @@ test "address of unwrap optional" { if (builtin.zig_backend == .stage2_arm) 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 { const Foo = struct { @@ -92,6 +98,7 @@ test "nested optional field in 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S2 = struct { y: u8, @@ -109,6 +116,7 @@ test "equality compare optional with non-optional" { 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_spirv64) return error.SkipZigTest; try test_cmp_optional_non_optional(); comptime try test_cmp_optional_non_optional(); @@ -146,6 +154,7 @@ fn test_cmp_optional_non_optional() !void { test "unwrap function call with optional pointer return 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_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -167,6 +176,7 @@ test "unwrap function call with optional pointer return value" { test "nested orelse" { 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 entry() !void { @@ -193,6 +203,7 @@ test "nested orelse" { test "self-referential struct through a slice of 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_spirv64) return error.SkipZigTest; const S = struct { const Node = struct { @@ -228,6 +239,7 @@ test "coerce an anon struct literal to optional struct" { 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 { const Struct = struct { @@ -247,6 +259,7 @@ test "0-bit child type coerced to optional return ptr result location" { 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 { @@ -271,6 +284,7 @@ test "0-bit child type coerced to optional return ptr result location" { test "0-bit child type coerced to optional" { 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 { @@ -298,6 +312,7 @@ test "array of optional unaligned types" { 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 Enum = enum { one, two, three }; @@ -334,6 +349,7 @@ test "optional pointer to zero bit optional payload" { 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 B = struct { fn foo(_: *@This()) void {} @@ -354,6 +370,7 @@ test "optional pointer to zero bit error union payload" { if (builtin.zig_backend == .stage2_aarch64) 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; const B = struct { fn foo(_: *@This()) void {} @@ -387,6 +404,7 @@ const NoReturn = struct { test "optional of noreturn used with if" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; NoReturn.a = 64; if (NoReturn.loop()) |_| { @@ -398,6 +416,7 @@ test "optional of noreturn used with if" { test "optional of noreturn used with orelse" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; NoReturn.a = 64; const val = NoReturn.testOrelse(); @@ -405,6 +424,8 @@ test "optional of noreturn used with orelse" { } test "orelse on C pointer" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + // TODO https://github.com/ziglang/zig/issues/6597 const foo: [*c]const u8 = "hey"; const d = foo orelse @compileError("bad"); @@ -415,6 +436,7 @@ test "alignment of wrapping an optional payload" { 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; const S = struct { const I = extern struct { x: i128 }; @@ -431,6 +453,7 @@ test "Optional slice size is optimized" { 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 expect(@sizeOf(?[]u8) == @sizeOf([]u8)); var a: ?[]const u8 = null; @@ -442,6 +465,7 @@ test "Optional slice size is optimized" { test "peer type resolution in nested if expressions" { 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; const Thing = struct { n: i32 }; var a = false; @@ -467,6 +491,7 @@ test "peer type resolution in nested if expressions" { test "cast slice to const slice nested in error union and optional" { 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; const S = struct { fn inner() !?[]u8 { diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig index 8a0ef72382..36e37786f1 100644 --- a/test/behavior/packed-struct.zig +++ b/test/behavior/packed-struct.zig @@ -7,6 +7,7 @@ const native_endian = builtin.cpu.arch.endian(); test "flags in packed structs" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const Flags1 = packed struct { // first 8 bits @@ -93,6 +94,7 @@ test "flags in packed structs" { test "consistent size of packed structs" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const TxData1 = packed struct { data: u8, _23: u23, full: bool = false }; const TxData2 = packed struct { data: u9, _22: u22, full: bool = false }; @@ -123,6 +125,7 @@ test "correct sizeOf and offsets in packed structs" { 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 PStruct = packed struct { bool_a: bool, @@ -190,6 +193,7 @@ test "nested packed structs" { 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 S1 = packed struct { a: u8, b: u8, c: u8 }; @@ -235,6 +239,7 @@ test "regular in irregular packed struct" { 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; const Irregular = packed struct { bar: Regular = Regular{}, @@ -254,6 +259,7 @@ test "byte-aligned field pointer offsets" { 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; const S = struct { const A = packed struct { @@ -354,6 +360,7 @@ test "load pointer from packed struct" { 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; const A = struct { index: u16, @@ -375,6 +382,7 @@ test "@ptrToInt on a packed struct field" { 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; const S = struct { const P = packed struct { @@ -395,6 +403,7 @@ test "optional pointer in packed struct" { 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; const T = packed struct { ptr: ?*const u8 }; var n: u8 = 0; @@ -409,6 +418,7 @@ test "nested packed struct field access test" { 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 Vec2 = packed struct { x: f32, @@ -525,6 +535,7 @@ test "runtime init of unnamed packed struct type" { 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; var z: u8 = 123; try (packed struct { @@ -539,6 +550,7 @@ test "packed struct passed to callconv(.C) function" { 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; const S = struct { const Packed = packed struct { @@ -564,6 +576,8 @@ test "overaligned pointer to packed struct" { 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; + const S = packed struct { a: u32, b: u32 }; var foo: S align(4) = .{ .a = 123, .b = 456 }; const ptr: *align(4) S = &foo; @@ -584,6 +598,7 @@ test "packed struct initialized in bitcast" { 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 T = packed struct { val: u8 }; var val: u8 = 123; @@ -597,6 +612,7 @@ test "pointer to container level packed struct field" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = packed struct(u32) { test_bit: bool, @@ -621,6 +637,7 @@ 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_llvm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; var x: u4 = 0; diff --git a/test/behavior/packed_struct_explicit_backing_int.zig b/test/behavior/packed_struct_explicit_backing_int.zig index fab43816da..62dd178fd5 100644 --- a/test/behavior/packed_struct_explicit_backing_int.zig +++ b/test/behavior/packed_struct_explicit_backing_int.zig @@ -9,6 +9,7 @@ test "packed struct explicit backing integer" { 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 S1 = packed struct { a: u8, b: u8, c: u8 }; diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig index cfce97b550..26d841a1fd 100644 --- a/test/behavior/pointers.zig +++ b/test/behavior/pointers.zig @@ -5,6 +5,7 @@ const expect = testing.expect; const expectError = testing.expectError; test "dereference pointer" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime try testDerefPtr(); try testDerefPtr(); } @@ -19,6 +20,7 @@ fn testDerefPtr() !void { test "pointer arithmetic" { 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; var ptr: [*]const u8 = "abcd"; @@ -51,6 +53,7 @@ fn PtrOf(comptime T: type) type { test "implicit cast single item pointer to C pointer and back" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var y: u8 = 11; var x: [*c]u8 = &y; @@ -67,6 +70,7 @@ test "initialize const optional C pointer to null" { test "assigning integer to C pointer" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: i32 = 0; var y: i32 = 1; @@ -83,6 +87,7 @@ test "assigning integer to C pointer" { test "C pointer comparison and arithmetic" { 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 { @@ -125,6 +130,7 @@ fn testDerefPtrOneVal() !void { } test "peer type resolution with C pointers" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var ptr_one: *u8 = undefined; var ptr_many: [*]u8 = undefined; var ptr_c: [*c]u8 = undefined; @@ -140,6 +146,7 @@ test "peer type resolution with C pointers" { } test "peer type resolution with C pointer and const pointer" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var ptr_c: [*c]u8 = undefined; const ptr_const: u8 = undefined; try expect(@TypeOf(ptr_c, &ptr_const) == [*c]const u8); @@ -149,6 +156,7 @@ test "implicit casting between C pointer and optional non-C pointer" { 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; var slice: []const u8 = "aoeu"; const opt_many_ptr: ?[*]const u8 = slice.ptr; @@ -163,6 +171,7 @@ test "implicit cast error unions with non-optional to optional pointer" { 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 { fn doTheTest() !void { @@ -191,6 +200,7 @@ test "allowzero pointer and slice" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO 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; var ptr = @intToPtr([*]allowzero i32, 0); var opt_ptr: ?[*]allowzero i32 = ptr; @@ -209,6 +219,7 @@ test "assign null directly to C pointer and test null equality" { 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; var x: [*c]i32 = null; try expect(x == null); @@ -275,6 +286,7 @@ test "array initialization types" { test "null terminated pointer" { 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; const S = struct { fn doTheTest() !void { @@ -292,6 +304,7 @@ test "null terminated pointer" { test "allow any sentinel" { 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; const S = struct { fn doTheTest() !void { @@ -307,6 +320,7 @@ test "allow any sentinel" { test "pointer sentinel with enums" { 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; const S = struct { const Number = enum { @@ -328,6 +342,7 @@ test "pointer sentinel with optional element" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -344,6 +359,7 @@ test "pointer sentinel with +inf" { 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; const S = struct { fn doTheTest() !void { @@ -364,6 +380,7 @@ test "pointer to array at fixed address" { } test "pointer arithmetic affects the alignment" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; { var ptr: [*]align(8) u32 = undefined; var x: usize = 1; @@ -410,6 +427,7 @@ test "indexing array with sentinel returns correct type" { 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; var s: [:0]const u8 = "abc"; try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0]))); @@ -418,6 +436,7 @@ test "indexing array with sentinel returns correct type" { test "element pointer to slice" { 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 { fn doTheTest() !void { @@ -440,6 +459,7 @@ test "element pointer to slice" { test "element pointer arithmetic to slice" { 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 { fn doTheTest() !void { @@ -464,6 +484,7 @@ test "element pointer arithmetic to slice" { test "array slicing to slice" { 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 { @@ -494,6 +515,7 @@ test "ptrCast comptime known slice to C pointer" { 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: [:0]const u8 = "foo"; var p = @ptrCast([*c]const u8, s); @@ -504,6 +526,7 @@ test "ptrToInt on a generic function" { 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_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn generic(i: anytype) @TypeOf(i) { diff --git a/test/behavior/popcount.zig b/test/behavior/popcount.zig index 10258f0c51..a7204fab30 100644 --- a/test/behavior/popcount.zig +++ b/test/behavior/popcount.zig @@ -7,6 +7,7 @@ test "@popCount integers" { 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; comptime try testPopCountIntegers(); try testPopCountIntegers(); @@ -17,6 +18,7 @@ test "@popCount 128bit integer" { 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; comptime { try expect(@popCount(@as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24); @@ -71,6 +73,7 @@ test "@popCount vectors" { 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; comptime try testPopCountVectors(); try testPopCountVectors(); diff --git a/test/behavior/prefetch.zig b/test/behavior/prefetch.zig index 98dc72a976..cd4d8c5aba 100644 --- a/test/behavior/prefetch.zig +++ b/test/behavior/prefetch.zig @@ -1,6 +1,9 @@ +const builtin = @import("builtin"); const std = @import("std"); test "@prefetch()" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var a: u32 = 42; @prefetch(&a, .{}); diff --git a/test/behavior/ptrcast.zig b/test/behavior/ptrcast.zig index d52f7ea727..8e25a52505 100644 --- a/test/behavior/ptrcast.zig +++ b/test/behavior/ptrcast.zig @@ -23,6 +23,7 @@ test "reinterpret an array over multiple elements, with no well-defined layout" 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; try testReinterpretWithOffsetAndNoWellDefinedLayout(); comptime try testReinterpretWithOffsetAndNoWellDefinedLayout(); @@ -130,6 +131,7 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" { if (builtin.zig_backend == .stage2_aarch64) 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; // Test lowering a field ptr comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 }; @@ -153,6 +155,7 @@ test "lower reinterpreted comptime field ptr" { if (builtin.zig_backend == .stage2_aarch64) 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; // Test lowering a field ptr comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 }; @@ -174,6 +177,7 @@ test "lower reinterpreted comptime field ptr" { test "reinterpret struct field at comptime" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const numNative = comptime Bytes.init(0x12345678); if (native_endian != .Little) { @@ -241,6 +245,7 @@ test "implicit optional pointer to optional anyopaque pointer" { 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_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var buf: [4]u8 = "aoeu".*; var x: ?[*]u8 = &buf; @@ -253,6 +258,7 @@ test "@ptrCast slice to slice" { 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 { fn foo(slice: []u32) []i32 { diff --git a/test/behavior/pub_enum.zig b/test/behavior/pub_enum.zig index d2e887b12e..672d097250 100644 --- a/test/behavior/pub_enum.zig +++ b/test/behavior/pub_enum.zig @@ -1,7 +1,10 @@ +const builtin = @import("builtin"); 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 { diff --git a/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig b/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig index bb6d5b1359..41d7f56662 100644 --- a/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig +++ b/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig @@ -8,6 +8,7 @@ test "reference a variable in an if after an if in the 2nd switch prong" { 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; try foo(true, Num.Two, false, "aoeu"); try expect(!ok); diff --git a/test/behavior/reflection.zig b/test/behavior/reflection.zig index aea84bc45a..b62838f243 100644 --- a/test/behavior/reflection.zig +++ b/test/behavior/reflection.zig @@ -28,6 +28,7 @@ fn dummy(a: bool, b: i32, c: f32) i32 { test "reflection: @field" { 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; var f = Foo{ .one = 42, diff --git a/test/behavior/return_address.zig b/test/behavior/return_address.zig index 123b90a66e..6d92e11793 100644 --- a/test/behavior/return_address.zig +++ b/test/behavior/return_address.zig @@ -10,6 +10,8 @@ test "return address" { 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; + _ = retAddr(); // TODO: #14938 try testing.expectEqual(0, comptime retAddr()); diff --git a/test/behavior/saturating_arithmetic.zig b/test/behavior/saturating_arithmetic.zig index c8658afd29..77304b1c6b 100644 --- a/test/behavior/saturating_arithmetic.zig +++ b/test/behavior/saturating_arithmetic.zig @@ -9,6 +9,7 @@ test "saturating add" { 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 { @@ -56,6 +57,7 @@ test "saturating add 128bit" { 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 { @@ -81,6 +83,7 @@ test "saturating subtraction" { 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 { @@ -127,6 +130,7 @@ test "saturating subtraction 128bit" { 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 { @@ -154,6 +158,7 @@ test "saturating multiplication" { 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_llvm and builtin.cpu.arch == .wasm32) { // https://github.com/ziglang/zig/issues/9660 @@ -198,6 +203,7 @@ test "saturating shift-left" { 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 { @@ -237,6 +243,7 @@ test "saturating shl uses the LHS type" { 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 lhs_const: u8 = 1; var lhs_var: u8 = 1; diff --git a/test/behavior/select.zig b/test/behavior/select.zig index 73d69c6530..c4549ab107 100644 --- a/test/behavior/select.zig +++ b/test/behavior/select.zig @@ -9,6 +9,7 @@ test "@select vectors" { 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; comptime try selectVectors(); try selectVectors(); @@ -37,6 +38,7 @@ test "@select arrays" { 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; comptime try selectArrays(); try selectArrays(); diff --git a/test/behavior/shuffle.zig b/test/behavior/shuffle.zig index 5ef48b5160..ed60bcad41 100644 --- a/test/behavior/shuffle.zig +++ b/test/behavior/shuffle.zig @@ -8,6 +8,7 @@ test "@shuffle int" { 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 { @@ -49,6 +50,7 @@ test "@shuffle bool 1" { 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 { @@ -69,6 +71,7 @@ test "@shuffle bool 2" { 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_llvm) { // https://github.com/ziglang/zig/issues/3246 diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig index 940ceda107..e01e20e544 100644 --- a/test/behavior/sizeof_and_typeof.zig +++ b/test/behavior/sizeof_and_typeof.zig @@ -18,6 +18,8 @@ test "@sizeOf on compile-time types" { } test "@TypeOf() with multiple arguments" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + { var var_1: u32 = undefined; var var_2: u8 = undefined; @@ -75,6 +77,7 @@ const P = packed struct { test "@offsetOf" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Packed structs have fixed memory layout try expect(@offsetOf(P, "a") == 0); @@ -137,6 +140,8 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" { } test "@TypeOf() has no runtime side effects" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn foo(comptime T: type, ptr: *T) T { ptr.* += 1; @@ -151,6 +156,8 @@ test "@TypeOf() has no runtime side effects" { test "branching logic inside @TypeOf" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { var data: i32 = 0; fn foo() anyerror!i32 { @@ -264,6 +271,7 @@ test "runtime instructions inside typeof in comptime only scope" { 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; { var y: i8 = 2; diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig index 29ceb061c1..79fa3b9ce7 100644 --- a/test/behavior/slice.zig +++ b/test/behavior/slice.zig @@ -29,6 +29,7 @@ comptime { test "slicing" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var array: [20]i32 = undefined; @@ -64,6 +65,7 @@ test "comptime slice of undefined pointer of length 0" { test "implicitly cast array of size 0 to slice" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var msg = [_]u8{}; try assertLenIsZero(&msg); @@ -120,6 +122,7 @@ test "slice of type" { test "generic malloc free" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a = memAlloc(u8, 10) catch unreachable; memFree(u8, a); @@ -171,6 +174,7 @@ test "comptime pointer cast array and then slice" { test "slicing zero length array" { 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; const s1 = ""[0..]; const s2 = ([_]u32{})[0..]; @@ -195,6 +199,8 @@ test "slicing pointer by length" { const x = @intToPtr([*]i32, 0x1000)[0..0x500]; const y = x[0x100..]; test "compile time slice of pointer to hard coded address" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(@ptrToInt(x) == 0x1000); try expect(x.len == 0x500); @@ -216,6 +222,7 @@ test "slice string literal has correct type" { test "result location zero sized array inside struct field implicit cast to slice" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const E = struct { entries: []u32, @@ -228,6 +235,7 @@ test "runtime safety lets us slice from len..len" { 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; var an_array = [_]u8{ 1, 2, 3 }; try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), "")); @@ -238,8 +246,9 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 { } test "C pointer" { - if (builtin.zig_backend == .stage2_sparc64) 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; var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf"; var len: u32 = 10; @@ -251,6 +260,7 @@ test "C pointer slice access" { 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; var buf: [10]u32 = [1]u32{42} ** 10; const c_ptr = @ptrCast([*c]const u32, &buf); @@ -280,6 +290,7 @@ fn sliceSum(comptime q: []const u8) i32 { test "slice type with custom alignment" { 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; const LazilyResolvedType = struct { anything: i32, @@ -293,6 +304,7 @@ test "slice type with custom alignment" { test "obtaining a null terminated slice" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // here we have a normal array var buf: [50]u8 = undefined; @@ -335,6 +347,7 @@ test "empty array to slice" { test "@ptrCast slice to pointer" { 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; const S = struct { fn doTheTest() !void { @@ -353,6 +366,7 @@ test "slice syntax resulting in pointer-to-array" { 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 { @@ -551,6 +565,7 @@ test "slice syntax resulting in pointer-to-array" { test "slice pointer-to-array null terminated" { 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; comptime { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; @@ -569,6 +584,7 @@ test "slice pointer-to-array null terminated" { test "slice pointer-to-array zero length" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime { { @@ -603,6 +619,7 @@ test "type coercion of pointer to anon struct literal to pointer to slice" { 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 { const U = union { @@ -655,6 +672,7 @@ test "array mult of slice gives ptr to array" { test "slice bounds in comptime concatenation" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const bs = comptime blk: { const b = "........1........"; @@ -690,6 +708,7 @@ test "slice sentinel access at comptime" { test "slicing array with sentinel as end index" { 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; const S = struct { fn do() !void { @@ -708,6 +727,7 @@ test "slicing array with sentinel as end index" { test "slicing slice with sentinel as end index" { 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; const S = struct { fn do() !void { @@ -736,6 +756,8 @@ test "slice len modification at comptime" { } test "slice field ptr const" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const const_slice: []const u8 = "string"; const const_ptr_const_slice = &const_slice; @@ -749,6 +771,7 @@ test "slice field ptr const" { test "slice field ptr var" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var var_slice: []const u8 = "string"; @@ -765,6 +788,7 @@ test "global slice field access" { 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 { var slice: []const u8 = undefined; @@ -776,6 +800,8 @@ test "global slice field access" { } test "slice of void" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var n: usize = 10; var arr: [12]void = undefined; const slice = @as([]void, &arr)[0..n]; @@ -783,6 +809,8 @@ test "slice of void" { } test "slice with dereferenced value" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var a: usize = 0; var idx: *usize = &a; _ = blk: { @@ -798,6 +826,7 @@ test "slice with dereferenced value" { test "empty slice ptr is non null" { if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; { const empty_slice: []u8 = &[_]u8{}; @@ -816,6 +845,7 @@ test "empty slice ptr is non null" { test "slice decays to many pointer" { 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; var buf: [8]u8 = "abcdefg\x00".*; const p: [*:0]const u8 = buf[0..7 :0]; @@ -826,6 +856,7 @@ test "write through pointer to optional slice arg" { 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; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn bar(foo: *?[]const u8) !void { diff --git a/test/behavior/src.zig b/test/behavior/src.zig index 89a8e424aa..9c81bcde89 100644 --- a/test/behavior/src.zig +++ b/test/behavior/src.zig @@ -17,6 +17,7 @@ test "@src" { 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_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try doTheTest(); } @@ -33,6 +34,8 @@ test "@src used as a comptime parameter" { } test "@src in tuple passed to anytype function" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn Foo(a: anytype) u32 { return a[0].line; diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index 0ca7f70de1..797a22c3a8 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -11,6 +11,7 @@ top_level_field: i32, test "top level fields" { 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; var instance = @This(){ .top_level_field = 1234, @@ -89,6 +90,7 @@ test "structs" { 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; var foo: StructFoo = undefined; @memset(@ptrCast([*]u8, &foo)[0..@sizeOf(StructFoo)], 0); @@ -107,6 +109,7 @@ fn testMutation(foo: *StructFoo) void { test "struct byval assign" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var foo1: StructFoo = undefined; var foo2: StructFoo = undefined; @@ -119,6 +122,8 @@ test "struct byval assign" { } test "call struct static method" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const result = StructWithNoFields.add(3, 4); try expect(result == 7); } @@ -126,6 +131,8 @@ test "call struct static method" { const should_be_11 = StructWithNoFields.add(5, 6); test "invoke static method in global scope" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(should_be_11 == 11); } @@ -248,6 +255,7 @@ test "usingnamespace within struct scope" { test "struct field init with catch" { 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; const S = struct { fn doTheTest() !void { @@ -274,6 +282,7 @@ const blah: packed struct { test "bit field alignment" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + try expect(@TypeOf(&blah.b) == *align(1:3:1) const u3); } @@ -289,6 +298,7 @@ const Val = struct { test "struct point to self" { 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; var root: Node = undefined; root.val.x = 1; @@ -305,6 +315,7 @@ test "struct point to self" { test "void struct fields" { 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; const foo = VoidStructFieldsFoo{ .a = void{}, @@ -332,6 +343,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 { test "pass slice of empty struct to fn" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1); } @@ -343,6 +355,7 @@ test "self-referencing struct via array member" { 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_spirv64) return error.SkipZigTest; const T = struct { children: [1]*@This(), @@ -353,6 +366,8 @@ test "self-referencing struct via array member" { } test "empty struct method call" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const es = EmptyStruct{}; try expect(es.method() == 1234); } @@ -365,6 +380,7 @@ const EmptyStruct = struct { test "align 1 field before self referential align 8 field as slice return type" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const result = alloc(Expr); try expect(result.len == 0); @@ -388,6 +404,7 @@ test "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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var foo = APackedStruct{ .x = 1, @@ -416,6 +433,7 @@ test "packed struct 24bits" { if (builtin.cpu.arch == .wasm32) return error.SkipZigTest; // TODO if (builtin.cpu.arch == .arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime { std.debug.assert(@sizeOf(Foo24Bits) == @sizeOf(u24)); @@ -457,6 +475,7 @@ test "runtime struct initialization of bitfield" { 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_spirv64) return error.SkipZigTest; const s1 = Nibbles{ .x = x1, @@ -495,6 +514,7 @@ test "packed struct fields are ordered from LSB to MSB" { 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; var all: u64 = 0x7765443322221111; var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined; @@ -515,6 +535,7 @@ test "implicit cast packed struct field to const ptr" { if (builtin.zig_backend == .stage2_arm) 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 LevelUpMove = packed struct { move_id: u9, @@ -533,6 +554,7 @@ test "implicit cast packed struct field to const ptr" { test "zero-bit field in packed struct" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = packed struct { x: u10, @@ -549,6 +571,7 @@ test "packed struct with non-ABI-aligned field" { if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = packed struct { x: u9, @@ -577,6 +600,7 @@ test "bit field access" { 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_spirv64) return error.SkipZigTest; var data = bit_field_1; try expect(getA(&data) == 1); @@ -631,6 +655,7 @@ test "packed array 24bits" { 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; comptime { try expect(@sizeOf([9]Foo32Bits) == 9 * 4); @@ -697,6 +722,7 @@ test "pointer to packed struct member in a stack variable" { 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 = packed struct { a: u2, @@ -723,6 +749,7 @@ test "packed struct with u0 field access" { test "access to global struct fields" { 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; g_foo.bar.value = 42; try expect(g_foo.bar.value == 42); @@ -747,6 +774,7 @@ test "packed struct with fp 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 = packed struct { data0: f32, @@ -799,6 +827,7 @@ test "non-packed struct with u128 entry in union" { 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 U = union(enum) { Num: u128, @@ -822,6 +851,7 @@ test "packed struct field passed to generic function" { 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 P = packed struct { @@ -915,6 +945,8 @@ test "tuple assigned to variable" { } test "comptime struct field" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.cpu.arch == .arm) return error.SkipZigTest; // TODO @@ -933,6 +965,7 @@ test "tuple element initialized with fn call" { 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 { fn doTheTest() !void { @@ -951,6 +984,7 @@ test "struct with union field" { 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 Value = struct { ref: u32 = 2, @@ -971,6 +1005,7 @@ test "type coercion of anon struct literal to struct" { 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 S2 = struct { @@ -1008,6 +1043,7 @@ test "type coercion of pointer to anon struct literal to pointer to struct" { 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 S2 = struct { @@ -1047,6 +1083,7 @@ test "packed struct with undefined initializers" { if (builtin.zig_backend == .stage2_arm) 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 { const P = packed struct { @@ -1115,6 +1152,7 @@ test "anon init through error unions and optionals" { 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 { a: u32, @@ -1141,6 +1179,7 @@ test "anon init through optional" { 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 { a: u32, @@ -1160,6 +1199,7 @@ test "anon init through error union" { 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 { a: u32, @@ -1179,6 +1219,7 @@ test "typed init through error unions and optionals" { 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 { a: u32, @@ -1239,6 +1280,7 @@ test "packed struct aggregate init" { 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: i2, b: i6) u8 { @@ -1258,6 +1300,7 @@ test "packed struct field access via pointer" { 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 { @@ -1313,6 +1356,7 @@ test "under-aligned struct field" { 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 U = extern union { fd: i32, @@ -1333,6 +1377,7 @@ test "under-aligned struct field" { test "fieldParentPtr of a zero-bit field" { 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 S = struct { fn testStruct(comptime A: type) !void { @@ -1380,6 +1425,7 @@ test "fieldParentPtr of a zero-bit field" { test "struct field has 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 = struct { next: *align(1) @This(), @@ -1391,6 +1437,8 @@ test "struct field has a pointer to an aligned version of itself" { } test "struct has only one reference" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { fn optionalStructParam(_: ?struct { x: u8 }) void {} fn errorUnionStructParam(_: error{}!struct { x: u8 }) void {} @@ -1439,6 +1487,7 @@ test "struct has only one reference" { test "no dependency loop on pointer to optional 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_spirv64) return error.SkipZigTest; const S = struct { const A = struct { b: B }; @@ -1459,6 +1508,7 @@ test "discarded struct initialization works as expected" { test "function pointer in struct returns the struct" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const A = struct { const A = @This(); @@ -1474,6 +1524,7 @@ test "function pointer in struct returns the struct" { test "no dependency loop on optional field wrapped in generic function" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn Atomic(comptime T: type) type { @@ -1493,6 +1544,7 @@ test "no dependency loop on optional field wrapped in generic function" { test "optional field init with tuple" { 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 S = struct { a: ?struct { b: u32 }, @@ -1506,6 +1558,7 @@ test "optional field init with tuple" { test "if inside struct init inside if" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const MyStruct = struct { x: u32 }; const b: u32 = 5; diff --git a/test/behavior/struct_contains_null_ptr_itself.zig b/test/behavior/struct_contains_null_ptr_itself.zig index 7f0182af22..ded29039c8 100644 --- a/test/behavior/struct_contains_null_ptr_itself.zig +++ b/test/behavior/struct_contains_null_ptr_itself.zig @@ -5,6 +5,7 @@ const builtin = @import("builtin"); test "struct contains null pointer which contains original struct" { 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; var x: ?*NodeLineComment = null; try expect(x == null); diff --git a/test/behavior/struct_contains_slice_of_itself.zig b/test/behavior/struct_contains_slice_of_itself.zig index adb1c31047..6f63bfb8de 100644 --- a/test/behavior/struct_contains_slice_of_itself.zig +++ b/test/behavior/struct_contains_slice_of_itself.zig @@ -13,6 +13,7 @@ const NodeAligned = struct { test "struct contains slice of itself" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var other_nodes = [_]Node{ Node{ @@ -53,6 +54,7 @@ test "struct contains slice of itself" { test "struct contains aligned slice of itself" { 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; var other_nodes = [_]NodeAligned{ NodeAligned{ diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig index a32a762e04..f66446632b 100644 --- a/test/behavior/switch.zig +++ b/test/behavior/switch.zig @@ -117,6 +117,7 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool { test "switching on booleans" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testSwitchOnBools(); comptime try testSwitchOnBools(); @@ -214,6 +215,7 @@ fn poll() void { test "switch on global mutable var isn't constant-folded" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; while (state < 2) { poll(); @@ -230,6 +232,7 @@ test "switch prong with variable" { 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; try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 }); try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 }); @@ -254,6 +257,7 @@ test "switch on enum using pointer capture" { 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; try testSwitchEnumPtrCapture(); comptime try testSwitchEnumPtrCapture(); @@ -314,6 +318,7 @@ test "switch on union with some prongs capturing" { 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 X = union(enum) { a, @@ -344,12 +349,15 @@ fn returnsFalse() bool { } } test "switch on const enum with var" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(!returnsFalse()); } test "anon enum literal used in switch on union enum" { 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 Foo = union(enum) { a: i32, @@ -388,6 +396,7 @@ fn switchWithUnreachable(x: i32) i32 { test "capture value of switch with all unreachable prongs" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const x = return_a_number() catch |err| switch (err) { else => unreachable, @@ -401,6 +410,7 @@ fn return_a_number() anyerror!i32 { test "switch on integer with else capturing expr" { 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 { @@ -420,6 +430,7 @@ test "else prong of switch on error set excludes other cases" { 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 { fn doTheTest() !void { @@ -454,6 +465,7 @@ test "switch prongs with error set cases make a new error set type for capture v 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 { fn doTheTest() !void { @@ -488,6 +500,7 @@ test "switch prongs with error set cases make a new error set type for capture v test "return result loc and then switch with range implicit casted to error union" { 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 { @@ -528,6 +541,7 @@ test "switch prongs with cases with identical payload types" { 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 Union = union(enum) { A: usize, @@ -571,6 +585,7 @@ test "switch prongs with cases with identical payload types" { test "switch on pointer type" { 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 X = struct { @@ -618,6 +633,7 @@ test "switch capture copies its payload" { 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 { fn doTheTest() !void { @@ -692,6 +708,8 @@ test "switch item sizeof" { } test "comptime inline switch" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const U = union(enum) { a: type, b: type }; const value = comptime blk: { var u: U = .{ .a = u32 }; diff --git a/test/behavior/switch_prong_err_enum.zig b/test/behavior/switch_prong_err_enum.zig index 15d366d04f..f09e2fb7d3 100644 --- a/test/behavior/switch_prong_err_enum.zig +++ b/test/behavior/switch_prong_err_enum.zig @@ -24,6 +24,7 @@ test "switch prong returns error enum" { 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; switch (doThing(17) catch unreachable) { FormValue.Address => |payload| { diff --git a/test/behavior/switch_prong_implicit_cast.zig b/test/behavior/switch_prong_implicit_cast.zig index 54107bb6bd..4be8f82085 100644 --- a/test/behavior/switch_prong_implicit_cast.zig +++ b/test/behavior/switch_prong_implicit_cast.zig @@ -18,6 +18,7 @@ test "switch prong implicit cast" { 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; const result = switch (foo(2) catch unreachable) { FormValue.One => false, diff --git a/test/behavior/this.zig b/test/behavior/this.zig index a68e44df89..8fd8af92a3 100644 --- a/test/behavior/this.zig +++ b/test/behavior/this.zig @@ -21,12 +21,15 @@ fn add(x: i32, y: i32) i32 { } test "this refer to module call private fn" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(module.add(1, 2) == 3); } test "this refer to container" { 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; var pt: Point(i32) = undefined; pt.x = 12; diff --git a/test/behavior/threadlocal.zig b/test/behavior/threadlocal.zig index f025e99ee7..a1214fff21 100644 --- a/test/behavior/threadlocal.zig +++ b/test/behavior/threadlocal.zig @@ -11,6 +11,7 @@ test "thread local variable" { else => 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 { threadlocal var t: i32 = 1234; @@ -28,6 +29,7 @@ test "pointer to thread local array" { else => 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 = "Hello world"; std.mem.copy(u8, buffer[0..], s); @@ -45,6 +47,7 @@ test "reference a global threadlocal variable" { else => return error.SkipZigTest, }; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; _ = nrfx_uart_rx(&g_uart0); } diff --git a/test/behavior/translate_c_macros.zig b/test/behavior/translate_c_macros.zig index bc19cddc22..aa08e8c9aa 100644 --- a/test/behavior/translate_c_macros.zig +++ b/test/behavior/translate_c_macros.zig @@ -9,6 +9,7 @@ const latin1 = @cImport(@cInclude("behavior/translate_c_macros_not_utf8.h")); test "casting to void with a macro" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; h.IGNORE_ME_1(42); h.IGNORE_ME_2(42); @@ -26,6 +27,7 @@ test "initializer list expression" { 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; try expectEqual(h.Color{ .r = 200, @@ -38,6 +40,7 @@ test "initializer list expression" { test "sizeof in macros" { 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; try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF(u32)); try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF2(u32)); @@ -45,6 +48,7 @@ test "sizeof in macros" { test "reference to a struct type" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(@sizeOf(h.struct_Foo) == h.SIZE_OF_FOO); } @@ -54,6 +58,7 @@ test "cast negative integer to pointer" { 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; try expectEqual(@intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))), h.MAP_FAILED); } @@ -64,6 +69,7 @@ test "casting to union with a macro" { 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 l: c_long = 42; const d: f64 = 2.0; @@ -80,6 +86,7 @@ test "casting or calling a value with a paren-surrounded macro" { 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 l: c_long = 42; const casted = h.CAST_OR_CALL_WITH_PARENS(c_int, l); @@ -99,6 +106,7 @@ test "nested comma operator" { 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; try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR); try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR_LHS); @@ -109,6 +117,7 @@ test "cast functions" { 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 { fn foo() void {} @@ -122,6 +131,7 @@ test "large integer macro" { 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; try expectEqual(@as(c_ulonglong, 18446744073709550592), h.LARGE_INT); } @@ -131,6 +141,7 @@ test "string literal macro with embedded tab character" { 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; try expectEqualStrings("hello\t", h.EMBEDDED_TAB); } @@ -140,6 +151,7 @@ test "string and char literals that are not UTF-8 encoded. Issue #12784" { 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; try expectEqual(@as(u8, '\xA9'), latin1.UNPRINTABLE_CHAR); try expectEqualStrings("\xA9\xA9\xA9", latin1.UNPRINTABLE_STRING); @@ -151,6 +163,7 @@ test "Macro that uses division operator. Issue #13162" { 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; try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000))); try expectEqual(@as(c_uint, 42), h.DIVIDE_CONSTANT(@as(c_uint, 42_000))); @@ -184,6 +197,7 @@ test "Macro that uses remainder operator. Issue #13346" { 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; try expectEqual(@as(c_int, 2_010), h.REMAINDER_CONSTANT(@as(c_int, 42_010))); try expectEqual(@as(c_uint, 2_030), h.REMAINDER_CONSTANT(@as(c_uint, 42_030))); @@ -214,5 +228,7 @@ test "Macro that uses remainder operator. Issue #13346" { } test "@typeInfo on @cImport result" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(@typeInfo(h).Struct.decls.len > 1); } diff --git a/test/behavior/truncate.zig b/test/behavior/truncate.zig index e70d33eea2..1db2f0280f 100644 --- a/test/behavior/truncate.zig +++ b/test/behavior/truncate.zig @@ -65,6 +65,7 @@ test "truncate on vectors" { 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; const S = struct { fn doTheTest() !void { diff --git a/test/behavior/try.zig b/test/behavior/try.zig index 36428a4616..967b1af04e 100644 --- a/test/behavior/try.zig +++ b/test/behavior/try.zig @@ -4,6 +4,7 @@ const expect = std.testing.expect; test "try on error union" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try tryOnErrorUnionImpl(); comptime try tryOnErrorUnionImpl(); @@ -23,6 +24,8 @@ fn returnsTen() anyerror!i32 { } test "try without vars" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const result1 = if (failIfTrue(true)) 1 else |_| @as(i32, 2); try expect(result1 == 2); @@ -39,6 +42,8 @@ fn failIfTrue(ok: bool) anyerror!void { } test "try then not executed with assignment" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (failIfTrue(true)) { unreachable; } else |err| { diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig index c1e5f40a46..2ce1922e50 100644 --- a/test/behavior/tuple.zig +++ b/test/behavior/tuple.zig @@ -9,6 +9,7 @@ test "tuple concatenation" { 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 { fn doTheTest() !void { @@ -52,6 +53,7 @@ test "more tuple concatenation" { 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 T = struct { fn consume_tuple(tuple: anytype, len: usize) !void { @@ -212,6 +214,7 @@ test "fieldParentPtr of tuple" { 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; var x: u32 = 0; const tuple = .{ x, x }; @@ -222,6 +225,7 @@ test "fieldParentPtr of anon struct" { 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; var x: u32 = 0; const anon_st = .{ .foo = x, .bar = x }; @@ -242,6 +246,7 @@ test "offsetOf anon struct" { test "initializing tuple with mixed comptime-runtime fields" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: u32 = 15; const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x }); @@ -251,6 +256,7 @@ test "initializing tuple with mixed comptime-runtime fields" { test "initializing anon struct with mixed comptime-runtime fields" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: u32 = 15; const T = @TypeOf(.{ .foo = @as(i32, -1234), .bar = x }); @@ -262,6 +268,7 @@ test "tuple in tuple passed to generic 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 pair(x: f32, y: f32) std.meta.Tuple(&.{ f32, f32 }) { @@ -281,6 +288,7 @@ test "coerce tuple to tuple" { 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 T = std.meta.Tuple(&.{u8}); const S = struct { @@ -295,6 +303,7 @@ test "tuple type with void field" { 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 T = std.meta.Tuple(&[_]type{void}); const x = T{{}}; @@ -302,6 +311,8 @@ test "tuple type with void field" { } test "zero sized struct in tuple handled correctly" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const State = struct { const Self = @This(); data: @Type(.{ @@ -331,6 +342,7 @@ test "zero sized struct in tuple handled correctly" { test "tuple type with void field and a runtime field" { 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 T = std.meta.Tuple(&[_]type{ usize, void }); var t: T = .{ 5, {} }; @@ -341,6 +353,7 @@ test "branching inside tuple literal" { 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: anytype) !void { @@ -356,6 +369,7 @@ test "tuple initialized with a runtime known value" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const E = union(enum) { e: []const u8 }; const W = union(enum) { w: E }; @@ -370,6 +384,7 @@ test "tuple of struct concatenation and coercion to array" { if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const StructWithDefault = struct { value: f32 = 42 }; const SomeStruct = struct { array: [4]StructWithDefault }; @@ -384,6 +399,7 @@ test "nested runtime conditionals in tuple initializer" { 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; var data: u8 = 0; const x = .{ diff --git a/test/behavior/tuple_declarations.zig b/test/behavior/tuple_declarations.zig index 74ee7da1dd..c053447ccc 100644 --- a/test/behavior/tuple_declarations.zig +++ b/test/behavior/tuple_declarations.zig @@ -7,6 +7,7 @@ const expectEqualStrings = testing.expectEqualStrings; test "tuple declaration type info" { 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; { const T = struct { comptime u32 align(2) = 1, []const u8 }; @@ -56,6 +57,7 @@ test "tuple declaration type info" { test "Tuple declaration usage" { 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; const T = struct { u32, []const u8 }; var t: T = .{ 1, "foo" }; diff --git a/test/behavior/type.zig b/test/behavior/type.zig index 695a81b1a3..936d9663ad 100644 --- a/test/behavior/type.zig +++ b/test/behavior/type.zig @@ -203,6 +203,7 @@ test "Type.Opaque" { 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 Opaque = @Type(.{ .Opaque = .{ @@ -261,6 +262,7 @@ test "Type.Struct" { 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 = @Type(@typeInfo(struct { x: u8, y: u32 })); const infoA = @typeInfo(A).Struct; @@ -348,6 +350,7 @@ test "Type.Struct" { test "Type.Enum" { 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 Foo = @Type(.{ .Enum = .{ @@ -384,6 +387,7 @@ test "Type.Union" { 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_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const Untagged = @Type(.{ .Union = .{ @@ -487,6 +491,7 @@ test "Type.Fn" { 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_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const some_opaque = opaque {}; const some_ptr = *some_opaque; diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig index ad6d5ac42f..d55688c5ee 100644 --- a/test/behavior/type_info.zig +++ b/test/behavior/type_info.zig @@ -160,6 +160,7 @@ test "type info: error set, error union info, anyerror" { 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_spirv64) return error.SkipZigTest; try testErrorSet(); comptime try testErrorSet(); @@ -191,6 +192,7 @@ test "type info: error set single value" { 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_spirv64) return error.SkipZigTest; const TestSet = error.One; @@ -204,6 +206,7 @@ test "type info: error set merged" { 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_spirv64) return error.SkipZigTest; const TestSet = error{ One, Two } || error{Three}; @@ -219,6 +222,7 @@ test "type info: enum info" { 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; try testEnum(); comptime try testEnum(); @@ -281,6 +285,7 @@ fn testUnion() !void { test "type info: struct info" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testStruct(); comptime try testStruct(); @@ -349,6 +354,8 @@ fn testOpaque() !void { } test "type info: function type info" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try testFunction(); comptime try testFunction(); } @@ -506,6 +513,7 @@ test "type info for async frames" { test "Declarations are returned in declaration order" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { const a = 1; @@ -528,6 +536,7 @@ test "Struct.is_tuple for anon list literal" { test "Struct.is_tuple for anon struct literal" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const info = @typeInfo(@TypeOf(.{ .a = 0 })); try expect(!info.Struct.is_tuple); @@ -564,6 +573,7 @@ test "value from struct @typeInfo default_value can be loaded at comptime" { test "@typeInfo decls and usingnamespace" { 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 A = struct { const x = 5; diff --git a/test/behavior/typename.zig b/test/behavior/typename.zig index fa2446dc6e..e30f37e5af 100644 --- a/test/behavior/typename.zig +++ b/test/behavior/typename.zig @@ -15,6 +15,7 @@ test "anon fn param" { 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; // https://github.com/ziglang/zig/issues/9339 try expectEqualStringsIgnoreDigits( @@ -40,6 +41,7 @@ test "anon field init" { 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 Foo = .{ .T1 = struct {}, @@ -65,6 +67,7 @@ test "basic" { 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; try expectEqualStrings("i64", @typeName(i64)); try expectEqualStrings("*usize", @typeName(*usize)); @@ -88,6 +91,7 @@ test "top level decl" { 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; try expectEqualStrings( "behavior.typename.A_Struct", @@ -137,6 +141,7 @@ test "fn param" { 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; // https://github.com/ziglang/zig/issues/675 try expectEqualStrings( @@ -207,6 +212,7 @@ test "local variable" { 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 Foo = struct { a: u32 }; const Bar = union { a: u32 }; @@ -225,6 +231,7 @@ test "comptime parameters not converted to anytype in function type" { 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 T = fn (fn (type) void, void) void; try expectEqualStrings("fn(comptime fn(comptime type) void, void) void", @typeName(T)); @@ -234,6 +241,7 @@ test "anon name strategy used in sub expression" { 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 getTheName() []const u8 { diff --git a/test/behavior/undefined.zig b/test/behavior/undefined.zig index 79838e02a6..e0f3e00fff 100644 --- a/test/behavior/undefined.zig +++ b/test/behavior/undefined.zig @@ -47,6 +47,7 @@ test "assign undefined to struct" { 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; comptime { var foo: Foo = undefined; @@ -64,6 +65,7 @@ test "assign undefined to struct with method" { 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; comptime { var foo: Foo = undefined; @@ -79,6 +81,7 @@ test "assign undefined to struct with method" { test "type name of undefined" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const x = undefined; try expect(mem.eql(u8, @typeName(@TypeOf(x)), "@TypeOf(undefined)")); diff --git a/test/behavior/underscore.zig b/test/behavior/underscore.zig index 66b49e52d5..bb5dd156bc 100644 --- a/test/behavior/underscore.zig +++ b/test/behavior/underscore.zig @@ -8,6 +8,7 @@ test "ignore lval with underscore" { test "ignore lval with underscore (while loop)" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; while (optionalReturnError()) |_| { while (optionalReturnError()) |_| { diff --git a/test/behavior/union.zig b/test/behavior/union.zig index 41842f5bc5..26a5d060df 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -14,6 +14,7 @@ test "basic unions with floats" { 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; var foo = FooWithFloats{ .int = 1 }; try expect(foo.int == 1); @@ -29,6 +30,7 @@ test "init union with runtime value - floats" { 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; var foo: FooWithFloats = undefined; @@ -40,6 +42,7 @@ test "basic unions" { 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_spirv64) return error.SkipZigTest; var foo = Foo{ .int = 1 }; try expect(foo.int == 1); @@ -58,6 +61,7 @@ test "init union with runtime value" { 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; var foo: Foo = undefined; @@ -96,6 +100,7 @@ const FooExtern = extern union { test "basic extern unions" { 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; var foo = FooExtern{ .int = 1 }; try expect(foo.int == 1); @@ -167,6 +172,7 @@ test "constant tagged union with payload" { 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; var empty = TaggedUnionWithPayload{ .Empty = {} }; var full = TaggedUnionWithPayload{ .Full = 13 }; @@ -216,6 +222,7 @@ test "union with specified enum tag" { 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; try doTest(); comptime try doTest(); @@ -225,6 +232,7 @@ test "packed union generates correctly aligned type" { 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; const U = packed union { f1: *const fn () error{TestUnexpectedResult}!void, @@ -264,6 +272,7 @@ test "comparison between union and enum literal" { 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; try testComparison(); comptime try testComparison(); @@ -279,6 +288,7 @@ test "cast union to tag type of union" { 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; try testCastUnionToTag(); comptime try testCastUnionToTag(); @@ -299,6 +309,7 @@ test "cast tag type of union to union" { 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; var x: Value2 = Letter2.B; try expect(@as(Letter2, x) == Letter2.B); @@ -314,6 +325,7 @@ test "implicit cast union to its tag type" { 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; var x: Value2 = Letter2.B; try expect(x == Letter2.B); @@ -334,6 +346,7 @@ test "constant packed union" { 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; try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }}); } @@ -353,6 +366,7 @@ test "simple union(enum(u32))" { 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; var x = MultipleChoice.C; try expect(x == MultipleChoice.C); @@ -378,6 +392,7 @@ test "tagged union initialization with runtime void" { 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; try expect(testTaggedUnionInit({})); } @@ -398,6 +413,7 @@ test "tagged union with no payloads" { 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; const a = UnionEnumNoPayloads{ .B = {} }; switch (a) { @@ -408,6 +424,7 @@ test "tagged union with no payloads" { test "union with only 1 field casted to its enum type" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const Literal = union(enum) { Number: f64, @@ -444,6 +461,7 @@ test "global union with single field is correctly initialized" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 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; glbl = Foo1{ .f = @typeInfo(Foo1).Union.fields[0].type{ .x = 123 }, @@ -462,6 +480,7 @@ test "initialize global array of union" { 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; glbl_array[1] = FooUnion{ .U1 = 2 }; glbl_array[0] = FooUnion{ .U0 = 1 }; @@ -473,6 +492,7 @@ test "update the tag value for zero-sized unions" { 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; const S = union(enum) { U0: void, @@ -489,6 +509,7 @@ test "union initializer generates padding only if needed" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 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; const U = union(enum) { A: u24, @@ -501,6 +522,7 @@ test "union initializer generates padding only if needed" { test "runtime tag name with single field" { 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; const U = union(enum) { A: i32, @@ -514,6 +536,7 @@ test "method call on an empty union" { 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; const S = struct { const MyUnion = union(MyUnionTag) { @@ -576,6 +599,7 @@ test "tagged union as return value" { 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; switch (returnAnInt(13)) { TaggedFoo.One => |value| try expect(value == 13), @@ -591,6 +615,7 @@ test "tagged union with all void fields but a meaningful tag" { 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; const S = struct { const B = union(enum) { @@ -620,6 +645,7 @@ test "union(enum(u32)) with specified and unspecified tag values" { 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; comptime try expect(Tag(Tag(MultipleChoice2)) == u32); try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); @@ -657,6 +683,7 @@ test "switch on union with only 1 field" { 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; var r: PartialInst = undefined; r = PartialInst.Compiled; @@ -685,6 +712,7 @@ const PartialInstWithPayload = union(enum) { test "union with only 1 field casted to its enum type which has enum value specified" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const Literal = union(enum) { Number: f64, @@ -711,6 +739,7 @@ test "@enumToInt works on unions" { 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 Bar = union(enum) { A: bool, @@ -770,6 +799,7 @@ test "return union init with void payload" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 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; const S = struct { fn entry() !void { @@ -796,6 +826,7 @@ test "@unionInit stored to a const" { 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; const S = struct { const U = union(enum) { @@ -824,6 +855,7 @@ test "@unionInit can modify a union type" { 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 UnionInitEnum = union(enum) { Boolean: bool, @@ -847,6 +879,7 @@ test "@unionInit can modify a pointer value" { 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 UnionInitEnum = union(enum) { Boolean: bool, @@ -867,6 +900,7 @@ test "union no tag with struct member" { 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 Struct = struct {}; const Union = union { @@ -902,6 +936,7 @@ test "anonymous union literal syntax" { 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 Number = union { @@ -928,6 +963,7 @@ test "function call result coerces from tagged union to the tag" { 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 Arch = union(enum) { @@ -963,6 +999,7 @@ test "cast from anonymous struct to union" { 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; const S = struct { const U = union(enum) { @@ -996,6 +1033,7 @@ test "cast from pointer to anonymous struct to pointer to union" { 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; const S = struct { const U = union(enum) { @@ -1027,6 +1065,7 @@ test "switching on non exhaustive union" { 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 E = enum(u8) { @@ -1054,6 +1093,7 @@ test "containers with single-field enums" { 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 A = union(enum) { f1 }; @@ -1083,6 +1123,7 @@ test "@unionInit on union with tag but no fields" { if (builtin.zig_backend == .stage2_aarch64) 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; const S = struct { const Type = enum(u8) { no_op = 105 }; @@ -1132,6 +1173,7 @@ test "global variable struct contains union initialized to non-most-aligned fiel 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 T = struct { const U = union(enum) { @@ -1159,6 +1201,7 @@ test "union with no result loc initiated with a runtime value" { 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 U = union { a: u32, @@ -1176,6 +1219,7 @@ test "union with a large struct field" { 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 { a: [8]usize, @@ -1209,6 +1253,7 @@ test "union tag is set when initiated as a temporary value at runtime" { 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 U = union(enum) { a, @@ -1227,6 +1272,7 @@ test "extern union most-aligned field is smaller" { 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 U = extern union { in6: extern struct { @@ -1246,6 +1292,7 @@ test "return an extern union from C calling convention" { 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 namespace = struct { const S = extern struct { @@ -1276,6 +1323,7 @@ test "noreturn field in union" { 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 U = union(enum) { a: u32, @@ -1327,6 +1375,7 @@ test "union and enum field order doesn't match" { 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 MyTag = enum(u32) { b = 1337, @@ -1353,6 +1402,7 @@ test "@unionInit uses tag value instead of field index" { 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; const E = enum(u8) { b = 255, @@ -1379,6 +1429,7 @@ test "union field ptr - zero sized payload" { 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 U = union { foo: void, @@ -1393,6 +1444,7 @@ test "union field ptr - zero sized field" { 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 U = union { foo: void, @@ -1408,6 +1460,7 @@ test "packed union in packed struct" { 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; const S = packed struct { nested: packed union { @@ -1425,6 +1478,8 @@ test "packed union in packed struct" { } test "Namespace-like union" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const DepType = enum { git, http, @@ -1458,6 +1513,7 @@ test "union int tag type is properly managed" { test "no dependency loop when function pointer in union returns the union" { 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 U = union(enum) { const U = @This(); @@ -1478,6 +1534,7 @@ test "no dependency loop when function pointer in union returns the union" { test "union reassignment can use previous value" { 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 U = union { a: u32, @@ -1493,6 +1550,7 @@ test "packed union with zero-bit field" { 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; const S = packed struct { nested: packed union { @@ -1512,6 +1570,7 @@ test "reinterpreting enum value inside packed union" { 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_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const U = packed union { tag: enum { a, b }, @@ -1529,6 +1588,7 @@ test "reinterpreting enum value inside packed union" { test "access the tag of a global tagged union" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const U = union(enum) { a, @@ -1540,6 +1600,7 @@ test "access the tag of a global tagged union" { test "coerce enum literal to union in result loc" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const U = union(enum) { a, diff --git a/test/behavior/union_with_members.zig b/test/behavior/union_with_members.zig index 8e9c2db475..1155d14924 100644 --- a/test/behavior/union_with_members.zig +++ b/test/behavior/union_with_members.zig @@ -21,6 +21,7 @@ test "enum with members" { 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 = ET{ .SINT = -42 }; const b = ET{ .UINT = 42 }; diff --git a/test/behavior/usingnamespace.zig b/test/behavior/usingnamespace.zig index de559f85f3..ca43f60e99 100644 --- a/test/behavior/usingnamespace.zig +++ b/test/behavior/usingnamespace.zig @@ -55,6 +55,7 @@ usingnamespace @import("usingnamespace/a.zig"); test "two files usingnamespace import each other" { 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; try expect(@This().ok()); } diff --git a/test/behavior/var_args.zig b/test/behavior/var_args.zig index 968b15b218..adb5491f7f 100644 --- a/test/behavior/var_args.zig +++ b/test/behavior/var_args.zig @@ -14,6 +14,8 @@ fn add(args: anytype) i32 { } test "add arbitrary args" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10); try expect(add(.{@as(i32, 1234)}) == 1234); try expect(add(.{}) == 0); @@ -30,6 +32,7 @@ test "send void arg to var args" { test "pass args directly" { 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; try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10); try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234); @@ -43,6 +46,7 @@ fn addSomeStuff(args: anytype) i32 { test "runtime parameter before var args" { 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; try expect((try extraFn(10, .{})) == 0); try expect((try extraFn(10, .{false})) == 1); @@ -99,6 +103,7 @@ test "simple variadic function" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.cpu.arch == .aarch64 and builtin.os.tag != .macos) { // https://github.com/ziglang/zig/issues/14096 return error.SkipZigTest; @@ -148,6 +153,7 @@ test "variadic functions" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.cpu.arch == .aarch64 and builtin.os.tag != .macos) { // https://github.com/ziglang/zig/issues/14096 return error.SkipZigTest; @@ -191,6 +197,7 @@ test "copy VaList" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.cpu.arch == .aarch64 and builtin.os.tag != .macos) { // https://github.com/ziglang/zig/issues/14096 return error.SkipZigTest; @@ -223,6 +230,7 @@ test "unused VaList arg" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.cpu.arch == .aarch64 and builtin.os.tag != .macos) { // https://github.com/ziglang/zig/issues/14096 return error.SkipZigTest; diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig index 41b0bfc39b..537879b5c9 100644 --- a/test/behavior/vector.zig +++ b/test/behavior/vector.zig @@ -11,6 +11,7 @@ test "implicit cast vector to array - bool" { 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 { @@ -29,6 +30,7 @@ test "vector wrap operators" { 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 { @@ -51,6 +53,7 @@ test "vector bin compares with mem.eql" { 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 { @@ -74,6 +77,7 @@ test "vector int operators" { 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 { @@ -95,6 +99,7 @@ test "vector float operators" { 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; inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| { const S = struct { @@ -118,6 +123,7 @@ test "vector bit operators" { 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 { @@ -136,6 +142,7 @@ test "implicit cast vector to array" { 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 { @@ -153,6 +160,7 @@ test "array to 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 { @@ -173,6 +181,7 @@ test "array to vector with element type coercion" { 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 { @@ -192,6 +201,7 @@ test "peer type resolution with coercible element types" { 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 { @@ -211,6 +221,7 @@ test "tuple to 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_llvm and builtin.cpu.arch == .aarch64) { // Regressed with LLVM 14: @@ -240,6 +251,7 @@ test "vector casts of sizes not divisible by 8" { 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 { @@ -274,6 +286,7 @@ test "vector @splat" { 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_llvm and builtin.os.tag == .macos) @@ -320,6 +333,7 @@ test "load vector elements via comptime index" { 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 { @@ -341,6 +355,7 @@ test "store vector elements via comptime index" { 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 { @@ -368,6 +383,7 @@ test "load vector elements via runtime index" { 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 { @@ -389,6 +405,7 @@ test "store vector elements via runtime index" { 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 { @@ -411,6 +428,7 @@ test "initialize vector which is a struct field" { 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 Vec4Obj = struct { data: @Vector(4, f32), @@ -434,6 +452,7 @@ test "vector comparison operators" { 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 { @@ -474,6 +493,7 @@ test "vector division operators" { 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 doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void { @@ -556,6 +576,7 @@ test "vector bitwise not operator" { 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 doTheTestNot(comptime T: type, x: @Vector(4, T)) !void { @@ -587,6 +608,7 @@ test "vector shift operators" { 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 doTheTestShift(x: anytype, y: anytype) !void { @@ -680,6 +702,7 @@ test "vector reduce operation" { 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 testReduce(comptime op: std.builtin.ReduceOp, x: anytype, expected: anytype) !void { @@ -837,6 +860,7 @@ test "mask parameter of @shuffle is comptime scope" { 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 __v4hi = @Vector(4, i16); var v4_a = __v4hi{ 0, 0, 0, 0 }; @@ -856,6 +880,7 @@ test "saturating add" { 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 { @@ -887,6 +912,7 @@ test "saturating subtraction" { 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 { @@ -909,6 +935,7 @@ test "saturating multiplication" { 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; // TODO: once #9660 has been solved, remove this line if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest; @@ -935,6 +962,7 @@ test "saturating shift-left" { 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 { @@ -957,6 +985,7 @@ test "multiplication-assignment operator with an array operand" { 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 { @@ -977,6 +1006,7 @@ 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 { @@ -1020,6 +1050,7 @@ test "@subWithOverflow" { 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 { @@ -1049,6 +1080,7 @@ test "@mulWithOverflow" { 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 { @@ -1069,6 +1101,7 @@ test "@shlWithOverflow" { 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 { @@ -1095,6 +1128,7 @@ test "loading the second vector from a slice of vectors" { 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) return error.SkipZigTest; // TODO @setRuntimeSafety(false); @@ -1113,6 +1147,7 @@ test "array of vectors is copied" { 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 Vec3 = @Vector(3, i32); var points = [_]Vec3{ @@ -1136,6 +1171,7 @@ test "byte vector initialized in inline 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; if (comptime builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.cpu.features.isEnabled(@enumToInt(std.Target.x86.Feature.avx512f))) @@ -1182,6 +1218,7 @@ test "zero multiplicand" { 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) return error.SkipZigTest; // TODO const zeros = @Vector(2, u32){ 0.0, 0.0 }; @@ -1206,6 +1243,7 @@ test "@intCast to u0" { 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; var zeros = @Vector(2, u32){ 0, 0 }; const casted = @intCast(@Vector(2, u0), zeros); @@ -1229,6 +1267,7 @@ test "array operands to shuffle are coerced to vectors" { 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 mask = [5]i32{ -1, 0, 1, 2, 3 }; @@ -1241,6 +1280,7 @@ test "load packed vector element" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO @@ -1253,6 +1293,7 @@ test "store packed vector element" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO @@ -1268,6 +1309,7 @@ test "store to vector in slice" { if (builtin.zig_backend == .stage2_wasm) 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; var v = [_]@Vector(3, f32){ .{ 1, 1, 1 }, @@ -1283,6 +1325,7 @@ test "addition of vectors represented as strings" { 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_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const V = @Vector(3, u8); const foo: V = "foo".*; diff --git a/test/behavior/void.zig b/test/behavior/void.zig index 8c6269123d..b726dbe004 100644 --- a/test/behavior/void.zig +++ b/test/behavior/void.zig @@ -20,6 +20,7 @@ test "compare void with void compile time known" { test "iterate over a void slice" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var j: usize = 0; for (times(10), 0..) |_, i| { @@ -36,6 +37,7 @@ test "void optional" { 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; var x: ?void = {}; try expect(x != null); diff --git a/test/behavior/while.zig b/test/behavior/while.zig index fc3c6e85d8..a6634b672f 100644 --- a/test/behavior/while.zig +++ b/test/behavior/while.zig @@ -5,6 +5,7 @@ const assert = std.debug.assert; test "while loop" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var i: i32 = 0; while (i < 4) { @@ -38,6 +39,8 @@ fn staticWhileLoop2() i32 { } test "while with continue expression" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var sum: i32 = 0; { var i: i32 = 0; @@ -50,6 +53,8 @@ test "while with continue expression" { } test "while with else" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var sum: i32 = 0; var i: i32 = 0; var got_else: i32 = 0; @@ -77,6 +82,8 @@ fn getNumberOrNull() ?i32 { } test "continue outer while loop" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + testContinueOuter(); comptime testContinueOuter(); } @@ -123,6 +130,7 @@ test "while copies its payload" { test "continue and break" { if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try runContinueAndBreakTest(); try expect(continue_and_break_counter == 8); @@ -144,6 +152,7 @@ fn runContinueAndBreakTest() !void { test "while with optional as condition" { 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; numbers_left = 10; var sum: i32 = 0; @@ -156,6 +165,7 @@ test "while with optional as condition" { test "while with optional as condition with else" { 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; numbers_left = 10; var sum: i32 = 0; @@ -172,6 +182,7 @@ test "while with optional as condition with else" { test "while with error union condition" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; numbers_left = 10; var sum: i32 = 0; @@ -215,6 +226,7 @@ test "while on optional with else result follow break prong" { 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; const result = while (returnOptional(10)) |value| { break value; @@ -242,6 +254,8 @@ fn returnTrue() bool { } test "return with implicit cast from while loop" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + returnWithImplicitCastFromWhileLoopTest() catch unreachable; } fn returnWithImplicitCastFromWhileLoopTest() anyerror!void { @@ -252,6 +266,7 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void { test "while on error union with else result follow else prong" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const result = while (returnError()) |value| { break value; @@ -261,6 +276,7 @@ test "while on error union with else result follow else prong" { test "while on error union with else result follow break prong" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const result = while (returnSuccess(10)) |value| { break value; @@ -306,6 +322,7 @@ test "while error 2 break statements and an else" { 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 { fn entry(opt_t: anyerror!bool, f: bool) !void { @@ -331,6 +348,8 @@ test "continue inline while loop" { } test "else continue outer while" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var i: usize = 0; while (true) { i += 1; @@ -343,6 +362,7 @@ test "else continue outer while" { test "try terminating an infinite loop" { 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; // Test coverage for https://github.com/ziglang/zig/issues/13546 const Foo = struct { diff --git a/test/behavior/widening.zig b/test/behavior/widening.zig index a4c1d1f78e..12076697d8 100644 --- a/test/behavior/widening.zig +++ b/test/behavior/widening.zig @@ -9,6 +9,7 @@ test "integer widening" { 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; var a: u8 = 250; var b: u16 = a; @@ -23,6 +24,8 @@ fn zero() u0 { return 0; } test "integer widening u0 to u8" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const a: u8 = zero(); try expect(a == 0); } @@ -30,6 +33,7 @@ test "integer widening u0 to u8" { test "implicit unsigned integer to signed integer" { 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; var a: u8 = 250; var b: i16 = a; @@ -42,6 +46,7 @@ test "float widening" { 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; var a: f16 = 12.34; var b: f32 = a; @@ -62,6 +67,7 @@ test "float widening f16 to f128" { 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; var x: f16 = 12.34; var y: f128 = x; @@ -72,6 +78,7 @@ test "cast small unsigned to larger signed" { 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; try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200)); try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999)); -- cgit v1.2.3 From 6e3770e970dbf460271a0e0cb60c2bf40a7c861e Mon Sep 17 00:00:00 2001 From: Robin Voetter Date: Thu, 18 May 2023 02:45:21 +0200 Subject: spirv: implement pointer comparison in for air cmp It turns out that the Khronos LLVM SPIRV translator does not support OpPtrEqual. Therefore, this instruction is emitted using a series of conversions. This commit breaks intToEnum, because enum was removed from the arithmetic type info. The enum should be converted to an int before this function is called. --- src/codegen/spirv.zig | 175 ++++++++++++++++++++++++++++++----------------- test/behavior/basic.zig | 17 ----- test/behavior/enum.zig | 2 + test/behavior/memcpy.zig | 20 +++--- 4 files changed, 127 insertions(+), 87 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index d1def8a02e..9cfac608a1 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -369,17 +369,6 @@ pub const DeclGen = struct { .composite_integer, }; }, - .Enum => blk: { - var buffer: Type.Payload.Bits = undefined; - const int_ty = ty.intTagType(&buffer); - const int_info = int_ty.intInfo(target); - break :blk ArithmeticTypeInfo{ - .bits = int_info.bits, - .is_vector = false, - .signedness = int_info.signedness, - .class = .integer, - }; - }, // As of yet, there is no vector support in the self-hosted compiler. .Vector => self.todo("implement arithmeticTypeInfo for Vector", .{}), // TODO: For which types is this the case? @@ -1742,12 +1731,12 @@ pub const DeclGen = struct { .struct_field_ptr_index_2 => try self.airStructFieldPtrIndex(inst, 2), .struct_field_ptr_index_3 => try self.airStructFieldPtrIndex(inst, 3), - .cmp_eq => try self.airCmp(inst, .OpFOrdEqual, .OpLogicalEqual, .OpIEqual), - .cmp_neq => try self.airCmp(inst, .OpFOrdNotEqual, .OpLogicalNotEqual, .OpINotEqual), - .cmp_gt => try self.airCmp(inst, .OpFOrdGreaterThan, .OpSGreaterThan, .OpUGreaterThan), - .cmp_gte => try self.airCmp(inst, .OpFOrdGreaterThanEqual, .OpSGreaterThanEqual, .OpUGreaterThanEqual), - .cmp_lt => try self.airCmp(inst, .OpFOrdLessThan, .OpSLessThan, .OpULessThan), - .cmp_lte => try self.airCmp(inst, .OpFOrdLessThanEqual, .OpSLessThanEqual, .OpULessThanEqual), + .cmp_eq => try self.airCmp(inst, .eq), + .cmp_neq => try self.airCmp(inst, .neq), + .cmp_gt => try self.airCmp(inst, .gt), + .cmp_gte => try self.airCmp(inst, .gte), + .cmp_lt => try self.airCmp(inst, .lt), + .cmp_lte => try self.airCmp(inst, .lte), .arg => self.airArg(), .alloc => try self.airAlloc(inst), @@ -2039,58 +2028,122 @@ pub const DeclGen = struct { return result_id; } - fn airCmp(self: *DeclGen, inst: Air.Inst.Index, comptime fop: Opcode, comptime sop: Opcode, comptime uop: Opcode) !?IdRef { - if (self.liveness.isUnused(inst)) return null; - const bin_op = self.air.instructions.items(.data)[inst].bin_op; - var lhs_id = try self.resolve(bin_op.lhs); - var rhs_id = try self.resolve(bin_op.rhs); - const result_id = self.spv.allocId(); - const result_type_id = try self.resolveTypeId(Type.bool); - const op_ty = self.air.typeOf(bin_op.lhs); - assert(op_ty.eql(self.air.typeOf(bin_op.rhs), self.module)); + fn cmp( + self: *DeclGen, + comptime op: std.math.CompareOperator, + bool_ty_id: IdRef, + ty: Type, + lhs_id: IdRef, + rhs_id: IdRef, + ) !IdRef { + var cmp_lhs_id = lhs_id; + var cmp_rhs_id = rhs_id; + const opcode: Opcode = opcode: { + var int_buffer: Type.Payload.Bits = undefined; + const op_ty = switch (ty.zigTypeTag()) { + .Int, .Bool, .Float => ty, + .Enum => ty.intTagType(&int_buffer), + .ErrorSet => Type.u16, + .Pointer => blk: { + // Note that while SPIR-V offers OpPtrEqual and OpPtrNotEqual, they are + // currently not implemented in the SPIR-V LLVM translator. Thus, we emit these using + // OpConvertPtrToU... + cmp_lhs_id = self.spv.allocId(); + cmp_rhs_id = self.spv.allocId(); + + const usize_ty_id = self.typeId(try self.sizeType()); + + try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{ + .id_result_type = usize_ty_id, + .id_result = cmp_lhs_id, + .pointer = lhs_id, + }); - // Comparisons are generally applicable to both scalar and vector operations in SPIR-V, - // but int and float versions of operations require different opcodes. - const info = try self.arithmeticTypeInfo(op_ty); + try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{ + .id_result_type = usize_ty_id, + .id_result = cmp_rhs_id, + .pointer = rhs_id, + }); - const opcode_index: usize = switch (info.class) { - .composite_integer => { - return self.todo("binary operations for composite integers", .{}); - }, - .float => 0, - .bool => 1, - .strange_integer => blk: { - const op_ty_ref = try self.resolveType(op_ty, .direct); - lhs_id = try self.maskStrangeInt(op_ty_ref, lhs_id, info.bits); - rhs_id = try self.maskStrangeInt(op_ty_ref, rhs_id, info.bits); - break :blk switch (info.signedness) { - .signed => @as(usize, 1), - .unsigned => @as(usize, 2), - }; - }, - .integer => switch (info.signedness) { - .signed => @as(usize, 1), - .unsigned => @as(usize, 2), - }, - }; + break :blk Type.usize; + }, + .Optional => unreachable, // TODO + else => unreachable, + }; - const operands = .{ - .id_result_type = result_type_id, - .id_result = result_id, - .operand_1 = lhs_id, - .operand_2 = rhs_id, - }; + const info = try self.arithmeticTypeInfo(op_ty); + const signedness = switch (info.class) { + .composite_integer => { + return self.todo("binary operations for composite integers", .{}); + }, + .float => break :opcode switch (op) { + .eq => .OpFOrdEqual, + .neq => .OpFOrdNotEqual, + .lt => .OpFOrdLessThan, + .lte => .OpFOrdLessThanEqual, + .gt => .OpFOrdGreaterThan, + .gte => .OpFOrdGreaterThanEqual, + }, + .bool => break :opcode switch (op) { + .eq => .OpIEqual, + .neq => .OpINotEqual, + else => unreachable, + }, + .strange_integer => sign: { + const op_ty_ref = try self.resolveType(op_ty, .direct); + // Mask operands before performing comparison. + cmp_lhs_id = try self.maskStrangeInt(op_ty_ref, cmp_lhs_id, info.bits); + cmp_rhs_id = try self.maskStrangeInt(op_ty_ref, cmp_rhs_id, info.bits); + break :sign info.signedness; + }, + .integer => info.signedness, + }; - switch (opcode_index) { - 0 => try self.func.body.emit(self.spv.gpa, fop, operands), - 1 => try self.func.body.emit(self.spv.gpa, sop, operands), - 2 => try self.func.body.emit(self.spv.gpa, uop, operands), - else => unreachable, - } + break :opcode switch (signedness) { + .unsigned => switch (op) { + .eq => .OpIEqual, + .neq => .OpINotEqual, + .lt => .OpULessThan, + .lte => .OpULessThanEqual, + .gt => .OpUGreaterThan, + .gte => .OpUGreaterThanEqual, + }, + .signed => switch (op) { + .eq => .OpIEqual, + .neq => .OpINotEqual, + .lt => .OpSLessThan, + .lte => .OpSLessThanEqual, + .gt => .OpSGreaterThan, + .gte => .OpSGreaterThanEqual, + }, + }; + }; + const result_id = self.spv.allocId(); + try self.func.body.emitRaw(self.spv.gpa, opcode, 4); + self.func.body.writeOperand(spec.IdResultType, bool_ty_id); + self.func.body.writeOperand(spec.IdResult, result_id); + self.func.body.writeOperand(spec.IdResultType, cmp_lhs_id); + self.func.body.writeOperand(spec.IdResultType, cmp_rhs_id); return result_id; } + fn airCmp( + self: *DeclGen, + inst: Air.Inst.Index, + comptime op: std.math.CompareOperator, + ) !?IdRef { + if (self.liveness.isUnused(inst)) return null; + const bin_op = self.air.instructions.items(.data)[inst].bin_op; + const lhs_id = try self.resolve(bin_op.lhs); + const rhs_id = try self.resolve(bin_op.rhs); + const bool_ty_id = try self.resolveTypeId(Type.bool); + const ty = self.air.typeOf(bin_op.lhs); + assert(ty.eql(self.air.typeOf(bin_op.rhs), self.module)); + + return try self.cmp(op, bool_ty_id, ty, lhs_id, rhs_id); + } + fn bitcast(self: *DeclGen, target_type_id: IdResultType, value_id: IdRef) !IdRef { const result_id = self.spv.allocId(); try self.func.body.emit(self.spv.gpa, .OpBitcast, .{ diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 0de278fc57..756d62f3ab 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -134,21 +134,18 @@ fn first4KeysOfHomeRow() []const u8 { test "return string from function" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu")); } test "hex escape" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello")); } test "multiline string" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -161,7 +158,6 @@ test "multiline string" { test "multiline string comments at start" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = //\\one @@ -174,7 +170,6 @@ test "multiline string comments at start" { test "multiline string comments at end" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -187,7 +182,6 @@ test "multiline string comments at end" { test "multiline string comments in middle" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -200,7 +194,6 @@ test "multiline string comments in middle" { test "multiline string comments at multiple places" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -214,14 +207,11 @@ test "multiline string comments at multiple places" { } test "string concatenation simple" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED")); } test "array mult operator" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, "ab" ** 5, "ababababab")); } @@ -387,7 +377,6 @@ test "take address of parameter" { 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 testTakeAddressOfParameter(12.34); } @@ -690,8 +679,6 @@ test "explicit cast optional pointers" { } test "pointer comparison" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const a = @as([]const u8, "a"); const b = &a; try expect(ptrEql(b, b)); @@ -892,8 +879,6 @@ test "catch in block has correct result location" { } test "labeled block with runtime branch forwards its result location type to break statements" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const E = enum { a, b }; var a = false; const e: E = blk: { @@ -1062,8 +1047,6 @@ test "switch inside @as gets correct type" { } test "inline call of function with a switch inside the return statement" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { inline fn foo(x: anytype) @TypeOf(x) { return switch (x) { diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index 097caaad19..44a6026f2b 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -20,6 +20,8 @@ test "enum to int" { } fn testIntToEnumEval(x: i32) !void { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + try expect(@intToEnum(IntToEnumNumber, x) == IntToEnumNumber.Three); } const IntToEnumNumber = enum { Zero, One, Two, Three, Four }; diff --git a/test/behavior/memcpy.zig b/test/behavior/memcpy.zig index af86c09113..b7c5eb29d9 100644 --- a/test/behavior/memcpy.zig +++ b/test/behavior/memcpy.zig @@ -67,14 +67,16 @@ fn testMemcpyDestManyPtr() !void { } comptime { - const S = struct { - buffer: [8]u8 = undefined, - fn set(self: *@This(), items: []const u8) void { - @memcpy(self.buffer[0..items.len], items); - } - }; + if (builtin.zig_backend != .stage2_spirv64) { + const S = struct { + buffer: [8]u8 = undefined, + fn set(self: *@This(), items: []const u8) void { + @memcpy(self.buffer[0..items.len], items); + } + }; - var s = S{}; - s.set("hello"); - if (!std.mem.eql(u8, s.buffer[0..5], "hello")) @compileError("bad"); + var s = S{}; + s.set("hello"); + if (!std.mem.eql(u8, s.buffer[0..5], "hello")) @compileError("bad"); + } } -- cgit v1.2.3 From 0ba0d8fecb255cf19a225e4cb160921d73f83652 Mon Sep 17 00:00:00 2001 From: Robin Voetter Date: Thu, 18 May 2023 17:39:43 +0200 Subject: spirv: dont use OpIAddCarry This instruction is not really working well in the LLVM SPIRV translator, as it is not implemented. This commit also intruces the constructStruct helper function to initialize structs at runtime. This is ALSO buggy in the translator, and we must work around OpCompositeConstruct not working when some of the constituents are runtime-known only. Some other improvements are made: - improved variable() so that it is more useful and no longer requires the address space. It always puts values in the Function address space, and returns a pointer to the Generic address space - adds a boolToInt utility function --- src/codegen/spirv.zig | 289 +++++++++++++++++++++++++----------------------- test/behavior/basic.zig | 7 -- test/behavior/math.zig | 2 - 3 files changed, 153 insertions(+), 145 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index 5edafc5037..b86b4193ab 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -442,6 +442,43 @@ pub const DeclGen = struct { } } + /// Construct a struct at runtime. + /// result_ty_ref must be a struct type. + fn constructStruct(self: *DeclGen, result_ty_ref: SpvType.Ref, constituents: []const IdRef) !IdRef { + // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which' + // operands are not constant. + // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349 + // For now, just initialize the struct by setting the fields manually... + // TODO: Make this OpCompositeConstruct when we can + const ptr_composite_id = try self.alloc(result_ty_ref, null); + // Note: using 32-bit ints here because usize crashes the translator as well + const index_ty_ref = try self.intType(.unsigned, 32); + const spv_composite_ty = self.spv.typeRefType(result_ty_ref); + const members = spv_composite_ty.payload(.@"struct").members; + for (constituents, members, 0..) |constitent_id, member, index| { + const index_id = try self.constInt(index_ty_ref, index); + const ptr_id = self.spv.allocId(); + const ptr_member_ty_ref = try self.spv.ptrType(member.ty, .Generic, 0); + try self.func.body.emit(self.spv.gpa, .OpInBoundsAccessChain, .{ + .id_result_type = self.typeId(ptr_member_ty_ref), + .id_result = ptr_id, + .base = ptr_composite_id, + .indexes = &.{index_id}, + }); + try self.func.body.emit(self.spv.gpa, .OpStore, .{ + .pointer = ptr_id, + .object = constitent_id, + }); + } + const result_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpLoad, .{ + .id_result_type = self.typeId(result_ty_ref), + .id_result = result_id, + .pointer = ptr_composite_id, + }); + return result_id; + } + const IndirectConstantLowering = struct { const undef = 0xAA; @@ -1582,6 +1619,20 @@ pub const DeclGen = struct { } } + fn boolToInt(self: *DeclGen, result_ty_ref: SpvType.Ref, condition_id: IdRef) !IdRef { + const zero_id = try self.constInt(result_ty_ref, 0); + const one_id = try self.constInt(result_ty_ref, 1); + const result_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpSelect, .{ + .id_result_type = self.typeId(result_ty_ref), + .id_result = result_id, + .condition = condition_id, + .object_1 = one_id, + .object_2 = zero_id, + }); + return result_id; + } + /// Convert representation from indirect (in memory) to direct (in 'register') /// This converts the argument type from resolveType(ty, .indirect) to resolveType(ty, .direct). fn convertToDirect(self: *DeclGen, ty: Type, operand_id: IdRef) !IdRef { @@ -1610,17 +1661,7 @@ pub const DeclGen = struct { return switch (ty.zigTypeTag()) { .Bool => blk: { const indirect_bool_ty_ref = try self.resolveType(ty, .indirect); - const zero_id = try self.constInt(indirect_bool_ty_ref, 0); - const one_id = try self.constInt(indirect_bool_ty_ref, 1); - const result_id = self.spv.allocId(); - try self.func.body.emit(self.spv.gpa, .OpSelect, .{ - .id_result_type = self.typeId(indirect_bool_ty_ref), - .id_result = result_id, - .condition = operand_id, - .object_1 = one_id, - .object_2 = zero_id, - }); - break :blk result_id; + break :blk self.boolToInt(indirect_bool_ty_ref, operand_id); }, else => operand_id, }; @@ -1933,64 +1974,83 @@ pub const DeclGen = struct { .float, .bool => unreachable, } - // The operand type must be the same as the result type in SPIR-V. + // The operand type must be the same as the result type in SPIR-V, which + // is the same as in Zig. const operand_ty_ref = try self.resolveType(operand_ty, .direct); const operand_ty_id = self.typeId(operand_ty_ref); - const op_result_id = blk: { - // Construct the SPIR-V result type. - // It is almost the same as the zig one, except that the fields must be the same type - // and they must be unsigned. - const overflow_result_ty_ref = try self.spv.simpleStructType(&.{ - .{ .ty = operand_ty_ref, .name = "res" }, - .{ .ty = operand_ty_ref, .name = "ov" }, - }); - const result_id = self.spv.allocId(); - try self.func.body.emit(self.spv.gpa, .OpIAddCarry, .{ - .id_result_type = self.typeId(overflow_result_ty_ref), - .id_result = result_id, - .operand_1 = lhs, - .operand_2 = rhs, - }); - break :blk result_id; - }; - - // Now convert the SPIR-V flavor result into a Zig-flavor result. - // First, extract the two fields. - const unsigned_result = try self.extractField(operand_ty, op_result_id, 0); - const overflow = try self.extractField(operand_ty, op_result_id, 1); - - // We need to convert the results to the types that Zig expects here. - // The `result` is the same type except unsigned, so we can just bitcast that. - // TODO: This can be removed in Kernels as there are only unsigned ints. Maybe for - // shaders as well? - const result = try self.bitcast(operand_ty_id, unsigned_result); - - // The overflow needs to be converted into whatever is used to represent it in Zig. - const casted_overflow = blk: { - const ov_ty = result_ty.tupleFields().types[1]; - const ov_ty_id = try self.resolveTypeId(ov_ty); - const result_id = self.spv.allocId(); - try self.func.body.emit(self.spv.gpa, .OpUConvert, .{ - .id_result_type = ov_ty_id, - .id_result = result_id, - .unsigned_value = overflow, - }); - break :blk result_id; - }; + const bool_ty_ref = try self.resolveType(Type.bool, .direct); - // TODO: If copying this function for borrow, make sure to convert -1 to 1 as appropriate. + const ov_ty = result_ty.tupleFields().types[1]; + // Note: result is stored in a struct, so indirect representation. + const ov_ty_ref = try self.resolveType(ov_ty, .indirect); - // Finally, construct the Zig type. - // Layout is result, overflow. - const result_id = self.spv.allocId(); - const constituents = [_]IdRef{ result, casted_overflow }; - try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{ + // TODO: Operations other than addition. + const value_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpIAdd, .{ .id_result_type = operand_ty_id, - .id_result = result_id, - .constituents = &constituents, + .id_result = value_id, + .operand_1 = lhs, + .operand_2 = rhs, + }); + + const overflowed_id = switch (info.signedness) { + .unsigned => blk: { + // Overflow happened if the result is smaller than either of the operands. It doesn't matter which. + const overflowed_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpULessThan, .{ + .id_result_type = self.typeId(bool_ty_ref), + .id_result = overflowed_id, + .operand_1 = value_id, + .operand_2 = lhs, + }); + break :blk overflowed_id; + }, + .signed => blk: { + // Overflow happened if: + // - rhs is negative and value > lhs + // - rhs is positive and value < lhs + // This can be shortened to: + // (rhs < 0 && value > lhs) || (rhs >= 0 && value <= lhs) + // = (rhs < 0) == (value > lhs) + // Note that signed overflow is also wrapping in spir-v. + + const rhs_lt_zero_id = self.spv.allocId(); + const zero_id = try self.constInt(operand_ty_ref, 0); + try self.func.body.emit(self.spv.gpa, .OpSLessThan, .{ + .id_result_type = self.typeId(bool_ty_ref), + .id_result = rhs_lt_zero_id, + .operand_1 = rhs, + .operand_2 = zero_id, + }); + + const value_gt_lhs_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpSGreaterThan, .{ + .id_result_type = self.typeId(bool_ty_ref), + .id_result = value_gt_lhs_id, + .operand_1 = value_id, + .operand_2 = lhs, + }); + + const overflowed_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpLogicalEqual, .{ + .id_result_type = self.typeId(bool_ty_ref), + .id_result = overflowed_id, + .operand_1 = rhs_lt_zero_id, + .operand_2 = value_gt_lhs_id, + }); + break :blk overflowed_id; + }, + }; + + // Construct the struct that Zig wants as result. + // The value should already be the correct type. + const ov_id = try self.boolToInt(ov_ty_ref, overflowed_id); + const result_ty_ref = try self.resolveType(result_ty, .direct); + return try self.constructStruct(result_ty_ref, &.{ + value_id, + ov_id, }); - return result_id; } fn airShuffle(self: *DeclGen, inst: Air.Inst.Index) !?IdRef { @@ -2463,76 +2523,45 @@ pub const DeclGen = struct { return result_id; } - fn variable( + // Allocate a function-local variable, with possible initializer. + // This function returns a pointer to a variable of type `ty_ref`, + // which is in the Generic address space. The variable is actually + // placed in the Function address space. + fn alloc( self: *DeclGen, - comptime context: enum { function, global }, - result_id: IdRef, - ptr_ty_ref: SpvType.Ref, + ty_ref: SpvType.Ref, initializer: ?IdRef, - ) !void { - const storage_class = self.spv.typeRefType(ptr_ty_ref).payload(.pointer).storage_class; - const actual_storage_class = switch (storage_class) { - .Generic => switch (context) { - .function => .Function, - .global => .CrossWorkgroup, - }, - else => storage_class, - }; - const actual_ptr_ty_ref = switch (storage_class) { - .Generic => try self.spv.changePtrStorageClass(ptr_ty_ref, actual_storage_class), - else => ptr_ty_ref, - }; - const alloc_result_id = switch (storage_class) { - .Generic => self.spv.allocId(), - else => result_id, - }; + ) !IdRef { + const fn_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Function, 0); + const general_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Generic, 0); - const section = switch (actual_storage_class) { - .Generic => unreachable, - // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to - // directly generate them into func.prologue instead of the body. - .Function => &self.func.prologue, - else => &self.spv.sections.types_globals_constants, - }; - try section.emit(self.spv.gpa, .OpVariable, .{ - .id_result_type = self.typeId(actual_ptr_ty_ref), - .id_result = alloc_result_id, - .storage_class = actual_storage_class, + // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to + // directly generate them into func.prologue instead of the body. + const var_id = self.spv.allocId(); + try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{ + .id_result_type = self.typeId(fn_ptr_ty_ref), + .id_result = var_id, + .storage_class = .Function, .initializer = initializer, }); - if (storage_class != .Generic) { - return; - } - - // Now we need to convert the pointer. - // If this is a function local, we need to perform the conversion at runtime. Otherwise, we can do - // it ahead of time using OpSpecConstantOp. - switch (actual_storage_class) { - .Function => try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{ - .id_result_type = self.typeId(ptr_ty_ref), - .id_result = result_id, - .pointer = alloc_result_id, - }), - // TODO: Can we do without this cast or move it to runtime? - else => { - const const_ptr_id = try self.makePointerConstant(section, actual_ptr_ty_ref, alloc_result_id); - try section.emitSpecConstantOp(self.spv.gpa, .OpPtrCastToGeneric, .{ - .id_result_type = self.typeId(ptr_ty_ref), - .id_result = result_id, - .pointer = const_ptr_id, - }); - }, - } + // Convert to a generic pointer + const result_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{ + .id_result_type = self.typeId(general_ptr_ty_ref), + .id_result = result_id, + .pointer = var_id, + }); + return result_id; } fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef { if (self.liveness.isUnused(inst)) return null; - const ty = self.air.typeOfIndex(inst); - const result_ty_ref = try self.resolveType(ty, .direct); - const result_id = self.spv.allocId(); - try self.variable(.function, result_id, result_ty_ref, null); - return result_id; + const ptr_ty = self.air.typeOfIndex(inst); + assert(ptr_ty.ptrAddressSpace() == .generic); + const child_ty = ptr_ty.childType(); + const child_ty_ref = try self.resolveType(child_ty, .indirect); + return try self.alloc(child_ty_ref, null); } fn airArg(self: *DeclGen) IdRef { @@ -2819,13 +2848,7 @@ pub const DeclGen = struct { } const err_union_ty_ref = try self.resolveType(err_union_ty, .direct); - const result_id = self.spv.allocId(); - try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{ - .id_result_type = self.typeId(err_union_ty_ref), - .id_result = result_id, - .constituents = members.slice(), - }); - return result_id; + return try self.constructStruct(err_union_ty_ref, members.slice()); } fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef { @@ -2925,14 +2948,8 @@ pub const DeclGen = struct { } const optional_ty_ref = try self.resolveType(optional_ty, .direct); - const result_id = self.spv.allocId(); const members = [_]IdRef{ operand_id, try self.constBool(true, .indirect) }; - try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{ - .id_result_type = self.typeId(optional_ty_ref), - .id_result = result_id, - .constituents = &members, - }); - return result_id; + return try self.constructStruct(optional_ty_ref, &members); } fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void { diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 756d62f3ab..9fced18915 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -82,8 +82,6 @@ test "type equality" { } test "pointer dereferencing" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var x = @as(i32, 3); const y = &x; @@ -293,8 +291,6 @@ test "function closes over local const" { } test "volatile load and store" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var number: i32 = 1234; const ptr = @as(*volatile i32, &number); ptr.* += 1; @@ -466,7 +462,6 @@ fn nine() u8 { test "struct inside function" { 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; try testStructInFn(); comptime try testStructInFn(); @@ -691,7 +686,6 @@ test "string concatenation" { 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; const a = "OK" ++ " IT " ++ "WORKED"; const b = "OK IT WORKED"; @@ -1130,7 +1124,6 @@ test "returning an opaque type from a function" { test "orelse coercion as function argument" { 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 Loc = struct { start: i32 = -1 }; const Container = struct { diff --git a/test/behavior/math.zig b/test/behavior/math.zig index cc85594c50..01aec23223 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -208,7 +208,6 @@ test "float equality" { 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 x: f64 = 0.012; const y: f64 = x + 1.0; @@ -685,7 +684,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; { var a: u8 = 250; -- cgit v1.2.3 From 64f99f36a6d960a97d241c3235653c464f7ac6b2 Mon Sep 17 00:00:00 2001 From: Robin Voetter Date: Thu, 18 May 2023 19:25:52 +0200 Subject: spirv: ptr_add Implements the ptr_add air tag for spirv. The implementation for slices is probably wrong, but there seems to be no test for this... --- src/codegen/spirv.zig | 29 +++++++++++++++++++++++++++++ test/behavior/basic.zig | 1 - 2 files changed, 29 insertions(+), 1 deletion(-) (limited to 'test/behavior/basic.zig') diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index 51cfba1a28..bf75fee3fd 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -1738,6 +1738,8 @@ pub const DeclGen = struct { .shuffle => try self.airShuffle(inst), + .ptr_add => try self.airPtrAdd(inst), + .bit_and => try self.airBinOpSimple(inst, .OpBitwiseAnd), .bit_or => try self.airBinOpSimple(inst, .OpBitwiseOr), .xor => try self.airBinOpSimple(inst, .OpBitwiseXor), @@ -2120,6 +2122,33 @@ pub const DeclGen = struct { return result_id; } + fn airPtrAdd(self: *DeclGen, inst: Air.Inst.Index) !?IdRef { + if (self.liveness.isUnused(inst)) return null; + const ty_pl = self.air.instructions.items(.data)[inst].ty_pl; + const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data; + const ptr_id = try self.resolve(bin_op.lhs); + const offset_id = try self.resolve(bin_op.rhs); + const ptr_ty = self.air.typeOf(bin_op.lhs); + const result_ty = self.air.typeOfIndex(inst); + const result_ty_ref = try self.resolveType(result_ty, .direct); + + switch (ptr_ty.ptrSize()) { + .One => { + // Pointer to array + // TODO: Is this correct? + return try self.accessChain(result_ty_ref, ptr_id, &.{offset_id}); + }, + .C, .Many => { + return try self.ptrAccessChain(result_ty_ref, ptr_id, offset_id, &.{}); + }, + .Slice => { + // TODO: This is probably incorrect. A slice should be returned here, though this is what llvm does. + const slice_ptr_id = try self.extractField(result_ty, ptr_id, 0); + return try self.ptrAccessChain(result_ty_ref, slice_ptr_id, offset_id, &.{}); + }, + } + } + fn cmp( self: *DeclGen, comptime op: std.math.CompareOperator, diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 9fced18915..7f9e2ae78a 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -751,7 +751,6 @@ fn maybe(x: bool) anyerror!?u32 { test "auto created variables have correct alignment" { 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 { fn foo(str: [*]const u8) u32 { -- cgit v1.2.3 From 37aa343079d32db96be742c9740f343ff8d2839e Mon Sep 17 00:00:00 2001 From: Robin Voetter Date: Fri, 19 May 2023 11:23:22 +0200 Subject: spirv: more passing tests --- test/behavior/align.zig | 4 ---- test/behavior/array.zig | 2 -- test/behavior/atomics.zig | 2 -- test/behavior/basic.zig | 2 +- test/behavior/bitcast.zig | 1 - test/behavior/bitreverse.zig | 1 - test/behavior/call.zig | 3 --- test/behavior/cast.zig | 2 -- test/behavior/decltest.zig | 2 -- test/behavior/defer.zig | 3 --- test/behavior/duplicated_test_names.zig | 2 -- test/behavior/enum.zig | 1 - test/behavior/error.zig | 1 - test/behavior/eval.zig | 1 - test/behavior/floatop.zig | 1 - test/behavior/fn.zig | 2 -- test/behavior/fn_delegation.zig | 1 - test/behavior/fn_in_struct_in_comptime.zig | 2 -- test/behavior/for.zig | 2 -- test/behavior/generics.zig | 2 -- test/behavior/if.zig | 2 -- test/behavior/inttoptr.zig | 1 - test/behavior/maximum_minimum.zig | 2 -- test/behavior/optional.zig | 1 - test/behavior/packed-struct.zig | 1 - test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig | 1 - test/behavior/reflection.zig | 1 - test/behavior/sizeof_and_typeof.zig | 2 -- test/behavior/slice.zig | 2 -- test/behavior/struct.zig | 1 - test/behavior/switch.zig | 1 - test/behavior/this.zig | 2 -- test/behavior/threadlocal.zig | 1 - test/behavior/type.zig | 1 - test/behavior/type_info.zig | 1 - test/behavior/undefined.zig | 1 - test/behavior/union.zig | 2 -- test/behavior/var_args.zig | 2 -- test/behavior/while.zig | 1 - 39 files changed, 1 insertion(+), 62 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/test/behavior/align.zig b/test/behavior/align.zig index 4bd6666696..bc1091ace7 100644 --- a/test/behavior/align.zig +++ b/test/behavior/align.zig @@ -33,8 +33,6 @@ test "default alignment allows unspecified in type syntax" { } test "implicitly decreasing pointer alignment" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const a: u32 align(4) = 3; const b: u32 align(8) = 4; try expect(addUnaligned(&a, &b) == 7); @@ -45,8 +43,6 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 { } test "@alignCast pointers" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var x: u32 align(4) = 1; expectsOnly1(&x); try expect(x == 2); diff --git a/test/behavior/array.zig b/test/behavior/array.zig index b4754a59a4..ed8b021613 100644 --- a/test/behavior/array.zig +++ b/test/behavior/array.zig @@ -347,7 +347,6 @@ test "read/write through global variable array of struct fields initialized via test "implicit cast single-item pointer" { 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; try testImplicitCastSingleItemPtr(); comptime try testImplicitCastSingleItemPtr(); @@ -542,7 +541,6 @@ test "sentinel element count towards the ABI size calculation" { 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/atomics.zig b/test/behavior/atomics.zig index d1b51207a4..99f08a6cae 100644 --- a/test/behavior/atomics.zig +++ b/test/behavior/atomics.zig @@ -120,7 +120,6 @@ test "128-bit cmpxchg" { 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_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try test_u128_cmpxchg(); comptime try test_u128_cmpxchg(); @@ -313,7 +312,6 @@ test "atomicrmw with 128-bit ints" { 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_spirv64) return error.SkipZigTest; // TODO "ld.lld: undefined symbol: __sync_lock_test_and_set_16" on -mcpu x86_64 if (builtin.cpu.arch == .x86_64 and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 7f9e2ae78a..3024ad58c0 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -583,7 +583,7 @@ test "comptime cast fn to ptr" { } test "equality compare fn ptrs" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Test passes but should not var a = &emptyFn; try expect(a == a); diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig index 4b8c363ac2..28eb00c6c1 100644 --- a/test/behavior/bitcast.zig +++ b/test/behavior/bitcast.zig @@ -9,7 +9,6 @@ const native_endian = builtin.target.cpu.arch.endian(); test "@bitCast iX -> uX (32, 64)" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const bit_values = [_]usize{ 32, 64 }; diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig index 87cea942d0..8d98f65b55 100644 --- a/test/behavior/bitreverse.zig +++ b/test/behavior/bitreverse.zig @@ -5,7 +5,6 @@ const minInt = std.math.minInt; test "@bitReverse large exotic integer" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624); } diff --git a/test/behavior/call.zig b/test/behavior/call.zig index e7d59d7e75..76225d815d 100644 --- a/test/behavior/call.zig +++ b/test/behavior/call.zig @@ -109,7 +109,6 @@ test "result location of function call argument through runtime condition and st test "function call with 40 arguments" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(thirty_nine: i32) !void { @@ -374,8 +373,6 @@ test "Enum constructed by @Type passed as generic argument" { } test "generic function with generic function parameter" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { fn f(comptime a: fn (anytype) anyerror!void, b: anytype) anyerror!void { try a(b); diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index 847abc1798..f3a64b4b7c 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -366,7 +366,6 @@ test "return u8 coercing into ?u32 return type" { 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; const S = struct { fn doTheTest() !void { @@ -428,7 +427,6 @@ test "peer resolve array and const slice" { 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_spirv64) return error.SkipZigTest; try testPeerResolveArrayConstSlice(true); comptime try testPeerResolveArrayConstSlice(true); diff --git a/test/behavior/decltest.zig b/test/behavior/decltest.zig index 7aa8fb6318..b01a431e28 100644 --- a/test/behavior/decltest.zig +++ b/test/behavior/decltest.zig @@ -5,7 +5,5 @@ pub fn the_add_function(a: u32, b: u32) u32 { } test the_add_function { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (the_add_function(1, 2) != 3) unreachable; } diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig index 5aa8c2f02b..c97350cd75 100644 --- a/test/behavior/defer.zig +++ b/test/behavior/defer.zig @@ -23,8 +23,6 @@ fn testBreakContInDefer(x: usize) void { } test "defer and labeled break" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var i = @as(usize, 0); blk: { @@ -58,7 +56,6 @@ test "return variable while defer expression in scope to modify it" { 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; const S = struct { fn doTheTest() !void { diff --git a/test/behavior/duplicated_test_names.zig b/test/behavior/duplicated_test_names.zig index 81b9ebdf50..52930ea318 100644 --- a/test/behavior/duplicated_test_names.zig +++ b/test/behavior/duplicated_test_names.zig @@ -15,7 +15,5 @@ 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/enum.zig b/test/behavior/enum.zig index 097caaad19..255efc50fc 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -1046,7 +1046,6 @@ test "tag name with assigned enum values" { test "@tagName on enum literals" { 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; try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); diff --git a/test/behavior/error.zig b/test/behavior/error.zig index 54d53eec4a..89ce094010 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -16,7 +16,6 @@ fn expectError(expected_err: anyerror, observed_err_union: anytype) !void { } test "error values" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a = @errorToInt(error.err1); const b = @errorToInt(error.err2); try expect(a != b); diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig index d22eba4fa0..cd913dcc9a 100644 --- a/test/behavior/eval.zig +++ b/test/behavior/eval.zig @@ -23,7 +23,6 @@ test "static add one" { 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; try expect(should_be_1235 == 1235); } diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig index 21fc87ff22..97054b7083 100644 --- a/test/behavior/floatop.zig +++ b/test/behavior/floatop.zig @@ -506,7 +506,6 @@ test "@fabs" { 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; comptime try testFabs(); try testFabs(); diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig index c84eb48d2e..608b992eb3 100644 --- a/test/behavior/fn.zig +++ b/test/behavior/fn.zig @@ -5,8 +5,6 @@ const expect = testing.expect; const expectEqual = testing.expectEqual; test "params" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(testParamsAdd(22, 11) == 33); } fn testParamsAdd(a: i32, b: i32) i32 { diff --git a/test/behavior/fn_delegation.zig b/test/behavior/fn_delegation.zig index d7a2ba2125..95dbfeb4b2 100644 --- a/test/behavior/fn_delegation.zig +++ b/test/behavior/fn_delegation.zig @@ -34,7 +34,6 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 { test "fn delegation" { 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 foo = Foo{}; try expect(foo.one() == 11); diff --git a/test/behavior/fn_in_struct_in_comptime.zig b/test/behavior/fn_in_struct_in_comptime.zig index 427b08e6a4..a7d8e779cc 100644 --- a/test/behavior/fn_in_struct_in_comptime.zig +++ b/test/behavior/fn_in_struct_in_comptime.zig @@ -13,8 +13,6 @@ fn get_foo() fn (*u8) usize { } test "define a function in an anonymous struct in comptime" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const foo = get_foo(); try expect(foo(@intToPtr(*u8, 12345)) == 12345); } diff --git a/test/behavior/for.zig b/test/behavior/for.zig index 8c9eeb083e..c99ee2edeb 100644 --- a/test/behavior/for.zig +++ b/test/behavior/for.zig @@ -22,8 +22,6 @@ test "continue in for loop" { } test "break from outer for loop" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try testBreakOuter(); comptime try testBreakOuter(); } diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig index e8d064154b..eddca9e7b1 100644 --- a/test/behavior/generics.zig +++ b/test/behavior/generics.zig @@ -5,8 +5,6 @@ const expect = testing.expect; const expectEqual = testing.expectEqual; test "one param, explicit comptime" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var x: usize = 0; x += checkSize(i32); x += checkSize(bool); diff --git a/test/behavior/if.zig b/test/behavior/if.zig index 7369435cd3..c17f2c9891 100644 --- a/test/behavior/if.zig +++ b/test/behavior/if.zig @@ -71,8 +71,6 @@ test "labeled break inside comptime if inside runtime if" { } test "const result loc, runtime if cond, else unreachable" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const Num = enum { One, Two }; var t = true; diff --git a/test/behavior/inttoptr.zig b/test/behavior/inttoptr.zig index a05ed83b9b..29a263b2ce 100644 --- a/test/behavior/inttoptr.zig +++ b/test/behavior/inttoptr.zig @@ -14,7 +14,6 @@ test "mutate through ptr initialized with constant intToPtr value" { 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; forceCompilerAnalyzeBranchHardCodedPtrDereference(false); } diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig index db6cad221f..648d4d9493 100644 --- a/test/behavior/maximum_minimum.zig +++ b/test/behavior/maximum_minimum.zig @@ -129,8 +129,6 @@ test "@min/max for floats" { } test "@min/@max on lazy values" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const A = extern struct { u8_4: [4]u8 }; const B = extern struct { u8_16: [16]u8 }; const size = @max(@sizeOf(A), @sizeOf(B)); diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig index e62065cf25..a813580a20 100644 --- a/test/behavior/optional.zig +++ b/test/behavior/optional.zig @@ -8,7 +8,6 @@ const expectEqualStrings = std.testing.expectEqualStrings; test "passing an optional integer as a parameter" { 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 entry() bool { diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig index 36e37786f1..7406c22f46 100644 --- a/test/behavior/packed-struct.zig +++ b/test/behavior/packed-struct.zig @@ -7,7 +7,6 @@ const native_endian = builtin.cpu.arch.endian(); test "flags in packed structs" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const Flags1 = packed struct { // first 8 bits diff --git a/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig b/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig index 41d7f56662..bb6d5b1359 100644 --- a/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig +++ b/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig @@ -8,7 +8,6 @@ test "reference a variable in an if after an if in the 2nd switch prong" { 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; try foo(true, Num.Two, false, "aoeu"); try expect(!ok); diff --git a/test/behavior/reflection.zig b/test/behavior/reflection.zig index b62838f243..aea84bc45a 100644 --- a/test/behavior/reflection.zig +++ b/test/behavior/reflection.zig @@ -28,7 +28,6 @@ fn dummy(a: bool, b: i32, c: f32) i32 { test "reflection: @field" { 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; var f = Foo{ .one = 42, diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig index e01e20e544..3f70f02fcb 100644 --- a/test/behavior/sizeof_and_typeof.zig +++ b/test/behavior/sizeof_and_typeof.zig @@ -140,8 +140,6 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" { } test "@TypeOf() has no runtime side effects" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { fn foo(comptime T: type, ptr: *T) T { ptr.* += 1; diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig index 3b88636dca..dc27328e6d 100644 --- a/test/behavior/slice.zig +++ b/test/behavior/slice.zig @@ -201,8 +201,6 @@ test "slicing pointer by length" { const x = @intToPtr([*]i32, 0x1000)[0..0x500]; const y = x[0x100..]; test "compile time slice of pointer to hard coded address" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(@ptrToInt(x) == 0x1000); try expect(x.len == 0x500); diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index 659acbf56b..a4a24ef3b3 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -11,7 +11,6 @@ top_level_field: i32, test "top level fields" { 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; var instance = @This(){ .top_level_field = 1234, diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig index f66446632b..dd096f89ed 100644 --- a/test/behavior/switch.zig +++ b/test/behavior/switch.zig @@ -215,7 +215,6 @@ fn poll() void { test "switch on global mutable var isn't constant-folded" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; while (state < 2) { poll(); diff --git a/test/behavior/this.zig b/test/behavior/this.zig index 8fd8af92a3..0bc765c8a7 100644 --- a/test/behavior/this.zig +++ b/test/behavior/this.zig @@ -21,8 +21,6 @@ fn add(x: i32, y: i32) i32 { } test "this refer to module call private fn" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(module.add(1, 2) == 3); } diff --git a/test/behavior/threadlocal.zig b/test/behavior/threadlocal.zig index a1214fff21..57740f75ce 100644 --- a/test/behavior/threadlocal.zig +++ b/test/behavior/threadlocal.zig @@ -11,7 +11,6 @@ test "thread local variable" { else => 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 { threadlocal var t: i32 = 1234; diff --git a/test/behavior/type.zig b/test/behavior/type.zig index 936d9663ad..2fff4b05af 100644 --- a/test/behavior/type.zig +++ b/test/behavior/type.zig @@ -491,7 +491,6 @@ test "Type.Fn" { 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const some_opaque = opaque {}; const some_ptr = *some_opaque; diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig index d55688c5ee..18b65b755e 100644 --- a/test/behavior/type_info.zig +++ b/test/behavior/type_info.zig @@ -285,7 +285,6 @@ fn testUnion() !void { test "type info: struct info" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testStruct(); comptime try testStruct(); diff --git a/test/behavior/undefined.zig b/test/behavior/undefined.zig index e0f3e00fff..6c99b4bbce 100644 --- a/test/behavior/undefined.zig +++ b/test/behavior/undefined.zig @@ -81,7 +81,6 @@ test "assign undefined to struct with method" { test "type name of undefined" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const x = undefined; try expect(mem.eql(u8, @typeName(@TypeOf(x)), "@TypeOf(undefined)")); diff --git a/test/behavior/union.zig b/test/behavior/union.zig index 26232159b6..213d4c75ea 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -1467,8 +1467,6 @@ test "packed union in packed struct" { } test "Namespace-like union" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const DepType = enum { git, http, diff --git a/test/behavior/var_args.zig b/test/behavior/var_args.zig index adb5491f7f..94e2a81a9a 100644 --- a/test/behavior/var_args.zig +++ b/test/behavior/var_args.zig @@ -14,8 +14,6 @@ fn add(args: anytype) i32 { } test "add arbitrary args" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10); try expect(add(.{@as(i32, 1234)}) == 1234); try expect(add(.{}) == 0); diff --git a/test/behavior/while.zig b/test/behavior/while.zig index a6634b672f..8d3e3a12da 100644 --- a/test/behavior/while.zig +++ b/test/behavior/while.zig @@ -5,7 +5,6 @@ const assert = std.debug.assert; test "while loop" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var i: i32 = 0; while (i < 4) { -- cgit v1.2.3 From 1042deb86fd57278f3a16fd064b370bf72f28160 Mon Sep 17 00:00:00 2001 From: Luuk de Gram Date: Wed, 31 May 2023 18:03:49 +0200 Subject: enable passing behavior tests --- test/behavior/align.zig | 1 - test/behavior/atomics.zig | 1 - test/behavior/basic.zig | 3 --- test/behavior/bugs/12142.zig | 1 - test/behavior/bugs/13113.zig | 1 - test/behavior/bugs/13128.zig | 1 - test/behavior/bugs/13664.zig | 1 - test/behavior/bugs/1381.zig | 1 - test/behavior/cast_int.zig | 1 - test/behavior/empty_union.zig | 5 ----- test/behavior/enum.zig | 2 -- test/behavior/error.zig | 5 ----- test/behavior/eval.zig | 5 ----- test/behavior/optional.zig | 1 - test/behavior/ptrcast.zig | 2 -- test/behavior/return_address.zig | 1 - test/behavior/type.zig | 2 -- test/behavior/union.zig | 11 ----------- test/behavior/union_with_members.zig | 1 - 19 files changed, 46 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/test/behavior/align.zig b/test/behavior/align.zig index dd0ea31711..ce407422bf 100644 --- a/test/behavior/align.zig +++ b/test/behavior/align.zig @@ -16,7 +16,6 @@ test "global variable alignment" { } test "slicing array of length 1 can not assume runtime index is always zero" { - if (builtin.zig_backend == .stage2_wasm) 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; diff --git a/test/behavior/atomics.zig b/test/behavior/atomics.zig index 99f08a6cae..41794461ad 100644 --- a/test/behavior/atomics.zig +++ b/test/behavior/atomics.zig @@ -383,7 +383,6 @@ fn testAtomicRmwInt128(comptime signedness: std.builtin.Signedness) !void { } test "atomics with different types" { - if (builtin.zig_backend == .stage2_wasm) 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_arm) return error.SkipZigTest; // TODO diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 3024ad58c0..bdbcfdbfc0 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -413,7 +413,6 @@ test "array 2D const double ptr with offset" { 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; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const rect_2d_vertexes = [_][2]f32{ @@ -427,7 +426,6 @@ test "array 3D const double ptr with offset" { 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; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const rect_3d_vertexes = [_][2][2]f32{ @@ -1052,7 +1050,6 @@ test "inline call of function with a switch inside the return statement" { } test "namespace lookup ignores decl causing the lookup" { - if (builtin.zig_backend == .stage2_wasm) 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; diff --git a/test/behavior/bugs/12142.zig b/test/behavior/bugs/12142.zig index e5c022bf18..4b9a4d9fa1 100644 --- a/test/behavior/bugs/12142.zig +++ b/test/behavior/bugs/12142.zig @@ -19,7 +19,6 @@ fn letter(e: Letter) u8 { } test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO 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 diff --git a/test/behavior/bugs/13113.zig b/test/behavior/bugs/13113.zig index 72ab0f9f5e..fd3a14f8f6 100644 --- a/test/behavior/bugs/13113.zig +++ b/test/behavior/bugs/13113.zig @@ -7,7 +7,6 @@ const Foo = extern struct { }; test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO 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 diff --git a/test/behavior/bugs/13128.zig b/test/behavior/bugs/13128.zig index 944fa52c8a..b87513d510 100644 --- a/test/behavior/bugs/13128.zig +++ b/test/behavior/bugs/13128.zig @@ -14,7 +14,6 @@ fn foo(val: U) !void { test "runtime union init, most-aligned field != largest" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; diff --git a/test/behavior/bugs/13664.zig b/test/behavior/bugs/13664.zig index 7171a89f29..34f6e9110b 100644 --- a/test/behavior/bugs/13664.zig +++ b/test/behavior/bugs/13664.zig @@ -13,7 +13,6 @@ fn value() i64 { return 1341; } test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO diff --git a/test/behavior/bugs/1381.zig b/test/behavior/bugs/1381.zig index aa349b4d13..90941de341 100644 --- a/test/behavior/bugs/1381.zig +++ b/test/behavior/bugs/1381.zig @@ -15,7 +15,6 @@ test "union that needs padding bytes inside an array" { if (builtin.zig_backend == .stage2_x86_64) 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_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; diff --git a/test/behavior/cast_int.zig b/test/behavior/cast_int.zig index c04c300d45..041ee193e8 100644 --- a/test/behavior/cast_int.zig +++ b/test/behavior/cast_int.zig @@ -4,7 +4,6 @@ const expect = std.testing.expect; const maxInt = std.math.maxInt; test "@intCast i32 to u7" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/empty_union.zig b/test/behavior/empty_union.zig index 54ad52df63..1bdbf8e54b 100644 --- a/test/behavior/empty_union.zig +++ b/test/behavior/empty_union.zig @@ -3,15 +3,12 @@ const std = @import("std"); const expect = std.testing.expect; test "switch on empty enum" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - const E = enum {}; var e: E = undefined; switch (e) {} } test "switch on empty enum with a specified tag type" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const E = enum(u8) {}; @@ -21,7 +18,6 @@ test "switch on empty enum with a specified tag type" { test "switch on empty auto numbered tagged union" { 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_spirv64) return error.SkipZigTest; const U = union(enum(u8)) {}; @@ -31,7 +27,6 @@ test "switch on empty auto numbered tagged union" { test "switch on empty tagged union" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO const E = enum {}; const U = union(E) {}; diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index f652d7fe5b..42131df80e 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -1079,7 +1079,6 @@ const bit_field_1 = BitFieldOfEnums{ }; test "bit field access with enum fields" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO 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 @@ -1120,7 +1119,6 @@ test "enum literal in array literal" { } test "tag name functions are unique" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO 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 diff --git a/test/behavior/error.zig b/test/behavior/error.zig index 618af87e10..b8f68ec663 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -720,7 +720,6 @@ test "ret_ptr doesn't cause own inferred error set to be resolved" { } test "simple else prong allowed even when all errors handled" { - 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; @@ -749,7 +748,6 @@ test "simple else prong allowed even when all errors handled" { test "pointer to error union payload" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -783,7 +781,6 @@ const NoReturn = struct { test "error union of noreturn used with if" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -798,7 +795,6 @@ test "error union of noreturn used with if" { test "error union of noreturn used with try" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -810,7 +806,6 @@ test "error union of noreturn used with try" { test "error union of noreturn used with catch" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig index 68d43ef0b6..39eac020c5 100644 --- a/test/behavior/eval.zig +++ b/test/behavior/eval.zig @@ -470,7 +470,6 @@ test "binary math operator in partially inlined function" { } test "comptime shl" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO @@ -501,7 +500,6 @@ test "comptime bitwise operators" { test "comptime shlWithOverflow" { 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_spirv64) return error.SkipZigTest; const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0]; @@ -812,7 +810,6 @@ test "array concatenation peer resolves element types - pointer" { } test "array concatenation sets the sentinel - value" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; 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 @@ -850,7 +847,6 @@ test "array concatenation sets the sentinel - pointer" { } test "array multiplication sets the sentinel - value" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; 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 @@ -1550,7 +1546,6 @@ test "x or true is comptime-known true" { test "non-optional and optional array elements concatenated" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig index 4a043c6a6e..8a38f95366 100644 --- a/test/behavior/optional.zig +++ b/test/behavior/optional.zig @@ -365,7 +365,6 @@ test "optional pointer to zero bit optional payload" { test "optional pointer to zero bit error union payload" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; diff --git a/test/behavior/ptrcast.zig b/test/behavior/ptrcast.zig index 8e25a52505..5051dc0ecb 100644 --- a/test/behavior/ptrcast.zig +++ b/test/behavior/ptrcast.zig @@ -129,7 +129,6 @@ fn testReinterpretOverAlignedExternStructAsExternStruct() !void { test "lower reinterpreted comptime field ptr (with under-aligned 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -153,7 +152,6 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" { test "lower reinterpreted comptime field ptr" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; diff --git a/test/behavior/return_address.zig b/test/behavior/return_address.zig index 6d92e11793..3e8c18c04a 100644 --- a/test/behavior/return_address.zig +++ b/test/behavior/return_address.zig @@ -6,7 +6,6 @@ fn retAddr() usize { } test "return address" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO diff --git a/test/behavior/type.zig b/test/behavior/type.zig index 2fff4b05af..94a6b460e4 100644 --- a/test/behavior/type.zig +++ b/test/behavior/type.zig @@ -258,7 +258,6 @@ test "Type.ErrorSet" { } test "Type.Struct" { - 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_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO @@ -488,7 +487,6 @@ test "Type.Union from regular enum" { } test "Type.Fn" { - 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_aarch64) return error.SkipZigTest; // TODO diff --git a/test/behavior/union.zig b/test/behavior/union.zig index 2520241aff..f1bfaa063b 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -452,7 +452,6 @@ var glbl: Foo1 = undefined; test "global union with single field is correctly initialized" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - 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; @@ -500,7 +499,6 @@ test "update the tag value for zero-sized unions" { test "union initializer generates padding only if needed" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - 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; @@ -788,7 +786,6 @@ fn Setter(comptime attr: Attribute) type { test "return union init with void payload" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - 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; @@ -814,7 +811,6 @@ test "return union init with void payload" { test "@unionInit stored to a const" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -985,7 +981,6 @@ test "function call result coerces from tagged union to the tag" { test "cast from anonymous struct to union" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -1018,7 +1013,6 @@ test "cast from anonymous struct to union" { test "cast from pointer to anonymous struct to pointer to union" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -1108,7 +1102,6 @@ test "containers with single-field enums" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -1382,7 +1375,6 @@ test "union and enum field order doesn't match" { test "@unionInit uses tag value instead of field index" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -1440,7 +1432,6 @@ test "union field ptr - zero sized field" { test "packed union in packed struct" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -1528,7 +1519,6 @@ test "union reassignment can use previous value" { test "packed union with zero-bit field" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; @@ -1549,7 +1539,6 @@ test "packed union with zero-bit field" { test "reinterpreting enum value inside packed union" { 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_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const U = packed union { diff --git a/test/behavior/union_with_members.zig b/test/behavior/union_with_members.zig index 1155d14924..186a30ad63 100644 --- a/test/behavior/union_with_members.zig +++ b/test/behavior/union_with_members.zig @@ -17,7 +17,6 @@ const ET = union(enum) { }; test "enum with members" { - 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_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO -- cgit v1.2.3 From d884d7050e061c620324aaaabfba507e08cb40f4 Mon Sep 17 00:00:00 2001 From: Eric Joldasov Date: Mon, 5 Jun 2023 14:29:28 +0600 Subject: all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov --- doc/langref.html.in | 22 ++--- lib/std/base64.zig | 4 +- lib/std/cstr.zig | 2 +- lib/std/math.zig | 26 +++--- lib/std/mem.zig | 12 +-- lib/std/meta.zig | 2 +- lib/std/meta/trait.zig | 4 +- lib/std/rand/test.zig | 10 +-- lib/std/unicode.zig | 30 +++---- test/behavior/align.zig | 16 ++-- test/behavior/alignof.zig | 4 +- test/behavior/array.zig | 30 +++---- test/behavior/async_fn.zig | 6 +- test/behavior/atomics.zig | 16 ++-- test/behavior/basic.zig | 12 +-- test/behavior/bitcast.zig | 24 ++--- test/behavior/bitreverse.zig | 10 +-- test/behavior/bool.zig | 2 +- test/behavior/bugs/1076.zig | 2 +- test/behavior/bugs/11139.zig | 2 +- test/behavior/bugs/1607.zig | 2 +- test/behavior/bugs/2114.zig | 2 +- test/behavior/bugs/421.zig | 2 +- test/behavior/bugs/4328.zig | 6 +- test/behavior/bugs/5474.zig | 4 +- test/behavior/bugs/655.zig | 2 +- test/behavior/byteswap.zig | 10 +-- test/behavior/call.zig | 10 +-- test/behavior/cast.zig | 116 ++++++++++++------------ test/behavior/comptime_memory.zig | 4 +- test/behavior/defer.zig | 6 +- test/behavior/enum.zig | 32 +++---- test/behavior/error.zig | 22 ++--- test/behavior/eval.zig | 20 ++--- test/behavior/field_parent_ptr.zig | 10 +-- test/behavior/floatop.zig | 116 ++++++++++++------------ test/behavior/fn.zig | 12 +-- test/behavior/for.zig | 12 +-- test/behavior/if.zig | 4 +- test/behavior/int128.zig | 8 +- test/behavior/int_div.zig | 2 +- test/behavior/math.zig | 106 +++++++++++----------- test/behavior/maximum_minimum.zig | 12 +-- test/behavior/muladd.zig | 18 ++-- test/behavior/null.zig | 6 +- test/behavior/optional.zig | 16 ++-- test/behavior/packed-struct.zig | 2 +- test/behavior/pointers.zig | 66 +++++++------- test/behavior/popcount.zig | 4 +- test/behavior/ptrcast.zig | 12 +-- test/behavior/saturating_arithmetic.zig | 64 +++++++------- test/behavior/select.zig | 4 +- test/behavior/shuffle.zig | 6 +- test/behavior/sizeof_and_typeof.zig | 16 ++-- test/behavior/slice.zig | 150 ++++++++++++++++---------------- test/behavior/struct.zig | 36 ++++---- test/behavior/switch.zig | 40 ++++----- test/behavior/truncate.zig | 6 +- test/behavior/try.zig | 2 +- test/behavior/tuple.zig | 14 +-- test/behavior/type_info.zig | 38 ++++---- test/behavior/union.zig | 56 ++++++------ test/behavior/usingnamespace.zig | 2 +- test/behavior/vector.zig | 68 +++++++-------- test/behavior/while.zig | 8 +- test/behavior/wrapping_arithmetic.zig | 30 +++---- test/standalone/issue_794/main.zig | 2 +- 67 files changed, 711 insertions(+), 711 deletions(-) (limited to 'test/behavior/basic.zig') diff --git a/doc/langref.html.in b/doc/langref.html.in index 6740d147bd..ae02ef5705 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -3306,7 +3306,7 @@ const Divided = packed struct { test "@bitCast between packed structs" { try doTheTest(); - comptime try doTheTest(); + try comptime doTheTest(); } fn doTheTest() !void { @@ -5815,10 +5815,10 @@ test "error union" { foo = error.SomeError; // Use compile-time reflection to access the payload type of an error union: - comptime try expect(@typeInfo(@TypeOf(foo)).ErrorUnion.payload == i32); + try comptime expect(@typeInfo(@TypeOf(foo)).ErrorUnion.payload == i32); // Use compile-time reflection to access the error set type of an error union: - comptime try expect(@typeInfo(@TypeOf(foo)).ErrorUnion.error_set == anyerror); + try comptime expect(@typeInfo(@TypeOf(foo)).ErrorUnion.error_set == anyerror); } {#code_end#} {#header_open|Merging Error Sets#} @@ -6199,7 +6199,7 @@ test "optional type" { foo = 1234; // Use compile-time reflection to access the child type of the optional: - comptime try expect(@typeInfo(@TypeOf(foo)).Optional.child == i32); + try comptime expect(@typeInfo(@TypeOf(foo)).Optional.child == i32); } {#code_end#} {#header_close#} @@ -6632,8 +6632,8 @@ test "peer resolve int widening" { test "peer resolve arrays of different size to const slice" { try expect(mem.eql(u8, boolToStr(true), "true")); try expect(mem.eql(u8, boolToStr(false), "false")); - comptime try expect(mem.eql(u8, boolToStr(true), "true")); - comptime try expect(mem.eql(u8, boolToStr(false), "false")); + try comptime expect(mem.eql(u8, boolToStr(true), "true")); + try comptime expect(mem.eql(u8, boolToStr(false), "false")); } fn boolToStr(b: bool) []const u8 { return if (b) "true" else "false"; @@ -6641,7 +6641,7 @@ fn boolToStr(b: bool) []const u8 { test "peer resolve array and const slice" { try testPeerResolveArrayConstSlice(true); - comptime try testPeerResolveArrayConstSlice(true); + try comptime testPeerResolveArrayConstSlice(true); } fn testPeerResolveArrayConstSlice(b: bool) !void { const value1 = if (b) "aoeu" else @as([]const u8, "zz"); @@ -9184,7 +9184,7 @@ const expect = std.testing.expect; test "vector @splat" { const scalar: u32 = 5; const result = @splat(4, scalar); - comptime try expect(@TypeOf(result) == @Vector(4, u32)); + try comptime expect(@TypeOf(result) == @Vector(4, u32)); try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 })); } {#code_end#} @@ -9228,9 +9228,9 @@ test "vector @reduce" { const value = @Vector(4, i32){ 1, -1, 1, -1 }; const result = value > @splat(4, @as(i32, 0)); // result is { true, false, true, false }; - comptime try expect(@TypeOf(result) == @Vector(4, bool)); + try comptime expect(@TypeOf(result) == @Vector(4, bool)); const is_all_true = @reduce(.And, result); - comptime try expect(@TypeOf(is_all_true) == bool); + try comptime expect(@TypeOf(is_all_true) == bool); try expect(is_all_true == false); } {#code_end#} @@ -9571,7 +9571,7 @@ const expect = std.testing.expect; test "no runtime side effects" { var data: i32 = 0; const T = @TypeOf(foo(i32, &data)); - comptime try expect(T == i32); + try comptime expect(T == i32); try expect(data == 0); } diff --git a/lib/std/base64.zig b/lib/std/base64.zig index 758c7c8b58..869fa47e5e 100644 --- a/lib/std/base64.zig +++ b/lib/std/base64.zig @@ -302,7 +302,7 @@ pub const Base64DecoderWithIgnore = struct { test "base64" { @setEvalBranchQuota(8000); try testBase64(); - comptime try testAllApis(standard, "comptime", "Y29tcHRpbWU="); + try comptime testAllApis(standard, "comptime", "Y29tcHRpbWU="); } test "base64 padding dest overflow" { @@ -322,7 +322,7 @@ test "base64 padding dest overflow" { test "base64 url_safe_no_pad" { @setEvalBranchQuota(8000); try testBase64UrlSafeNoPad(); - comptime try testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU"); + try comptime testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU"); } fn testBase64() !void { diff --git a/lib/std/cstr.zig b/lib/std/cstr.zig index 8a203e5c8e..9bd98a72b7 100644 --- a/lib/std/cstr.zig +++ b/lib/std/cstr.zig @@ -22,7 +22,7 @@ pub fn cmp(a: [*:0]const u8, b: [*:0]const u8) i8 { } test "cstr fns" { - comptime try testCStrFnsImpl(); + try comptime testCStrFnsImpl(); try testCStrFnsImpl(); } diff --git a/lib/std/math.zig b/lib/std/math.zig index d85cefdefb..46a7e40a37 100644 --- a/lib/std/math.zig +++ b/lib/std/math.zig @@ -854,7 +854,7 @@ test "IntFittingRange" { test "overflow functions" { try testOverflow(); - comptime try testOverflow(); + try comptime testOverflow(); } fn testOverflow() !void { @@ -898,7 +898,7 @@ pub fn absInt(x: anytype) !@TypeOf(x) { test "absInt" { try testAbsInt(); - comptime try testAbsInt(); + try comptime testAbsInt(); } fn testAbsInt() !void { try testing.expect((absInt(@as(i32, -10)) catch unreachable) == 10); @@ -920,7 +920,7 @@ pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T { test "divTrunc" { try testDivTrunc(); - comptime try testDivTrunc(); + try comptime testDivTrunc(); } fn testDivTrunc() !void { try testing.expect((divTrunc(i32, 5, 3) catch unreachable) == 1); @@ -944,7 +944,7 @@ pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T { test "divFloor" { try testDivFloor(); - comptime try testDivFloor(); + try comptime testDivFloor(); } fn testDivFloor() !void { try testing.expect((divFloor(i32, 5, 3) catch unreachable) == 1); @@ -981,7 +981,7 @@ pub fn divCeil(comptime T: type, numerator: T, denominator: T) !T { test "divCeil" { try testDivCeil(); - comptime try testDivCeil(); + try comptime testDivCeil(); } fn testDivCeil() !void { try testing.expectEqual(@as(i32, 2), divCeil(i32, 5, 3) catch unreachable); @@ -1025,7 +1025,7 @@ pub fn divExact(comptime T: type, numerator: T, denominator: T) !T { test "divExact" { try testDivExact(); - comptime try testDivExact(); + try comptime testDivExact(); } fn testDivExact() !void { try testing.expect((divExact(i32, 10, 5) catch unreachable) == 2); @@ -1051,7 +1051,7 @@ pub fn mod(comptime T: type, numerator: T, denominator: T) !T { test "mod" { try testMod(); - comptime try testMod(); + try comptime testMod(); } fn testMod() !void { try testing.expect((mod(i32, -5, 3) catch unreachable) == 1); @@ -1077,7 +1077,7 @@ pub fn rem(comptime T: type, numerator: T, denominator: T) !T { test "rem" { try testRem(); - comptime try testRem(); + try comptime testRem(); } fn testRem() !void { try testing.expect((rem(i32, -5, 3) catch unreachable) == -2); @@ -1253,7 +1253,7 @@ pub fn floorPowerOfTwo(comptime T: type, value: T) T { test "floorPowerOfTwo" { try testFloorPowerOfTwo(); - comptime try testFloorPowerOfTwo(); + try comptime testFloorPowerOfTwo(); } fn testFloorPowerOfTwo() !void { @@ -1315,7 +1315,7 @@ pub fn ceilPowerOfTwoAssert(comptime T: type, value: T) T { test "ceilPowerOfTwoPromote" { try testCeilPowerOfTwoPromote(); - comptime try testCeilPowerOfTwoPromote(); + try comptime testCeilPowerOfTwoPromote(); } fn testCeilPowerOfTwoPromote() !void { @@ -1332,7 +1332,7 @@ fn testCeilPowerOfTwoPromote() !void { test "ceilPowerOfTwo" { try testCeilPowerOfTwo(); - comptime try testCeilPowerOfTwo(); + try comptime testCeilPowerOfTwo(); } fn testCeilPowerOfTwo() !void { @@ -1751,7 +1751,7 @@ test "boolMask" { } }.runTest; try runTest(); - comptime try runTest(); + try comptime runTest(); } /// Return the mod of `num` with the smallest integer type @@ -1882,5 +1882,5 @@ test "sign" { return error.SkipZigTest; } try testSign(); - comptime try testSign(); + try comptime testSign(); } diff --git a/lib/std/mem.zig b/lib/std/mem.zig index d6ca4a9ea1..cd65323569 100644 --- a/lib/std/mem.zig +++ b/lib/std/mem.zig @@ -3101,7 +3101,7 @@ test "testStringEquality" { test "testReadInt" { try testReadIntImpl(); - comptime try testReadIntImpl(); + try comptime testReadIntImpl(); } fn testReadIntImpl() !void { { @@ -3152,7 +3152,7 @@ fn testReadIntImpl() !void { test writeIntSlice { try testWriteIntImpl(); - comptime try testWriteIntImpl(); + try comptime testWriteIntImpl(); } fn testWriteIntImpl() !void { var bytes: [8]u8 = undefined; @@ -4069,13 +4069,13 @@ test "bytesAsSlice keeps pointer alignment" { { var bytes = [_]u8{ 0x01, 0x02, 0x03, 0x04 }; const numbers = bytesAsSlice(u32, bytes[0..]); - comptime try testing.expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32); + try comptime testing.expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32); } { var bytes = [_]u8{ 0x01, 0x02, 0x03, 0x04 }; var runtime_zero: usize = 0; const numbers = bytesAsSlice(u32, bytes[runtime_zero..]); - comptime try testing.expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32); + try comptime testing.expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32); } } @@ -4168,7 +4168,7 @@ test "sliceAsBytes packed struct at runtime and comptime" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "sliceAsBytes and bytesAsSlice back" { @@ -4557,7 +4557,7 @@ test "read/write(Var)PackedInt" { } const signedness = @typeInfo(PackedType).Int.signedness; - const NextPowerOfTwoInt = std.meta.Int(signedness, comptime try std.math.ceilPowerOfTwo(u16, @bitSizeOf(PackedType))); + const NextPowerOfTwoInt = std.meta.Int(signedness, try comptime std.math.ceilPowerOfTwo(u16, @bitSizeOf(PackedType))); const ui64 = std.meta.Int(signedness, 64); inline for ([_]type{ PackedType, NextPowerOfTwoInt, ui64 }) |U| { { // Variable-size Read/Write (Native-endian) diff --git a/lib/std/meta.zig b/lib/std/meta.zig index 28709750c7..db415199ed 100644 --- a/lib/std/meta.zig +++ b/lib/std/meta.zig @@ -210,7 +210,7 @@ pub fn sentinel(comptime T: type) ?Elem(T) { test "std.meta.sentinel" { try testSentinel(); - comptime try testSentinel(); + try comptime testSentinel(); } fn testSentinel() !void { diff --git a/lib/std/meta/trait.zig b/lib/std/meta/trait.zig index e8cf9bd3fc..3d0e0bce5d 100644 --- a/lib/std/meta/trait.zig +++ b/lib/std/meta/trait.zig @@ -222,8 +222,8 @@ pub fn isSingleItemPtr(comptime T: type) bool { test "isSingleItemPtr" { const array = [_]u8{0} ** 10; - comptime try testing.expect(isSingleItemPtr(@TypeOf(&array[0]))); - comptime try testing.expect(!isSingleItemPtr(@TypeOf(array))); + try comptime testing.expect(isSingleItemPtr(@TypeOf(&array[0]))); + try comptime testing.expect(!isSingleItemPtr(@TypeOf(array))); var runtime_zero: usize = 0; try testing.expect(!isSingleItemPtr(@TypeOf(array[runtime_zero..1]))); } diff --git a/lib/std/rand/test.zig b/lib/std/rand/test.zig index 1ad9adbeb8..d257425ad1 100644 --- a/lib/std/rand/test.zig +++ b/lib/std/rand/test.zig @@ -79,7 +79,7 @@ const Dilbert = struct { test "Random int" { try testRandomInt(); - comptime try testRandomInt(); + try comptime testRandomInt(); } fn testRandomInt() !void { var rng = SequentialPrng.init(); @@ -126,7 +126,7 @@ fn testRandomInt() !void { test "Random boolean" { try testRandomBoolean(); - comptime try testRandomBoolean(); + try comptime testRandomBoolean(); } fn testRandomBoolean() !void { var rng = SequentialPrng.init(); @@ -140,7 +140,7 @@ fn testRandomBoolean() !void { test "Random enum" { try testRandomEnumValue(); - comptime try testRandomEnumValue(); + try comptime testRandomEnumValue(); } fn testRandomEnumValue() !void { const TestEnum = enum { @@ -159,7 +159,7 @@ fn testRandomEnumValue() !void { test "Random intLessThan" { @setEvalBranchQuota(10000); try testRandomIntLessThan(); - comptime try testRandomIntLessThan(); + try comptime testRandomIntLessThan(); } fn testRandomIntLessThan() !void { var rng = SequentialPrng.init(); @@ -201,7 +201,7 @@ fn testRandomIntLessThan() !void { test "Random intAtMost" { @setEvalBranchQuota(10000); try testRandomIntAtMost(); - comptime try testRandomIntAtMost(); + try comptime testRandomIntAtMost(); } fn testRandomIntAtMost() !void { var rng = SequentialPrng.init(); diff --git a/lib/std/unicode.zig b/lib/std/unicode.zig index 9d334218c1..1987d10b0d 100644 --- a/lib/std/unicode.zig +++ b/lib/std/unicode.zig @@ -354,11 +354,11 @@ fn testUtf16CountCodepoints() !void { test "utf16 count codepoints" { try testUtf16CountCodepoints(); - comptime try testUtf16CountCodepoints(); + try comptime testUtf16CountCodepoints(); } test "utf8 encode" { - comptime try testUtf8Encode(); + try comptime testUtf8Encode(); try testUtf8Encode(); } fn testUtf8Encode() !void { @@ -384,7 +384,7 @@ fn testUtf8Encode() !void { } test "utf8 encode error" { - comptime try testUtf8EncodeError(); + try comptime testUtf8EncodeError(); try testUtf8EncodeError(); } fn testUtf8EncodeError() !void { @@ -400,7 +400,7 @@ fn testErrorEncode(codePoint: u21, array: []u8, expectedErr: anyerror) !void { } test "utf8 iterator on ascii" { - comptime try testUtf8IteratorOnAscii(); + try comptime testUtf8IteratorOnAscii(); try testUtf8IteratorOnAscii(); } fn testUtf8IteratorOnAscii() !void { @@ -420,7 +420,7 @@ fn testUtf8IteratorOnAscii() !void { } test "utf8 view bad" { - comptime try testUtf8ViewBad(); + try comptime testUtf8ViewBad(); try testUtf8ViewBad(); } fn testUtf8ViewBad() !void { @@ -430,7 +430,7 @@ fn testUtf8ViewBad() !void { } test "utf8 view ok" { - comptime try testUtf8ViewOk(); + try comptime testUtf8ViewOk(); try testUtf8ViewOk(); } fn testUtf8ViewOk() !void { @@ -450,7 +450,7 @@ fn testUtf8ViewOk() !void { } test "bad utf8 slice" { - comptime try testBadUtf8Slice(); + try comptime testBadUtf8Slice(); try testBadUtf8Slice(); } fn testBadUtf8Slice() !void { @@ -461,7 +461,7 @@ fn testBadUtf8Slice() !void { } test "valid utf8" { - comptime try testValidUtf8(); + try comptime testValidUtf8(); try testValidUtf8(); } fn testValidUtf8() !void { @@ -480,7 +480,7 @@ fn testValidUtf8() !void { } test "invalid utf8 continuation bytes" { - comptime try testInvalidUtf8ContinuationBytes(); + try comptime testInvalidUtf8ContinuationBytes(); try testInvalidUtf8ContinuationBytes(); } fn testInvalidUtf8ContinuationBytes() !void { @@ -512,7 +512,7 @@ fn testInvalidUtf8ContinuationBytes() !void { } test "overlong utf8 codepoint" { - comptime try testOverlongUtf8Codepoint(); + try comptime testOverlongUtf8Codepoint(); try testOverlongUtf8Codepoint(); } fn testOverlongUtf8Codepoint() !void { @@ -525,7 +525,7 @@ fn testOverlongUtf8Codepoint() !void { } test "misc invalid utf8" { - comptime try testMiscInvalidUtf8(); + try comptime testMiscInvalidUtf8(); try testMiscInvalidUtf8(); } fn testMiscInvalidUtf8() !void { @@ -540,7 +540,7 @@ fn testMiscInvalidUtf8() !void { } test "utf8 iterator peeking" { - comptime try testUtf8Peeking(); + try comptime testUtf8Peeking(); try testUtf8Peeking(); } @@ -813,7 +813,7 @@ fn testCalcUtf16LeLen() !void { test "calculate utf16 string length of given utf8 string in u16" { try testCalcUtf16LeLen(); - comptime try testCalcUtf16LeLen(); + try comptime testCalcUtf16LeLen(); } /// Print the given `utf16le` string @@ -919,7 +919,7 @@ fn testUtf8CountCodepoints() !void { test "utf8 count codepoints" { try testUtf8CountCodepoints(); - comptime try testUtf8CountCodepoints(); + try comptime testUtf8CountCodepoints(); } fn testUtf8ValidCodepoint() !void { @@ -935,5 +935,5 @@ fn testUtf8ValidCodepoint() !void { test "utf8 valid codepoint" { try testUtf8ValidCodepoint(); - comptime try testUtf8ValidCodepoint(); + try comptime testUtf8ValidCodepoint(); } diff --git a/test/behavior/align.zig b/test/behavior/align.zig index ce407422bf..4ce408e65d 100644 --- a/test/behavior/align.zig +++ b/test/behavior/align.zig @@ -7,11 +7,11 @@ const assert = std.debug.assert; var foo: u8 align(4) = 100; test "global variable alignment" { - comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4); - comptime try expect(@TypeOf(&foo) == *align(4) u8); + try comptime expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4); + try comptime expect(@TypeOf(&foo) == *align(4) u8); { const slice = @as(*align(4) [1]u8, &foo)[0..]; - comptime try expect(@TypeOf(slice) == *align(4) [1]u8); + try comptime expect(@TypeOf(slice) == *align(4) [1]u8); } } @@ -396,7 +396,7 @@ test "function align expression depends on generic parameter" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "function callconv expression depends on generic parameter" { @@ -414,7 +414,7 @@ test "function callconv expression depends on generic parameter" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "runtime-known array index has best alignment possible" { @@ -452,10 +452,10 @@ test "runtime-known array index has best alignment possible" { try testIndex2(&array, 3, *u8); } fn testIndex(smaller: [*]align(2) u32, index: usize, comptime T: type) !void { - comptime try expect(@TypeOf(&smaller[index]) == T); + try comptime expect(@TypeOf(&smaller[index]) == T); } fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void { - comptime try expect(@TypeOf(&ptr[index]) == T); + try comptime expect(@TypeOf(&ptr[index]) == T); } test "alignment of function with c calling convention" { @@ -517,7 +517,7 @@ test "struct field explicit alignment" { var node: S.Node = undefined; node.massive_byte = 100; try expect(node.massive_byte == 100); - comptime try expect(@TypeOf(&node.massive_byte) == *align(64) u8); + try comptime expect(@TypeOf(&node.massive_byte) == *align(64) u8); try expect(@ptrToInt(&node.massive_byte) % 64 == 0); } diff --git a/test/behavior/alignof.zig b/test/behavior/alignof.zig index 6109d84fe2..bacf69be57 100644 --- a/test/behavior/alignof.zig +++ b/test/behavior/alignof.zig @@ -11,9 +11,9 @@ const Foo = struct { }; test "@alignOf(T) before referencing T" { - comptime try expect(@alignOf(Foo) != maxInt(usize)); + try comptime expect(@alignOf(Foo) != maxInt(usize)); if (native_arch == .x86_64) { - comptime try expect(@alignOf(Foo) == 4); + try comptime expect(@alignOf(Foo) == 4); } } diff --git a/test/behavior/array.zig b/test/behavior/array.zig index ed8b021613..cd4c81508a 100644 --- a/test/behavior/array.zig +++ b/test/behavior/array.zig @@ -67,7 +67,7 @@ test "array concat with undefined" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "array concat with tuple" { @@ -154,9 +154,9 @@ test "array len field" { var arr = [4]u8{ 0, 0, 0, 0 }; var ptr = &arr; try expect(arr.len == 4); - comptime try expect(arr.len == 4); + try comptime expect(arr.len == 4); try expect(ptr.len == 4); - comptime try expect(ptr.len == 4); + try comptime expect(ptr.len == 4); try expect(@TypeOf(arr.len) == usize); } @@ -186,7 +186,7 @@ test "array with sentinels" { }; try S.doTheTest(false); - comptime try S.doTheTest(true); + try comptime S.doTheTest(true); } test "void arrays" { @@ -247,7 +247,7 @@ test "single-item pointer to array indexing and slicing" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testSingleItemPtrArrayIndexSlice(); - comptime try testSingleItemPtrArrayIndexSlice(); + try comptime testSingleItemPtrArrayIndexSlice(); } fn testSingleItemPtrArrayIndexSlice() !void { @@ -300,7 +300,7 @@ test "anonymous list literal syntax" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } var s_array: [8]Sub = undefined; @@ -349,7 +349,7 @@ test "implicit cast single-item pointer" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testImplicitCastSingleItemPtr(); - comptime try testImplicitCastSingleItemPtr(); + try comptime testImplicitCastSingleItemPtr(); } fn testImplicitCastSingleItemPtr() !void { @@ -410,7 +410,7 @@ test "array literal as argument to function" { } }; try S.entry(2); - comptime try S.entry(2); + try comptime S.entry(2); } test "double nested array to const slice cast in array literal" { @@ -472,7 +472,7 @@ test "double nested array to const slice cast in array literal" { } }; try S.entry(2); - comptime try S.entry(2); + try comptime S.entry(2); } test "anonymous literal in array" { @@ -498,7 +498,7 @@ test "anonymous literal in array" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "access the null element of a null terminated array" { @@ -515,7 +515,7 @@ test "access the null element of a null terminated array" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "type deduction for array subscript expression" { @@ -534,7 +534,7 @@ test "type deduction for array subscript expression" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "sentinel element count towards the ABI size calculation" { @@ -558,7 +558,7 @@ test "sentinel element count towards the ABI size calculation" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "zero-sized array with recursive type definition" { @@ -613,7 +613,7 @@ test "type coercion of anon struct literal to array" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "type coercion of pointer to anon struct literal to pointer to array" { @@ -646,7 +646,7 @@ test "type coercion of pointer to anon struct literal to pointer to array" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "array with comptime-only element type" { diff --git a/test/behavior/async_fn.zig b/test/behavior/async_fn.zig index fe095e99a3..54609ac298 100644 --- a/test/behavior/async_fn.zig +++ b/test/behavior/async_fn.zig @@ -331,7 +331,7 @@ test "async fn pointer in a struct field" { var foo = Foo{ .bar = simpleAsyncFn2 }; var bytes: [64]u8 align(16) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); - comptime try expect(@TypeOf(f) == anyframe->void); + try comptime expect(@TypeOf(f) == anyframe->void); try expect(data == 2); resume f; try expect(data == 4); @@ -1143,7 +1143,7 @@ test "@asyncCall using the result location inside the frame" { var foo = Foo{ .bar = S.simple2 }; var bytes: [64]u8 align(16) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); - comptime try expect(@TypeOf(f) == anyframe->i32); + try comptime expect(@TypeOf(f) == anyframe->i32); try expect(data == 2); resume f; try expect(data == 4); @@ -1158,7 +1158,7 @@ test "@TypeOf an async function call of generic fn with error union type" { const S = struct { fn func(comptime x: anytype) anyerror!i32 { const T = @TypeOf(async func(x)); - comptime try expect(T == @typeInfo(@TypeOf(@frame())).Pointer.child); + try comptime expect(T == @typeInfo(@TypeOf(@frame())).Pointer.child); return undefined; } }; diff --git a/test/behavior/atomics.zig b/test/behavior/atomics.zig index 41794461ad..4394e62f6f 100644 --- a/test/behavior/atomics.zig +++ b/test/behavior/atomics.zig @@ -17,7 +17,7 @@ test "cmpxchg" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCmpxchg(); - comptime try testCmpxchg(); + try comptime testCmpxchg(); } fn testCmpxchg() !void { @@ -122,7 +122,7 @@ test "128-bit cmpxchg" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO try test_u128_cmpxchg(); - comptime try test_u128_cmpxchg(); + try comptime test_u128_cmpxchg(); } fn test_u128_cmpxchg() !void { @@ -195,7 +195,7 @@ test "atomic store comptime" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testAtomicStore(); + try comptime testAtomicStore(); try testAtomicStore(); } @@ -219,7 +219,7 @@ test "atomicrmw with floats" { return error.SkipZigTest; } try testAtomicRmwFloat(); - comptime try testAtomicRmwFloat(); + try comptime testAtomicRmwFloat(); } fn testAtomicRmwFloat() !void { @@ -244,7 +244,7 @@ test "atomicrmw with ints" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testAtomicRmwInts(); - comptime try testAtomicRmwInts(); + try comptime testAtomicRmwInts(); } fn testAtomicRmwInts() !void { @@ -318,8 +318,8 @@ test "atomicrmw with 128-bit ints" { try testAtomicRmwInt128(.signed); try testAtomicRmwInt128(.unsigned); - comptime try testAtomicRmwInt128(.signed); - comptime try testAtomicRmwInt128(.unsigned); + try comptime testAtomicRmwInt128(.signed); + try comptime testAtomicRmwInt128(.unsigned); } fn testAtomicRmwInt128(comptime signedness: std.builtin.Signedness) !void { @@ -441,5 +441,5 @@ test "return @atomicStore, using it as a void value" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index bdbcfdbfc0..f98cf8f237 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -17,7 +17,7 @@ test "empty function with comments" { test "truncate" { try expect(testTruncate(0x10fd) == 0xfd); - comptime try expect(testTruncate(0x10fd) == 0xfd); + try comptime expect(testTruncate(0x10fd) == 0xfd); } fn testTruncate(x: u32) u8 { return @truncate(u8, x); @@ -462,7 +462,7 @@ test "struct inside function" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testStructInFn(); - comptime try testStructInFn(); + try comptime testStructInFn(); } fn testStructInFn() !void { @@ -577,7 +577,7 @@ fn emptyFn() void {} const addr1 = @ptrCast(*const u8, &emptyFn); test "comptime cast fn to ptr" { const addr2 = @ptrCast(*const u8, &emptyFn); - comptime try expect(addr1 == addr2); + try comptime expect(addr1 == addr2); } test "equality compare fn ptrs" { @@ -688,8 +688,8 @@ test "string concatenation" { const a = "OK" ++ " IT " ++ "WORKED"; const b = "OK IT WORKED"; - comptime try expect(@TypeOf(a) == *const [12:0]u8); - comptime try expect(@TypeOf(b) == *const [12:0]u8); + try comptime expect(@TypeOf(a) == *const [12:0]u8); + try comptime expect(@TypeOf(b) == *const [12:0]u8); const len = b.len; const len_with_null = len + 1; @@ -759,7 +759,7 @@ test "auto created variables have correct alignment" { } }; try expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a); - comptime try expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a); + try comptime expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a); } test "extern variable with non-pointer opaque type" { diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig index 28eb00c6c1..f71a05cada 100644 --- a/test/behavior/bitcast.zig +++ b/test/behavior/bitcast.zig @@ -14,7 +14,7 @@ test "@bitCast iX -> uX (32, 64)" { inline for (bit_values) |bits| { try testBitCast(bits); - comptime try testBitCast(bits); + try comptime testBitCast(bits); } } @@ -28,7 +28,7 @@ test "@bitCast iX -> uX (8, 16, 128)" { inline for (bit_values) |bits| { try testBitCast(bits); - comptime try testBitCast(bits); + try comptime testBitCast(bits); } } @@ -43,7 +43,7 @@ test "@bitCast iX -> uX exotic integers" { inline for (bit_values) |bits| { try testBitCast(bits); - comptime try testBitCast(bits); + try comptime testBitCast(bits); } } @@ -88,7 +88,7 @@ test "bitcast uX to bytes" { const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 }; inline for (bit_values) |bits| { try testBitCast(bits); - comptime try testBitCast(bits); + try comptime testBitCast(bits); } } @@ -141,7 +141,7 @@ test "nested bitcast" { }; try S.foo(42); - comptime try S.foo(42); + try comptime S.foo(42); } // issue #3010: compiler segfault @@ -182,7 +182,7 @@ test "@bitCast packed structs at runtime and comptime" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@bitCast extern structs at runtime and comptime" { @@ -214,7 +214,7 @@ test "@bitCast extern structs at runtime and comptime" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "bitcast packed struct to integer and back" { @@ -237,7 +237,7 @@ test "bitcast packed struct to integer and back" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "implicit cast to error union by returning" { @@ -254,7 +254,7 @@ test "implicit cast to error union by returning" { } }; try S.entry(); - comptime try S.entry(); + try comptime S.entry(); } test "bitcast packed struct literal to byte" { @@ -275,7 +275,7 @@ test "comptime bitcast used in expression has the correct type" { test "bitcast passed as tuple element" { const S = struct { fn foo(args: anytype) !void { - comptime try expect(@TypeOf(args[0]) == f32); + try comptime expect(@TypeOf(args[0]) == f32); try expect(args[0] == 12.34); } }; @@ -285,7 +285,7 @@ test "bitcast passed as tuple element" { test "triple level result location with bitcast sandwich passed as tuple element" { const S = struct { fn foo(args: anytype) !void { - comptime try expect(@TypeOf(args[0]) == f64); + try comptime expect(@TypeOf(args[0]) == f64); try expect(args[0] > 12.33 and args[0] < 12.35); } }; @@ -326,7 +326,7 @@ test "@bitCast packed struct of floats" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "comptime @bitCast packed struct to int and back" { diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig index 8d98f65b55..e19a560a9d 100644 --- a/test/behavior/bitreverse.zig +++ b/test/behavior/bitreverse.zig @@ -17,7 +17,7 @@ test "@bitReverse" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testBitReverse(); + try comptime testBitReverse(); try testBitReverse(); } @@ -103,7 +103,7 @@ test "bitReverse vectors u8" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector8(); + try comptime vector8(); try vector8(); } @@ -122,7 +122,7 @@ test "bitReverse vectors u16" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector16(); + try comptime vector16(); try vector16(); } @@ -141,7 +141,7 @@ test "bitReverse vectors u24" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector24(); + try comptime vector24(); try vector24(); } @@ -155,6 +155,6 @@ fn vector0() !void { test "bitReverse vectors u0" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - comptime try vector0(); + try comptime vector0(); try vector0(); } diff --git a/test/behavior/bool.zig b/test/behavior/bool.zig index 8cfd87bf21..a2636ecf42 100644 --- a/test/behavior/bool.zig +++ b/test/behavior/bool.zig @@ -49,7 +49,7 @@ test "compile time bool not" { test "short circuit" { try testShortCircuit(false, true); - comptime try testShortCircuit(false, true); + try comptime testShortCircuit(false, true); } fn testShortCircuit(f: bool, t: bool) !void { diff --git a/test/behavior/bugs/1076.zig b/test/behavior/bugs/1076.zig index 3eb07695cb..9aca002c90 100644 --- a/test/behavior/bugs/1076.zig +++ b/test/behavior/bugs/1076.zig @@ -9,7 +9,7 @@ test "comptime code should not modify constant data" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCastPtrOfArrayToSliceAndPtr(); - comptime try testCastPtrOfArrayToSliceAndPtr(); + try comptime testCastPtrOfArrayToSliceAndPtr(); } fn testCastPtrOfArrayToSliceAndPtr() !void { diff --git a/test/behavior/bugs/11139.zig b/test/behavior/bugs/11139.zig index e04960c24b..85b2e6957b 100644 --- a/test/behavior/bugs/11139.zig +++ b/test/behavior/bugs/11139.zig @@ -9,7 +9,7 @@ test "store array of array of structs at comptime" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(storeArrayOfArrayOfStructs() == 15); - comptime try expect(storeArrayOfArrayOfStructs() == 15); + try comptime expect(storeArrayOfArrayOfStructs() == 15); } fn storeArrayOfArrayOfStructs() u8 { diff --git a/test/behavior/bugs/1607.zig b/test/behavior/bugs/1607.zig index 31904ec3fd..32d5b38ba3 100644 --- a/test/behavior/bugs/1607.zig +++ b/test/behavior/bugs/1607.zig @@ -17,5 +17,5 @@ test "slices pointing at the same address as global array." { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try checkAddress(&a); - comptime try checkAddress(&a); + try comptime checkAddress(&a); } diff --git a/test/behavior/bugs/2114.zig b/test/behavior/bugs/2114.zig index 265de399f7..c785928024 100644 --- a/test/behavior/bugs/2114.zig +++ b/test/behavior/bugs/2114.zig @@ -17,7 +17,7 @@ test "fixed" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCtz(); - comptime try testCtz(); + try comptime testCtz(); } fn testCtz() !void { diff --git a/test/behavior/bugs/421.zig b/test/behavior/bugs/421.zig index f44cee37a9..1ed4a66738 100644 --- a/test/behavior/bugs/421.zig +++ b/test/behavior/bugs/421.zig @@ -7,7 +7,7 @@ test "bitCast to array" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testBitCastArray(); + try comptime testBitCastArray(); try testBitCastArray(); } diff --git a/test/behavior/bugs/4328.zig b/test/behavior/bugs/4328.zig index 89eb4d4fd0..846f751815 100644 --- a/test/behavior/bugs/4328.zig +++ b/test/behavior/bugs/4328.zig @@ -35,7 +35,7 @@ test "Extern function calls in @TypeOf" { }; try Test.doTheTest(); - comptime try Test.doTheTest(); + try comptime Test.doTheTest(); } test "Peer resolution of extern function calls in @TypeOf" { @@ -52,7 +52,7 @@ test "Peer resolution of extern function calls in @TypeOf" { }; try Test.doTheTest(); - comptime try Test.doTheTest(); + try comptime Test.doTheTest(); } test "Extern function calls, dereferences and field access in @TypeOf" { @@ -78,5 +78,5 @@ test "Extern function calls, dereferences and field access in @TypeOf" { }; try Test.doTheTest(); - comptime try Test.doTheTest(); + try comptime Test.doTheTest(); } diff --git a/test/behavior/bugs/5474.zig b/test/behavior/bugs/5474.zig index 13bee0912e..ee58a93124 100644 --- a/test/behavior/bugs/5474.zig +++ b/test/behavior/bugs/5474.zig @@ -52,12 +52,12 @@ test "pointer-to-array constness for zero-size elements, var" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try mutable(); - comptime try mutable(); + try comptime mutable(); } test "pointer-to-array constness for zero-size elements, const" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try constant(); - comptime try constant(); + try comptime constant(); } diff --git a/test/behavior/bugs/655.zig b/test/behavior/bugs/655.zig index 9ec9f01e69..d958513e6f 100644 --- a/test/behavior/bugs/655.zig +++ b/test/behavior/bugs/655.zig @@ -3,7 +3,7 @@ const other_file = @import("655_other_file.zig"); test "function with *const parameter with type dereferenced by namespace" { const x: other_file.Integer = 1234; - comptime try std.testing.expect(@TypeOf(&x) == *const other_file.Integer); + try comptime std.testing.expect(@TypeOf(&x) == *const other_file.Integer); try foo(&x); } diff --git a/test/behavior/byteswap.zig b/test/behavior/byteswap.zig index e779626765..8d28285d27 100644 --- a/test/behavior/byteswap.zig +++ b/test/behavior/byteswap.zig @@ -50,7 +50,7 @@ test "@byteSwap integers" { try std.testing.expect(expected_output == @byteSwap(input)); } }; - comptime try ByteSwapIntTest.run(); + try comptime ByteSwapIntTest.run(); try ByteSwapIntTest.run(); } @@ -69,7 +69,7 @@ test "@byteSwap vectors u8" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector8(); + try comptime vector8(); try vector8(); } @@ -88,7 +88,7 @@ test "@byteSwap vectors u16" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector16(); + try comptime vector16(); try vector16(); } @@ -107,7 +107,7 @@ test "@byteSwap vectors u24" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector24(); + try comptime vector24(); try vector24(); } @@ -121,6 +121,6 @@ fn vector0() !void { test "@byteSwap vectors u0" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - comptime try vector0(); + try comptime vector0(); try vector0(); } diff --git a/test/behavior/call.zig b/test/behavior/call.zig index 4645a2ad9e..64eca08c82 100644 --- a/test/behavior/call.zig +++ b/test/behavior/call.zig @@ -10,11 +10,11 @@ test "super basic invocations" { } }.foo; try expect(@call(.auto, foo, .{}) == 1234); - comptime try expect(@call(.always_inline, foo, .{}) == 1234); + try comptime expect(@call(.always_inline, foo, .{}) == 1234); { // comptime call without comptime keyword const result = @call(.compile_time, foo, .{}) == 1234; - comptime try expect(result); + try comptime expect(result); } } @@ -42,7 +42,7 @@ test "basic invocations" { { // comptime call without comptime keyword const result = @call(.compile_time, foo, .{}) == 1234; - comptime try expect(result); + try comptime expect(result); } { // call of non comptime-known function @@ -71,7 +71,7 @@ test "tuple parameters" { try expect(@call(.auto, add, .{ a, b }) == 46); try expect(@call(.auto, add, .{ 12, 34 }) == 46); if (false) { - comptime try expect(@call(.auto, add, .{ 12, 34 }) == 46); // TODO + try comptime expect(@call(.auto, add, .{ 12, 34 }) == 46); // TODO } try expect(comptime @call(.auto, add, .{ 12, 34 }) == 46); { @@ -344,7 +344,7 @@ test "inline call doesn't re-evaluate non generic struct" { }; const ArgTuple = std.meta.ArgsTuple(@TypeOf(S.foo)); try @call(.always_inline, S.foo, ArgTuple{.{ .a = 123, .b = 45 }}); - comptime try @call(.always_inline, S.foo, ArgTuple{.{ .a = 123, .b = 45 }}); + try comptime @call(.always_inline, S.foo, ArgTuple{.{ .a = 123, .b = 45 }}); } test "Enum constructed by @Type passed as generic argument" { diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index e9ebd4476b..9c7d8412f6 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -39,7 +39,7 @@ fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize { test "resolve undefined with integer" { try testResolveUndefWithInt(true, 1234); - comptime try testResolveUndefWithInt(true, 1234); + try comptime testResolveUndefWithInt(true, 1234); } fn testResolveUndefWithInt(b: bool, x: i32) !void { const value = if (b) x else undefined; @@ -59,7 +59,7 @@ test "implicit cast comptime numbers to any type when the value fits" { } test "implicit cast comptime_int to comptime_float" { - comptime try expect(@as(comptime_float, 10) == @as(f32, 10)); + try comptime expect(@as(comptime_float, 10) == @as(f32, 10)); try expect(2 == 2.0); } @@ -110,7 +110,7 @@ test "@intToFloat" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@intToFloat(f80)" { @@ -140,13 +140,13 @@ test "@intToFloat(f80)" { try S.doTheTest(i80); try S.doTheTest(i128); // try S.doTheTest(i256); // TODO missing compiler_rt symbols - comptime try S.doTheTest(i31); - comptime try S.doTheTest(i32); - comptime try S.doTheTest(i45); - comptime try S.doTheTest(i64); - comptime try S.doTheTest(i80); - comptime try S.doTheTest(i128); - comptime try S.doTheTest(i256); + try comptime S.doTheTest(i31); + try comptime S.doTheTest(i32); + try comptime S.doTheTest(i45); + try comptime S.doTheTest(i64); + try comptime S.doTheTest(i80); + try comptime S.doTheTest(i128); + try comptime S.doTheTest(i256); } test "@floatToInt" { @@ -156,7 +156,7 @@ test "@floatToInt" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testFloatToInts(); - comptime try testFloatToInts(); + try comptime testFloatToInts(); } fn testFloatToInts() !void { @@ -291,7 +291,7 @@ test "@intCast to u0 and use the result" { } }; try S.doTheTest(0, 1, 0); - comptime try S.doTheTest(0, 1, 0); + try comptime S.doTheTest(0, 1, 0); } test "peer result null and comptime_int" { @@ -312,11 +312,11 @@ test "peer result null and comptime_int" { }; try expect(S.blah(0) == null); - comptime try expect(S.blah(0) == null); + try comptime expect(S.blah(0) == null); try expect(S.blah(10).? == 1); - comptime try expect(S.blah(10).? == 1); + try comptime expect(S.blah(10).? == 1); try expect(S.blah(-10).? == -1); - comptime try expect(S.blah(-10).? == -1); + try comptime expect(S.blah(-10).? == -1); } test "*const ?[*]const T to [*c]const [*c]const T" { @@ -375,7 +375,7 @@ test "return u8 coercing into ?u32 return type" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "cast from ?[*]T to ??[*]T" { @@ -392,7 +392,7 @@ test "peer type unsigned int to signed" { var x: u8 = 7; var y: i32 = -5; var a = w + y + x; - comptime try expect(@TypeOf(a) == i32); + try comptime expect(@TypeOf(a) == i32); try expect(a == 7); } @@ -414,7 +414,7 @@ test "explicit cast from integer to error type" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCastIntToErr(error.ItBroke); - comptime try testCastIntToErr(error.ItBroke); + try comptime testCastIntToErr(error.ItBroke); } fn testCastIntToErr(err: anyerror) !void { const x = @errorToInt(err); @@ -428,7 +428,7 @@ test "peer resolve array and const slice" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testPeerResolveArrayConstSlice(true); - comptime try testPeerResolveArrayConstSlice(true); + try comptime testPeerResolveArrayConstSlice(true); } fn testPeerResolveArrayConstSlice(b: bool) !void { const value1 = if (b) "aoeu" else @as([]const u8, "zz"); @@ -444,7 +444,7 @@ test "implicitly cast from T to anyerror!?T" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try castToOptionalTypeError(1); - comptime try castToOptionalTypeError(1); + try comptime castToOptionalTypeError(1); } const A = struct { @@ -470,7 +470,7 @@ test "implicitly cast from [0]T to anyerror![]T" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCastZeroArrayToErrSliceMut(); - comptime try testCastZeroArrayToErrSliceMut(); + try comptime testCastZeroArrayToErrSliceMut(); } fn testCastZeroArrayToErrSliceMut() !void { @@ -504,7 +504,7 @@ test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 { if (a) { @@ -520,7 +520,7 @@ test "implicit cast from *const [N]T to []const T" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCastConstArrayRefToConstSlice(); - comptime try testCastConstArrayRefToConstSlice(); + try comptime testCastConstArrayRefToConstSlice(); } fn testCastConstArrayRefToConstSlice() !void { @@ -546,9 +546,9 @@ test "peer type resolution: error and [N]T" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); - comptime try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); + try comptime expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); try expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK")); - comptime try expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK")); + try comptime expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK")); } fn testPeerErrorAndArray(x: u8) anyerror![]const u8 { @@ -571,7 +571,7 @@ test "single-item pointer of array to slice to unknown length pointer" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCastPtrOfArrayToSliceAndPtr(); - comptime try testCastPtrOfArrayToSliceAndPtr(); + try comptime testCastPtrOfArrayToSliceAndPtr(); } fn testCastPtrOfArrayToSliceAndPtr() !void { @@ -644,9 +644,9 @@ test "vector casts" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); try S.doTheTestFloat(); - comptime try S.doTheTestFloat(); + try comptime S.doTheTestFloat(); } test "@floatCast cast down" { @@ -887,7 +887,7 @@ test "peer resolution of string literals" { } }; try S.doTheTest(.b); - comptime try S.doTheTest(.b); + try comptime S.doTheTest(.b); } test "peer cast [:x]T to []T" { @@ -904,7 +904,7 @@ test "peer cast [:x]T to []T" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "peer cast [N:x]T to [N]T" { @@ -920,7 +920,7 @@ test "peer cast [N:x]T to [N]T" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "peer cast *[N:x]T to *[N]T" { @@ -936,7 +936,7 @@ test "peer cast *[N:x]T to *[N]T" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "peer cast [*:x]T to [*]T" { @@ -956,7 +956,7 @@ test "peer cast [*:x]T to [*]T" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "peer cast [:x]T to [*:x]T" { @@ -978,7 +978,7 @@ test "peer cast [:x]T to [*:x]T" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "peer type resolution implicit cast to return type" { @@ -999,7 +999,7 @@ test "peer type resolution implicit cast to return type" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "peer type resolution implicit cast to variable type" { @@ -1018,7 +1018,7 @@ test "peer type resolution implicit cast to variable type" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "variable initialization uses result locations properly with regards to the type" { @@ -1042,7 +1042,7 @@ test "cast between C pointer with different but compatible types" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "peer type resolve string lit with sentinel-terminated mutable slice" { @@ -1053,8 +1053,8 @@ test "peer type resolve string lit with sentinel-terminated mutable slice" { var array: [4:0]u8 = undefined; array[4] = 0; // TODO remove this when #4372 is solved var slice: [:0]u8 = array[0..4 :0]; - comptime try expect(@TypeOf(slice, "hi") == [:0]const u8); - comptime try expect(@TypeOf("hi", slice) == [:0]const u8); + try comptime expect(@TypeOf(slice, "hi") == [:0]const u8); + try comptime expect(@TypeOf("hi", slice) == [:0]const u8); } test "peer type resolve array pointers, one of them const" { @@ -1062,8 +1062,8 @@ test "peer type resolve array pointers, one of them const" { var array1: [4]u8 = undefined; const array2: [5]u8 = undefined; - comptime try expect(@TypeOf(&array1, &array2) == []const u8); - comptime try expect(@TypeOf(&array2, &array1) == []const u8); + try comptime expect(@TypeOf(&array1, &array2) == []const u8); + try comptime expect(@TypeOf(&array2, &array1) == []const u8); } test "peer type resolve array pointer and unknown pointer" { @@ -1074,17 +1074,17 @@ test "peer type resolve array pointer and unknown pointer" { var const_ptr: [*]const u8 = undefined; var ptr: [*]u8 = undefined; - comptime try expect(@TypeOf(&array, ptr) == [*]u8); - comptime try expect(@TypeOf(ptr, &array) == [*]u8); + try comptime expect(@TypeOf(&array, ptr) == [*]u8); + try comptime expect(@TypeOf(ptr, &array) == [*]u8); - comptime try expect(@TypeOf(&const_array, ptr) == [*]const u8); - comptime try expect(@TypeOf(ptr, &const_array) == [*]const u8); + try comptime expect(@TypeOf(&const_array, ptr) == [*]const u8); + try comptime expect(@TypeOf(ptr, &const_array) == [*]const u8); - comptime try expect(@TypeOf(&array, const_ptr) == [*]const u8); - comptime try expect(@TypeOf(const_ptr, &array) == [*]const u8); + try comptime expect(@TypeOf(&array, const_ptr) == [*]const u8); + try comptime expect(@TypeOf(const_ptr, &array) == [*]const u8); - comptime try expect(@TypeOf(&const_array, const_ptr) == [*]const u8); - comptime try expect(@TypeOf(const_ptr, &const_array) == [*]const u8); + try comptime expect(@TypeOf(&const_array, const_ptr) == [*]const u8); + try comptime expect(@TypeOf(const_ptr, &const_array) == [*]const u8); } test "comptime float casts" { @@ -1209,7 +1209,7 @@ test "implicitly cast from [N]T to ?[]const T" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, castToOptionalSlice().?, "hi")); - comptime try expect(mem.eql(u8, castToOptionalSlice().?, "hi")); + try comptime expect(mem.eql(u8, castToOptionalSlice().?, "hi")); } fn castToOptionalSlice() ?[]const u8 { @@ -1223,7 +1223,7 @@ test "cast u128 to f128 and back" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testCast128(); + try comptime testCast128(); try testCast128(); } @@ -1303,7 +1303,7 @@ test "*const [N]null u8 to ?[]const u8" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "cast between [*c]T and ?[*:0]T on fn parameter" { @@ -1352,8 +1352,8 @@ test "peer resolve arrays of different size to const slice" { try expect(mem.eql(u8, boolToStr(true), "true")); try expect(mem.eql(u8, boolToStr(false), "false")); - comptime try expect(mem.eql(u8, boolToStr(true), "true")); - comptime try expect(mem.eql(u8, boolToStr(false), "false")); + try comptime expect(mem.eql(u8, boolToStr(true), "true")); + try comptime expect(mem.eql(u8, boolToStr(false), "false")); } fn boolToStr(b: bool) []const u8 { return if (b) "true" else "false"; @@ -1376,7 +1376,7 @@ test "cast f16 to wider types" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "cast f128 to narrower types" { @@ -1396,7 +1396,7 @@ test "cast f128 to narrower types" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "peer type resolution: unreachable, null, slice" { @@ -1436,7 +1436,7 @@ test "cast i8 fn call peers to i32 result" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "cast compatible optional types" { @@ -1509,7 +1509,7 @@ test "floatToInt to zero-bit int" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO const a: f32 = 0.0; - comptime try std.testing.expect(@floatToInt(u0, a) == 0); + try comptime std.testing.expect(@floatToInt(u0, a) == 0); } test "peer type resolution of function pointer and function body" { diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig index ea7a67651c..646433a5c0 100644 --- a/test/behavior/comptime_memory.zig +++ b/test/behavior/comptime_memory.zig @@ -257,9 +257,9 @@ test "shuffle chunks of linker value" { try testing.expectEqual(lazy_address, unshuffled1_rt); const shuffled1_ct = comptime shuffle(lazy_address, Bits, ShuffledBits); const shuffled1_ct_2 = comptime shuffle(lazy_address, Bits, ShuffledBits); - comptime try testing.expectEqual(shuffled1_ct, shuffled1_ct_2); + try comptime testing.expectEqual(shuffled1_ct, shuffled1_ct_2); const unshuffled1_ct = comptime shuffle(shuffled1_ct, ShuffledBits, Bits); - comptime try testing.expectEqual(lazy_address, unshuffled1_ct); + try comptime testing.expectEqual(lazy_address, unshuffled1_ct); try testing.expectEqual(shuffled1_ct, shuffled1_rt); } diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig index 8e97425c5e..db776e598e 100644 --- a/test/behavior/defer.zig +++ b/test/behavior/defer.zig @@ -70,7 +70,7 @@ test "return variable while defer expression in scope to modify it" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } var result: [3]u8 = undefined; @@ -131,7 +131,7 @@ test "errdefer with payload" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "reference to errdefer payload" { @@ -157,7 +157,7 @@ test "reference to errdefer payload" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "simple else prong doesn't emit an error for unreachable else prong" { diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index 42131df80e..a795d5f4b8 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -611,7 +611,7 @@ test "enum with specified tag values" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testEnumWithSpecifiedTagValues(MultipleChoice.C); - comptime try testEnumWithSpecifiedTagValues(MultipleChoice.C); + try comptime testEnumWithSpecifiedTagValues(MultipleChoice.C); } test "non-exhaustive enum" { @@ -656,7 +656,7 @@ test "non-exhaustive enum" { } }; try S.doTheTest(52); - comptime try S.doTheTest(52); + try comptime S.doTheTest(52); } test "empty non-exhaustive enum" { @@ -677,7 +677,7 @@ test "empty non-exhaustive enum" { } }; try S.doTheTest(42); - comptime try S.doTheTest(42); + try comptime S.doTheTest(42); } test "single field non-exhaustive enum" { @@ -715,7 +715,7 @@ test "single field non-exhaustive enum" { } }; try S.doTheTest(23); - comptime try S.doTheTest(23); + try comptime S.doTheTest(23); } const EnumWithTagValues = enum(u4) { @@ -750,7 +750,7 @@ test "enum with specified and unspecified tag values" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D); - comptime try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D); + try comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D); } fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void { @@ -775,18 +775,18 @@ test "set enum tag type" { { var x = Small.One; x = Small.Two; - comptime try expect(Tag(Small) == u2); + try comptime expect(Tag(Small) == u2); } { var x = Small2.One; x = Small2.Two; - comptime try expect(Tag(Small2) == u2); + try comptime expect(Tag(Small2) == u2); } } test "casting enum to its tag type" { try testCastEnumTag(Small2.Two); - comptime try testCastEnumTag(Small2.Two); + try comptime testCastEnumTag(Small2.Two); } fn testCastEnumTag(value: Small2) !void { @@ -797,7 +797,7 @@ test "enum with 1 field but explicit tag type should still have the tag type" { const Enum = enum(u8) { B = 2, }; - comptime try expect(@sizeOf(Enum) == @sizeOf(u8)); + try comptime expect(@sizeOf(Enum) == @sizeOf(u8)); } test "signed integer as enum tag" { @@ -836,12 +836,12 @@ test "enum with comptime_int tag type" { Two = 2, Three = 1, }; - comptime try expect(Tag(Enum) == comptime_int); + try comptime expect(Tag(Enum) == comptime_int); } test "enum with one member default to u0 tag type" { const E0 = enum { X }; - comptime try expect(Tag(E0) == u0); + try comptime expect(Tag(E0) == u0); } const EnumWithOneMember = enum { Eof }; @@ -891,7 +891,7 @@ test "method call on an enum" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "enum value allocation" { @@ -993,7 +993,7 @@ test "@tagName" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); - comptime try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); + try comptime expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); } fn testEnumTagNameBare(n: anytype) []const u8 { @@ -1009,7 +1009,7 @@ test "@tagName non-exhaustive enum" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); - comptime try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); + try comptime expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); } const NonExhaustive = enum(u8) { A, B, _ }; @@ -1047,7 +1047,7 @@ test "@tagName on enum literals" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); - comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); + try comptime expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); } test "enum literal casting to optional" { @@ -1088,7 +1088,7 @@ test "bit field access with enum fields" { try expect(getA(&data) == A.Two); try expect(getB(&data) == B.Three3); try expect(getC(&data) == C.Four4); - comptime try expect(@sizeOf(BitFieldOfEnums) == 1); + try comptime expect(@sizeOf(BitFieldOfEnums) == 1); data.b = B.Four3; try expect(data.b == B.Four3); diff --git a/test/behavior/error.zig b/test/behavior/error.zig index b8f68ec663..c61cd70e6b 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -188,7 +188,7 @@ fn bar2() (error{}!void) {} test "error union type " { try testErrorUnionType(); - comptime try testErrorUnionType(); + try comptime testErrorUnionType(); } fn testErrorUnionType() !void { @@ -201,7 +201,7 @@ fn testErrorUnionType() !void { test "error set type" { try testErrorSetType(); - comptime try testErrorSetType(); + try comptime testErrorSetType(); } const MyErrSet = error{ @@ -227,7 +227,7 @@ test "explicit error set cast" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testExplicitErrorSetCast(Set1.A); - comptime try testExplicitErrorSetCast(Set1.A); + try comptime testExplicitErrorSetCast(Set1.A); } const Set1 = error{ A, B }; @@ -246,7 +246,7 @@ test "comptime test error for empty error set" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testComptimeTestErrorEmptySet(1234); - comptime try testComptimeTestErrorEmptySet(1234); + try comptime testComptimeTestErrorEmptySet(1234); } const EmptyErrorSet = error{}; @@ -337,7 +337,7 @@ test "error: Zero sized error set returned with value payload crash" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; _ = try foo3(0); - _ = comptime try foo3(0); + _ = try comptime foo3(0); } const Error = error{}; @@ -446,7 +446,7 @@ test "return function call to error set from error union function" { } }; try expectError(error.Failure, S.errorable()); - comptime try expectError(error.Failure, S.errorable()); + try comptime expectError(error.Failure, S.errorable()); } test "optional error set is the same size as error set" { @@ -455,15 +455,15 @@ test "optional error set is the same size as error set" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try expect(@sizeOf(?anyerror) == @sizeOf(anyerror)); - comptime try expect(@alignOf(?anyerror) == @alignOf(anyerror)); + try comptime expect(@sizeOf(?anyerror) == @sizeOf(anyerror)); + try comptime expect(@alignOf(?anyerror) == @alignOf(anyerror)); const S = struct { fn returnsOptErrSet() ?anyerror { return null; } }; try expect(S.returnsOptErrSet() == null); - comptime try expect(S.returnsOptErrSet() == null); + try comptime expect(S.returnsOptErrSet() == null); } test "nested catch" { @@ -489,7 +489,7 @@ test "nested catch" { }; }; try S.entry(); - comptime try S.entry(); + try comptime S.entry(); } test "function pointer with return type that is error union with payload which is pointer of parent struct" { @@ -545,7 +545,7 @@ test "return result loc as peer result loc in inferred error set function" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "error payload type is correctly resolved" { diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig index 39eac020c5..2c2f1d72ff 100644 --- a/test/behavior/eval.zig +++ b/test/behavior/eval.zig @@ -56,7 +56,7 @@ fn staticAdd(a: i32, b: i32) i32 { test "const expr eval on single expr blocks" { try expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3); - comptime try expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3); + try comptime expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3); } fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 { @@ -436,7 +436,7 @@ test "f64 at compile time is lossy" { } test { - comptime try expect(@as(f128, 1 << 113) == 10384593717069655257060992658440192); + try comptime expect(@as(f128, 1 << 113) == 10384593717069655257060992658440192); } fn copyWithPartialInline(s: []u32, b: []u8) void { @@ -625,7 +625,7 @@ test "const global shares pointer with other same one" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try assertEqualPtrs(&hi1[0], &hi2[0]); - comptime try expect(&hi1[0] == &hi2[0]); + try comptime expect(&hi1[0] == &hi2[0]); } fn assertEqualPtrs(ptr1: *const u8, ptr2: *const u8) !void { try expect(ptr1 == ptr2); @@ -646,8 +646,8 @@ fn assertEqualPtrs(ptr1: *const u8, ptr2: *const u8) !void { test "string literal used as comptime slice is memoized" { const a = "link"; const b = "link"; - comptime try expect(TypeWithCompTimeSlice(a).Node == TypeWithCompTimeSlice(b).Node); - comptime try expect(TypeWithCompTimeSlice("link").Node == TypeWithCompTimeSlice("link").Node); + try comptime expect(TypeWithCompTimeSlice(a).Node == TypeWithCompTimeSlice(b).Node); + try comptime expect(TypeWithCompTimeSlice("link").Node == TypeWithCompTimeSlice("link").Node); } pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type { @@ -1072,7 +1072,7 @@ test "comptime break operand passing through runtime condition converted to runt }; try S.doTheTest('b'); - comptime try S.doTheTest('b'); + try comptime S.doTheTest('b'); } test "comptime break operand passing through runtime switch converted to runtime break" { @@ -1092,7 +1092,7 @@ test "comptime break operand passing through runtime switch converted to runtime }; try S.doTheTest('b'); - comptime try S.doTheTest('b'); + try comptime S.doTheTest('b'); } test "no dependency loop for alignment of self struct" { @@ -1349,7 +1349,7 @@ test "value in if block is comptime-known" { const s = if (false) S{ .str = "a" } else S{ .str = "b" }; break :blk "foo" ++ s.str; }; - comptime try expect(std.mem.eql(u8, first, second)); + try comptime expect(std.mem.eql(u8, first, second)); } test "lazy sizeof is resolved in division" { @@ -1448,7 +1448,7 @@ test "length of global array is determinable at comptime" { try std.testing.expect(bytes.len == 1024); } }; - comptime try S.foo(); + try comptime S.foo(); } test "continue nested inline for loop" { @@ -1574,7 +1574,7 @@ test "comptime function turns function value to function pointer" { fnPtr(Nil), }; }; - comptime try expect(S.foo[0] == &S.Nil); + try comptime expect(S.foo[0] == &S.Nil); } test "container level const and var have unique addresses" { diff --git a/test/behavior/field_parent_ptr.zig b/test/behavior/field_parent_ptr.zig index 80026bdc4b..6e3eda9032 100644 --- a/test/behavior/field_parent_ptr.zig +++ b/test/behavior/field_parent_ptr.zig @@ -7,7 +7,7 @@ test "@fieldParentPtr non-first field" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testParentFieldPtr(&foo.c); - comptime try testParentFieldPtr(&foo.c); + try comptime testParentFieldPtr(&foo.c); } test "@fieldParentPtr first field" { @@ -16,7 +16,7 @@ test "@fieldParentPtr first field" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testParentFieldPtrFirst(&foo.a); - comptime try testParentFieldPtrFirst(&foo.a); + try comptime testParentFieldPtrFirst(&foo.a); } const Foo = struct { @@ -56,7 +56,7 @@ test "@fieldParentPtr untagged union" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFieldParentPtrUnion(&bar.c); - comptime try testFieldParentPtrUnion(&bar.c); + try comptime testFieldParentPtrUnion(&bar.c); } const Bar = union(enum) { @@ -83,7 +83,7 @@ test "@fieldParentPtr tagged union" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFieldParentPtrTaggedUnion(&bar_tagged.c); - comptime try testFieldParentPtrTaggedUnion(&bar_tagged.c); + try comptime testFieldParentPtrTaggedUnion(&bar_tagged.c); } const BarTagged = union(enum) { @@ -110,7 +110,7 @@ test "@fieldParentPtr extern union" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFieldParentPtrExternUnion(&bar_extern.c); - comptime try testFieldParentPtrExternUnion(&bar_extern.c); + try comptime testFieldParentPtrExternUnion(&bar_extern.c); } const BarExtern = extern union { diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig index 9391aa9398..15033d5515 100644 --- a/test/behavior/floatop.zig +++ b/test/behavior/floatop.zig @@ -25,7 +25,7 @@ test "floating point comparisons" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testFloatComparisons(); - comptime try testFloatComparisons(); + try comptime testFloatComparisons(); } fn testFloatComparisons() !void { @@ -61,7 +61,7 @@ test "different sized float comparisons" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testDifferentSizedFloatComparisons(); - comptime try testDifferentSizedFloatComparisons(); + try comptime testDifferentSizedFloatComparisons(); } fn testDifferentSizedFloatComparisons() !void { @@ -104,7 +104,7 @@ test "@sqrt" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testSqrt(); + try comptime testSqrt(); try testSqrt(); } @@ -142,7 +142,7 @@ test "@sqrt with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testSqrtWithVectors(); + try comptime testSqrtWithVectors(); try testSqrtWithVectors(); } @@ -188,18 +188,18 @@ test "another, possibly redundant @sqrt test" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testSqrtLegacy(f64, 12.0); - comptime try testSqrtLegacy(f64, 12.0); + try comptime testSqrtLegacy(f64, 12.0); try testSqrtLegacy(f32, 13.0); - comptime try testSqrtLegacy(f32, 13.0); + try comptime testSqrtLegacy(f32, 13.0); try testSqrtLegacy(f16, 13.0); - comptime try testSqrtLegacy(f16, 13.0); + try comptime testSqrtLegacy(f16, 13.0); // TODO: make this pass if (false) { const x = 14.0; const y = x * x; const z = @sqrt(y); - comptime try expect(z == x); + try comptime expect(z == x); } } @@ -214,7 +214,7 @@ test "@sin" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testSin(); + try comptime testSin(); try testSin(); } @@ -235,7 +235,7 @@ test "@sin with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testSinWithVectors(); + try comptime testSinWithVectors(); try testSinWithVectors(); } @@ -255,7 +255,7 @@ test "@cos" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testCos(); + try comptime testCos(); try testCos(); } @@ -276,7 +276,7 @@ test "@cos with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testCosWithVectors(); + try comptime testCosWithVectors(); try testCosWithVectors(); } @@ -296,7 +296,7 @@ test "@exp" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testExp(); + try comptime testExp(); try testExp(); } @@ -316,7 +316,7 @@ test "@exp with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testExpWithVectors(); + try comptime testExpWithVectors(); try testExpWithVectors(); } @@ -336,7 +336,7 @@ test "@exp2" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testExp2(); + try comptime testExp2(); try testExp2(); } @@ -356,7 +356,7 @@ test "@exp2 with @vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testExp2WithVectors(); + try comptime testExp2WithVectors(); try testExp2WithVectors(); } @@ -376,7 +376,7 @@ test "@log" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testLog(); + try comptime testLog(); try testLog(); } @@ -425,7 +425,7 @@ test "@log2" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testLog2(); + try comptime testLog2(); try testLog2(); } @@ -449,7 +449,7 @@ test "@log2 with vectors" { builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest; - comptime try testLog2WithVectors(); + try comptime testLog2WithVectors(); try testLog2WithVectors(); } @@ -469,7 +469,7 @@ test "@log10" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testLog10(); + try comptime testLog10(); try testLog10(); } @@ -489,7 +489,7 @@ test "@log10 with vectors" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testLog10WithVectors(); + try comptime testLog10WithVectors(); try testLog10WithVectors(); } @@ -507,7 +507,7 @@ test "@fabs" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - comptime try testFabs(); + try comptime testFabs(); try testFabs(); } @@ -535,7 +535,7 @@ test "@fabs with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testFabsWithVectors(); + try comptime testFabsWithVectors(); try testFabsWithVectors(); } @@ -556,18 +556,18 @@ test "another, possibly redundant, @fabs test" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFabsLegacy(f128, 12.0); - comptime try testFabsLegacy(f128, 12.0); + try comptime testFabsLegacy(f128, 12.0); try testFabsLegacy(f64, 12.0); - comptime try testFabsLegacy(f64, 12.0); + try comptime testFabsLegacy(f64, 12.0); try testFabsLegacy(f32, 12.0); - comptime try testFabsLegacy(f32, 12.0); + try comptime testFabsLegacy(f32, 12.0); try testFabsLegacy(f16, 12.0); - comptime try testFabsLegacy(f16, 12.0); + try comptime testFabsLegacy(f16, 12.0); const x = 14.0; const y = -x; const z = @fabs(y); - comptime try std.testing.expectEqual(x, z); + try comptime std.testing.expectEqual(x, z); } test "@fabs f80" { @@ -578,7 +578,7 @@ test "@fabs f80" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFabsLegacy(f80, 12.0); - comptime try testFabsLegacy(f80, 12.0); + try comptime testFabsLegacy(f80, 12.0); } fn testFabsLegacy(comptime T: type, x: T) !void { @@ -621,7 +621,7 @@ test "@floor" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - comptime try testFloor(); + try comptime testFloor(); try testFloor(); } @@ -646,7 +646,7 @@ test "@floor with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testFloorWithVectors(); + try comptime testFloorWithVectors(); try testFloorWithVectors(); } @@ -666,16 +666,16 @@ test "another, possibly redundant, @floor test" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFloorLegacy(f64, 12.0); - comptime try testFloorLegacy(f64, 12.0); + try comptime testFloorLegacy(f64, 12.0); try testFloorLegacy(f32, 12.0); - comptime try testFloorLegacy(f32, 12.0); + try comptime testFloorLegacy(f32, 12.0); try testFloorLegacy(f16, 12.0); - comptime try testFloorLegacy(f16, 12.0); + try comptime testFloorLegacy(f16, 12.0); const x = 14.0; const y = x + 0.7; const z = @floor(y); - comptime try expect(x == z); + try comptime expect(x == z); } test "@floor f80" { @@ -691,7 +691,7 @@ test "@floor f80" { } try testFloorLegacy(f80, 12.0); - comptime try testFloorLegacy(f80, 12.0); + try comptime testFloorLegacy(f80, 12.0); } test "@floor f128" { @@ -702,7 +702,7 @@ test "@floor f128" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFloorLegacy(f128, 12.0); - comptime try testFloorLegacy(f128, 12.0); + try comptime testFloorLegacy(f128, 12.0); } fn testFloorLegacy(comptime T: type, x: T) !void { @@ -717,7 +717,7 @@ test "@ceil" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testCeil(); + try comptime testCeil(); try testCeil(); } @@ -742,7 +742,7 @@ test "@ceil with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testCeilWithVectors(); + try comptime testCeilWithVectors(); try testCeilWithVectors(); } @@ -762,16 +762,16 @@ test "another, possibly redundant, @ceil test" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCeilLegacy(f64, 12.0); - comptime try testCeilLegacy(f64, 12.0); + try comptime testCeilLegacy(f64, 12.0); try testCeilLegacy(f32, 12.0); - comptime try testCeilLegacy(f32, 12.0); + try comptime testCeilLegacy(f32, 12.0); try testCeilLegacy(f16, 12.0); - comptime try testCeilLegacy(f16, 12.0); + try comptime testCeilLegacy(f16, 12.0); const x = 14.0; const y = x - 0.7; const z = @ceil(y); - comptime try expect(x == z); + try comptime expect(x == z); } test "@ceil f80" { @@ -787,7 +787,7 @@ test "@ceil f80" { } try testCeilLegacy(f80, 12.0); - comptime try testCeilLegacy(f80, 12.0); + try comptime testCeilLegacy(f80, 12.0); } test "@ceil f128" { @@ -798,7 +798,7 @@ test "@ceil f128" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCeilLegacy(f128, 12.0); - comptime try testCeilLegacy(f128, 12.0); + try comptime testCeilLegacy(f128, 12.0); } fn testCeilLegacy(comptime T: type, x: T) !void { @@ -812,7 +812,7 @@ test "@trunc" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - comptime try testTrunc(); + try comptime testTrunc(); try testTrunc(); } @@ -837,7 +837,7 @@ test "@trunc with vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testTruncWithVectors(); + try comptime testTruncWithVectors(); try testTruncWithVectors(); } @@ -857,16 +857,16 @@ test "another, possibly redundant, @trunc test" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testTruncLegacy(f64, 12.0); - comptime try testTruncLegacy(f64, 12.0); + try comptime testTruncLegacy(f64, 12.0); try testTruncLegacy(f32, 12.0); - comptime try testTruncLegacy(f32, 12.0); + try comptime testTruncLegacy(f32, 12.0); try testTruncLegacy(f16, 12.0); - comptime try testTruncLegacy(f16, 12.0); + try comptime testTruncLegacy(f16, 12.0); const x = 14.0; const y = x + 0.7; const z = @trunc(y); - comptime try expect(x == z); + try comptime expect(x == z); } test "@trunc f80" { @@ -882,7 +882,7 @@ test "@trunc f80" { } try testTruncLegacy(f80, 12.0); - comptime try testTruncLegacy(f80, 12.0); + try comptime testTruncLegacy(f80, 12.0); comptime { const x: f80 = 12.0; const y = x + 0.8; @@ -899,7 +899,7 @@ test "@trunc f128" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testTruncLegacy(f128, 12.0); - comptime try testTruncLegacy(f128, 12.0); + try comptime testTruncLegacy(f128, 12.0); } fn testTruncLegacy(comptime T: type, x: T) !void { @@ -939,7 +939,7 @@ test "negation f16" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "negation f32" { @@ -959,7 +959,7 @@ test "negation f32" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "negation f64" { @@ -979,7 +979,7 @@ test "negation f64" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "negation f80" { @@ -1001,7 +1001,7 @@ test "negation f80" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "negation f128" { @@ -1023,7 +1023,7 @@ test "negation f128" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "eval @setFloatMode at compile-time" { diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig index 4f05054522..4ccba00cec 100644 --- a/test/behavior/fn.zig +++ b/test/behavior/fn.zig @@ -211,7 +211,7 @@ test "pass by non-copying value through var arg" { } fn addPointCoordsVar(pt: anytype) !i32 { - comptime try expect(@TypeOf(pt) == Point); + try comptime expect(@TypeOf(pt) == Point); return pt.x + pt.y; } @@ -285,7 +285,7 @@ test "implicit cast fn call result to optional in field result" { }; }; try S.entry(); - comptime try S.entry(); + try comptime S.entry(); } test "void parameters" { @@ -344,7 +344,7 @@ fn fn4() u32 { test "number literal as an argument" { try numberLiteralArg(3); - comptime try numberLiteralArg(3); + try comptime numberLiteralArg(3); } fn numberLiteralArg(a: anytype) !void { @@ -369,7 +369,7 @@ test "function call with anon list literal" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "function call with anon list literal - 2D" { @@ -391,7 +391,7 @@ test "function call with anon list literal - 2D" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "ability to give comptime types and non comptime types to same parameter" { @@ -410,7 +410,7 @@ test "ability to give comptime types and non comptime types to same parameter" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "function with inferred error set but returning no error" { diff --git a/test/behavior/for.zig b/test/behavior/for.zig index c41fccfc80..773f08f9ce 100644 --- a/test/behavior/for.zig +++ b/test/behavior/for.zig @@ -23,7 +23,7 @@ test "continue in for loop" { test "break from outer for loop" { try testBreakOuter(); - comptime try testBreakOuter(); + try comptime testBreakOuter(); } fn testBreakOuter() !void { @@ -40,7 +40,7 @@ fn testBreakOuter() !void { test "continue outer for loop" { try testContinueOuter(); - comptime try testContinueOuter(); + try comptime testContinueOuter(); } fn testContinueOuter() !void { @@ -129,7 +129,7 @@ test "for with null and T peer types and inferred result location type" { } }; try S.doTheTest(&[_]u8{ 1, 2 }); - comptime try S.doTheTest(&[_]u8{ 1, 2 }); + try comptime S.doTheTest(&[_]u8{ 1, 2 }); } test "2 break statements and an else" { @@ -150,7 +150,7 @@ test "2 break statements and an else" { } }; try S.entry(true, false); - comptime try S.entry(true, false); + try comptime S.entry(true, false); } test "for loop with pointer elem var" { @@ -197,7 +197,7 @@ test "for copies its payload" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "for on slice with allowzero ptr" { @@ -214,7 +214,7 @@ test "for on slice with allowzero ptr" { } }; try S.doTheTest(&[_]u8{ 1, 2, 3, 4 }); - comptime try S.doTheTest(&[_]u8{ 1, 2, 3, 4 }); + try comptime S.doTheTest(&[_]u8{ 1, 2, 3, 4 }); } test "else continue outer for" { diff --git a/test/behavior/if.zig b/test/behavior/if.zig index c17f2c9891..49018cdfe2 100644 --- a/test/behavior/if.zig +++ b/test/behavior/if.zig @@ -93,7 +93,7 @@ test "if copies its payload" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "if prongs cast to expected type instead of peer type resolution" { @@ -109,7 +109,7 @@ test "if prongs cast to expected type instead of peer type resolution" { } }; try S.doTheTest(false); - comptime try S.doTheTest(false); + try comptime S.doTheTest(false); } test "if peer expressions inferred optional type" { diff --git a/test/behavior/int128.zig b/test/behavior/int128.zig index cdf32f02c2..6fd2c192a2 100644 --- a/test/behavior/int128.zig +++ b/test/behavior/int128.zig @@ -95,16 +95,16 @@ test "shift int128" { const types = .{ u128, i128 }; inline for (types) |t| { try testShlTrunc(t, 0x8, 123); - comptime try testShlTrunc(t, 0x8, 123); + try comptime testShlTrunc(t, 0x8, 123); try testShlTrunc(t, 0x40000000_00000000, 64); - comptime try testShlTrunc(t, 0x40000000_00000000, 64); + try comptime testShlTrunc(t, 0x40000000_00000000, 64); try testShlTrunc(t, 0x01000000_00000000_00000000, 38); - comptime try testShlTrunc(t, 0x01000000_00000000_00000000, 38); + try comptime testShlTrunc(t, 0x01000000_00000000_00000000, 38); try testShlTrunc(t, 0x00000008_00000000_00000000_00000000, 27); - comptime try testShlTrunc(t, 0x00000008_00000000_00000000_00000000, 27); + try comptime testShlTrunc(t, 0x00000008_00000000_00000000_00000000, 27); } } diff --git a/test/behavior/int_div.zig b/test/behavior/int_div.zig index c917dde1c9..98e4b361c7 100644 --- a/test/behavior/int_div.zig +++ b/test/behavior/int_div.zig @@ -9,7 +9,7 @@ test "integer division" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testDivision(); - comptime try testDivision(); + try comptime testDivision(); } fn testDivision() !void { try expect(div(u32, 13, 3) == 4); diff --git a/test/behavior/math.zig b/test/behavior/math.zig index 14f90ee3fa..42c328c7d4 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -40,7 +40,7 @@ test "assignment operators" { test "three expr in a row" { try testThreeExprInARow(false, true); - comptime try testThreeExprInARow(false, true); + try comptime testThreeExprInARow(false, true); } fn testThreeExprInARow(f: bool, t: bool) !void { try assertFalse(f or f or f); @@ -67,7 +67,7 @@ test "@clz" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testClz(); - comptime try testClz(); + try comptime testClz(); } fn testClz() !void { @@ -86,7 +86,7 @@ test "@clz big ints" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testClzBigInts(); - comptime try testClzBigInts(); + try comptime testClzBigInts(); } fn testClzBigInts() !void { @@ -107,7 +107,7 @@ test "@clz vectors" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testClzVectors(); - comptime try testClzVectors(); + try comptime testClzVectors(); } fn testClzVectors() !void { @@ -147,7 +147,7 @@ test "@ctz" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCtz(); - comptime try testCtz(); + try comptime testCtz(); } fn testCtz() !void { @@ -176,7 +176,7 @@ test "@ctz vectors" { } try testCtzVectors(); - comptime try testCtzVectors(); + try comptime testCtzVectors(); } fn testCtzVectors() !void { @@ -213,7 +213,7 @@ test "float equality" { const y: f64 = x + 1.0; try testFloatEqualityImpl(x, y); - comptime try testFloatEqualityImpl(x, y); + try comptime testFloatEqualityImpl(x, y); } fn testFloatEqualityImpl(x: f64, y: f64) !void { @@ -222,7 +222,7 @@ fn testFloatEqualityImpl(x: f64, y: f64) !void { } test "hex float literal parsing" { - comptime try expect(0x1.0 == 1.0); + try comptime expect(0x1.0 == 1.0); } test "hex float literal within range" { @@ -323,7 +323,7 @@ test "comptime_int multi-limb partial shift right" { test "xor" { try test_xor(); - comptime try test_xor(); + try comptime test_xor(); } fn test_xor() !void { @@ -412,7 +412,7 @@ test "division" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testDivision(); - comptime try testDivision(); + try comptime testDivision(); } fn testDivision() !void { @@ -492,7 +492,7 @@ test "division half-precision floats" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testDivisionFP16(); - comptime try testDivisionFP16(); + try comptime testDivisionFP16(); } fn testDivisionFP16() !void { @@ -527,7 +527,7 @@ fn mod(comptime T: type, a: T, b: T) T { test "unsigned wrapping" { try testUnsignedWrappingEval(maxInt(u32)); - comptime try testUnsignedWrappingEval(maxInt(u32)); + try comptime testUnsignedWrappingEval(maxInt(u32)); } fn testUnsignedWrappingEval(x: u32) !void { const zero = x +% 1; @@ -538,7 +538,7 @@ fn testUnsignedWrappingEval(x: u32) !void { test "signed wrapping" { try testSignedWrappingEval(maxInt(i32)); - comptime try testSignedWrappingEval(maxInt(i32)); + try comptime testSignedWrappingEval(maxInt(i32)); } fn testSignedWrappingEval(x: i32) !void { const min_val = x +% 1; @@ -549,7 +549,7 @@ fn testSignedWrappingEval(x: i32) !void { test "signed negation wrapping" { try testSignedNegationWrappingEval(minInt(i16)); - comptime try testSignedNegationWrappingEval(minInt(i16)); + try comptime testSignedNegationWrappingEval(minInt(i16)); } fn testSignedNegationWrappingEval(x: i16) !void { try expect(x == -32768); @@ -559,7 +559,7 @@ fn testSignedNegationWrappingEval(x: i16) !void { test "unsigned negation wrapping" { try testUnsignedNegationWrappingEval(1); - comptime try testUnsignedNegationWrappingEval(1); + try comptime testUnsignedNegationWrappingEval(1); } fn testUnsignedNegationWrappingEval(x: u16) !void { try expect(x == 1); @@ -586,7 +586,7 @@ test "unsigned 64-bit division" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try test_u64_div(); - comptime try test_u64_div(); + try comptime test_u64_div(); } fn test_u64_div() !void { const result = divWithResult(1152921504606846976, 34359738365); @@ -614,7 +614,7 @@ test "truncating shift right" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testShrTrunc(maxInt(u16)); - comptime try testShrTrunc(maxInt(u16)); + try comptime testShrTrunc(maxInt(u16)); } fn testShrTrunc(x: u16) !void { const shifted = x >> 1; @@ -630,7 +630,7 @@ test "f128" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try test_f128(); - comptime try test_f128(); + try comptime test_f128(); } fn make_f128(x: f128) f128 { @@ -1238,12 +1238,12 @@ test "quad hex float literal parsing accurate" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "truncating shift left" { try testShlTrunc(maxInt(u16)); - comptime try testShlTrunc(maxInt(u16)); + try comptime testShlTrunc(maxInt(u16)); } fn testShlTrunc(x: u16) !void { const shifted = x << 1; @@ -1254,7 +1254,7 @@ test "exact shift left" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testShlExact(0b00110101); - comptime try testShlExact(0b00110101); + try comptime testShlExact(0b00110101); } fn testShlExact(x: u8) !void { const shifted = @shlExact(x, 2); @@ -1265,7 +1265,7 @@ test "exact shift right" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testShrExact(0b10110100); - comptime try testShrExact(0b10110100); + try comptime testShrExact(0b10110100); } fn testShrExact(x: u8) !void { const shifted = @shrExact(x, 2); @@ -1288,7 +1288,7 @@ test "shift left/right on u0 operand" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "comptime float rem int" { @@ -1311,11 +1311,11 @@ test "remainder division" { return error.SkipZigTest; } - comptime try remdiv(f16); - comptime try remdiv(f32); - comptime try remdiv(f64); - comptime try remdiv(f80); - comptime try remdiv(f128); + try comptime remdiv(f16); + try comptime remdiv(f32); + try comptime remdiv(f64); + try comptime remdiv(f80); + try comptime remdiv(f128); try remdiv(f16); try remdiv(f64); try remdiv(f80); @@ -1343,11 +1343,11 @@ test "float remainder division using @rem" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - comptime try frem(f16); - comptime try frem(f32); - comptime try frem(f64); - comptime try frem(f80); - comptime try frem(f128); + try comptime frem(f16); + try comptime frem(f32); + try comptime frem(f64); + try comptime frem(f80); + try comptime frem(f128); try frem(f16); try frem(f32); try frem(f64); @@ -1386,11 +1386,11 @@ test "float modulo division using @mod" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try fmod(f16); - comptime try fmod(f32); - comptime try fmod(f64); - comptime try fmod(f80); - comptime try fmod(f128); + try comptime fmod(f16); + try comptime fmod(f32); + try comptime fmod(f64); + try comptime fmod(f80); + try comptime fmod(f128); try fmod(f16); try fmod(f32); try fmod(f64); @@ -1430,16 +1430,16 @@ test "@round" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testRound(f64, 12.0); - comptime try testRound(f64, 12.0); + try comptime testRound(f64, 12.0); try testRound(f32, 12.0); - comptime try testRound(f32, 12.0); + try comptime testRound(f32, 12.0); try testRound(f16, 12.0); - comptime try testRound(f16, 12.0); + try comptime testRound(f16, 12.0); const x = 14.0; const y = x + 0.4; const z = @round(y); - comptime try expect(x == z); + try comptime expect(x == z); } test "@round f80" { @@ -1451,7 +1451,7 @@ test "@round f80" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testRound(f80, 12.0); - comptime try testRound(f80, 12.0); + try comptime testRound(f80, 12.0); } test "@round f128" { @@ -1463,7 +1463,7 @@ test "@round f128" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testRound(f128, 12.0); - comptime try testRound(f128, 12.0); + try comptime testRound(f128, 12.0); } fn testRound(comptime T: type, x: T) !void { @@ -1491,7 +1491,7 @@ test "vector integer addition" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "NaN comparison" { @@ -1506,10 +1506,10 @@ test "NaN comparison" { try testNanEqNan(f32); try testNanEqNan(f64); try testNanEqNan(f128); - comptime try testNanEqNan(f16); - comptime try testNanEqNan(f32); - comptime try testNanEqNan(f64); - comptime try testNanEqNan(f128); + try comptime testNanEqNan(f16); + try comptime testNanEqNan(f32); + try comptime testNanEqNan(f64); + try comptime testNanEqNan(f128); } test "NaN comparison f80" { @@ -1521,7 +1521,7 @@ test "NaN comparison f80" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testNanEqNan(f80); - comptime try testNanEqNan(f80); + try comptime testNanEqNan(f80); } fn testNanEqNan(comptime F: type) !void { @@ -1556,7 +1556,7 @@ test "vector comparison" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "compare undefined literal with comptime_int" { @@ -1593,7 +1593,7 @@ test "signed zeros are represented properly" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "comptime sin and ln" { @@ -1609,7 +1609,7 @@ test "absFloat" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testAbsFloat(); - comptime try testAbsFloat(); + try comptime testAbsFloat(); } fn testAbsFloat() !void { try testAbsFloatOne(-10.05, 10.05); diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig index 932a904421..7d382e961f 100644 --- a/test/behavior/maximum_minimum.zig +++ b/test/behavior/maximum_minimum.zig @@ -19,7 +19,7 @@ test "@max" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@max on vectors" { @@ -50,7 +50,7 @@ test "@max on vectors" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@min" { @@ -68,7 +68,7 @@ test "@min" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@min for vectors" { @@ -99,7 +99,7 @@ test "@min for vectors" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@min/max for floats" { @@ -123,9 +123,9 @@ test "@min/max for floats" { inline for (.{ f16, f32, f64, f80, f128, c_longdouble }) |T| { try S.doTheTest(T); - comptime try S.doTheTest(T); + try comptime S.doTheTest(T); } - comptime try S.doTheTest(comptime_float); + try comptime S.doTheTest(comptime_float); } test "@min/@max on lazy values" { diff --git a/test/behavior/muladd.zig b/test/behavior/muladd.zig index c4e1dd1c30..023b7621cf 100644 --- a/test/behavior/muladd.zig +++ b/test/behavior/muladd.zig @@ -12,7 +12,7 @@ test "@mulAdd" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testMulAdd(); + try comptime testMulAdd(); try testMulAdd(); } @@ -38,7 +38,7 @@ test "@mulAdd f16" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testMulAdd16(); + try comptime testMulAdd16(); try testMulAdd16(); } @@ -57,7 +57,7 @@ test "@mulAdd f80" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testMulAdd80(); + try comptime testMulAdd80(); try testMulAdd80(); } @@ -76,7 +76,7 @@ test "@mulAdd f128" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testMulAdd128(); + try comptime testMulAdd128(); try testMulAdd128(); } @@ -107,7 +107,7 @@ test "vector f16" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector16(); + try comptime vector16(); try vector16(); } @@ -131,7 +131,7 @@ test "vector f32" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector32(); + try comptime vector32(); try vector32(); } @@ -155,7 +155,7 @@ test "vector f64" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector64(); + try comptime vector64(); try vector64(); } @@ -178,7 +178,7 @@ test "vector f80" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector80(); + try comptime vector80(); try vector80(); } @@ -202,6 +202,6 @@ test "vector f128" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try vector128(); + try comptime vector128(); try vector128(); } diff --git a/test/behavior/null.zig b/test/behavior/null.zig index d4fcd8360d..e9fc66f4b8 100644 --- a/test/behavior/null.zig +++ b/test/behavior/null.zig @@ -56,7 +56,7 @@ test "maybe return" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try maybeReturnImpl(); - comptime try maybeReturnImpl(); + try comptime maybeReturnImpl(); } fn maybeReturnImpl() !void { @@ -87,7 +87,7 @@ test "optional void" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try optionalVoidImpl(); - comptime try optionalVoidImpl(); + try comptime optionalVoidImpl(); } fn optionalVoidImpl() !void { @@ -111,7 +111,7 @@ test "optional struct{}" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; _ = try optionalEmptyStructImpl(); - _ = comptime try optionalEmptyStructImpl(); + _ = try comptime optionalEmptyStructImpl(); } fn optionalEmptyStructImpl() !void { diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig index 8a38f95366..865d960847 100644 --- a/test/behavior/optional.zig +++ b/test/behavior/optional.zig @@ -20,7 +20,7 @@ test "passing an optional integer as a parameter" { } }; try expect(S.entry()); - comptime try expect(S.entry()); + try comptime expect(S.entry()); } pub const EmptyStruct = struct {}; @@ -38,7 +38,7 @@ test "equality compare optional pointers" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testNullPtrsEql(); - comptime try testNullPtrsEql(); + try comptime testNullPtrsEql(); } fn testNullPtrsEql() !void { @@ -117,7 +117,7 @@ test "equality compare optional with non-optional" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try test_cmp_optional_non_optional(); - comptime try test_cmp_optional_non_optional(); + try comptime test_cmp_optional_non_optional(); } fn test_cmp_optional_non_optional() !void { @@ -168,7 +168,7 @@ test "unwrap function call with optional pointer return value" { } }; try S.entry(); - comptime try S.entry(); + try comptime S.entry(); } test "nested orelse" { @@ -195,7 +195,7 @@ test "nested orelse" { }; }; try S.entry(); - comptime try S.entry(); + try comptime S.entry(); } test "self-referential struct through a slice of optional" { @@ -250,7 +250,7 @@ test "coerce an anon struct literal to optional struct" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "0-bit child type coerced to optional return ptr result location" { @@ -277,7 +277,7 @@ test "0-bit child type coerced to optional return ptr result location" { }; }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "0-bit child type coerced to optional" { @@ -303,7 +303,7 @@ test "0-bit child type coerced to optional" { }; }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "array of optional unaligned types" { diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig index 0bd6390796..5a6e92403b 100644 --- a/test/behavior/packed-struct.zig +++ b/test/behavior/packed-struct.zig @@ -351,7 +351,7 @@ test "byte-aligned field pointer offsets" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "load pointer from packed struct" { diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig index d343c5dbc4..32c2dc13ac 100644 --- a/test/behavior/pointers.zig +++ b/test/behavior/pointers.zig @@ -5,7 +5,7 @@ const expect = testing.expect; const expectError = testing.expectError; test "dereference pointer" { - comptime try testDerefPtr(); + try comptime testDerefPtr(); try testDerefPtr(); } @@ -42,7 +42,7 @@ test "pointer arithmetic" { } test "double pointer parsing" { - comptime try expect(PtrOf(PtrOf(i32)) == **i32); + try comptime expect(PtrOf(PtrOf(i32)) == **i32); } fn PtrOf(comptime T: type) type { @@ -62,7 +62,7 @@ test "implicit cast single item pointer to C pointer and back" { test "initialize const optional C pointer to null" { const a: ?[*c]i32 = null; try expect(a == null); - comptime try expect(a == null); + try comptime expect(a == null); } test "assigning integer to C pointer" { @@ -105,12 +105,12 @@ test "C pointer comparison and arithmetic" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "dereference pointer again" { try testDerefPtrOneVal(); - comptime try testDerefPtrOneVal(); + try comptime testDerefPtrOneVal(); } const Foo1 = struct { @@ -180,7 +180,7 @@ test "implicit cast error unions with non-optional to optional pointer" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "compare equality of optional and non-optional pointer" { @@ -203,11 +203,11 @@ test "allowzero pointer and slice" { try expect(@ptrToInt(ptr) == 0); var runtime_zero: usize = 0; var slice = ptr[runtime_zero..10]; - comptime try expect(@TypeOf(slice) == []allowzero i32); + try comptime expect(@TypeOf(slice) == []allowzero i32); try expect(@ptrToInt(&slice[5]) == 20); - comptime try expect(@typeInfo(@TypeOf(ptr)).Pointer.is_allowzero); - comptime try expect(@typeInfo(@TypeOf(slice)).Pointer.is_allowzero); + try comptime expect(@typeInfo(@TypeOf(ptr)).Pointer.is_allowzero); + try comptime expect(@typeInfo(@TypeOf(slice)).Pointer.is_allowzero); } test "assign null directly to C pointer and test null equality" { @@ -229,17 +229,17 @@ test "assign null directly to C pointer and test null equality" { try expect((x orelse &otherx) == &otherx); const y: [*c]i32 = null; - comptime try expect(y == null); - comptime try expect(null == y); - comptime try expect(!(y != null)); - comptime try expect(!(null != y)); + try comptime expect(y == null); + try comptime expect(null == y); + try comptime expect(!(y != null)); + try comptime expect(!(null != y)); if (y) |same_y| { _ = same_y; @panic("fail"); } const othery: i32 = undefined; const ptr_othery = &othery; - comptime try expect((y orelse ptr_othery) == ptr_othery); + try comptime expect((y orelse ptr_othery) == ptr_othery); var n: i32 = 1234; var x1: [*c]i32 = &n; @@ -257,17 +257,17 @@ test "assign null directly to C pointer and test null equality" { const nc: i32 = 1234; const y1: [*c]const i32 = &nc; - comptime try expect(!(y1 == null)); - comptime try expect(!(null == y1)); - comptime try expect(y1 != null); - comptime try expect(null != y1); - comptime try expect(y1.?.* == 1234); + try comptime expect(!(y1 == null)); + try comptime expect(!(null == y1)); + try comptime expect(y1 != null); + try comptime expect(null != y1); + try comptime expect(y1.?.* == 1234); if (y1) |same_y1| { try expect(same_y1.* == 1234); } else { @compileError("fail"); } - comptime try expect((y1 orelse &othery) == y1); + try comptime expect((y1 orelse &othery) == y1); } test "array initialization types" { @@ -293,7 +293,7 @@ test "null terminated pointer" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "allow any sentinel" { @@ -308,7 +308,7 @@ test "allow any sentinel" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "pointer sentinel with enums" { @@ -325,11 +325,11 @@ test "pointer sentinel with enums" { fn doTheTest() !void { var ptr: [*:.sentinel]const Number = &[_:.sentinel]Number{ .one, .two, .two, .one }; - try expect(ptr[4] == .sentinel); // TODO this should be comptime try expect, see #3731 + try expect(ptr[4] == .sentinel); // TODO this should be try comptime expect, see #3731 } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "pointer sentinel with optional element" { @@ -341,11 +341,11 @@ test "pointer sentinel with optional element" { const S = struct { fn doTheTest() !void { var ptr: [*:null]const ?i32 = &[_:null]?i32{ 1, 2, 3, 4 }; - try expect(ptr[4] == null); // TODO this should be comptime try expect, see #3731 + try expect(ptr[4] == null); // TODO this should be try comptime expect, see #3731 } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "pointer sentinel with +inf" { @@ -359,11 +359,11 @@ test "pointer sentinel with +inf" { fn doTheTest() !void { const inf_f32 = comptime std.math.inf(f32); var ptr: [*:inf_f32]const f32 = &[_:inf_f32]f32{ 1.1, 2.2, 3.3, 4.4 }; - try expect(ptr[4] == inf_f32); // TODO this should be comptime try expect, see #3731 + try expect(ptr[4] == inf_f32); // TODO this should be try comptime expect, see #3731 } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "pointer to array at fixed address" { @@ -409,11 +409,11 @@ test "@ptrToInt on null optional at comptime" { const pointer = @intToPtr(?*u8, 0x000); const x = @ptrToInt(pointer); _ = x; - comptime try expect(0 == @ptrToInt(pointer)); + try comptime expect(0 == @ptrToInt(pointer)); } { const pointer = @intToPtr(?*u8, 0xf00); - comptime try expect(0xf00 == @ptrToInt(pointer)); + try comptime expect(0xf00 == @ptrToInt(pointer)); } } @@ -447,7 +447,7 @@ test "element pointer to slice" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "element pointer arithmetic to slice" { @@ -473,7 +473,7 @@ test "element pointer arithmetic to slice" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "array slicing to slice" { @@ -491,7 +491,7 @@ test "array slicing to slice" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "pointer to constant decl preserves alignment" { diff --git a/test/behavior/popcount.zig b/test/behavior/popcount.zig index a7204fab30..51146b14c8 100644 --- a/test/behavior/popcount.zig +++ b/test/behavior/popcount.zig @@ -9,7 +9,7 @@ test "@popCount integers" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testPopCountIntegers(); + try comptime testPopCountIntegers(); try testPopCountIntegers(); } @@ -75,7 +75,7 @@ test "@popCount vectors" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try testPopCountVectors(); + try comptime testPopCountVectors(); try testPopCountVectors(); } diff --git a/test/behavior/ptrcast.zig b/test/behavior/ptrcast.zig index 5051dc0ecb..aadae132d9 100644 --- a/test/behavior/ptrcast.zig +++ b/test/behavior/ptrcast.zig @@ -7,7 +7,7 @@ test "reinterpret bytes as integer with nonzero offset" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testReinterpretBytesAsInteger(); - comptime try testReinterpretBytesAsInteger(); + try comptime testReinterpretBytesAsInteger(); } fn testReinterpretBytesAsInteger() !void { @@ -26,7 +26,7 @@ test "reinterpret an array over multiple elements, with no well-defined layout" if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testReinterpretWithOffsetAndNoWellDefinedLayout(); - comptime try testReinterpretWithOffsetAndNoWellDefinedLayout(); + try comptime testReinterpretWithOffsetAndNoWellDefinedLayout(); } fn testReinterpretWithOffsetAndNoWellDefinedLayout() !void { @@ -41,7 +41,7 @@ test "reinterpret bytes inside auto-layout struct as integer with nonzero offset if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testReinterpretStructWrappedBytesAsInteger(); - comptime try testReinterpretStructWrappedBytesAsInteger(); + try comptime testReinterpretStructWrappedBytesAsInteger(); } fn testReinterpretStructWrappedBytesAsInteger() !void { @@ -59,7 +59,7 @@ test "reinterpret bytes of an array into an extern struct" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testReinterpretBytesAsExternStruct(); - comptime try testReinterpretBytesAsExternStruct(); + try comptime testReinterpretBytesAsExternStruct(); } fn testReinterpretBytesAsExternStruct() !void { @@ -80,7 +80,7 @@ test "reinterpret bytes of an extern struct (with under-aligned fields) into ano if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testReinterpretExternStructAsExternStruct(); - comptime try testReinterpretExternStructAsExternStruct(); + try comptime testReinterpretExternStructAsExternStruct(); } fn testReinterpretExternStructAsExternStruct() !void { @@ -104,7 +104,7 @@ test "reinterpret bytes of an extern struct into another" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testReinterpretOverAlignedExternStructAsExternStruct(); - comptime try testReinterpretOverAlignedExternStructAsExternStruct(); + try comptime testReinterpretOverAlignedExternStructAsExternStruct(); } fn testReinterpretOverAlignedExternStructAsExternStruct() !void { diff --git a/test/behavior/saturating_arithmetic.zig b/test/behavior/saturating_arithmetic.zig index 18baada0e5..4203aec0d9 100644 --- a/test/behavior/saturating_arithmetic.zig +++ b/test/behavior/saturating_arithmetic.zig @@ -38,16 +38,16 @@ test "saturating add" { }; try S.doTheTest(); - comptime try S.doTheTest(); - - comptime try S.testSatAdd(comptime_int, 0, 0, 0); - comptime try S.testSatAdd(comptime_int, -1, 1, 0); - comptime try S.testSatAdd(comptime_int, 3, 2, 5); - comptime try S.testSatAdd(comptime_int, -3, -2, -5); - comptime try S.testSatAdd(comptime_int, 3, -2, 1); - comptime try S.testSatAdd(comptime_int, -3, 2, -1); - comptime try S.testSatAdd(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 1119305249183743626545271163355074748512); - comptime try S.testSatAdd(comptime_int, 7, -593423721213448152027139550640105366508, -593423721213448152027139550640105366501); + try comptime S.doTheTest(); + + try comptime S.testSatAdd(comptime_int, 0, 0, 0); + try comptime S.testSatAdd(comptime_int, -1, 1, 0); + try comptime S.testSatAdd(comptime_int, 3, 2, 5); + try comptime S.testSatAdd(comptime_int, -3, -2, -5); + try comptime S.testSatAdd(comptime_int, 3, -2, 1); + try comptime S.testSatAdd(comptime_int, -3, 2, -1); + try comptime S.testSatAdd(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 1119305249183743626545271163355074748512); + try comptime S.testSatAdd(comptime_int, 7, -593423721213448152027139550640105366508, -593423721213448152027139550640105366501); } test "saturating add 128bit" { @@ -74,7 +74,7 @@ test "saturating add 128bit" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "saturating subtraction" { @@ -110,16 +110,16 @@ test "saturating subtraction" { }; try S.doTheTest(); - comptime try S.doTheTest(); - - comptime try S.testSatSub(comptime_int, 0, 0, 0); - comptime try S.testSatSub(comptime_int, 1, 1, 0); - comptime try S.testSatSub(comptime_int, 3, 2, 1); - comptime try S.testSatSub(comptime_int, -3, -2, -1); - comptime try S.testSatSub(comptime_int, 3, -2, 5); - comptime try S.testSatSub(comptime_int, -3, 2, -5); - comptime try S.testSatSub(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 182846383813587550256162760261375991602); - comptime try S.testSatSub(comptime_int, 7, -593423721213448152027139550640105366508, 593423721213448152027139550640105366515); + try comptime S.doTheTest(); + + try comptime S.testSatSub(comptime_int, 0, 0, 0); + try comptime S.testSatSub(comptime_int, 1, 1, 0); + try comptime S.testSatSub(comptime_int, 3, 2, 1); + try comptime S.testSatSub(comptime_int, -3, -2, -1); + try comptime S.testSatSub(comptime_int, 3, -2, 5); + try comptime S.testSatSub(comptime_int, -3, 2, -5); + try comptime S.testSatSub(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 182846383813587550256162760261375991602); + try comptime S.testSatSub(comptime_int, 7, -593423721213448152027139550640105366508, 593423721213448152027139550640105366515); } test "saturating subtraction 128bit" { @@ -147,7 +147,7 @@ test "saturating subtraction 128bit" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "saturating multiplication" { @@ -188,12 +188,12 @@ test "saturating multiplication" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); - comptime try S.testSatMul(comptime_int, 0, 0, 0); - comptime try S.testSatMul(comptime_int, 3, 2, 6); - comptime try S.testSatMul(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 304852860194144160265083087140337419215516305999637969803722975979232817921935); - comptime try S.testSatMul(comptime_int, 7, -593423721213448152027139550640105366508, -4153966048494137064189976854480737565556); + try comptime S.testSatMul(comptime_int, 0, 0, 0); + try comptime S.testSatMul(comptime_int, 3, 2, 6); + try comptime S.testSatMul(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 304852860194144160265083087140337419215516305999637969803722975979232817921935); + try comptime S.testSatMul(comptime_int, 7, -593423721213448152027139550640105366508, -4153966048494137064189976854480737565556); } test "saturating shift-left" { @@ -228,12 +228,12 @@ test "saturating shift-left" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); - comptime try S.testSatShl(comptime_int, 0, 0, 0); - comptime try S.testSatShl(comptime_int, 1, 2, 4); - comptime try S.testSatShl(comptime_int, 13, 150, 18554220005177478453757717602843436772975706112); - comptime try S.testSatShl(comptime_int, -582769, 180, -893090893854873184096635538665358532628308979495815656505344); + try comptime S.testSatShl(comptime_int, 0, 0, 0); + try comptime S.testSatShl(comptime_int, 1, 2, 4); + try comptime S.testSatShl(comptime_int, 13, 150, 18554220005177478453757717602843436772975706112); + try comptime S.testSatShl(comptime_int, -582769, 180, -893090893854873184096635538665358532628308979495815656505344); } test "saturating shl uses the LHS type" { diff --git a/test/behavior/select.zig b/test/behavior/select.zig index c4549ab107..66cc0a49b0 100644 --- a/test/behavior/select.zig +++ b/test/behavior/select.zig @@ -11,7 +11,7 @@ test "@select vectors" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try selectVectors(); + try comptime selectVectors(); try selectVectors(); } @@ -40,7 +40,7 @@ test "@select arrays" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try selectArrays(); + try comptime selectArrays(); try selectArrays(); } diff --git a/test/behavior/shuffle.zig b/test/behavior/shuffle.zig index ed60bcad41..6137c66f1f 100644 --- a/test/behavior/shuffle.zig +++ b/test/behavior/shuffle.zig @@ -41,7 +41,7 @@ test "@shuffle int" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@shuffle bool 1" { @@ -62,7 +62,7 @@ test "@shuffle bool 1" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@shuffle bool 2" { @@ -88,5 +88,5 @@ test "@shuffle bool 2" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig index 6f7d420646..a14ae1c6e7 100644 --- a/test/behavior/sizeof_and_typeof.zig +++ b/test/behavior/sizeof_and_typeof.zig @@ -24,21 +24,21 @@ test "@TypeOf() with multiple arguments" { var var_1: u32 = undefined; var var_2: u8 = undefined; var var_3: u64 = undefined; - comptime try expect(@TypeOf(var_1, var_2, var_3) == u64); + try comptime expect(@TypeOf(var_1, var_2, var_3) == u64); } { var var_1: f16 = undefined; var var_2: f32 = undefined; var var_3: f64 = undefined; - comptime try expect(@TypeOf(var_1, var_2, var_3) == f64); + try comptime expect(@TypeOf(var_1, var_2, var_3) == f64); } { var var_1: u16 = undefined; - comptime try expect(@TypeOf(var_1, 0xffff) == u16); + try comptime expect(@TypeOf(var_1, 0xffff) == u16); } { var var_1: f32 = undefined; - comptime try expect(@TypeOf(var_1, 3.1415) == f32); + try comptime expect(@TypeOf(var_1, 3.1415) == f32); } } @@ -148,7 +148,7 @@ test "@TypeOf() has no runtime side effects" { }; var data: i32 = 0; const T = @TypeOf(S.foo(i32, &data)); - comptime try expect(T == i32); + try comptime expect(T == i32); try expect(data == 0); } @@ -163,7 +163,7 @@ test "branching logic inside @TypeOf" { } }; const T = @TypeOf(S.foo() catch undefined); - comptime try expect(T == i32); + try comptime expect(T == i32); try expect(S.data == 0); } @@ -236,7 +236,7 @@ test "hardcoded address in typeof expression" { } }; try expect(S.func() == 0); - comptime try expect(S.func() == 0); + try comptime expect(S.func() == 0); } test "array access of generic param in typeof expression" { @@ -246,7 +246,7 @@ test "array access of generic param in typeof expression" { } }; try expect(S.first("a") == 'a'); - comptime try expect(S.first("a") == 'a'); + try comptime expect(S.first("a") == 'a'); } test "lazy size cast to float" { diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig index 5a5aa5ec72..fb9d1e047a 100644 --- a/test/behavior/slice.zig +++ b/test/behavior/slice.zig @@ -87,7 +87,7 @@ test "access len index of sentinel-terminated slice" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "comptime slice of slice preserves comptime var" { @@ -139,7 +139,7 @@ test "slice of hardcoded address to pointer" { const S = struct { fn doTheTest() !void { const pointer = @intToPtr([*]u8, 0x04)[0..2]; - comptime try expect(@TypeOf(pointer) == *[2]u8); + try comptime expect(@TypeOf(pointer) == *[2]u8); const slice: []const u8 = pointer; try expect(@ptrToInt(slice.ptr) == 4); try expect(slice.len == 2); @@ -214,9 +214,9 @@ test "slice string literal has correct type" { try expect(@TypeOf(array[0..]) == *const [4]i32); } var runtime_zero: usize = 0; - comptime try expect(@TypeOf("aoeu"[runtime_zero..]) == [:0]const u8); + try comptime expect(@TypeOf("aoeu"[runtime_zero..]) == [:0]const u8); const array = [_]i32{ 1, 2, 3, 4 }; - comptime try expect(@TypeOf(array[runtime_zero..]) == []const i32); + try comptime expect(@TypeOf(array[runtime_zero..]) == []const i32); } test "result location zero sized array inside struct field implicit cast to slice" { @@ -265,8 +265,8 @@ test "C pointer slice access" { const c_ptr = @ptrCast([*c]const u32, &buf); var runtime_zero: usize = 0; - comptime try expectEqual([]const u32, @TypeOf(c_ptr[runtime_zero..1])); - comptime try expectEqual(*const [1]u32, @TypeOf(c_ptr[0..1])); + try comptime expectEqual([]const u32, @TypeOf(c_ptr[runtime_zero..1])); + try comptime expectEqual(*const [1]u32, @TypeOf(c_ptr[0..1])); for (c_ptr[0..5]) |*cl| { try expect(@as(u32, 42) == cl.*); @@ -320,10 +320,10 @@ test "obtaining a null terminated slice" { var runtime_len: usize = 3; const ptr2 = buf[0..runtime_len :0]; // ptr2 is a null-terminated slice - comptime try expect(@TypeOf(ptr2) == [:0]u8); - comptime try expect(@TypeOf(ptr2[0..2]) == *[2]u8); + try comptime expect(@TypeOf(ptr2) == [:0]u8); + try comptime expect(@TypeOf(ptr2[0..2]) == *[2]u8); var runtime_zero: usize = 0; - comptime try expect(@TypeOf(ptr2[runtime_zero..2]) == []u8); + try comptime expect(@TypeOf(ptr2[runtime_zero..2]) == []u8); } test "empty array to slice" { @@ -340,7 +340,7 @@ test "empty array to slice" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@ptrCast slice to pointer" { @@ -358,7 +358,7 @@ test "@ptrCast slice to pointer" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "slice syntax resulting in pointer-to-array" { @@ -389,29 +389,29 @@ test "slice syntax resulting in pointer-to-array" { fn testArray() !void { var array = [5]u8{ 1, 2, 3, 4, 5 }; var slice = array[1..3]; - comptime try expect(@TypeOf(slice) == *[2]u8); + try comptime expect(@TypeOf(slice) == *[2]u8); try expect(slice[0] == 2); try expect(slice[1] == 3); } fn testArrayZ() !void { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; - comptime try expect(@TypeOf(array[1..3]) == *[2]u8); - comptime try expect(@TypeOf(array[1..5]) == *[4:0]u8); - comptime try expect(@TypeOf(array[1..]) == *[4:0]u8); - comptime try expect(@TypeOf(array[1..3 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(array[1..3]) == *[2]u8); + try comptime expect(@TypeOf(array[1..5]) == *[4:0]u8); + try comptime expect(@TypeOf(array[1..]) == *[4:0]u8); + try comptime expect(@TypeOf(array[1..3 :4]) == *[2:4]u8); } fn testArray0() !void { { var array = [0]u8{}; var slice = array[0..0]; - comptime try expect(@TypeOf(slice) == *[0]u8); + try comptime expect(@TypeOf(slice) == *[0]u8); } { var array = [0:0]u8{}; var slice = array[0..0]; - comptime try expect(@TypeOf(slice) == *[0:0]u8); + try comptime expect(@TypeOf(slice) == *[0:0]u8); try expect(slice[0] == 0); } } @@ -419,16 +419,16 @@ test "slice syntax resulting in pointer-to-array" { fn testArrayAlign() !void { var array align(4) = [5]u8{ 1, 2, 3, 4, 5 }; var slice = array[4..5]; - comptime try expect(@TypeOf(slice) == *align(4) [1]u8); + try comptime expect(@TypeOf(slice) == *align(4) [1]u8); try expect(slice[0] == 5); - comptime try expect(@TypeOf(array[0..2]) == *align(4) [2]u8); + try comptime expect(@TypeOf(array[0..2]) == *align(4) [2]u8); } fn testPointer() !void { var array = [5]u8{ 1, 2, 3, 4, 5 }; var pointer: [*]u8 = &array; var slice = pointer[1..3]; - comptime try expect(@TypeOf(slice) == *[2]u8); + try comptime expect(@TypeOf(slice) == *[2]u8); try expect(slice[0] == 2); try expect(slice[1] == 3); } @@ -436,14 +436,14 @@ test "slice syntax resulting in pointer-to-array" { fn testPointerZ() !void { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; var pointer: [*:0]u8 = &array; - comptime try expect(@TypeOf(pointer[1..3]) == *[2]u8); - comptime try expect(@TypeOf(pointer[1..3 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(pointer[1..3]) == *[2]u8); + try comptime expect(@TypeOf(pointer[1..3 :4]) == *[2:4]u8); } fn testPointer0() !void { var pointer: [*]const u0 = &[1]u0{0}; var slice = pointer[0..1]; - comptime try expect(@TypeOf(slice) == *const [1]u0); + try comptime expect(@TypeOf(slice) == *const [1]u0); try expect(slice[0] == 0); } @@ -451,16 +451,16 @@ test "slice syntax resulting in pointer-to-array" { var array align(4) = [5]u8{ 1, 2, 3, 4, 5 }; var pointer: [*]align(4) u8 = &array; var slice = pointer[4..5]; - comptime try expect(@TypeOf(slice) == *align(4) [1]u8); + try comptime expect(@TypeOf(slice) == *align(4) [1]u8); try expect(slice[0] == 5); - comptime try expect(@TypeOf(pointer[0..2]) == *align(4) [2]u8); + try comptime expect(@TypeOf(pointer[0..2]) == *align(4) [2]u8); } fn testSlice() !void { var array = [5]u8{ 1, 2, 3, 4, 5 }; var src_slice: []u8 = &array; var slice = src_slice[1..3]; - comptime try expect(@TypeOf(slice) == *[2]u8); + try comptime expect(@TypeOf(slice) == *[2]u8); try expect(slice[0] == 2); try expect(slice[1] == 3); } @@ -468,26 +468,26 @@ test "slice syntax resulting in pointer-to-array" { fn testSliceZ() !void { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; var slice: [:0]u8 = &array; - comptime try expect(@TypeOf(slice[1..3]) == *[2]u8); - comptime try expect(@TypeOf(slice[1..]) == [:0]u8); - comptime try expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(slice[1..3]) == *[2]u8); + try comptime expect(@TypeOf(slice[1..]) == [:0]u8); + try comptime expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8); } fn testSliceOpt() !void { var array: [2]u8 = [2]u8{ 1, 2 }; var slice: ?[]u8 = &array; - comptime try expect(@TypeOf(&array, slice) == ?[]u8); - comptime try expect(@TypeOf(slice, &array) == ?[]u8); - comptime try expect(@TypeOf(slice.?[0..2]) == *[2]u8); + try comptime expect(@TypeOf(&array, slice) == ?[]u8); + try comptime expect(@TypeOf(slice, &array) == ?[]u8); + try comptime expect(@TypeOf(slice.?[0..2]) == *[2]u8); } fn testSliceAlign() !void { var array align(4) = [5]u8{ 1, 2, 3, 4, 5 }; var src_slice: []align(4) u8 = &array; var slice = src_slice[4..5]; - comptime try expect(@TypeOf(slice) == *align(4) [1]u8); + try comptime expect(@TypeOf(slice) == *align(4) [1]u8); try expect(slice[0] == 5); - comptime try expect(@TypeOf(src_slice[0..2]) == *align(4) [2]u8); + try comptime expect(@TypeOf(src_slice[0..2]) == *align(4) [2]u8); } fn testConcatStrLiterals() !void { @@ -498,67 +498,67 @@ test "slice syntax resulting in pointer-to-array" { fn testSliceLength() !void { var array = [5]u8{ 1, 2, 3, 4, 5 }; var slice: []u8 = &array; - comptime try expect(@TypeOf(slice[1..][0..2]) == *[2]u8); - comptime try expect(@TypeOf(slice[1..][0..4]) == *[4]u8); - comptime try expect(@TypeOf(slice[1..][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(slice[1..][0..2]) == *[2]u8); + try comptime expect(@TypeOf(slice[1..][0..4]) == *[4]u8); + try comptime expect(@TypeOf(slice[1..][0..2 :4]) == *[2:4]u8); } fn testSliceLengthZ() !void { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; var slice: [:0]u8 = &array; - comptime try expect(@TypeOf(slice[1..][0..2]) == *[2]u8); - comptime try expect(@TypeOf(slice[1..][0..2 :4]) == *[2:4]u8); - comptime try expect(@TypeOf(slice[1.. :0][0..2]) == *[2]u8); - comptime try expect(@TypeOf(slice[1.. :0][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(slice[1..][0..2]) == *[2]u8); + try comptime expect(@TypeOf(slice[1..][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(slice[1.. :0][0..2]) == *[2]u8); + try comptime expect(@TypeOf(slice[1.. :0][0..2 :4]) == *[2:4]u8); } fn testArrayLength() !void { var array = [5]u8{ 1, 2, 3, 4, 5 }; - comptime try expect(@TypeOf(array[1..][0..2]) == *[2]u8); - comptime try expect(@TypeOf(array[1..][0..4]) == *[4]u8); - comptime try expect(@TypeOf(array[1..][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(array[1..][0..2]) == *[2]u8); + try comptime expect(@TypeOf(array[1..][0..4]) == *[4]u8); + try comptime expect(@TypeOf(array[1..][0..2 :4]) == *[2:4]u8); } fn testArrayLengthZ() !void { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; - comptime try expect(@TypeOf(array[1..][0..2]) == *[2]u8); - comptime try expect(@TypeOf(array[1..][0..4]) == *[4:0]u8); - comptime try expect(@TypeOf(array[1..][0..2 :4]) == *[2:4]u8); - comptime try expect(@TypeOf(array[1.. :0][0..2]) == *[2]u8); - comptime try expect(@TypeOf(array[1.. :0][0..4]) == *[4:0]u8); - comptime try expect(@TypeOf(array[1.. :0][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(array[1..][0..2]) == *[2]u8); + try comptime expect(@TypeOf(array[1..][0..4]) == *[4:0]u8); + try comptime expect(@TypeOf(array[1..][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(array[1.. :0][0..2]) == *[2]u8); + try comptime expect(@TypeOf(array[1.. :0][0..4]) == *[4:0]u8); + try comptime expect(@TypeOf(array[1.. :0][0..2 :4]) == *[2:4]u8); } fn testMultiPointer() !void { var array = [5]u8{ 1, 2, 3, 4, 5 }; var ptr: [*]u8 = &array; - comptime try expect(@TypeOf(ptr[1..][0..2]) == *[2]u8); - comptime try expect(@TypeOf(ptr[1..][0..4]) == *[4]u8); - comptime try expect(@TypeOf(ptr[1..][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(ptr[1..][0..2]) == *[2]u8); + try comptime expect(@TypeOf(ptr[1..][0..4]) == *[4]u8); + try comptime expect(@TypeOf(ptr[1..][0..2 :4]) == *[2:4]u8); } fn testMultiPointerLengthZ() !void { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; var ptr: [*]u8 = &array; - comptime try expect(@TypeOf(ptr[1..][0..2]) == *[2]u8); - comptime try expect(@TypeOf(ptr[1..][0..4]) == *[4:0]u8); - comptime try expect(@TypeOf(ptr[1..][0..2 :4]) == *[2:4]u8); - comptime try expect(@TypeOf(ptr[1.. :0][0..2]) == *[2]u8); - comptime try expect(@TypeOf(ptr[1.. :0][0..4]) == *[4:0]u8); - comptime try expect(@TypeOf(ptr[1.. :0][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(ptr[1..][0..2]) == *[2]u8); + try comptime expect(@TypeOf(ptr[1..][0..4]) == *[4:0]u8); + try comptime expect(@TypeOf(ptr[1..][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(ptr[1.. :0][0..2]) == *[2]u8); + try comptime expect(@TypeOf(ptr[1.. :0][0..4]) == *[4:0]u8); + try comptime expect(@TypeOf(ptr[1.. :0][0..2 :4]) == *[2:4]u8); var ptr_z: [*:0]u8 = &array; - comptime try expect(@TypeOf(ptr_z[1..][0..2]) == *[2]u8); - comptime try expect(@TypeOf(ptr_z[1..][0..4]) == *[4:0]u8); - comptime try expect(@TypeOf(ptr_z[1..][0..2 :4]) == *[2:4]u8); - comptime try expect(@TypeOf(ptr_z[1.. :0][0..2]) == *[2]u8); - comptime try expect(@TypeOf(ptr_z[1.. :0][0..4]) == *[4:0]u8); - comptime try expect(@TypeOf(ptr_z[1.. :0][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(ptr_z[1..][0..2]) == *[2]u8); + try comptime expect(@TypeOf(ptr_z[1..][0..4]) == *[4:0]u8); + try comptime expect(@TypeOf(ptr_z[1..][0..2 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(ptr_z[1.. :0][0..2]) == *[2]u8); + try comptime expect(@TypeOf(ptr_z[1.. :0][0..4]) == *[4:0]u8); + try comptime expect(@TypeOf(ptr_z[1.. :0][0..2 :4]) == *[2:4]u8); } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "slice pointer-to-array null terminated" { @@ -576,9 +576,9 @@ test "slice pointer-to-array null terminated" { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; var slice: [:0]u8 = &array; - comptime try expect(@TypeOf(slice[1..3]) == *[2]u8); - comptime try expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8); - comptime try expect(@TypeOf(slice[1..]) == [:0]u8); + try comptime expect(@TypeOf(slice[1..3]) == *[2]u8); + try comptime expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8); + try comptime expect(@TypeOf(slice[1..]) == [:0]u8); } test "slice pointer-to-array zero length" { @@ -604,13 +604,13 @@ test "slice pointer-to-array zero length" { var array = [0]u8{}; var src_slice: []u8 = &array; var slice = src_slice[0..0]; - comptime try expect(@TypeOf(slice) == *[0]u8); + try comptime expect(@TypeOf(slice) == *[0]u8); } { var array = [0:0]u8{}; var src_slice: [:0]u8 = &array; var slice = src_slice[0..0]; - comptime try expect(@TypeOf(slice) == *[0]u8); + try comptime expect(@TypeOf(slice) == *[0]u8); } } @@ -647,7 +647,7 @@ test "type coercion of pointer to anon struct literal to pointer to slice" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "array concat of slices gives ptr to array" { @@ -719,7 +719,7 @@ test "slicing array with sentinel as end index" { }; try S.do(); - comptime try S.do(); + try comptime S.do(); } test "slicing slice with sentinel as end index" { @@ -739,7 +739,7 @@ test "slicing slice with sentinel as end index" { }; try S.do(); - comptime try S.do(); + try comptime S.do(); } test "slice len modification at comptime" { diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index 4553596c41..6686c911a5 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -268,7 +268,7 @@ test "struct field init with catch" { }; }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } const blah: packed struct { @@ -603,7 +603,7 @@ test "bit field access" { try expect(getA(&data) == 1); try expect(getB(&data) == 2); try expect(getC(&data) == 3); - comptime try expect(@sizeOf(BitField1) == 1); + try comptime expect(@sizeOf(BitField1) == 1); data.b += 1; try expect(data.b == 3); @@ -740,7 +740,7 @@ test "packed struct with u0 field access" { f0: u0, }; var s = S{ .f0 = 0 }; - comptime try expect(s.f0 == 0); + try comptime expect(s.f0 == 0); } test "access to global struct fields" { @@ -817,7 +817,7 @@ test "fn with C calling convention returns struct by value" { } }; try S.entry(); - comptime try S.entry(); + try comptime S.entry(); } test "non-packed struct with u128 entry in union" { @@ -889,7 +889,7 @@ test "anonymous struct literal syntax" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "fully anonymous struct" { @@ -911,7 +911,7 @@ test "fully anonymous struct" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "fully anonymous list literal" { @@ -928,7 +928,7 @@ test "fully anonymous list literal" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "tuple assigned to variable" { @@ -955,7 +955,7 @@ test "comptime struct field" { comptime std.debug.assert(@sizeOf(T) == 4); var foo: T = undefined; - comptime try expect(foo.b == 1234); + try comptime expect(foo.b == 1234); } test "tuple element initialized with fn call" { @@ -974,7 +974,7 @@ test "tuple element initialized with fn call" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "struct with union field" { @@ -1033,7 +1033,7 @@ test "type coercion of anon struct literal to struct" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "type coercion of pointer to anon struct literal to pointer to struct" { @@ -1071,7 +1071,7 @@ test "type coercion of pointer to anon struct literal to pointer to struct" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "packed struct with undefined initializers" { @@ -1104,7 +1104,7 @@ test "packed struct with undefined initializers" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "for loop over pointers to struct, getting field from struct pointer" { @@ -1169,7 +1169,7 @@ test "anon init through error unions and optionals" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "anon init through optional" { @@ -1189,7 +1189,7 @@ test "anon init through optional" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "anon init through error union" { @@ -1209,7 +1209,7 @@ test "anon init through error union" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "typed init through error unions and optionals" { @@ -1236,7 +1236,7 @@ test "typed init through error unions and optionals" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "initialize struct with empty literal" { @@ -1311,7 +1311,7 @@ test "packed struct field access via pointer" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "store to comptime field" { @@ -1416,7 +1416,7 @@ test "fieldParentPtr of a zero-bit field" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "struct field has a pointer to an aligned version of itself" { diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig index 72a36c9883..02e3ef4dce 100644 --- a/test/behavior/switch.zig +++ b/test/behavior/switch.zig @@ -121,7 +121,7 @@ test "switching on booleans" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testSwitchOnBools(); - comptime try testSwitchOnBools(); + try comptime testSwitchOnBools(); } fn testSwitchOnBools() !void { @@ -186,10 +186,10 @@ test "switch variable for range and multiple prongs" { fn doTheTest() !void { var u: u8 = 16; try doTheSwitch(u); - comptime try doTheSwitch(u); + try comptime doTheSwitch(u); var v: u8 = 42; try doTheSwitch(v); - comptime try doTheSwitch(v); + try comptime doTheSwitch(v); } fn doTheSwitch(q: u8) !void { switch (q) { @@ -260,7 +260,7 @@ test "switch on enum using pointer capture" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testSwitchEnumPtrCapture(); - comptime try testSwitchEnumPtrCapture(); + try comptime testSwitchEnumPtrCapture(); } fn testSwitchEnumPtrCapture() !void { @@ -279,7 +279,7 @@ test "switch handles all cases of number" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testSwitchHandleAllCases(); - comptime try testSwitchHandleAllCases(); + try comptime testSwitchHandleAllCases(); } fn testSwitchHandleAllCases() !void { @@ -373,7 +373,7 @@ test "switch all prongs unreachable" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testAllProngsUnreachable(); - comptime try testAllProngsUnreachable(); + try comptime testAllProngsUnreachable(); } fn testAllProngsUnreachable() !void { @@ -421,7 +421,7 @@ test "switch on integer with else capturing expr" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "else prong of switch on error set excludes other cases" { @@ -456,7 +456,7 @@ test "else prong of switch on error set excludes other cases" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "switch prongs with error set cases make a new error set type for capture value" { @@ -493,7 +493,7 @@ test "switch prongs with error set cases make a new error set type for capture v } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "return result loc and then switch with range implicit casted to error union" { @@ -512,7 +512,7 @@ test "return result loc and then switch with range implicit casted to error unio } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "switch with null and T peer types and inferred result location type" { @@ -532,7 +532,7 @@ test "switch with null and T peer types and inferred result location type" { } }; try S.doTheTest(1); - comptime try S.doTheTest(1); + try comptime S.doTheTest(1); } test "switch prongs with cases with identical payload types" { @@ -577,7 +577,7 @@ test "switch prongs with cases with identical payload types" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "switch on pointer type" { @@ -606,9 +606,9 @@ test "switch on pointer type" { try expect(1 == S.doTheTest(S.P1)); try expect(2 == S.doTheTest(S.P2)); try expect(3 == S.doTheTest(S.P3)); - comptime try expect(1 == S.doTheTest(S.P1)); - comptime try expect(2 == S.doTheTest(S.P2)); - comptime try expect(3 == S.doTheTest(S.P3)); + try comptime expect(1 == S.doTheTest(S.P1)); + try comptime expect(2 == S.doTheTest(S.P2)); + try comptime expect(3 == S.doTheTest(S.P3)); } test "switch on error set with single else" { @@ -624,7 +624,7 @@ test "switch on error set with single else" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "switch capture copies its payload" { @@ -650,7 +650,7 @@ test "switch capture copies its payload" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "capture of integer forwards the switch condition directly" { @@ -670,8 +670,8 @@ test "capture of integer forwards the switch condition directly" { }; try S.foo(42); try S.foo(100); - comptime try S.foo(42); - comptime try S.foo(100); + try comptime S.foo(42); + try comptime S.foo(100); } test "enum value without tag name used as switch item" { @@ -702,7 +702,7 @@ test "switch item sizeof" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "comptime inline switch" { diff --git a/test/behavior/truncate.zig b/test/behavior/truncate.zig index d3091487b4..3ea979009e 100644 --- a/test/behavior/truncate.zig +++ b/test/behavior/truncate.zig @@ -5,7 +5,7 @@ const expect = std.testing.expect; test "truncate u0 to larger integer allowed and has comptime-known result" { var x: u0 = 0; const y = @truncate(u8, x); - comptime try expect(y == 0); + try comptime expect(y == 0); } test "truncate.u0.literal" { @@ -28,7 +28,7 @@ test "truncate.u0.var" { test "truncate i0 to larger integer allowed and has comptime-known result" { var x: i0 = 0; const y = @truncate(i8, x); - comptime try expect(y == 0); + try comptime expect(y == 0); } test "truncate.i0.literal" { @@ -73,6 +73,6 @@ test "truncate on vectors" { try expect(std.mem.eql(u8, &@as([4]u8, v2), &[4]u8{ 0xbb, 0xdd, 0xff, 0x22 })); } }; - comptime try S.doTheTest(); + try comptime S.doTheTest(); try S.doTheTest(); } diff --git a/test/behavior/try.zig b/test/behavior/try.zig index 967b1af04e..c7b0396051 100644 --- a/test/behavior/try.zig +++ b/test/behavior/try.zig @@ -7,7 +7,7 @@ test "try on error union" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try tryOnErrorUnionImpl(); - comptime try tryOnErrorUnionImpl(); + try comptime tryOnErrorUnionImpl(); } fn tryOnErrorUnionImpl() !void { diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig index b6fde88af2..190ac3c7df 100644 --- a/test/behavior/tuple.zig +++ b/test/behavior/tuple.zig @@ -23,7 +23,7 @@ test "tuple concatenation" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "tuple multiplication" { @@ -46,7 +46,7 @@ test "tuple multiplication" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "more tuple concatenation" { @@ -91,7 +91,7 @@ test "more tuple concatenation" { }; try T.doTheTest(); - comptime try T.doTheTest(); + try comptime T.doTheTest(); } test "pass tuple to comptime var parameter" { @@ -105,7 +105,7 @@ test "pass tuple to comptime var parameter" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "tuple initializer for var" { @@ -163,7 +163,7 @@ test "array-like initializer for tuple types" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "anon struct as the result from a labeled block" { @@ -180,7 +180,7 @@ test "anon struct as the result from a labeled block" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "tuple as the result from a labeled block" { @@ -195,7 +195,7 @@ test "tuple as the result from a labeled block" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "initializing tuple with explicit type" { diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig index 2c32b70807..87ae96768a 100644 --- a/test/behavior/type_info.zig +++ b/test/behavior/type_info.zig @@ -10,7 +10,7 @@ const expectEqualStrings = std.testing.expectEqualStrings; test "type info: integer, floating point type info" { try testIntFloat(); - comptime try testIntFloat(); + try comptime testIntFloat(); } fn testIntFloat() !void { @@ -26,7 +26,7 @@ fn testIntFloat() !void { test "type info: optional type info" { try testOptional(); - comptime try testOptional(); + try comptime testOptional(); } fn testOptional() !void { @@ -37,7 +37,7 @@ fn testOptional() !void { test "type info: C pointer type info" { try testCPtr(); - comptime try testCPtr(); + try comptime testCPtr(); } fn testCPtr() !void { @@ -60,7 +60,7 @@ test "type info: value is correctly copied" { test "type info: tag type, void info" { try testBasic(); - comptime try testBasic(); + try comptime testBasic(); } fn testBasic() !void { @@ -72,7 +72,7 @@ fn testBasic() !void { test "type info: pointer type info" { try testPointer(); - comptime try testPointer(); + try comptime testPointer(); } fn testPointer() !void { @@ -88,7 +88,7 @@ fn testPointer() !void { test "type info: unknown length pointer type info" { try testUnknownLenPtr(); - comptime try testUnknownLenPtr(); + try comptime testUnknownLenPtr(); } fn testUnknownLenPtr() !void { @@ -104,7 +104,7 @@ fn testUnknownLenPtr() !void { test "type info: null terminated pointer type info" { try testNullTerminatedPtr(); - comptime try testNullTerminatedPtr(); + try comptime testNullTerminatedPtr(); } fn testNullTerminatedPtr() !void { @@ -120,7 +120,7 @@ fn testNullTerminatedPtr() !void { test "type info: slice type info" { try testSlice(); - comptime try testSlice(); + try comptime testSlice(); } fn testSlice() !void { @@ -135,7 +135,7 @@ fn testSlice() !void { test "type info: array type info" { try testArray(); - comptime try testArray(); + try comptime testArray(); } fn testArray() !void { @@ -163,7 +163,7 @@ test "type info: error set, error union info, anyerror" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testErrorSet(); - comptime try testErrorSet(); + try comptime testErrorSet(); } fn testErrorSet() !void { @@ -225,7 +225,7 @@ test "type info: enum info" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testEnum(); - comptime try testEnum(); + try comptime testEnum(); } fn testEnum() !void { @@ -247,7 +247,7 @@ fn testEnum() !void { test "type info: union info" { try testUnion(); - comptime try testUnion(); + try comptime testUnion(); } fn testUnion() !void { @@ -287,7 +287,7 @@ test "type info: struct info" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testStruct(); - comptime try testStruct(); + try comptime testStruct(); } fn testStruct() !void { @@ -306,7 +306,7 @@ const TestStruct = struct { test "type info: packed struct info" { try testPackedStruct(); - comptime try testPackedStruct(); + try comptime testPackedStruct(); } fn testPackedStruct() !void { @@ -339,7 +339,7 @@ const TestPackedStruct = packed struct { test "type info: opaque info" { try testOpaque(); - comptime try testOpaque(); + try comptime testOpaque(); } fn testOpaque() !void { @@ -356,7 +356,7 @@ test "type info: function type info" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFunction(); - comptime try testFunction(); + try comptime testFunction(); } fn testFunction() !void { @@ -427,7 +427,7 @@ test "typeInfo with comptime parameter in struct fn def" { test "type info: vectors" { try testVector(); - comptime try testVector(); + try comptime testVector(); } fn testVector() !void { @@ -444,7 +444,7 @@ test "type info: anyframe and anyframe->T" { } try testAnyFrame(); - comptime try testAnyFrame(); + try comptime testAnyFrame(); } fn testAnyFrame() !void { @@ -489,7 +489,7 @@ test "@typeInfo does not force declarations into existence" { @compileError("test failed"); } }; - comptime try expect(@typeInfo(S).Struct.fields.len == 1); + try comptime expect(@typeInfo(S).Struct.fields.len == 1); } fn add(a: i32, b: i32) i32 { diff --git a/test/behavior/union.zig b/test/behavior/union.zig index f1bfaa063b..c94695ff21 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -113,7 +113,7 @@ const ExternPtrOrInt = extern union { int: u64, }; test "extern union size" { - comptime try expect(@sizeOf(ExternPtrOrInt) == 8); + try comptime expect(@sizeOf(ExternPtrOrInt) == 8); } test "0-sized extern union definition" { @@ -165,7 +165,7 @@ test "access a member of tagged union with conflicting enum tag name" { const B = void; }; - comptime try expect(Bar.A == u8); + try comptime expect(Bar.A == u8); } test "constant tagged union with payload" { @@ -225,7 +225,7 @@ test "union with specified enum tag" { if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try doTest(); - comptime try doTest(); + try comptime doTest(); } test "packed union generates correctly aligned type" { @@ -274,7 +274,7 @@ test "comparison between union and enum literal" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testComparison(); - comptime try testComparison(); + try comptime testComparison(); } const TheTag = enum { A, B, C }; @@ -289,7 +289,7 @@ test "cast union to tag type of union" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO try testCastUnionToTag(); - comptime try testCastUnionToTag(); + try comptime testCastUnionToTag(); } fn testCastUnionToTag() !void { @@ -372,14 +372,14 @@ const PackedPtrOrInt = packed union { int: u64, }; test "packed union size" { - comptime try expect(@sizeOf(PackedPtrOrInt) == 8); + try comptime expect(@sizeOf(PackedPtrOrInt) == 8); } const ZeroBits = union { OnlyField: void, }; test "union with only 1 field which is void should be zero bits" { - comptime try expect(@sizeOf(ZeroBits) == 0); + try comptime expect(@sizeOf(ZeroBits) == 0); } test "tagged union initialization with runtime void" { @@ -430,7 +430,7 @@ test "union with only 1 field casted to its enum type" { var e = Expr{ .Literal = Literal{ .Bool = true } }; const ExprTag = Tag(Expr); - comptime try expect(Tag(ExprTag) == u0); + try comptime expect(Tag(ExprTag) == u0); var t = @as(ExprTag, e); try expect(t == Expr.Literal); } @@ -439,7 +439,7 @@ test "union with one member defaults to u0 tag type" { const U0 = union(enum) { X: u32, }; - comptime try expect(Tag(Tag(U0)) == u0); + try comptime expect(Tag(Tag(U0)) == u0); } const Foo1 = union(enum) { @@ -547,7 +547,7 @@ test "method call on an empty union" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } const Point = struct { @@ -628,7 +628,7 @@ test "tagged union with all void fields but a meaningful tag" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "union(enum(u32)) with specified and unspecified tag values" { @@ -637,9 +637,9 @@ test "union(enum(u32)) with specified and unspecified tag values" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime try expect(Tag(Tag(MultipleChoice2)) == u32); + try comptime expect(Tag(Tag(MultipleChoice2)) == u32); try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); - comptime try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); + try comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); } const MultipleChoice2 = union(enum(u32)) { @@ -718,11 +718,11 @@ test "union with only 1 field casted to its enum type which has enum value speci }; var e = Expr{ .Literal = Literal{ .Bool = true } }; - comptime try expect(Tag(ExprTag) == comptime_int); + try comptime expect(Tag(ExprTag) == comptime_int); comptime var t = @as(ExprTag, e); try expect(t == Expr.Literal); try expect(@enumToInt(t) == 33); - comptime try expect(@enumToInt(t) == 33); + try comptime expect(@enumToInt(t) == 33); } test "@enumToInt works on unions" { @@ -805,7 +805,7 @@ test "return union init with void payload" { } }; try S.entry(); - comptime try S.entry(); + try comptime S.entry(); } test "@unionInit stored to a const" { @@ -833,7 +833,7 @@ test "@unionInit stored to a const" { } }; - comptime try S.doTheTest(); + try comptime S.doTheTest(); try S.doTheTest(); } @@ -905,7 +905,7 @@ test "union with comptime_int tag" { Y: u16, Z: u8, }; - comptime try expect(Tag(Tag(Union)) == comptime_int); + try comptime expect(Tag(Tag(Union)) == comptime_int); } test "extern union doesn't trigger field check at comptime" { @@ -915,7 +915,7 @@ test "extern union doesn't trigger field check at comptime" { }; const x = U{ .x = 0x55AAAA55 }; - comptime try expect(x.y == 0x55); + try comptime expect(x.y == 0x55); } test "anonymous union literal syntax" { @@ -942,7 +942,7 @@ test "anonymous union literal syntax" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "function call result coerces from tagged union to the tag" { @@ -975,7 +975,7 @@ test "function call result coerces from tagged union to the tag" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "cast from anonymous struct to union" { @@ -1007,7 +1007,7 @@ test "cast from anonymous struct to union" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "cast from pointer to anonymous struct to pointer to union" { @@ -1039,7 +1039,7 @@ test "cast from pointer to anonymous struct to pointer to union" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "switching on non exhaustive union" { @@ -1067,7 +1067,7 @@ test "switching on non exhaustive union" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "containers with single-field enums" { @@ -1096,7 +1096,7 @@ test "containers with single-field enums" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@unionInit on union with tag but no fields" { @@ -1130,7 +1130,7 @@ test "@unionInit on union with tag but no fields" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "union enum type gets a separate scope" { @@ -1552,7 +1552,7 @@ test "reinterpreting enum value inside packed union" { } }; try U.doTest(); - comptime try U.doTest(); + try comptime U.doTest(); } test "access the tag of a global tagged union" { @@ -1581,5 +1581,5 @@ test "coerce enum literal to union in result loc" { } }; try U.doTest(true); - comptime try U.doTest(true); + try comptime U.doTest(true); } diff --git a/test/behavior/usingnamespace.zig b/test/behavior/usingnamespace.zig index ca43f60e99..212edb353d 100644 --- a/test/behavior/usingnamespace.zig +++ b/test/behavior/usingnamespace.zig @@ -32,7 +32,7 @@ usingnamespace struct { }; test "usingnamespace does not redeclare an imported variable" { - comptime try std.testing.expect(@This().foo == 42); + try comptime std.testing.expect(@This().foo == 42); } usingnamespace @import("usingnamespace/foo.zig"); diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig index 4103f0c2c7..195500c178 100644 --- a/test/behavior/vector.zig +++ b/test/behavior/vector.zig @@ -21,7 +21,7 @@ test "implicit cast vector to array - bool" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector wrap operators" { @@ -45,7 +45,7 @@ test "vector wrap operators" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector bin compares with mem.eql" { @@ -69,7 +69,7 @@ test "vector bin compares with mem.eql" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector int operators" { @@ -91,7 +91,7 @@ test "vector int operators" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector float operators" { @@ -114,7 +114,7 @@ test "vector float operators" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } } @@ -135,7 +135,7 @@ test "vector bit operators" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "implicit cast vector to array" { @@ -153,7 +153,7 @@ test "implicit cast vector to array" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "array to vector" { @@ -171,7 +171,7 @@ test "array to vector" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "array to vector with element type coercion" { @@ -192,7 +192,7 @@ test "array to vector with element type coercion" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "peer type resolution with coercible element types" { @@ -212,7 +212,7 @@ test "peer type resolution with coercible element types" { try std.testing.expect(@TypeOf(c) == @Vector(2, u16)); } }; - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "tuple to vector" { @@ -242,7 +242,7 @@ test "tuple to vector" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector casts of sizes not divisible by 8" { @@ -278,7 +278,7 @@ test "vector casts of sizes not divisible by 8" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector @splat" { @@ -326,7 +326,7 @@ test "vector @splat" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "load vector elements via comptime index" { @@ -348,7 +348,7 @@ test "load vector elements via comptime index" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "store vector elements via comptime index" { @@ -376,7 +376,7 @@ test "store vector elements via comptime index" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "load vector elements via runtime index" { @@ -398,7 +398,7 @@ test "load vector elements via runtime index" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "store vector elements via runtime index" { @@ -421,7 +421,7 @@ test "store vector elements via runtime index" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "initialize vector which is a struct field" { @@ -443,7 +443,7 @@ test "initialize vector which is a struct field" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector comparison operators" { @@ -484,7 +484,7 @@ test "vector comparison operators" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector division operators" { @@ -567,7 +567,7 @@ test "vector division operators" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector bitwise not operator" { @@ -599,7 +599,7 @@ test "vector bitwise not operator" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector shift operators" { @@ -693,7 +693,7 @@ test "vector shift operators" { } try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector reduce operation" { @@ -837,7 +837,7 @@ test "vector reduce operation" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "vector @reduce comptime" { @@ -849,9 +849,9 @@ test "vector @reduce comptime" { const value = @Vector(4, i32){ 1, -1, 1, -1 }; const result = value > @splat(4, @as(i32, 0)); // result is { true, false, true, false }; - comptime try expect(@TypeOf(result) == @Vector(4, bool)); + try comptime expect(@TypeOf(result) == @Vector(4, bool)); const is_all_true = @reduce(.And, result); - comptime try expect(@TypeOf(is_all_true) == bool); + try comptime expect(@TypeOf(is_all_true) == bool); try expect(is_all_true == false); } @@ -903,7 +903,7 @@ test "saturating add" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "saturating subtraction" { @@ -926,7 +926,7 @@ test "saturating subtraction" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "saturating multiplication" { @@ -953,7 +953,7 @@ test "saturating multiplication" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "saturating shift-left" { @@ -976,7 +976,7 @@ test "saturating shift-left" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "multiplication-assignment operator with an array operand" { @@ -997,7 +997,7 @@ test "multiplication-assignment operator with an array operand" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@addWithOverflow" { @@ -1041,7 +1041,7 @@ test "@addWithOverflow" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@subWithOverflow" { @@ -1071,7 +1071,7 @@ test "@subWithOverflow" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@mulWithOverflow" { @@ -1092,7 +1092,7 @@ test "@mulWithOverflow" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "@shlWithOverflow" { @@ -1113,7 +1113,7 @@ test "@shlWithOverflow" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "alignment of vectors" { diff --git a/test/behavior/while.zig b/test/behavior/while.zig index a051a8fd3b..e52b394746 100644 --- a/test/behavior/while.zig +++ b/test/behavior/while.zig @@ -122,7 +122,7 @@ test "while copies its payload" { } }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); } test "continue and break" { @@ -293,7 +293,7 @@ test "while bool 2 break statements and an else" { } }; try S.entry(true, false); - comptime try S.entry(true, false); + try comptime S.entry(true, false); } test "while optional 2 break statements and an else" { @@ -312,7 +312,7 @@ test "while optional 2 break statements and an else" { } }; try S.entry(true, false); - comptime try S.entry(true, false); + try comptime S.entry(true, false); } test "while error 2 break statements and an else" { @@ -332,7 +332,7 @@ test "while error 2 break statements and an else" { } }; try S.entry(true, false); - comptime try S.entry(true, false); + try comptime S.entry(true, false); } test "continue inline while loop" { diff --git a/test/behavior/wrapping_arithmetic.zig b/test/behavior/wrapping_arithmetic.zig index 5ee9b20780..23ebcfaf61 100644 --- a/test/behavior/wrapping_arithmetic.zig +++ b/test/behavior/wrapping_arithmetic.zig @@ -31,12 +31,12 @@ test "wrapping add" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); - comptime try S.testWrapAdd(comptime_int, 0, 0, 0); - comptime try S.testWrapAdd(comptime_int, 3, 2, 5); - comptime try S.testWrapAdd(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 1119305249183743626545271163355074748512); - comptime try S.testWrapAdd(comptime_int, 7, -593423721213448152027139550640105366508, -593423721213448152027139550640105366501); + try comptime S.testWrapAdd(comptime_int, 0, 0, 0); + try comptime S.testWrapAdd(comptime_int, 3, 2, 5); + try comptime S.testWrapAdd(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 1119305249183743626545271163355074748512); + try comptime S.testWrapAdd(comptime_int, 7, -593423721213448152027139550640105366508, -593423721213448152027139550640105366501); } test "wrapping subtraction" { @@ -64,12 +64,12 @@ test "wrapping subtraction" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); - comptime try S.testWrapSub(comptime_int, 0, 0, 0); - comptime try S.testWrapSub(comptime_int, 3, 2, 1); - comptime try S.testWrapSub(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 182846383813587550256162760261375991602); - comptime try S.testWrapSub(comptime_int, 7, -593423721213448152027139550640105366508, 593423721213448152027139550640105366515); + try comptime S.testWrapSub(comptime_int, 0, 0, 0); + try comptime S.testWrapSub(comptime_int, 3, 2, 1); + try comptime S.testWrapSub(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 182846383813587550256162760261375991602); + try comptime S.testWrapSub(comptime_int, 7, -593423721213448152027139550640105366508, 593423721213448152027139550640105366515); } test "wrapping multiplication" { @@ -101,10 +101,10 @@ test "wrapping multiplication" { }; try S.doTheTest(); - comptime try S.doTheTest(); + try comptime S.doTheTest(); - comptime try S.testWrapMul(comptime_int, 0, 0, 0); - comptime try S.testWrapMul(comptime_int, 3, 2, 6); - comptime try S.testWrapMul(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 304852860194144160265083087140337419215516305999637969803722975979232817921935); - comptime try S.testWrapMul(comptime_int, 7, -593423721213448152027139550640105366508, -4153966048494137064189976854480737565556); + try comptime S.testWrapMul(comptime_int, 0, 0, 0); + try comptime S.testWrapMul(comptime_int, 3, 2, 6); + try comptime S.testWrapMul(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 304852860194144160265083087140337419215516305999637969803722975979232817921935); + try comptime S.testWrapMul(comptime_int, 7, -593423721213448152027139550640105366508, -4153966048494137064189976854480737565556); } diff --git a/test/standalone/issue_794/main.zig b/test/standalone/issue_794/main.zig index d8c4364bf0..04b95de5b5 100644 --- a/test/standalone/issue_794/main.zig +++ b/test/standalone/issue_794/main.zig @@ -3,5 +3,5 @@ const std = @import("std"); const testing = std.testing; test "c import" { - comptime try testing.expect(c.NUMBER == 1234); + try comptime testing.expect(c.NUMBER == 1234); } -- cgit v1.2.3