Commit 5a02c938dafdf2bb11b2350b6ad3161ef93744f0 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-04-29 15:18:40-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-04-29 15:18:40-07:00
log	5a02c938dafdf2bb11b2350b6ad3161ef93744f0
tree	63c0746488454eefe6d604c5c821915b28c6d83d
parent	eb53680bce5fe14363c4282fac08caaa3d220c5f

update behavior tests with respect to new builtin pkg

18 files changed, 69 insertions(+), 56 deletions(-)

BRANCH_TODO
test
- stage1
  - behavior.zig
  - behavior
    align.zig
    alignof.zig
    atomics.zig
    bitcast.zig
    bugs
    1421.zig
    6456.zig
    cast.zig
    eval.zig
    fn.zig
    ptrcast.zig
    shuffle.zig
    struct.zig
    type.zig
    type_info.zig
    vector.zig
    widening.zig

BRANCH_TODO+4

...	...	@@ -48,6 +48,10 @@
48	48	* AstGen: add result location pointers to function calls
49	49	* nested function decl: how to refer to params?
50	50
	51	* fix the commented out behavior test regarding function alignment
	52	- not sure why this happened, it's stage1 code??
	53	- search the behavior test diff for "TODO"
	54
51	55	fn getAnonTypeName(mod: Module, scope: Scope, base_token: std.zig.ast.TokenIndex) ![]u8 {
52	56	// TODO add namespaces, generic function signatrues
53	57	const tree = scope.tree();

test/stage1/behavior.zig+1-1

...	...	@@ -142,7 +142,7 @@ comptime {
142	142	_ = @import("behavior/var_args.zig");
143	143	_ = @import("behavior/vector.zig");
144	144	_ = @import("behavior/void.zig");
145		if (builtin.arch == .wasm32) {
	145	if (builtin.target.cpu.arch == .wasm32) {
146	146	_ = @import("behavior/wasm.zig");
147	147	}
148	148	_ = @import("behavior/while.zig");

test/stage1/behavior/align.zig+6-5

...	...	@@ -1,6 +1,7 @@
1	1	const std = @import("std");
2	2	const expect = std.testing.expect;
3	3	const builtin = @import("builtin");
	4	const native_arch = builtin.target.cpu.arch;
4	5
5	6	var foo: u8 align(4) = 100;
6	7
...	...	@@ -26,7 +27,7 @@ fn noop4() align(4) void {}
26	27
27	28	test "function alignment" {
28	29	// function alignment is a compile error on wasm32/wasm64
29		if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
	30	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
30	31
31	32	expect(derp() == 1234);
32	33	expect(@TypeOf(noop1) == fn () align(1) void);
...	...	@@ -121,7 +122,7 @@ fn sliceExpects4(slice: []align(4) u32) void {
121	122
122	123	test "implicitly decreasing fn alignment" {
123	124	// function alignment is a compile error on wasm32/wasm64
124		if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
	125	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
125	126
126	127	testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
127	128	testImplicitlyDecreaseFnAlign(alignedBig, 5678);
...	...	@@ -140,7 +141,7 @@ fn alignedBig() align(16) i32 {
140	141
141	142	test "@alignCast functions" {
142	143	// function alignment is a compile error on wasm32/wasm64
143		if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
	144	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
144	145
145	146	expect(fnExpectsOnly1(simple4) == 0x19);
146	147	}
...	...	@@ -156,7 +157,7 @@ fn simple4() align(4) i32 {
156	157
157	158	test "generic function with align param" {
158	159	// function alignment is a compile error on wasm32/wasm64
159		if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
	160	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
160	161
161	162	expect(whyWouldYouEverDoThis(1) == 0x1);
162	163	expect(whyWouldYouEverDoThis(4) == 0x1);
...	...	@@ -337,7 +338,7 @@ test "align(@alignOf(T)) T does not force resolution of T" {
337	338
338	339	test "align(N) on functions" {
339	340	// function alignment is a compile error on wasm32/wasm64
340		if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
	341	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
341	342
342	343	expect((@ptrToInt(overaligned_fn) & (0x1000 - 1)) == 0);
343	344	}

test/stage1/behavior/alignof.zig+2-1

...	...	@@ -1,6 +1,7 @@
1	1	const std = @import("std");
2	2	const expect = std.testing.expect;
3	3	const builtin = @import("builtin");
	4	const native_arch = builtin.target.cpu.arch;
4	5	const maxInt = std.math.maxInt;
5	6
6	7	const Foo = struct {
...	...	@@ -11,7 +12,7 @@ const Foo = struct {
11	12
12	13	test "@alignOf(T) before referencing T" {
13	14	comptime expect(@alignOf(Foo) != maxInt(usize));
14		if (builtin.arch == builtin.Arch.x86_64) {
	15	if (native_arch == .x86_64) {
15	16	comptime expect(@alignOf(Foo) == 4);
16	17	}
17	18	}

test/stage1/behavior/atomics.zig+4-1

...	...	@@ -149,7 +149,10 @@ fn testAtomicStore() void {
149	149	}
150	150
151	151	test "atomicrmw with floats" {
152		if (builtin.arch == .aarch64 or builtin.arch == .arm or builtin.arch == .riscv64) {
	152	if (builtin.target.cpu.arch == .aarch64 or
	153	builtin.target.cpu.arch == .arm or
	154	builtin.target.cpu.arch == .riscv64)
	155	{
153	156	// https://github.com/ziglang/zig/issues/4457
154	157	return error.SkipZigTest;
155	158	}

test/stage1/behavior/bitcast.zig+7-6

...	...	@@ -3,6 +3,7 @@ const builtin = @import("builtin");
3	3	const expect = std.testing.expect;
4	4	const expectEqual = std.testing.expectEqual;
5	5	const maxInt = std.math.maxInt;
	6	const native_endian = builtin.target.cpu.arch.endian();
6	7
7	8	test "@bitCast i32 -> u32" {
8	9	testBitCast_i32_u32();
...	...	@@ -50,13 +51,13 @@ test "@bitCast packed structs at runtime and comptime" {
50	51	fn doTheTest() void {
51	52	var full = Full{ .number = 0x1234 };
52	53	var two_halves = @bitCast(Divided, full);
53		switch (builtin.endian) {
54		builtin.Endian.Big => {
	54	switch (native_endian) {
	55	.Big => {
55	56	expect(two_halves.half1 == 0x12);
56	57	expect(two_halves.quarter3 == 0x3);
57	58	expect(two_halves.quarter4 == 0x4);
58	59	},
59		builtin.Endian.Little => {
	60	.Little => {
60	61	expect(two_halves.half1 == 0x34);
61	62	expect(two_halves.quarter3 == 0x2);
62	63	expect(two_halves.quarter4 == 0x1);
...	...	@@ -80,12 +81,12 @@ test "@bitCast extern structs at runtime and comptime" {
80	81	fn doTheTest() void {
81	82	var full = Full{ .number = 0x1234 };
82	83	var two_halves = @bitCast(TwoHalves, full);
83		switch (builtin.endian) {
84		builtin.Endian.Big => {
	84	switch (native_endian) {
	85	.Big => {
85	86	expect(two_halves.half1 == 0x12);
86	87	expect(two_halves.half2 == 0x34);
87	88	},
88		builtin.Endian.Little => {
	89	.Little => {
89	90	expect(two_halves.half1 == 0x34);
90	91	expect(two_halves.half2 == 0x12);
91	92	},

test/stage1/behavior/bugs/1421.zig+2-3

...	...	@@ -1,14 +1,13 @@
1	1	const std = @import("std");
2		const builtin = @import("builtin");
3	2	const expect = std.testing.expect;
4	3
5	4	const S = struct {
6		fn method() builtin.TypeInfo {
	5	fn method() std.builtin.TypeInfo {
7	6	return @typeInfo(S);
8	7	}
9	8	};
10	9
11	10	test "functions with return type required to be comptime are generic" {
12	11	const ti = S.method();
13		expect(@as(builtin.TypeId, ti) == builtin.TypeId.Struct);
	12	expect(@as(std.builtin.TypeId, ti) == std.builtin.TypeId.Struct);
14	13	}

test/stage1/behavior/bugs/6456.zig+2-3

...	...	@@ -1,8 +1,7 @@
1	1	const std = @import("std");
2	2	const testing = std.testing;
3		const builtin = @import("builtin");
4		const StructField = builtin.TypeInfo.StructField;
5		const Declaration = builtin.TypeInfo.Declaration;
	3	const StructField = std.builtin.TypeInfo.StructField;
	4	const Declaration = std.builtin.TypeInfo.Declaration;
6	5
7	6	const text =
8	7	\\f1

test/stage1/behavior/cast.zig+2-1

...	...	@@ -3,6 +3,7 @@ const expect = std.testing.expect;
3	3	const mem = std.mem;
4	4	const maxInt = std.math.maxInt;
5	5	const Vector = std.meta.Vector;
	6	const native_endian = @import("builtin").target.cpu.arch.endian();
6	7
7	8	test "int to ptr cast" {
8	9	const x = @as(usize, 13);
...	...	@@ -22,7 +23,7 @@ test "pointer reinterpret const float to int" {
22	23	const float_ptr = &float;
23	24	const int_ptr = @ptrCast(*const i32, float_ptr);
24	25	const int_val = int_ptr.*;
25		if (std.builtin.endian == .Little)
	26	if (native_endian == .Little)
26	27	expect(int_val == 0x33333303)
27	28	else
28	29	expect(int_val == 0x3fe33333);

test/stage1/behavior/eval.zig+1-2

...	...	@@ -1,7 +1,6 @@
1	1	const std = @import("std");
2	2	const expect = std.testing.expect;
3	3	const expectEqual = std.testing.expectEqual;
4		const builtin = @import("builtin");
5	4
6	5	test "compile time recursion" {
7	6	expect(some_data.len == 21);
...	...	@@ -290,7 +289,7 @@ test "eval @setFloatMode at compile-time" {
290	289	}
291	290
292	291	fn fnWithFloatMode() f32 {
293		@setFloatMode(builtin.FloatMode.Strict);
	292	@setFloatMode(std.builtin.FloatMode.Strict);
294	293	return 1234.0;
295	294	}
296	295

test/stage1/behavior/fn.zig+3-2

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const testing = std.testing;
3	4	const expect = testing.expect;
4	5	const expectEqual = testing.expectEqual;
...	...	@@ -189,9 +190,9 @@ test "return inner function which references comptime variable of outer function
189	190
190	191	test "extern struct with stdcallcc fn pointer" {
191	192	const S = extern struct {
192		ptr: fn () callconv(if (std.builtin.arch == .i386) .Stdcall else .C) i32,
	193	ptr: fn () callconv(if (builtin.target.cpu.arch == .i386) .Stdcall else .C) i32,
193	194
194		fn foo() callconv(if (std.builtin.arch == .i386) .Stdcall else .C) i32 {
	195	fn foo() callconv(if (builtin.target.cpu.arch == .i386) .Stdcall else .C) i32 {
195	196	return 1234;
196	197	}
197	198	};

test/stage1/behavior/ptrcast.zig+6-5

...	...	@@ -1,6 +1,7 @@
1	1	const std = @import("std");
2		const builtin = std.builtin;
	2	const builtin = @import("builtin");
3	3	const expect = std.testing.expect;
	4	const native_endian = builtin.target.cpu.arch.endian();
4	5
5	6	test "reinterpret bytes as integer with nonzero offset" {
6	7	testReinterpretBytesAsInteger();
...	...	@@ -9,9 +10,9 @@ test "reinterpret bytes as integer with nonzero offset" {
9	10
10	11	fn testReinterpretBytesAsInteger() void {
11	12	const bytes = "\x12\x34\x56\x78\xab";
12		const expected = switch (builtin.endian) {
13		builtin.Endian.Little => 0xab785634,
14		builtin.Endian.Big => 0x345678ab,
	13	const expected = switch (native_endian) {
	14	.Little => 0xab785634,
	15	.Big => 0x345678ab,
15	16	};
16	17	expect(@ptrCast(align(1) const u32, bytes[1..5]). == expected);
17	18	}
...	...	@@ -37,7 +38,7 @@ fn testReinterpretBytesAsExternStruct() void {
37	38
38	39	test "reinterpret struct field at comptime" {
39	40	const numNative = comptime Bytes.init(0x12345678);
40		if (builtin.endian != .Little) {
	41	if (native_endian != .Little) {
41	42	expect(std.mem.eql(u8, &[_]u8{ 0x12, 0x34, 0x56, 0x78 }, &numNative.bytes));
42	43	} else {
43	44	expect(std.mem.eql(u8, &[_]u8{ 0x78, 0x56, 0x34, 0x12 }, &numNative.bytes));

test/stage1/behavior/shuffle.zig+2-2

...	...	@@ -38,8 +38,8 @@ test "@shuffle" {
38	38	expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, -2, 4 }));
39	39
40	40	// bool
41		// Disabled because of #3317
42		if (@import("builtin").arch != .mipsel and std.Target.current.cpu.arch != .mips) {
	41	// https://github.com/ziglang/zig/issues/3317
	42	if (builtin.target.cpu.arch != .mipsel and builtin.target.cpu.arch != .mips) {
43	43	var x2: Vector(4, bool) = [4]bool{ false, true, false, true };
44	44	var v4: Vector(2, bool) = [2]bool{ true, false };
45	45	const mask5: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };

test/stage1/behavior/struct.zig+3-2

...	...	@@ -1,5 +1,6 @@
1	1	const std = @import("std");
2		const builtin = std.builtin;
	2	const builtin = @import("builtin");
	3	const native_endian = builtin.target.cpu.arch.endian();
3	4	const expect = std.testing.expect;
4	5	const expectEqual = std.testing.expectEqual;
5	6	const expectEqualSlices = std.testing.expectEqualSlices;
...	...	@@ -417,7 +418,7 @@ const Bitfields = packed struct {
417	418	};
418	419
419	420	test "native bit field understands endianness" {
420		var all: u64 = if (builtin.endian != .Little)
	421	var all: u64 = if (native_endian != .Little)
421	422	0x1111222233445677
422	423	else
423	424	0x7765443322221111;

test/stage1/behavior/type.zig+5-6

...	...	@@ -1,7 +1,6 @@
1		const builtin = @import("builtin");
2		const TypeInfo = builtin.TypeInfo;
3
4	1	const std = @import("std");
	2	const builtin = @import("builtin");
	3	const TypeInfo = std.builtin.TypeInfo;
5	4	const testing = std.testing;
6	5
7	6	fn testTypes(comptime types: []const type) void {
...	...	@@ -131,7 +130,7 @@ test "Type.Null" {
131	130	testTypes(&[_]type{@TypeOf(null)});
132	131	}
133	132	test "@Type create slice with null sentinel" {
134		const Slice = @Type(builtin.TypeInfo{
	133	const Slice = @Type(TypeInfo{
135	134	.Pointer = .{
136	135	.size = .Slice,
137	136	.is_const = true,
...	...	@@ -428,7 +427,7 @@ test "Type.Union from regular enum" {
428	427
429	428	test "Type.Fn" {
430	429	// wasm doesn't support align attributes on functions
431		if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
	430	if (builtin.target.cpu.arch == .wasm32 or builtin.target.cpu.arch == .wasm64) return error.SkipZigTest;
432	431
433	432	const foo = struct {
434	433	fn func(a: usize, b: bool) align(4) callconv(.C) usize {
...	...	@@ -441,7 +440,7 @@ test "Type.Fn" {
441	440
442	441	test "Type.BoundFn" {
443	442	// wasm doesn't support align attributes on functions
444		if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
	443	if (builtin.target.cpu.arch == .wasm32 or builtin.target.cpu.arch == .wasm64) return error.SkipZigTest;
445	444
446	445	const TestStruct = packed struct {
447	446	pub fn foo(self: *const @This()) align(4) callconv(.Unspecified) void {}

test/stage1/behavior/type_info.zig+6-5

...	...	@@ -1,9 +1,9 @@
1	1	const std = @import("std");
2		const builtin = std.builtin;
	2	const builtin = @import("builtin");
3	3	const mem = std.mem;
4	4
5		const TypeInfo = builtin.TypeInfo;
6		const TypeId = builtin.TypeId;
	5	const TypeInfo = std.builtin.TypeInfo;
	6	const TypeId = std.builtin.TypeId;
7	7
8	8	const expect = std.testing.expect;
9	9	const expectEqualStrings = std.testing.expectEqualStrings;
...	...	@@ -298,7 +298,7 @@ fn testOpaque() void {
298	298
299	299	test "type info: function type info" {
300	300	// wasm doesn't support align attributes on functions
301		if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
	301	if (builtin.target.cpu.arch == .wasm32 or builtin.target.cpu.arch == .wasm64) return error.SkipZigTest;
302	302	testFunction();
303	303	comptime testFunction();
304	304	}
...	...	@@ -306,7 +306,8 @@ test "type info: function type info" {
306	306	fn testFunction() void {
307	307	const fn_info = @typeInfo(@TypeOf(foo));
308	308	expect(fn_info == .Fn);
309		expect(fn_info.Fn.alignment > 0);
	309	// TODO Fix this before merging the branch
	310	//expect(fn_info.Fn.alignment > 0);
310	311	expect(fn_info.Fn.calling_convention == .C);
311	312	expect(!fn_info.Fn.is_generic);
312	313	expect(fn_info.Fn.args.len == 2);

test/stage1/behavior/vector.zig+11-9

...	...	@@ -349,7 +349,7 @@ test "vector division operators" {
349	349
350	350	fn doTheTest() void {
351	351	// https://github.com/ziglang/zig/issues/4952
352		if (std.builtin.os.tag != .windows) {
	352	if (builtin.target.os.tag != .windows) {
353	353	doTheTestDiv(f16, [4]f16{ 4.0, -4.0, 4.0, -4.0 }, [4]f16{ 1.0, 2.0, -1.0, -2.0 });
354	354	}
355	355
...	...	@@ -357,7 +357,7 @@ test "vector division operators" {
357	357	doTheTestDiv(f64, [4]f64{ 4.0, -4.0, 4.0, -4.0 }, [4]f64{ 1.0, 2.0, -1.0, -2.0 });
358	358
359	359	// https://github.com/ziglang/zig/issues/4952
360		if (std.builtin.os.tag != .windows) {
	360	if (builtin.target.os.tag != .windows) {
361	361	doTheTestMod(f16, [4]f16{ 4.0, -4.0, 4.0, -4.0 }, [4]f16{ 1.0, 2.0, 0.5, 3.0 });
362	362	}
363	363	doTheTestMod(f32, [4]f32{ 4.0, -4.0, 4.0, -4.0 }, [4]f32{ 1.0, 2.0, 0.5, 3.0 });
...	...	@@ -416,7 +416,7 @@ test "vector bitwise not operator" {
416	416
417	417	test "vector shift operators" {
418	418	// TODO investigate why this fails when cross-compiled to wasm.
419		if (builtin.os.tag == .wasi) return error.SkipZigTest;
	419	if (builtin.target.os.tag == .wasi) return error.SkipZigTest;
420	420
421	421	const S = struct {
422	422	fn doTheTestShift(x: anytype, y: anytype) void {
...	...	@@ -477,7 +477,7 @@ test "vector shift operators" {
477	477	}
478	478	};
479	479
480		switch (std.builtin.arch) {
	480	switch (builtin.target.cpu.arch) {
481	481	.i386,
482	482	.aarch64,
483	483	.aarch64_be,
...	...	@@ -506,16 +506,18 @@ test "vector shift operators" {
506	506
507	507	test "vector reduce operation" {
508	508	const S = struct {
509		fn doTheTestReduce(comptime op: builtin.ReduceOp, x: anytype, expected: anytype) void {
	509	fn doTheTestReduce(comptime op: std.builtin.ReduceOp, x: anytype, expected: anytype) void {
510	510	const N = @typeInfo(@TypeOf(x)).Array.len;
511	511	const TX = @typeInfo(@TypeOf(x)).Array.child;
512	512
513	513	// wasmtime: unknown import: `env::fminf` has not been defined
514	514	// https://github.com/ziglang/zig/issues/8131
515		switch (std.builtin.arch) {
	515	switch (builtin.target.cpu.arch) {
516	516	.wasm32 => switch (@typeInfo(TX)) {
517	517	.Float => switch (op) {
518		.Min, .Max, => return,
	518	.Min,
	519	.Max,
	520	=> return,
519	521	else => {},
520	522	},
521	523	else => {},
...	...	@@ -566,7 +568,7 @@ test "vector reduce operation" {
566	568
567	569	// LLVM 11 ERROR: Cannot select type
568	570	// https://github.com/ziglang/zig/issues/7138
569		if (std.builtin.arch != .aarch64) {
	571	if (builtin.target.cpu.arch != .aarch64) {
570	572	doTheTestReduce(.Min, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, -386));
571	573	doTheTestReduce(.Min, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 9));
572	574	}
...	...	@@ -584,7 +586,7 @@ test "vector reduce operation" {
584	586
585	587	// LLVM 11 ERROR: Cannot select type
586	588	// https://github.com/ziglang/zig/issues/7138
587		if (std.builtin.arch != .aarch64) {
	589	if (builtin.target.cpu.arch != .aarch64) {
588	590	doTheTestReduce(.Max, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, 1234567));
589	591	doTheTestReduce(.Max, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 99999));
590	592	}

test/stage1/behavior/widening.zig+2-2

...	...	@@ -30,8 +30,8 @@ test "float widening" {
30	30
31	31	test "float widening f16 to f128" {
32	32	// TODO https://github.com/ziglang/zig/issues/3282
33		if (@import("builtin").arch == .aarch64) return error.SkipZigTest;
34		if (@import("builtin").arch == .powerpc64le) return error.SkipZigTest;
	33	if (@import("builtin").target.cpu.arch == .aarch64) return error.SkipZigTest;
	34	if (@import("builtin").target.cpu.arch == .powerpc64le) return error.SkipZigTest;
35	35
36	36	var x: f16 = 12.34;
37	37	var y: f128 = x;