authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2016-12-22 01:20:08-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2016-12-22 01:20:08-05:00
log5a717187571e5eed99087a9b4359f6ac194db1cf
tree19dd55cda5b3b72119b3ed7d04d84c94f0514032
parent5fc95c2a538b10ad346273112b1d4ed5371f8135

IR: port more tests

17 files changed, 425 insertions(+), 401 deletions(-)

test/cases/max_value_type.zig deleted-11
......@@ -1,11 +0,0 @@
1const assert = @import("std").debug.assert;
2
3fn maxValueType() {
4 @setFnTest(this, true);
5
6 // If the type of @maxValue(i32) was i32 then this implicit cast to
7 // u32 would not work. But since the value is a number literal,
8 // it works fine.
9 const x: u32 = @maxValue(i32);
10 assert(x == 2147483647);
11}
test/cases/this.zig deleted-50
......@@ -1,50 +0,0 @@
1const assert = @import("std").debug.assert;
2const module = this;
3
4struct Point(inline T: type) {
5 const Self = this;
6 x: T,
7 y: T,
8
9 fn addOne(self: &Self) {
10 self.x += 1;
11 self.y += 1;
12 }
13}
14
15fn add(x: i32, y: i32) -> i32 {
16 x + y
17}
18
19fn factorial(x: i32) -> i32 {
20 const selfFn = this;
21 if (x == 0) {
22 1
23 } else {
24 x * selfFn(x - 1)
25 }
26}
27
28fn thisReferToModuleCallPrivateFn() {
29 @setFnTest(this, true);
30
31 assert(module.add(1, 2) == 3);
32}
33
34fn thisReferToContainer() {
35 @setFnTest(this, true);
36
37 var pt = Point(i32) {
38 .x = 12,
39 .y = 34,
40 };
41 pt.addOne();
42 assert(pt.x == 13);
43 assert(pt.y == 35);
44}
45
46fn thisReferToFn() {
47 @setFnTest(this, true);
48
49 assert(factorial(5) == 120);
50}
test/cases/zeroes.zig deleted-19
......@@ -1,19 +0,0 @@
1const assert = @import("std").debug.assert;
2
3struct Foo {
4 a: f32,
5 b: i32,
6 c: bool,
7 d: ?i32,
8}
9
10fn initializing_a_struct_with_zeroes() {
11 @setFnTest(this, true);
12
13 const foo: Foo = zeroes;
14 assert(foo.a == 0.0);
15 assert(foo.b == 0);
16 assert(foo.c == false);
17 assert(if (const x ?= foo.d) false else true);
18}
19
test/cases3/array.zig+21
......@@ -24,6 +24,27 @@ fn getArrayLen(a: []u32) -> usize {
2424 a.len
2525}
2626
27fn voidArrays() {
28 @setFnTest(this);
29
30 var array: [4]void = undefined;
31 array[0] = void{};
32 array[1] = array[2];
33 assert(@sizeOf(@typeOf(array)) == 0);
34 assert(array.len == 4);
35}
36
37fn arrayLiteral() {
38 @setFnTest(this);
39
40 const hex_mult = []u16{4096, 256, 16, 1};
41
42 assert(hex_mult.len == 4);
43 assert(hex_mult[1] == 256);
44}
45
46
47
2748// TODO const assert = @import("std").debug.assert;
2849fn assert(ok: bool) {
2950 if (!ok)
test/cases3/bool.zig created+27
......@@ -0,0 +1,27 @@
1fn boolLiterals() {
2 @setFnTest(this);
3
4 assert(true);
5 assert(!false);
6}
7
8fn castBoolToInt() {
9 @setFnTest(this);
10
11 const t = true;
12 const f = false;
13 assert(i32(t) == i32(1));
14 assert(i32(f) == i32(0));
15 nonConstCastBoolToInt(t, f);
16}
17
18fn nonConstCastBoolToInt(t: bool, f: bool) {
19 assert(i32(t) == i32(1));
20 assert(i32(f) == i32(0));
21}
22
23// TODO const assert = @import("std").debug.assert;
24fn assert(ok: bool) {
25 if (!ok)
26 @unreachable();
27}
test/cases3/enum.zig+30
......@@ -43,6 +43,36 @@ fn returnAnInt(x: i32) -> Foo {
4343}
4444
4545
46fn constantEnumWithPayload() {
47 @setFnTest(this);
48
49 var empty = AnEnumWithPayload.Empty;
50 var full = AnEnumWithPayload.Full {13};
51 shouldBeEmpty(empty);
52 shouldBeNotEmpty(full);
53}
54
55fn shouldBeEmpty(x: AnEnumWithPayload) {
56 switch (x) {
57 AnEnumWithPayload.Empty => {},
58 else => @unreachable(),
59 }
60}
61
62fn shouldBeNotEmpty(x: AnEnumWithPayload) {
63 switch (x) {
64 AnEnumWithPayload.Empty => @unreachable(),
65 else => {},
66 }
67}
68
69const AnEnumWithPayload = enum {
70 Empty,
71 Full: i32,
72};
73
74
75
4676fn assert(ok: bool) {
4777 if (!ok)
4878 @unreachable();
test/cases3/error.zig+28
......@@ -29,6 +29,34 @@ fn errorName() {
2929}
3030
3131
32fn errorValues() {
33 @setFnTest(this);
34
35 const a = i32(error.err1);
36 const b = i32(error.err2);
37 assert(a != b);
38}
39error err1;
40error err2;
41
42
43fn redefinitionOfErrorValuesAllowed() {
44 @setFnTest(this);
45
46 shouldBeNotEqual(error.AnError, error.SecondError);
47}
48error AnError;
49error AnError;
50error SecondError;
51fn shouldBeNotEqual(a: error, b: error) {
52 if (a == b) @unreachable()
53}
54
55
56
57
58
59
3260// TODO const assert = @import("std").debug.assert;
3361fn assert(ok: bool) {
3462 if (!ok)
test/cases3/generics.zig+24
......@@ -40,6 +40,30 @@ fn fnWithInlineArgs() {
4040 assert(sameButWithFloats(0.43, 0.49) == 0.49);
4141}
4242
43
44fn varParams() {
45 @setFnTest(this);
46
47 assert(max_i32(12, 34) == 34);
48 assert(max_f64(1.2, 3.4) == 3.4);
49}
50
51// TODO `_`
52const _1 = assert(max_i32(12, 34) == 34);
53const _2 = assert(max_f64(1.2, 3.4) == 3.4);
54
55fn max_var(a: var, b: var) -> @typeOf(a + b) {
56 if (a > b) a else b
57}
58
59fn max_i32(a: i32, b: i32) -> i32 {
60 max_var(a, b)
61}
62
63fn max_f64(a: f64, b: f64) -> f64 {
64 max_var(a, b)
65}
66
4367// TODO const assert = @import("std").debug.assert;
4468fn assert(ok: bool) {
4569 if (!ok)
test/cases3/math.zig+32
......@@ -68,6 +68,38 @@ fn modifyOperators() {
6868 i |= 3; assert(i == 7);
6969}
7070
71fn threeExprInARow() {
72 @setFnTest(this);
73
74 assertFalse(false || false || false);
75 assertFalse(true && true && false);
76 assertFalse(1 | 2 | 4 != 7);
77 assertFalse(3 ^ 6 ^ 8 != 13);
78 assertFalse(7 & 14 & 28 != 4);
79 assertFalse(9 << 1 << 2 != 9 << 3);
80 assertFalse(90 >> 1 >> 2 != 90 >> 3);
81 assertFalse(100 - 1 + 1000 != 1099);
82 assertFalse(5 * 4 / 2 % 3 != 1);
83 assertFalse(i32(i32(5)) != 5);
84 assertFalse(!!false);
85 assertFalse(i32(7) != --(i32(7)));
86}
87fn assertFalse(b: bool) {
88 assert(!b);
89}
90
91
92fn constNumberLiteral() {
93 @setFnTest(this);
94
95 const one = 1;
96 const eleven = ten + one;
97
98 assert(eleven == 11);
99}
100const ten = 10;
101
102
71103
72104// TODO const assert = @import("std").debug.assert;
73105fn assert(ok: bool) {
test/cases3/misc.zig+19-3
......@@ -70,6 +70,16 @@ fn minValueAndMaxValue() {
7070 assert(@minValue(i64) == -9223372036854775808);
7171}
7272
73fn maxValueType() {
74 @setFnTest(this);
75
76 // If the type of @maxValue(i32) was i32 then this implicit cast to
77 // u32 would not work. But since the value is a number literal,
78 // it works fine.
79 const x: u32 = @maxValue(i32);
80 assert(x == 2147483647);
81}
82
7383fn shortCircuit() {
7484 @setFnTest(this);
7585
......@@ -130,14 +140,20 @@ fn ReturnStringFromFunction() {
130140 assert(memeql(first4KeysOfHomeRow(), "aoeu"));
131141}
132142
133fn boolLiterals() {
143const g1 : i32 = 1233 + 1;
144var g2 : i32 = 0;
145
146fn globalVariables() {
134147 @setFnTest(this);
135148
136 assert(true);
137 assert(!false);
149 assert(g2 == 0);
150 g2 = g1;
151 assert(g2 == 1234);
138152}
139153
140154
155
156
141157// TODO import from std.str
142158pub fn memeql(a: []const u8, b: []const u8) -> bool {
143159 sliceEql(u8, a, b)
test/cases3/null.zig created+34
......@@ -0,0 +1,34 @@
1fn nullableType() {
2 @setFnTest(this);
3
4 const x : ?bool = true;
5
6 if (const y ?= x) {
7 if (y) {
8 // OK
9 } else {
10 @unreachable();
11 }
12 } else {
13 @unreachable();
14 }
15
16 const next_x : ?i32 = null;
17
18 const z = next_x ?? 1234;
19
20 assert(z == 1234);
21
22 const final_x : ?i32 = 13;
23
24 const num = final_x ?? @unreachable();
25
26 assert(num == 13);
27}
28
29// TODO const assert = @import("std").debug.assert;
30fn assert(ok: bool) {
31 if (!ok)
32 @unreachable();
33}
34
test/cases3/struct.zig+61
......@@ -63,6 +63,67 @@ fn testMutation(foo : &StructFoo) {
6363}
6464
6565
66const Node = struct {
67 val: Val,
68 next: &Node,
69};
70
71const Val = struct {
72 x: i32,
73};
74
75fn structPointToSelf() {
76 @setFnTest(this);
77
78 var root : Node = undefined;
79 root.val.x = 1;
80
81 var node : Node = undefined;
82 node.next = &root;
83 node.val.x = 2;
84
85 root.next = &node;
86
87 assert(node.next.next.next.val.x == 1);
88}
89
90fn structByvalAssign() {
91 @setFnTest(this);
92
93 var foo1 : StructFoo = undefined;
94 var foo2 : StructFoo = undefined;
95
96 foo1.a = 1234;
97 foo2.a = 0;
98 assert(foo2.a == 0);
99 foo2 = foo1;
100 assert(foo2.a == 1234);
101}
102
103fn structInitializer() {
104 const val = Val { .x = 42 };
105 assert(val.x == 42);
106}
107
108
109fn fnCallOfStructField() {
110 @setFnTest(this);
111
112 assert(callStructField(Foo {.ptr = aFunc,}) == 13);
113}
114
115const Foo = struct {
116 ptr: fn() -> i32,
117};
118
119fn aFunc() -> i32 { 13 }
120
121fn callStructField(foo: Foo) -> i32 {
122 return foo.ptr();
123}
124
125
126
66127
67128// TODO const assert = @import("std").debug.assert;
68129fn assert(ok: bool) {
test/cases3/switch.zig+44
......@@ -45,6 +45,50 @@ fn inlineSwitch() {
4545 assert(result + 1 == 14);
4646}
4747
48fn switchOnEnum() {
49 @setFnTest(this);
50
51 const fruit = Fruit.Orange;
52 nonConstSwitchOnEnum(fruit);
53}
54const Fruit = enum {
55 Apple,
56 Orange,
57 Banana,
58};
59fn nonConstSwitchOnEnum(fruit: Fruit) {
60 switch (fruit) {
61 Fruit.Apple => @unreachable(),
62 Fruit.Orange => {},
63 Fruit.Banana => @unreachable(),
64 }
65}
66
67
68fn switchStatement() {
69 @setFnTest(this);
70
71 nonConstSwitch(SwitchStatmentFoo.C);
72}
73fn nonConstSwitch(foo: SwitchStatmentFoo) {
74 const val = switch (foo) {
75 SwitchStatmentFoo.A => i32(1),
76 SwitchStatmentFoo.B => 2,
77 SwitchStatmentFoo.C => 3,
78 SwitchStatmentFoo.D => 4,
79 };
80 if (val != 3) @unreachable();
81}
82const SwitchStatmentFoo = enum {
83 A,
84 B,
85 C,
86 D,
87};
88
89
90
91
4892// TODO const assert = @import("std").debug.assert;
4993fn assert(ok: bool) {
5094 if (!ok)
test/cases3/this.zig created+57
......@@ -0,0 +1,57 @@
1const module = this;
2
3fn Point(inline T: type) -> type {
4 struct {
5 const Self = this;
6 x: T,
7 y: T,
8
9 fn addOne(self: &Self) {
10 self.x += 1;
11 self.y += 1;
12 }
13 }
14}
15
16fn add(x: i32, y: i32) -> i32 {
17 x + y
18}
19
20fn factorial(x: i32) -> i32 {
21 const selfFn = this;
22 if (x == 0) {
23 1
24 } else {
25 x * selfFn(x - 1)
26 }
27}
28
29fn thisReferToModuleCallPrivateFn() {
30 @setFnTest(this);
31
32 assert(module.add(1, 2) == 3);
33}
34
35fn thisReferToContainer() {
36 @setFnTest(this);
37
38 var pt = Point(i32) {
39 .x = 12,
40 .y = 34,
41 };
42 pt.addOne();
43 assert(pt.x == 13);
44 assert(pt.y == 35);
45}
46
47fn thisReferToFn() {
48 @setFnTest(this);
49
50 assert(factorial(5) == 120);
51}
52
53// TODO const assert = @import("std").debug.assert;
54fn assert(ok: bool) {
55 if (!ok)
56 @unreachable();
57}
test/cases3/while.zig created+38
......@@ -0,0 +1,38 @@
1fn whileLoop() {
2 @setFnTest(this);
3
4 var i : i32 = 0;
5 while (i < 4) {
6 i += 1;
7 }
8 assert(i == 4);
9 assert(whileLoop1() == 1);
10}
11fn whileLoop1() -> i32 {
12 return whileLoop2();
13}
14fn whileLoop2() -> i32 {
15 while (true) {
16 return 1;
17 }
18}
19fn staticEvalWhile() {
20 @setFnTest(this);
21
22 assert(static_eval_while_number == 1);
23}
24const static_eval_while_number = staticWhileLoop1();
25fn staticWhileLoop1() -> i32 {
26 return whileLoop2();
27}
28fn staticWhileLoop2() -> i32 {
29 while (true) {
30 return 1;
31 }
32}
33
34// TODO const assert = @import("std").debug.assert;
35fn assert(ok: bool) {
36 if (!ok)
37 @unreachable();
38}
test/self_hosted.zig+6-318
......@@ -3,334 +3,37 @@ const assert = std.debug.assert;
33const str = std.str;
44const cstr = std.cstr;
55const test_return_type_type = @import("cases/return_type_type.zig");
6const test_zeroes = @import("cases/zeroes.zig");
76const test_sizeof_and_typeof = @import("cases/sizeof_and_typeof.zig");
87const test_maybe_return = @import("cases/maybe_return.zig");
9const test_max_value_type = @import("cases/max_value_type.zig");
108const test_var_params = @import("cases/var_params.zig");
119const test_const_slice_child = @import("cases/const_slice_child.zig");
1210const test_switch_prong_implicit_cast = @import("cases/switch_prong_implicit_cast.zig");
1311const test_switch_prong_err_enum = @import("cases/switch_prong_err_enum.zig");
1412const test_enum_with_members = @import("cases/enum_with_members.zig");
1513const test_struct_contains_slice_of_itself = @import("cases/struct_contains_slice_of_itself.zig");
16const test_this = @import("cases/this.zig");
17
18
19
20struct Node {
21 val: Val,
22 next: &Node,
23}
24
25struct Val {
26 x: i32,
27}
28
29fn structPointToSelf() {
30 @setFnTest(this, true);
31
32 var root : Node = undefined;
33 root.val.x = 1;
34
35 var node : Node = undefined;
36 node.next = &root;
37 node.val.x = 2;
38
39 root.next = &node;
40
41 assert(node.next.next.next.val.x == 1);
42}
43
44fn structByvalAssign() {
45 @setFnTest(this, true);
46
47 var foo1 : StructFoo = undefined;
48 var foo2 : StructFoo = undefined;
49
50 foo1.a = 1234;
51 foo2.a = 0;
52 assert(foo2.a == 0);
53 foo2 = foo1;
54 assert(foo2.a == 1234);
55}
56
57fn structInitializer() {
58 const val = Val { .x = 42 };
59 assert(val.x == 42);
60}
61
62
63const g1 : i32 = 1233 + 1;
64var g2 : i32 = 0;
65
66fn globalVariables() {
67 @setFnTest(this, true);
68
69 assert(g2 == 0);
70 g2 = g1;
71 assert(g2 == 1234);
72}
73
74
75fn whileLoop() {
76 @setFnTest(this, true);
77
78 var i : i32 = 0;
79 while (i < 4) {
80 i += 1;
81 }
82 assert(i == 4);
83 assert(whileLoop1() == 1);
84}
85fn whileLoop1() -> i32 {
86 return whileLoop2();
87}
88fn whileLoop2() -> i32 {
89 while (true) {
90 return 1;
91 }
92}
93
94fn voidArrays() {
95 @setFnTest(this, true);
96
97 var array: [4]void = undefined;
98 array[0] = void{};
99 array[1] = array[2];
100 assert(@sizeOf(@typeOf(array)) == 0);
101 assert(array.len == 4);
102}
103
104
105fn threeExprInARow() {
106 @setFnTest(this, true);
107
108 assertFalse(false || false || false);
109 assertFalse(true && true && false);
110 assertFalse(1 | 2 | 4 != 7);
111 assertFalse(3 ^ 6 ^ 8 != 13);
112 assertFalse(7 & 14 & 28 != 4);
113 assertFalse(9 << 1 << 2 != 9 << 3);
114 assertFalse(90 >> 1 >> 2 != 90 >> 3);
115 assertFalse(100 - 1 + 1000 != 1099);
116 assertFalse(5 * 4 / 2 % 3 != 1);
117 assertFalse(i32(i32(5)) != 5);
118 assertFalse(!!false);
119 assertFalse(i32(7) != --(i32(7)));
120}
121fn assertFalse(b: bool) {
122 assert(!b);
123}
124
125
126fn maybeType() {
127 @setFnTest(this, true);
128
129 const x : ?bool = true;
130
131 if (const y ?= x) {
132 if (y) {
133 // OK
134 } else {
135 @unreachable();
136 }
137 } else {
138 @unreachable();
139 }
140
141 const next_x : ?i32 = null;
142
143 const z = next_x ?? 1234;
144
145 assert(z == 1234);
146
147 const final_x : ?i32 = 13;
148
149 const num = final_x ?? @unreachable();
150
151 assert(num == 13);
152}
153
154
155fn arrayLiteral() {
156 @setFnTest(this, true);
157
158 const hex_mult = []u16{4096, 256, 16, 1};
159
160 assert(hex_mult.len == 4);
161 assert(hex_mult[1] == 256);
162}
163
164
165fn constNumberLiteral() {
166 @setFnTest(this, true);
167
168 const one = 1;
169 const eleven = ten + one;
170
171 assert(eleven == 11);
172}
173const ten = 10;
174
175
176fn errorValues() {
177 @setFnTest(this, true);
178
179 const a = i32(error.err1);
180 const b = i32(error.err2);
181 assert(a != b);
182}
183error err1;
184error err2;
185
186
187
188fn fnCallOfStructField() {
189 @setFnTest(this, true);
190
191 assert(callStructField(Foo {.ptr = aFunc,}) == 13);
192}
193
194struct Foo {
195 ptr: fn() -> i32,
196}
197
198fn aFunc() -> i32 { 13 }
199
200fn callStructField(foo: Foo) -> i32 {
201 return foo.ptr();
202}
203
204
205
206fn redefinitionOfErrorValuesAllowed() {
207 @setFnTest(this, true);
208
209 shouldBeNotEqual(error.AnError, error.SecondError);
210}
211error AnError;
212error AnError;
213error SecondError;
214fn shouldBeNotEqual(a: error, b: error) {
215 if (a == b) @unreachable()
216}
217
218
219
220
221fn constantEnumWithPayload() {
222 @setFnTest(this, true);
223
224 var empty = AnEnumWithPayload.Empty;
225 var full = AnEnumWithPayload.Full {13};
226 shouldBeEmpty(empty);
227 shouldBeNotEmpty(full);
228}
229
230fn shouldBeEmpty(x: AnEnumWithPayload) {
231 switch (x) {
232 Empty => {},
233 else => @unreachable(),
234 }
235}
236
237fn shouldBeNotEmpty(x: AnEnumWithPayload) {
238 switch (x) {
239 Empty => @unreachable(),
240 else => {},
241 }
242}
243
244enum AnEnumWithPayload {
245 Empty,
246 Full: i32,
247}
248
249
250fn castBoolToInt() {
251 @setFnTest(this, true);
252
253 const t = true;
254 const f = false;
255 assert(i32(t) == i32(1));
256 assert(i32(f) == i32(0));
257 nonConstCastBoolToInt(t, f);
258}
259
260fn nonConstCastBoolToInt(t: bool, f: bool) {
261 assert(i32(t) == i32(1));
262 assert(i32(f) == i32(0));
263}
264
265
266fn switchOnEnum() {
267 @setFnTest(this, true);
268
269 const fruit = Fruit.Orange;
270 nonConstSwitchOnEnum(fruit);
271}
272enum Fruit {
273 Apple,
274 Orange,
275 Banana,
276}
277fn nonConstSwitchOnEnum(fruit: Fruit) {
278 @setFnStaticEval(this, false);
279
280 switch (fruit) {
281 Apple => @unreachable(),
282 Orange => {},
283 Banana => @unreachable(),
284 }
285}
286
287fn switchStatement() {
288 @setFnTest(this, true);
289
290 nonConstSwitch(SwitchStatmentFoo.C);
291}
292fn nonConstSwitch(foo: SwitchStatmentFoo) {
293 @setFnStaticEval(this, false);
294
295 const val: i32 = switch (foo) {
296 A => 1,
297 B => 2,
298 C => 3,
299 D => 4,
300 };
301 if (val != 3) @unreachable();
302}
303enum SwitchStatmentFoo {
304 A,
305 B,
306 C,
307 D,
308}
30914
31015
31116fn switchProngWithVar() {
312 @setFnTest(this, true);
17 @setFnTest(this);
31318
31419 switchProngWithVarFn(SwitchProngWithVarEnum.One {13});
31520 switchProngWithVarFn(SwitchProngWithVarEnum.Two {13.0});
31621 switchProngWithVarFn(SwitchProngWithVarEnum.Meh);
31722}
318enum SwitchProngWithVarEnum {
23const SwitchProngWithVarEnum = enum {
31924 One: i32,
32025 Two: f32,
32126 Meh,
322}
27};
32328fn switchProngWithVarFn(a: SwitchProngWithVarEnum) {
324 @setFnStaticEval(this, false);
325
32629 switch(a) {
327 One => |x| {
30 SwitchProngWithVarEnum.One => |x| {
32831 if (x != 13) @unreachable();
32932 },
330 Two => |x| {
33 SwitchProngWithVarEnum.Two => |x| {
33134 if (x != 13.0) @unreachable();
33235 },
333 Meh => |x| {
36 SwitchProngWithVarEnum.Meh => |x| {
33437 const v: void = x;
33538 },
33639 }
......@@ -677,21 +380,6 @@ fn fibbonaci(x: i32) -> i32 {
677380 return fibbonaci(x - 1) + fibbonaci(x - 2);
678381}
679382
680fn staticEvalWhile() {
681 @setFnTest(this, true);
682
683 assert(static_eval_while_number == 1);
684}
685const static_eval_while_number = staticWhileLoop1();
686fn staticWhileLoop1() -> i32 {
687 return whileLoop2();
688}
689fn staticWhileLoop2() -> i32 {
690 while (true) {
691 return 1;
692 }
693}
694
695383fn staticEvalListInit() {
696384 @setFnTest(this, true);
697385
test/self_hosted3.zig+4
......@@ -1,6 +1,7 @@
11// TODO '_' identifier for unused variable bindings
22const test_array = @import("cases3/array.zig");
33const test_atomics = @import("cases3/atomics.zig");
4const test_bool = @import("cases3/bool.zig");
45const test_defer = @import("cases3/defer.zig");
56const test_enum = @import("cases3/enum.zig");
67const test_error = @import("cases3/error.zig");
......@@ -13,5 +14,8 @@ const test_if = @import("cases3/if.zig");
1314const test_import = @import("cases3/import.zig");
1415const test_math = @import("cases3/math.zig");
1516const test_misc = @import("cases3/misc.zig");
17const test_null = @import("cases3/null.zig");
1618const test_struct = @import("cases3/struct.zig");
1719const test_switch = @import("cases3/switch.zig");
20const test_this = @import("cases3/this.zig");
21const test_while = @import("cases3/while.zig");