mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 06:13:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

spirv: update failing / passing tests

Browse Source 
Some tests are now failing due to debug info changes, some tests
now pass due to improved compiler functionality.
This commit is contained in:
Robin Voetter 2023-09-23 01:30:16 +02:00
parent 0552e504d0
commit faad97edff
No known key found for this signature in database
87 changed files with 48 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
test/behavior/abs.zig
View File

@ -48,7 +48,6 @@ test "@abs unsigned integers" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try comptime testAbsUnsignedIntegers();
try testAbsUnsignedIntegers();

7
test/behavior/align.zig
View File

@ -18,7 +18,6 @@ test "global variable alignment" {
test "slicing array of length 1 can not assume runtime index is always zero" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var runtime_index: usize = 1;
const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];
@ -226,7 +225,6 @@ 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;
@ -396,7 +394,6 @@ 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 {
@ -414,7 +411,6 @@ 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 };
@ -546,7 +542,6 @@ test "align(N) on functions" {
if (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_c) {
// https://github.com/ziglang/zig/issues/16845
@ -585,7 +580,6 @@ 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(ptr);
@ -601,7 +595,6 @@ test "sub-aligned pointer field 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;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
// Originally reported at https://github.com/ziglang/zig/issues/14904

4
test/behavior/array.zig
View File

@ -72,7 +72,6 @@ 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 };
{
@ -298,7 +297,6 @@ 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..] };
@ -568,7 +566,6 @@ 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 {
@ -651,7 +648,6 @@ 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 };

7
test/behavior/basic.zig
View File

@ -378,8 +378,6 @@ 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 {
@ -473,7 +471,6 @@ 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);
}
@ -484,7 +481,6 @@ 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;
@ -573,8 +569,6 @@ 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);
}
@ -840,7 +834,6 @@ 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() {

8
test/behavior/bitcast.zig
View File

@ -149,8 +149,6 @@ 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 = @as(u16, @bitCast(@as([2]u8, @bitCast(y))));
try expect(y == x);
@ -186,7 +184,6 @@ 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,
@ -241,7 +238,6 @@ 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 {
@ -271,8 +267,6 @@ test "comptime bitcast used in expression has the correct type" {
}
test "bitcast passed as tuple element" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo(args: anytype) !void {
try comptime expect(@TypeOf(args[0]) == f32);
@ -283,8 +277,6 @@ test "bitcast passed as tuple element" {
}
test "triple level result location with bitcast sandwich passed as tuple element" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo(args: anytype) !void {
try comptime expect(@TypeOf(args[0]) == f64);

1
test/behavior/bugs/10684.zig
View File

@ -6,7 +6,6 @@ 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];

1
test/behavior/bugs/1076.zig
View File

@ -6,7 +6,6 @@ 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();
try comptime testCastPtrOfArrayToSliceAndPtr();

1
test/behavior/bugs/11046.zig
View File

@ -13,7 +13,6 @@ 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}

1
test/behavior/bugs/11139.zig
View File

@ -6,7 +6,6 @@ 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);
try comptime expect(storeArrayOfArrayOfStructs() == 15);

2
test/behavior/bugs/11213.zig
View File

@ -3,8 +3,6 @@ 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;

1
test/behavior/bugs/11995.zig
View File

@ -20,7 +20,6 @@ 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 = @as([*c]u8, @ptrCast(&string)), .len = string.len };

1
test/behavior/bugs/12092.zig
View File

@ -17,7 +17,6 @@ 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(&.{

1
test/behavior/bugs/12142.zig
View File

@ -22,7 +22,6 @@ 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 = &.{

1
test/behavior/bugs/12551.zig
View File

@ -4,7 +4,6 @@ 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;

2
test/behavior/bugs/12644.zig
View File

@ -10,8 +10,6 @@ fn main0() !void {
}
test "issue12644" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
main0() catch |e| {
try std.testing.expect(e == error.AnError);
};

1
test/behavior/bugs/12890.zig
View File

@ -11,7 +11,6 @@ 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);

6
test/behavior/bugs/12891.zig
View File

@ -29,7 +29,6 @@ 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));
@ -37,7 +36,6 @@ 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));
@ -45,7 +43,6 @@ 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));
@ -55,7 +52,6 @@ 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));
@ -65,7 +61,6 @@ 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));
@ -75,7 +70,6 @@ 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));

1
test/behavior/bugs/12972.zig
View File

@ -6,7 +6,6 @@ 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});

1
test/behavior/bugs/13064.zig
View File

@ -6,7 +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_spirv64) return error.SkipZigTest;
var x: [10][10]u32 = undefined;

1
test/behavior/bugs/13065.zig
View File

@ -11,7 +11,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_spirv64) return error.SkipZigTest;
var x = U{ .array = undefined };

1
test/behavior/bugs/13366.zig
View File

@ -16,7 +16,6 @@ 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 } };

1
test/behavior/bugs/1381.zig
View File

@ -15,7 +15,6 @@ test "union that needs padding bytes inside an array" {
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 as = [_]A{
A{ .B = B{ .D = 1 } },

1
test/behavior/bugs/1442.zig
View File

@ -10,7 +10,6 @@ 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);

1
test/behavior/bugs/1607.zig
View File

@ -14,7 +14,6 @@ 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);
try comptime checkAddress(&a);

2
test/behavior/bugs/1741.zig
View File

@ -4,7 +4,7 @@ const builtin = @import("builtin");
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_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
const x: f32 align(128) = 12.34;
try std.testing.expect(@intFromPtr(&x) % 128 == 0);

2
test/behavior/bugs/2346.zig
View File

@ -1,3 +1,5 @@
const builtin = @import("builtin");
test "fixed" {
const a: *void = undefined;
const b: *[1]void = a;

1
test/behavior/bugs/2578.zig
View File

@ -15,7 +15,6 @@ 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);
}

1
test/behavior/bugs/2692.zig
View File

@ -7,7 +7,6 @@ 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);

1
test/behavior/bugs/3046.zig
View File

@ -16,7 +16,6 @@ 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),

2
test/behavior/bugs/3367.zig
View File

@ -10,8 +10,6 @@ const Mixin = struct {
};
test "container member access usingnamespace decls" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var foo = Foo{};
foo.two();
}

1
test/behavior/bugs/3742.zig
View File

@ -40,7 +40,6 @@ 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"));
}

3
test/behavior/bugs/3779.zig
View File

@ -34,7 +34,6 @@ 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));
@ -48,7 +47,6 @@ 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));
@ -63,7 +61,6 @@ 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));

1
test/behavior/bugs/5487.zig
View File

@ -13,6 +13,5 @@ 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;
_ = io.multiWriter(.{writer()});
}

1
test/behavior/bugs/6905.zig
View File

@ -5,7 +5,6 @@ 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 };

2
test/behavior/bugs/726.zig
View File

@ -5,7 +5,6 @@ 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 = @as(?*const u8, @ptrCast(&c));
@ -16,7 +15,6 @@ 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;

1
test/behavior/bugs/8646.zig
View File

@ -10,7 +10,6 @@ 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]);

6
test/behavior/call.zig
View File

@ -90,7 +90,6 @@ 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 {
@ -400,7 +399,6 @@ 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 {
@ -416,8 +414,6 @@ test "inline while with @call" {
}
test "method call as parameter type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) {
return y;
@ -436,7 +432,6 @@ test "non-anytype generic parameters provide result 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; // TODO
const S = struct {
fn f(comptime T: type, y: T) !void {
@ -467,7 +462,6 @@ test "argument to generic function has correct result 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; // TODO
const S = struct {
fn foo(_: anytype, e: enum { a, b }) bool {

24
test/behavior/cast.zig
View File

@ -67,6 +67,8 @@ test "implicit cast comptime_int to comptime_float" {
}
test "comptime_int @floatFromInt" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
{
const result = @as(f16, @floatFromInt(1234));
try expect(@TypeOf(result) == f16);
@ -463,7 +465,6 @@ 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();
try comptime testCastZeroArrayToErrSliceMut();
@ -481,7 +482,6 @@ 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 {
@ -562,7 +562,6 @@ 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();
try comptime testCastPtrOfArrayToSliceAndPtr();
@ -592,7 +591,6 @@ 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;
@ -663,7 +661,6 @@ 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,
@ -822,7 +819,6 @@ 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..];
@ -837,7 +833,6 @@ 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..];
@ -859,7 +854,6 @@ 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 };
@ -881,7 +875,6 @@ 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 {
@ -1185,7 +1178,6 @@ 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);
@ -1270,7 +1262,6 @@ 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);
@ -1524,6 +1515,7 @@ test "implicit cast from [:0]T to [*c]T" {
test "bitcast packed struct with u0" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = packed struct(u2) { a: u0, b: u2 };
const s = @as(S, @bitCast(@as(u2, 2)));
@ -1588,7 +1580,6 @@ test "peer type resolution: const sentinel slice and mutable non-sentinel 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; // TODO
const S = struct {
fn doTheTest(comptime T: type, comptime s: T) !void {
@ -1617,7 +1608,6 @@ test "peer type resolution: float and comptime-known fixed-width integer" {
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; // TODO
const i: u8 = 100;
var f: f32 = 1.234;
@ -1678,7 +1668,6 @@ test "peer type resolution: array and vector with same child 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; // TODO
var arr: [2]u32 = .{ 0, 1 };
var vec: @Vector(2, u32) = .{ 2, 3 };
@ -1743,7 +1732,6 @@ test "peer type resolution: C pointer and @TypeOf(null)" {
if (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
var a: [*c]c_int = 0x1000;
const b = null;
@ -1826,7 +1814,6 @@ test "peer type resolution: optional fixed-width int and comptime_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; // TODO
var a: ?i32 = 42;
const b: comptime_int = 50;
@ -1869,7 +1856,6 @@ test "peer type resolution: vector and tuple" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
var vec: @Vector(3, i32) = .{ 1, 2, 3 };
const tup = .{ 4, 5, 6 };
@ -1892,7 +1878,6 @@ test "peer type resolution: vector and array and tuple" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
var vec: @Vector(2, i8) = .{ 10, 20 };
var arr: [2]i8 = .{ 30, 40 };
@ -2086,7 +2071,6 @@ test "peer type resolution: C pointer and many 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; // TODO
var buf = "hello".*;
@ -2389,7 +2373,6 @@ test "@intFromBool on vector" {
test "numeric coercions with undefined" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const from: i32 = undefined;
var to: f32 = from;
@ -2401,7 +2384,6 @@ test "numeric coercions with undefined" {
test "15-bit int to float" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: u15 = 42;
var b: f32 = @floatFromInt(a);

3
test/behavior/cast_int.zig
View File

@ -149,6 +149,8 @@ const Piece = packed struct {
test "load non byte-sized optional value" {
// Originally reported at https://github.com/ziglang/zig/issues/14200
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
// note: this bug is triggered by the == operator, expectEqual will hide it
var opt: ?Piece = try Piece.charToPiece('p');
try expect(opt.?.type == .PAWN);
@ -162,6 +164,7 @@ test "load non byte-sized optional value" {
test "load non byte-sized value in struct" {
if (builtin.cpu.arch.endian() != .Little) return error.SkipZigTest; // packed struct TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
// note: this bug is triggered by the == operator, expectEqual will hide it
// using ptrCast not to depend on unitialised memory state

4
test/behavior/comptime_memory.zig
View File

@ -426,8 +426,6 @@ test "mutate entire slice at comptime" {
}
test "dereference undefined pointer to zero-bit type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const p0: *void = undefined;
try testing.expectEqual({}, p0.*);
@ -436,8 +434,6 @@ test "dereference undefined pointer to zero-bit type" {
}
test "type pun extern struct" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = extern struct { f: u8 };
comptime var s = S{ .f = 123 };
@as(*u8, @ptrCast(&s)).* = 72;

1
test/behavior/const_slice_child.zig
View File

@ -10,7 +10,6 @@ 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;

3
test/behavior/defer.zig
View File

@ -34,7 +34,6 @@ 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);
}
@ -95,7 +94,6 @@ 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');
@ -160,7 +158,6 @@ test "reference to errdefer 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 {

4
test/behavior/empty_union.zig
View File

@ -44,8 +44,6 @@ 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) {}
@ -55,8 +53,6 @@ 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) {}

8
test/behavior/enum.zig
View File

@ -617,7 +617,6 @@ 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, _ };
@ -660,8 +659,6 @@ 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) { _ };
@ -683,7 +680,6 @@ 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, _ };
@ -856,8 +852,6 @@ 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);
}
@ -1211,8 +1205,6 @@ test "enum tag from a local variable" {
}
test "auto-numbered enum with signed tag type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const E = enum(i32) { a, b };
try std.testing.expectEqual(@as(i32, 0), @intFromEnum(E.a));

10
test/behavior/error.zig
View File

@ -124,7 +124,6 @@ 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 {
@ -218,7 +217,6 @@ 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);
try comptime testExplicitErrorSetCast(Set1.A);
@ -320,7 +318,6 @@ 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);
}
@ -404,7 +401,6 @@ 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 {
@ -469,7 +465,6 @@ 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;
try comptime expect(@sizeOf(?anyerror) == @sizeOf(anyerror));
try comptime expect(@alignOf(?anyerror) == @alignOf(anyerror));
@ -485,7 +480,6 @@ 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 {
@ -536,7 +530,6 @@ 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 {
@ -568,7 +561,6 @@ 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();
@ -736,7 +728,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_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn foo() !u8 {
@ -920,7 +911,6 @@ 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 {

8
test/behavior/eval.zig
View File

@ -441,7 +441,6 @@ 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;
@ -710,7 +709,6 @@ fn loopNTimes(comptime n: usize) void {
}
test "variable inside inline loop that has different types on different iterations" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testVarInsideInlineLoop(.{ true, @as(u32, 42) });
}
@ -760,7 +758,6 @@ 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 };
@ -777,7 +774,6 @@ 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 };
@ -794,7 +790,6 @@ 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 };
@ -812,7 +807,6 @@ 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 };
@ -1668,8 +1662,6 @@ 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();

20
test/behavior/floatop.zig
View File

@ -29,6 +29,7 @@ test "add f32/f64" {
test "add f80/f128/c_longdouble" {
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testAdd(f80);
try comptime testAdd(f80);
@ -60,6 +61,7 @@ test "sub f32/f64" {
test "sub f80/f128/c_longdouble" {
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testSub(f80);
try comptime testSub(f80);
@ -91,6 +93,7 @@ test "mul f32/f64" {
test "mul f80/f128/c_longdouble" {
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testMul(f80);
try comptime testMul(f80);
@ -200,7 +203,6 @@ 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;
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
try testDifferentSizedFloatComparisons();
@ -235,6 +237,7 @@ fn testDifferentSizedFloatComparisons() !void {
test "negative f128 intFromFloat at compile-time" {
if (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 = -2;
var b = @as(i64, @intFromFloat(a));
@ -908,6 +911,7 @@ test "@abs f16" {
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 builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testFabs(f16);
try comptime testFabs(f16);
@ -917,6 +921,7 @@ test "@abs f32/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;
try testFabs(f32);
try comptime testFabs(f32);
@ -930,6 +935,7 @@ test "@abs f80/f128/c_longdouble" {
if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testFabs(f80);
try comptime testFabs(f80);
@ -1007,6 +1013,7 @@ test "@floor f16" {
if (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 builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testFloor(f16);
try comptime testFloor(f16);
@ -1017,6 +1024,7 @@ test "@floor f32/f64" {
if (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 builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testFloor(f32);
try comptime testFloor(f32);
@ -1030,6 +1038,7 @@ test "@floor f80/f128/c_longdouble" {
if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
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
@ -1089,6 +1098,7 @@ test "@ceil f16" {
if (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 builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testCeil(f16);
try comptime testCeil(f16);
@ -1099,6 +1109,7 @@ test "@ceil f32/f64" {
if (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 builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testCeil(f32);
try comptime testCeil(f32);
@ -1112,6 +1123,7 @@ test "@ceil f80/f128/c_longdouble" {
if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
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
@ -1148,8 +1160,8 @@ fn testCeil(comptime T: type) !void {
test "@ceil 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_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64 and
!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest;
@ -1171,6 +1183,7 @@ test "@trunc f16" {
if (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 builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {
// https://github.com/ziglang/zig/issues/16846
@ -1186,6 +1199,7 @@ test "@trunc f32/f64" {
if (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 builtin.target.ofmt != .elf) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {
// https://github.com/ziglang/zig/issues/16846
@ -1204,6 +1218,7 @@ test "@trunc f80/f128/c_longdouble" {
if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
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
@ -1390,6 +1405,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);

11
test/behavior/fn.zig
View File

@ -201,7 +201,6 @@ 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);
}
@ -257,7 +256,6 @@ 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 {
@ -284,7 +282,6 @@ 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, {});
}
@ -348,7 +345,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_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -369,7 +365,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_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -415,7 +410,6 @@ 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) {
@ -451,7 +445,6 @@ 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,
@ -471,7 +464,6 @@ 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,
@ -528,7 +520,6 @@ 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 {
@ -571,8 +562,6 @@ test "lazy values passed to anytype parameter" {
}
test "pass and return comptime-only types" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn returnNull(comptime x: @Type(.Null)) @Type(.Null) {
return x;

11
test/behavior/for.zig
View File

@ -7,7 +7,6 @@ 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;
@ -113,7 +112,6 @@ 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 {
@ -134,7 +132,6 @@ 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 {
@ -182,7 +179,6 @@ 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 {
@ -217,7 +213,6 @@ 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;
@ -279,7 +274,6 @@ 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;
@ -360,7 +354,6 @@ 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";
@ -380,7 +373,6 @@ 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;
@ -429,7 +421,6 @@ 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;
@ -460,7 +451,6 @@ test "inline for on tuple pointer" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const S = struct { u32, u32, u32 };
var s: S = .{ 100, 200, 300 };
@ -476,7 +466,6 @@ test "ref counter that starts at zero" {
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; // TODO
for ([_]usize{ 0, 1, 2 }, 0..) |i, j| {
try expectEqual(i, j);

4
test/behavior/generics.zig
View File

@ -153,7 +153,6 @@ 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{
@ -280,7 +279,6 @@ test "generic function instantiation turns into comptime call" {
test "generic function with void and comptime parameter" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct { x: i32 };
const namespace = struct {
@ -315,7 +313,6 @@ 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 {
@ -433,7 +430,6 @@ test "generic function passed as comptime argument" {
test "return type of generic function is function pointer" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn b(comptime T: type) ?*const fn () error{}!T {

3
test/behavior/if.zig
View File

@ -45,7 +45,6 @@ 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);
@ -116,7 +115,6 @@ 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;
@ -134,7 +132,6 @@ 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;

1
test/behavior/inline_switch.zig
View File

@ -84,7 +84,6 @@ 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;

3
test/behavior/int_comparison_elision.zig
View File

@ -4,8 +4,6 @@ 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);
@ -17,6 +15,7 @@ test "int comparison elision" {
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;
// TODO: panic: integer overflow with int types > 65528 bits wide
// TODO: LLVM generates too many parameters for wasmtime when splitting up int > 64000 bits wide

1
test/behavior/ir_block_deps.zig
View File

@ -21,7 +21,6 @@ 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);

1
test/behavior/lower_strlit_to_vector.zig
View File

@ -6,7 +6,6 @@ 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.*;

5
test/behavior/math.zig
View File

@ -1119,6 +1119,8 @@ test "@shlWithOverflow" {
}
test "overflow arithmetic with u0 values" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
{
var a: u0 = 0;
const ov = @addWithOverflow(a, 0);
@ -1287,8 +1289,6 @@ fn testShrExact(x: u8) !void {
}
test "shift left/right on u0 operand" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
var x: u0 = 0;
@ -1565,7 +1565,6 @@ 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 {

7
test/behavior/maximum_minimum.zig
View File

@ -147,8 +147,6 @@ 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;
@ -161,7 +159,6 @@ 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 };
@ -174,7 +171,6 @@ 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;
@ -224,7 +220,6 @@ test "@min/@max notices bounds from 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 x: u16 = 123;
var y: u32 = 456;
@ -305,8 +300,6 @@ test "@min/@max notices bounds from vector types when element of comptime-known
}
test "@min/@max of signed and unsigned runtime integers" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: i32 = -1;
var y: u31 = 1;

1
test/behavior/merge_error_sets.zig
View File

@ -13,7 +13,6 @@ 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");

4
test/behavior/null.zig
View File

@ -53,7 +53,6 @@ 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();
try comptime maybeReturnImpl();
@ -84,7 +83,6 @@ 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();
try comptime optionalVoidImpl();
@ -108,7 +106,6 @@ 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();
_ = try comptime optionalEmptyStructImpl();
@ -134,7 +131,6 @@ 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;

12
test/behavior/optional.zig
View File

@ -34,8 +34,6 @@ test "optional pointer to size zero struct" {
}
test "equality compare optional pointers" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testNullPtrsEql();
try comptime testNullPtrsEql();
}
@ -60,7 +58,6 @@ 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,
@ -95,7 +92,6 @@ 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,
@ -113,7 +109,6 @@ 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();
try comptime test_cmp_optional_non_optional();
@ -172,7 +167,6 @@ 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 {
@ -255,7 +249,6 @@ 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 {
@ -308,7 +301,6 @@ 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 };
@ -444,7 +436,6 @@ 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;
@ -456,7 +447,6 @@ 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;
@ -496,8 +486,6 @@ test "cast slice to const slice nested in error union and optional" {
}
test "variable of optional of noreturn" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var null_opv: ?noreturn = null;
try std.testing.expectEqual(@as(?noreturn, null), null_opv);
}

5
test/behavior/packed-struct.zig
View File

@ -622,6 +622,7 @@ test "@intFromPtr on a packed struct field unaligned and nested" {
test "packed struct fields modification" {
// Originally reported at https://github.com/ziglang/zig/issues/16615
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Small = packed struct {
val: u8 = 0,
@ -980,6 +981,8 @@ test "store undefined to packed result location" {
}
test "bitcast back and forth" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
// Originally reported at https://github.com/ziglang/zig/issues/9914
const S = packed struct { one: u6, two: u1 };
const s = S{ .one = 0b110101, .two = 0b1 };
@ -991,6 +994,7 @@ test "bitcast back and forth" {
test "field access of packed struct smaller than its abi size inside struct initialized with rls" {
// Originally reported at https://github.com/ziglang/zig/issues/14200
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
ps: packed struct { x: i2, y: i2 },
@ -1039,6 +1043,7 @@ test "modify nested packed struct aligned field" {
test "assigning packed struct inside another packed struct" {
// Originally reported at https://github.com/ziglang/zig/issues/9674
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const Inner = packed struct {

1
test/behavior/packed-union.zig
View File

@ -88,6 +88,7 @@ test "flags in packed union at offset" {
test "packed union in packed struct" {
// Originally reported at https://github.com/ziglang/zig/issues/16581
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const ReadRequest = packed struct { key: i32 };
const RequestType = enum {

5
test/behavior/pointers.zig
View File

@ -191,7 +191,6 @@ test "allowzero pointer and slice" {
if (builtin.zig_backend == .stage2_c) 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 = @as([*]allowzero i32, @ptrFromInt(0));
var opt_ptr: ?[*]allowzero i32 = ptr;
@ -276,7 +275,6 @@ 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 {
@ -411,7 +409,6 @@ 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])));
@ -496,7 +493,6 @@ 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 = @as([*c]const u8, @ptrCast(s));
@ -507,7 +503,6 @@ test "intFromPtr 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) {

4
test/behavior/ptrcast.zig
View File

@ -233,7 +233,6 @@ 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;
@ -246,7 +245,6 @@ 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 {
@ -286,6 +284,8 @@ test "@ptrCast undefined value at comptime" {
}
test "comptime @ptrCast with packed struct leaves value unmodified" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = packed struct { three: u3 };
const st: S = .{ .three = 6 };
try expect(st.three == 6);

2
test/behavior/ptrfromint.zig
View File

@ -33,7 +33,6 @@ test "@ptrFromInt creates null 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 ptr = @as(?*u32, @ptrFromInt(0));
try expectEqual(@as(?*u32, null), ptr);
@ -43,7 +42,6 @@ test "@ptrFromInt creates allowzero zero 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 ptr = @as(*allowzero u32, @ptrFromInt(0));
try expectEqual(@as(usize, 0), @intFromPtr(ptr));

3
test/behavior/sizeof_and_typeof.zig
View File

@ -18,8 +18,6 @@ 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;
@ -268,7 +266,6 @@ 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;

9
test/behavior/slice.zig
View File

@ -227,7 +227,6 @@ 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), ""));
@ -240,7 +239,6 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
test "C pointer" {
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;
@ -252,7 +250,6 @@ 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 = @as([*c]const u32, @ptrCast(&buf));
@ -282,7 +279,6 @@ 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,
@ -356,7 +352,6 @@ 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 {
@ -615,7 +610,6 @@ 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 {
@ -830,7 +824,6 @@ 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];
@ -841,7 +834,6 @@ 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 {
@ -861,7 +853,6 @@ test "modify slice length at 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;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const arr: [2]u8 = .{ 10, 20 };
comptime var s: []const u8 = arr[0..0];

2
test/behavior/src.zig
View File

@ -33,8 +33,6 @@ 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;

3
test/behavior/struct.zig
View File

@ -134,8 +134,6 @@ test "invoke static method in global scope" {
const empty_global_instance = StructWithNoFields{};
test "return empty struct instance" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
_ = returnEmptyStructInstance();
}
fn returnEmptyStructInstance() StructWithNoFields {
@ -328,7 +326,6 @@ const VoidStructFieldsFoo = struct {
test "return empty struct from fn" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
_ = testReturnEmptyStructFromFn();
}

7
test/behavior/switch.zig
View File

@ -623,7 +623,6 @@ 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 {
@ -710,8 +709,6 @@ test "comptime inline switch" {
}
test "switch capture peer type resolution" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = union(enum) {
a: u32,
b: u64,
@ -727,8 +724,6 @@ test "switch capture peer type resolution" {
}
test "switch capture peer type resolution for in-memory coercible payloads" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const T1 = c_int;
const T2 = @Type(@typeInfo(T1));
@ -777,8 +772,6 @@ test "switch pointer capture peer type resolution" {
}
test "inline switch range that includes the maximum value of the switched type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const inputs: [3]u8 = .{ 0, 254, 255 };
for (inputs) |input| {
switch (input) {

1
test/behavior/switch_prong_err_enum.zig
View File

@ -24,7 +24,6 @@ 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| {

1
test/behavior/switch_prong_implicit_cast.zig
View File

@ -18,7 +18,6 @@ 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,

1
test/behavior/threadlocal.zig
View File

@ -33,7 +33,6 @@ 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);

3
test/behavior/try.zig
View File

@ -4,7 +4,6 @@ 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();
try comptime tryOnErrorUnionImpl();
@ -40,8 +39,6 @@ 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| {

10
test/behavior/tuple.zig
View File

@ -10,7 +10,6 @@ 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 {
@ -269,7 +268,6 @@ 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 }) {
@ -310,8 +308,6 @@ 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(.{
@ -351,7 +347,6 @@ 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 {
@ -366,7 +361,6 @@ test "tuple initialized with a runtime known value" {
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 E = union(enum) { e: []const u8 };
const W = union(enum) { w: E };
@ -380,7 +374,6 @@ test "tuple of struct concatenation and coercion to array" {
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 StructWithDefault = struct { value: f32 = 42 };
const SomeStruct = struct { array: [4]StructWithDefault };
@ -395,7 +388,6 @@ 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 = .{
@ -430,7 +422,6 @@ test "tuple pointer is indexable" {
if (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
const S = struct { u32, bool };
@ -454,7 +445,6 @@ test "coerce anon 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; // TODO
var x: u8 = 1;
var y: u16 = 2;

2
test/behavior/tuple_declarations.zig
View File

@ -7,7 +7,6 @@ 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 };
@ -36,7 +35,6 @@ 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" };

3
test/behavior/type.zig
View File

@ -202,7 +202,6 @@ 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 = .{
@ -260,7 +259,6 @@ 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,7 +346,6 @@ 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 = .{

1
test/behavior/type_info.zig
View File

@ -565,7 +565,6 @@ 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 {
pub const x = 5;

2
test/behavior/type_info_only_pub_decls.zig
View File

@ -15,8 +15,6 @@ const other = struct {
};
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const ti = @typeInfo(other);
const decls = ti.Struct.decls;

2
test/behavior/typename.zig
View File

@ -67,7 +67,6 @@ 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));
@ -231,7 +230,6 @@ 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));

17
test/behavior/union.zig
View File

@ -97,7 +97,6 @@ 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);
@ -218,7 +217,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_spirv64) return error.SkipZigTest;
try doTest();
try comptime doTest();
@ -381,7 +379,6 @@ 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({}));
}
@ -466,7 +463,6 @@ 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 };
@ -966,7 +962,6 @@ 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_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const U = union(enum) {
@ -1056,7 +1051,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_spirv64) return error.SkipZigTest;
const S = struct {
const A = union(enum) { f1 };
@ -1573,7 +1567,6 @@ test "undefined-layout union field pointer has correct alignment" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const S = struct {
fn doTheTest(comptime U: type) !void {
@ -1659,6 +1652,8 @@ test "union with 128 bit integer" {
}
test "memset extern union" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = extern union {
foo: u8,
bar: u32,
@ -1678,6 +1673,8 @@ test "memset extern union" {
}
test "memset packed union" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = packed union {
a: u32,
b: u8,
@ -1703,6 +1700,8 @@ fn littleToNativeEndian(comptime T: type, v: T) T {
}
test "reinterpret extern union" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = extern union {
foo: u8,
baz: u32 align(8),
@ -1771,6 +1770,8 @@ test "reinterpret extern union" {
}
test "reinterpret packed union" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = packed union {
foo: u8,
bar: u29,
@ -1842,6 +1843,8 @@ test "reinterpret packed union" {
}
test "reinterpret packed union inside packed struct" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = packed union {
a: u7,
b: u1,

1
test/behavior/usingnamespace.zig
View File

@ -55,7 +55,6 @@ 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());
}

10
test/behavior/var_args.zig
View File

@ -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);
@ -26,15 +24,12 @@ fn readFirstVarArg(args: anytype) void {
}
test "send void arg to var args" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
readFirstVarArg(.{{}});
}
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);
@ -48,7 +43,6 @@ 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);
@ -87,15 +81,11 @@ fn foo2(args: anytype) bool {
}
test "array of var args functions" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(foos[0](.{}));
try expect(!foos[1](.{}));
}
test "pass zero length array to var args param" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
doNothingWithFirstArg(.{""});
}

1
test/behavior/vector.zig
View File

@ -11,7 +11,6 @@ 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 {

2
test/behavior/void.zig
View File

@ -20,7 +20,6 @@ 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| {
@ -37,7 +36,6 @@ 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);

1
test/behavior/while.zig
View File

@ -172,7 +172,6 @@ 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;

2
test/behavior/widening.zig
View File

@ -22,8 +22,6 @@ 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);
}