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

test: update behavior to silence 'var is never mutated' errors

Browse Source
This commit is contained in:
mlugg 2023-11-16 13:21:18 +00:00
parent 21fa187abc
commit 9c16b2370d
No known key found for this signature in database
GPG Key ID: 58978E823BDE3EF9
104 changed files with 1160 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
test/behavior/abs.zig
View File

@ -16,26 +16,32 @@ test "@abs integers" {
fn testAbsIntegers() !void {
{
var x: i32 = -1000;
_ = &x;
try expect(@abs(x) == 1000);
}
{
var x: i32 = 0;
_ = &x;
try expect(@abs(x) == 0);
}
{
var x: i32 = 1000;
_ = &x;
try expect(@abs(x) == 1000);
}
{
var x: i64 = std.math.minInt(i64);
_ = &x;
try expect(@abs(x) == @as(u64, -std.math.minInt(i64)));
}
{
var x: i5 = -1;
_ = &x;
try expect(@abs(x) == 1);
}
{
var x: i5 = -5;
_ = &x;
try expect(@abs(x) == 5);
}
comptime {
@ -56,22 +62,27 @@ test "@abs unsigned integers" {
fn testAbsUnsignedIntegers() !void {
{
var x: u32 = 1000;
_ = &x;
try expect(@abs(x) == 1000);
}
{
var x: u32 = 0;
_ = &x;
try expect(@abs(x) == 0);
}
{
var x: u32 = 1000;
_ = &x;
try expect(@abs(x) == 1000);
}
{
var x: u5 = 1;
_ = &x;
try expect(@abs(x) == 1);
}
{
var x: u5 = 5;
_ = &x;
try expect(@abs(x) == 5);
}
comptime {
@ -102,27 +113,33 @@ test "@abs floats" {
fn testAbsFloats(comptime T: type) !void {
{
var x: T = -2.62;
_ = &x;
try expect(@abs(x) == 2.62);
}
{
var x: T = 2.62;
_ = &x;
try expect(@abs(x) == 2.62);
}
{
var x: T = 0.0;
_ = &x;
try expect(@abs(x) == 0.0);
}
{
var x: T = -std.math.pi;
_ = &x;
try expect(@abs(x) == std.math.pi);
}
{
var x: T = -std.math.inf(T);
_ = &x;
try expect(@abs(x) == std.math.inf(T));
}
{
var x: T = std.math.inf(T);
_ = &x;
try expect(@abs(x) == std.math.inf(T));
}
comptime {
@ -164,31 +181,37 @@ fn testAbsIntVectors(comptime len: comptime_int) !void {
{
var x: I32 = @splat(-10);
var y: U32 = @splat(10);
_ = .{ &x, &y };
try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
}
{
var x: I32 = @splat(10);
var y: U32 = @splat(10);
_ = .{ &x, &y };
try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
}
{
var x: I32 = @splat(0);
var y: U32 = @splat(0);
_ = .{ &x, &y };
try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
}
{
var x: I64 = @splat(-10);
var y: U64 = @splat(10);
_ = .{ &x, &y };
try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
}
{
var x: I64 = @splat(std.math.minInt(i64));
var y: U64 = @splat(-std.math.minInt(i64));
_ = .{ &x, &y };
try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
}
{
var x = std.simd.repeat(len, @Vector(4, i32){ -2, 5, std.math.minInt(i32), -7 });
var y = std.simd.repeat(len, @Vector(4, u32){ 2, 5, -std.math.minInt(i32), 7 });
_ = .{ &x, &y };
try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
}
}
@ -225,26 +248,31 @@ fn testAbsUnsignedIntVectors(comptime len: comptime_int) !void {
{
var x: U32 = @splat(10);
var y: U32 = @splat(10);
_ = .{ &x, &y };
try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
}
{
var x: U32 = @splat(10);
var y: U32 = @splat(10);
_ = .{ &x, &y };
try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
}
{
var x: U32 = @splat(0);
var y: U32 = @splat(0);
_ = .{ &x, &y };
try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
}
{
var x: U64 = @splat(10);
var y: U64 = @splat(10);
_ = .{ &x, &y };
try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
}
{
var x = std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
var y = std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
_ = .{ &x, &y };
try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
}
}
@ -346,26 +374,31 @@ fn testAbsFloatVectors(comptime T: type, comptime len: comptime_int) !void {
{
var x: V = @splat(-7.5);
var y: V = @splat(7.5);
_ = .{ &x, &y };
try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
}
{
var x: V = @splat(7.5);
var y: V = @splat(7.5);
_ = .{ &x, &y };
try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
}
{
var x: V = @splat(0.0);
var y: V = @splat(0.0);
_ = .{ &x, &y };
try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
}
{
var x: V = @splat(-std.math.pi);
var y: V = @splat(std.math.pi);
_ = .{ &x, &y };
try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
}
{
var x: V = @splat(std.math.pi);
var y: V = @splat(std.math.pi);
_ = .{ &x, &y };
try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
}
}

10
test/behavior/align.zig
View File

@ -29,6 +29,7 @@ test "slicing array of length 1 can not assume runtime index is always zero" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var runtime_index: usize = 1;
_ = &runtime_index;
const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];
try expect(@TypeOf(slice) == []u8);
try expect(slice.len == 0);
@ -438,6 +439,7 @@ test "runtime-known array index has best alignment possible" {
// because pointer is align 2 and u32 align % 2 == 0 we can assume align 2
var smaller align(2) = [_]u32{ 1, 2, 3, 4 };
var runtime_zero: usize = 0;
_ = &runtime_zero;
comptime assert(@TypeOf(smaller[runtime_zero..]) == []align(2) u32);
comptime assert(@TypeOf(smaller[runtime_zero..].ptr) == [*]align(2) u32);
try testIndex(smaller[runtime_zero..].ptr, 0, *align(2) u32);
@ -464,6 +466,7 @@ test "alignment of function with c calling convention" {
const a = @alignOf(@TypeOf(nothing));
var runtime_nothing = &nothing;
_ = &runtime_nothing;
const casted1: *align(a) const u8 = @ptrCast(runtime_nothing);
const casted2: *const fn () callconv(.C) void = @ptrCast(casted1);
casted2();
@ -486,6 +489,7 @@ test "read 128-bit field from default aligned struct in stack memory" {
.nevermind = 1,
.badguy = 12,
};
_ = &default_aligned;
try expect(12 == default_aligned.badguy);
}
@ -579,10 +583,10 @@ test "comptime alloc alignment" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime var bytes1 = [_]u8{0};
_ = bytes1;
_ = &bytes1;
comptime var bytes2 align(256) = [_]u8{0};
var bytes2_addr = @intFromPtr(&bytes2);
const bytes2_addr = @intFromPtr(&bytes2);
try expect(bytes2_addr & 0xff == 0);
}
@ -591,6 +595,7 @@ test "@alignCast null" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var ptr: ?*anyopaque = null;
_ = &ptr;
const aligned: ?*anyopaque = @alignCast(ptr);
try expect(aligned == null);
}
@ -637,6 +642,7 @@ test "alignment of zero-bit types is respected" {
var s32: S align(32) = .{};
var zero: usize = 0;
_ = &zero;
try expect(@intFromPtr(&s) % @alignOf(usize) == 0);
try expect(@intFromPtr(&s.arr) % @alignOf(usize) == 0);

1
test/behavior/alignof.zig
View File

@ -31,6 +31,7 @@ test "correct alignment for elements and slices of aligned array" {
var buf: [1024]u8 align(64) = undefined;
var start: usize = 1;
var end: usize = undefined;
_ = .{ &start, &end };
try expect(@alignOf(@TypeOf(buf[start..end])) == @alignOf(*u8));
try expect(@alignOf(@TypeOf(&buf[start..end])) == @alignOf(*u8));
try expect(@alignOf(@TypeOf(&buf[start])) == @alignOf(*u8));

33
test/behavior/array.zig
View File

@ -138,6 +138,7 @@ test "array literal with specified size" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var array = [2]u8{ 1, 2 };
_ = &array;
try expect(array[0] == 1);
try expect(array[1] == 2);
}
@ -146,7 +147,7 @@ test "array len field" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var arr = [4]u8{ 0, 0, 0, 0 };
var ptr = &arr;
const ptr = &arr;
try expect(arr.len == 4);
try comptime expect(arr.len == 4);
try expect(ptr.len == 4);
@ -163,7 +164,8 @@ test "array with sentinels" {
{
var zero_sized: [0:0xde]u8 = [_:0xde]u8{};
try expect(zero_sized[0] == 0xde);
var reinterpreted = @as(*[1]u8, @ptrCast(&zero_sized));
var reinterpreted: *[1]u8 = @ptrCast(&zero_sized);
_ = &reinterpreted;
try expect(reinterpreted[0] == 0xde);
}
var arr: [3:0x55]u8 = undefined;
@ -225,6 +227,7 @@ test "implicit comptime in array type size" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var arr: [plusOne(10)]bool = undefined;
_ = &arr;
try expect(arr.len == 11);
}
@ -281,6 +284,7 @@ test "anonymous list literal syntax" {
const S = struct {
fn doTheTest() !void {
var array: [4]u8 = .{ 1, 2, 3, 4 };
_ = &array;
try expect(array[0] == 1);
try expect(array[1] == 2);
try expect(array[2] == 3);
@ -365,6 +369,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var two: i32 = 2;
_ = &two;
const x: []const i32 = &[_]i32{two};
try expect(x[0] == 2);
}
@ -472,6 +477,7 @@ test "anonymous literal in array" {
.{ .a = 3 },
.{ .b = 3 },
};
_ = &array;
try expect(array[0].a == 3);
try expect(array[0].b == 4);
try expect(array[1].a == 2);
@ -489,8 +495,10 @@ test "access the null element of a null terminated array" {
const S = struct {
fn doTheTest() !void {
var array: [4:0]u8 = .{ 'a', 'o', 'e', 'u' };
_ = &array;
try expect(array[4] == 0);
var len: usize = 4;
_ = &len;
try expect(array[len] == 0);
}
};
@ -510,6 +518,7 @@ test "type deduction for array subscript expression" {
try expect(@as(u8, 0xAA) == array[if (v0) 1 else 0]);
var v1 = false;
try expect(@as(u8, 0x55) == array[if (v1) 1 else 0]);
_ = .{ &array, &v0, &v1 };
}
};
try S.doTheTest();
@ -529,7 +538,7 @@ test "sentinel element count towards the ABI size calculation" {
fill_post: u8 = 0xAA,
};
var x = T{};
var as_slice = mem.asBytes(&x);
const as_slice = mem.asBytes(&x);
try expect(@as(usize, 3) == as_slice.len);
try expect(@as(u8, 0x55) == as_slice[0]);
try expect(@as(u8, 0xAA) == as_slice[2]);
@ -559,6 +568,7 @@ test "zero-sized array with recursive type definition" {
};
var t: S = .{ .list = .{ .s = undefined } };
_ = &t;
try expect(@as(usize, 0) == t.list.x);
}
@ -576,15 +586,17 @@ test "type coercion of anon struct literal to array" {
fn doTheTest() !void {
var x1: u8 = 42;
_ = &x1;
const t1 = .{ x1, 56, 54 };
var arr1: [3]u8 = t1;
const arr1: [3]u8 = t1;
try expect(arr1[0] == 42);
try expect(arr1[1] == 56);
try expect(arr1[2] == 54);
var x2: U = .{ .a = 42 };
_ = &x2;
const t2 = .{ x2, .{ .b = true }, .{ .c = "hello" } };
var arr2: [3]U = t2;
const arr2: [3]U = t2;
try expect(arr2[0].a == 42);
try expect(arr2[1].b == true);
try expect(mem.eql(u8, arr2[2].c, "hello"));
@ -608,15 +620,17 @@ test "type coercion of pointer to anon struct literal to pointer to array" {
fn doTheTest() !void {
var x1: u8 = 42;
_ = &x1;
const t1 = &.{ x1, 56, 54 };
var arr1: *const [3]u8 = t1;
const arr1: *const [3]u8 = t1;
try expect(arr1[0] == 42);
try expect(arr1[1] == 56);
try expect(arr1[2] == 54);
var x2: U = .{ .a = 42 };
_ = &x2;
const t2 = &.{ x2, .{ .b = true }, .{ .c = "hello" } };
var arr2: *const [3]U = t2;
const arr2: *const [3]U = t2;
try expect(arr2[0].a == 42);
try expect(arr2[1].b == true);
try expect(mem.eql(u8, arr2[2].c, "hello"));
@ -656,6 +670,7 @@ test "array init of container level array variable" {
}
noinline fn bar(x: usize, y: usize) void {
var tmp: [2]usize = .{ x, y };
_ = &tmp;
pair = tmp;
}
};
@ -668,6 +683,7 @@ test "array init of container level array variable" {
test "runtime initialized sentinel-terminated array literal" {
var c: u16 = 300;
_ = &c;
const f = &[_:0x9999]u16{c};
const g = @as(*const [4]u8, @ptrCast(f));
try std.testing.expect(g[2] == 0x99);
@ -681,6 +697,7 @@ test "array of array agregate init" {
var a = [1]u32{11} ** 10;
var b = [1][10]u32{a} ** 2;
_ = .{ &a, &b };
try std.testing.expect(b[1][1] == 11);
}
@ -778,6 +795,7 @@ test "runtime side-effects in comptime-known array init" {
test "slice initialized through reference to anonymous array init provides result types" {
var my_u32: u32 = 123;
var my_u64: u64 = 456;
_ = .{ &my_u32, &my_u64 };
const foo: []const u16 = &.{
@intCast(my_u32),
@intCast(my_u64),
@ -790,6 +808,7 @@ test "slice initialized through reference to anonymous array init provides resul
test "pointer to array initialized through reference to anonymous array init provides result types" {
var my_u32: u32 = 123;
var my_u64: u64 = 456;
_ = .{ &my_u32, &my_u64 };
const foo: *const [4]u16 = &.{
@intCast(my_u32),
@intCast(my_u64),

1
test/behavior/asm.zig
View File

@ -180,6 +180,7 @@ test "asm modifiers (AArch64)" {
if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
var x: u32 = 15;
_ = &x;
const double = asm ("add %[ret:w], %[in:w], %[in:w]"
: [ret] "=r" (-> u32),
: [in] "r" (x),

32
test/behavior/async_fn.zig
View File

@ -137,11 +137,13 @@ test "@frameSize" {
fn doTheTest() !void {
{
var ptr = @as(fn (i32) callconv(.Async) void, @ptrCast(other));
_ = &ptr;
const size = @frameSize(ptr);
try expect(size == @sizeOf(@Frame(other)));
}
{
var ptr = @as(fn () callconv(.Async) void, @ptrCast(first));
_ = &ptr;
const size = @frameSize(ptr);
try expect(size == @sizeOf(@Frame(first)));
}
@ -153,7 +155,7 @@ test "@frameSize" {
fn other(param: i32) void {
_ = param;
var local: i32 = undefined;
_ = local;
_ = &local;
suspend {}
}
};
@ -239,7 +241,7 @@ test "coroutine await" {
await_seq('a');
var p = async await_amain();
_ = p;
_ = &p;
await_seq('f');
resume await_a_promise;
await_seq('i');
@ -279,7 +281,7 @@ test "coroutine await early return" {
early_seq('a');
var p = async early_amain();
_ = p;
_ = &p;
early_seq('f');
try expect(early_final_result == 1234);
try expect(std.mem.eql(u8, &early_points, "abcdef"));
@ -329,6 +331,7 @@ test "async fn pointer in a struct field" {
bar: fn (*i32) callconv(.Async) void,
};
var foo = Foo{ .bar = simpleAsyncFn2 };
_ = &foo;
var bytes: [64]u8 align(16) = undefined;
const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
try comptime expect(@TypeOf(f) == anyframe->void);
@ -367,6 +370,7 @@ test "@asyncCall with return type" {
}
};
var foo = Foo{ .bar = Foo.middle };
_ = &foo;
var bytes: [150]u8 align(16) = undefined;
var aresult: i32 = 0;
_ = @asyncCall(&bytes, &aresult, foo.bar, .{});
@ -385,6 +389,7 @@ test "async fn with inferred error set" {
fn doTheTest() !void {
var frame: [1]@Frame(middle) = undefined;
var fn_ptr = middle;
_ = &fn_ptr;
var result: @typeInfo(@typeInfo(@TypeOf(fn_ptr)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;
_ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, fn_ptr, .{});
resume global_frame;
@ -827,7 +832,7 @@ test "alignment of local variables in async functions" {
const S = struct {
fn doTheTest() !void {
var y: u8 = 123;
_ = y;
_ = &y;
var x: u8 align(128) = 1;
try expect(@intFromPtr(&x) % 128 == 0);
}
@ -843,7 +848,7 @@ test "no reason to resolve frame still works" {
}
fn simpleNothing() void {
var x: i32 = 1234;
_ = x;
_ = &x;
}
test "async call a generic function" {
@ -913,13 +918,14 @@ test "struct parameter to async function is copied to the frame" {
if (x == 0) return;
clobberStack(x - 1);
var y: i32 = x;
_ = y;
_ = &y;
}
fn bar(f: *@Frame(foo)) void {
var pt = Point{ .x = 1, .y = 2 };
_ = &pt;
f.* = async foo(pt);
var result = await f;
const result = await f;
expect(result == 1) catch @panic("test failure");
}
@ -1141,6 +1147,7 @@ test "@asyncCall using the result location inside the frame" {
bar: fn (*i32) callconv(.Async) i32,
};
var foo = Foo{ .bar = S.simple2 };
_ = &foo;
var bytes: [64]u8 align(16) = undefined;
const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
try comptime expect(@TypeOf(f) == anyframe->i32);
@ -1465,7 +1472,7 @@ test "spill target expr in a for loop, with a var decl in the loop body" {
// the for loop spills still happen even though there is a VarDecl in scope
// before the suspend.
var anything = true;
_ = anything;
_ = &anything;
suspend {
global_frame = @frame();
}
@ -1538,6 +1545,7 @@ test "async function passed align(16) arg after align(8) arg" {
fn foo() void {
var a: u128 = 99;
_ = &a;
bar(10, .{a}) catch unreachable;
}
@ -1590,6 +1598,7 @@ test "async function call resolves target fn frame, runtime func" {
const stack_size = 1000;
var stack_frame: [stack_size]u8 align(std.Target.stack_align) = undefined;
var func: fn () callconv(.Async) anyerror!void = bar;
_ = &func;
return await @asyncCall(&stack_frame, {}, func, .{});
}
@ -1614,6 +1623,7 @@ test "properly spill optional payload capture value" {
fn foo() void {
var opt: ?usize = 1234;
_ = &opt;
if (opt) |x| {
bar();
global_int += x;
@ -1863,6 +1873,7 @@ test "@asyncCall with pass-by-value arguments" {
var buffer: [1024]u8 align(@alignOf(@Frame(S.f))) = undefined;
// The function pointer must not be comptime-known.
var t = S.f;
_ = &t;
var frame_ptr = @asyncCall(&buffer, {}, t, .{
F0,
.{ .f0 = 1, .f1 = 2 },
@ -1870,7 +1881,7 @@ test "@asyncCall with pass-by-value arguments" {
[_]u8{ 1, 2, 3, 4, 5 },
F2,
});
_ = frame_ptr;
_ = &frame_ptr;
}
test "@asyncCall with arguments having non-standard alignment" {
@ -1893,6 +1904,7 @@ test "@asyncCall with arguments having non-standard alignment" {
var buffer: [1024]u8 align(@alignOf(@Frame(S.f))) = undefined;
// The function pointer must not be comptime-known.
var t = S.f;
_ = &t;
var frame_ptr = @asyncCall(&buffer, {}, t, .{ F0, undefined, F1 });
_ = frame_ptr;
_ = &frame_ptr;
}

2
test/behavior/await_struct.zig
View File

@ -14,7 +14,7 @@ test "coroutine await struct" {
await_seq('a');
var p = async await_amain();
_ = p;
_ = &p;
await_seq('f');
resume await_a_promise;
await_seq('i');

19
test/behavior/basic.zig
View File

@ -118,6 +118,7 @@ fn thisIsAColdFn() void {
test "unicode escape in character literal" {
var a: u24 = '\u{01f4a9}';
_ = &a;
try expect(a == 128169);
}
@ -362,6 +363,7 @@ test "variable is allowed to be a pointer to an opaque type" {
}
fn hereIsAnOpaqueType(ptr: *OpaqueA) *OpaqueA {
var a = ptr;
_ = &a;
return a;
}
@ -441,6 +443,7 @@ test "double implicit cast in same expression" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x = @as(i32, @as(u16, nine()));
_ = &x;
try expect(x == 9);
}
fn nine() u8 {
@ -570,6 +573,7 @@ test "comptime cast fn to ptr" {
test "equality compare fn ptrs" {
var a = &emptyFn;
_ = &a;
try expect(a == a);
}
@ -611,6 +615,7 @@ test "global constant is loaded with a runtime-known index" {
const S = struct {
fn doTheTest() !void {
var index: usize = 1;
_ = &index;
const ptr = &pieces[index].field;
try expect(ptr.* == 2);
}
@ -785,6 +790,7 @@ test "variable name containing underscores does not shadow int primitive" {
test "if expression type coercion" {
var cond: bool = true;
_ = &cond;
const x: u16 = if (cond) 1 else 0;
try expect(@as(u16, x) == 1);
}
@ -825,6 +831,7 @@ test "discarding the result of various expressions" {
test "labeled block implicitly ends in a break" {
var a = false;
_ = &a;
blk: {
if (a) break :blk;
}
@ -852,6 +859,7 @@ test "catch in block has correct result location" {
test "labeled block with runtime branch forwards its result location type to break statements" {
const E = enum { a, b };
var a = false;
_ = &a;
const e: E = blk: {
if (a) {
break :blk .a;
@ -872,8 +880,7 @@ test "try in labeled block doesn't cast to wrong type" {
};
const s: ?*S = blk: {
var a = try S.foo();
_ = a;
_ = &a;
break :blk null;
};
_ = s;
@ -894,6 +901,7 @@ test "weird array and tuple initializations" {
const E = enum { a, b };
const S = struct { e: E };
var a = false;
_ = &a;
const b = S{ .e = .a };
_ = &[_]S{
@ -1009,6 +1017,7 @@ test "switch inside @as gets correct type" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: u32 = 0;
_ = &a;
var b: [2]u32 = undefined;
b[0] = @as(u32, switch (a) {
1 => 1,
@ -1110,7 +1119,8 @@ test "orelse coercion as function argument" {
}
};
var optional: ?Loc = .{};
var foo = Container.init(optional orelse .{});
_ = &optional;
const foo = Container.init(optional orelse .{});
try expect(foo.a.?.start == -1);
}
@ -1153,6 +1163,7 @@ test "arrays and vectors with big integers" {
test "pointer to struct literal with runtime field is constant" {
const S = struct { data: usize };
var runtime_zero: usize = 0;
_ = &runtime_zero;
const ptr = &S{ .data = runtime_zero };
try expect(@typeInfo(@TypeOf(ptr)).Pointer.is_const);
}
@ -1163,6 +1174,7 @@ test "integer compare" {
var z: T = 0;
var p: T = 123;
var n: T = -123;
_ = .{ &z, &p, &n };
try expect(z == z and z != p and z != n);
try expect(p == p and p != n and n == n);
try expect(z > n and z < p and z >= n and z <= p);
@ -1180,6 +1192,7 @@ test "integer compare" {
fn doTheTestUnsigned(comptime T: type) !void {
var z: T = 0;
var p: T = 123;
_ = .{ &z, &p };
try expect(z == z and z != p);
try expect(p == p);
try expect(z < p and z <= p);

4
test/behavior/bit_shifting.zig
View File

@ -99,9 +99,9 @@ fn testShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, c
// #2225
test "comptime shr of BigInt" {
comptime {
var n0 = 0xdeadbeef0000000000000000;
const n0 = 0xdeadbeef0000000000000000;
try expect(n0 >> 64 == 0xdeadbeef);
var n1 = 17908056155735594659;
const n1 = 17908056155735594659;
try expect(n1 >> 64 == 0);
}
}

26
test/behavior/bitcast.zig
View File

@ -149,8 +149,9 @@ test "bitcast literal [4]u8 param to u32" {
}
test "bitcast generates a temporary value" {
var y = @as(u16, 0x55AA);
const x = @as(u16, @bitCast(@as([2]u8, @bitCast(y))));
var y: u16 = 0x55AA;
_ = &y;
const x: u16 = @bitCast(@as([2]u8, @bitCast(y)));
try expect(y == x);
}
@ -171,7 +172,8 @@ test "@bitCast packed structs at runtime and comptime" {
const S = struct {
fn doTheTest() !void {
var full = Full{ .number = 0x1234 };
var two_halves = @as(Divided, @bitCast(full));
_ = &full;
const two_halves: Divided = @bitCast(full);
try expect(two_halves.half1 == 0x34);
try expect(two_halves.quarter3 == 0x2);
try expect(two_halves.quarter4 == 0x1);
@ -195,7 +197,8 @@ test "@bitCast extern structs at runtime and comptime" {
const S = struct {
fn doTheTest() !void {
var full = Full{ .number = 0x1234 };
var two_halves = @as(TwoHalves, @bitCast(full));
_ = &full;
const two_halves: TwoHalves = @bitCast(full);
switch (native_endian) {
.big => {
try expect(two_halves.half1 == 0x12);
@ -225,8 +228,9 @@ test "bitcast packed struct to integer and back" {
const S = struct {
fn doTheTest() !void {
var move = LevelUpMove{ .move_id = 1, .level = 2 };
var v = @as(u16, @bitCast(move));
var back_to_a_move = @as(LevelUpMove, @bitCast(v));
_ = &move;
const v: u16 = @bitCast(move);
const back_to_a_move: LevelUpMove = @bitCast(v);
try expect(back_to_a_move.move_id == 1);
try expect(back_to_a_move.level == 2);
}
@ -312,7 +316,8 @@ test "@bitCast packed struct of floats" {
const S = struct {
fn doTheTest() !void {
var foo = Foo{};
var v = @as(Foo2, @bitCast(foo));
_ = &foo;
const v: Foo2 = @bitCast(foo);
try expect(v.a == foo.a);
try expect(v.b == foo.b);
try expect(v.c == foo.c);
@ -354,10 +359,12 @@ test "comptime @bitCast packed struct to int and back" {
// S -> Int
var s: S = .{};
_ = &s;
try expectEqual(@as(Int, @bitCast(s)), comptime @as(Int, @bitCast(S{})));
// Int -> S
var i: Int = 0;
_ = &i;
const rt_cast = @as(S, @bitCast(i));
const ct_cast = comptime @as(S, @bitCast(@as(Int, 0)));
inline for (@typeInfo(S).Struct.fields) |field| {
@ -376,6 +383,7 @@ test "comptime bitcast with fields following f80" {
const FloatT = extern struct { f: f80, x: u128 align(16) };
const x: FloatT = .{ .f = 0.5, .x = 123 };
var x_as_uint: u256 = comptime @as(u256, @bitCast(x));
_ = &x_as_uint;
try expect(x.f == @as(FloatT, @bitCast(x_as_uint)).f);
try expect(x.x == @as(FloatT, @bitCast(x_as_uint)).x);
@ -428,6 +436,7 @@ test "bitcast nan float does not modify signaling bit" {
try expectEqual(snan_u16, bitCastWrapper16(snan_f16_const));
var snan_f16_var = math.snan(f16);
_ = &snan_f16_var;
try expectEqual(snan_u16, @as(u16, @bitCast(snan_f16_var)));
try expectEqual(snan_u16, bitCastWrapper16(snan_f16_var));
@ -437,6 +446,7 @@ test "bitcast nan float does not modify signaling bit" {
try expectEqual(snan_u32, bitCastWrapper32(snan_f32_const));
var snan_f32_var = math.snan(f32);
_ = &snan_f32_var;
try expectEqual(snan_u32, @as(u32, @bitCast(snan_f32_var)));
try expectEqual(snan_u32, bitCastWrapper32(snan_f32_var));
@ -446,6 +456,7 @@ test "bitcast nan float does not modify signaling bit" {
try expectEqual(snan_u64, bitCastWrapper64(snan_f64_const));
var snan_f64_var = math.snan(f64);
_ = &snan_f64_var;
try expectEqual(snan_u64, @as(u64, @bitCast(snan_f64_var)));
try expectEqual(snan_u64, bitCastWrapper64(snan_f64_var));
@ -455,6 +466,7 @@ test "bitcast nan float does not modify signaling bit" {
try expectEqual(snan_u128, bitCastWrapper128(snan_f128_const));
var snan_f128_var = math.snan(f128);
_ = &snan_f128_var;
try expectEqual(snan_u128, @as(u128, @bitCast(snan_f128_var)));
try expectEqual(snan_u128, bitCastWrapper128(snan_f128_var));
}

30
test/behavior/bitreverse.zig
View File

@ -86,11 +86,30 @@ fn testBitReverse() !void {
try expect(@bitReverse(@as(i24, -6773785)) == @bitReverse(neg24));
var neg32: i32 = -16773785;
try expect(@bitReverse(@as(i32, -16773785)) == @bitReverse(neg32));
_ = .{
&num0,
&num5,
&num8,
&num16,
&num24,
&num32,
&num40,
&num48,
&num56,
&num64,
&num128,
&neg8,
&neg16,
&neg24,
&neg32,
};
}
fn vector8() !void {
var v = @Vector(2, u8){ 0x12, 0x23 };
var result = @bitReverse(v);
_ = &v;
const result = @bitReverse(v);
try expect(result[0] == 0x48);
try expect(result[1] == 0xc4);
}
@ -109,7 +128,8 @@ test "bitReverse vectors u8" {
fn vector16() !void {
var v = @Vector(2, u16){ 0x1234, 0x2345 };
var result = @bitReverse(v);
_ = &v;
const result = @bitReverse(v);
try expect(result[0] == 0x2c48);
try expect(result[1] == 0xa2c4);
}
@ -128,7 +148,8 @@ test "bitReverse vectors u16" {
fn vector24() !void {
var v = @Vector(2, u24){ 0x123456, 0x234567 };
var result = @bitReverse(v);
_ = &v;
const result = @bitReverse(v);
try expect(result[0] == 0x6a2c48);
try expect(result[1] == 0xe6a2c4);
}
@ -147,7 +168,8 @@ test "bitReverse vectors u24" {
fn vector0() !void {
var v = @Vector(2, u0){ 0, 0 };
var result = @bitReverse(v);
_ = &v;
const result = @bitReverse(v);
try expect(result[0] == 0);
try expect(result[1] == 0);
}

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

@ -10,9 +10,11 @@ test "test calling @clz on both vector and scalar inputs" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u32 = 0x1;
_ = &x;
var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };
var a = @clz(x);
var b = @clz(y);
_ = &y;
const a = @clz(x);
const b = @clz(y);
try std.testing.expectEqual(@as(u6, 31), a);
try std.testing.expectEqual([_]u6{ 31, 31, 31, 31 }, b);
}

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

@ -9,6 +9,7 @@ test "breaking from a loop in an if statement" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var cond = true;
_ = &cond;
const opt = while (cond) {
if (retOpt()) |opt| {
break opt;

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

@ -2,6 +2,7 @@ const builtin = @import("builtin");
fn foo() !void {
var a = true;
_ = &a;
if (a) return error.Foo;
return error.Bar;
}

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

@ -21,5 +21,6 @@ fn storeArrayOfArrayOfStructs() u8 {
S{ .x = 15 },
},
};
_ = &cases;
return cases[0][0].x;
}

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

@ -4,7 +4,7 @@ const builtin = @import("builtin");
test {
const T = @TypeOf(.{ @as(i32, 0), @as(u32, 0) });
var a: T = .{ 0, 0 };
_ = a;
_ = &a;
}
test {
@ -13,7 +13,7 @@ test {
comptime y: u32 = 0,
};
var a: S = .{};
_ = a;
_ = &a;
var b = S{};
_ = b;
_ = &b;
}

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

@ -6,8 +6,9 @@ test "aggregate initializers should allow initializing comptime fields, verifyin
if (true) return error.SkipZigTest; // TODO
var x: u32 = 15;
_ = &x;
const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });
var a: T = .{ -1234, 5678, x + 1 };
const a: T = .{ -1234, 5678, x + 1 };
try expect(a[0] == -1234);
try expect(a[1] == 5678);

4
test/behavior/bugs/11165.zig
View File

@ -18,7 +18,7 @@ test "bytes" {
};
var u_2 = U{ .s = s_1 };
_ = u_2;
_ = &u_2;
}
test "aggregate" {
@ -40,5 +40,5 @@ test "aggregate" {
};
var u_2 = U{ .s = s_1 };
_ = u_2;
_ = &u_2;
}

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

@ -21,5 +21,5 @@ test "var inferred array of slices" {
.{ .v = false },
},
};
_ = decls;
_ = &decls;
}

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

@ -11,5 +11,6 @@ test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
var t: T = .{ .next = null };
_ = &t;
try std.testing.expect(t.next == null);
}

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

@ -5,6 +5,7 @@ test {
.foo = &1,
.bar = &2,
};
_ = &st;
inline for (@typeInfo(@TypeOf(st)).Struct.fields) |field| {
_ = field;

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

@ -19,6 +19,7 @@ test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
var baz: u32 = 24;
_ = &baz;
try takeFoo(&.{
.a = .{
.b = baz,

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

@ -4,5 +4,6 @@ const expect = std.testing.expect;
const S = struct { a: usize };
test "lazy abi size used in comparison" {
var rhs: i32 = 100;
_ = &rhs;
try expect(@sizeOf(S) < rhs);
}

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

@ -22,6 +22,7 @@ const CPU = packed struct {
}
fn tick(self: *CPU) !void {
var queued_interrupts = self.ram.get(0xFFFF) & self.ram.get(0xFF0F);
_ = &queued_interrupts;
if (self.interrupts and queued_interrupts != 0) {
self.interrupts = false;
}

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

@ -4,26 +4,31 @@ const builtin = @import("builtin");
test "issue12891" {
const f = 10.0;
var i: usize = 0;
_ = &i;
try std.testing.expect(i < f);
}
test "nan" {
const f = comptime std.math.nan(f64);
var i: usize = 0;
_ = &i;
try std.testing.expect(!(f < i));
}
test "inf" {
const f = comptime std.math.inf(f64);
var i: usize = 0;
_ = &i;
try std.testing.expect(f > i);
}
test "-inf < 0" {
const f = comptime -std.math.inf(f64);
var i: usize = 0;
_ = &i;
try std.testing.expect(f < i);
}
test "inf >= 1" {
const f = comptime std.math.inf(f64);
var i: usize = 1;
_ = &i;
try std.testing.expect(f >= i);
}
test "isNan(nan * 1)" {

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

@ -12,6 +12,7 @@ test {
f(&.{c});
var v: u8 = 42;
_ = &v;
f(&[_:null]?u8{v});
f(&.{v});
}

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

@ -16,5 +16,5 @@ test "simple test" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
var c: CustomDraw = undefined;
_ = c;
_ = &c;
}

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

@ -18,6 +18,7 @@ test "runtime union init, most-aligned field != largest" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u8 = 1;
_ = &x;
try foo(.{ .x = x });
const val: U = @unionInit(U, "x", x);

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

@ -13,5 +13,6 @@ test {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var foo = Bar.Baz.fizz;
_ = &foo;
try expect(foo == .fizz);
}

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

@ -8,7 +8,7 @@ test {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: Crasher = undefined;
var crasher_ptr = &a;
const crasher_ptr = &a;
var crasher_local = crasher_ptr.*;
const crasher_local_ptr = &crasher_local;
crasher_local_ptr.lets_crash = 1;

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

@ -18,9 +18,11 @@ test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
var a: u32 = 16;
_ = &a;
var reason = .{ .c_import = .{ .a = a } };
var block = Block{
.reason = &reason,
};
_ = &block;
try expect(block.reason.?.c_import.a == 16);
}

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

@ -1,4 +1,5 @@
comptime {
var image: [1]u8 = undefined;
_ = &image;
_ = @shlExact(@as(u16, image[0]), 8);
}

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

@ -9,5 +9,6 @@ test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: u8 = 0;
_ = &a;
try std.io.null_writer.print("\n{} {}\n", .{ a, S{} });
}

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

@ -20,6 +20,7 @@ test "union that needs padding bytes inside an array" {
A{ .B = B{ .D = 1 } },
A{ .B = B{ .D = 1 } },
};
_ = &as;
const a = as[0].B;
try std.testing.expect(a.D == 1);

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

@ -12,5 +12,6 @@ test "const error union field alignment" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var union_or_err: anyerror!Union = Union{ .Color = 1234 };
_ = &union_or_err;
try std.testing.expect((union_or_err catch unreachable).Color == 1234);
}

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

@ -8,6 +8,7 @@ const B = *const fn (A) void;
test "allow these dependencies" {
var a: A = undefined;
var b: B = undefined;
_ = .{ &a, &b };
if (false) {
a;
b;

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

@ -45,6 +45,6 @@ test "initialization" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var t = a.init();
const t = a.init();
try std.testing.expect(t.foo.len == 0);
}

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

@ -2,5 +2,5 @@ test {
var a = if (true) {
return;
} else true;
_ = a;
_ = &a;
}

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

@ -3,4 +3,5 @@ test "pointer deref next to assignment" {
var a:i32=2;
var b=&a;
b.*=3;
_=&b;
}

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

@ -12,5 +12,5 @@ test "fixed" {
var ctr = Container{
.params = NoteParams{},
};
_ = ctr;
_ = &ctr;
}

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

@ -11,6 +11,7 @@ test "fixed" {
.max_distance_from_start_index = 456,
},
};
_ = &s;
try std.testing.expect(s.a == 1);
try std.testing.expect(s.b.size == 123);
try std.testing.expect(s.b.max_distance_from_start_index == 456);

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

@ -6,6 +6,7 @@ fn getError() !void {
fn getError2() !void {
var a: u8 = 'c';
_ = &a;
try if (a == 'a') getError() else if (a == 'b') getError() else getError();
}

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

@ -25,5 +25,6 @@ test "foo" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var allocator = ContextAllocator{ .n = 10 };
_ = &allocator;
try expect(allocator.n == 10);
}

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

@ -22,6 +22,7 @@ fn foo(a: bool, b: bool) !void {
var prefix_op = PrefixOp{
.AddrOf = Value{ .align_expr = 1234 },
};
_ = &prefix_op;
if (a) {} else {
switch (prefix_op) {
PrefixOp.AddrOf => |addr_of_info| {

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

@ -51,7 +51,8 @@ pub const JournalHeader = packed struct {
return @as(u128, @bitCast(target[0..hash_chain_root_size].*));
} else {
var array = target[0..hash_chain_root_size].*;
return @as(u128, @bitCast(array));
_ = &array;
return @bitCast(array);
}
}

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

@ -14,5 +14,6 @@ const Element = struct {
test "false dependency loop in struct definition" {
const listType = ElementList;
var x: listType = 42;
_ = &x;
try expect(x == 42);
}

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

@ -6,13 +6,15 @@ test "sentinel-terminated 0-length slices" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
var u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
const u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
var index: u8 = 2;
var slice = u32s[index..index :2];
var array_ptr = u32s[2..2 :2];
_ = &index;
const slice = u32s[index..index :2];
const array_ptr = u32s[2..2 :2];
const comptime_known_array_value = u32s[2..2 :2].*;
var runtime_array_value = u32s[2..2 :2].*;
_ = &runtime_array_value;
try expect(slice[0] == 2);
try expect(array_ptr[0] == 2);

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

@ -5,7 +5,7 @@ const expect = std.testing.expect;
test "miscompilation with bool return type" {
var x: usize = 1;
var y: bool = getFalse();
_ = y;
_ = .{ &x, &y };
try expect(x == 1);
}

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

@ -7,7 +7,8 @@ test "@ptrCast from const to nullable" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
const c: u8 = 4;
var x: ?*const u8 = @as(?*const u8, @ptrCast(&c));
var x: ?*const u8 = @ptrCast(&c);
_ = &x;
try expect(x.?.* == 4);
}
@ -19,6 +20,7 @@ test "@ptrCast from var in empty struct to nullable" {
const container = struct {
var c: u8 = 4;
};
var x: ?*const u8 = @as(?*const u8, @ptrCast(&container.c));
var x: ?*const u8 = @ptrCast(&container.c);
_ = &x;
try expect(x.?.* == 4);
}

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

@ -85,6 +85,7 @@ test {
var param: ParamType = .{
.one_of = .{ .name = "name" },
};
_ = &param;
var arg: CallArg = .{
.value = .{
.literal_enum_value = .{
@ -92,6 +93,7 @@ test {
},
},
};
_ = &arg;
const result = try genExpression(arg.value);
switch (result) {

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

@ -60,6 +60,7 @@ test {
.g = false,
.h = false,
};
_ = &flags;
var x = X{
.x = flags,
};

12
test/behavior/byteswap.zig
View File

@ -56,7 +56,8 @@ test "@byteSwap integers" {
fn vector8() !void {
var v = @Vector(2, u8){ 0x12, 0x13 };
var result = @byteSwap(v);
_ = &v;
const result = @byteSwap(v);
try expect(result[0] == 0x12);
try expect(result[1] == 0x13);
}
@ -75,7 +76,8 @@ test "@byteSwap vectors u8" {
fn vector16() !void {
var v = @Vector(2, u16){ 0x1234, 0x2345 };
var result = @byteSwap(v);
_ = &v;
const result = @byteSwap(v);
try expect(result[0] == 0x3412);
try expect(result[1] == 0x4523);
}
@ -94,7 +96,8 @@ test "@byteSwap vectors u16" {
fn vector24() !void {
var v = @Vector(2, u24){ 0x123456, 0x234567 };
var result = @byteSwap(v);
_ = &v;
const result = @byteSwap(v);
try expect(result[0] == 0x563412);
try expect(result[1] == 0x674523);
}
@ -113,7 +116,8 @@ test "@byteSwap vectors u24" {
fn vector0() !void {
var v = @Vector(2, u0){ 0, 0 };
var result = @byteSwap(v);
_ = &v;
const result = @byteSwap(v);
try expect(result[0] == 0);
try expect(result[1] == 0);
}

5
test/behavior/call.zig
View File

@ -47,6 +47,7 @@ test "basic invocations" {
{
// call of non comptime-known function
var alias_foo = &foo;
_ = &alias_foo;
try expect(@call(.no_async, alias_foo, .{}) == 1234);
try expect(@call(.never_tail, alias_foo, .{}) == 1234);
try expect(@call(.never_inline, alias_foo, .{}) == 1234);
@ -66,6 +67,7 @@ test "tuple parameters" {
}.add;
var a: i32 = 12;
var b: i32 = 34;
_ = .{ &a, &b };
try expect(@call(.auto, add, .{ a, 34 }) == 46);
try expect(@call(.auto, add, .{ 12, b }) == 46);
try expect(@call(.auto, add, .{ a, b }) == 46);
@ -101,6 +103,7 @@ test "result location of function call argument through runtime condition and st
}
};
var runtime = true;
_ = &runtime;
try namespace.foo(.{
.e = if (!runtime) .a else .b,
});
@ -445,6 +448,7 @@ test "non-anytype generic parameters provide result type" {
var rt_u16: u16 = 123;
var rt_u32: u32 = 0x10000222;
_ = .{ &rt_u16, &rt_u32 };
try S.f(u8, @intCast(rt_u16));
try S.f(u8, @intCast(123));
@ -470,6 +474,7 @@ test "argument to generic function has correct result type" {
fn doTheTest() !void {
var t = true;
_ = &t;
// Since the enum literal passes through a runtime conditional here, these can only
// compile if RLS provides the correct result type to the argument

160
test/behavior/cast.zig
View File

@ -58,6 +58,7 @@ test "@intCast to comptime_int" {
test "implicit cast comptime numbers to any type when the value fits" {
const a: u64 = 255;
var b: u8 = a;
_ = &b;
try expect(b == 255);
}
@ -273,7 +274,7 @@ test "implicit cast from *[N]T to [*c]T" {
test "*usize to *void" {
var i = @as(usize, 0);
var v = @as(*void, @ptrCast(&i));
const v: *void = @ptrCast(&i);
v.* = {};
}
@ -391,7 +392,8 @@ test "peer type unsigned int to signed" {
var w: u31 = 5;
var x: u8 = 7;
var y: i32 = -5;
var a = w + y + x;
_ = .{ &w, &x, &y };
const a = w + y + x;
try comptime expect(@TypeOf(a) == i32);
try expect(a == 7);
}
@ -401,8 +403,9 @@ test "expected [*c]const u8, found [*:0]const u8" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: [*:0]const u8 = "hello";
var b: [*c]const u8 = a;
var c: [*:0]const u8 = b;
_ = &a;
const b: [*c]const u8 = a;
const c: [*:0]const u8 = b;
try expect(std.mem.eql(u8, c[0..5], "hello"));
}
@ -609,14 +612,16 @@ test "@intCast on vector" {
fn doTheTest() !void {
// Upcast (implicit, equivalent to @intCast)
var up0: @Vector(2, u8) = [_]u8{ 0x55, 0xaa };
var up1 = @as(@Vector(2, u16), up0);
var up2 = @as(@Vector(2, u32), up0);
var up3 = @as(@Vector(2, u64), up0);
_ = &up0;
const up1 = @as(@Vector(2, u16), up0);
const up2 = @as(@Vector(2, u32), up0);
const up3 = @as(@Vector(2, u64), up0);
// Downcast (safety-checked)
var down0 = up3;
var down1 = @as(@Vector(2, u32), @intCast(down0));
var down2 = @as(@Vector(2, u16), @intCast(down0));
var down3 = @as(@Vector(2, u8), @intCast(down0));
_ = &down0;
const down1 = @as(@Vector(2, u32), @intCast(down0));
const down2 = @as(@Vector(2, u16), @intCast(down0));
const down3 = @as(@Vector(2, u8), @intCast(down0));
try expect(mem.eql(u16, &@as([2]u16, up1), &[2]u16{ 0x55, 0xaa }));
try expect(mem.eql(u32, &@as([2]u32, up2), &[2]u32{ 0x55, 0xaa }));
@ -629,7 +634,8 @@ test "@intCast on vector" {
fn doTheTestFloat() !void {
var vec: @Vector(2, f32) = @splat(1234.0);
var wider: @Vector(2, f64) = vec;
_ = &vec;
const wider: @Vector(2, f64) = vec;
try expect(wider[0] == 1234.0);
try expect(wider[1] == 1234.0);
}
@ -648,7 +654,8 @@ test "@floatCast cast down" {
{
var double: f64 = 0.001534;
var single = @as(f32, @floatCast(double));
_ = &double;
const single = @as(f32, @floatCast(double));
try expect(single == 0.001534);
}
{
@ -672,6 +679,7 @@ test "peer type resolution: unreachable, error set, unreachable" {
Unexpected,
};
var err = Error.SystemResources;
_ = &err;
const transformed_err = switch (err) {
error.FileDescriptorAlreadyPresentInSet => unreachable,
error.OperationCausesCircularLoop => unreachable,
@ -821,10 +829,11 @@ test "peer cast *[0]T to E![]const T" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var buffer: [5]u8 = "abcde".*;
var buf: anyerror![]const u8 = buffer[0..];
const buf: anyerror![]const u8 = buffer[0..];
var b = false;
var y = if (b) &[0]u8{} else buf;
var z = if (!b) buf else &[0]u8{};
_ = &b;
const y = if (b) &[0]u8{} else buf;
const z = if (!b) buf else &[0]u8{};
try expect(mem.eql(u8, "abcde", y catch unreachable));
try expect(mem.eql(u8, "abcde", z catch unreachable));
}
@ -835,9 +844,10 @@ test "peer cast *[0]T to []const T" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var buffer: [5]u8 = "abcde".*;
var buf: []const u8 = buffer[0..];
const buf: []const u8 = buffer[0..];
var b = false;
var y = if (b) &[0]u8{} else buf;
_ = &b;
const y = if (b) &[0]u8{} else buf;
try expect(mem.eql(u8, "abcde", y));
}
@ -846,6 +856,7 @@ test "peer cast *[N]T to [*]T" {
var array = [4:99]i32{ 1, 2, 3, 4 };
var dest: [*]i32 = undefined;
_ = &dest;
try expect(@TypeOf(&array, dest) == [*]i32);
try expect(@TypeOf(dest, &array) == [*]i32);
}
@ -879,8 +890,8 @@ test "peer cast [:x]T to []T" {
const S = struct {
fn doTheTest() !void {
var array = [4:0]i32{ 1, 2, 3, 4 };
var slice: [:0]i32 = &array;
var dest: []i32 = slice;
const slice: [:0]i32 = &array;
const dest: []i32 = slice;
try expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));
}
};
@ -895,7 +906,8 @@ test "peer cast [N:x]T to [N]T" {
const S = struct {
fn doTheTest() !void {
var array = [4:0]i32{ 1, 2, 3, 4 };
var dest: [4]i32 = array;
_ = &array;
const dest: [4]i32 = array;
try expect(mem.eql(i32, &dest, &[_]i32{ 1, 2, 3, 4 }));
}
};
@ -910,7 +922,7 @@ test "peer cast *[N:x]T to *[N]T" {
const S = struct {
fn doTheTest() !void {
var array = [4:0]i32{ 1, 2, 3, 4 };
var dest: *[4]i32 = &array;
const dest: *[4]i32 = &array;
try expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));
}
};
@ -925,7 +937,7 @@ test "peer cast [*:x]T to [*]T" {
const S = struct {
fn doTheTest() !void {
var array = [4:99]i32{ 1, 2, 3, 4 };
var dest: [*]i32 = &array;
const dest: [*]i32 = &array;
try expect(dest[0] == 1);
try expect(dest[1] == 2);
try expect(dest[2] == 3);
@ -945,8 +957,8 @@ test "peer cast [:x]T to [*:x]T" {
const S = struct {
fn doTheTest() !void {
var array = [4:0]i32{ 1, 2, 3, 4 };
var slice: [:0]i32 = &array;
var dest: [*:0]i32 = slice;
const slice: [:0]i32 = &array;
const dest: [*:0]i32 = slice;
try expect(dest[0] == 1);
try expect(dest[1] == 2);
try expect(dest[2] == 3);
@ -998,6 +1010,7 @@ test "peer type resolution implicit cast to variable type" {
test "variable initialization uses result locations properly with regards to the type" {
var b = true;
_ = &b;
const x: i32 = if (b) 1 else 2;
try expect(x == 1);
}
@ -1025,7 +1038,7 @@ test "peer type resolve string lit with sentinel-terminated mutable slice" {
var array: [4:0]u8 = undefined;
array[4] = 0; // TODO remove this when #4372 is solved
var slice: [:0]u8 = array[0..4 :0];
const slice: [:0]u8 = array[0..4 :0];
try comptime expect(@TypeOf(slice, "hi") == [:0]const u8);
try comptime expect(@TypeOf("hi", slice) == [:0]const u8);
}
@ -1042,6 +1055,7 @@ test "peer type resolve array pointer and unknown pointer" {
var array: [4]u8 = undefined;
var const_ptr: [*]const u8 = undefined;
var ptr: [*]u8 = undefined;
_ = .{ &const_ptr, &ptr };
try comptime expect(@TypeOf(&array, ptr) == [*]u8);
try comptime expect(@TypeOf(ptr, &array) == [*]u8);
@ -1090,6 +1104,7 @@ test "implicit cast from [*]T to ?*anyopaque" {
var a = [_]u8{ 3, 2, 1 };
var runtime_zero: usize = 0;
_ = &runtime_zero;
incrementVoidPtrArray(a[runtime_zero..].ptr, 3);
try expect(std.mem.eql(u8, &a, &[_]u8{ 4, 3, 2 }));
}
@ -1151,11 +1166,11 @@ test "implicit ptr to *anyopaque" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: u32 = 1;
var ptr: *align(@alignOf(u32)) anyopaque = &a;
var b: *u32 = @as(*u32, @ptrCast(ptr));
const ptr: *align(@alignOf(u32)) anyopaque = &a;
const b: *u32 = @as(*u32, @ptrCast(ptr));
try expect(b.* == 1);
var ptr2: ?*align(@alignOf(u32)) anyopaque = &a;
var c: *u32 = @as(*u32, @ptrCast(ptr2.?));
const ptr2: ?*align(@alignOf(u32)) anyopaque = &a;
const c: *u32 = @as(*u32, @ptrCast(ptr2.?));
try expect(c.* == 1);
}
@ -1264,6 +1279,7 @@ test "implicit cast *[0]T to E![]const u8" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x = @as(anyerror![]const u8, &[0]u8{});
_ = &x;
try expect((x catch unreachable).len == 0);
}
@ -1274,6 +1290,7 @@ test "cast from array reference to fn: comptime fn ptr" {
}
test "cast from array reference to fn: runtime fn ptr" {
var f = @as(*align(1) const fn () callconv(.C) void, @ptrCast(&global_array));
_ = &f;
try expect(@intFromPtr(f) == @intFromPtr(&global_array));
}
@ -1285,7 +1302,8 @@ test "*const [N]null u8 to ?[]const u8" {
const S = struct {
fn doTheTest() !void {
var a = "Hello";
var b: ?[]const u8 = a;
_ = &a;
const b: ?[]const u8 = a;
try expect(mem.eql(u8, b.?, "Hello"));
}
};
@ -1318,12 +1336,13 @@ test "assignment to optional pointer result loc" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var foo: struct { ptr: ?*anyopaque } = .{ .ptr = &global_struct };
_ = &foo;
try expect(foo.ptr.? == @as(*anyopaque, @ptrCast(&global_struct)));
}
test "cast between *[N]void and []void" {
var a: [4]void = undefined;
var b: []void = &a;
const b: []void = &a;
try expect(b.len == 4);
}
@ -1351,6 +1370,7 @@ test "cast f16 to wider types" {
const S = struct {
fn doTheTest() !void {
var x: f16 = 1234.0;
_ = &x;
try expect(@as(f32, 1234.0) == x);
try expect(@as(f64, 1234.0) == x);
try expect(@as(f128, 1234.0) == x);
@ -1370,6 +1390,7 @@ test "cast f128 to narrower types" {
const S = struct {
fn doTheTest() !void {
var x: f128 = 1234.0;
_ = &x;
try expect(@as(f16, 1234.0) == @as(f16, @floatCast(x)));
try expect(@as(f32, 1234.0) == @as(f32, @floatCast(x)));
try expect(@as(f64, 1234.0) == @as(f64, @floatCast(x)));
@ -1404,6 +1425,7 @@ test "cast i8 fn call peers to i32 result" {
const S = struct {
fn doTheTest() !void {
var cond = true;
_ = &cond;
const value: i32 = if (cond) smallBoi() else bigBoi();
try expect(value == 123);
}
@ -1424,7 +1446,8 @@ test "cast compatible optional types" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: ?[:0]const u8 = null;
var b: ?[]const u8 = a;
_ = &a;
const b: ?[]const u8 = a;
try expect(b == null);
}
@ -1434,6 +1457,7 @@ test "coerce undefined single-item pointer of array to error union of slice" {
const a = @as([*]u8, undefined)[0..0];
var b: error{a}![]const u8 = a;
_ = &b;
const s = try b;
try expect(s.len == 0);
}
@ -1442,6 +1466,7 @@ test "pointer to empty struct literal to mutable slice" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: []i32 = &.{};
_ = &x;
try expect(x.len == 0);
}
@ -1466,7 +1491,7 @@ test "coerce between pointers of compatible differently-named floats" {
else => @compileError("unreachable"),
};
var f1: F = 12.34;
var f2: *c_longdouble = &f1;
const f2: *c_longdouble = &f1;
f2.* += 1;
try expect(f1 == @as(F, 12.34) + 1);
}
@ -1507,8 +1532,9 @@ test "implicit cast from [:0]T to [*c]T" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
var a: [:0]const u8 = "foo";
var b: [*c]const u8 = a;
var c = std.mem.span(b);
_ = &a;
const b: [*c]const u8 = a;
const c = std.mem.span(b);
try expect(c.len == a.len);
try expect(c.ptr == a.ptr);
}
@ -1544,6 +1570,7 @@ test "single item pointer to pointer to array to slice" {
test "peer type resolution forms error union" {
var foo: i32 = 123;
_ = &foo;
const result = if (foo < 0) switch (-foo) {
0 => unreachable,
42 => error.AccessDenied,
@ -1561,7 +1588,7 @@ test "@constCast without a result location" {
test "@volatileCast without a result location" {
var x: i32 = 1234;
var y: *volatile i32 = &x;
const y: *volatile i32 = &x;
const z = @volatileCast(y);
try expect(@TypeOf(z) == *i32);
try expect(z.* == 1234);
@ -1585,10 +1612,12 @@ test "peer type resolution: const sentinel slice and mutable non-sentinel slice"
fn doTheTest(comptime T: type, comptime s: T) !void {
var a: [:s]const T = @as(*const [2:s]T, @ptrFromInt(0x1000));
var b: []T = @as(*[3]T, @ptrFromInt(0x2000));
_ = .{ &a, &b };
comptime assert(@TypeOf(a, b) == []const T);
comptime assert(@TypeOf(b, a) == []const T);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1611,10 +1640,12 @@ test "peer type resolution: float and comptime-known fixed-width integer" {
const i: u8 = 100;
var f: f32 = 1.234;
_ = &f;
comptime assert(@TypeOf(i, f) == f32);
comptime assert(@TypeOf(f, i) == f32);
var t = true;
_ = &t;
const r1 = if (t) i else f;
const r2 = if (t) f else i;
@ -1631,10 +1662,12 @@ test "peer type resolution: same array type with sentinel" {
var a: [2:0]u32 = .{ 0, 1 };
var b: [2:0]u32 = .{ 2, 3 };
_ = .{ &a, &b };
comptime assert(@TypeOf(a, b) == [2:0]u32);
comptime assert(@TypeOf(b, a) == [2:0]u32);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1651,10 +1684,12 @@ test "peer type resolution: array with sentinel and array without sentinel" {
var a: [2:0]u32 = .{ 0, 1 };
var b: [2]u32 = .{ 2, 3 };
_ = .{ &a, &b };
comptime assert(@TypeOf(a, b) == [2]u32);
comptime assert(@TypeOf(b, a) == [2]u32);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1671,10 +1706,12 @@ test "peer type resolution: array and vector with same child type" {
var arr: [2]u32 = .{ 0, 1 };
var vec: @Vector(2, u32) = .{ 2, 3 };
_ = .{ &arr, &vec };
comptime assert(@TypeOf(arr, vec) == @Vector(2, u32));
comptime assert(@TypeOf(vec, arr) == @Vector(2, u32));
var t = true;
_ = &t;
const r1 = if (t) arr else vec;
const r2 = if (t) vec else arr;
@ -1694,10 +1731,12 @@ test "peer type resolution: array with smaller child type and vector with larger
var arr: [2]u8 = .{ 0, 1 };
var vec: @Vector(2, u64) = .{ 2, 3 };
_ = .{ &arr, &vec };
comptime assert(@TypeOf(arr, vec) == @Vector(2, u64));
comptime assert(@TypeOf(vec, arr) == @Vector(2, u64));
var t = true;
_ = &t;
const r1 = if (t) arr else vec;
const r2 = if (t) vec else arr;
@ -1715,10 +1754,12 @@ test "peer type resolution: error union and optional of same type" {
const E = error{Foo};
var a: E!*u8 = error.Foo;
var b: ?*u8 = null;
_ = .{ &a, &b };
comptime assert(@TypeOf(a, b) == E!?*u8);
comptime assert(@TypeOf(b, a) == E!?*u8);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1734,11 +1775,13 @@ test "peer type resolution: C pointer and @TypeOf(null)" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: [*c]c_int = 0x1000;
_ = &a;
const b = null;
comptime assert(@TypeOf(a, b) == [*c]c_int);
comptime assert(@TypeOf(b, a) == [*c]c_int);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1755,8 +1798,9 @@ test "peer type resolution: three-way resolution combines error set and optional
const E = error{Foo};
var a: E = error.Foo;
var b: *const [5:0]u8 = @as(*const [5:0]u8, @ptrFromInt(0x1000));
var b: *const [5:0]u8 = @ptrFromInt(0x1000);
var c: ?[*:0]u8 = null;
_ = .{ &a, &b, &c };
comptime assert(@TypeOf(a, b, c) == E!?[*:0]const u8);
comptime assert(@TypeOf(a, c, b) == E!?[*:0]const u8);
comptime assert(@TypeOf(b, a, c) == E!?[*:0]const u8);
@ -1765,6 +1809,7 @@ test "peer type resolution: three-way resolution combines error set and optional
comptime assert(@TypeOf(c, b, a) == E!?[*:0]const u8);
var x: u8 = 0;
_ = &x;
const r1 = switch (x) {
0 => a,
1 => b,
@ -1797,10 +1842,12 @@ test "peer type resolution: vector and optional vector" {
var a: ?@Vector(3, u32) = .{ 0, 1, 2 };
var b: @Vector(3, u32) = .{ 3, 4, 5 };
_ = .{ &a, &b };
comptime assert(@TypeOf(a, b) == ?@Vector(3, u32));
comptime assert(@TypeOf(b, a) == ?@Vector(3, u32));
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1816,11 +1863,13 @@ test "peer type resolution: optional fixed-width int and comptime_int" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: ?i32 = 42;
_ = &a;
const b: comptime_int = 50;
comptime assert(@TypeOf(a, b) == ?i32);
comptime assert(@TypeOf(b, a) == ?i32);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1836,12 +1885,14 @@ test "peer type resolution: array and tuple" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var arr: [3]i32 = .{ 1, 2, 3 };
_ = &arr;
const tup = .{ 4, 5, 6 };
comptime assert(@TypeOf(arr, tup) == [3]i32);
comptime assert(@TypeOf(tup, arr) == [3]i32);
var t = true;
_ = &t;
const r1 = if (t) arr else tup;
const r2 = if (t) tup else arr;
@ -1858,12 +1909,14 @@ test "peer type resolution: vector and tuple" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var vec: @Vector(3, i32) = .{ 1, 2, 3 };
_ = &vec;
const tup = .{ 4, 5, 6 };
comptime assert(@TypeOf(vec, tup) == @Vector(3, i32));
comptime assert(@TypeOf(tup, vec) == @Vector(3, i32));
var t = true;
_ = &t;
const r1 = if (t) vec else tup;
const r2 = if (t) tup else vec;
@ -1881,6 +1934,7 @@ test "peer type resolution: vector and array and tuple" {
var vec: @Vector(2, i8) = .{ 10, 20 };
var arr: [2]i8 = .{ 30, 40 };
_ = .{ &vec, &arr };
const tup = .{ 50, 60 };
comptime assert(@TypeOf(vec, arr, tup) == @Vector(2, i8));
@ -1891,6 +1945,7 @@ test "peer type resolution: vector and array and tuple" {
comptime assert(@TypeOf(tup, arr, vec) == @Vector(2, i8));
var x: u8 = 0;
_ = &x;
const r1 = switch (x) {
0 => vec,
1 => arr,
@ -1921,11 +1976,13 @@ test "peer type resolution: empty tuple pointer and slice" {
var a: [:0]const u8 = "Hello";
var b = &.{};
_ = .{ &a, &b };
comptime assert(@TypeOf(a, b) == []const u8);
comptime assert(@TypeOf(b, a) == []const u8);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1940,11 +1997,13 @@ test "peer type resolution: tuple pointer and slice" {
var a: [:0]const u8 = "Hello";
var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
_ = .{ &a, &b };
comptime assert(@TypeOf(a, b) == []const u8);
comptime assert(@TypeOf(b, a) == []const u8);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1959,11 +2018,13 @@ test "peer type resolution: tuple pointer and optional slice" {
var a: ?[:0]const u8 = null;
var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
_ = .{ &a, &b };
comptime assert(@TypeOf(a, b) == ?[]const u8);
comptime assert(@TypeOf(b, a) == ?[]const u8);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -1986,6 +2047,7 @@ test "peer type resolution: many compatible pointers" {
@as([*]u8, &buf),
@as(*const [5]u8, "foo-4"),
};
_ = &vals;
// Check every possible permutation of types in @TypeOf
@setEvalBranchQuota(5000);
@ -2015,6 +2077,7 @@ test "peer type resolution: many compatible pointers" {
comptime assert(perms == 5 * 4 * 3 * 2 * 1);
var x: u8 = 0;
_ = &x;
inline for (0..5) |i| {
const r = switch (x) {
0 => vals[i],
@ -2057,6 +2120,7 @@ test "peer type resolution: tuples with comptime fields" {
}
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -2074,13 +2138,15 @@ test "peer type resolution: C pointer and many pointer" {
var buf = "hello".*;
var a: [*c]u8 = &buf;
const a: [*c]u8 = &buf;
var b: [*:0]const u8 = "world";
_ = &b;
comptime assert(@TypeOf(a, b) == [*c]const u8);
comptime assert(@TypeOf(b, a) == [*c]const u8);
var t = true;
_ = &t;
const r1 = if (t) a else b;
const r2 = if (t) b else a;
@ -2097,9 +2163,9 @@ test "peer type resolution: pointer attributes are combined correctly" {
var buf_b align(4) = "bar".*;
var buf_c align(4) = "baz".*;
var a: [*:0]align(4) const u8 = &buf_a;
var b: *align(2) volatile [3:0]u8 = &buf_b;
var c: [*:0]align(4) u8 = &buf_c;
const a: [*:0]align(4) const u8 = &buf_a;
const b: *align(2) volatile [3:0]u8 = &buf_b;
const c: [*:0]align(4) u8 = &buf_c;
comptime assert(@TypeOf(a, b, c) == [*:0]align(2) const volatile u8);
comptime assert(@TypeOf(a, c, b) == [*:0]align(2) const volatile u8);
@ -2109,6 +2175,7 @@ test "peer type resolution: pointer attributes are combined correctly" {
comptime assert(@TypeOf(c, b, a) == [*:0]align(2) const volatile u8);
var x: u8 = 0;
_ = &x;
const r1 = switch (x) {
0 => a,
1 => b,
@ -2254,6 +2321,7 @@ test "@floatCast on vector" {
const S = struct {
fn doTheTest() !void {
var a: @Vector(3, f64) = .{ 1.5, 2.5, 3.5 };
_ = &a;
const b: @Vector(3, f32) = @floatCast(a);
try expectEqual(@Vector(3, f32){ 1.5, 2.5, 3.5 }, b);
}
@ -2274,6 +2342,7 @@ test "@ptrFromInt on vector" {
const S = struct {
fn doTheTest() !void {
var a: @Vector(3, usize) = .{ 0x1000, 0x2000, 0x3000 };
_ = &a;
const b: @Vector(3, *anyopaque) = @ptrFromInt(a);
try expectEqual(@Vector(3, *anyopaque){
@ptrFromInt(0x1000),
@ -2302,6 +2371,7 @@ test "@intFromPtr on vector" {
@ptrFromInt(0x2000),
@ptrFromInt(0x3000),
};
_ = &a;
const b: @Vector(3, usize) = @intFromPtr(a);
try expectEqual(@Vector(3, usize){ 0x1000, 0x2000, 0x3000 }, b);
}
@ -2322,6 +2392,7 @@ test "@floatFromInt on vector" {
const S = struct {
fn doTheTest() !void {
var a: @Vector(3, u32) = .{ 10, 20, 30 };
_ = &a;
const b: @Vector(3, f32) = @floatFromInt(a);
try expectEqual(@Vector(3, f32){ 10.0, 20.0, 30.0 }, b);
}
@ -2342,6 +2413,7 @@ test "@intFromFloat on vector" {
const S = struct {
fn doTheTest() !void {
var a: @Vector(3, f32) = .{ 10.3, 20.5, 30.7 };
_ = &a;
const b: @Vector(3, u32) = @intFromFloat(a);
try expectEqual(@Vector(3, u32){ 10, 20, 30 }, b);
}
@ -2362,6 +2434,7 @@ test "@intFromBool on vector" {
const S = struct {
fn doTheTest() !void {
var a: @Vector(3, bool) = .{ false, true, false };
_ = &a;
const b: @Vector(3, u1) = @intFromBool(a);
try expectEqual(@Vector(3, u1){ 0, 1, 0 }, b);
}
@ -2385,7 +2458,8 @@ test "15-bit int to float" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
var a: u15 = 42;
var b: f32 = @floatFromInt(a);
_ = &a;
const b: f32 = @floatFromInt(a);
try expect(b == 42.0);
}
@ -2417,6 +2491,7 @@ test "result information is preserved through many nested structures" {
const T = *const ?E!struct { x: ?*const E!?u8 };
var val: T = &.{ .x = &@truncate(0x1234) };
_ = &val;
const struct_val = val.*.? catch unreachable;
const int_val = (struct_val.x.?.* catch unreachable).?;
@ -2439,6 +2514,7 @@ test "@intCast vector of signed integer" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
var x: @Vector(4, i32) = .{ 1, 2, 3, 4 };
_ = &x;
const y: @Vector(4, i8) = @intCast(x);
try expect(y[0] == 1);

19
test/behavior/cast_int.zig
View File

@ -12,7 +12,8 @@ test "@intCast i32 to u7" {
var x: u128 = maxInt(u128);
var y: i32 = 120;
var z = x >> @as(u7, @intCast(y));
_ = .{ &x, &y };
const z = x >> @as(u7, @intCast(y));
try expect(z == 0xff);
}
@ -23,20 +24,24 @@ test "coerce i8 to i32 and @intCast back" {
var x: i8 = -5;
var y: i32 = -5;
_ = .{ &x, &y };
try expect(y == x);
var x2: i32 = -5;
var y2: i8 = -5;
_ = .{ &x2, &y2 };
try expect(y2 == @as(i8, @intCast(x2)));
}
test "coerce non byte-sized integers accross 32bits boundary" {
{
var v: u21 = 6417;
_ = &v;
const a: u32 = v;
const b: u64 = v;
const c: u64 = a;
var w: u64 = 0x1234567812345678;
_ = &w;
const d: u21 = @truncate(w);
const e: u60 = d;
try expectEqual(@as(u32, 6417), a);
@ -48,10 +53,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
{
var v: u10 = 234;
_ = &v;
const a: u32 = v;
const b: u64 = v;
const c: u64 = a;
var w: u64 = 0x1234567812345678;
_ = &w;
const d: u10 = @truncate(w);
const e: u60 = d;
try expectEqual(@as(u32, 234), a);
@ -62,10 +69,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
}
{
var v: u7 = 11;
_ = &v;
const a: u32 = v;
const b: u64 = v;
const c: u64 = a;
var w: u64 = 0x1234567812345678;
_ = &w;
const d: u7 = @truncate(w);
const e: u60 = d;
try expectEqual(@as(u32, 11), a);
@ -77,10 +86,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
{
var v: i21 = -6417;
_ = &v;
const a: i32 = v;
const b: i64 = v;
const c: i64 = a;
var w: i64 = -12345;
_ = &w;
const d: i21 = @intCast(w);
const e: i60 = d;
try expectEqual(@as(i32, -6417), a);
@ -92,10 +103,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
{
var v: i10 = -234;
_ = &v;
const a: i32 = v;
const b: i64 = v;
const c: i64 = a;
var w: i64 = -456;
_ = &w;
const d: i10 = @intCast(w);
const e: i60 = d;
try expectEqual(@as(i32, -234), a);
@ -106,10 +119,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
}
{
var v: i7 = -11;
_ = &v;
const a: i32 = v;
const b: i64 = v;
const c: i64 = a;
var w: i64 = -42;
_ = &w;
const d: i7 = @intCast(w);
const e: i60 = d;
try expectEqual(@as(i32, -11), a);
@ -152,7 +167,7 @@ test "load non byte-sized optional value" {
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');
const opt: ?Piece = try Piece.charToPiece('p');
try expect(opt.?.type == .PAWN);
try expect(opt.?.color == .BLACK);

2
test/behavior/comptime_memory.zig
View File

@ -280,7 +280,7 @@ test "dance on linker values" {
if (ptr_size > @sizeOf(Bits))
try doTypePunBitsTest(&weird_ptr[1]);
var arr_bytes = @as(*[2][ptr_size]u8, @ptrCast(&arr));
const arr_bytes: *[2][ptr_size]u8 = @ptrCast(&arr);
var rebuilt_bytes: [ptr_size]u8 = undefined;
var i: usize = 0;

4
test/behavior/destructure.zig
View File

@ -7,6 +7,7 @@ test "simple destructure" {
fn doTheTest() !void {
var x: u32 = undefined;
x, const y, var z: u64 = .{ 1, @as(u16, 2), 3 };
_ = &z;
comptime assert(@TypeOf(y) == u16);
@ -25,6 +26,7 @@ test "destructure with comptime syntax" {
fn doTheTest() void {
comptime var x: f32 = undefined;
comptime x, const y, var z = .{ 0.5, 123, 456 }; // z is a comptime var
_ = &z;
comptime assert(@TypeOf(y) == comptime_int);
comptime assert(@TypeOf(z) == comptime_int);
@ -112,6 +114,7 @@ test "destructure of comptime-known tuple is comptime-known" {
test "destructure of comptime-known tuple where some destinations are runtime-known is comptime-known" {
var z: u32 = undefined;
var x: u8, const y, z = .{ 1, 2, 3 };
_ = &x;
comptime assert(@TypeOf(y) == comptime_int);
comptime assert(y == 2);
@ -122,6 +125,7 @@ test "destructure of comptime-known tuple where some destinations are runtime-kn
test "destructure of tuple with comptime fields results in some comptime-known values" {
var runtime: u32 = 42;
_ = &runtime;
const a, const b, const c, const d = .{ 123, runtime, 456, runtime };
// a, c are comptime-known

4
test/behavior/empty_union.zig
View File

@ -5,12 +5,14 @@ const expect = std.testing.expect;
test "switch on empty enum" {
const E = enum {};
var e: E = undefined;
_ = &e;
switch (e) {}
}
test "switch on empty enum with a specified tag type" {
const E = enum(u8) {};
var e: E = undefined;
_ = &e;
switch (e) {}
}
@ -19,6 +21,7 @@ test "switch on empty auto numbered tagged union" {
const U = union(enum(u8)) {};
var u: U = undefined;
_ = &u;
switch (u) {}
}
@ -28,6 +31,7 @@ test "switch on empty tagged union" {
const E = enum {};
const U = union(E) {};
var u: U = undefined;
_ = &u;
switch (u) {}
}

15
test/behavior/enum.zig
View File

@ -579,6 +579,7 @@ test "enum literal cast to enum" {
var color1: Color = .Auto;
var color2 = Color.Auto;
_ = .{ &color1, &color2 };
try expect(color1 == color2);
}
@ -663,7 +664,8 @@ test "empty non-exhaustive enum" {
const E = enum(u8) { _ };
fn doTheTest(y: u8) !void {
var e = @as(E, @enumFromInt(y));
var e: E = @enumFromInt(y);
_ = &e;
try expect(switch (e) {
_ => true,
});
@ -858,6 +860,7 @@ test "comparison operator on enum with one member is comptime-known" {
const State = enum { Start };
test "switch on enum with one member is comptime-known" {
var state = State.Start;
_ = &state;
switch (state) {
State.Start => return,
}
@ -917,7 +920,8 @@ test "enum literal casting to tagged union" {
var t = true;
var x: Arch = .x86_64;
var y = if (t) x else .x86_64;
_ = .{ &t, &x };
const y = if (t) x else .x86_64;
switch (y) {
.x86_64 => {},
else => @panic("fail"),
@ -1031,6 +1035,7 @@ test "tag name with assigned enum values" {
B = 0,
};
var b = LocalFoo.B;
_ = &b;
try expect(mem.eql(u8, @tagName(b), "B"));
}
@ -1055,6 +1060,7 @@ test "tag name with signed enum values" {
delta = 65,
};
var b = LocalFoo.bravo;
_ = &b;
try expect(mem.eql(u8, @tagName(b), "bravo"));
}
@ -1135,13 +1141,13 @@ test "tag name functions are unique" {
const E = enum { a, b };
var b = E.a;
var a = @tagName(b);
_ = a;
_ = .{ &a, &b };
}
{
const E = enum { a, b, c, d, e, f };
var b = E.a;
var a = @tagName(b);
_ = a;
_ = .{ &a, &b };
}
}
@ -1189,6 +1195,7 @@ test "Non-exhaustive enum with nonstandard int size behaves correctly" {
test "runtime int to enum with one possible value" {
const E = enum { one };
var runtime: usize = 0;
_ = &runtime;
if (@as(E, @enumFromInt(runtime)) != .one) {
@compileError("test failed");
}

22
test/behavior/error.zig
View File

@ -102,8 +102,7 @@ test "widen cast integer payload of error union function call" {
const S = struct {
fn errorable() !u64 {
var x = @as(u64, try number());
return x;
return @as(u64, try number());
}
fn number() anyerror!u32 {
@ -119,7 +118,7 @@ test "debug info for optional error set" {
const SomeError = error{ Hello, Hello2 };
var a_local_variable: ?SomeError = null;
_ = a_local_variable;
_ = &a_local_variable;
}
test "implicit cast to optional to error union to return result loc" {
@ -160,6 +159,7 @@ fn entry() void {
fn entryPtr() void {
var ptr = &bar2;
_ = &ptr;
fooPtr(ptr);
}
@ -226,9 +226,9 @@ const Set1 = error{ A, B };
const Set2 = error{ A, C };
fn testExplicitErrorSetCast(set1: Set1) !void {
var x = @as(Set2, @errorCast(set1));
const x: Set2 = @errorCast(set1);
try expect(@TypeOf(x) == Set2);
var y = @as(Set1, @errorCast(x));
const y: Set1 = @errorCast(x);
try expect(@TypeOf(y) == Set1);
try expect(y == error.A);
}
@ -408,17 +408,17 @@ test "nested error union function call in optional unwrap" {
};
fn errorable() !i32 {
var x: Foo = (try getFoo()) orelse return error.Other;
const x: Foo = (try getFoo()) orelse return error.Other;
return x.a;
}
fn errorable2() !i32 {
var x: Foo = (try getFoo2()) orelse return error.Other;
const x: Foo = (try getFoo2()) orelse return error.Other;
return x.a;
}
fn errorable3() !i32 {
var x: Foo = (try getFoo3()) orelse return error.Other;
const x: Foo = (try getFoo3()) orelse return error.Other;
return x.a;
}
@ -673,6 +673,7 @@ test "peer type resolution of two different error unions" {
const a: error{B}!void = {};
const b: error{A}!void = {};
var cond = true;
_ = &cond;
const err = if (cond) a else b;
try err;
}
@ -681,6 +682,7 @@ test "coerce error set to the current inferred error set" {
const S = struct {
fn foo() !void {
var a = false;
_ = &a;
if (a) {
const b: error{A}!void = error.A;
return b;
@ -831,6 +833,7 @@ test "alignment of wrapping an error union payload" {
fn foo() anyerror!I {
var i: I = .{ .x = 1234 };
_ = &i;
return i;
}
};
@ -842,6 +845,7 @@ test "compare error union and error set" {
var a: anyerror = error.Foo;
var b: anyerror!u32 = error.Bar;
_ = &a;
try expect(a != b);
try expect(b != a);
@ -863,6 +867,7 @@ fn non_errorable() void {
// This test is needed because stage 2's fix for #1923 means that catch blocks interact
// with the error return trace index.
var x: error{Foo}!void = {};
_ = &x;
return x catch {};
}
@ -902,6 +907,7 @@ test "optional error union return type" {
const S = struct {
fn foo() ?anyerror!u32 {
var x: u32 = 1234;
_ = &x;
return @as(anyerror!u32, x);
}
};

59
test/behavior/eval.zig
View File

@ -37,6 +37,7 @@ fn gimme1or2(comptime a: bool) i32 {
const x: i32 = 1;
const y: i32 = 2;
comptime var z: i32 = if (a) x else y;
_ = &z;
return z;
}
test "inline variable gets result of const if" {
@ -74,6 +75,7 @@ test "constant expressions" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var array: [array_size]u8 = undefined;
_ = &array;
try expect(@sizeOf(@TypeOf(array)) == 20);
}
const array_size: u8 = 20;
@ -129,7 +131,7 @@ test "pointer to type" {
comptime {
var T: type = i32;
try expect(T == i32);
var ptr = &T;
const ptr = &T;
try expect(@TypeOf(ptr) == *type);
ptr.* = f32;
try expect(T == f32);
@ -372,6 +374,7 @@ fn doNothingWithType(comptime T: type) void {
test "zero extend from u0 to u1" {
var zero_u0: u0 = 0;
var zero_u1: u1 = zero_u0;
_ = .{ &zero_u0, &zero_u1 };
try expect(zero_u1 == 0);
}
@ -408,6 +411,7 @@ test "inline for with same type but different values" {
var res: usize = 0;
inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
var a: T = undefined;
_ = &a;
res += a.len;
}
try expect(res == 5);
@ -460,9 +464,9 @@ test "comptime shl" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: u128 = 3;
var b: u7 = 63;
var c: u128 = 3 << 63;
const a: u128 = 3;
const b: u7 = 63;
const c: u128 = 3 << 63;
try expect((a << b) == c);
}
@ -489,6 +493,7 @@ test "comptime shlWithOverflow" {
const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0];
var a = ~@as(u64, 0);
_ = &a;
const rt_shifted = @shlWithOverflow(a, 16)[0];
try expect(ct_shifted == rt_shifted);
@ -521,7 +526,8 @@ test "runtime 128 bit integer division" {
var a: u128 = 152313999999999991610955792383;
var b: u128 = 10000000000000000000;
var c = a / b;
_ = .{ &a, &b };
const c = a / b;
try expect(c == 15231399999);
}
@ -555,6 +561,7 @@ test "inlined loop has array literal with elided runtime scope on first iteratio
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var runtime = [1]i32{3};
_ = &runtime;
comptime var i: usize = 0;
inline while (i < 2) : (i += 1) {
const result = if (i == 0) [1]i32{2} else runtime;
@ -692,7 +699,7 @@ test "call method with comptime pass-by-non-copying-value self parameter" {
};
const s = S{ .a = 2 };
var b = s.b();
const b = s.b();
try expect(b == 2);
}
@ -759,7 +766,8 @@ test "array concatenation peer resolves element types - value" {
var a = [2]u3{ 1, 7 };
var b = [3]u8{ 200, 225, 255 };
var c = a ++ b;
_ = .{ &a, &b };
const c = a ++ b;
comptime assert(@TypeOf(c) == [5]u8);
try expect(c[0] == 1);
try expect(c[1] == 7);
@ -775,7 +783,7 @@ test "array concatenation peer resolves element types - pointer" {
var a = [2]u3{ 1, 7 };
var b = [3]u8{ 200, 225, 255 };
var c = &a ++ &b;
const c = &a ++ &b;
comptime assert(@TypeOf(c) == *[5]u8);
try expect(c[0] == 1);
try expect(c[1] == 7);
@ -791,14 +799,15 @@ test "array concatenation sets the sentinel - value" {
var a = [2]u3{ 1, 7 };
var b = [3:69]u8{ 200, 225, 255 };
var c = a ++ b;
_ = .{ &a, &b };
const c = a ++ b;
comptime assert(@TypeOf(c) == [5:69]u8);
try expect(c[0] == 1);
try expect(c[1] == 7);
try expect(c[2] == 200);
try expect(c[3] == 225);
try expect(c[4] == 255);
var ptr: [*]const u8 = &c;
const ptr: [*]const u8 = &c;
try expect(ptr[5] == 69);
}
@ -808,14 +817,14 @@ test "array concatenation sets the sentinel - pointer" {
var a = [2]u3{ 1, 7 };
var b = [3:69]u8{ 200, 225, 255 };
var c = &a ++ &b;
const c = &a ++ &b;
comptime assert(@TypeOf(c) == *[5:69]u8);
try expect(c[0] == 1);
try expect(c[1] == 7);
try expect(c[2] == 200);
try expect(c[3] == 225);
try expect(c[4] == 255);
var ptr: [*]const u8 = c;
const ptr: [*]const u8 = c;
try expect(ptr[5] == 69);
}
@ -825,13 +834,14 @@ test "array multiplication sets the sentinel - value" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a = [2:7]u3{ 1, 6 };
var b = a ** 2;
_ = &a;
const b = a ** 2;
comptime assert(@TypeOf(b) == [4:7]u3);
try expect(b[0] == 1);
try expect(b[1] == 6);
try expect(b[2] == 1);
try expect(b[3] == 6);
var ptr: [*]const u3 = &b;
const ptr: [*]const u3 = &b;
try expect(ptr[4] == 7);
}
@ -841,13 +851,13 @@ test "array multiplication sets the sentinel - pointer" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a = [2:7]u3{ 1, 6 };
var b = &a ** 2;
const b = &a ** 2;
comptime assert(@TypeOf(b) == *[4:7]u3);
try expect(b[0] == 1);
try expect(b[1] == 6);
try expect(b[2] == 1);
try expect(b[3] == 6);
var ptr: [*]const u3 = b;
const ptr: [*]const u3 = b;
try expect(ptr[4] == 7);
}
@ -913,8 +923,8 @@ test "comptime pointer load through elem_ptr" {
.x = i,
};
}
var ptr = @as([*]S, @ptrCast(&array));
var x = ptr[0].x;
var ptr: [*]S = @ptrCast(&array);
const x = ptr[0].x;
assert(x == 0);
ptr += 1;
assert(ptr[1].x == 2);
@ -953,11 +963,12 @@ test "closure capture type of runtime-known parameter" {
const S = struct {
fn b(c: anytype) !void {
const D = struct { c: @TypeOf(c) };
var d = D{ .c = c };
const d: D = .{ .c = c };
try expect(d.c == 1234);
}
};
var c: i32 = 1234;
_ = &c;
try S.b(c);
}
@ -966,6 +977,7 @@ test "closure capture type of runtime-known var" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: u32 = 1234;
_ = &x;
const S = struct { val: @TypeOf(x + 100) };
const s: S = .{ .val = x };
try expect(s.val == 1234);
@ -977,6 +989,7 @@ test "comptime break passing through runtime condition converted to runtime brea
const S = struct {
fn doTheTest() !void {
var runtime: u8 = 'b';
_ = &runtime;
inline for ([3]u8{ 'a', 'b', 'c' }) |byte| {
bar();
if (byte == runtime) {
@ -1010,6 +1023,7 @@ test "comptime break to outer loop passing through runtime condition converted t
const S = struct {
fn doTheTest() !void {
var runtime: u8 = 'b';
_ = &runtime;
outer: inline for ([3]u8{ 'A', 'B', 'C' }) |outer_byte| {
inline for ([3]u8{ 'a', 'b', 'c' }) |byte| {
bar(outer_byte);
@ -1387,6 +1401,7 @@ test "break from inline loop depends on runtime condition" {
test "inline for inside a runtime condition" {
var a = false;
_ = &a;
if (a) {
const arr = .{ 1, 2, 3 };
inline for (arr) |val| {
@ -1522,6 +1537,7 @@ test "non-optional and optional array elements concatenated" {
const array = [1]u8{'A'} ++ [1]?u8{null};
var index: usize = 0;
_ = &index;
try expect(array[index].? == 'A');
}
@ -1556,6 +1572,7 @@ test "container level const and var have unique addresses" {
var v: @This() = c;
};
var p = &S.c;
_ = &p;
try std.testing.expect(p.x == S.c.x);
S.v.x = 2;
try std.testing.expect(p.x == S.c.x);
@ -1625,7 +1642,8 @@ test "inline for loop of functions returning error unions" {
test "if inside a switch" {
var condition = true;
var wave_type: u32 = 0;
var sample: i32 = switch (wave_type) {
_ = .{ &condition, &wave_type };
const sample: i32 = switch (wave_type) {
0 => if (condition) 2 else 3,
1 => 100,
2 => 200,
@ -1673,6 +1691,7 @@ test "@inComptime" {
comptime {
var foo = [3]u8{ 0x55, 0x55, 0x55 };
var bar = [2]u8{ 1, 2 };
_ = .{ &foo, &bar };
foo[0..2].* = bar;
assert(foo[0] == 1);
assert(foo[1] == 2);

2
test/behavior/extern_struct_zero_size_fields.zig
View File

@ -17,5 +17,5 @@ const T = extern struct {
test {
var t: T = .{};
_ = t;
_ = &t;
}

164
test/behavior/floatop.zig
View File

@ -42,6 +42,8 @@ test "add f80/f128/c_longdouble" {
fn testAdd(comptime T: type) !void {
var one_point_two_five: T = 1.25;
var two_point_seven_five: T = 2.75;
_ = &one_point_two_five;
_ = &two_point_seven_five;
try expect(one_point_two_five + two_point_seven_five == 4);
}
@ -74,6 +76,8 @@ test "sub f80/f128/c_longdouble" {
fn testSub(comptime T: type) !void {
var one_point_two_five: T = 1.25;
var two_point_seven_five: T = 2.75;
_ = &one_point_two_five;
_ = &two_point_seven_five;
try expect(one_point_two_five - two_point_seven_five == -1.5);
}
@ -106,6 +110,8 @@ test "mul f80/f128/c_longdouble" {
fn testMul(comptime T: type) !void {
var one_point_two_five: T = 1.25;
var two_point_seven_five: T = 2.75;
_ = &one_point_two_five;
_ = &two_point_seven_five;
try expect(one_point_two_five * two_point_seven_five == 3.4375);
}
@ -152,6 +158,7 @@ fn testCmp(comptime T: type) !void {
{
// No decimal part
var x: T = 1.0;
_ = &x;
try expect(x == 1.0);
try expect(x != 0.0);
try expect(x > 0.0);
@ -162,6 +169,7 @@ fn testCmp(comptime T: type) !void {
{
// Non-zero decimal part
var x: T = 1.5;
_ = &x;
try expect(x != 1.0);
try expect(x != 2.0);
try expect(x > 1.0);
@ -184,6 +192,7 @@ fn testCmp(comptime T: type) !void {
math.floatMax(T),
math.inf(T),
};
_ = &edges;
for (edges, 0..) |rhs, rhs_i| {
for (edges, 0..) |lhs, lhs_i| {
const no_nan = lhs_i != 5 and rhs_i != 5;
@ -212,6 +221,7 @@ test "different sized float comparisons" {
fn testDifferentSizedFloatComparisons() !void {
var a: f16 = 1;
var b: f64 = 2;
_ = .{ &a, &b };
try expect(a < b);
}
@ -240,7 +250,8 @@ test "negative f128 intFromFloat at compile-time" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a: f128 = -2;
var b = @as(i64, @intFromFloat(a));
var b: i64 = @intFromFloat(a);
_ = &b;
try expect(@as(i64, -2) == b);
}
@ -331,6 +342,28 @@ fn testSqrt(comptime T: type) !void {
try expect(math.isNan(@sqrt(neg_one)));
var nan: T = math.nan(T);
try expect(math.isNan(@sqrt(nan)));
_ = .{
&four,
&nine,
&twenty_five,
&sixty_four,
&one_point_one,
&two,
&three_point_six,
&sixty_four_point_one,
&twelve,
&thirteen,
&fourteen,
&a,
&b,
&c,
&inf,
&zero,
&neg_zero,
&neg_one,
&nan,
};
}
test "@sqrt with vectors" {
@ -345,7 +378,8 @@ test "@sqrt with vectors" {
fn testSqrtWithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
var result = @sqrt(v);
_ = &v;
const result = @sqrt(v);
try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon));
@ -394,8 +428,10 @@ test "@sin f80/f128/c_longdouble" {
fn testSin(comptime T: type) !void {
const eps = epsForType(T);
var zero: T = 0;
_ = &zero;
try expect(@sin(zero) == 0);
var pi: T = math.pi;
_ = &pi;
try expect(math.approxEqAbs(T, @sin(pi), 0, eps));
try expect(math.approxEqAbs(T, @sin(pi / 2.0), 1, eps));
try expect(math.approxEqAbs(T, @sin(pi / 4.0), 0.7071067811865475, eps));
@ -414,7 +450,8 @@ test "@sin with vectors" {
fn testSinWithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
var result = @sin(v);
_ = &v;
const result = @sin(v);
try expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon));
@ -463,8 +500,10 @@ test "@cos f80/f128/c_longdouble" {
fn testCos(comptime T: type) !void {
const eps = epsForType(T);
var zero: T = 0;
_ = &zero;
try expect(@cos(zero) == 1);
var pi: T = math.pi;
_ = &pi;
try expect(math.approxEqAbs(T, @cos(pi), -1, eps));
try expect(math.approxEqAbs(T, @cos(pi / 2.0), 0, eps));
try expect(math.approxEqAbs(T, @cos(pi / 4.0), 0.7071067811865475, eps));
@ -483,7 +522,8 @@ test "@cos with vectors" {
fn testCosWithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
var result = @cos(v);
_ = &v;
const result = @cos(v);
try expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon));
@ -532,8 +572,10 @@ test "@tan f80/f128/c_longdouble" {
fn testTan(comptime T: type) !void {
const eps = epsForType(T);
var zero: T = 0;
_ = &zero;
try expect(@tan(zero) == 0);
var pi: T = math.pi;
_ = &pi;
try expect(math.approxEqAbs(T, @tan(pi), 0, eps));
try expect(math.approxEqAbs(T, @tan(pi / 3.0), 1.732050807568878, eps));
try expect(math.approxEqAbs(T, @tan(pi / 4.0), 1, eps));
@ -552,7 +594,8 @@ test "@tan with vectors" {
fn testTanWithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
var result = @tan(v);
_ = &v;
const result = @tan(v);
try expect(math.approxEqAbs(f32, @tan(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @tan(@as(f32, 2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @tan(@as(f32, 3.3)), result[2], epsilon));
@ -600,11 +643,17 @@ test "@exp f80/f128/c_longdouble" {
fn testExp(comptime T: type) !void {
const eps = epsForType(T);
var zero: T = 0;
_ = &zero;
try expect(@exp(zero) == 1);
var two: T = 2;
_ = &two;
try expect(math.approxEqAbs(T, @exp(two), 7.389056098930650, eps));
var five: T = 5;
_ = &five;
try expect(math.approxEqAbs(T, @exp(five), 148.4131591025766, eps));
}
@ -621,7 +670,8 @@ test "@exp with vectors" {
fn testExpWithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
var result = @exp(v);
_ = &v;
const result = @exp(v);
try expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon));
@ -675,6 +725,7 @@ fn testExp2(comptime T: type) !void {
try expect(math.approxEqAbs(T, @exp2(one_point_five), 2.8284271247462, eps));
var four_point_five: T = 4.5;
try expect(math.approxEqAbs(T, @exp2(four_point_five), 22.627416997969, eps));
_ = .{ &two, &one_point_five, &four_point_five };
}
test "@exp2 with @vectors" {
@ -690,7 +741,8 @@ test "@exp2 with @vectors" {
fn testExp2WithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
var result = @exp2(v);
_ = &v;
const result = @exp2(v);
try expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon));
@ -744,6 +796,7 @@ fn testLog(comptime T: type) !void {
try expect(math.approxEqAbs(T, @log(two), 0.6931471805599, eps));
var five: T = 5;
try expect(math.approxEqAbs(T, @log(five), 1.6094379124341, eps));
_ = .{ &e, &two, &five };
}
test "@log with @vectors" {
@ -756,7 +809,8 @@ test "@log with @vectors" {
{
var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
var result = @log(v);
_ = &v;
const result = @log(v);
try expect(@log(@as(f32, 1.1)) == result[0]);
try expect(@log(@as(f32, 2.2)) == result[1]);
try expect(@log(@as(f32, 0.3)) == result[2]);
@ -811,6 +865,7 @@ fn testLog2(comptime T: type) !void {
try expect(math.approxEqAbs(T, @log2(six), 2.5849625007212, eps));
var ten: T = 10;
try expect(math.approxEqAbs(T, @log2(ten), 3.3219280948874, eps));
_ = .{ &four, &six, &ten };
}
test "@log2 with vectors" {
@ -830,7 +885,8 @@ test "@log2 with vectors" {
fn testLog2WithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
var result = @log2(v);
_ = &v;
const result = @log2(v);
try expect(@log2(@as(f32, 1.1)) == result[0]);
try expect(@log2(@as(f32, 2.2)) == result[1]);
try expect(@log2(@as(f32, 0.3)) == result[2]);
@ -884,6 +940,7 @@ fn testLog10(comptime T: type) !void {
try expect(math.approxEqAbs(T, @log10(fifteen), 1.176091259056, eps));
var fifty: T = 50;
try expect(math.approxEqAbs(T, @log10(fifty), 1.698970004336, eps));
_ = .{ &hundred, &fifteen, &fifty };
}
test "@log10 with vectors" {
@ -899,7 +956,8 @@ test "@log10 with vectors" {
fn testLog10WithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
var result = @log10(v);
_ = &v;
const result = @log10(v);
try expect(@log10(@as(f32, 1.1)) == result[0]);
try expect(@log10(@as(f32, 2.2)) == result[1]);
try expect(@log10(@as(f32, 0.3)) == result[2]);
@ -987,6 +1045,26 @@ fn testFabs(comptime T: type) !void {
try expect(math.isPositiveInf(@abs(neg_inf)));
var nan: T = math.nan(T);
try expect(math.isNan(@abs(nan)));
_ = .{
&two_point_five,
&neg_two_point_five,
&twelve,
&neg_fourteen,
&one,
&neg_one,
&min,
&neg_min,
&max,
&neg_max,
&zero,
&neg_zero,
&true_min,
&neg_true_min,
&inf,
&neg_inf,
&nan,
};
}
test "@abs with vectors" {
@ -1001,7 +1079,8 @@ test "@abs with vectors" {
fn testFabsWithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
var result = @abs(v);
_ = &v;
const result = @abs(v);
try expect(math.approxEqAbs(f32, @abs(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @abs(@as(f32, -2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @abs(@as(f32, 0.3)), result[2], epsilon));
@ -1070,6 +1149,17 @@ fn testFloor(comptime T: type) !void {
try expect(@floor(fourteen_point_seven) == 14.0);
var neg_fourteen_point_seven: T = -14.7;
try expect(@floor(neg_fourteen_point_seven) == -15.0);
_ = .{
&two_point_one,
&neg_two_point_one,
&three_point_five,
&neg_three_point_five,
&twelve,
&neg_twelve,
&fourteen_point_seven,
&neg_fourteen_point_seven,
};
}
test "@floor with vectors" {
@ -1086,7 +1176,8 @@ test "@floor with vectors" {
fn testFloorWithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
var result = @floor(v);
_ = &v;
const result = @floor(v);
try expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon));
@ -1155,6 +1246,17 @@ fn testCeil(comptime T: type) !void {
try expect(@ceil(fourteen_point_seven) == 15.0);
var neg_fourteen_point_seven: T = -14.7;
try expect(@ceil(neg_fourteen_point_seven) == -14.0);
_ = .{
&two_point_one,
&neg_two_point_one,
&three_point_five,
&neg_three_point_five,
&twelve,
&neg_twelve,
&fourteen_point_seven,
&neg_fourteen_point_seven,
};
}
test "@ceil with vectors" {
@ -1171,7 +1273,8 @@ test "@ceil with vectors" {
fn testCeilWithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
var result = @ceil(v);
_ = &v;
const result = @ceil(v);
try expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon));
@ -1250,6 +1353,17 @@ fn testTrunc(comptime T: type) !void {
try expect(@trunc(fourteen_point_seven) == 14.0);
var neg_fourteen_point_seven: T = -14.7;
try expect(@trunc(neg_fourteen_point_seven) == -14.0);
_ = .{
&two_point_one,
&neg_two_point_one,
&three_point_five,
&neg_three_point_five,
&twelve,
&neg_twelve,
&fourteen_point_seven,
&neg_fourteen_point_seven,
};
}
test "@trunc with vectors" {
@ -1266,7 +1380,8 @@ test "@trunc with vectors" {
fn testTruncWithVectors() !void {
var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
var result = @trunc(v);
_ = &v;
const result = @trunc(v);
try expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));
try expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));
try expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon));
@ -1365,6 +1480,27 @@ fn testNeg(comptime T: type) !void {
var neg_nan: T = -math.nan(T);
try expect(math.isNan(-neg_nan));
try expect(!math.signbit(-neg_nan));
_ = .{
&two_point_five,
&neg_two_point_five,
&twelve,
&neg_fourteen,
&one,
&neg_one,
&min,
&neg_min,
&max,
&neg_max,
&zero,
&neg_zero,
&true_min,
&neg_true_min,
&inf,
&neg_inf,
&nan,
&neg_nan,
};
}
test "eval @setFloatMode at compile-time" {

13
test/behavior/fn.zig
View File

@ -21,6 +21,7 @@ fn testLocVars(b: i32) void {
test "mutable local variables" {
var zero: i32 = 0;
_ = &zero;
try expect(zero == 0);
var i = @as(i32, 0);
@ -70,7 +71,7 @@ fn outer(y: u32) *const fn (u32) u32 {
test "return inner function which references comptime variable of outer function" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var func = outer(10);
const func = outer(10);
try expect(func(3) == 7);
}
@ -259,7 +260,7 @@ test "implicit cast fn call result to optional in field result" {
const S = struct {
fn entry() !void {
var x = Foo{
const x = Foo{
.field = optionalPtr(),
};
try expect(x.field.?.* == 999);
@ -386,6 +387,7 @@ test "ability to give comptime types and non comptime types to same parameter" {
const S = struct {
fn doTheTest() !void {
var x: i32 = 1;
_ = &x;
try expect(foo(x) == 10);
try expect(foo(i32) == 20);
}
@ -413,11 +415,11 @@ test "import passed byref to function in return type" {
const S = struct {
fn get() @import("std").ArrayListUnmanaged(i32) {
var x: @import("std").ArrayListUnmanaged(i32) = .{};
const x: @import("std").ArrayListUnmanaged(i32) = .{};
return x;
}
};
var list = S.get();
const list = S.get();
try expect(list.items.len == 0);
}
@ -434,11 +436,13 @@ test "implicit cast function to function ptr" {
}
};
var fnPtr1: *const fn () callconv(.C) c_int = S1.someFunctionThatReturnsAValue;
_ = &fnPtr1;
try expect(fnPtr1() == 123);
const S2 = struct {
extern fn someFunctionThatReturnsAValue() c_int;
};
var fnPtr2: *const fn () callconv(.C) c_int = S2.someFunctionThatReturnsAValue;
_ = &fnPtr2;
try expect(fnPtr2() == 123);
}
@ -588,5 +592,6 @@ test "pointer to alias behaves same as pointer to function" {
const bar = foo;
};
var a = &S.bar;
_ = &a;
try std.testing.expect(S.foo() == a());
}

3
test/behavior/fn_in_struct_in_comptime.zig
View File

@ -5,8 +5,7 @@ fn get_foo() fn (*u8) usize {
comptime {
return struct {
fn func(ptr: *u8) usize {
var u = @intFromPtr(ptr);
return u;
return @intFromPtr(ptr);
}
}.func;
}

19
test/behavior/for.zig
View File

@ -26,7 +26,7 @@ test "break from outer for loop" {
}
fn testBreakOuter() !void {
var array = "aoeu";
const array = "aoeu";
var count: usize = 0;
outer: for (array) |_| {
for (array) |_| {
@ -43,7 +43,7 @@ test "continue outer for loop" {
}
fn testContinueOuter() !void {
var array = "aoeu";
const array = "aoeu";
var counter: usize = 0;
outer: for (array) |_| {
for (array) |_| {
@ -137,7 +137,7 @@ test "2 break statements and an else" {
fn entry(t: bool, f: bool) !void {
var buf: [10]u8 = undefined;
var ok = false;
ok = for (buf) |item| {
ok = for (&buf) |*item| {
_ = item;
if (f) break false;
if (t) break true;
@ -201,7 +201,7 @@ test "for on slice with allowzero ptr" {
const S = struct {
fn doTheTest(slice: []const u8) !void {
var ptr = @as([*]allowzero const u8, @ptrCast(slice.ptr))[0..slice.len];
const ptr = @as([*]allowzero const u8, @ptrCast(slice.ptr))[0..slice.len];
for (ptr, 0..) |x, i| try expect(x == i + 1);
for (ptr, 0..) |*x, i| try expect(x.* == i + 1);
}
@ -230,6 +230,7 @@ test "for loop with else branch" {
{
var x = [_]u32{ 1, 2 };
_ = &x;
const q = for (x) |y| {
if ((y & 1) != 0) continue;
break y * 2;
@ -238,6 +239,7 @@ test "for loop with else branch" {
}
{
var x = [_]u32{ 1, 2 };
_ = &x;
const q = for (x) |y| {
if ((y & 1) != 0) continue;
break y * 2;
@ -310,6 +312,7 @@ test "slice and two counters, one is offset and one is runtime" {
const slice: []const u8 = "blah";
var start: usize = 0;
_ = &start;
for (slice, start..4, 1..5) |a, b, c| {
if (a == 'b') {
@ -394,6 +397,7 @@ test "inline for with slice as the comptime-known" {
const comptime_slice = "hello";
var runtime_i: usize = 3;
_ = &runtime_i;
const S = struct {
var ok: usize = 0;
@ -424,6 +428,7 @@ test "inline for with counter as the comptime-known" {
var runtime_slice = "hello";
var runtime_i: usize = 3;
_ = &runtime_i;
const S = struct {
var ok: usize = 0;
@ -484,14 +489,16 @@ test "inferred alloc ptr of for loop" {
{
var cond = false;
var opt = for (0..1) |_| {
_ = &cond;
const opt = for (0..1) |_| {
if (cond) break cond;
} else null;
try expectEqual(@as(?bool, null), opt);
}
{
var cond = true;
var opt = for (0..1) |_| {
_ = &cond;
const opt = for (0..1) |_| {
if (cond) break cond;
} else null;
try expectEqual(@as(?bool, true), opt);

2
test/behavior/generics.zig
View File

@ -102,6 +102,7 @@ test "type constructed by comptime function call" {
fn SimpleList(comptime L: usize) type {
var mutable_T = u8;
_ = &mutable_T;
const T = mutable_T;
return struct {
array: [L]T,
@ -238,6 +239,7 @@ test "function parameter is generic" {
}
};
var rng: u32 = 2;
_ = &rng;
S.init(rng, S.fill);
}

17
test/behavior/if.zig
View File

@ -61,6 +61,7 @@ test "unwrap mutable global var" {
test "labeled break inside comptime if inside runtime if" {
var answer: i32 = 0;
var c = true;
_ = &c;
if (c) {
answer = if (true) blk: {
break :blk @as(i32, 42);
@ -73,6 +74,7 @@ test "const result loc, runtime if cond, else unreachable" {
const Num = enum { One, Two };
var t = true;
_ = &t;
const x = if (t) Num.Two else unreachable;
try expect(x == .Two);
}
@ -103,6 +105,7 @@ test "if prongs cast to expected type instead of peer type resolution" {
try expect(x == 2);
var b = true;
_ = &b;
const y: i32 = if (b) 1 else 2;
try expect(y == 1);
}
@ -118,10 +121,11 @@ test "if peer expressions inferred optional type" {
var self: []const u8 = "abcdef";
var index: usize = 0;
var left_index = (index << 1) + 1;
var right_index = left_index + 1;
var left = if (left_index < self.len) self[left_index] else null;
var right = if (right_index < self.len) self[right_index] else null;
_ = .{ &self, &index };
const left_index = (index << 1) + 1;
const right_index = left_index + 1;
const left = if (left_index < self.len) self[left_index] else null;
const right = if (right_index < self.len) self[right_index] else null;
try expect(left_index < self.len);
try expect(right_index < self.len);
try expect(left.? == 98);
@ -135,6 +139,7 @@ test "if-else expression with runtime condition result location is inferred opti
const A = struct { b: u64, c: u64 };
var d: bool = true;
_ = &d;
const e = if (d) A{ .b = 15, .c = 30 } else null;
try expect(e != null);
}
@ -142,7 +147,8 @@ test "if-else expression with runtime condition result location is inferred opti
test "result location with inferred type ends up being pointer to comptime_int" {
var a: ?u32 = 1234;
var b: u32 = 2000;
var c = if (a) |d| blk: {
_ = .{ &a, &b };
const c = if (a) |d| blk: {
if (d < b) break :blk @as(u32, 1);
break :blk 0;
} else @as(u32, 0);
@ -152,6 +158,7 @@ test "result location with inferred type ends up being pointer to comptime_int"
test "if-@as-if chain" {
var fast = true;
var very_fast = false;
_ = .{ &fast, &very_fast };
const num_frames = if (fast)
@as(u32, if (very_fast) 16 else 4)

8
test/behavior/inline_switch.zig
View File

@ -22,6 +22,7 @@ test "inline prong ranges" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: usize = 0;
_ = &x;
switch (x) {
inline 0...20, 24 => |item| {
if (item > 25) @compileError("bad");
@ -36,6 +37,7 @@ test "inline switch enums" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: E = .a;
_ = &x;
switch (x) {
inline .a, .b => |aorb| if (aorb != .a and aorb != .b) @compileError("bad"),
inline .c, .d => |cord| if (cord != .c and cord != .d) @compileError("bad"),
@ -49,6 +51,7 @@ test "inline switch unions" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: U = .a;
_ = &x;
switch (x) {
inline .a, .b => |aorb, tag| {
if (tag == .a) {
@ -74,6 +77,7 @@ test "inline else bool" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a = true;
_ = &a;
switch (a) {
true => {},
inline else => |val| if (val != false) @compileError("bad"),
@ -86,6 +90,7 @@ test "inline else error" {
const Err = error{ a, b, c };
var a = Err.a;
_ = &a;
switch (a) {
error.a => {},
inline else => |val| comptime if (val == error.a) @compileError("bad"),
@ -98,6 +103,7 @@ test "inline else enum" {
const E2 = enum(u8) { a = 2, b = 3, c = 4, d = 5 };
var a: E2 = .a;
_ = &a;
switch (a) {
.a, .b => {},
inline else => |val| comptime if (@intFromEnum(val) < 4) @compileError("bad"),
@ -109,6 +115,7 @@ test "inline else int with gaps" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: u8 = 0;
_ = &a;
switch (a) {
1...125, 128...254 => {},
inline else => |val| {
@ -126,6 +133,7 @@ test "inline else int all values" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: u2 = 0;
_ = &a;
switch (a) {
inline else => |val| {
if (val != 0 and

3
test/behavior/int128.zig
View File

@ -39,6 +39,7 @@ test "undefined 128 bit int" {
var undef: u128 = undefined;
var undef_signed: i128 = undefined;
_ = .{ &undef, &undef_signed };
try expect(undef == 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa and @as(u128, @bitCast(undef_signed)) == undef);
}
@ -73,6 +74,7 @@ test "truncate int128" {
{
var buff: u128 = maxInt(u128);
_ = &buff;
try expect(@as(u64, @truncate(buff)) == maxInt(u64));
try expect(@as(u90, @truncate(buff)) == maxInt(u90));
try expect(@as(u128, @truncate(buff)) == maxInt(u128));
@ -80,6 +82,7 @@ test "truncate int128" {
{
var buff: i128 = maxInt(i128);
_ = &buff;
try expect(@as(i64, @truncate(buff)) == -1);
try expect(@as(i90, @truncate(buff)) == -1);
try expect(@as(i128, @truncate(buff)) == maxInt(i128));

1
test/behavior/int_comparison_elision.zig
View File

@ -30,6 +30,7 @@ fn testIntEdges(comptime T: type) void {
const max = maxInt(T);
var runtime_val: T = undefined;
_ = &runtime_val;
if (min > runtime_val) @compileError("analyzed impossible branch");
if (min <= runtime_val) {} else @compileError("analyzed impossible branch");

2
test/behavior/int_div.zig
View File

@ -100,11 +100,13 @@ test "large integer division" {
{
var numerator: u256 = 99999999999999999997315645440;
var divisor: u256 = 10000000000000000000000000000;
_ = .{ &numerator, &divisor };
try expect(numerator / divisor == 9);
}
{
var numerator: u256 = 99999999999999999999000000000000000000000;
var divisor: u256 = 10000000000000000000000000000000000000000;
_ = .{ &numerator, &divisor };
try expect(numerator / divisor == 9);
}
}

58
test/behavior/math.zig
View File

@ -624,7 +624,8 @@ const DivResult = struct {
test "bit shift a u1" {
var x: u1 = 1;
var y = x << 0;
_ = &x;
const y = x << 0;
try expect(y == 1);
}
@ -692,7 +693,8 @@ test "128-bit multiplication" {
{
var a: u128 = 0xffffffffffffffff;
var b: u128 = 100;
var c = a * b;
_ = .{ &a, &b };
const c = a * b;
try expect(c == 0x63ffffffffffffff9c);
}
}
@ -704,18 +706,21 @@ test "@addWithOverflow" {
{
var a: u8 = 250;
_ = &a;
const ov = @addWithOverflow(a, 100);
try expect(ov[0] == 94);
try expect(ov[1] == 1);
}
{
var a: u8 = 100;
_ = &a;
const ov = @addWithOverflow(a, 150);
try expect(ov[0] == 250);
try expect(ov[1] == 0);
}
{
var a: u8 = 200;
_ = &a;
var b: u8 = 99;
var ov = @addWithOverflow(a, b);
try expect(ov[0] == 43);
@ -729,6 +734,7 @@ test "@addWithOverflow" {
{
var a: usize = 6;
var b: usize = 6;
_ = .{ &a, &b };
const ov = @addWithOverflow(a, b);
try expect(ov[0] == 12);
try expect(ov[1] == 0);
@ -737,6 +743,7 @@ test "@addWithOverflow" {
{
var a: isize = -6;
var b: isize = -6;
_ = .{ &a, &b };
const ov = @addWithOverflow(a, b);
try expect(ov[0] == -12);
try expect(ov[1] == 0);
@ -772,18 +779,21 @@ test "basic @mulWithOverflow" {
{
var a: u8 = 86;
_ = &a;
const ov = @mulWithOverflow(a, 3);
try expect(ov[0] == 2);
try expect(ov[1] == 1);
}
{
var a: u8 = 85;
_ = &a;
const ov = @mulWithOverflow(a, 3);
try expect(ov[0] == 255);
try expect(ov[1] == 0);
}
var a: u8 = 123;
_ = &a;
var b: u8 = 2;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == 246);
@ -802,6 +812,7 @@ test "extensive @mulWithOverflow" {
{
var a: u5 = 3;
_ = &a;
var b: u5 = 10;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == 30);
@ -815,6 +826,7 @@ test "extensive @mulWithOverflow" {
{
var a: i5 = 3;
_ = &a;
var b: i5 = -5;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == -15);
@ -828,6 +840,7 @@ test "extensive @mulWithOverflow" {
{
var a: u8 = 3;
_ = &a;
var b: u8 = 85;
var ov = @mulWithOverflow(a, b);
@ -842,6 +855,7 @@ test "extensive @mulWithOverflow" {
{
var a: i8 = 3;
_ = &a;
var b: i8 = -42;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == -126);
@ -855,6 +869,7 @@ test "extensive @mulWithOverflow" {
{
var a: u14 = 3;
_ = &a;
var b: u14 = 0x1555;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == 0x3fff);
@ -868,6 +883,7 @@ test "extensive @mulWithOverflow" {
{
var a: i14 = 3;
_ = &a;
var b: i14 = -0xaaa;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == -0x1ffe);
@ -880,6 +896,7 @@ test "extensive @mulWithOverflow" {
{
var a: u16 = 3;
_ = &a;
var b: u16 = 0x5555;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == 0xffff);
@ -893,6 +910,7 @@ test "extensive @mulWithOverflow" {
{
var a: i16 = 3;
_ = &a;
var b: i16 = -0x2aaa;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == -0x7ffe);
@ -906,6 +924,7 @@ test "extensive @mulWithOverflow" {
{
var a: u30 = 3;
_ = &a;
var b: u30 = 0x15555555;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == 0x3fffffff);
@ -919,6 +938,7 @@ test "extensive @mulWithOverflow" {
{
var a: i30 = 3;
_ = &a;
var b: i30 = -0xaaaaaaa;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == -0x1ffffffe);
@ -932,6 +952,7 @@ test "extensive @mulWithOverflow" {
{
var a: u32 = 3;
_ = &a;
var b: u32 = 0x55555555;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == 0xffffffff);
@ -945,6 +966,7 @@ test "extensive @mulWithOverflow" {
{
var a: i32 = 3;
_ = &a;
var b: i32 = -0x2aaaaaaa;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == -0x7ffffffe);
@ -967,6 +989,7 @@ test "@mulWithOverflow bitsize > 32" {
{
var a: u62 = 3;
_ = &a;
var b: u62 = 0x1555555555555555;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == 0x3fffffffffffffff);
@ -980,6 +1003,7 @@ test "@mulWithOverflow bitsize > 32" {
{
var a: i62 = 3;
_ = &a;
var b: i62 = -0xaaaaaaaaaaaaaaa;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == -0x1ffffffffffffffe);
@ -993,6 +1017,7 @@ test "@mulWithOverflow bitsize > 32" {
{
var a: u64 = 3;
_ = &a;
var b: u64 = 0x5555555555555555;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == 0xffffffffffffffff);
@ -1006,6 +1031,7 @@ test "@mulWithOverflow bitsize > 32" {
{
var a: i64 = 3;
_ = &a;
var b: i64 = -0x2aaaaaaaaaaaaaaa;
var ov = @mulWithOverflow(a, b);
try expect(ov[0] == -0x7ffffffffffffffe);
@ -1025,12 +1051,14 @@ test "@subWithOverflow" {
{
var a: u8 = 1;
_ = &a;
const ov = @subWithOverflow(a, 2);
try expect(ov[0] == 255);
try expect(ov[1] == 1);
}
{
var a: u8 = 1;
_ = &a;
const ov = @subWithOverflow(a, 1);
try expect(ov[0] == 0);
try expect(ov[1] == 0);
@ -1038,6 +1066,7 @@ test "@subWithOverflow" {
{
var a: u8 = 1;
_ = &a;
var b: u8 = 2;
var ov = @subWithOverflow(a, b);
try expect(ov[0] == 255);
@ -1051,6 +1080,7 @@ test "@subWithOverflow" {
{
var a: usize = 6;
var b: usize = 6;
_ = .{ &a, &b };
const ov = @subWithOverflow(a, b);
try expect(ov[0] == 0);
try expect(ov[1] == 0);
@ -1059,6 +1089,7 @@ test "@subWithOverflow" {
{
var a: isize = -6;
var b: isize = -6;
_ = .{ &a, &b };
const ov = @subWithOverflow(a, b);
try expect(ov[0] == 0);
try expect(ov[1] == 0);
@ -1072,6 +1103,7 @@ test "@shlWithOverflow" {
{
var a: u4 = 2;
_ = &a;
var b: u2 = 1;
var ov = @shlWithOverflow(a, b);
try expect(ov[0] == 4);
@ -1085,6 +1117,7 @@ test "@shlWithOverflow" {
{
var a: i9 = 127;
_ = &a;
var b: u4 = 1;
var ov = @shlWithOverflow(a, b);
try expect(ov[0] == 254);
@ -1108,6 +1141,7 @@ test "@shlWithOverflow" {
}
{
var a: u16 = 0b0000_0000_0000_0011;
_ = &a;
var b: u4 = 15;
var ov = @shlWithOverflow(a, b);
try expect(ov[0] == 0b1000_0000_0000_0000);
@ -1124,24 +1158,28 @@ test "overflow arithmetic with u0 values" {
{
var a: u0 = 0;
_ = &a;
const ov = @addWithOverflow(a, 0);
try expect(ov[1] == 0);
try expect(ov[1] == 0);
}
{
var a: u0 = 0;
_ = &a;
const ov = @subWithOverflow(a, 0);
try expect(ov[1] == 0);
try expect(ov[1] == 0);
}
{
var a: u0 = 0;
_ = &a;
const ov = @mulWithOverflow(a, 0);
try expect(ov[1] == 0);
try expect(ov[1] == 0);
}
{
var a: u0 = 0;
_ = &a;
const ov = @shlWithOverflow(a, 0);
try expect(ov[1] == 0);
try expect(ov[1] == 0);
@ -1157,6 +1195,7 @@ test "allow signed integer division/remainder when values are comptime-known and
try expect(-6 % 3 == 0);
var undef: i32 = undefined;
_ = &undef;
if (0 % undef != 0) {
@compileError("0 as numerator should return comptime zero independent of denominator");
}
@ -1183,18 +1222,22 @@ test "quad hex float literal parsing accurate" {
fn doTheTest() !void {
{
var f: f128 = 0x1.2eab345678439abcdefea56782346p+5;
_ = &f;
try expect(@as(u128, @bitCast(f)) == 0x40042eab345678439abcdefea5678234);
}
{
var f: f128 = 0x1.edcb34a235253948765432134674fp-1;
_ = &f;
try expect(@as(u128, @bitCast(f)) == 0x3ffeedcb34a235253948765432134675); // round-to-even
}
{
var f: f128 = 0x1.353e45674d89abacc3a2ebf3ff4ffp-50;
_ = &f;
try expect(@as(u128, @bitCast(f)) == 0x3fcd353e45674d89abacc3a2ebf3ff50);
}
{
var f: f128 = 0x1.ed8764648369535adf4be3214567fp-9;
_ = &f;
try expect(@as(u128, @bitCast(f)) == 0x3ff6ed8764648369535adf4be3214568);
}
const exp2ft = [_]f64{
@ -1294,6 +1337,7 @@ test "shift left/right on u0 operand" {
fn doTheTest() !void {
var x: u0 = 0;
var y: u0 = 0;
_ = .{ &x, &y };
try expectEqual(@as(u0, 0), x << 0);
try expectEqual(@as(u0, 0), x >> 0);
try expectEqual(@as(u0, 0), x << y);
@ -1310,7 +1354,7 @@ test "shift left/right on u0 operand" {
test "comptime float rem int" {
comptime {
var x = @as(f32, 1) % 2;
const x = @as(f32, 1) % 2;
try expect(x == 1.0);
}
}
@ -1511,7 +1555,8 @@ test "vector integer addition" {
fn doTheTest() !void {
var a: @Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
var b: @Vector(4, i32) = [_]i32{ 5, 6, 7, 8 };
var result = a + b;
_ = .{ &a, &b };
const result = a + b;
var result_array: [4]i32 = result;
const expected = [_]i32{ 6, 8, 10, 12 };
try expectEqualSlices(i32, &expected, &result_array);
@ -1552,6 +1597,7 @@ test "NaN comparison f80" {
fn testNanEqNan(comptime F: type) !void {
var nan1 = math.nan(F);
var nan2 = math.nan(F);
_ = .{ &nan1, &nan2 };
try expect(nan1 != nan2);
try expect(!(nan1 == nan2));
try expect(!(nan1 > nan2));
@ -1571,6 +1617,7 @@ test "vector comparison" {
fn doTheTest() !void {
var a: @Vector(6, i32) = [_]i32{ 1, 3, -1, 5, 7, 9 };
var b: @Vector(6, i32) = [_]i32{ -1, 3, 0, 6, 10, -10 };
_ = .{ &a, &b };
try expect(mem.eql(bool, &@as([6]bool, a < b), &[_]bool{ false, false, true, true, true, false }));
try expect(mem.eql(bool, &@as([6]bool, a <= b), &[_]bool{ false, true, true, true, true, false }));
try expect(mem.eql(bool, &@as([6]bool, a == b), &[_]bool{ false, true, false, false, false, false }));
@ -1609,7 +1656,8 @@ test "signed zeros are represented properly" {
fn testOne(comptime T: type) !void {
const ST = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
var as_fp_val = -@as(T, 0.0);
var as_uint_val = @as(ST, @bitCast(as_fp_val));
_ = &as_fp_val;
const as_uint_val: ST = @bitCast(as_fp_val);
// Ensure the sign bit is set.
try expect(as_uint_val >> (@typeInfo(T).Float.bits - 1) == 1);
}

29
test/behavior/maximum_minimum.zig
View File

@ -15,6 +15,7 @@ test "@max" {
var x: i32 = 10;
var y: f32 = 0.68;
var nan: f32 = std.math.nan(f32);
_ = .{ &x, &y, &nan };
try expect(@as(i32, 10) == @max(@as(i32, -3), x));
try expect(@as(f32, 3.2) == @max(@as(f32, 3.2), y));
try expect(y == @max(nan, y));
@ -38,17 +39,20 @@ test "@max on vectors" {
fn doTheTest() !void {
var a: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
var b: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
var x = @max(a, b);
const x = @max(a, b);
_ = .{ &a, &b };
try expect(mem.eql(i32, &@as([4]i32, x), &[4]i32{ 2147483647, 2147483647, 30, 40 }));
var c: @Vector(4, f32) = [4]f32{ 0, 0.4, -2.4, 7.8 };
var d: @Vector(4, f32) = [4]f32{ -0.23, 0.42, -0.64, 0.9 };
var y = @max(c, d);
const y = @max(c, d);
_ = .{ &c, &d };
try expect(mem.eql(f32, &@as([4]f32, y), &[4]f32{ 0, 0.42, -0.64, 7.8 }));
var e: @Vector(2, f32) = [2]f32{ 0, std.math.nan(f32) };
var f: @Vector(2, f32) = [2]f32{ std.math.nan(f32), 0 };
var z = @max(e, f);
const z = @max(e, f);
_ = .{ &e, &f };
try expect(mem.eql(f32, &@as([2]f32, z), &[2]f32{ 0, 0 }));
}
};
@ -66,6 +70,7 @@ test "@min" {
var x: i32 = 10;
var y: f32 = 0.68;
var nan: f32 = std.math.nan(f32);
_ = .{ &x, &y, &nan };
try expect(@as(i32, -3) == @min(@as(i32, -3), x));
try expect(@as(f32, 0.68) == @min(@as(f32, 3.2), y));
try expect(y == @min(nan, y));
@ -89,17 +94,20 @@ test "@min for vectors" {
fn doTheTest() !void {
var a: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
var b: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
var x = @min(a, b);
_ = .{ &a, &b };
const x = @min(a, b);
try expect(mem.eql(i32, &@as([4]i32, x), &[4]i32{ 1, -2, 3, 4 }));
var c: @Vector(4, f32) = [4]f32{ 0, 0.4, -2.4, 7.8 };
var d: @Vector(4, f32) = [4]f32{ -0.23, 0.42, -0.64, 0.9 };
var y = @min(c, d);
_ = .{ &c, &d };
const y = @min(c, d);
try expect(mem.eql(f32, &@as([4]f32, y), &[4]f32{ -0.23, 0.4, -2.4, 0.9 }));
var e: @Vector(2, f32) = [2]f32{ 0, std.math.nan(f32) };
var f: @Vector(2, f32) = [2]f32{ std.math.nan(f32), 0 };
var z = @max(e, f);
_ = .{ &e, &f };
const z = @max(e, f);
try expect(mem.eql(f32, &@as([2]f32, z), &[2]f32{ 0, 0 }));
}
};
@ -119,6 +127,7 @@ test "@min/max for floats" {
fn doTheTest(comptime T: type) !void {
var x: T = -3.14;
var y: T = 5.27;
_ = .{ &x, &y };
try expectEqual(x, @min(x, y));
try expectEqual(x, @min(y, x));
try expectEqual(y, @max(x, y));
@ -126,6 +135,7 @@ test "@min/max for floats" {
if (T != comptime_float) {
var nan: T = std.math.nan(T);
_ = &nan;
try expectEqual(y, @max(nan, y));
try expectEqual(y, @max(y, nan));
}
@ -175,6 +185,7 @@ test "@min/@max notices bounds" {
var x: u16 = 20;
const y = 30;
var z: u32 = 100;
_ = .{ &x, &z };
const min = @min(x, y, z);
const max = @max(x, y, z);
try expectEqual(x, min);
@ -194,6 +205,7 @@ test "@min/@max notices vector bounds" {
var x: @Vector(2, u16) = .{ 140, 40 };
const y: @Vector(2, u64) = .{ 5, 100 };
var z: @Vector(2, u32) = .{ 10, 300 };
_ = .{ &x, &z };
const min = @min(x, y, z);
const max = @max(x, y, z);
try expectEqual(@Vector(2, u32){ 5, 40 }, min);
@ -224,6 +236,7 @@ test "@min/@max notices bounds from types" {
var x: u16 = 123;
var y: u32 = 456;
var z: u8 = 10;
_ = .{ &x, &y, &z };
const min = @min(x, y, z);
const max = @max(x, y, z);
@ -246,6 +259,7 @@ test "@min/@max notices bounds from vector types" {
var x: @Vector(2, u16) = .{ 30, 67 };
var y: @Vector(2, u32) = .{ 20, 500 };
var z: @Vector(2, u8) = .{ 60, 15 };
_ = .{ &x, &y, &z };
const min = @min(x, y, z);
const max = @max(x, y, z);
@ -263,6 +277,7 @@ test "@min/@max notices bounds from types when comptime-known value is undef" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: u32 = 1_000_000;
_ = &x;
const y: u16 = undefined;
// y is comptime-known, but is undef, so bounds cannot be refined using its value
@ -285,6 +300,7 @@ test "@min/@max notices bounds from vector types when element of comptime-known
!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx)) return error.SkipZigTest;
var x: @Vector(2, u32) = .{ 1_000_000, 12345 };
_ = &x;
const y: @Vector(2, u16) = .{ 10, undefined };
// y is comptime-known, but an element is undef, so bounds cannot be refined using its value
@ -302,6 +318,7 @@ test "@min/@max notices bounds from vector types when element of comptime-known
test "@min/@max of signed and unsigned runtime integers" {
var x: i32 = -1;
var y: u31 = 1;
_ = .{ &x, &y };
const min = @min(x, y);
const max = @max(x, y);

1
test/behavior/memcpy.zig
View File

@ -57,6 +57,7 @@ fn testMemcpyDestManyPtr() !void {
var str = "hello".*;
var buf: [5]u8 = undefined;
var len: usize = 5;
_ = &len;
@memcpy(@as([*]u8, @ptrCast(&buf)), @as([*]const u8, @ptrCast(&str))[0..len]);
try expect(buf[0] == 'h');
try expect(buf[1] == 'e');

7
test/behavior/memset.zig
View File

@ -46,7 +46,8 @@ fn testMemsetSlice() !void {
// memset slice to non-undefined, ABI size == 1
var array: [20]u8 = undefined;
var len = array.len;
var slice = array[0..len];
_ = &len;
const slice = array[0..len];
@memset(slice, 'A');
try expect(slice[0] == 'A');
try expect(slice[11] == 'A');
@ -56,7 +57,8 @@ fn testMemsetSlice() !void {
// memset slice to non-undefined, ABI size > 1
var array: [20]u32 = undefined;
var len = array.len;
var slice = array[0..len];
_ = &len;
const slice = array[0..len];
@memset(slice, 1234);
try expect(slice[0] == 1234);
try expect(slice[11] == 1234);
@ -111,6 +113,7 @@ test "memset with large array element, runtime known" {
const A = [128]u64;
var buf: [5]A = undefined;
var runtime_known_element = [_]u64{0} ** 128;
_ = &runtime_known_element;
@memset(&buf, runtime_known_element);
for (buf[0]) |elem| try expect(elem == 0);
for (buf[1]) |elem| try expect(elem == 0);

20
test/behavior/muladd.zig
View File

@ -21,12 +21,14 @@ fn testMulAdd() !void {
var a: f32 = 5.5;
var b: f32 = 2.5;
var c: f32 = 6.25;
_ = .{ &a, &b, &c };
try expect(@mulAdd(f32, a, b, c) == 20);
}
{
var a: f64 = 5.5;
var b: f64 = 2.5;
var c: f64 = 6.25;
_ = .{ &a, &b, &c };
try expect(@mulAdd(f64, a, b, c) == 20);
}
}
@ -46,6 +48,7 @@ fn testMulAdd16() !void {
var a: f16 = 5.5;
var b: f16 = 2.5;
var c: f16 = 6.25;
_ = .{ &a, &b, &c };
try expect(@mulAdd(f16, a, b, c) == 20);
}
@ -65,6 +68,7 @@ fn testMulAdd80() !void {
var a: f16 = 5.5;
var b: f80 = 2.5;
var c: f80 = 6.25;
_ = .{ &a, &b, &c };
try expect(@mulAdd(f80, a, b, c) == 20);
}
@ -84,6 +88,7 @@ fn testMulAdd128() !void {
var a: f16 = 5.5;
var b: f128 = 2.5;
var c: f128 = 6.25;
_ = .{ &a, &b, &c };
try expect(@mulAdd(f128, a, b, c) == 20);
}
@ -91,7 +96,8 @@ fn vector16() !void {
var a = @Vector(4, f16){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f16){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f16){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f16), a, b, c);
_ = .{ &a, &b, &c };
const x = @mulAdd(@Vector(4, f16), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);
@ -115,7 +121,8 @@ fn vector32() !void {
var a = @Vector(4, f32){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f32){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f32){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f32), a, b, c);
_ = .{ &a, &b, &c };
const x = @mulAdd(@Vector(4, f32), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);
@ -139,7 +146,8 @@ fn vector64() !void {
var a = @Vector(4, f64){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f64){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f64){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f64), a, b, c);
_ = .{ &a, &b, &c };
const x = @mulAdd(@Vector(4, f64), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);
@ -163,7 +171,8 @@ fn vector80() !void {
var a = @Vector(4, f80){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f80){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f80){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f80), a, b, c);
_ = .{ &a, &b, &c };
const x = @mulAdd(@Vector(4, f80), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);
try expect(x[2] == 20);
@ -187,7 +196,8 @@ fn vector128() !void {
var a = @Vector(4, f128){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f128){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f128){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f128), a, b, c);
_ = .{ &a, &b, &c };
const x = @mulAdd(@Vector(4, f128), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);

1
test/behavior/null.zig
View File

@ -134,6 +134,7 @@ test "optional pointer to 0 bit type null value at runtime" {
const EmptyStruct = struct {};
var x: ?*EmptyStruct = null;
_ = &x;
try expect(x == null);
}

19
test/behavior/optional.zig
View File

@ -11,7 +11,7 @@ test "passing an optional integer as a parameter" {
const S = struct {
fn entry() bool {
var x: i32 = 1234;
const x: i32 = 1234;
return foo(x);
}
@ -29,7 +29,7 @@ test "optional pointer to size zero struct" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var e = EmptyStruct{};
var o: ?*EmptyStruct = &e;
const o: ?*EmptyStruct = &e;
try expect(o != null);
}
@ -63,6 +63,7 @@ test "optional with void type" {
x: ?void,
};
var x = Foo{ .x = null };
_ = &x;
try expect(x.x == null);
}
@ -102,6 +103,7 @@ test "nested optional field in struct" {
var s = S1{
.x = S2{ .y = 127 },
};
_ = &s;
try expect(s.x.?.y == 127);
}
@ -120,6 +122,8 @@ fn test_cmp_optional_non_optional() !void {
var five: i32 = 5;
var int_n: ?i32 = null;
_ = .{ &ten, &opt_ten, &five, &int_n };
try expect(int_n != ten);
try expect(opt_ten == ten);
try expect(opt_ten != five);
@ -208,7 +212,7 @@ test "self-referential struct through a slice of optional" {
};
};
var n = S.Node.new();
const n = S.Node.new();
try expect(n.data == null);
}
@ -252,7 +256,7 @@ test "0-bit child type coerced to optional return ptr result location" {
const S = struct {
fn doTheTest() !void {
var y = Foo{};
var z = y.thing();
const z = y.thing();
try expect(z != null);
}
@ -425,6 +429,7 @@ test "alignment of wrapping an optional payload" {
fn foo() ?I {
var i: I = .{ .x = 1234 };
_ = &i;
return i;
}
};
@ -450,15 +455,16 @@ test "peer type resolution in nested if expressions" {
const Thing = struct { n: i32 };
var a = false;
var b = false;
_ = .{ &a, &b };
var result1 = if (a)
const result1 = if (a)
Thing{ .n = 1 }
else
null;
try expect(result1 == null);
try expect(@TypeOf(result1) == ?Thing);
var result2 = if (a)
const result2 = if (a)
Thing{ .n = 0 }
else if (b)
Thing{ .n = 1 }
@ -486,5 +492,6 @@ test "cast slice to const slice nested in error union and optional" {
test "variable of optional of noreturn" {
var null_opv: ?noreturn = null;
_ = &null_opv;
try std.testing.expectEqual(@as(?noreturn, null), null_opv);
}

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

@ -479,10 +479,9 @@ test "load pointer from packed struct" {
y: u32,
};
var a: A = .{ .index = 123 };
var b_list: []const B = &.{.{ .x = &a, .y = 99 }};
const b_list: []const B = &.{.{ .x = &a, .y = 99 }};
for (b_list) |b| {
var i = b.x.index;
try expect(i == 123);
try expect(b.x.index == 123);
}
}
@ -770,6 +769,7 @@ test "nested packed struct field access test" {
};
var arg = a{ .b = hld{ .c = 1, .d = 2 }, .g = mld{ .h = 6, .i = 8 } };
_ = &arg;
try std.testing.expect(arg.b.c == 1);
try std.testing.expect(arg.b.d == 2);
try std.testing.expect(arg.g.h == 6);
@ -790,6 +790,7 @@ test "nested packed struct at non-zero offset" {
};
var k: u8 = 123;
_ = &k;
var v: A = .{
.p1 = .{ .a = k + 1, .b = k },
.p2 = .{ .a = k + 1, .b = k },
@ -833,6 +834,7 @@ test "nested packed struct at non-zero offset 2" {
fn doTheTest() !void {
var k: u8 = 123;
_ = &k;
var v: A = .{
.p1 = .{ .a = k + 1, .b = k },
.p2 = .{ .a = k + 1, .b = k },
@ -877,6 +879,7 @@ test "runtime init of unnamed packed struct type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var z: u8 = 123;
_ = &z;
try (packed struct {
x: u8,
pub fn m(s: @This()) !void {
@ -941,6 +944,7 @@ test "packed struct initialized in bitcast" {
const T = packed struct { val: u8 };
var val: u8 = 123;
_ = &val;
const t = @as(u8, @bitCast(T{ .val = val }));
try expect(t == val);
}
@ -976,7 +980,8 @@ test "store undefined to packed result location" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u4 = 0;
var s = packed struct { x: u4, y: u4 }{ .x = x, .y = if (x > 0) x else undefined };
_ = &x;
const s = packed struct { x: u4, y: u4 }{ .x = x, .y = if (x > 0) x else undefined };
try expectEqual(x, s.x);
}
@ -1004,7 +1009,7 @@ test "field access of packed struct smaller than its abi size inside struct init
}
};
var s = S.init(true);
const s = S.init(true);
// note: this bug is triggered by the == operator, expectEqual will hide it
try expect(@as(i2, 0) == s.ps.x);
try expect(@as(i2, 1) == s.ps.y);

60
test/behavior/pointers.zig
View File

@ -11,7 +11,7 @@ test "dereference pointer" {
fn testDerefPtr() !void {
var x: i32 = 1234;
var y = &x;
const y = &x;
y.* += 1;
try expect(x == 1235);
}
@ -53,8 +53,8 @@ test "implicit cast single item pointer to C pointer and back" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var y: u8 = 11;
var x: [*c]u8 = &y;
var z: *u8 = x;
const x: [*c]u8 = &y;
const z: *u8 = x;
z.* += 1;
try expect(y == 12);
}
@ -74,6 +74,7 @@ test "assigning integer to C pointer" {
var ptr2: [*c]u8 = x;
var ptr3: [*c]u8 = 1;
var ptr4: [*c]u8 = y;
_ = .{ &x, &y, &ptr, &ptr2, &ptr3, &ptr4 };
try expect(ptr == ptr2);
try expect(ptr3 == ptr4);
@ -88,6 +89,7 @@ test "C pointer comparison and arithmetic" {
fn doTheTest() !void {
var ptr1: [*c]u32 = 0;
var ptr2 = ptr1 + 10;
_ = &ptr1;
try expect(ptr1 == 0);
try expect(ptr1 >= 0);
try expect(ptr1 <= 0);
@ -125,14 +127,15 @@ fn testDerefPtrOneVal() !void {
}
test "peer type resolution with C pointers" {
var ptr_one: *u8 = undefined;
var ptr_many: [*]u8 = undefined;
var ptr_c: [*c]u8 = undefined;
const ptr_one: *u8 = undefined;
const ptr_many: [*]u8 = undefined;
const ptr_c: [*c]u8 = undefined;
var t = true;
var x1 = if (t) ptr_one else ptr_c;
var x2 = if (t) ptr_many else ptr_c;
var x3 = if (t) ptr_c else ptr_one;
var x4 = if (t) ptr_c else ptr_many;
_ = &t;
const x1 = if (t) ptr_one else ptr_c;
const x2 = if (t) ptr_many else ptr_c;
const x3 = if (t) ptr_c else ptr_one;
const x4 = if (t) ptr_c else ptr_many;
try expect(@TypeOf(x1) == [*c]u8);
try expect(@TypeOf(x2) == [*c]u8);
try expect(@TypeOf(x3) == [*c]u8);
@ -141,8 +144,9 @@ test "peer type resolution with C pointers" {
test "peer type resolution with C pointer and const pointer" {
var ptr_c: [*c]u8 = undefined;
const ptr_const: u8 = undefined;
try expect(@TypeOf(ptr_c, &ptr_const) == [*c]const u8);
var ptr_const: *const u8 = &undefined;
_ = .{ &ptr_c, &ptr_const };
try expect(@TypeOf(ptr_c, ptr_const) == [*c]const u8);
}
test "implicit casting between C pointer and optional non-C pointer" {
@ -151,9 +155,10 @@ test "implicit casting between C pointer and optional non-C pointer" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var slice: []const u8 = "aoeu";
_ = &slice;
const opt_many_ptr: ?[*]const u8 = slice.ptr;
var ptr_opt_many_ptr = &opt_many_ptr;
var c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr;
const c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr;
try expect(c_ptr.*.* == 'a');
ptr_opt_many_ptr = c_ptr;
try expect(ptr_opt_many_ptr.*.?[1] == 'o');
@ -192,11 +197,12 @@ test "allowzero pointer and slice" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var ptr = @as([*]allowzero i32, @ptrFromInt(0));
var opt_ptr: ?[*]allowzero i32 = ptr;
var ptr: [*]allowzero i32 = @ptrFromInt(0);
const opt_ptr: ?[*]allowzero i32 = ptr;
try expect(opt_ptr != null);
try expect(@intFromPtr(ptr) == 0);
var runtime_zero: usize = 0;
_ = &runtime_zero;
var slice = ptr[runtime_zero..10];
try comptime expect(@TypeOf(slice) == []allowzero i32);
try expect(@intFromPtr(&slice[5]) == 20);
@ -211,6 +217,7 @@ test "assign null directly to C pointer and test null equality" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: [*c]i32 = null;
_ = &x;
try expect(x == null);
try expect(null == x);
try expect(!(x != null));
@ -236,7 +243,7 @@ test "assign null directly to C pointer and test null equality" {
try comptime expect((y orelse ptr_othery) == ptr_othery);
var n: i32 = 1234;
var x1: [*c]i32 = &n;
const x1: [*c]i32 = &n;
try expect(!(x1 == null));
try expect(!(null == x1));
try expect(x1 != null);
@ -279,9 +286,9 @@ test "null terminated pointer" {
const S = struct {
fn doTheTest() !void {
var array_with_zero = [_:0]u8{ 'h', 'e', 'l', 'l', 'o' };
var zero_ptr: [*:0]const u8 = @as([*:0]const u8, @ptrCast(&array_with_zero));
var no_zero_ptr: [*]const u8 = zero_ptr;
var zero_ptr_again = @as([*:0]const u8, @ptrCast(no_zero_ptr));
const zero_ptr: [*:0]const u8 = @ptrCast(&array_with_zero);
const no_zero_ptr: [*]const u8 = zero_ptr;
const zero_ptr_again: [*:0]const u8 = @ptrCast(no_zero_ptr);
try expect(std.mem.eql(u8, std.mem.sliceTo(zero_ptr_again, 0), "hello"));
}
};
@ -296,7 +303,7 @@ test "allow any sentinel" {
const S = struct {
fn doTheTest() !void {
var array = [_:std.math.minInt(i32)]i32{ 1, 2, 3, 4 };
var ptr: [*:std.math.minInt(i32)]i32 = &array;
const ptr: [*:std.math.minInt(i32)]i32 = &array;
try expect(ptr[4] == std.math.minInt(i32));
}
};
@ -317,6 +324,7 @@ test "pointer sentinel with enums" {
fn doTheTest() !void {
var ptr: [*:.sentinel]const Number = &[_:.sentinel]Number{ .one, .two, .two, .one };
_ = &ptr;
try expect(ptr[4] == .sentinel); // TODO this should be try comptime expect, see #3731
}
};
@ -332,6 +340,7 @@ test "pointer sentinel with optional element" {
const S = struct {
fn doTheTest() !void {
var ptr: [*:null]const ?i32 = &[_:null]?i32{ 1, 2, 3, 4 };
_ = &ptr;
try expect(ptr[4] == null); // TODO this should be try comptime expect, see #3731
}
};
@ -348,6 +357,7 @@ test "pointer sentinel with +inf" {
fn doTheTest() !void {
const inf_f32 = comptime std.math.inf(f32);
var ptr: [*:inf_f32]const f32 = &[_:inf_f32]f32{ 1.1, 2.2, 3.3, 4.4 };
_ = &ptr;
try expect(ptr[4] == inf_f32); // TODO this should be try comptime expect, see #3731
}
};
@ -366,6 +376,7 @@ test "pointer arithmetic affects the alignment" {
{
var ptr: [*]align(8) u32 = undefined;
var x: usize = 1;
_ = .{ &ptr, &x };
try expect(@typeInfo(@TypeOf(ptr)).Pointer.alignment == 8);
const ptr1 = ptr + 1; // 1 * 4 = 4 -> lcd(4,8) = 4
@ -380,6 +391,7 @@ test "pointer arithmetic affects the alignment" {
{
var ptr: [*]align(8) [3]u8 = undefined;
var x: usize = 1;
_ = .{ &ptr, &x };
const ptr1 = ptr + 17; // 3 * 17 = 51
try expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 1);
@ -467,8 +479,8 @@ test "array slicing to slice" {
const S = struct {
fn doTheTest() !void {
var str: [5]i32 = [_]i32{ 1, 2, 3, 4, 5 };
var sub: *[2]i32 = str[1..3];
var slice: []i32 = sub; // used to cause failures
const sub: *[2]i32 = str[1..3];
const slice: []i32 = sub; // used to cause failures
try testing.expect(slice.len == 2);
try testing.expect(slice[0] == 2);
}
@ -495,7 +507,8 @@ test "ptrCast comptime known slice to C pointer" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
const s: [:0]const u8 = "foo";
var p = @as([*c]const u8, @ptrCast(s));
var p: [*c]const u8 = @ptrCast(s);
_ = &p;
try std.testing.expectEqualStrings(s, std.mem.sliceTo(p, 0));
}
@ -527,6 +540,7 @@ test "pointer to array has explicit alignment" {
test "result type preserved through multiple references" {
const S = struct { x: u32 };
var my_u64: u64 = 12345;
_ = &my_u64;
const foo: *const *const *const S = &&&.{
.x = @intCast(my_u64),
};

10
test/behavior/popcount.zig
View File

@ -26,6 +26,7 @@ test "@popCount 128bit integer" {
{
var x: u128 = 0b11111111000110001100010000100001000011000011100101010001;
_ = &x;
try expect(@popCount(x) == 24);
}
@ -35,30 +36,37 @@ test "@popCount 128bit integer" {
fn testPopCountIntegers() !void {
{
var x: u32 = 0xffffffff;
_ = &x;
try expect(@popCount(x) == 32);
}
{
var x: u5 = 0x1f;
_ = &x;
try expect(@popCount(x) == 5);
}
{
var x: u32 = 0xaa;
_ = &x;
try expect(@popCount(x) == 4);
}
{
var x: u32 = 0xaaaaaaaa;
_ = &x;
try expect(@popCount(x) == 16);
}
{
var x: u32 = 0xaaaaaaaa;
_ = &x;
try expect(@popCount(x) == 16);
}
{
var x: i16 = -1;
_ = &x;
try expect(@popCount(x) == 16);
}
{
var x: i8 = -120;
_ = &x;
try expect(@popCount(x) == 2);
}
comptime {
@ -81,12 +89,14 @@ test "@popCount vectors" {
fn testPopCountVectors() !void {
{
var x: @Vector(8, u32) = [1]u32{0xffffffff} ** 8;
_ = &x;
const expected = [1]u6{32} ** 8;
const result: [8]u6 = @popCount(x);
try expect(std.mem.eql(u6, &expected, &result));
}
{
var x: @Vector(8, i16) = [1]i16{-1} ** 8;
_ = &x;
const expected = [1]u5{16} ** 8;
const result: [8]u5 = @popCount(x);
try expect(std.mem.eql(u5, &expected, &result));

1
test/behavior/prefetch.zig
View File

@ -6,6 +6,7 @@ test "@prefetch()" {
var a: [2]u32 = .{ 42, 42 };
var a_len = a.len;
_ = &a_len;
@prefetch(&a, .{});

28
test/behavior/ptrcast.zig
View File

@ -71,8 +71,8 @@ fn testReinterpretBytesAsExternStruct() !void {
c: u8,
};
var ptr = @as(*const S, @ptrCast(&bytes));
var val = ptr.c;
const ptr: *const S = @ptrCast(&bytes);
const val = ptr.c;
try expect(val == 5);
}
@ -95,8 +95,8 @@ fn testReinterpretExternStructAsExternStruct() !void {
a: u32 align(2),
c: u8,
};
var ptr = @as(*const S2, @ptrCast(&bytes));
var val = ptr.c;
const ptr: *const S2 = @ptrCast(&bytes);
const val = ptr.c;
try expect(val == 5);
}
@ -121,8 +121,8 @@ fn testReinterpretOverAlignedExternStructAsExternStruct() !void {
a2: u16,
c: u8,
};
var ptr = @as(*const S2, @ptrCast(&bytes));
var val = ptr.c;
const ptr: *const S2 = @ptrCast(&bytes);
const val = ptr.c;
try expect(val == 5);
}
@ -138,13 +138,13 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
c: u8,
};
comptime var ptr = @as(*const S, @ptrCast(&bytes));
var val = &ptr.c;
const val = &ptr.c;
try expect(val.* == 5);
// Test lowering an elem ptr
comptime var src_value = S{ .a = 15, .c = 5 };
comptime var ptr2 = @as(*[@sizeOf(S)]u8, @ptrCast(&src_value));
var val2 = &ptr2[4];
const val2 = &ptr2[4];
try expect(val2.* == 5);
}
@ -160,13 +160,13 @@ test "lower reinterpreted comptime field ptr" {
c: u8,
};
comptime var ptr = @as(*const S, @ptrCast(&bytes));
var val = &ptr.c;
const val = &ptr.c;
try expect(val.* == 5);
// Test lowering an elem ptr
comptime var src_value = S{ .a = 15, .c = 5 };
comptime var ptr2 = @as(*[@sizeOf(S)]u8, @ptrCast(&src_value));
var val2 = &ptr2[4];
const val2 = &ptr2[4];
try expect(val2.* == 5);
}
@ -233,9 +233,9 @@ test "implicit optional pointer to optional anyopaque pointer" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
var buf: [4]u8 = "aoeu".*;
var x: ?[*]u8 = &buf;
var y: ?*anyopaque = x;
var z = @as(*[4]u8, @ptrCast(y));
const x: ?[*]u8 = &buf;
const y: ?*anyopaque = x;
const z: *[4]u8 = @ptrCast(y);
try expect(std.mem.eql(u8, z, "aoeu"));
}
@ -276,7 +276,7 @@ test "@ptrCast undefined value at comptime" {
}
};
comptime {
var x = S.transmute([]u8, i32, undefined);
const x = S.transmute([]u8, i32, undefined);
_ = x;
}
}

1
test/behavior/ptrfromint.zig
View File

@ -9,6 +9,7 @@ test "casting integer address to function pointer" {
fn addressToFunction() void {
var addr: usize = 0xdeadbee0;
_ = &addr;
_ = @as(*const fn () void, @ptrFromInt(addr));
}

2
test/behavior/saturating_arithmetic.zig
View File

@ -246,9 +246,11 @@ test "saturating shl uses the LHS type" {
const lhs_const: u8 = 1;
var lhs_var: u8 = 1;
_ = &lhs_var;
const rhs_const: usize = 8;
var rhs_var: usize = 8;
_ = &rhs_var;
try expect((lhs_const <<| 8) == 255);
try expect((lhs_const <<| rhs_const) == 255);

12
test/behavior/select.zig
View File

@ -19,7 +19,8 @@ fn selectVectors() !void {
var a = @Vector(4, bool){ true, false, true, false };
var b = @Vector(4, i32){ -1, 4, 999, -31 };
var c = @Vector(4, i32){ -5, 1, 0, 1234 };
var abc = @select(i32, a, b, c);
_ = .{ &a, &b, &c };
const abc = @select(i32, a, b, c);
try expect(abc[0] == -1);
try expect(abc[1] == 1);
try expect(abc[2] == 999);
@ -28,7 +29,8 @@ fn selectVectors() !void {
var x = @Vector(4, bool){ false, false, false, true };
var y = @Vector(4, f32){ 0.001, 33.4, 836, -3381.233 };
var z = @Vector(4, f32){ 0.0, 312.1, -145.9, 9993.55 };
var xyz = @select(f32, x, y, z);
_ = .{ &x, &y, &z };
const xyz = @select(f32, x, y, z);
try expect(mem.eql(f32, &@as([4]f32, xyz), &[4]f32{ 0.0, 312.1, -145.9, -3381.233 }));
}
@ -48,7 +50,8 @@ fn selectArrays() !void {
var a = [4]bool{ false, true, false, true };
var b = [4]usize{ 0, 1, 2, 3 };
var c = [4]usize{ 4, 5, 6, 7 };
var abc = @select(usize, a, b, c);
_ = .{ &a, &b, &c };
const abc = @select(usize, a, b, c);
try expect(abc[0] == 4);
try expect(abc[1] == 1);
try expect(abc[2] == 6);
@ -57,6 +60,7 @@ fn selectArrays() !void {
var x = [4]bool{ false, false, false, true };
var y = [4]f32{ 0.001, 33.4, 836, -3381.233 };
var z = [4]f32{ 0.0, 312.1, -145.9, 9993.55 };
var xyz = @select(f32, x, y, z);
_ = .{ &x, &y, &z };
const xyz = @select(f32, x, y, z);
try expect(mem.eql(f32, &@as([4]f32, xyz), &[4]f32{ 0.0, 312.1, -145.9, -3381.233 }));
}

12
test/behavior/shuffle.zig
View File

@ -13,7 +13,9 @@ test "@shuffle int" {
const S = struct {
fn doTheTest() !void {
var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
_ = &v;
var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
_ = &x;
const mask = [4]i32{ 0, ~@as(i32, 2), 3, ~@as(i32, 3) };
var res = @shuffle(i32, v, x, mask);
try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 40, 4 }));
@ -29,12 +31,14 @@ test "@shuffle int" {
// Upcasting of b
var v2: @Vector(2, i32) = [2]i32{ 2147483647, undefined };
_ = &v2;
const mask3 = [4]i32{ ~@as(i32, 0), 2, ~@as(i32, 0), 3 };
res = @shuffle(i32, x, v2, mask3);
try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 2147483647, 4 }));
// Upcasting of a
var v3: @Vector(2, i32) = [2]i32{ 2147483647, -2 };
_ = &v3;
const mask4 = [4]i32{ 0, ~@as(i32, 2), 1, ~@as(i32, 3) };
res = @shuffle(i32, v3, x, mask4);
try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, -2, 4 }));
@ -55,9 +59,11 @@ test "@shuffle bool 1" {
const S = struct {
fn doTheTest() !void {
var x: @Vector(4, bool) = [4]bool{ false, true, false, true };
_ = &x;
var v: @Vector(2, bool) = [2]bool{ true, false };
_ = &v;
const mask = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
var res = @shuffle(bool, x, v, mask);
const res = @shuffle(bool, x, v, mask);
try expect(mem.eql(bool, &@as([4]bool, res), &[4]bool{ false, false, true, false }));
}
};
@ -81,9 +87,11 @@ test "@shuffle bool 2" {
const S = struct {
fn doTheTest() !void {
var x: @Vector(3, bool) = [3]bool{ false, true, false };
_ = &x;
var v: @Vector(2, bool) = [2]bool{ true, false };
_ = &v;
const mask = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
var res = @shuffle(bool, x, v, mask);
const res = @shuffle(bool, x, v, mask);
try expect(mem.eql(bool, &@as([4]bool, res), &[4]bool{ false, false, true, false }));
}
};

6
test/behavior/sizeof_and_typeof.zig
View File

@ -22,20 +22,24 @@ test "@TypeOf() with multiple arguments" {
var var_1: u32 = undefined;
var var_2: u8 = undefined;
var var_3: u64 = undefined;
_ = .{ &var_1, &var_2, &var_3 };
try comptime expect(@TypeOf(var_1, var_2, var_3) == u64);
}
{
var var_1: f16 = undefined;
var var_2: f32 = undefined;
var var_3: f64 = undefined;
_ = .{ &var_1, &var_2, &var_3 };
try comptime expect(@TypeOf(var_1, var_2, var_3) == f64);
}
{
var var_1: u16 = undefined;
_ = &var_1;
try comptime expect(@TypeOf(var_1, 0xffff) == u16);
}
{
var var_1: f32 = undefined;
_ = &var_1;
try comptime expect(@TypeOf(var_1, 3.1415) == f32);
}
}
@ -269,6 +273,7 @@ test "runtime instructions inside typeof in comptime only scope" {
{
var y: i8 = 2;
_ = &y;
const i: [2]i8 = [_]i8{ 1, y };
const T = struct {
a: @TypeOf(i) = undefined, // causes crash
@ -279,6 +284,7 @@ test "runtime instructions inside typeof in comptime only scope" {
}
{
var y: i8 = 2;
_ = &y;
const i = .{ 1, y };
const T = struct {
b: @TypeOf(i[1]) = undefined,

76
test/behavior/slice.zig
View File

@ -23,7 +23,7 @@ comptime {
};
const unsigned = [_]type{ c_uint, c_ulong, c_ulonglong };
const list: []const type = &unsigned;
var pos = S.indexOfScalar(type, list, c_ulong).?;
const pos = S.indexOfScalar(type, list, c_ulong).?;
if (pos != 1) @compileError("bad pos");
}
@ -36,13 +36,14 @@ test "slicing" {
var slice = array[5..10];
if (slice.len != 5) unreachable;
try expect(slice.len == 5);
const ptr = &slice[0];
if (ptr.* != 1234) unreachable;
try expect(ptr.* == 1234);
var slice_rest = array[10..];
if (slice_rest.len != 10) unreachable;
_ = &slice_rest;
try expect(slice_rest.len == 10);
}
test "const slice" {
@ -79,7 +80,7 @@ test "access len index of sentinel-terminated slice" {
const S = struct {
fn doTheTest() !void {
var slice: [:0]const u8 = "hello";
_ = &slice;
try expect(slice.len == 5);
try expect(slice[5] == 0);
}
@ -208,6 +209,7 @@ test "slice string literal has correct type" {
try expect(@TypeOf(array[0..]) == *const [4]i32);
}
var runtime_zero: usize = 0;
_ = &runtime_zero;
try comptime expect(@TypeOf("aoeu"[runtime_zero..]) == [:0]const u8);
const array = [_]i32{ 1, 2, 3, 4 };
try comptime expect(@TypeOf(array[runtime_zero..]) == []const i32);
@ -219,7 +221,8 @@ test "result location zero sized array inside struct field implicit cast to slic
const E = struct {
entries: []u32,
};
var foo = E{ .entries = &[_]u32{} };
var foo: E = .{ .entries = &[_]u32{} };
_ = &foo;
try expect(foo.entries.len == 0);
}
@ -242,7 +245,8 @@ test "C pointer" {
var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
var len: u32 = 10;
var slice = buf[0..len];
_ = &len;
const slice = buf[0..len];
try expect(mem.eql(u8, "kjdhfkjdhf", slice));
}
@ -255,6 +259,7 @@ test "C pointer slice access" {
const c_ptr = @as([*c]const u32, @ptrCast(&buf));
var runtime_zero: usize = 0;
_ = &runtime_zero;
try comptime expectEqual([]const u32, @TypeOf(c_ptr[runtime_zero..1]));
try comptime expectEqual(*const [1]u32, @TypeOf(c_ptr[0..1]));
@ -306,11 +311,13 @@ test "obtaining a null terminated slice" {
_ = ptr;
var runtime_len: usize = 3;
_ = &runtime_len;
const ptr2 = buf[0..runtime_len :0];
// ptr2 is a null-terminated slice
try comptime expect(@TypeOf(ptr2) == [:0]u8);
try comptime expect(@TypeOf(ptr2[0..2]) == *[2]u8);
var runtime_zero: usize = 0;
_ = &runtime_zero;
try comptime expect(@TypeOf(ptr2[runtime_zero..2]) == []u8);
}
@ -338,8 +345,8 @@ test "@ptrCast slice to pointer" {
const S = struct {
fn doTheTest() !void {
var array align(@alignOf(u16)) = [5]u8{ 0xff, 0xff, 0xff, 0xff, 0xff };
var slice: []align(@alignOf(u16)) u8 = &array;
var ptr = @as(*u16, @ptrCast(slice));
const slice: []align(@alignOf(u16)) u8 = &array;
const ptr: *u16 = @ptrCast(slice);
try expect(ptr.* == 65535);
}
};
@ -357,8 +364,8 @@ test "slice multi-pointer without end" {
fn testPointer() !void {
var array = [5]u8{ 1, 2, 3, 4, 5 };
var pointer: [*]u8 = &array;
var slice = pointer[1..];
const pointer: [*]u8 = &array;
const slice = pointer[1..];
try comptime expect(@TypeOf(slice) == [*]u8);
try expect(slice[0] == 2);
try expect(slice[1] == 3);
@ -366,13 +373,13 @@ test "slice multi-pointer without end" {
fn testPointerZ() !void {
var array = [5:0]u8{ 1, 2, 3, 4, 5 };
var pointer: [*:0]u8 = &array;
const pointer: [*:0]u8 = &array;
try comptime expect(@TypeOf(pointer[1..3]) == *[2]u8);
try comptime expect(@TypeOf(pointer[1..3 :4]) == *[2:4]u8);
try comptime expect(@TypeOf(pointer[1..5 :0]) == *[4:0]u8);
var slice = pointer[1..];
const slice = pointer[1..];
try comptime expect(@TypeOf(slice) == [*:0]u8);
try expect(slice[0] == 2);
try expect(slice[1] == 3);
@ -413,7 +420,7 @@ test "slice syntax resulting in pointer-to-array" {
fn testArray() !void {
var array = [5]u8{ 1, 2, 3, 4, 5 };
var slice = array[1..3];
const slice = array[1..3];
try comptime expect(@TypeOf(slice) == *[2]u8);
try expect(slice[0] == 2);
try expect(slice[1] == 3);
@ -430,12 +437,12 @@ test "slice syntax resulting in pointer-to-array" {
fn testArray0() !void {
{
var array = [0]u8{};
var slice = array[0..0];
const slice = array[0..0];
try comptime expect(@TypeOf(slice) == *[0]u8);
}
{
var array = [0:0]u8{};
var slice = array[0..0];
const slice = array[0..0];
try comptime expect(@TypeOf(slice) == *[0:0]u8);
try expect(slice[0] == 0);
}
@ -443,7 +450,7 @@ test "slice syntax resulting in pointer-to-array" {
fn testArrayAlign() !void {
var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };
var slice = array[4..5];
const slice = array[4..5];
try comptime expect(@TypeOf(slice) == *align(4) [1]u8);
try expect(slice[0] == 5);
try comptime expect(@TypeOf(array[0..2]) == *align(4) [2]u8);
@ -452,7 +459,7 @@ test "slice syntax resulting in pointer-to-array" {
fn testPointer() !void {
var array = [5]u8{ 1, 2, 3, 4, 5 };
var pointer: [*]u8 = &array;
var slice = pointer[1..3];
const slice = pointer[1..3];
try comptime expect(@TypeOf(slice) == *[2]u8);
try expect(slice[0] == 2);
try expect(slice[1] == 3);
@ -467,7 +474,7 @@ test "slice syntax resulting in pointer-to-array" {
fn testPointer0() !void {
var pointer: [*]const u0 = &[1]u0{0};
var slice = pointer[0..1];
const slice = pointer[0..1];
try comptime expect(@TypeOf(slice) == *const [1]u0);
try expect(slice[0] == 0);
}
@ -475,7 +482,7 @@ test "slice syntax resulting in pointer-to-array" {
fn testPointerAlign() !void {
var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };
var pointer: [*]align(4) u8 = &array;
var slice = pointer[4..5];
const slice = pointer[4..5];
try comptime expect(@TypeOf(slice) == *align(4) [1]u8);
try expect(slice[0] == 5);
try comptime expect(@TypeOf(pointer[0..2]) == *align(4) [2]u8);
@ -484,7 +491,7 @@ test "slice syntax resulting in pointer-to-array" {
fn testSlice() !void {
var array = [5]u8{ 1, 2, 3, 4, 5 };
var src_slice: []u8 = &array;
var slice = src_slice[1..3];
const slice = src_slice[1..3];
try comptime expect(@TypeOf(slice) == *[2]u8);
try expect(slice[0] == 2);
try expect(slice[1] == 3);
@ -513,7 +520,7 @@ test "slice syntax resulting in pointer-to-array" {
fn testSliceAlign() !void {
var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };
var src_slice: []align(4) u8 = &array;
var slice = src_slice[4..5];
const slice = src_slice[4..5];
try comptime expect(@TypeOf(slice) == *align(4) [1]u8);
try expect(slice[0] == 5);
try comptime expect(@TypeOf(src_slice[0..2]) == *align(4) [2]u8);
@ -616,13 +623,13 @@ test "slice pointer-to-array zero length" {
{
var array = [0]u8{};
var src_slice: []u8 = &array;
var slice = src_slice[0..0];
const slice = src_slice[0..0];
try expect(@TypeOf(slice) == *[0]u8);
}
{
var array = [0:0]u8{};
var src_slice: [:0]u8 = &array;
var slice = src_slice[0..0];
const slice = src_slice[0..0];
try expect(@TypeOf(slice) == *[0:0]u8);
}
}
@ -630,13 +637,13 @@ test "slice pointer-to-array zero length" {
{
var array = [0]u8{};
var src_slice: []u8 = &array;
var slice = src_slice[0..0];
const slice = src_slice[0..0];
try comptime expect(@TypeOf(slice) == *[0]u8);
}
{
var array = [0:0]u8{};
var src_slice: [:0]u8 = &array;
var slice = src_slice[0..0];
const slice = src_slice[0..0];
try comptime expect(@TypeOf(slice) == *[0]u8);
}
}
@ -655,17 +662,19 @@ test "type coercion of pointer to anon struct literal to pointer to slice" {
fn doTheTest() !void {
var x1: u8 = 42;
_ = &x1;
const t1 = &.{ x1, 56, 54 };
var slice1: []const u8 = t1;
const slice1: []const u8 = t1;
try expect(slice1.len == 3);
try expect(slice1[0] == 42);
try expect(slice1[1] == 56);
try expect(slice1[2] == 54);
var x2: []const u8 = "hello";
_ = &x2;
const t2 = &.{ x2, ", ", "world!" };
// @compileLog(@TypeOf(t2));
var slice2: []const []const u8 = t2;
const slice2: []const []const u8 = t2;
try expect(slice2.len == 3);
try expect(mem.eql(u8, slice2[0], "hello"));
try expect(mem.eql(u8, slice2[1], ", "));
@ -680,6 +689,7 @@ test "array concat of slices gives ptr to array" {
comptime {
var a: []const u8 = "aoeu";
var b: []const u8 = "asdf";
_ = .{ &a, &b };
const c = a ++ b;
try expect(std.mem.eql(u8, c, "aoeuasdf"));
try expect(@TypeOf(c) == *const [8]u8);
@ -689,6 +699,7 @@ test "array concat of slices gives ptr to array" {
test "array mult of slice gives ptr to array" {
comptime {
var a: []const u8 = "aoeu";
_ = &a;
const c = a ** 2;
try expect(std.mem.eql(u8, c, "aoeuaoeu"));
try expect(@TypeOf(c) == *const [8]u8);
@ -736,7 +747,7 @@ test "slicing array with sentinel as end index" {
const S = struct {
fn do() !void {
var array = [_:0]u8{ 1, 2, 3, 4 };
var slice = array[4..5];
const slice = array[4..5];
try expect(slice.len == 1);
try expect(slice[0] == 0);
try expect(@TypeOf(slice) == *[1]u8);
@ -754,8 +765,8 @@ test "slicing slice with sentinel as end index" {
const S = struct {
fn do() !void {
var array = [_:0]u8{ 1, 2, 3, 4 };
var src_slice: [:0]u8 = &array;
var slice = src_slice[4..5];
const src_slice: [:0]u8 = &array;
const slice = src_slice[4..5];
try expect(slice.len == 1);
try expect(slice[0] == 0);
try expect(@TypeOf(slice) == *[1]u8);
@ -820,6 +831,7 @@ test "global slice field access" {
test "slice of void" {
var n: usize = 10;
_ = &n;
var arr: [12]void = undefined;
const slice = @as([]void, &arr)[0..n];
try expect(slice.len == n);
@ -827,7 +839,7 @@ test "slice of void" {
test "slice with dereferenced value" {
var a: usize = 0;
var idx: *usize = &a;
const idx: *usize = &a;
_ = blk: {
var array = [_]u8{};
break :blk array[idx.*..];

65
test/behavior/struct.zig
View File

@ -254,7 +254,8 @@ test "struct field init with catch" {
const S = struct {
fn doTheTest() !void {
var x: anyerror!isize = 1;
var req = Foo{
_ = &x;
const req = Foo{
.field = x catch undefined,
};
try expect(req.field == 1);
@ -505,7 +506,7 @@ test "packed struct fields are ordered from LSB to MSB" {
var all: u64 = 0x7765443322221111;
var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined;
@memcpy(bytes[0..8], @as([*]u8, @ptrCast(&all)));
var bitfields = @as(*Bitfields, @ptrCast(&bytes)).*;
const bitfields = @as(*Bitfields, @ptrCast(&bytes)).*;
try expect(bitfields.f1 == 0x1111);
try expect(bitfields.f2 == 0x2222);
@ -545,7 +546,7 @@ test "zero-bit field in packed struct" {
y: void,
};
var x: S = undefined;
_ = x;
_ = &x;
}
test "packed struct with non-ABI-aligned field" {
@ -624,6 +625,7 @@ test "default struct initialization fields" {
.b = 5,
};
var five: i32 = 5;
_ = &five;
const y = S{
.b = five,
};
@ -714,7 +716,7 @@ test "pointer to packed struct member in a stack variable" {
};
var s = S{ .a = 2, .b = 0 };
var b_ptr = &s.b;
const b_ptr = &s.b;
try expect(s.b == 0);
b_ptr.* = 2;
try expect(s.b == 2);
@ -727,6 +729,7 @@ test "packed struct with u0 field access" {
f0: u0,
};
var s = S{ .f0 = 0 };
_ = &s;
try comptime expect(s.f0 == 0);
}
@ -788,7 +791,7 @@ test "fn with C calling convention returns struct by value" {
const S = struct {
fn entry() !void {
var x = makeBar(10);
const x = makeBar(10);
try expect(@as(i32, 10) == x.handle);
}
@ -827,6 +830,7 @@ test "non-packed struct with u128 entry in union" {
var s = &sx;
try expect(@intFromPtr(&s.f2) - @intFromPtr(&s.f1) == @offsetOf(S, "f2"));
var v2 = U{ .Num = 123 };
_ = &v2;
s.f2 = v2;
try expect(s.f2.Num == 123);
}
@ -852,7 +856,7 @@ test "packed struct field passed to generic function" {
var p: S.P = undefined;
p.b = 29;
var loaded = S.genericReadPackedField(&p.b);
const loaded = S.genericReadPackedField(&p.b);
try expect(loaded == 29);
}
@ -871,6 +875,7 @@ test "anonymous struct literal syntax" {
.x = 1,
.y = 2,
};
_ = &p;
try expect(p.x == 1);
try expect(p.y == 2);
}
@ -920,6 +925,7 @@ test "fully anonymous list literal" {
test "tuple assigned to variable" {
var vec = .{ @as(i32, 22), @as(i32, 55), @as(i32, 99) };
_ = &vec;
try expect(vec.@"0" == 22);
try expect(vec.@"1" == 55);
try expect(vec.@"2" == 99);
@ -940,6 +946,7 @@ test "comptime struct field" {
comptime std.debug.assert(@sizeOf(T) == 4);
var foo: T = undefined;
_ = &foo;
try comptime expect(foo.b == 1234);
}
@ -950,7 +957,7 @@ test "tuple element initialized with fn call" {
const S = struct {
fn doTheTest() !void {
var x = .{foo()};
const x = .{foo()};
try expectEqualSlices(u8, x[0], "hi");
}
fn foo() []const u8 {
@ -977,6 +984,7 @@ test "struct with union field" {
var True = Value{
.kind = .{ .Bool = true },
};
_ = &True;
try expect(@as(u32, 2) == True.ref);
try expect(True.kind.Bool);
}
@ -996,6 +1004,7 @@ test "struct with 0-length union array field" {
};
var s: S = undefined;
_ = &s;
try expectEqual(@as(usize, 0), s.zero_length.len);
}
@ -1019,10 +1028,11 @@ test "type coercion of anon struct literal to struct" {
fn doTheTest() !void {
var y: u32 = 42;
_ = &y;
const t0 = .{ .A = 123, .B = "foo", .C = {} };
const t1 = .{ .A = y, .B = "foo", .C = {} };
const y0: S2 = t0;
var y1: S2 = t1;
const y1: S2 = t1;
try expect(y0.A == 123);
try expect(std.mem.eql(u8, y0.B, "foo"));
try expect(y0.C == {});
@ -1057,10 +1067,11 @@ test "type coercion of pointer to anon struct literal to pointer to struct" {
fn doTheTest() !void {
var y: u32 = 42;
_ = &y;
const t0 = &.{ .A = 123, .B = "foo", .C = {} };
const t1 = &.{ .A = y, .B = "foo", .C = {} };
const y0: *const S2 = t0;
var y1: *const S2 = t1;
const y1: *const S2 = t1;
try expect(y0.A == 123);
try expect(std.mem.eql(u8, y0.B, "foo"));
try expect(y0.C == {});
@ -1161,8 +1172,8 @@ test "anon init through error unions and optionals" {
}
fn doTheTest() !void {
var a = try (try foo()).?;
var b = try bar().?;
const a = try (try foo()).?;
const b = try bar().?;
try expect(a.a + b[1] == 3);
}
};
@ -1227,8 +1238,8 @@ test "typed init through error unions and optionals" {
}
fn doTheTest() !void {
var a = try (try foo()).?;
var b = try bar().?;
const a = try (try foo()).?;
const b = try bar().?;
try expect(a.a + b[1] == 3);
}
};
@ -1243,6 +1254,7 @@ test "initialize struct with empty literal" {
const S = struct { x: i32 = 1234 };
var s: S = .{};
_ = &s;
try expect(s.x == 1234);
}
@ -1301,10 +1313,10 @@ test "packed struct field access via pointer" {
fn doTheTest() !void {
const S = packed struct { a: u30 };
var s1: S = .{ .a = 1 };
var s2 = &s1;
const s2 = &s1;
try expect(s2.a == 1);
var s3: S = undefined;
var s4 = &s3;
const s4 = &s3;
_ = s4;
}
};
@ -1343,6 +1355,7 @@ test "struct field init value is size of the struct" {
};
};
var s: namespace.S = .{ .blah = 1234 };
_ = &s;
try expect(s.size == 4);
}
@ -1362,6 +1375,7 @@ test "under-aligned struct field" {
data: U align(4),
};
var runtime: usize = 1234;
_ = &runtime;
const ptr = &S{ .events = 0, .data = .{ .u64 = runtime } };
const array = @as(*const [12]u8, @ptrCast(ptr));
const result = std.mem.readInt(u64, array[4..12], native_endian);
@ -1509,6 +1523,7 @@ test "function pointer in struct returns the struct" {
}
};
var a = A.f();
_ = &a;
try expect(a.f == A.f);
}
@ -1538,7 +1553,8 @@ test "optional field init with tuple" {
a: ?struct { b: u32 },
};
var a: u32 = 0;
var b = S{
_ = &a;
const b = S{
.a = .{ .b = a },
};
try expect(b.a.?.b == a);
@ -1550,7 +1566,8 @@ test "if inside struct init inside if" {
const MyStruct = struct { x: u32 };
const b: u32 = 5;
var i: u32 = 1;
var my_var = if (i < 5)
_ = &i;
const my_var = if (i < 5)
MyStruct{
.x = 1 + if (i > 0) b else 0,
}
@ -1599,7 +1616,7 @@ test "instantiate struct with comptime field" {
var things = struct {
comptime foo: i8 = 1,
}{};
_ = &things;
comptime std.debug.assert(things.foo == 1);
}
@ -1608,7 +1625,7 @@ test "instantiate struct with comptime field" {
comptime foo: i8 = 1,
};
var things = T{};
_ = &things;
comptime std.debug.assert(things.foo == 1);
}
@ -1616,7 +1633,7 @@ test "instantiate struct with comptime field" {
var things: struct {
comptime foo: i8 = 1,
} = .{};
_ = &things;
comptime std.debug.assert(things.foo == 1);
}
@ -1624,7 +1641,7 @@ test "instantiate struct with comptime field" {
var things: struct {
comptime foo: i8 = 1,
} = undefined; // Segmentation fault at address 0x0
_ = &things;
comptime std.debug.assert(things.foo == 1);
}
}
@ -1755,6 +1772,7 @@ test "runtime side-effects in comptime-known struct init" {
test "pointer to struct initialized through reference to anonymous initializer provides result types" {
const S = struct { a: u8, b: u16, c: *const anyopaque };
var my_u16: u16 = 0xABCD;
_ = &my_u16;
const s: *const S = &.{
// intentionally out of order
.c = @ptrCast("hello"),
@ -1792,6 +1810,7 @@ test "initializer uses own alignment" {
};
var s: S = .{};
_ = &s;
try expectEqual(4, @alignOf(S));
try expectEqual(@as(usize, 5), s.x);
}
@ -1802,6 +1821,7 @@ test "initializer uses own size" {
};
var s: S = .{};
_ = &s;
try expectEqual(4, @sizeOf(S));
try expectEqual(@as(usize, 5), s.x);
}
@ -1815,6 +1835,7 @@ test "initializer takes a pointer to a variable inside its struct" {
fn doTheTest() !void {
var foo: S = .{};
_ = &foo;
try expectEqual(&S.instance, foo.s);
}
};
@ -1839,6 +1860,7 @@ test "circular dependency through pointer field of a struct" {
};
};
var outer: S.StructOuter = .{};
_ = &outer;
try expect(outer.middle.outer == null);
try expect(outer.middle.inner == null);
}
@ -1855,5 +1877,6 @@ test "field calls do not force struct field init resolution" {
}
};
var s: S = .{};
_ = &s;
try expect(s.x == 123);
}

1
test/behavior/struct_contains_null_ptr_itself.zig
View File

@ -7,6 +7,7 @@ test "struct contains null pointer which contains original struct" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: ?*NodeLineComment = null;
_ = &x;
try expect(x == null);
}

26
test/behavior/switch.zig
View File

@ -157,6 +157,7 @@ fn testSwitchOnBoolsFalseWithElse(x: bool) bool {
test "u0" {
var val: u0 = 0;
_ = &val;
switch (val) {
0 => try expect(val == 0),
}
@ -164,6 +165,7 @@ test "u0" {
test "undefined.u0" {
var val: u0 = undefined;
_ = &val;
switch (val) {
0 => try expect(val == 0),
}
@ -173,6 +175,7 @@ test "switch with disjoint range" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var q: u8 = 0;
_ = &q;
switch (q) {
0...125 => {},
127...255 => {},
@ -183,12 +186,8 @@ test "switch with disjoint range" {
test "switch variable for range and multiple prongs" {
const S = struct {
fn doTheTest() !void {
var u: u8 = 16;
try doTheSwitch(u);
try comptime doTheSwitch(u);
var v: u8 = 42;
try doTheSwitch(v);
try comptime doTheSwitch(v);
try doTheSwitch(16);
try doTheSwitch(42);
}
fn doTheSwitch(q: u8) !void {
switch (q) {
@ -198,7 +197,8 @@ test "switch variable for range and multiple prongs" {
}
}
};
_ = S;
try S.doTheTest();
try comptime S.doTheTest();
}
var state: u32 = 0;
@ -322,7 +322,8 @@ test "switch on union with some prongs capturing" {
};
var x: X = X{ .b = 10 };
var y: i32 = switch (x) {
_ = &x;
const y: i32 = switch (x) {
.a => unreachable,
.b => |b| b + 1,
};
@ -357,6 +358,7 @@ test "anon enum literal used in switch on union enum" {
};
var foo = Foo{ .a = 1234 };
_ = &foo;
switch (foo) {
.a => |x| {
try expect(x == 1234);
@ -406,6 +408,7 @@ test "switch on integer with else capturing expr" {
const S = struct {
fn doTheTest() !void {
var x: i32 = 5;
_ = &x;
switch (x + 10) {
14 => @panic("fail"),
16 => @panic("fail"),
@ -606,6 +609,7 @@ 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;
@ -672,7 +676,8 @@ test "enum value without tag name used as switch item" {
b = 2,
_,
};
var e: E = @as(E, @enumFromInt(0));
var e: E = @enumFromInt(0);
_ = &e;
switch (e) {
@as(E, @enumFromInt(0)) => {},
.a => return error.TestFailed,
@ -685,6 +690,7 @@ test "switch item sizeof" {
const S = struct {
fn doTheTest() !void {
var a: usize = 0;
_ = &a;
switch (a) {
@sizeOf(struct {}) => {},
else => return error.TestFailed,
@ -699,6 +705,7 @@ 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,
};
@ -814,6 +821,7 @@ test "peer type resolution on switch captures ignores unused payload bits" {
// 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

29
test/behavior/truncate.zig
View File

@ -4,58 +4,62 @@ const expect = std.testing.expect;
test "truncate u0 to larger integer allowed and has comptime-known result" {
var x: u0 = 0;
_ = &x;
const y = @as(u8, @truncate(x));
try comptime expect(y == 0);
}
test "truncate.u0.literal" {
var z = @as(u0, @truncate(0));
const z: u0 = @truncate(0);
try expect(z == 0);
}
test "truncate.u0.const" {
const c0: usize = 0;
var z = @as(u0, @truncate(c0));
const z: u0 = @truncate(c0);
try expect(z == 0);
}
test "truncate.u0.var" {
var d: u8 = 2;
var z = @as(u0, @truncate(d));
_ = &d;
const z: u0 = @truncate(d);
try expect(z == 0);
}
test "truncate i0 to larger integer allowed and has comptime-known result" {
var x: i0 = 0;
const y = @as(i8, @truncate(x));
_ = &x;
const y: i8 = @truncate(x);
try comptime expect(y == 0);
}
test "truncate.i0.literal" {
var z = @as(i0, @truncate(0));
const z: i0 = @truncate(0);
try expect(z == 0);
}
test "truncate.i0.const" {
const c0: isize = 0;
var z = @as(i0, @truncate(c0));
const z: i0 = @truncate(c0);
try expect(z == 0);
}
test "truncate.i0.var" {
var d: i8 = 2;
var z = @as(i0, @truncate(d));
_ = &d;
const z: i0 = @truncate(d);
try expect(z == 0);
}
test "truncate on comptime integer" {
var x = @as(u16, @truncate(9999));
const x: u16 = @truncate(9999);
try expect(x == 9999);
var y = @as(u16, @truncate(-21555));
const y: u16 = @truncate(-21555);
try expect(y == 0xabcd);
var z = @as(i16, @truncate(-65537));
const z: i16 = @truncate(-65537);
try expect(z == -1);
var w = @as(u1, @truncate(1 << 100));
const w: u1 = @truncate(1 << 100);
try expect(w == 0);
}
@ -69,7 +73,8 @@ test "truncate on vectors" {
const S = struct {
fn doTheTest() !void {
var v1: @Vector(4, u16) = .{ 0xaabb, 0xccdd, 0xeeff, 0x1122 };
var v2: @Vector(4, u8) = @truncate(v1);
_ = &v1;
const v2: @Vector(4, u8) = @truncate(v1);
try expect(std.mem.eql(u8, &@as([4]u8, v2), &[4]u8{ 0xbb, 0xdd, 0xff, 0x22 }));
}
};

33
test/behavior/tuple.zig
View File

@ -15,9 +15,10 @@ test "tuple concatenation" {
fn doTheTest() !void {
var a: i32 = 1;
var b: i32 = 2;
var x = .{a};
var y = .{b};
var c = x ++ y;
_ = .{ &a, &b };
const x = .{a};
const y = .{b};
const c = x ++ y;
try expect(@as(i32, 1) == c[0]);
try expect(@as(i32, 2) == c[1]);
}
@ -119,7 +120,7 @@ test "tuple initializer for var" {
.id = @as(usize, 2),
.name = Bytes{ .id = 20 },
};
_ = tmp;
_ = &tmp;
}
};
@ -157,6 +158,7 @@ test "array-like initializer for tuple types" {
const S = struct {
fn doTheTest() !void {
var obj: T = .{ -1234, 128 };
_ = &obj;
try expect(@as(i32, -1234) == obj[0]);
try expect(@as(u8, 128) == obj[1]);
}
@ -171,6 +173,7 @@ test "anon struct as the result from a labeled block" {
fn doTheTest() !void {
const precomputed = comptime blk: {
var x: i32 = 1234;
_ = &x;
break :blk .{
.x = x,
};
@ -188,6 +191,7 @@ test "tuple as the result from a labeled block" {
fn doTheTest() !void {
const precomputed = comptime blk: {
var x: i32 = 1234;
_ = &x;
break :blk .{x};
};
try expect(precomputed[0] == 1234);
@ -201,13 +205,13 @@ test "tuple as the result from a labeled block" {
test "initializing tuple with explicit type" {
const T = @TypeOf(.{ @as(i32, 0), @as(u32, 0) });
var a = T{ 0, 0 };
_ = a;
_ = &a;
}
test "initializing anon struct with explicit type" {
const T = @TypeOf(.{ .foo = @as(i32, 1), .bar = @as(i32, 2) });
var a = T{ .foo = 1, .bar = 2 };
_ = a;
_ = &a;
}
test "fieldParentPtr of tuple" {
@ -216,6 +220,7 @@ test "fieldParentPtr of tuple" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: u32 = 0;
_ = &x;
const tuple = .{ x, x };
try testing.expect(&tuple == @fieldParentPtr(@TypeOf(tuple), "1", &tuple[1]));
}
@ -226,18 +231,21 @@ test "fieldParentPtr of anon struct" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: u32 = 0;
_ = &x;
const anon_st = .{ .foo = x, .bar = x };
try testing.expect(&anon_st == @fieldParentPtr(@TypeOf(anon_st), "bar", &anon_st.bar));
}
test "offsetOf tuple" {
var x: u32 = 0;
_ = &x;
const T = @TypeOf(.{ x, x });
try expect(@offsetOf(T, "1") == @sizeOf(u32));
}
test "offsetOf anon struct" {
var x: u32 = 0;
_ = &x;
const T = @TypeOf(.{ .foo = x, .bar = x });
try expect(@offsetOf(T, "bar") == @sizeOf(u32));
}
@ -247,8 +255,10 @@ test "initializing tuple with mixed comptime-runtime fields" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u32 = 15;
_ = &x;
const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });
var a: T = .{ -1234, 5678, x + 1 };
_ = &a;
try expect(a[2] == 16);
}
@ -257,8 +267,10 @@ test "initializing anon struct with mixed comptime-runtime fields" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u32 = 15;
_ = &x;
const T = @TypeOf(.{ .foo = @as(i32, -1234), .bar = x });
var a: T = .{ .foo = -1234, .bar = x + 1 };
_ = &a;
try expect(a.bar == 16);
}
@ -338,6 +350,7 @@ test "tuple type with void field and a runtime field" {
const T = std.meta.Tuple(&[_]type{ usize, void });
var t: T = .{ 5, {} };
_ = &t;
try expect(t[0] == 5);
}
@ -352,6 +365,7 @@ test "branching inside tuple literal" {
}
};
var a = false;
_ = &a;
try S.foo(.{if (a) @as(u32, 5678) else @as(u32, 1234)});
}
@ -363,6 +377,7 @@ test "tuple initialized with a runtime known value" {
const E = union(enum) { e: []const u8 };
const W = union(enum) { w: E };
var e = E{ .e = "test" };
_ = &e;
const w = .{W{ .w = e }};
try expectEqualStrings(w[0].w.e, "test");
}
@ -388,6 +403,7 @@ test "nested runtime conditionals in tuple initializer" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var data: u8 = 0;
_ = &data;
const x = .{
if (data != 0) "" else switch (@as(u1, @truncate(data))) {
0 => "up",
@ -446,8 +462,9 @@ test "coerce anon tuple to tuple" {
var x: u8 = 1;
var y: u16 = 2;
var t = .{ x, y };
var s: struct { u8, u16 } = t;
_ = .{ &x, &y };
const t = .{ x, y };
const s: struct { u8, u16 } = t;
try expectEqual(x, s[0]);
try expectEqual(y, s[1]);
}

6
test/behavior/tuple_declarations.zig
View File

@ -38,17 +38,19 @@ test "Tuple declaration usage" {
const T = struct { u32, []const u8 };
var t: T = .{ 1, "foo" };
_ = &t;
try expect(t[0] == 1);
try expectEqualStrings(t[1], "foo");
var mul = t ** 3;
const mul = t ** 3;
try expect(@TypeOf(mul) != T);
try expect(mul.len == 6);
try expect(mul[2] == 1);
try expectEqualStrings(mul[3], "foo");
var t2: T = .{ 2, "bar" };
var cat = t ++ t2;
_ = &t2;
const cat = t ++ t2;
try expect(@TypeOf(cat) != T);
try expect(cat.len == 4);
try expect(cat[2] == 2);

5
test/behavior/type.zig
View File

@ -410,7 +410,8 @@ test "Type.Union" {
.decls = &.{},
},
});
var packed_untagged = PackedUntagged{ .signed = -1 };
var packed_untagged: PackedUntagged = .{ .signed = -1 };
_ = &packed_untagged;
try testing.expectEqual(@as(i32, -1), packed_untagged.signed);
try testing.expectEqual(~@as(u32, 0), packed_untagged.unsigned);
@ -529,7 +530,7 @@ test "reified struct field name from optional payload" {
.decls = &.{},
.is_tuple = false,
} });
var t: T = .{ .a = 123 };
const t: T = .{ .a = 123 };
try std.testing.expect(t.a == 123);
}
}

2
test/behavior/type_info.zig
View File

@ -417,7 +417,7 @@ test "typeInfo with comptime parameter in struct fn def" {
}
};
comptime var info = @typeInfo(S);
_ = info;
_ = &info;
}
test "type info: vectors" {

51
test/behavior/union.zig
View File

@ -171,6 +171,7 @@ test "constant tagged union with payload" {
var empty = TaggedUnionWithPayload{ .Empty = {} };
var full = TaggedUnionWithPayload{ .Full = 13 };
_ = .{ &empty, &full };
shouldBeEmpty(empty);
shouldBeNotEmpty(full);
}
@ -254,6 +255,7 @@ fn bar(value: Payload) error{TestUnexpectedResult}!i32 {
fn testComparison() !void {
var x = Payload{ .A = 42 };
_ = &x;
try expect(x == .A);
try expect(x != .B);
try expect(x != .C);
@ -288,6 +290,7 @@ test "cast union to tag type of union" {
fn testCastUnionToTag() !void {
var u = TheUnion{ .B = 1234 };
_ = &u;
try expect(@as(TheTag, u) == TheTag.B);
}
@ -303,6 +306,7 @@ test "cast tag type of union to union" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: Value2 = Letter2.B;
_ = &x;
try expect(@as(Letter2, x) == Letter2.B);
}
const Letter2 = enum { A, B, C };
@ -318,6 +322,7 @@ test "implicit cast union to its tag type" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: Value2 = Letter2.B;
_ = &x;
try expect(x == Letter2.B);
try giveMeLetterB(x);
}
@ -356,6 +361,7 @@ test "simple union(enum(u32))" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x = MultipleChoice.C;
_ = &x;
try expect(x == MultipleChoice.C);
try expect(@intFromEnum(@as(Tag(MultipleChoice), x)) == 60);
}
@ -420,9 +426,11 @@ test "union with only 1 field casted to its enum type" {
};
var e = Expr{ .Literal = Literal{ .Bool = true } };
_ = &e;
const ExprTag = Tag(Expr);
try comptime expect(Tag(ExprTag) == u0);
var t = @as(ExprTag, e);
_ = &t;
try expect(t == Expr.Literal);
}
@ -494,6 +502,7 @@ test "union initializer generates padding only if needed" {
};
var v = U{ .A = 532 };
_ = &v;
try expect(v.A == 532);
}
@ -506,6 +515,7 @@ test "runtime tag name with single field" {
};
var v = U{ .A = 42 };
_ = &v;
try expect(std.mem.eql(u8, @tagName(v), "A"));
}
@ -698,8 +708,9 @@ test "union with only 1 field casted to its enum type which has enum value speci
};
var e = Expr{ .Literal = Literal{ .Bool = true } };
_ = &e;
try comptime expect(Tag(ExprTag) == comptime_int);
comptime var t = @as(ExprTag, e);
const t = comptime @as(ExprTag, e);
try expect(t == Expr.Literal);
try expect(@intFromEnum(t) == 33);
try comptime expect(@intFromEnum(t) == 33);
@ -719,6 +730,7 @@ test "@intFromEnum works on unions" {
const a = Bar{ .A = true };
var b = Bar{ .B = undefined };
var c = Bar.C;
_ = .{ &b, &c };
try expect(@intFromEnum(a) == 0);
try expect(@intFromEnum(b) == 1);
try expect(@intFromEnum(c) == 2);
@ -800,11 +812,13 @@ test "@unionInit stored to a const" {
fn doTheTest() !void {
{
var t = true;
_ = &t;
const u = @unionInit(U, "boolean", t);
try expect(u.boolean);
}
{
var byte: u8 = 69;
_ = &byte;
const u = @unionInit(U, "byte", byte);
try expect(u.byte == 69);
}
@ -849,7 +863,7 @@ test "@unionInit can modify a pointer value" {
};
var value: UnionInitEnum = undefined;
var value_ptr = &value;
const value_ptr = &value;
value_ptr.* = @unionInit(UnionInitEnum, "Boolean", true);
try expect(value.Boolean == true);
@ -906,7 +920,8 @@ test "anonymous union literal syntax" {
fn doTheTest() !void {
var i: Number = .{ .int = 42 };
var f = makeNumber();
_ = &i;
const f = makeNumber();
try expect(i.int == 42);
try expect(f.float == 12.34);
}
@ -934,9 +949,11 @@ test "function call result coerces from tagged union to the tag" {
fn doTheTest() !void {
var x: ArchTag = getArch1();
_ = &x;
try expect(x == .One);
var y: ArchTag = getArch2();
_ = &y;
try expect(y == .Two);
}
@ -965,14 +982,17 @@ test "cast from anonymous struct to union" {
};
fn doTheTest() !void {
var y: u32 = 42;
_ = &y;
const t0 = .{ .A = 123 };
const t1 = .{ .B = "foo" };
const t2 = .{ .C = {} };
const t3 = .{ .A = y };
const x0: U = t0;
var x1: U = t1;
_ = &x1;
const x2: U = t2;
var x3: U = t3;
_ = &x3;
try expect(x0.A == 123);
try expect(std.mem.eql(u8, x1.B, "foo"));
try expect(x2 == .C);
@ -996,14 +1016,17 @@ test "cast from pointer to anonymous struct to pointer to union" {
};
fn doTheTest() !void {
var y: u32 = 42;
_ = &y;
const t0 = &.{ .A = 123 };
const t1 = &.{ .B = "foo" };
const t2 = &.{ .C = {} };
const t3 = &.{ .A = y };
const x0: *const U = t0;
var x1: *const U = t1;
_ = &x1;
const x2: *const U = t2;
var x3: *const U = t3;
_ = &x3;
try expect(x0.A == 123);
try expect(std.mem.eql(u8, x1.B, "foo"));
try expect(x2.* == .C);
@ -1031,6 +1054,7 @@ test "switching on non exhaustive union" {
};
fn doTheTest() !void {
var a = U{ .a = 2 };
_ = &a;
switch (a) {
.a => |val| try expect(val == 2),
.b => return error.Fail,
@ -1055,11 +1079,13 @@ test "containers with single-field enums" {
fn doTheTest() !void {
var array1 = [1]A{A{ .f1 = {} }};
var array2 = [1]B{B{ .f1 = {} }};
_ = .{ &array1, &array2 };
try expect(array1[0] == .f1);
try expect(array2[0] == .f1);
var struct1 = C{ .a = A{ .f1 = {} } };
var struct2 = D{ .a = B{ .f1 = {} } };
_ = .{ &struct1, &struct2 };
try expect(struct1.a == .f1);
try expect(struct2.a == .f1);
}
@ -1092,8 +1118,9 @@ test "@unionInit on union with tag but no fields" {
fn doTheTest() !void {
var data: Data = .{ .no_op = {} };
_ = data;
_ = &data;
var o = Data.decode(&[_]u8{});
_ = &o;
try expectEqual(Type.no_op, o);
}
};
@ -1156,6 +1183,7 @@ test "union with no result loc initiated with a runtime value" {
}
};
var a: u32 = 1;
_ = &a;
U.foo(U{ .a = a });
}
@ -1174,6 +1202,7 @@ test "union with a large struct field" {
fn foo(_: @This()) void {}
};
var s: S = undefined;
_ = &s;
U.foo(U{ .s = s });
}
@ -1207,6 +1236,7 @@ test "union tag is set when initiated as a temporary value at runtime" {
}
};
var b: u32 = 1;
_ = &b;
try (U{ .b = b }).doTheTest();
}
@ -1226,6 +1256,7 @@ test "extern union most-aligned field is smaller" {
un: [110]u8,
};
var a: ?U = .{ .un = [_]u8{0} ** 110 };
_ = &a;
try expect(a != null);
}
@ -1246,6 +1277,7 @@ test "return an extern union from C calling convention" {
fn bar(arg_u: U) callconv(.C) U {
var u = arg_u;
_ = &u;
return u;
}
};
@ -1324,13 +1356,16 @@ test "@unionInit uses tag value instead of field index" {
a: usize,
};
var i: isize = -1;
_ = &i;
var u = @unionInit(U, "b", i);
{
var a = u.b;
_ = &a;
try expect(a == i);
}
{
var a = &u.b;
_ = &a;
try expect(a.* == i);
}
try expect(@intFromEnum(u) == 255);
@ -1508,7 +1543,7 @@ test "coerce enum literal to union in result loc" {
b: u8,
fn doTest(c: bool) !void {
var u = if (c) .a else @This(){ .b = 0 };
const u = if (c) .a else @This(){ .b = 0 };
try expect(u == .a);
}
};
@ -1947,6 +1982,7 @@ test "packed union initialized via reintepreted struct field initializer" {
};
var s: S = .{};
_ = &s;
try expect(s.u.a == littleToNativeEndian(u32, 0xddccbbaa));
try expect(s.u.b == if (endian == .little) 0xaa else 0xdd);
}
@ -1966,6 +2002,7 @@ test "store of comptime reinterpreted memory to extern union" {
};
var u: U = reinterpreted;
_ = &u;
try expect(u.a == littleToNativeEndian(u32, 0xddccbbaa));
try expect(u.b == 0xaa);
}
@ -1985,6 +2022,7 @@ test "store of comptime reinterpreted memory to packed union" {
};
var u: U = reinterpreted;
_ = &u;
try expect(u.a == littleToNativeEndian(u32, 0xddccbbaa));
try expect(u.b == if (endian == .little) 0xaa else 0xdd);
}
@ -2018,6 +2056,7 @@ test "pass register-sized field as non-register-sized union" {
};
var x: usize = 42;
_ = &x;
try S.taggedUnion(.{ .x = x });
try S.untaggedUnion(.{ .x = x });
try S.externUnion(.{ .x = x });
@ -2039,6 +2078,7 @@ test "circular dependency through pointer field of a union" {
};
};
var outer: S.UnionOuter = .{};
_ = &outer;
try expect(outer.u.outer == null);
try expect(outer.u.inner == null);
}
@ -2057,5 +2097,6 @@ test "pass nested union with rls" {
};
var c: u7 = 32;
_ = &c;
try expectEqual(@as(u7, 32), Union.getC(.{ .b = .{ .c = c } }));
}

1
test/behavior/var_args.zig
View File

@ -147,6 +147,7 @@ test "simple variadic function" {
var runtime: bool = true;
var a: i32 = 1;
var b: i32 = 2;
_ = .{ &runtime, &a, &b };
try expect(1 == S.add(1, if (runtime) a else b));
}
}

Some files were not shown because too many files have changed in this diff Show More