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

spirv: skip range switch tests

Browse Source 
This is not yet implemented
This commit is contained in:
Robin Voetter 2024-10-13 01:58:11 +02:00
parent c1132edd53
commit 86b88ea7da
No known key found for this signature in database
7 changed files with 27 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
test/behavior/basic.zig
View File

@ -1260,6 +1260,7 @@ test "integer compare <= 64 bits" {
test "integer compare <= 128 bits" { test "integer compare <= 128 bits" {
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
inline for (.{ u65, u96, u127, u128 }) |T| { inline for (.{ u65, u96, u127, u128 }) |T| {
try testUnsignedCmp(T); try testUnsignedCmp(T);

2
test/behavior/decl_literals.zig
View File

@ -73,6 +73,8 @@ test "call decl literal" {
} }
test "call decl literal with error union" { test "call decl literal with error union" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
x: u32, x: u32,
fn init(err: bool) !@This() { fn init(err: bool) !@This() {

2
test/behavior/eval.zig
View File

@ -1618,6 +1618,8 @@ test "struct in comptime false branch is not evaluated" {
} }
test "result of nested switch assigned to variable" { test "result of nested switch assigned to variable" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
var zds: u32 = 0; var zds: u32 = 0;
zds = switch (zds) { zds = switch (zds) {
0 => switch (zds) { 0 => switch (zds) {

1
test/behavior/inline_switch.zig
View File

@ -113,6 +113,7 @@ test "inline else enum" {
test "inline else int with gaps" { test "inline else int with gaps" {
if (builtin.zig_backend == .stage2_aarch64) 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_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
var a: u8 = 0; var a: u8 = 0;
_ = &a; _ = &a;

4
test/behavior/math.zig
View File

@ -833,6 +833,8 @@ test "@addWithOverflow > 64 bits" {
if (builtin.zig_backend == .stage2_arm) 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_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
try testAddWithOverflow(u65, 4, 105, 109, 0); try testAddWithOverflow(u65, 4, 105, 109, 0);
try testAddWithOverflow(u65, 1000, 100, 1100, 0); try testAddWithOverflow(u65, 1000, 100, 1100, 0);
@ -986,6 +988,7 @@ test "@mulWithOverflow bitsize 128 bits" {
if (builtin.zig_backend == .stage2_aarch64) 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_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555555, 0xffffffffffffffff_ffffffffffffffff, 0); try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555555, 0xffffffffffffffff_ffffffffffffffff, 0);
try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555556, 2, 1); try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555556, 2, 1);
@ -1065,6 +1068,7 @@ test "@subWithOverflow > 64 bits" {
if (builtin.zig_backend == .stage2_arm) 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_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
try testSubWithOverflow(u65, 4, 105, maxInt(u65) - 100, 1); try testSubWithOverflow(u65, 4, 105, maxInt(u65) - 100, 1);
try testSubWithOverflow(u65, 1000, 100, 900, 0); try testSubWithOverflow(u65, 1000, 100, 900, 0);

1
test/behavior/pointers.zig
View File

@ -45,6 +45,7 @@ test "pointer-integer arithmetic" {
test "pointer subtraction" { test "pointer subtraction" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
{ {
const a: *u8 = @ptrFromInt(100); const a: *u8 = @ptrFromInt(100);

16
test/behavior/switch.zig
View File

@ -12,6 +12,8 @@ test "switch with numbers" {
} }
fn testSwitchWithNumbers(x: u32) !void { fn testSwitchWithNumbers(x: u32) !void {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const result = switch (x) { const result = switch (x) {
1, 2, 3, 4...8 => false, 1, 2, 3, 4...8 => false,
13 => true, 13 => true,
@ -22,6 +24,7 @@ fn testSwitchWithNumbers(x: u32) !void {
test "switch with all ranges" { test "switch with all ranges" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
try expect(testSwitchWithAllRanges(50, 3) == 1); try expect(testSwitchWithAllRanges(50, 3) == 1);
try expect(testSwitchWithAllRanges(101, 0) == 2); try expect(testSwitchWithAllRanges(101, 0) == 2);
@ -173,6 +176,7 @@ test "undefined.u0" {
test "switch with disjoint range" { test "switch with disjoint range" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
var q: u8 = 0; var q: u8 = 0;
_ = &q; _ = &q;
@ -184,6 +188,8 @@ test "switch with disjoint range" {
} }
test "switch variable for range and multiple prongs" { test "switch variable for range and multiple prongs" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
try doTheSwitch(16); try doTheSwitch(16);
@ -281,6 +287,8 @@ test "switch handles all cases of number" {
} }
fn testSwitchHandleAllCases() !void { fn testSwitchHandleAllCases() !void {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
try expect(testSwitchHandleAllCasesExhaustive(0) == 3); try expect(testSwitchHandleAllCasesExhaustive(0) == 3);
try expect(testSwitchHandleAllCasesExhaustive(1) == 2); try expect(testSwitchHandleAllCasesExhaustive(1) == 2);
try expect(testSwitchHandleAllCasesExhaustive(2) == 1); try expect(testSwitchHandleAllCasesExhaustive(2) == 1);
@ -497,6 +505,7 @@ test "switch prongs with error set cases make a new error set type for capture v
test "return result loc and then switch with range implicit casted to error union" { test "return result loc and then switch with range implicit casted to error union" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
@ -714,6 +723,7 @@ test "switch capture copies its payload" {
test "capture of integer forwards the switch condition directly" { test "capture of integer forwards the switch condition directly" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn foo(x: u8) !void { fn foo(x: u8) !void {
@ -854,6 +864,7 @@ test "inline switch range that includes the maximum value of the switched type"
test "nested break ignores switch conditions and breaks instead" { test "nested break ignores switch conditions and breaks instead" {
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct { const S = struct {
fn register_to_address(ident: []const u8) !u8 { fn register_to_address(ident: []const u8) !u8 {
@ -901,6 +912,7 @@ test "peer type resolution on switch captures ignores unused payload bits" {
test "switch prong captures range" { test "switch prong captures range" {
if (builtin.zig_backend == .stage2_aarch64) 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_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn a(b: []u3, c: u3) void { fn a(b: []u3, c: u3) void {
@ -935,6 +947,8 @@ test "prong with inline call to unreachable" {
} }
test "block error return trace index is reset between prongs" { test "block error return trace index is reset between prongs" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn returnError() error{TestFailed} { fn returnError() error{TestFailed} {
return error.TestFailed; return error.TestFailed;
@ -963,6 +977,8 @@ test "block error return trace index is reset between prongs" {
} }
test "labeled switch with break" { test "labeled switch with break" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
var six: u32 = undefined; var six: u32 = undefined;
six = 6; six = 6;