mirror of
https://github.com/ziglang/zig.git
synced 2025-12-06 06:13:07 +00:00
1121 lines
30 KiB
Zig
1121 lines
30 KiB
Zig
const builtin = @import("builtin");
|
|
const std = @import("std");
|
|
const assert = std.debug.assert;
|
|
const expect = std.testing.expect;
|
|
const expectError = std.testing.expectError;
|
|
const expectEqual = std.testing.expectEqual;
|
|
const minInt = std.math.minInt;
|
|
const maxInt = std.math.maxInt;
|
|
|
|
test "switch with numbers" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
|
|
|
|
try testSwitchWithNumbers(13);
|
|
}
|
|
|
|
fn testSwitchWithNumbers(x: u32) !void {
|
|
const result = switch (x) {
|
|
1, 2, 3, 4...8 => false,
|
|
13 => true,
|
|
else => false,
|
|
};
|
|
try expect(result);
|
|
}
|
|
|
|
test "switch with all ranges" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
|
|
|
|
try expect(testSwitchWithAllRanges(50, 3) == 1);
|
|
try expect(testSwitchWithAllRanges(101, 0) == 2);
|
|
try expect(testSwitchWithAllRanges(300, 5) == 3);
|
|
try expect(testSwitchWithAllRanges(301, 6) == 6);
|
|
}
|
|
|
|
fn testSwitchWithAllRanges(x: u32, y: u32) u32 {
|
|
return switch (x) {
|
|
0...100 => 1,
|
|
101...200 => 2,
|
|
201...300 => 3,
|
|
else => y,
|
|
};
|
|
}
|
|
|
|
test "switch arbitrary int size" {
|
|
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_spirv) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
|
|
|
|
if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // TODO
|
|
|
|
try expect(testSwitchArbInt(u64, 0) == 0);
|
|
try expect(testSwitchArbInt(u64, 12) == 1);
|
|
try expect(testSwitchArbInt(u64, maxInt(u64)) == 2);
|
|
try expect(testSwitchArbInt(u64, 5555) == 3);
|
|
|
|
try expect(testSwitchArbInt(i64, minInt(i64)) == 0);
|
|
try expect(testSwitchArbInt(i64, 12) == 1);
|
|
try expect(testSwitchArbInt(i64, maxInt(i64)) == 2);
|
|
try expect(testSwitchArbInt(i64, -1000) == 3);
|
|
|
|
try expect(testSwitchArbInt(u128, 0) == 0);
|
|
try expect(testSwitchArbInt(u128, 12) == 1);
|
|
try expect(testSwitchArbInt(u128, maxInt(u128)) == 2);
|
|
try expect(testSwitchArbInt(u128, 5555) == 3);
|
|
|
|
try expect(testSwitchArbInt(i128, minInt(i128)) == 0);
|
|
try expect(testSwitchArbInt(i128, 12) == 1);
|
|
try expect(testSwitchArbInt(i128, maxInt(i128)) == 2);
|
|
try expect(testSwitchArbInt(i128, -1000) == 3);
|
|
}
|
|
|
|
fn testSwitchArbInt(comptime T: type, x: T) u32 {
|
|
return switch (x) {
|
|
minInt(T) => 0,
|
|
10...15 => 1,
|
|
maxInt(T) => 2,
|
|
else => 3,
|
|
};
|
|
}
|
|
|
|
test "implicit comptime switch" {
|
|
const x = 3 + 4;
|
|
const result = switch (x) {
|
|
3 => 10,
|
|
4 => 11,
|
|
5, 6 => 12,
|
|
7, 8 => 13,
|
|
else => 14,
|
|
};
|
|
|
|
comptime {
|
|
try expect(result + 1 == 14);
|
|
}
|
|
}
|
|
|
|
test "switch on enum" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
const fruit = Fruit.Orange;
|
|
try expect(nonConstSwitchOnEnum(fruit));
|
|
}
|
|
const Fruit = enum {
|
|
Apple,
|
|
Orange,
|
|
Banana,
|
|
};
|
|
fn nonConstSwitchOnEnum(fruit: Fruit) bool {
|
|
return switch (fruit) {
|
|
Fruit.Apple => false,
|
|
Fruit.Orange => true,
|
|
Fruit.Banana => false,
|
|
};
|
|
}
|
|
|
|
test "switch statement" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
try nonConstSwitch(SwitchStatementFoo.C);
|
|
}
|
|
fn nonConstSwitch(foo: SwitchStatementFoo) !void {
|
|
const val = switch (foo) {
|
|
SwitchStatementFoo.A => @as(i32, 1),
|
|
SwitchStatementFoo.B => 2,
|
|
SwitchStatementFoo.C => 3,
|
|
SwitchStatementFoo.D => 4,
|
|
};
|
|
try expect(val == 3);
|
|
}
|
|
const SwitchStatementFoo = enum { A, B, C, D };
|
|
|
|
test "switch with multiple expressions" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
const x = switch (returnsFive()) {
|
|
1, 2, 3 => 1,
|
|
4, 5, 6 => 2,
|
|
else => @as(i32, 3),
|
|
};
|
|
try expect(x == 2);
|
|
}
|
|
fn returnsFive() i32 {
|
|
return 5;
|
|
}
|
|
|
|
test "switch on type" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
try expect(trueIfBoolFalseOtherwise(bool));
|
|
try expect(!trueIfBoolFalseOtherwise(i32));
|
|
}
|
|
|
|
fn trueIfBoolFalseOtherwise(comptime T: type) bool {
|
|
return switch (T) {
|
|
bool => true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
test "switching on booleans" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
try testSwitchOnBools();
|
|
try comptime testSwitchOnBools();
|
|
}
|
|
|
|
fn testSwitchOnBools() !void {
|
|
try expect(testSwitchOnBoolsTrueAndFalse(true) == false);
|
|
try expect(testSwitchOnBoolsTrueAndFalse(false) == true);
|
|
|
|
try expect(testSwitchOnBoolsTrueWithElse(true) == false);
|
|
try expect(testSwitchOnBoolsTrueWithElse(false) == true);
|
|
|
|
try expect(testSwitchOnBoolsFalseWithElse(true) == false);
|
|
try expect(testSwitchOnBoolsFalseWithElse(false) == true);
|
|
}
|
|
|
|
fn testSwitchOnBoolsTrueAndFalse(x: bool) bool {
|
|
return switch (x) {
|
|
true => false,
|
|
false => true,
|
|
};
|
|
}
|
|
|
|
fn testSwitchOnBoolsTrueWithElse(x: bool) bool {
|
|
return switch (x) {
|
|
true => false,
|
|
else => true,
|
|
};
|
|
}
|
|
|
|
fn testSwitchOnBoolsFalseWithElse(x: bool) bool {
|
|
return switch (x) {
|
|
false => true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
test "u0" {
|
|
var val: u0 = 0;
|
|
_ = &val;
|
|
switch (val) {
|
|
0 => try expect(val == 0),
|
|
}
|
|
}
|
|
|
|
test "undefined.u0" {
|
|
var val: u0 = undefined;
|
|
_ = &val;
|
|
switch (val) {
|
|
0 => try expect(val == 0),
|
|
}
|
|
}
|
|
|
|
test "switch with disjoint range" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
|
|
|
|
var q: u8 = 0;
|
|
_ = &q;
|
|
switch (q) {
|
|
0...125 => {},
|
|
127...255 => {},
|
|
126...126 => {},
|
|
}
|
|
}
|
|
|
|
test "switch variable for range and multiple prongs" {
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
|
|
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
try doTheSwitch(16);
|
|
try doTheSwitch(42);
|
|
}
|
|
fn doTheSwitch(q: u8) !void {
|
|
switch (q) {
|
|
0...40 => |x| try expect(x == 16),
|
|
41, 42, 43 => |x| try expect(x == 42),
|
|
else => try expect(false),
|
|
}
|
|
}
|
|
};
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
}
|
|
|
|
var state: u32 = 0;
|
|
fn poll() void {
|
|
switch (state) {
|
|
0 => {
|
|
state = 1;
|
|
},
|
|
else => {
|
|
state += 1;
|
|
},
|
|
}
|
|
}
|
|
|
|
test "switch on global mutable var isn't constant-folded" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
while (state < 2) {
|
|
poll();
|
|
}
|
|
}
|
|
|
|
const SwitchProngWithVarEnum = union(enum) {
|
|
One: i32,
|
|
Two: f32,
|
|
Meh: void,
|
|
};
|
|
|
|
test "switch prong with variable" {
|
|
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_riscv64) return error.SkipZigTest;
|
|
|
|
try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 });
|
|
try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 });
|
|
try switchProngWithVarFn(SwitchProngWithVarEnum{ .Meh = {} });
|
|
}
|
|
fn switchProngWithVarFn(a: SwitchProngWithVarEnum) !void {
|
|
switch (a) {
|
|
SwitchProngWithVarEnum.One => |x| {
|
|
try expect(x == 13);
|
|
},
|
|
SwitchProngWithVarEnum.Two => |x| {
|
|
try expect(x == 13.0);
|
|
},
|
|
SwitchProngWithVarEnum.Meh => |x| {
|
|
const v: void = x;
|
|
_ = v;
|
|
},
|
|
}
|
|
}
|
|
|
|
test "switch on enum using pointer capture" {
|
|
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
try testSwitchEnumPtrCapture();
|
|
try comptime testSwitchEnumPtrCapture();
|
|
}
|
|
|
|
fn testSwitchEnumPtrCapture() !void {
|
|
var value = SwitchProngWithVarEnum{ .One = 1234 };
|
|
switch (value) {
|
|
SwitchProngWithVarEnum.One => |*x| x.* += 1,
|
|
else => unreachable,
|
|
}
|
|
switch (value) {
|
|
SwitchProngWithVarEnum.One => |x| try expect(x == 1235),
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
test "switch handles all cases of number" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
|
|
|
|
try testSwitchHandleAllCases();
|
|
try comptime testSwitchHandleAllCases();
|
|
}
|
|
|
|
fn testSwitchHandleAllCases() !void {
|
|
try expect(testSwitchHandleAllCasesExhaustive(0) == 3);
|
|
try expect(testSwitchHandleAllCasesExhaustive(1) == 2);
|
|
try expect(testSwitchHandleAllCasesExhaustive(2) == 1);
|
|
try expect(testSwitchHandleAllCasesExhaustive(3) == 0);
|
|
|
|
try expect(testSwitchHandleAllCasesRange(100) == 0);
|
|
try expect(testSwitchHandleAllCasesRange(200) == 1);
|
|
try expect(testSwitchHandleAllCasesRange(201) == 2);
|
|
try expect(testSwitchHandleAllCasesRange(202) == 4);
|
|
try expect(testSwitchHandleAllCasesRange(230) == 3);
|
|
}
|
|
|
|
fn testSwitchHandleAllCasesExhaustive(x: u2) u2 {
|
|
return switch (x) {
|
|
0 => @as(u2, 3),
|
|
1 => 2,
|
|
2 => 1,
|
|
3 => 0,
|
|
};
|
|
}
|
|
|
|
fn testSwitchHandleAllCasesRange(x: u8) u8 {
|
|
return switch (x) {
|
|
0...100 => @as(u8, 0),
|
|
101...200 => 1,
|
|
201, 203 => 2,
|
|
202 => 4,
|
|
204...255 => 3,
|
|
};
|
|
}
|
|
|
|
test "switch on union with some prongs capturing" {
|
|
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
const X = union(enum) {
|
|
a,
|
|
b: i32,
|
|
};
|
|
|
|
var x: X = X{ .b = 10 };
|
|
_ = &x;
|
|
const y: i32 = switch (x) {
|
|
.a => unreachable,
|
|
.b => |b| b + 1,
|
|
};
|
|
try expect(y == 11);
|
|
}
|
|
|
|
const Number = union(enum) {
|
|
One: u64,
|
|
Two: u8,
|
|
Three: f32,
|
|
};
|
|
|
|
const number = Number{ .Three = 1.23 };
|
|
|
|
fn returnsFalse() bool {
|
|
switch (number) {
|
|
Number.One => |x| return x > 1234,
|
|
Number.Two => |x| return x == 'a',
|
|
Number.Three => |x| return x > 12.34,
|
|
}
|
|
}
|
|
test "switch on const enum with var" {
|
|
try expect(!returnsFalse());
|
|
}
|
|
|
|
test "anon enum literal used in switch on union enum" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
const Foo = union(enum) {
|
|
a: i32,
|
|
};
|
|
|
|
var foo = Foo{ .a = 1234 };
|
|
_ = &foo;
|
|
switch (foo) {
|
|
.a => |x| {
|
|
try expect(x == 1234);
|
|
},
|
|
}
|
|
}
|
|
|
|
test "switch all prongs unreachable" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
try testAllProngsUnreachable();
|
|
try comptime testAllProngsUnreachable();
|
|
}
|
|
|
|
fn testAllProngsUnreachable() !void {
|
|
try expect(switchWithUnreachable(1) == 2);
|
|
try expect(switchWithUnreachable(2) == 10);
|
|
}
|
|
|
|
fn switchWithUnreachable(x: i32) i32 {
|
|
while (true) {
|
|
switch (x) {
|
|
1 => return 2,
|
|
2 => break,
|
|
else => continue,
|
|
}
|
|
}
|
|
return 10;
|
|
}
|
|
|
|
test "capture value of switch with all unreachable prongs" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
const x = return_a_number() catch |err| switch (err) {
|
|
else => unreachable,
|
|
};
|
|
try expect(x == 1);
|
|
}
|
|
|
|
fn return_a_number() anyerror!i32 {
|
|
return 1;
|
|
}
|
|
|
|
test "switch on integer with else capturing expr" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
var x: i32 = 5;
|
|
_ = &x;
|
|
switch (x + 10) {
|
|
14 => return error.TestFailed,
|
|
16 => return error.TestFailed,
|
|
else => |e| try expect(e == 15),
|
|
}
|
|
}
|
|
};
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
}
|
|
|
|
test "else prong of switch on error set excludes other cases" {
|
|
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
|
|
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
|
|
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
try expectError(error.C, bar());
|
|
}
|
|
const E = error{
|
|
A,
|
|
B,
|
|
} || E2;
|
|
|
|
const E2 = error{
|
|
C,
|
|
D,
|
|
};
|
|
|
|
fn foo() E!void {
|
|
return error.C;
|
|
}
|
|
|
|
fn bar() E2!void {
|
|
foo() catch |err| switch (err) {
|
|
error.A, error.B => {},
|
|
else => |e| return e,
|
|
};
|
|
}
|
|
};
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
}
|
|
|
|
test "switch prongs with error set cases make a new error set type for capture value" {
|
|
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
|
|
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
|
|
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
try expectError(error.B, bar());
|
|
}
|
|
const E = E1 || E2;
|
|
|
|
const E1 = error{
|
|
A,
|
|
B,
|
|
};
|
|
|
|
const E2 = error{
|
|
C,
|
|
D,
|
|
};
|
|
|
|
fn foo() E!void {
|
|
return error.B;
|
|
}
|
|
|
|
fn bar() E1!void {
|
|
foo() catch |err| switch (err) {
|
|
error.A, error.B => |e| return e,
|
|
else => {},
|
|
};
|
|
}
|
|
};
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
}
|
|
|
|
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_spirv) return error.SkipZigTest; // TODO
|
|
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
try expect((func(0xb) catch unreachable) == 0xb);
|
|
}
|
|
fn func(d: u8) anyerror!u8 {
|
|
return switch (d) {
|
|
0xa...0xf => d,
|
|
else => unreachable,
|
|
};
|
|
}
|
|
};
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
}
|
|
|
|
test "switch with null and T peer types and inferred result location type" {
|
|
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
const S = struct {
|
|
fn doTheTest(c: u8) !void {
|
|
if (switch (c) {
|
|
0 => true,
|
|
else => null,
|
|
}) |v| {
|
|
_ = v;
|
|
return error.TestFailed;
|
|
}
|
|
}
|
|
};
|
|
try S.doTheTest(1);
|
|
try comptime S.doTheTest(1);
|
|
}
|
|
|
|
test "switch prongs with cases with identical payload types" {
|
|
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
const Union = union(enum) {
|
|
A: usize,
|
|
B: isize,
|
|
C: usize,
|
|
};
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
try doTheSwitch1(Union{ .A = 8 });
|
|
try doTheSwitch2(Union{ .B = -8 });
|
|
}
|
|
fn doTheSwitch1(u: Union) !void {
|
|
switch (u) {
|
|
.A, .C => |e| {
|
|
comptime assert(@TypeOf(e) == usize);
|
|
try expect(e == 8);
|
|
},
|
|
.B => |e| {
|
|
_ = e;
|
|
return error.TestFailed;
|
|
},
|
|
}
|
|
}
|
|
fn doTheSwitch2(u: Union) !void {
|
|
switch (u) {
|
|
.A, .C => |e| {
|
|
_ = e;
|
|
return error.TestFailed;
|
|
},
|
|
.B => |e| {
|
|
comptime assert(@TypeOf(e) == isize);
|
|
try expect(e == -8);
|
|
},
|
|
}
|
|
}
|
|
};
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
}
|
|
|
|
test "switch prong pointer capture alignment" {
|
|
const U = union(enum) {
|
|
a: u8 align(8),
|
|
b: u8 align(4),
|
|
c: u8,
|
|
};
|
|
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
const u = U{ .a = 1 };
|
|
switch (u) {
|
|
.a => |*a| comptime assert(@TypeOf(a) == *align(8) const u8),
|
|
.b, .c => |*p| {
|
|
_ = p;
|
|
return error.TestFailed;
|
|
},
|
|
}
|
|
|
|
switch (u) {
|
|
.a, .b => |*p| comptime assert(@TypeOf(p) == *align(4) const u8),
|
|
.c => |*p| {
|
|
_ = p;
|
|
return error.TestFailed;
|
|
},
|
|
}
|
|
|
|
switch (u) {
|
|
.a, .c => |*p| comptime assert(@TypeOf(p) == *const u8),
|
|
.b => |*p| {
|
|
_ = p;
|
|
return error.TestFailed;
|
|
},
|
|
}
|
|
}
|
|
|
|
fn doTheTest2() !void {
|
|
const un1 = U{ .b = 1 };
|
|
switch (un1) {
|
|
.b => |*b| comptime assert(@TypeOf(b) == *align(4) const u8),
|
|
.a, .c => |*p| {
|
|
_ = p;
|
|
return error.TestFailed;
|
|
},
|
|
}
|
|
|
|
const un2 = U{ .c = 1 };
|
|
switch (un2) {
|
|
.c => |*c| comptime assert(@TypeOf(c) == *const u8),
|
|
.a, .b => |*p| {
|
|
_ = p;
|
|
return error.TestFailed;
|
|
},
|
|
}
|
|
}
|
|
};
|
|
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
|
|
try S.doTheTest2();
|
|
try comptime S.doTheTest2();
|
|
}
|
|
|
|
test "switch on pointer type" {
|
|
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
|
|
|
|
const S = struct {
|
|
const X = struct {
|
|
field: u32,
|
|
};
|
|
|
|
const P1 = @as(*X, @ptrFromInt(0x400));
|
|
const P2 = @as(*X, @ptrFromInt(0x800));
|
|
const P3 = @as(*X, @ptrFromInt(0xC00));
|
|
|
|
fn doTheTest(arg: *X) i32 {
|
|
switch (arg) {
|
|
P1 => return 1,
|
|
P2 => return 2,
|
|
else => return 3,
|
|
}
|
|
}
|
|
};
|
|
|
|
try expect(1 == S.doTheTest(S.P1));
|
|
try expect(2 == S.doTheTest(S.P2));
|
|
try expect(3 == S.doTheTest(S.P3));
|
|
comptime assert(1 == S.doTheTest(S.P1));
|
|
comptime assert(2 == S.doTheTest(S.P2));
|
|
comptime assert(3 == S.doTheTest(S.P3));
|
|
}
|
|
|
|
test "switch on error set with single else" {
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
var some: error{Foo} = error.Foo;
|
|
_ = &some;
|
|
try expect(switch (some) {
|
|
else => blk: {
|
|
break :blk true;
|
|
},
|
|
});
|
|
}
|
|
};
|
|
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
}
|
|
|
|
test "switch capture copies its payload" {
|
|
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
|
|
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
var tmp: union(enum) {
|
|
A: u8,
|
|
B: u32,
|
|
} = .{ .A = 42 };
|
|
switch (tmp) {
|
|
.A => |value| {
|
|
// Modify the original union
|
|
tmp = .{ .B = 0x10101010 };
|
|
try expectEqual(@as(u8, 42), value);
|
|
},
|
|
else => unreachable,
|
|
}
|
|
}
|
|
};
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
}
|
|
|
|
test "capture of integer forwards the switch condition directly" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
|
|
|
|
const S = struct {
|
|
fn foo(x: u8) !void {
|
|
switch (x) {
|
|
40...45 => |capture| {
|
|
try expect(capture == 42);
|
|
},
|
|
else => |capture| {
|
|
try expect(capture == 100);
|
|
},
|
|
}
|
|
}
|
|
};
|
|
try S.foo(42);
|
|
try S.foo(100);
|
|
try comptime S.foo(42);
|
|
try comptime S.foo(100);
|
|
}
|
|
|
|
test "enum value without tag name used as switch item" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
|
|
const E = enum(u32) {
|
|
a = 1,
|
|
b = 2,
|
|
_,
|
|
};
|
|
var e: E = @enumFromInt(0);
|
|
_ = &e;
|
|
switch (e) {
|
|
@as(E, @enumFromInt(0)) => {},
|
|
.a => return error.TestFailed,
|
|
.b => return error.TestFailed,
|
|
_ => return error.TestFailed,
|
|
}
|
|
}
|
|
|
|
test "switch item sizeof" {
|
|
const S = struct {
|
|
fn doTheTest() !void {
|
|
var a: usize = 0;
|
|
_ = &a;
|
|
switch (a) {
|
|
@sizeOf(struct {}) => {},
|
|
else => return error.TestFailed,
|
|
}
|
|
}
|
|
};
|
|
try S.doTheTest();
|
|
try comptime S.doTheTest();
|
|
}
|
|
|
|
test "comptime inline switch" {
|
|
const U = union(enum) { a: type, b: type };
|
|
const value = comptime blk: {
|
|
var u: U = .{ .a = u32 };
|
|
_ = &u;
|
|
break :blk switch (u) {
|
|
inline .a, .b => |v| v,
|
|
};
|
|
};
|
|
|
|
try expectEqual(u32, value);
|
|
}
|
|
|
|
test "switch capture peer type resolution" {
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
|
|
|
|
const U = union(enum) {
|
|
a: u32,
|
|
b: u64,
|
|
fn innerVal(u: @This()) u64 {
|
|
switch (u) {
|
|
.a, .b => |x| return x,
|
|
}
|
|
}
|
|
};
|
|
|
|
try expectEqual(@as(u64, 100), U.innerVal(.{ .a = 100 }));
|
|
try expectEqual(@as(u64, 200), U.innerVal(.{ .b = 200 }));
|
|
}
|
|
|
|
test "switch capture peer type resolution for in-memory coercible payloads" {
|
|
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
|
|
|
const T1 = c_int;
|
|
const T2 = @Type(@typeInfo(T1));
|
|
|
|
comptime assert(T1 != T2);
|
|
|
|
const U = union(enum) {
|
|
a: T1,
|
|
b: T2,
|
|
fn innerVal(u: @This()) c_int {
|
|
switch (u) {
|
|
.a, .b => |x| return x,
|
|
}
|
|
}
|
|
};
|
|
|
|
try expectEqual(@as(c_int, 100), U.innerVal(.{ .a = 100 }));
|
|
try expectEqual(@as(c_int, 200), U.innerVal(.{ .b = 200 }));
|
|
}
|
|
|
|
test "switch pointer capture peer type resolution" {
|
|
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
|
|
|
const T1 = c_int;
|
|
const T2 = @Type(@typeInfo(T1));
|
|
|
|
comptime assert(T1 != T2);
|
|
|
|
const U = union(enum) {
|
|
a: T1,
|
|
b: T2,
|
|
fn innerVal(u: *@This()) *c_int {
|
|
switch (u.*) {
|
|
.a, .b => |*ptr| return ptr,
|
|
}
|
|
}
|
|
};
|
|
|
|
var ua: U = .{ .a = 100 };
|
|
var ub: U = .{ .b = 200 };
|
|
|
|
ua.innerVal().* = 111;
|
|
ub.innerVal().* = 222;
|
|
|
|
try expectEqual(U{ .a = 111 }, ua);
|
|
try expectEqual(U{ .b = 222 }, ub);
|
|
}
|
|
|
|
test "inline switch range that includes the maximum value of the switched type" {
|
|
const inputs: [3]u8 = .{ 0, 254, 255 };
|
|
for (inputs) |input| {
|
|
switch (input) {
|
|
inline 254...255 => |val| try expectEqual(input, val),
|
|
else => |val| try expectEqual(input, val),
|
|
}
|
|
}
|
|
}
|
|
|
|
test "nested break ignores switch conditions and breaks instead" {
|
|
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
|
|
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
|
|
|
|
const S = struct {
|
|
fn register_to_address(ident: []const u8) !u8 {
|
|
const reg: u8 = if (std.mem.eql(u8, ident, "zero")) 0x00 else blk: {
|
|
break :blk switch (ident[0]) {
|
|
0x61 => (try std.fmt.parseInt(u8, ident[1..], 0)) + 1,
|
|
0x66 => (try std.fmt.parseInt(u8, ident[1..], 0)) + 1,
|
|
else => {
|
|
break :blk 0xFF;
|
|
},
|
|
};
|
|
};
|
|
return reg;
|
|
}
|
|
};
|
|
// Originally reported at https://github.com/ziglang/zig/issues/10196
|
|
try expect(0x01 == try S.register_to_address("a0"));
|
|
}
|
|
|
|
test "peer type resolution on switch captures ignores unused payload bits" {
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
|
|
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
|
|
|
|
const Foo = union(enum) {
|
|
a: u32,
|
|
b: u64,
|
|
};
|
|
|
|
var val: Foo = undefined;
|
|
@memset(std.mem.asBytes(&val), 0xFF);
|
|
|
|
// This is runtime-known so the following store isn't comptime-known.
|
|
var rt: u32 = 123;
|
|
_ = &rt;
|
|
val = .{ .a = rt }; // will not necessarily zero remaning payload memory
|
|
|
|
// Fields intentionally backwards here
|
|
const x = switch (val) {
|
|
.b, .a => |x| x,
|
|
};
|
|
|
|
try expect(x == 123);
|
|
}
|
|
|
|
test "switch prong captures range" {
|
|
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
|
|
|
|
const S = struct {
|
|
fn a(b: []u3, c: u3) void {
|
|
switch (c) {
|
|
0...1 => b[c] = c,
|
|
2...3 => b[c] = c,
|
|
4...7 => |d| b[d] = c,
|
|
}
|
|
}
|
|
};
|
|
|
|
var arr: [8]u3 = undefined;
|
|
S.a(&arr, 5);
|
|
try expect(arr[5] == 5);
|
|
}
|
|
|
|
test "prong with inline call to unreachable" {
|
|
const U = union(enum) {
|
|
void: void,
|
|
bool: bool,
|
|
|
|
inline fn unreach() noreturn {
|
|
unreachable;
|
|
}
|
|
};
|
|
var u: U = undefined;
|
|
u = .{ .bool = true };
|
|
switch (u) {
|
|
.void => U.unreach(),
|
|
.bool => |ok| try expect(ok),
|
|
}
|
|
}
|
|
|
|
test "block error return trace index is reset between prongs" {
|
|
const S = struct {
|
|
fn returnError() error{TestFailed} {
|
|
return error.TestFailed;
|
|
}
|
|
};
|
|
|
|
var x: u1 = 0;
|
|
_ = &x;
|
|
|
|
const result = switch (x) {
|
|
0 => {
|
|
const result: anyerror!i32 = blk: {
|
|
break :blk 1;
|
|
};
|
|
_ = &result;
|
|
},
|
|
1 => blk: {
|
|
const err = switch (x) {
|
|
0 => {},
|
|
1 => S.returnError(),
|
|
};
|
|
break :blk err;
|
|
},
|
|
};
|
|
try result;
|
|
}
|
|
|
|
test "labeled switch with break" {
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
|
|
|
|
var six: u32 = undefined;
|
|
six = 6;
|
|
|
|
const val = s: switch (six) {
|
|
0...4 => break :s false,
|
|
5 => break :s false,
|
|
6...7 => break :s true,
|
|
else => break :s false,
|
|
};
|
|
|
|
try expect(val);
|
|
|
|
// Make sure the switch is implicitly comptime!
|
|
const comptime_val = s: switch (@as(u32, 6)) {
|
|
0...4 => break :s false,
|
|
5 => break :s false,
|
|
6...7 => break :s true,
|
|
else => break :s false,
|
|
};
|
|
|
|
comptime assert(comptime_val);
|
|
}
|
|
|
|
test "unlabeled break ignores switch" {
|
|
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_spirv) return error.SkipZigTest; // TODO
|
|
|
|
const result = while (true) {
|
|
_ = s: switch (@as(u32, 1)) {
|
|
1 => continue :s 123,
|
|
else => |x| break x,
|
|
};
|
|
comptime unreachable; // control flow never breaks from the switch
|
|
};
|
|
try expect(result == 123);
|
|
}
|
|
|
|
test "switch on a signed value smaller than the smallest prong value" {
|
|
var v: i32 = undefined;
|
|
v = -1;
|
|
switch (v) {
|
|
inline 0...10 => return error.TestFailed,
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
test "switch on 8-bit mod result" {
|
|
var x: u8 = undefined;
|
|
x = 16;
|
|
switch (x % 4) {
|
|
0 => {},
|
|
1, 2, 3 => return error.TestFailed,
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
test "switch on non-exhaustive enum" {
|
|
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
|
|
|
|
const E = enum(u4) {
|
|
a,
|
|
b,
|
|
c,
|
|
_,
|
|
|
|
fn doTheTest(e: @This()) !void {
|
|
switch (e) {
|
|
.a, .b => {},
|
|
else => return error.TestFailed,
|
|
}
|
|
switch (e) {
|
|
.a, .b => {},
|
|
.c => return error.TestFailed,
|
|
_ => return error.TestFailed,
|
|
}
|
|
switch (e) {
|
|
.a, .b => {},
|
|
.c, _ => return error.TestFailed,
|
|
}
|
|
switch (e) {
|
|
.a => {},
|
|
.b, .c, _ => return error.TestFailed,
|
|
}
|
|
switch (e) {
|
|
.b => return error.TestFailed,
|
|
else => {},
|
|
_ => return error.TestFailed,
|
|
}
|
|
switch (e) {
|
|
else => {},
|
|
_ => return error.TestFailed,
|
|
}
|
|
switch (e) {
|
|
inline else => {},
|
|
_ => return error.TestFailed,
|
|
}
|
|
}
|
|
};
|
|
|
|
try E.doTheTest(.a);
|
|
try comptime E.doTheTest(.a);
|
|
}
|