srctree

Robin Voetter parent 1d548aa2 9fbba0e0
spirv: update tests

inline split

test/behavior/align.zig added: 79, removed: 53, total 26

@@ -18,7 +18,6 @@ test "global variable alignment" {

test "large alignment of local constant" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky

const x: f32 align(128) = 12.34;

try std.testing.expect(@intFromPtr(&x) % 128 == 0);

@@ -27,7 +26,7 @@ test "large alignment of local constant" {

test "slicing array of length 1 can not assume runtime index is always zero" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky

var runtime_index: usize = 1;

_ = &runtime_index;

@@ -512,7 +511,7 @@ test "struct field explicit alignment" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky

const S = struct {

const Node = struct {

@@ -581,7 +580,7 @@ test "comptime alloc alignment" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky

if (builtin.zig_backend == .stage2_llvm and builtin.target.cpu.arch == .x86) {

// https://github.com/ziglang/zig/issues/18034

return error.SkipZigTest;

test/behavior/array.zig added: 79, removed: 53, total 26

@@ -768,8 +768,6 @@ test "array init with no result pointer sets field result types" {

}

test "runtime side-effects in comptime-known array init" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

var side_effects: u4 = 0;

const init = [4]u4{

blk: {

test/behavior/basic.zig added: 79, removed: 53, total 26

@@ -1222,6 +1222,7 @@ test "integer compare" {

test "reference to inferred local variable works as expected" {

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const Crasher = struct {

lets_crash: u64 = 0,

test/behavior/builtin_functions_returning_void_or_noreturn.zig added: 79, removed: 53, total 26

@@ -11,6 +11,7 @@ test {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

var val: u8 = undefined;

try testing.expectEqual({}, @atomicStore(u8, &val, 0, .Unordered));

test/behavior/cast.zig added: 79, removed: 53, total 26

@@ -759,6 +759,7 @@ test "peer type resolution: error union and error set" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const a: error{Three} = undefined;

const b: error{ One, Two }!u32 = undefined;

@@ -1730,7 +1731,6 @@ test "peer type resolution: array with smaller child type and vector with larger

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO

var arr: [2]u8 = .{ 0, 1 };

var vec: @Vector(2, u64) = .{ 2, 3 };

@@ -2318,7 +2318,6 @@ test "@floatCast on vector" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;

const S = struct {

@@ -2339,7 +2338,6 @@ test "@ptrFromInt on vector" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

fn doTheTest() !void {

@@ -2363,7 +2361,6 @@ test "@intFromPtr on vector" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

fn doTheTest() !void {

@@ -2387,7 +2384,6 @@ test "@floatFromInt on vector" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;

const S = struct {

@@ -2408,7 +2404,6 @@ test "@intFromFloat on vector" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

fn doTheTest() !void {

test/behavior/destructure.zig added: 79, removed: 53, total 26

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const assert = std.debug.assert;

const expect = std.testing.expect;

test/behavior/duplicated_test_names.zig added: 79, removed: 53, total 26

@@ -15,5 +15,7 @@ comptime {

test "thingy" {}

test thingy {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

if (thingy(1, 2) != 3) unreachable;

}

test/behavior/eval.zig added: 79, removed: 53, total 26

@@ -489,7 +489,6 @@ test "comptime bitwise operators" {

test "comptime shlWithOverflow" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0];

var a = ~@as(u64, 0);

test/behavior/export_builtin.zig added: 79, removed: 53, total 26

@@ -6,7 +6,6 @@ test "exporting enum type and value" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

const E = enum(c_int) { one, two };

@@ -22,7 +21,6 @@ test "exporting with internal linkage" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

fn foo() callconv(.C) void {}

@@ -37,7 +35,6 @@ test "exporting using field access" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

const Inner = struct {

test/behavior/export_keyword.zig added: 79, removed: 53, total 26

@@ -23,6 +23,7 @@ const PackedUnion = packed union {

test "packed struct, enum, union parameters in extern function" {

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

testPackedStuff(&(PackedStruct{

.a = 1,

test/behavior/extern.zig added: 79, removed: 53, total 26

@@ -5,6 +5,7 @@ const expect = std.testing.expect;

test "anyopaque extern symbol" {

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const a = @extern(*anyopaque, .{ .name = "a_mystery_symbol" });

const b: *i32 = @alignCast(@ptrCast(a));

@@ -17,6 +18,7 @@ test "function extern symbol" {

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const a = @extern(*const fn () callconv(.C) i32, .{ .name = "a_mystery_function" });

try expect(a() == 4567);

test/behavior/for.zig added: 79, removed: 53, total 26

@@ -456,6 +456,7 @@ test "inline for on tuple pointer" {

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct { u32, u32, u32 };

var s: S = .{ 100, 200, 300 };

test/behavior/globals.zig added: 79, removed: 53, total 26

@@ -8,7 +8,6 @@ test "store to global array" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try expect(pos[1] == 0.0);

pos = [2]f32{ 0.0, 1.0 };

@@ -21,7 +20,6 @@ test "store to global vector" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try expect(vpos[1] == 0.0);

vpos = @Vector(2, f32){ 0.0, 1.0 };

test/behavior/hasdecl.zig added: 79, removed: 53, total 26

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

const Foo = @import("hasdecl/foo.zig");

@@ -11,6 +12,8 @@ const Bar = struct {

};

test "@hasDecl" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try expect(@hasDecl(Foo, "public_thing"));

try expect(!@hasDecl(Foo, "private_thing"));

try expect(!@hasDecl(Foo, "no_thing"));

@@ -21,6 +24,8 @@ test "@hasDecl" {

}

test "@hasDecl using a sliced string literal" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try expect(@hasDecl(@This(), "std") == true);

try expect(@hasDecl(@This(), "std"[0..0]) == false);

try expect(@hasDecl(@This(), "std"[0..1]) == false);

test/behavior/import.zig added: 79, removed: 53, total 26

@@ -1,17 +1,24 @@

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

const a_namespace = @import("import/a_namespace.zig");

test "call fn via namespace lookup" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try expect(@as(i32, 1234) == a_namespace.foo());

}

test "importing the same thing gives the same import" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try expect(@import("std") == @import("std"));

}

test "import in non-toplevel scope" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

usingnamespace @import("import/a_namespace.zig");

};

@@ -19,5 +26,7 @@ test "import in non-toplevel scope" {

}

test "import empty file" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

_ = @import("import/empty.zig");

}

test/behavior/int_div.zig added: 79, removed: 53, total 26

@@ -6,6 +6,7 @@ test "integer division" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try testDivision();

try comptime testDivision();

@@ -96,6 +97,7 @@ test "large integer division" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

{

var numerator: u256 = 99999999999999999997315645440;

test/behavior/math.zig added: 79, removed: 53, total 26

@@ -602,7 +602,6 @@ fn testUnsignedNegationWrappingEval(x: u16) !void {

test "negation wrapping" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try expectEqual(@as(u1, 1), negateWrap(u1, 1));

}

@@ -770,7 +769,6 @@ test "@addWithOverflow" {

test "small int addition" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

var x: u2 = 0;

try expect(x == 0);

@@ -1564,7 +1562,6 @@ test "vector integer addition" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

fn doTheTest() !void {

test/behavior/namespace_depends_on_compile_var.zig added: 79, removed: 53, total 26

@@ -3,6 +3,8 @@ const builtin = @import("builtin");

const expect = std.testing.expect;

test "namespace depends on compile var" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

if (some_namespace.a_bool) {

try expect(some_namespace.a_bool);

} else {

test/behavior/optional.zig added: 79, removed: 53, total 26

@@ -451,6 +451,7 @@ test "Optional slice passed to function" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

fn foo(a: ?[]const u8) !void {

test/behavior/pub_enum.zig added: 79, removed: 53, total 26

@@ -3,6 +3,8 @@ const other = @import("pub_enum/other.zig");

const expect = @import("std").testing.expect;

test "pub enum" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try pubEnumTest(other.APubEnum.Two);

}

fn pubEnumTest(foo: other.APubEnum) !void {

@@ -10,5 +12,7 @@ fn pubEnumTest(foo: other.APubEnum) !void {

}

test "cast with imported symbol" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

try expect(@as(other.size_t, 42) == 42);

}

test/behavior/slice_sentinel_comptime.zig added: 79, removed: 53, total 26

@@ -1,3 +1,5 @@

const builtin = @import("builtin");

test "comptime slice-sentinel in bounds (unterminated)" {

// array

comptime {

test/behavior/struct.zig added: 79, removed: 53, total 26

@@ -1744,8 +1744,6 @@ test "struct init with no result pointer sets field result types" {

}

test "runtime side-effects in comptime-known struct init" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

var side_effects: u4 = 0;

const S = struct { a: u4, b: u4, c: u4, d: u4 };

const init = S{

@@ -2056,6 +2054,8 @@ test "struct field default value is a call" {

}

test "aggregate initializers should allow initializing comptime fields, verifying equality" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

var x: u32 = 15;

_ = &x;

const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });

test/behavior/switch_on_captured_error.zig added: 79, removed: 53, total 26

@@ -5,6 +5,8 @@ const expectError = std.testing.expectError;

const expectEqual = std.testing.expectEqual;

test "switch on error union catch capture" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

const Error = error{ A, B, C };

fn doTheTest() !void {

@@ -257,6 +259,8 @@ test "switch on error union catch capture" {

}

test "switch on error union if else capture" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

const Error = error{ A, B, C };

fn doTheTest() !void {

test/behavior/tuple.zig added: 79, removed: 53, total 26

@@ -483,7 +483,6 @@ test "empty tuple type" {

test "tuple with comptime fields with non empty initializer" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const a: struct { comptime comptime_int = 0 } = .{0};

_ = a;

test/behavior/union.zig added: 79, removed: 53, total 26

@@ -1119,6 +1119,7 @@ test "@unionInit on union with tag but no fields" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

const Type = enum(u8) { no_op = 105 };

@@ -2059,7 +2060,6 @@ test "store of comptime reinterpreted memory to packed union" {

test "union field is a pointer to an aligned version of itself" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const E = union {

next: *align(1) @This(),

@@ -2181,6 +2181,7 @@ test "create union(enum) from other union(enum)" {

if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const string = "hello world";

const TempRef = struct {

test/behavior/vector.zig added: 79, removed: 53, total 26

@@ -1060,7 +1060,6 @@ test "@addWithOverflow" {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

// if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

fn doTheTest() !void {

test/behavior/wrapping_arithmetic.zig added: 79, removed: 53, total 26

@@ -5,6 +5,8 @@ const maxInt = std.math.maxInt;

const expect = std.testing.expect;

test "wrapping add" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

fn doTheTest() !void {

try testWrapAdd(i8, -3, 10, 7);

@@ -40,6 +42,8 @@ test "wrapping add" {

}

test "wrapping subtraction" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

const S = struct {

fn doTheTest() !void {

try testWrapSub(i8, -3, 10, -13);

@@ -73,6 +77,8 @@ test "wrapping subtraction" {

}

test "wrapping multiplication" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

// TODO: once #9660 has been solved, remove this line

if (builtin.cpu.arch == .wasm32) return error.SkipZigTest;