Meg's Mirrors

zig

1	const builtin = @import("builtin");
2	const std = @import("std");
3	const expect = std.testing.expect;
4
5	test "optional type" {
6	const x: ?bool = true;
7
8	if (x) |y| {
9	if (y) {
10	// OK
11	} else {
12	unreachable;
13	}
14	} else {
15	unreachable;
16	}
17
18	const next_x: ?i32 = null;
19
20	const z = next_x orelse 1234;
21
22	try expect(z == 1234);
23
24	const final_x: ?i32 = 13;
25
26	const num = final_x orelse unreachable;
27
28	try expect(num == 13);
29	}
30
31	test "test maybe object and get a pointer to the inner value" {
32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
35	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
36
37	var maybe_bool: ?bool = true;
38
39	if (maybe_bool) |*b| {
40	b.* = false;
41	}
42
43	try expect(maybe_bool.? == false);
44	}
45
46	test "rhs maybe unwrap return" {
47	const x: ?bool = true;
48	const y = x orelse return;
49	_ = y;
50	}
51
52	test "maybe return" {
53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
54	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
55
56	try maybeReturnImpl();
57	try comptime maybeReturnImpl();
58	}
59
60	fn maybeReturnImpl() !void {
61	try expect(foo(1235).?);
62	if (foo(null) != null) unreachable;
63	try expect(!foo(1234).?);
64	}
65
66	fn foo(x: ?i32) ?bool {
67	const value = x orelse return null;
68	return value > 1234;
69	}
70
71	test "test null runtime" {
72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
73	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
74
75	try testTestNullRuntime(null);
76	}
77	fn testTestNullRuntime(x: ?i32) !void {
78	try expect(x == null);
79	try expect(!(x != null));
80	}
81
82	test "optional void" {
83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
85
86	try optionalVoidImpl();
87	try comptime optionalVoidImpl();
88	}
89
90	fn optionalVoidImpl() !void {
91	try expect(bar(null) == null);
92	try expect(bar({}) != null);
93	}
94
95	fn bar(x: ?void) ?void {
96	if (x) |_| {
97	return {};
98	} else {
99	return null;
100	}
101	}
102
103	const Empty = struct {};
104
105	test "optional struct{}" {
106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
108
109	_ = try optionalEmptyStructImpl();
110	_ = try comptime optionalEmptyStructImpl();
111	}
112
113	fn optionalEmptyStructImpl() !void {
114	try expect(baz(null) == null);
115	try expect(baz(Empty{}) != null);
116	}
117
118	fn baz(x: ?Empty) ?Empty {
119	if (x) |_| {
120	return Empty{};
121	} else {
122	return null;
123	}
124	}
125
126	test "null with default unwrap" {
127	const x: i32 = null orelse 1;
128	try expect(x == 1);
129	}
130
131	test "optional pointer to 0 bit type null value at runtime" {
132	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
133	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
134
135	const EmptyStruct = struct {};
136	var x: ?*EmptyStruct = null;
137	_ = &x;
138	try expect(x == null);
139	}
140
141	test "if var maybe pointer" {
142	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
143	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
145	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
146
147	try expect(shouldBeAPlus1(Particle{
148	.a = 14,
149	.b = 1,
150	.c = 1,
151	.d = 1,
152	}) == 15);
153	}
154	fn shouldBeAPlus1(p: Particle) u64 {
155	var maybe_particle: ?Particle = p;
156	if (maybe_particle) |*particle| {
157	particle.a += 1;
158	}
159	if (maybe_particle) |particle| {
160	return particle.a;
161	}
162	return 0;
163	}
164	const Particle = struct {
165	a: u64,
166	b: u64,
167	c: u64,
168	d: u64,
169	};
170
171	test "null literal outside function" {
172	const is_null = here_is_a_null_literal.context == null;
173	try expect(is_null);
174
175	const is_non_null = here_is_a_null_literal.context != null;
176	try expect(!is_non_null);
177	}
178
179	const SillyStruct = struct {
180	context: ?i32,
181	};
182
183	const here_is_a_null_literal = SillyStruct{ .context = null };
184
185	test "unwrap optional which is field of global var" {
186	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
187	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
188
189	struct_with_optional.field = null;
190	if (struct_with_optional.field) |payload| {
191	_ = payload;
192	unreachable;
193	}
194	struct_with_optional.field = 1234;
195	if (struct_with_optional.field) |payload| {
196	try expect(payload == 1234);
197	} else {
198	unreachable;
199	}
200	}
201	const StructWithOptional = struct {
202	field: ?i32,
203	};
204
205	var struct_with_optional: StructWithOptional = undefined;
206
207	test "optional types" {
208	comptime {
209	const opt_type_struct = StructWithOptionalType{ .t = u8 };
210	try expect(opt_type_struct.t != null and opt_type_struct.t.? == u8);
211	}
212	}
213
214	const StructWithOptionalType = struct {
215	t: ?type,
216	};