Commit 35423b005440c9f31a4cc6a53ccf6b7edd08b859 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-01-26 20:59:20-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-01-26 20:59:20-07:00
log	35423b005440c9f31a4cc6a53ccf6b7edd08b859
tree	8dffff28ae0950fb03d8d146f25985a813f492d0
parent	82bd0ac572f14d1e3a13737f4daf00a1ee8041a2

organize behavior tests

check the set of passing tests; move towards the disabling logic being
inside each test rather than which files are included.

this enables a few more passing tests.

13 files changed, 1034 insertions(+), 972 deletions(-)

test
- behavior.zig
- behavior

test/behavior.zig+1-8

...	...	@@ -1,7 +1,6 @@
1	1	const builtin = @import("builtin");
2	2
3	3	test {
4		// Tests that pass for stage1, llvm backend, C backend, wasm backend, arm backend and x86_64 backend.
5	4	_ = @import("behavior/align.zig");
6	5	_ = @import("behavior/alignof.zig");
7	6	_ = @import("behavior/array.zig");
...	...	@@ -26,7 +25,6 @@ test {
26	25	_ = @import("behavior/cast.zig");
27	26	_ = @import("behavior/comptime_memory.zig");
28	27	_ = @import("behavior/fn_in_struct_in_comptime.zig");
29		_ = @import("behavior/generics_llvm.zig");
30	28	_ = @import("behavior/hasdecl.zig");
31	29	_ = @import("behavior/hasfield.zig");
32	30	_ = @import("behavior/namespace_depends_on_compile_var.zig");
...	...	@@ -43,6 +41,7 @@ test {
43	41	_ = @import("behavior/bitcast.zig");
44	42	_ = @import("behavior/bugs/624.zig");
45	43	_ = @import("behavior/bugs/704.zig");
	44	_ = @import("behavior/bugs/1076.zig");
46	45	_ = @import("behavior/bugs/1486.zig");
47	46	_ = @import("behavior/bugs/2692.zig");
48	47	_ = @import("behavior/bugs/2889.zig");
...	...	@@ -128,7 +127,6 @@ test {
128	127	_ = @import("behavior/bugs/726.zig");
129	128	_ = @import("behavior/bugs/828.zig");
130	129	_ = @import("behavior/bugs/920.zig");
131		_ = @import("behavior/bugs/1076.zig");
132	130	_ = @import("behavior/bugs/1120.zig");
133	131	_ = @import("behavior/bugs/1421.zig");
134	132	_ = @import("behavior/bugs/1442.zig");
...	...	@@ -150,9 +148,7 @@ test {
150	148	_ = @import("behavior/bugs/7047.zig");
151	149	_ = @import("behavior/bugs/10147.zig");
152	150	_ = @import("behavior/byteswap.zig");
153		_ = @import("behavior/call_stage1.zig");
154	151	_ = @import("behavior/const_slice_child.zig");
155		_ = @import("behavior/error_stage1.zig");
156	152	_ = @import("behavior/field_parent_ptr.zig");
157	153	_ = @import("behavior/floatop_stage1.zig");
158	154	_ = @import("behavior/fn_delegation.zig");
...	...	@@ -164,14 +160,12 @@ test {
164	160	_ = @import("behavior/optional_stage1.zig");
165	161	_ = @import("behavior/popcount_stage1.zig");
166	162	_ = @import("behavior/reflection.zig");
167		_ = @import("behavior/saturating_arithmetic_stage1.zig");
168	163	_ = @import("behavior/select.zig");
169	164	_ = @import("behavior/shuffle.zig");
170	165	_ = @import("behavior/sizeof_and_typeof_stage1.zig");
171	166	_ = @import("behavior/slice_stage1.zig");
172	167	_ = @import("behavior/struct_contains_null_ptr_itself.zig");
173	168	_ = @import("behavior/struct_contains_slice_of_itself.zig");
174		_ = @import("behavior/struct_stage1.zig");
175	169	_ = @import("behavior/switch_prong_err_enum.zig");
176	170	_ = @import("behavior/switch_prong_implicit_cast.zig");
177	171	_ = @import("behavior/truncate_stage1.zig");
...	...	@@ -185,7 +179,6 @@ test {
185	179	if (builtin.target.cpu.arch == .wasm32) {
186	180	_ = @import("behavior/wasm.zig");
187	181	}
188		_ = @import("behavior/translate_c_macros_stage1.zig");
189	182	}
190	183	}
191	184	}

test/behavior/call.zig+78

...	...	@@ -1,3 +1,81 @@
	1	const builtin = @import("builtin");
1	2	const std = @import("std");
2	3	const expect = std.testing.expect;
3	4	const expectEqual = std.testing.expectEqual;
	5
	6	test "basic invocations" {
	7	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	8
	9	const foo = struct {
	10	fn foo() i32 {
	11	return 1234;
	12	}
	13	}.foo;
	14	try expect(@call(.{}, foo, .{}) == 1234);
	15	comptime {
	16	// modifiers that allow comptime calls
	17	try expect(@call(.{}, foo, .{}) == 1234);
	18	try expect(@call(.{ .modifier = .no_async }, foo, .{}) == 1234);
	19	try expect(@call(.{ .modifier = .always_tail }, foo, .{}) == 1234);
	20	try expect(@call(.{ .modifier = .always_inline }, foo, .{}) == 1234);
	21	}
	22	{
	23	// comptime call without comptime keyword
	24	const result = @call(.{ .modifier = .compile_time }, foo, .{}) == 1234;
	25	comptime try expect(result);
	26	}
	27	{
	28	// call of non comptime-known function
	29	var alias_foo = foo;
	30	try expect(@call(.{ .modifier = .no_async }, alias_foo, .{}) == 1234);
	31	try expect(@call(.{ .modifier = .never_tail }, alias_foo, .{}) == 1234);
	32	try expect(@call(.{ .modifier = .never_inline }, alias_foo, .{}) == 1234);
	33	}
	34	}
	35
	36	test "tuple parameters" {
	37	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	38
	39	const add = struct {
	40	fn add(a: i32, b: i32) i32 {
	41	return a + b;
	42	}
	43	}.add;
	44	var a: i32 = 12;
	45	var b: i32 = 34;
	46	try expect(@call(.{}, add, .{ a, 34 }) == 46);
	47	try expect(@call(.{}, add, .{ 12, b }) == 46);
	48	try expect(@call(.{}, add, .{ a, b }) == 46);
	49	try expect(@call(.{}, add, .{ 12, 34 }) == 46);
	50	comptime try expect(@call(.{}, add, .{ 12, 34 }) == 46);
	51	{
	52	const separate_args0 = .{ a, b };
	53	const separate_args1 = .{ a, 34 };
	54	const separate_args2 = .{ 12, 34 };
	55	const separate_args3 = .{ 12, b };
	56	try expect(@call(.{ .modifier = .always_inline }, add, separate_args0) == 46);
	57	try expect(@call(.{ .modifier = .always_inline }, add, separate_args1) == 46);
	58	try expect(@call(.{ .modifier = .always_inline }, add, separate_args2) == 46);
	59	try expect(@call(.{ .modifier = .always_inline }, add, separate_args3) == 46);
	60	}
	61	}
	62
	63	test "comptime call with bound function as parameter" {
	64	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	65
	66	const S = struct {
	67	fn ReturnType(func: anytype) type {
	68	return switch (@typeInfo(@TypeOf(func))) {
	69	.BoundFn => \|info\| info,
	70	else => unreachable,
	71	}.return_type orelse void;
	72	}
	73
	74	fn call_me_maybe() ?i32 {
	75	return 123;
	76	}
	77	};
	78
	79	var inst: S = undefined;
	80	try expectEqual(?i32, S.ReturnType(inst.call_me_maybe));
	81	}

test/behavior/call_stage1.zig deleted-74

...	...	@@ -1,74 +0,0 @@
1		const std = @import("std");
2		const expect = std.testing.expect;
3		const expectEqual = std.testing.expectEqual;
4
5		test "basic invocations" {
6		const foo = struct {
7		fn foo() i32 {
8		return 1234;
9		}
10		}.foo;
11		try expect(@call(.{}, foo, .{}) == 1234);
12		comptime {
13		// modifiers that allow comptime calls
14		try expect(@call(.{}, foo, .{}) == 1234);
15		try expect(@call(.{ .modifier = .no_async }, foo, .{}) == 1234);
16		try expect(@call(.{ .modifier = .always_tail }, foo, .{}) == 1234);
17		try expect(@call(.{ .modifier = .always_inline }, foo, .{}) == 1234);
18		}
19		{
20		// comptime call without comptime keyword
21		const result = @call(.{ .modifier = .compile_time }, foo, .{}) == 1234;
22		comptime try expect(result);
23		}
24		{
25		// call of non comptime-known function
26		var alias_foo = foo;
27		try expect(@call(.{ .modifier = .no_async }, alias_foo, .{}) == 1234);
28		try expect(@call(.{ .modifier = .never_tail }, alias_foo, .{}) == 1234);
29		try expect(@call(.{ .modifier = .never_inline }, alias_foo, .{}) == 1234);
30		}
31		}
32
33		test "tuple parameters" {
34		const add = struct {
35		fn add(a: i32, b: i32) i32 {
36		return a + b;
37		}
38		}.add;
39		var a: i32 = 12;
40		var b: i32 = 34;
41		try expect(@call(.{}, add, .{ a, 34 }) == 46);
42		try expect(@call(.{}, add, .{ 12, b }) == 46);
43		try expect(@call(.{}, add, .{ a, b }) == 46);
44		try expect(@call(.{}, add, .{ 12, 34 }) == 46);
45		comptime try expect(@call(.{}, add, .{ 12, 34 }) == 46);
46		{
47		const separate_args0 = .{ a, b };
48		const separate_args1 = .{ a, 34 };
49		const separate_args2 = .{ 12, 34 };
50		const separate_args3 = .{ 12, b };
51		try expect(@call(.{ .modifier = .always_inline }, add, separate_args0) == 46);
52		try expect(@call(.{ .modifier = .always_inline }, add, separate_args1) == 46);
53		try expect(@call(.{ .modifier = .always_inline }, add, separate_args2) == 46);
54		try expect(@call(.{ .modifier = .always_inline }, add, separate_args3) == 46);
55		}
56		}
57
58		test "comptime call with bound function as parameter" {
59		const S = struct {
60		fn ReturnType(func: anytype) type {
61		return switch (@typeInfo(@TypeOf(func))) {
62		.BoundFn => \|info\| info,
63		else => unreachable,
64		}.return_type orelse void;
65		}
66
67		fn call_me_maybe() ?i32 {
68		return 123;
69		}
70		};
71
72		var inst: S = undefined;
73		try expectEqual(?i32, S.ReturnType(inst.call_me_maybe));
74		}

test/behavior/error.zig+346

...	...	@@ -132,3 +132,349 @@ fn foo2(f: fn () anyerror!void) void {
132	132	}
133	133
134	134	fn bar2() (error{}!void) {}
	135
	136	test "error union type " {
	137	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	138
	139	try testErrorUnionType();
	140	comptime try testErrorUnionType();
	141	}
	142
	143	fn testErrorUnionType() !void {
	144	const x: anyerror!i32 = 1234;
	145	if (x) \|value\| try expect(value == 1234) else \|_\| unreachable;
	146	try expect(@typeInfo(@TypeOf(x)) == .ErrorUnion);
	147	try expect(@typeInfo(@typeInfo(@TypeOf(x)).ErrorUnion.error_set) == .ErrorSet);
	148	try expect(@typeInfo(@TypeOf(x)).ErrorUnion.error_set == anyerror);
	149	}
	150
	151	test "error set type" {
	152	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	153
	154	try testErrorSetType();
	155	comptime try testErrorSetType();
	156	}
	157
	158	const MyErrSet = error{
	159	OutOfMemory,
	160	FileNotFound,
	161	};
	162
	163	fn testErrorSetType() !void {
	164	try expect(@typeInfo(MyErrSet).ErrorSet.?.len == 2);
	165
	166	const a: MyErrSet!i32 = 5678;
	167	const b: MyErrSet!i32 = MyErrSet.OutOfMemory;
	168	try expect(b catch error.OutOfMemory == error.OutOfMemory);
	169
	170	if (a) \|value\| try expect(value == 5678) else \|err\| switch (err) {
	171	error.OutOfMemory => unreachable,
	172	error.FileNotFound => unreachable,
	173	}
	174	}
	175
	176	test "explicit error set cast" {
	177	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	178
	179	try testExplicitErrorSetCast(Set1.A);
	180	comptime try testExplicitErrorSetCast(Set1.A);
	181	}
	182
	183	const Set1 = error{ A, B };
	184	const Set2 = error{ A, C };
	185
	186	fn testExplicitErrorSetCast(set1: Set1) !void {
	187	var x = @errSetCast(Set2, set1);
	188	var y = @errSetCast(Set1, x);
	189	try expect(y == error.A);
	190	}
	191
	192	test "comptime test error for empty error set" {
	193	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	194
	195	try testComptimeTestErrorEmptySet(1234);
	196	comptime try testComptimeTestErrorEmptySet(1234);
	197	}
	198
	199	const EmptyErrorSet = error{};
	200
	201	fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) !void {
	202	if (x) \|v\| try expect(v == 1234) else \|err\| {
	203	_ = err;
	204	@compileError("bad");
	205	}
	206	}
	207
	208	test "comptime err to int of error set with only 1 possible value" {
	209	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	210
	211	testErrToIntWithOnePossibleValue(error.A, @errorToInt(error.A));
	212	comptime testErrToIntWithOnePossibleValue(error.A, @errorToInt(error.A));
	213	}
	214	fn testErrToIntWithOnePossibleValue(
	215	x: error{A},
	216	comptime value: u32,
	217	) void {
	218	if (@errorToInt(x) != value) {
	219	@compileError("bad");
	220	}
	221	}
	222
	223	test "error union peer type resolution" {
	224	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	225
	226	try testErrorUnionPeerTypeResolution(1);
	227	}
	228
	229	fn testErrorUnionPeerTypeResolution(x: i32) !void {
	230	const y = switch (x) {
	231	1 => bar_1(),
	232	2 => baz_1(),
	233	else => quux_1(),
	234	};
	235	if (y) \|_\| {
	236	@panic("expected error");
	237	} else \|e\| {
	238	try expect(e == error.A);
	239	}
	240	}
	241
	242	fn bar_1() anyerror {
	243	return error.A;
	244	}
	245
	246	fn baz_1() !i32 {
	247	return error.B;
	248	}
	249
	250	fn quux_1() !i32 {
	251	return error.C;
	252	}
	253
	254	test "error: Zero sized error set returned with value payload crash" {
	255	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	256
	257	_ = foo3(0) catch {};
	258	_ = comptime foo3(0) catch {};
	259	}
	260
	261	const Error = error{};
	262	fn foo3(b: usize) Error!usize {
	263	return b;
	264	}
	265
	266	test "error: Infer error set from literals" {
	267	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	268
	269	_ = nullLiteral("n") catch \|err\| handleErrors(err);
	270	_ = floatLiteral("n") catch \|err\| handleErrors(err);
	271	_ = intLiteral("n") catch \|err\| handleErrors(err);
	272	_ = comptime nullLiteral("n") catch \|err\| handleErrors(err);
	273	_ = comptime floatLiteral("n") catch \|err\| handleErrors(err);
	274	_ = comptime intLiteral("n") catch \|err\| handleErrors(err);
	275	}
	276
	277	fn handleErrors(err: anytype) noreturn {
	278	switch (err) {
	279	error.T => {},
	280	}
	281
	282	unreachable;
	283	}
	284
	285	fn nullLiteral(str: []const u8) !?i64 {
	286	if (str[0] == 'n') return null;
	287
	288	return error.T;
	289	}
	290
	291	fn floatLiteral(str: []const u8) !?f64 {
	292	if (str[0] == 'n') return 1.0;
	293
	294	return error.T;
	295	}
	296
	297	fn intLiteral(str: []const u8) !?i64 {
	298	if (str[0] == 'n') return 1;
	299
	300	return error.T;
	301	}
	302
	303	test "nested error union function call in optional unwrap" {
	304	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	305
	306	const S = struct {
	307	const Foo = struct {
	308	a: i32,
	309	};
	310
	311	fn errorable() !i32 {
	312	var x: Foo = (try getFoo()) orelse return error.Other;
	313	return x.a;
	314	}
	315
	316	fn errorable2() !i32 {
	317	var x: Foo = (try getFoo2()) orelse return error.Other;
	318	return x.a;
	319	}
	320
	321	fn errorable3() !i32 {
	322	var x: Foo = (try getFoo3()) orelse return error.Other;
	323	return x.a;
	324	}
	325
	326	fn getFoo() anyerror!?Foo {
	327	return Foo{ .a = 1234 };
	328	}
	329
	330	fn getFoo2() anyerror!?Foo {
	331	return error.Failure;
	332	}
	333
	334	fn getFoo3() anyerror!?Foo {
	335	return null;
	336	}
	337	};
	338	try expect((try S.errorable()) == 1234);
	339	try expectError(error.Failure, S.errorable2());
	340	try expectError(error.Other, S.errorable3());
	341	comptime {
	342	try expect((try S.errorable()) == 1234);
	343	try expectError(error.Failure, S.errorable2());
	344	try expectError(error.Other, S.errorable3());
	345	}
	346	}
	347
	348	test "return function call to error set from error union function" {
	349	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	350
	351	const S = struct {
	352	fn errorable() anyerror!i32 {
	353	return fail();
	354	}
	355
	356	fn fail() anyerror {
	357	return error.Failure;
	358	}
	359	};
	360	try expectError(error.Failure, S.errorable());
	361	comptime try expectError(error.Failure, S.errorable());
	362	}
	363
	364	test "optional error set is the same size as error set" {
	365	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	366
	367	comptime try expect(@sizeOf(?anyerror) == @sizeOf(anyerror));
	368	const S = struct {
	369	fn returnsOptErrSet() ?anyerror {
	370	return null;
	371	}
	372	};
	373	try expect(S.returnsOptErrSet() == null);
	374	comptime try expect(S.returnsOptErrSet() == null);
	375	}
	376
	377	test "nested catch" {
	378	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	379
	380	const S = struct {
	381	fn entry() !void {
	382	try expectError(error.Bad, func());
	383	}
	384	fn fail() anyerror!Foo {
	385	return error.Wrong;
	386	}
	387	fn func() anyerror!Foo {
	388	_ = fail() catch
	389	fail() catch
	390	return error.Bad;
	391	unreachable;
	392	}
	393	const Foo = struct {
	394	field: i32,
	395	};
	396	};
	397	try S.entry();
	398	comptime try S.entry();
	399	}
	400
	401	test "function pointer with return type that is error union with payload which is pointer of parent struct" {
	402	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	403
	404	const S = struct {
	405	const Foo = struct {
	406	fun: fn (a: i32) (anyerror!*Foo),
	407	};
	408
	409	const Err = error{UnspecifiedErr};
	410
	411	fn bar(a: i32) anyerror!*Foo {
	412	_ = a;
	413	return Err.UnspecifiedErr;
	414	}
	415
	416	fn doTheTest() !void {
	417	var x = Foo{ .fun = @This().bar };
	418	try expectError(error.UnspecifiedErr, x.fun(1));
	419	}
	420	};
	421	try S.doTheTest();
	422	}
	423
	424	test "return result loc as peer result loc in inferred error set function" {
	425	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	426
	427	const S = struct {
	428	fn doTheTest() !void {
	429	if (quux(2)) \|x\| {
	430	try expect(x.Two);
	431	} else \|e\| switch (e) {
	432	error.Whatever => @panic("fail"),
	433	}
	434	try expectError(error.Whatever, quux(99));
	435	}
	436	const FormValue = union(enum) {
	437	One: void,
	438	Two: bool,
	439	};
	440
	441	fn quux(id: u64) !FormValue {
	442	return switch (id) {
	443	2 => FormValue{ .Two = true },
	444	1 => FormValue{ .One = {} },
	445	else => return error.Whatever,
	446	};
	447	}
	448	};
	449	try S.doTheTest();
	450	comptime try S.doTheTest();
	451	}
	452
	453	test "error payload type is correctly resolved" {
	454	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	455
	456	const MyIntWrapper = struct {
	457	const Self = @This();
	458
	459	x: i32,
	460
	461	pub fn create() anyerror!Self {
	462	return Self{ .x = 42 };
	463	}
	464	};
	465
	466	try expectEqual(MyIntWrapper{ .x = 42 }, try MyIntWrapper.create());
	467	}
	468
	469	test "error union comptime caching" {
	470	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	471
	472	const S = struct {
	473	fn quux(comptime arg: anytype) void {
	474	arg catch {};
	475	}
	476	};
	477
	478	S.quux(@as(anyerror!void, {}));
	479	S.quux(@as(anyerror!void, {}));
	480	}

test/behavior/error_stage1.zig deleted-319

...	...	@@ -1,319 +0,0 @@
1		const std = @import("std");
2		const expect = std.testing.expect;
3		const expectError = std.testing.expectError;
4		const expectEqual = std.testing.expectEqual;
5		const mem = std.mem;
6
7		test "error union type " {
8		try testErrorUnionType();
9		comptime try testErrorUnionType();
10		}
11
12		fn testErrorUnionType() !void {
13		const x: anyerror!i32 = 1234;
14		if (x) \|value\| try expect(value == 1234) else \|_\| unreachable;
15		try expect(@typeInfo(@TypeOf(x)) == .ErrorUnion);
16		try expect(@typeInfo(@typeInfo(@TypeOf(x)).ErrorUnion.error_set) == .ErrorSet);
17		try expect(@typeInfo(@TypeOf(x)).ErrorUnion.error_set == anyerror);
18		}
19
20		test "error set type" {
21		try testErrorSetType();
22		comptime try testErrorSetType();
23		}
24
25		const MyErrSet = error{
26		OutOfMemory,
27		FileNotFound,
28		};
29
30		fn testErrorSetType() !void {
31		try expect(@typeInfo(MyErrSet).ErrorSet.?.len == 2);
32
33		const a: MyErrSet!i32 = 5678;
34		const b: MyErrSet!i32 = MyErrSet.OutOfMemory;
35		try expect(b catch error.OutOfMemory == error.OutOfMemory);
36
37		if (a) \|value\| try expect(value == 5678) else \|err\| switch (err) {
38		error.OutOfMemory => unreachable,
39		error.FileNotFound => unreachable,
40		}
41		}
42
43		test "explicit error set cast" {
44		try testExplicitErrorSetCast(Set1.A);
45		comptime try testExplicitErrorSetCast(Set1.A);
46		}
47
48		const Set1 = error{ A, B };
49		const Set2 = error{ A, C };
50
51		fn testExplicitErrorSetCast(set1: Set1) !void {
52		var x = @errSetCast(Set2, set1);
53		var y = @errSetCast(Set1, x);
54		try expect(y == error.A);
55		}
56
57		test "comptime test error for empty error set" {
58		try testComptimeTestErrorEmptySet(1234);
59		comptime try testComptimeTestErrorEmptySet(1234);
60		}
61
62		const EmptyErrorSet = error{};
63
64		fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) !void {
65		if (x) \|v\| try expect(v == 1234) else \|err\| {
66		_ = err;
67		@compileError("bad");
68		}
69		}
70
71		test "comptime err to int of error set with only 1 possible value" {
72		testErrToIntWithOnePossibleValue(error.A, @errorToInt(error.A));
73		comptime testErrToIntWithOnePossibleValue(error.A, @errorToInt(error.A));
74		}
75		fn testErrToIntWithOnePossibleValue(
76		x: error{A},
77		comptime value: u32,
78		) void {
79		if (@errorToInt(x) != value) {
80		@compileError("bad");
81		}
82		}
83
84		test "error union peer type resolution" {
85		try testErrorUnionPeerTypeResolution(1);
86		}
87
88		fn testErrorUnionPeerTypeResolution(x: i32) !void {
89		const y = switch (x) {
90		1 => bar_1(),
91		2 => baz_1(),
92		else => quux_1(),
93		};
94		if (y) \|_\| {
95		@panic("expected error");
96		} else \|e\| {
97		try expect(e == error.A);
98		}
99		}
100
101		fn bar_1() anyerror {
102		return error.A;
103		}
104
105		fn baz_1() !i32 {
106		return error.B;
107		}
108
109		fn quux_1() !i32 {
110		return error.C;
111		}
112
113		test "error: Zero sized error set returned with value payload crash" {
114		_ = foo3(0) catch {};
115		_ = comptime foo3(0) catch {};
116		}
117
118		const Error = error{};
119		fn foo3(b: usize) Error!usize {
120		return b;
121		}
122
123		test "error: Infer error set from literals" {
124		_ = nullLiteral("n") catch \|err\| handleErrors(err);
125		_ = floatLiteral("n") catch \|err\| handleErrors(err);
126		_ = intLiteral("n") catch \|err\| handleErrors(err);
127		_ = comptime nullLiteral("n") catch \|err\| handleErrors(err);
128		_ = comptime floatLiteral("n") catch \|err\| handleErrors(err);
129		_ = comptime intLiteral("n") catch \|err\| handleErrors(err);
130		}
131
132		fn handleErrors(err: anytype) noreturn {
133		switch (err) {
134		error.T => {},
135		}
136
137		unreachable;
138		}
139
140		fn nullLiteral(str: []const u8) !?i64 {
141		if (str[0] == 'n') return null;
142
143		return error.T;
144		}
145
146		fn floatLiteral(str: []const u8) !?f64 {
147		if (str[0] == 'n') return 1.0;
148
149		return error.T;
150		}
151
152		fn intLiteral(str: []const u8) !?i64 {
153		if (str[0] == 'n') return 1;
154
155		return error.T;
156		}
157
158		test "nested error union function call in optional unwrap" {
159		const S = struct {
160		const Foo = struct {
161		a: i32,
162		};
163
164		fn errorable() !i32 {
165		var x: Foo = (try getFoo()) orelse return error.Other;
166		return x.a;
167		}
168
169		fn errorable2() !i32 {
170		var x: Foo = (try getFoo2()) orelse return error.Other;
171		return x.a;
172		}
173
174		fn errorable3() !i32 {
175		var x: Foo = (try getFoo3()) orelse return error.Other;
176		return x.a;
177		}
178
179		fn getFoo() anyerror!?Foo {
180		return Foo{ .a = 1234 };
181		}
182
183		fn getFoo2() anyerror!?Foo {
184		return error.Failure;
185		}
186
187		fn getFoo3() anyerror!?Foo {
188		return null;
189		}
190		};
191		try expect((try S.errorable()) == 1234);
192		try expectError(error.Failure, S.errorable2());
193		try expectError(error.Other, S.errorable3());
194		comptime {
195		try expect((try S.errorable()) == 1234);
196		try expectError(error.Failure, S.errorable2());
197		try expectError(error.Other, S.errorable3());
198		}
199		}
200
201		test "return function call to error set from error union function" {
202		const S = struct {
203		fn errorable() anyerror!i32 {
204		return fail();
205		}
206
207		fn fail() anyerror {
208		return error.Failure;
209		}
210		};
211		try expectError(error.Failure, S.errorable());
212		comptime try expectError(error.Failure, S.errorable());
213		}
214
215		test "optional error set is the same size as error set" {
216		comptime try expect(@sizeOf(?anyerror) == @sizeOf(anyerror));
217		const S = struct {
218		fn returnsOptErrSet() ?anyerror {
219		return null;
220		}
221		};
222		try expect(S.returnsOptErrSet() == null);
223		comptime try expect(S.returnsOptErrSet() == null);
224		}
225
226		test "nested catch" {
227		const S = struct {
228		fn entry() !void {
229		try expectError(error.Bad, func());
230		}
231		fn fail() anyerror!Foo {
232		return error.Wrong;
233		}
234		fn func() anyerror!Foo {
235		_ = fail() catch
236		fail() catch
237		return error.Bad;
238		unreachable;
239		}
240		const Foo = struct {
241		field: i32,
242		};
243		};
244		try S.entry();
245		comptime try S.entry();
246		}
247
248		test "function pointer with return type that is error union with payload which is pointer of parent struct" {
249		const S = struct {
250		const Foo = struct {
251		fun: fn (a: i32) (anyerror!*Foo),
252		};
253
254		const Err = error{UnspecifiedErr};
255
256		fn bar(a: i32) anyerror!*Foo {
257		_ = a;
258		return Err.UnspecifiedErr;
259		}
260
261		fn doTheTest() !void {
262		var x = Foo{ .fun = @This().bar };
263		try expectError(error.UnspecifiedErr, x.fun(1));
264		}
265		};
266		try S.doTheTest();
267		}
268
269		test "return result loc as peer result loc in inferred error set function" {
270		const S = struct {
271		fn doTheTest() !void {
272		if (quux(2)) \|x\| {
273		try expect(x.Two);
274		} else \|e\| switch (e) {
275		error.Whatever => @panic("fail"),
276		}
277		try expectError(error.Whatever, quux(99));
278		}
279		const FormValue = union(enum) {
280		One: void,
281		Two: bool,
282		};
283
284		fn quux(id: u64) !FormValue {
285		return switch (id) {
286		2 => FormValue{ .Two = true },
287		1 => FormValue{ .One = {} },
288		else => return error.Whatever,
289		};
290		}
291		};
292		try S.doTheTest();
293		comptime try S.doTheTest();
294		}
295
296		test "error payload type is correctly resolved" {
297		const MyIntWrapper = struct {
298		const Self = @This();
299
300		x: i32,
301
302		pub fn create() anyerror!Self {
303		return Self{ .x = 42 };
304		}
305		};
306
307		try expectEqual(MyIntWrapper{ .x = 42 }, try MyIntWrapper.create());
308		}
309
310		test "error union comptime caching" {
311		const S = struct {
312		fn quux(comptime arg: anytype) void {
313		arg catch {};
314		}
315		};
316
317		S.quux(@as(anyerror!void, {}));
318		S.quux(@as(anyerror!void, {}));
319		}

test/behavior/generics.zig+46

...	...	@@ -163,3 +163,49 @@ test "generic fn keeps non-generic parameter types" {
163	163	var x: [16]u8 align(A) = undefined;
164	164	try S.f(u8, &x);
165	165	}
	166
	167	test "array of generic fns" {
	168	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
	169	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	170	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	171	try expect(foos[0](true));
	172	try expect(!foos[1](true));
	173	}
	174
	175	const foos = [_]fn (anytype) bool{
	176	foo1,
	177	foo2,
	178	};
	179
	180	fn foo1(arg: anytype) bool {
	181	return arg;
	182	}
	183	fn foo2(arg: anytype) bool {
	184	return !arg;
	185	}
	186
	187	test "generic struct" {
	188	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
	189	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	190	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	191	var a1 = GenNode(i32){
	192	.value = 13,
	193	.next = null,
	194	};
	195	var b1 = GenNode(bool){
	196	.value = true,
	197	.next = null,
	198	};
	199	try expect(a1.value == 13);
	200	try expect(a1.value == a1.getVal());
	201	try expect(b1.getVal());
	202	}
	203	fn GenNode(comptime T: type) type {
	204	return struct {
	205	value: T,
	206	next: ?*GenNode(T),
	207	fn getVal(n: *const GenNode(T)) T {
	208	return n.value;
	209	}
	210	};
	211	}

test/behavior/generics_llvm.zig deleted-49

...	...	@@ -1,49 +0,0 @@
1		const std = @import("std");
2		const expect = std.testing.expect;
3		const builtin = @import("builtin");
4
5		const foos = [_]fn (anytype) bool{
6		foo1,
7		foo2,
8		};
9
10		fn foo1(arg: anytype) bool {
11		return arg;
12		}
13		fn foo2(arg: anytype) bool {
14		return !arg;
15		}
16
17		test "array of generic fns" {
18		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
19		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
20		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
21		try expect(foos[0](true));
22		try expect(!foos[1](true));
23		}
24
25		test "generic struct" {
26		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
27		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
28		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
29		var a1 = GenNode(i32){
30		.value = 13,
31		.next = null,
32		};
33		var b1 = GenNode(bool){
34		.value = true,
35		.next = null,
36		};
37		try expect(a1.value == 13);
38		try expect(a1.value == a1.getVal());
39		try expect(b1.getVal());
40		}
41		fn GenNode(comptime T: type) type {
42		return struct {
43		value: T,
44		next: ?*GenNode(T),
45		fn getVal(n: *const GenNode(T)) T {
46		return n.value;
47		}
48		};
49		}

test/behavior/saturating_arithmetic.zig+22

...	...	@@ -118,3 +118,25 @@ test "saturating shift-left" {
118	118	try S.doTheTest();
119	119	comptime try S.doTheTest();
120	120	}
	121
	122	test "saturating shl uses the LHS type" {
	123	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	124
	125	const lhs_const: u8 = 1;
	126	var lhs_var: u8 = 1;
	127
	128	const rhs_const: usize = 8;
	129	var rhs_var: usize = 8;
	130
	131	try expect((lhs_const <<\| 8) == 255);
	132	try expect((lhs_const <<\| rhs_const) == 255);
	133	try expect((lhs_const <<\| rhs_var) == 255);
	134
	135	try expect((lhs_var <<\| 8) == 255);
	136	try expect((lhs_var <<\| rhs_const) == 255);
	137	try expect((lhs_var <<\| rhs_var) == 255);
	138
	139	try expect((@as(u8, 1) <<\| 8) == 255);
	140	try expect((@as(u8, 1) <<\| rhs_const) == 255);
	141	try expect((@as(u8, 1) <<\| rhs_var) == 255);
	142	}

test/behavior/saturating_arithmetic_stage1.zig deleted-22

...	...	@@ -1,22 +0,0 @@
1		const std = @import("std");
2		const expect = std.testing.expect;
3
4		test "saturating shl uses the LHS type" {
5		const lhs_const: u8 = 1;
6		var lhs_var: u8 = 1;
7
8		const rhs_const: usize = 8;
9		var rhs_var: usize = 8;
10
11		try expect((lhs_const <<\| 8) == 255);
12		try expect((lhs_const <<\| rhs_const) == 255);
13		try expect((lhs_const <<\| rhs_var) == 255);
14
15		try expect((lhs_var <<\| 8) == 255);
16		try expect((lhs_var <<\| rhs_const) == 255);
17		try expect((lhs_var <<\| rhs_var) == 255);
18
19		try expect((@as(u8, 1) <<\| 8) == 255);
20		try expect((@as(u8, 1) <<\| rhs_const) == 255);
21		try expect((@as(u8, 1) <<\| rhs_var) == 255);
22		}

test/behavior/struct_llvm.zig+510

...	...	@@ -305,3 +305,513 @@ test "default struct initialization fields" {
305	305	try expect(y.b == x.b);
306	306	try expect(1239 == x.a + x.b);
307	307	}
	308
	309	// TODO revisit this test when doing https://github.com/ziglang/zig/issues/1512
	310	test "packed array 24bits" {
	311	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	312
	313	comptime {
	314	try expect(@sizeOf([9]Foo32Bits) == 9 * 4);
	315	try expect(@sizeOf(FooArray24Bits) == 2 + 2 * 4 + 2);
	316	}
	317
	318	var bytes = [_]u8{0} ** (@sizeOf(FooArray24Bits) + 1);
	319	bytes[bytes.len - 1] = 0xaa;
	320	const ptr = &std.mem.bytesAsSlice(FooArray24Bits, bytes[0 .. bytes.len - 1])[0];
	321	try expect(ptr.a == 0);
	322	try expect(ptr.b[0].field == 0);
	323	try expect(ptr.b[1].field == 0);
	324	try expect(ptr.c == 0);
	325
	326	ptr.a = maxInt(u16);
	327	try expect(ptr.a == maxInt(u16));
	328	try expect(ptr.b[0].field == 0);
	329	try expect(ptr.b[1].field == 0);
	330	try expect(ptr.c == 0);
	331
	332	ptr.b[0].field = maxInt(u24);
	333	try expect(ptr.a == maxInt(u16));
	334	try expect(ptr.b[0].field == maxInt(u24));
	335	try expect(ptr.b[1].field == 0);
	336	try expect(ptr.c == 0);
	337
	338	ptr.b[1].field = maxInt(u24);
	339	try expect(ptr.a == maxInt(u16));
	340	try expect(ptr.b[0].field == maxInt(u24));
	341	try expect(ptr.b[1].field == maxInt(u24));
	342	try expect(ptr.c == 0);
	343
	344	ptr.c = maxInt(u16);
	345	try expect(ptr.a == maxInt(u16));
	346	try expect(ptr.b[0].field == maxInt(u24));
	347	try expect(ptr.b[1].field == maxInt(u24));
	348	try expect(ptr.c == maxInt(u16));
	349
	350	try expect(bytes[bytes.len - 1] == 0xaa);
	351	}
	352
	353	const Foo32Bits = packed struct {
	354	field: u24,
	355	pad: u8,
	356	};
	357
	358	const FooArray24Bits = packed struct {
	359	a: u16,
	360	b: [2]Foo32Bits,
	361	c: u16,
	362	};
	363
	364	test "aligned array of packed struct" {
	365	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	366
	367	comptime {
	368	try expect(@sizeOf(FooStructAligned) == 2);
	369	try expect(@sizeOf(FooArrayOfAligned) == 2 * 2);
	370	}
	371
	372	var bytes = [_]u8{0xbb} ** @sizeOf(FooArrayOfAligned);
	373	const ptr = &std.mem.bytesAsSlice(FooArrayOfAligned, bytes[0..])[0];
	374
	375	try expect(ptr.a[0].a == 0xbb);
	376	try expect(ptr.a[0].b == 0xbb);
	377	try expect(ptr.a[1].a == 0xbb);
	378	try expect(ptr.a[1].b == 0xbb);
	379	}
	380
	381	const FooStructAligned = packed struct {
	382	a: u8,
	383	b: u8,
	384	};
	385
	386	const FooArrayOfAligned = packed struct {
	387	a: [2]FooStructAligned,
	388	};
	389
	390	test "pointer to packed struct member in a stack variable" {
	391	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	392
	393	const S = packed struct {
	394	a: u2,
	395	b: u2,
	396	};
	397
	398	var s = S{ .a = 2, .b = 0 };
	399	var b_ptr = &s.b;
	400	try expect(s.b == 0);
	401	b_ptr.* = 2;
	402	try expect(s.b == 2);
	403	}
	404
	405	test "non-byte-aligned array inside packed struct" {
	406	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	407
	408	const Foo = packed struct {
	409	a: bool,
	410	b: [0x16]u8,
	411	};
	412	const S = struct {
	413	fn bar(slice: []const u8) !void {
	414	try expectEqualSlices(u8, slice, "abcdefghijklmnopqurstu");
	415	}
	416	fn doTheTest() !void {
	417	var foo = Foo{
	418	.a = true,
	419	.b = "abcdefghijklmnopqurstu".*,
	420	};
	421	const value = foo.b;
	422	try bar(&value);
	423	}
	424	};
	425	try S.doTheTest();
	426	comptime try S.doTheTest();
	427	}
	428
	429	test "packed struct with u0 field access" {
	430	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	431
	432	const S = packed struct {
	433	f0: u0,
	434	};
	435	var s = S{ .f0 = 0 };
	436	comptime try expect(s.f0 == 0);
	437	}
	438
	439	test "access to global struct fields" {
	440	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	441
	442	g_foo.bar.value = 42;
	443	try expect(g_foo.bar.value == 42);
	444	}
	445
	446	const S0 = struct {
	447	bar: S1,
	448
	449	pub const S1 = struct {
	450	value: u8,
	451	};
	452
	453	fn init() @This() {
	454	return S0{ .bar = S1{ .value = 123 } };
	455	}
	456	};
	457
	458	var g_foo: S0 = S0.init();
	459
	460	test "packed struct with fp fields" {
	461	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	462
	463	const S = packed struct {
	464	data: [3]f32,
	465
	466	pub fn frob(self: *@This()) void {
	467	self.data[0] += self.data[1] + self.data[2];
	468	self.data[1] += self.data[0] + self.data[2];
	469	self.data[2] += self.data[0] + self.data[1];
	470	}
	471	};
	472
	473	var s: S = undefined;
	474	s.data[0] = 1.0;
	475	s.data[1] = 2.0;
	476	s.data[2] = 3.0;
	477	s.frob();
	478	try expectEqual(@as(f32, 6.0), s.data[0]);
	479	try expectEqual(@as(f32, 11.0), s.data[1]);
	480	try expectEqual(@as(f32, 20.0), s.data[2]);
	481	}
	482
	483	test "fn with C calling convention returns struct by value" {
	484	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	485
	486	const S = struct {
	487	fn entry() !void {
	488	var x = makeBar(10);
	489	try expectEqual(@as(i32, 10), x.handle);
	490	}
	491
	492	const ExternBar = extern struct {
	493	handle: i32,
	494	};
	495
	496	fn makeBar(t: i32) callconv(.C) ExternBar {
	497	return ExternBar{
	498	.handle = t,
	499	};
	500	}
	501	};
	502	try S.entry();
	503	comptime try S.entry();
	504	}
	505
	506	test "non-packed struct with u128 entry in union" {
	507	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	508
	509	const U = union(enum) {
	510	Num: u128,
	511	Void,
	512	};
	513
	514	const S = struct {
	515	f1: U,
	516	f2: U,
	517	};
	518
	519	var sx: S = undefined;
	520	var s = &sx;
	521	try std.testing.expect(@ptrToInt(&s.f2) - @ptrToInt(&s.f1) == @offsetOf(S, "f2"));
	522	var v2 = U{ .Num = 123 };
	523	s.f2 = v2;
	524	try std.testing.expect(s.f2.Num == 123);
	525	}
	526
	527	test "packed struct field passed to generic function" {
	528	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	529
	530	const S = struct {
	531	const P = packed struct {
	532	b: u5,
	533	g: u5,
	534	r: u5,
	535	a: u1,
	536	};
	537
	538	fn genericReadPackedField(ptr: anytype) u5 {
	539	return ptr.*;
	540	}
	541	};
	542
	543	var p: S.P = undefined;
	544	p.b = 29;
	545	var loaded = S.genericReadPackedField(&p.b);
	546	try expect(loaded == 29);
	547	}
	548
	549	test "anonymous struct literal syntax" {
	550	const S = struct {
	551	const Point = struct {
	552	x: i32,
	553	y: i32,
	554	};
	555
	556	fn doTheTest() !void {
	557	var p: Point = .{
	558	.x = 1,
	559	.y = 2,
	560	};
	561	try expect(p.x == 1);
	562	try expect(p.y == 2);
	563	}
	564	};
	565	try S.doTheTest();
	566	comptime try S.doTheTest();
	567	}
	568
	569	test "fully anonymous struct" {
	570	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	571
	572	const S = struct {
	573	fn doTheTest() !void {
	574	try dump(.{
	575	.int = @as(u32, 1234),
	576	.float = @as(f64, 12.34),
	577	.b = true,
	578	.s = "hi",
	579	});
	580	}
	581	fn dump(args: anytype) !void {
	582	try expect(args.int == 1234);
	583	try expect(args.float == 12.34);
	584	try expect(args.b);
	585	try expect(args.s[0] == 'h');
	586	try expect(args.s[1] == 'i');
	587	}
	588	};
	589	try S.doTheTest();
	590	comptime try S.doTheTest();
	591	}
	592
	593	test "fully anonymous list literal" {
	594	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	595
	596	const S = struct {
	597	fn doTheTest() !void {
	598	try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
	599	}
	600	fn dump(args: anytype) !void {
	601	try expect(args.@"0" == 1234);
	602	try expect(args.@"1" == 12.34);
	603	try expect(args.@"2");
	604	try expect(args.@"3"[0] == 'h');
	605	try expect(args.@"3"[1] == 'i');
	606	}
	607	};
	608	try S.doTheTest();
	609	comptime try S.doTheTest();
	610	}
	611
	612	test "anonymous struct literal assigned to variable" {
	613	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	614
	615	var vec = .{ @as(i32, 22), @as(i32, 55), @as(i32, 99) };
	616	try expect(vec.@"0" == 22);
	617	try expect(vec.@"1" == 55);
	618	try expect(vec.@"2" == 99);
	619	}
	620
	621	test "struct with var field" {
	622	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	623
	624	const Point = struct {
	625	x: anytype,
	626	y: anytype,
	627	};
	628	const pt = Point{
	629	.x = 1,
	630	.y = 2,
	631	};
	632	try expect(pt.x == 1);
	633	try expect(pt.y == 2);
	634	}
	635
	636	test "comptime struct field" {
	637	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	638
	639	const T = struct {
	640	a: i32,
	641	comptime b: i32 = 1234,
	642	};
	643
	644	var foo: T = undefined;
	645	comptime try expect(foo.b == 1234);
	646	}
	647
	648	test "anon struct literal field value initialized with fn call" {
	649	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	650
	651	const S = struct {
	652	fn doTheTest() !void {
	653	var x = .{foo()};
	654	try expectEqualSlices(u8, x[0], "hi");
	655	}
	656	fn foo() []const u8 {
	657	return "hi";
	658	}
	659	};
	660	try S.doTheTest();
	661	comptime try S.doTheTest();
	662	}
	663
	664	test "struct with union field" {
	665	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	666
	667	const Value = struct {
	668	ref: u32 = 2,
	669	kind: union(enum) {
	670	None: usize,
	671	Bool: bool,
	672	},
	673	};
	674
	675	var True = Value{
	676	.kind = .{ .Bool = true },
	677	};
	678	try expectEqual(@as(u32, 2), True.ref);
	679	try expectEqual(true, True.kind.Bool);
	680	}
	681
	682	test "type coercion of anon struct literal to struct" {
	683	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	684
	685	const S = struct {
	686	const S2 = struct {
	687	A: u32,
	688	B: []const u8,
	689	C: void,
	690	D: Foo = .{},
	691	};
	692
	693	const Foo = struct {
	694	field: i32 = 1234,
	695	};
	696
	697	fn doTheTest() !void {
	698	var y: u32 = 42;
	699	const t0 = .{ .A = 123, .B = "foo", .C = {} };
	700	const t1 = .{ .A = y, .B = "foo", .C = {} };
	701	const y0: S2 = t0;
	702	var y1: S2 = t1;
	703	try expect(y0.A == 123);
	704	try expect(std.mem.eql(u8, y0.B, "foo"));
	705	try expect(y0.C == {});
	706	try expect(y0.D.field == 1234);
	707	try expect(y1.A == y);
	708	try expect(std.mem.eql(u8, y1.B, "foo"));
	709	try expect(y1.C == {});
	710	try expect(y1.D.field == 1234);
	711	}
	712	};
	713	try S.doTheTest();
	714	comptime try S.doTheTest();
	715	}
	716
	717	test "type coercion of pointer to anon struct literal to pointer to struct" {
	718	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	719
	720	const S = struct {
	721	const S2 = struct {
	722	A: u32,
	723	B: []const u8,
	724	C: void,
	725	D: Foo = .{},
	726	};
	727
	728	const Foo = struct {
	729	field: i32 = 1234,
	730	};
	731
	732	fn doTheTest() !void {
	733	var y: u32 = 42;
	734	const t0 = &.{ .A = 123, .B = "foo", .C = {} };
	735	const t1 = &.{ .A = y, .B = "foo", .C = {} };
	736	const y0: *const S2 = t0;
	737	var y1: *const S2 = t1;
	738	try expect(y0.A == 123);
	739	try expect(std.mem.eql(u8, y0.B, "foo"));
	740	try expect(y0.C == {});
	741	try expect(y0.D.field == 1234);
	742	try expect(y1.A == y);
	743	try expect(std.mem.eql(u8, y1.B, "foo"));
	744	try expect(y1.C == {});
	745	try expect(y1.D.field == 1234);
	746	}
	747	};
	748	try S.doTheTest();
	749	comptime try S.doTheTest();
	750	}
	751
	752	test "packed struct with undefined initializers" {
	753	const S = struct {
	754	const P = packed struct {
	755	a: u3,
	756	_a: u3 = undefined,
	757	b: u3,
	758	_b: u3 = undefined,
	759	c: u3,
	760	_c: u3 = undefined,
	761	};
	762
	763	fn doTheTest() !void {
	764	var p: P = undefined;
	765	p = P{ .a = 2, .b = 4, .c = 6 };
	766	// Make sure the compiler doesn't touch the unprefixed fields.
	767	// Use expect since i386-linux doesn't like expectEqual
	768	try expect(p.a == 2);
	769	try expect(p.b == 4);
	770	try expect(p.c == 6);
	771	}
	772	};
	773
	774	try S.doTheTest();
	775	comptime try S.doTheTest();
	776	}
	777
	778	test "for loop over pointers to struct, getting field from struct pointer" {
	779	// When enabling this test, be careful. I have observed it to pass when compiling
	780	// stage2 alone, but when using stage1 with -fno-stage1 -fLLVM it fails.
	781	// Maybe eyeball the LLVM that it generates and run in valgrind, both the compiler
	782	// and the generated test at runtime.
	783	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	784
	785	const S = struct {
	786	const Foo = struct {
	787	name: []const u8,
	788	};
	789
	790	var ok = true;
	791
	792	fn eql(a: []const u8) bool {
	793	_ = a;
	794	return true;
	795	}
	796
	797	const ArrayList = struct {
	798	fn toSlice(self: ArrayList) []Foo {
	799	_ = self;
	800	return @as([]Foo, undefined)[0..0];
	801	}
	802	};
	803
	804	fn doTheTest() !void {
	805	var objects: ArrayList = undefined;
	806
	807	for (objects.toSlice()) \|obj\| {
	808	if (eql(obj.name)) {
	809	ok = false;
	810	}
	811	}
	812
	813	try expect(ok);
	814	}
	815	};
	816	try S.doTheTest();
	817	}

test/behavior/struct_stage1.zig deleted-473

...	...	@@ -1,473 +0,0 @@
1		const std = @import("std");
2		const builtin = @import("builtin");
3		const native_endian = builtin.target.cpu.arch.endian();
4		const expect = std.testing.expect;
5		const expectEqual = std.testing.expectEqual;
6		const expectEqualSlices = std.testing.expectEqualSlices;
7		const maxInt = std.math.maxInt;
8
9		const Foo32Bits = packed struct {
10		field: u24,
11		pad: u8,
12		};
13
14		const FooArray24Bits = packed struct {
15		a: u16,
16		b: [2]Foo32Bits,
17		c: u16,
18		};
19
20		// TODO revisit this test when doing https://github.com/ziglang/zig/issues/1512
21		test "packed array 24bits" {
22		comptime {
23		try expect(@sizeOf([9]Foo32Bits) == 9 * 4);
24		try expect(@sizeOf(FooArray24Bits) == 2 + 2 * 4 + 2);
25		}
26
27		var bytes = [_]u8{0} ** (@sizeOf(FooArray24Bits) + 1);
28		bytes[bytes.len - 1] = 0xaa;
29		const ptr = &std.mem.bytesAsSlice(FooArray24Bits, bytes[0 .. bytes.len - 1])[0];
30		try expect(ptr.a == 0);
31		try expect(ptr.b[0].field == 0);
32		try expect(ptr.b[1].field == 0);
33		try expect(ptr.c == 0);
34
35		ptr.a = maxInt(u16);
36		try expect(ptr.a == maxInt(u16));
37		try expect(ptr.b[0].field == 0);
38		try expect(ptr.b[1].field == 0);
39		try expect(ptr.c == 0);
40
41		ptr.b[0].field = maxInt(u24);
42		try expect(ptr.a == maxInt(u16));
43		try expect(ptr.b[0].field == maxInt(u24));
44		try expect(ptr.b[1].field == 0);
45		try expect(ptr.c == 0);
46
47		ptr.b[1].field = maxInt(u24);
48		try expect(ptr.a == maxInt(u16));
49		try expect(ptr.b[0].field == maxInt(u24));
50		try expect(ptr.b[1].field == maxInt(u24));
51		try expect(ptr.c == 0);
52
53		ptr.c = maxInt(u16);
54		try expect(ptr.a == maxInt(u16));
55		try expect(ptr.b[0].field == maxInt(u24));
56		try expect(ptr.b[1].field == maxInt(u24));
57		try expect(ptr.c == maxInt(u16));
58
59		try expect(bytes[bytes.len - 1] == 0xaa);
60		}
61
62		const FooStructAligned = packed struct {
63		a: u8,
64		b: u8,
65		};
66
67		const FooArrayOfAligned = packed struct {
68		a: [2]FooStructAligned,
69		};
70
71		test "aligned array of packed struct" {
72		comptime {
73		try expect(@sizeOf(FooStructAligned) == 2);
74		try expect(@sizeOf(FooArrayOfAligned) == 2 * 2);
75		}
76
77		var bytes = [_]u8{0xbb} ** @sizeOf(FooArrayOfAligned);
78		const ptr = &std.mem.bytesAsSlice(FooArrayOfAligned, bytes[0..])[0];
79
80		try expect(ptr.a[0].a == 0xbb);
81		try expect(ptr.a[0].b == 0xbb);
82		try expect(ptr.a[1].a == 0xbb);
83		try expect(ptr.a[1].b == 0xbb);
84		}
85
86		test "pointer to packed struct member in a stack variable" {
87		const S = packed struct {
88		a: u2,
89		b: u2,
90		};
91
92		var s = S{ .a = 2, .b = 0 };
93		var b_ptr = &s.b;
94		try expect(s.b == 0);
95		b_ptr.* = 2;
96		try expect(s.b == 2);
97		}
98
99		test "non-byte-aligned array inside packed struct" {
100		const Foo = packed struct {
101		a: bool,
102		b: [0x16]u8,
103		};
104		const S = struct {
105		fn bar(slice: []const u8) !void {
106		try expectEqualSlices(u8, slice, "abcdefghijklmnopqurstu");
107		}
108		fn doTheTest() !void {
109		var foo = Foo{
110		.a = true,
111		.b = "abcdefghijklmnopqurstu".*,
112		};
113		const value = foo.b;
114		try bar(&value);
115		}
116		};
117		try S.doTheTest();
118		comptime try S.doTheTest();
119		}
120
121		test "packed struct with u0 field access" {
122		const S = packed struct {
123		f0: u0,
124		};
125		var s = S{ .f0 = 0 };
126		comptime try expect(s.f0 == 0);
127		}
128
129		const S0 = struct {
130		bar: S1,
131
132		pub const S1 = struct {
133		value: u8,
134		};
135
136		fn init() @This() {
137		return S0{ .bar = S1{ .value = 123 } };
138		}
139		};
140
141		var g_foo: S0 = S0.init();
142
143		test "access to global struct fields" {
144		g_foo.bar.value = 42;
145		try expect(g_foo.bar.value == 42);
146		}
147
148		test "packed struct with fp fields" {
149		const S = packed struct {
150		data: [3]f32,
151
152		pub fn frob(self: *@This()) void {
153		self.data[0] += self.data[1] + self.data[2];
154		self.data[1] += self.data[0] + self.data[2];
155		self.data[2] += self.data[0] + self.data[1];
156		}
157		};
158
159		var s: S = undefined;
160		s.data[0] = 1.0;
161		s.data[1] = 2.0;
162		s.data[2] = 3.0;
163		s.frob();
164		try expectEqual(@as(f32, 6.0), s.data[0]);
165		try expectEqual(@as(f32, 11.0), s.data[1]);
166		try expectEqual(@as(f32, 20.0), s.data[2]);
167		}
168
169		test "fn with C calling convention returns struct by value" {
170		const S = struct {
171		fn entry() !void {
172		var x = makeBar(10);
173		try expectEqual(@as(i32, 10), x.handle);
174		}
175
176		const ExternBar = extern struct {
177		handle: i32,
178		};
179
180		fn makeBar(t: i32) callconv(.C) ExternBar {
181		return ExternBar{
182		.handle = t,
183		};
184		}
185		};
186		try S.entry();
187		comptime try S.entry();
188		}
189
190		test "non-packed struct with u128 entry in union" {
191		const U = union(enum) {
192		Num: u128,
193		Void,
194		};
195
196		const S = struct {
197		f1: U,
198		f2: U,
199		};
200
201		var sx: S = undefined;
202		var s = &sx;
203		try std.testing.expect(@ptrToInt(&s.f2) - @ptrToInt(&s.f1) == @offsetOf(S, "f2"));
204		var v2 = U{ .Num = 123 };
205		s.f2 = v2;
206		try std.testing.expect(s.f2.Num == 123);
207		}
208
209		test "packed struct field passed to generic function" {
210		const S = struct {
211		const P = packed struct {
212		b: u5,
213		g: u5,
214		r: u5,
215		a: u1,
216		};
217
218		fn genericReadPackedField(ptr: anytype) u5 {
219		return ptr.*;
220		}
221		};
222
223		var p: S.P = undefined;
224		p.b = 29;
225		var loaded = S.genericReadPackedField(&p.b);
226		try expect(loaded == 29);
227		}
228
229		test "anonymous struct literal syntax" {
230		const S = struct {
231		const Point = struct {
232		x: i32,
233		y: i32,
234		};
235
236		fn doTheTest() !void {
237		var p: Point = .{
238		.x = 1,
239		.y = 2,
240		};
241		try expect(p.x == 1);
242		try expect(p.y == 2);
243		}
244		};
245		try S.doTheTest();
246		comptime try S.doTheTest();
247		}
248
249		test "fully anonymous struct" {
250		const S = struct {
251		fn doTheTest() !void {
252		try dump(.{
253		.int = @as(u32, 1234),
254		.float = @as(f64, 12.34),
255		.b = true,
256		.s = "hi",
257		});
258		}
259		fn dump(args: anytype) !void {
260		try expect(args.int == 1234);
261		try expect(args.float == 12.34);
262		try expect(args.b);
263		try expect(args.s[0] == 'h');
264		try expect(args.s[1] == 'i');
265		}
266		};
267		try S.doTheTest();
268		comptime try S.doTheTest();
269		}
270
271		test "fully anonymous list literal" {
272		const S = struct {
273		fn doTheTest() !void {
274		try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
275		}
276		fn dump(args: anytype) !void {
277		try expect(args.@"0" == 1234);
278		try expect(args.@"1" == 12.34);
279		try expect(args.@"2");
280		try expect(args.@"3"[0] == 'h');
281		try expect(args.@"3"[1] == 'i');
282		}
283		};
284		try S.doTheTest();
285		comptime try S.doTheTest();
286		}
287
288		test "anonymous struct literal assigned to variable" {
289		var vec = .{ @as(i32, 22), @as(i32, 55), @as(i32, 99) };
290		try expect(vec.@"0" == 22);
291		try expect(vec.@"1" == 55);
292		try expect(vec.@"2" == 99);
293		}
294
295		test "struct with var field" {
296		const Point = struct {
297		x: anytype,
298		y: anytype,
299		};
300		const pt = Point{
301		.x = 1,
302		.y = 2,
303		};
304		try expect(pt.x == 1);
305		try expect(pt.y == 2);
306		}
307
308		test "comptime struct field" {
309		const T = struct {
310		a: i32,
311		comptime b: i32 = 1234,
312		};
313
314		var foo: T = undefined;
315		comptime try expect(foo.b == 1234);
316		}
317
318		test "anon struct literal field value initialized with fn call" {
319		const S = struct {
320		fn doTheTest() !void {
321		var x = .{foo()};
322		try expectEqualSlices(u8, x[0], "hi");
323		}
324		fn foo() []const u8 {
325		return "hi";
326		}
327		};
328		try S.doTheTest();
329		comptime try S.doTheTest();
330		}
331
332		test "struct with union field" {
333		const Value = struct {
334		ref: u32 = 2,
335		kind: union(enum) {
336		None: usize,
337		Bool: bool,
338		},
339		};
340
341		var True = Value{
342		.kind = .{ .Bool = true },
343		};
344		try expectEqual(@as(u32, 2), True.ref);
345		try expectEqual(true, True.kind.Bool);
346		}
347
348		test "type coercion of anon struct literal to struct" {
349		const S = struct {
350		const S2 = struct {
351		A: u32,
352		B: []const u8,
353		C: void,
354		D: Foo = .{},
355		};
356
357		const Foo = struct {
358		field: i32 = 1234,
359		};
360
361		fn doTheTest() !void {
362		var y: u32 = 42;
363		const t0 = .{ .A = 123, .B = "foo", .C = {} };
364		const t1 = .{ .A = y, .B = "foo", .C = {} };
365		const y0: S2 = t0;
366		var y1: S2 = t1;
367		try expect(y0.A == 123);
368		try expect(std.mem.eql(u8, y0.B, "foo"));
369		try expect(y0.C == {});
370		try expect(y0.D.field == 1234);
371		try expect(y1.A == y);
372		try expect(std.mem.eql(u8, y1.B, "foo"));
373		try expect(y1.C == {});
374		try expect(y1.D.field == 1234);
375		}
376		};
377		try S.doTheTest();
378		comptime try S.doTheTest();
379		}
380
381		test "type coercion of pointer to anon struct literal to pointer to struct" {
382		const S = struct {
383		const S2 = struct {
384		A: u32,
385		B: []const u8,
386		C: void,
387		D: Foo = .{},
388		};
389
390		const Foo = struct {
391		field: i32 = 1234,
392		};
393
394		fn doTheTest() !void {
395		var y: u32 = 42;
396		const t0 = &.{ .A = 123, .B = "foo", .C = {} };
397		const t1 = &.{ .A = y, .B = "foo", .C = {} };
398		const y0: *const S2 = t0;
399		var y1: *const S2 = t1;
400		try expect(y0.A == 123);
401		try expect(std.mem.eql(u8, y0.B, "foo"));
402		try expect(y0.C == {});
403		try expect(y0.D.field == 1234);
404		try expect(y1.A == y);
405		try expect(std.mem.eql(u8, y1.B, "foo"));
406		try expect(y1.C == {});
407		try expect(y1.D.field == 1234);
408		}
409		};
410		try S.doTheTest();
411		comptime try S.doTheTest();
412		}
413
414		test "packed struct with undefined initializers" {
415		const S = struct {
416		const P = packed struct {
417		a: u3,
418		_a: u3 = undefined,
419		b: u3,
420		_b: u3 = undefined,
421		c: u3,
422		_c: u3 = undefined,
423		};
424
425		fn doTheTest() !void {
426		var p: P = undefined;
427		p = P{ .a = 2, .b = 4, .c = 6 };
428		// Make sure the compiler doesn't touch the unprefixed fields.
429		// Use expect since i386-linux doesn't like expectEqual
430		try expect(p.a == 2);
431		try expect(p.b == 4);
432		try expect(p.c == 6);
433		}
434		};
435
436		try S.doTheTest();
437		comptime try S.doTheTest();
438		}
439
440		test "for loop over pointers to struct, getting field from struct pointer" {
441		const S = struct {
442		const Foo = struct {
443		name: []const u8,
444		};
445
446		var ok = true;
447
448		fn eql(a: []const u8) bool {
449		_ = a;
450		return true;
451		}
452
453		const ArrayList = struct {
454		fn toSlice(self: ArrayList) []Foo {
455		_ = self;
456		return @as([]Foo, undefined)[0..0];
457		}
458		};
459
460		fn doTheTest() !void {
461		var objects: ArrayList = undefined;
462
463		for (objects.toSlice()) \|obj\| {
464		if (eql(obj.name)) {
465		ok = false;
466		}
467		}
468
469		try expect(ok);
470		}
471		};
472		try S.doTheTest();
473		}

test/behavior/translate_c_macros.zig+31

...	...	@@ -1,3 +1,4 @@
	1	const builtin = @import("builtin");
1	2	const std = @import("std");
2	3	const expect = std.testing.expect;
3	4	const expectEqual = std.testing.expectEqual;
...	...	@@ -16,3 +17,33 @@ test "casting to void with a macro" {
16	17	h.IGNORE_ME_9(42);
17	18	h.IGNORE_ME_10(42);
18	19	}
	20
	21	test "initializer list expression" {
	22	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	23
	24	try expectEqual(h.Color{
	25	.r = 200,
	26	.g = 200,
	27	.b = 200,
	28	.a = 255,
	29	}, h.LIGHTGRAY);
	30	}
	31
	32	test "sizeof in macros" {
	33	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	34
	35	try expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF(u32));
	36	try expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF2(u32));
	37	}
	38
	39	test "reference to a struct type" {
	40	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	41
	42	try expectEqual(@sizeOf(h.struct_Foo), h.SIZE_OF_FOO);
	43	}
	44
	45	test "cast negative integer to pointer" {
	46	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	47
	48	try expectEqual(@intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))), h.MAP_FAILED);
	49	}

test/behavior/translate_c_macros_stage1.zig deleted-27

...	...	@@ -1,27 +0,0 @@
1		const std = @import("std");
2		const expect = std.testing.expect;
3		const expectEqual = std.testing.expectEqual;
4
5		const h = @cImport(@cInclude("behavior/translate_c_macros.h"));
6
7		test "initializer list expression" {
8		try expectEqual(h.Color{
9		.r = 200,
10		.g = 200,
11		.b = 200,
12		.a = 255,
13		}, h.LIGHTGRAY);
14		}
15
16		test "sizeof in macros" {
17		try expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF(u32));
18		try expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF2(u32));
19		}
20
21		test "reference to a struct type" {
22		try expectEqual(@sizeOf(h.struct_Foo), h.SIZE_OF_FOO);
23		}
24
25		test "cast negative integer to pointer" {
26		try expectEqual(@intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))), h.MAP_FAILED);
27		}