authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-18 15:02:52-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-18 15:02:52-07:00
logad5770eba40e0cc425c7a1eab4d37c6f9788d670
treee849a479217b69c9698ac35782e4f270ce3bbfca
parentd5803441cd0c06d3fb7f11f5cb447c20e0d62d52

organize behavior tests

* Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.

17 files changed, 328 insertions(+), 73 deletions(-)

test/behavior.zig+37-41
......@@ -13,6 +13,7 @@ test {
1313 _ = @import("behavior/byval_arg_var.zig");
1414 _ = @import("behavior/bool.zig");
1515 _ = @import("behavior/bugs/394.zig");
16 _ = @import("behavior/bugs/421.zig");
1617 _ = @import("behavior/bugs/624.zig");
1718 _ = @import("behavior/bugs/655.zig");
1819 _ = @import("behavior/bugs/656.zig");
......@@ -34,8 +35,10 @@ test {
3435 _ = @import("behavior/bugs/1607.zig");
3536 _ = @import("behavior/bugs/1735.zig");
3637 _ = @import("behavior/bugs/1741.zig");
38 _ = @import("behavior/bugs/1851.zig");
3739 _ = @import("behavior/bugs/1914.zig");
3840 _ = @import("behavior/bugs/2006.zig");
41 _ = @import("behavior/bugs/2114.zig");
3942 _ = @import("behavior/bugs/2346.zig");
4043 _ = @import("behavior/bugs/2578.zig");
4144 _ = @import("behavior/bugs/2692.zig");
......@@ -47,6 +50,7 @@ test {
4750 _ = @import("behavior/bugs/3384.zig");
4851 _ = @import("behavior/bugs/3586.zig");
4952 _ = @import("behavior/bugs/3742.zig");
53 _ = @import("behavior/bugs/3779.zig");
5054 _ = @import("behavior/bugs/4328.zig");
5155 _ = @import("behavior/bugs/4560.zig");
5256 _ = @import("behavior/bugs/4769_a.zig");
......@@ -61,9 +65,11 @@ test {
6165 _ = @import("behavior/bugs/7003.zig");
6266 _ = @import("behavior/bugs/7047.zig");
6367 _ = @import("behavior/bugs/7250.zig");
64 _ = @import("behavior/bugs/11100.zig");
68 _ = @import("behavior/bugs/9584.zig");
69 _ = @import("behavior/bugs/10147.zig");
6570 _ = @import("behavior/bugs/10970.zig");
6671 _ = @import("behavior/bugs/11046.zig");
72 _ = @import("behavior/bugs/11100.zig");
6773 _ = @import("behavior/bugs/11139.zig");
6874 _ = @import("behavior/bugs/11159.zig");
6975 _ = @import("behavior/bugs/11162.zig");
......@@ -73,11 +79,13 @@ test {
7379 _ = @import("behavior/bugs/11213.zig");
7480 _ = @import("behavior/call.zig");
7581 _ = @import("behavior/cast.zig");
82 _ = @import("behavior/cast_int.zig");
7683 _ = @import("behavior/comptime_memory.zig");
7784 _ = @import("behavior/const_slice_child.zig");
7885 _ = @import("behavior/defer.zig");
7986 _ = @import("behavior/enum.zig");
8087 _ = @import("behavior/error.zig");
88 _ = @import("behavior/eval.zig");
8189 _ = @import("behavior/field_parent_ptr.zig");
8290 _ = @import("behavior/floatop.zig");
8391 _ = @import("behavior/fn_delegation.zig");
......@@ -90,10 +98,12 @@ test {
9098 _ = @import("behavior/if.zig");
9199 _ = @import("behavior/import.zig");
92100 _ = @import("behavior/incomplete_struct_param_tld.zig");
101 _ = @import("behavior/int128.zig");
93102 _ = @import("behavior/int_div.zig");
94103 _ = @import("behavior/inttoptr.zig");
95104 _ = @import("behavior/ir_block_deps.zig");
96105 _ = @import("behavior/math.zig");
106 _ = @import("behavior/maximum_minimum.zig");
97107 _ = @import("behavior/member_func.zig");
98108 _ = @import("behavior/merge_error_sets.zig");
99109 _ = @import("behavior/muladd.zig");
......@@ -101,21 +111,25 @@ test {
101111 _ = @import("behavior/null.zig");
102112 _ = @import("behavior/optional.zig");
103113 _ = @import("behavior/pointers.zig");
114 _ = @import("behavior/popcount.zig");
104115 _ = @import("behavior/prefetch.zig");
105116 _ = @import("behavior/ptrcast.zig");
106117 _ = @import("behavior/pub_enum.zig");
107118 _ = @import("behavior/ref_var_in_if_after_if_2nd_switch_prong.zig");
108119 _ = @import("behavior/reflection.zig");
120 _ = @import("behavior/saturating_arithmetic.zig");
121 _ = @import("behavior/shuffle.zig");
109122 _ = @import("behavior/sizeof_and_typeof.zig");
110 _ = @import("behavior/slice_sentinel_comptime.zig");
111123 _ = @import("behavior/slice.zig");
124 _ = @import("behavior/slice_sentinel_comptime.zig");
112125 _ = @import("behavior/src.zig");
113 _ = @import("behavior/struct_contains_null_ptr_itself.zig");
114126 _ = @import("behavior/struct.zig");
127 _ = @import("behavior/struct_contains_null_ptr_itself.zig");
128 _ = @import("behavior/switch.zig");
115129 _ = @import("behavior/switch_prong_err_enum.zig");
116130 _ = @import("behavior/switch_prong_implicit_cast.zig");
117 _ = @import("behavior/switch.zig");
118131 _ = @import("behavior/this.zig");
132 _ = @import("behavior/translate_c_macros.zig");
119133 _ = @import("behavior/truncate.zig");
120134 _ = @import("behavior/try.zig");
121135 _ = @import("behavior/tuple.zig");
......@@ -125,11 +139,13 @@ test {
125139 _ = @import("behavior/undefined.zig");
126140 _ = @import("behavior/underscore.zig");
127141 _ = @import("behavior/union.zig");
142 _ = @import("behavior/union_with_members.zig");
128143 _ = @import("behavior/usingnamespace.zig");
129144 _ = @import("behavior/var_args.zig");
130145 _ = @import("behavior/vector.zig");
131146 _ = @import("behavior/void.zig");
132147 _ = @import("behavior/while.zig");
148 _ = @import("behavior/widening.zig");
133149
134150 if (builtin.stage2_arch == .wasm32) {
135151 _ = @import("behavior/wasm.zig");
......@@ -142,46 +158,26 @@ test {
142158 if (builtin.zig_backend != .stage2_arm and
143159 builtin.zig_backend != .stage2_x86_64 and
144160 builtin.zig_backend != .stage2_aarch64 and
145 builtin.zig_backend != .stage2_wasm)
161 builtin.zig_backend != .stage2_wasm and
162 builtin.zig_backend != .stage2_c)
146163 {
147 // Tests that pass for stage1, llvm backend, C backend
148 _ = @import("behavior/bugs/421.zig");
149 _ = @import("behavior/bugs/3779.zig");
150 _ = @import("behavior/bugs/9584.zig");
151 _ = @import("behavior/cast_int.zig");
152 _ = @import("behavior/eval.zig");
164 _ = @import("behavior/export.zig");
153165 _ = @import("behavior/export_self_referential_type_info.zig");
154 _ = @import("behavior/int128.zig");
155 _ = @import("behavior/popcount.zig");
156 _ = @import("behavior/translate_c_macros.zig");
157 _ = @import("behavior/union_with_members.zig");
158
159 if (builtin.zig_backend != .stage2_c) {
160 // Tests that pass for stage1 and the llvm backend.
161 _ = @import("behavior/export.zig");
162 _ = @import("behavior/maximum_minimum.zig");
163 _ = @import("behavior/saturating_arithmetic.zig");
164 _ = @import("behavior/widening.zig");
165 _ = @import("behavior/bugs/2114.zig");
166 _ = @import("behavior/bugs/10147.zig");
167 _ = @import("behavior/shuffle.zig");
166 }
168167
169 if (builtin.zig_backend == .stage1) {
170 // Tests that only pass for the stage1 backend.
171 if (builtin.os.tag != .wasi) {
172 _ = @import("behavior/asm.zig");
173 _ = @import("behavior/async_fn.zig");
174 }
175 _ = @import("behavior/await_struct.zig");
176 _ = @import("behavior/bugs/529.zig");
177 _ = @import("behavior/bugs/920.zig");
178 _ = @import("behavior/bugs/1120.zig");
179 _ = @import("behavior/bugs/1851.zig");
180 _ = @import("behavior/bugs/6781.zig");
181 _ = @import("behavior/bugs/7027.zig");
182 _ = @import("behavior/select.zig");
183 _ = @import("behavior/struct_contains_slice_of_itself.zig");
184 }
168 if (builtin.zig_backend == .stage1) {
169 // TODO get these tests passing with stage2
170 if (builtin.os.tag != .wasi) {
171 _ = @import("behavior/asm.zig");
172 _ = @import("behavior/async_fn.zig");
185173 }
174 _ = @import("behavior/await_struct.zig");
175 _ = @import("behavior/bugs/529.zig");
176 _ = @import("behavior/bugs/920.zig");
177 _ = @import("behavior/bugs/1120.zig");
178 _ = @import("behavior/bugs/6781.zig");
179 _ = @import("behavior/bugs/7027.zig");
180 _ = @import("behavior/select.zig");
181 _ = @import("behavior/struct_contains_slice_of_itself.zig");
186182 }
187183}
test/behavior/bugs/10147.zig+7
......@@ -1,6 +1,13 @@
1const builtin = @import("builtin");
12const std = @import("std");
23
34test "uses correct LLVM builtin" {
5 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
6 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
10
411 var x: u32 = 0x1;
512 var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };
613 // The stage1 compiler used to call the same builtin function for both
test/behavior/bugs/1851.zig+15
......@@ -1,7 +1,22 @@
1const builtin = @import("builtin");
12const std = @import("std");
23const expect = std.testing.expect;
34
45test "allocation and looping over 3-byte integer" {
6 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11
12 if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .macos) {
13 return error.SkipZigTest; // TODO
14 }
15
16 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) {
17 return error.SkipZigTest; // TODO
18 }
19
520 try expect(@sizeOf(u24) == 4);
621 try expect(@sizeOf([1]u24) == 4);
722 try expect(@alignOf(u24) == 4);
test/behavior/bugs/2114.zig+7
......@@ -1,3 +1,4 @@
1const builtin = @import("builtin");
12const std = @import("std");
23const expect = std.testing.expect;
34const math = std.math;
......@@ -7,6 +8,12 @@ fn ctz(x: anytype) usize {
78}
89
910test "fixed" {
11 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
12 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
13 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
16
1017 try testCtz();
1118 comptime try testCtz();
1219}
test/behavior/bugs/3779.zig+15
......@@ -7,6 +7,9 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
77
88test "@tagName() returns a string literal" {
99 if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the type wrong
10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12
1013 try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
1114 try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
1215 try std.testing.expect(std.mem.eql(u8, "TestEnumValue", ptr_tag_name[0..tag_name.len]));
......@@ -18,6 +21,9 @@ const ptr_error_name: [*:0]const u8 = error_name;
1821
1922test "@errorName() returns a string literal" {
2023 if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the type wrong
24 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
25 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
26
2127 try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
2228 try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));
2329 try std.testing.expect(std.mem.eql(u8, "TestErrorCode", ptr_error_name[0..error_name.len]));
......@@ -29,6 +35,9 @@ const ptr_type_name: [*:0]const u8 = type_name;
2935
3036test "@typeName() returns a string literal" {
3137 if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the type wrong
38 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
39 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
40
3241 try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));
3342 try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name));
3443 try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", ptr_type_name[0..type_name.len]));
......@@ -39,6 +48,9 @@ const ptr_actual_contents: [*:0]const u8 = actual_contents;
3948const expected_contents = "hello zig\n";
4049
4150test "@embedFile() returns a string literal" {
51 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
52 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
53
4254 try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));
4355 try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
4456 try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
......@@ -50,6 +62,9 @@ fn testFnForSrc() std.builtin.SourceLocation {
5062}
5163
5264test "@src() returns a struct containing 0-terminated string slices" {
65 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
66 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
67
5368 const src = testFnForSrc();
5469 try std.testing.expect([:0]const u8 == @TypeOf(src.file));
5570 try std.testing.expect(std.mem.endsWith(u8, src.file, "3779.zig"));
test/behavior/bugs/421.zig+6
......@@ -1,6 +1,12 @@
1const builtin = @import("builtin");
12const expect = @import("std").testing.expect;
23
34test "bitCast to array" {
5 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
6 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9
410 comptime try testBitCastArray();
511 try testBitCastArray();
612}
test/behavior/bugs/9584.zig+8-1
......@@ -1,3 +1,4 @@
1const builtin = @import("builtin");
12const std = @import("std");
23
34const A = packed struct {
......@@ -41,7 +42,13 @@ pub fn b(x: *X) !void {
4142 try a(0, 1, 2, 3, 4, x.x.a, x.x.b);
4243}
4344
44test "bug 9584" {
45test {
46 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
47 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
48 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
49 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
50 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
51
4552 var flags = A{
4653 .a = false,
4754 .b = true,
test/behavior/cast_int.zig+7
......@@ -1,8 +1,15 @@
1const builtin = @import("builtin");
12const std = @import("std");
23const expect = std.testing.expect;
34const maxInt = std.math.maxInt;
45
56test "@intCast i32 to u7" {
7 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
12
613 var x: u128 = maxInt(u128);
714 var y: i32 = 120;
815 var z = x >> @intCast(u7, y);
test/behavior/eval.zig+59-3
......@@ -17,6 +17,9 @@ fn unwrapAndAddOne(blah: ?i32) i32 {
1717}
1818const should_be_1235 = unwrapAndAddOne(1234);
1919test "static add one" {
20 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
21 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22
2023 try expect(should_be_1235 == 1235);
2124}
2225
......@@ -65,6 +68,9 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
6568}
6669
6770test "constant expressions" {
71 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
72 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
73
6874 var array: [array_size]u8 = undefined;
6975 try expect(@sizeOf(@TypeOf(array)) == 20);
7076}
......@@ -83,6 +89,9 @@ fn letsTryToCompareBools(a: bool, b: bool) bool {
8389 return max(bool, a, b);
8490}
8591test "inlined block and runtime block phi" {
92 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
93 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
94
8695 try expect(letsTryToCompareBools(true, true));
8796 try expect(letsTryToCompareBools(true, false));
8897 try expect(letsTryToCompareBools(false, true));
......@@ -127,6 +136,10 @@ test "pointer to type" {
127136}
128137
129138test "a type constructed in a global expression" {
139 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
140 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
141 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
142
130143 var l: List = undefined;
131144 l.array[0] = 10;
132145 l.array[1] = 11;
......@@ -220,6 +233,8 @@ const vertices = [_]Vertex{
220233};
221234
222235test "statically initialized list" {
236 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
237
223238 try expect(static_point_list[0].x == 1);
224239 try expect(static_point_list[0].y == 2);
225240 try expect(static_point_list[1].x == 3);
......@@ -323,6 +338,9 @@ fn doesAlotT(comptime T: type, value: usize) T {
323338}
324339
325340test "@setEvalBranchQuota at same scope as generic function call" {
341 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
342 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
343
326344 try expect(doesAlotT(u32, 2) == 2);
327345}
328346
......@@ -371,6 +389,9 @@ test "return 0 from function that has u0 return type" {
371389}
372390
373391test "statically initialized struct" {
392 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
393 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
394
374395 st_init_str_foo.x += 1;
375396 try expect(st_init_str_foo.x == 14);
376397}
......@@ -384,6 +405,8 @@ var st_init_str_foo = StInitStrFoo{
384405};
385406
386407test "inline for with same type but different values" {
408 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
409
387410 var res: usize = 0;
388411 inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
389412 var a: T = undefined;
......@@ -416,7 +439,9 @@ fn copyWithPartialInline(s: []u32, b: []u8) void {
416439}
417440
418441test "binary math operator in partially inlined function" {
419 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
442 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
443 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
444 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
420445
421446 var s: [4]u32 = undefined;
422447 var b: [16]u8 = undefined;
......@@ -432,6 +457,12 @@ test "binary math operator in partially inlined function" {
432457}
433458
434459test "comptime shl" {
460 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
461 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
462 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
463 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
464 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
465
435466 var a: u128 = 3;
436467 var b: u7 = 63;
437468 var c: u128 = 3 << 63;
......@@ -456,6 +487,9 @@ test "comptime bitwise operators" {
456487}
457488
458489test "comptime shlWithOverflow" {
490 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
491 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
492
459493 const ct_shifted: u64 = comptime amt: {
460494 var amt = @as(u64, 0);
461495 _ = @shlWithOverflow(u64, ~@as(u64, 0), 16, &amt);
......@@ -472,6 +506,9 @@ test "comptime shlWithOverflow" {
472506}
473507
474508test "const ptr to variable data changes at runtime" {
509 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
510 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
511
475512 try expect(foo_ref.name[0] == 'a');
476513 foo_ref.name = "b";
477514 try expect(foo_ref.name[0] == 'b');
......@@ -485,6 +522,12 @@ var foo_contents = Foo{ .name = "a" };
485522const foo_ref = &foo_contents;
486523
487524test "runtime 128 bit integer division" {
525 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
526 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
527 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
528 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
529 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
530
488531 var a: u128 = 152313999999999991610955792383;
489532 var b: u128 = 10000000000000000000;
490533 var c = a / b;
......@@ -492,12 +535,17 @@ test "runtime 128 bit integer division" {
492535}
493536
494537test "@tagName of @typeInfo" {
538 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
539
495540 const str = @tagName(@typeInfo(u8));
496541 try expect(std.mem.eql(u8, str, "Int"));
497542}
498543
499544test "static eval list init" {
500545 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
546 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
547 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
548 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
501549
502550 try expect(static_vec3.data[2] == 1.0);
503551 try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);
......@@ -513,6 +561,8 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 {
513561}
514562
515563test "inlined loop has array literal with elided runtime scope on first iteration but not second iteration" {
564 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
565
516566 var runtime = [1]i32{3};
517567 comptime var i: usize = 0;
518568 inline while (i < 2) : (i += 1) {
......@@ -548,6 +598,8 @@ const bound_fn = simple_struct.method;
548598
549599test "ptr to local array argument at comptime" {
550600 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
601 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
602 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
551603
552604 comptime {
553605 var bytes: [10]u8 = undefined;
......@@ -583,6 +635,9 @@ fn testCompTimeUIntComparisons(x: u32) void {
583635const hi1 = "hi";
584636const hi2 = hi1;
585637test "const global shares pointer with other same one" {
638 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
639 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
640
586641 try assertEqualPtrs(&hi1[0], &hi2[0]);
587642 comptime try expect(&hi1[0] == &hi2[0]);
588643}
......@@ -681,8 +736,6 @@ fn loopNTimes(comptime n: usize) void {
681736}
682737
683738test "variable inside inline loop that has different types on different iterations" {
684 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
685
686739 try testVarInsideInlineLoop(.{ true, @as(u32, 42) });
687740}
688741
......@@ -742,6 +795,9 @@ test "comptime assign int to optional int" {
742795}
743796
744797test "two comptime calls with array default initialized to undefined" {
798 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
799 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
800
745801 const S = struct {
746802 const CrossTarget = struct {
747803 dynamic_linker: DynamicLinker = DynamicLinker{},
test/behavior/int128.zig+20
......@@ -5,6 +5,11 @@ const minInt = std.math.minInt;
55const builtin = @import("builtin");
66
77test "uint128" {
8 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12
813 var buff: u128 = maxInt(u128);
914 try expect(buff == maxInt(u128));
1015
......@@ -19,6 +24,11 @@ test "uint128" {
1924}
2025
2126test "undefined 128 bit int" {
27 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
28 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
29 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
30 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
31
2232 @setRuntimeSafety(true);
2333
2434 // TODO implement @setRuntimeSafety in stage2
......@@ -32,6 +42,11 @@ test "undefined 128 bit int" {
3242}
3343
3444test "int128" {
45 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
46 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
47 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
48 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
49
3550 var buff: i128 = -1;
3651 try expect(buff < 0 and (buff + 1) == 0);
3752 try expect(@intCast(i8, buff) == @as(i8, -1));
......@@ -44,6 +59,11 @@ test "int128" {
4459}
4560
4661test "truncate int128" {
62 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
63 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
64 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
65 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
66
4767 var buff: u128 = maxInt(u128);
4868 try expect(@truncate(u64, buff) == maxInt(u64));
4969}
test/behavior/maximum_minimum.zig+24-13
......@@ -3,26 +3,31 @@ const builtin = @import("builtin");
33const mem = std.mem;
44const expect = std.testing.expect;
55const expectEqual = std.testing.expectEqual;
6const Vector = std.meta.Vector;
76
87test "@maximum" {
8 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13
914 const S = struct {
1015 fn doTheTest() !void {
1116 try expect(@as(i32, 10) == @maximum(@as(i32, -3), @as(i32, 10)));
1217 try expect(@as(f32, 3.2) == @maximum(@as(f32, 3.2), @as(f32, 0.68)));
1318
14 var a: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
15 var b: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
19 var a: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
20 var b: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
1621 var x = @maximum(a, b);
1722 try expect(mem.eql(i32, &@as([4]i32, x), &[4]i32{ 2147483647, 2147483647, 30, 40 }));
1823
19 var c: Vector(4, f32) = [4]f32{ 0, 0.4, -2.4, 7.8 };
20 var d: Vector(4, f32) = [4]f32{ -0.23, 0.42, -0.64, 0.9 };
24 var c: @Vector(4, f32) = [4]f32{ 0, 0.4, -2.4, 7.8 };
25 var d: @Vector(4, f32) = [4]f32{ -0.23, 0.42, -0.64, 0.9 };
2126 var y = @maximum(c, d);
2227 try expect(mem.eql(f32, &@as([4]f32, y), &[4]f32{ 0, 0.42, -0.64, 7.8 }));
2328
24 var e: Vector(2, f32) = [2]f32{ 0, std.math.qnan_f32 };
25 var f: Vector(2, f32) = [2]f32{ std.math.qnan_f32, 0 };
29 var e: @Vector(2, f32) = [2]f32{ 0, std.math.qnan_f32 };
30 var f: @Vector(2, f32) = [2]f32{ std.math.qnan_f32, 0 };
2631 var z = @maximum(e, f);
2732 try expect(mem.eql(f32, &@as([2]f32, z), &[2]f32{ 0, 0 }));
2833 }
......@@ -32,23 +37,29 @@ test "@maximum" {
3237}
3338
3439test "@minimum" {
40 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
41 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
42 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
43 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
44 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
45
3546 const S = struct {
3647 fn doTheTest() !void {
3748 try expect(@as(i32, -3) == @minimum(@as(i32, -3), @as(i32, 10)));
3849 try expect(@as(f32, 0.68) == @minimum(@as(f32, 3.2), @as(f32, 0.68)));
3950
40 var a: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
41 var b: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
51 var a: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
52 var b: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
4253 var x = @minimum(a, b);
4354 try expect(mem.eql(i32, &@as([4]i32, x), &[4]i32{ 1, -2, 3, 4 }));
4455
45 var c: Vector(4, f32) = [4]f32{ 0, 0.4, -2.4, 7.8 };
46 var d: Vector(4, f32) = [4]f32{ -0.23, 0.42, -0.64, 0.9 };
56 var c: @Vector(4, f32) = [4]f32{ 0, 0.4, -2.4, 7.8 };
57 var d: @Vector(4, f32) = [4]f32{ -0.23, 0.42, -0.64, 0.9 };
4758 var y = @minimum(c, d);
4859 try expect(mem.eql(f32, &@as([4]f32, y), &[4]f32{ -0.23, 0.4, -2.4, 0.9 }));
4960
50 var e: Vector(2, f32) = [2]f32{ 0, std.math.qnan_f32 };
51 var f: Vector(2, f32) = [2]f32{ std.math.qnan_f32, 0 };
61 var e: @Vector(2, f32) = [2]f32{ 0, std.math.qnan_f32 };
62 var f: @Vector(2, f32) = [2]f32{ std.math.qnan_f32, 0 };
5263 var z = @maximum(e, f);
5364 try expect(mem.eql(f32, &@as([2]f32, z), &[2]f32{ 0, 0 }));
5465 }
test/behavior/popcount.zig+9
......@@ -4,6 +4,11 @@ const expect = std.testing.expect;
44const expectEqual = std.testing.expectEqual;
55
66test "@popCount integers" {
7 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11
712 comptime try testPopCountIntegers();
813 try testPopCountIntegers();
914}
......@@ -51,6 +56,10 @@ fn testPopCountIntegers() !void {
5156
5257test "@popCount vectors" {
5358 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
59 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
60 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
61 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
62 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5463
5564 comptime try testPopCountVectors();
5665 try testPopCountVectors();
test/behavior/saturating_arithmetic.zig+38-2
......@@ -5,6 +5,12 @@ const maxInt = std.math.maxInt;
55const expect = std.testing.expect;
66
77test "saturating add" {
8 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
13
814 const S = struct {
915 fn doTheTest() !void {
1016 try testSatAdd(i8, -3, 10, 7);
......@@ -49,6 +55,12 @@ test "saturating add" {
4955}
5056
5157test "saturating subtraction" {
58 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
59 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
60 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
61 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
62 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
63
5264 const S = struct {
5365 fn doTheTest() !void {
5466 try testSatSub(i8, -3, 10, -13);
......@@ -92,8 +104,20 @@ test "saturating subtraction" {
92104}
93105
94106test "saturating multiplication" {
95 // TODO: once #9660 has been solved, remove this line
96 if (builtin.cpu.arch == .wasm32) return error.SkipZigTest;
107 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
108 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
110 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
111 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
112
113 if (builtin.zig_backend == .stage1 and builtin.cpu.arch == .wasm32) {
114 // https://github.com/ziglang/zig/issues/9660
115 return error.SkipZigTest;
116 }
117 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) {
118 // https://github.com/ziglang/zig/issues/9660
119 return error.SkipZigTest;
120 }
97121
98122 const S = struct {
99123 fn doTheTest() !void {
......@@ -129,6 +153,12 @@ test "saturating multiplication" {
129153}
130154
131155test "saturating shift-left" {
156 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
157 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
158 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
159 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
160 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
161
132162 const S = struct {
133163 fn doTheTest() !void {
134164 try testSatShl(i8, 1, 2, 4);
......@@ -163,6 +193,12 @@ test "saturating shift-left" {
163193}
164194
165195test "saturating shl uses the LHS type" {
196 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
197 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
198 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
199 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
200 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
201
166202 const lhs_const: u8 = 1;
167203 var lhs_var: u8 = 1;
168204
test/behavior/shuffle.zig+31-13
......@@ -2,13 +2,18 @@ const std = @import("std");
22const builtin = @import("builtin");
33const mem = std.mem;
44const expect = std.testing.expect;
5const Vector = std.meta.Vector;
65
76test "@shuffle int" {
7 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
12
813 const S = struct {
914 fn doTheTest() !void {
10 var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
11 var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
15 var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
16 var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
1217 const mask = [4]i32{ 0, ~@as(i32, 2), 3, ~@as(i32, 3) };
1318 var res = @shuffle(i32, v, x, mask);
1419 try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 40, 4 }));
......@@ -23,13 +28,13 @@ test "@shuffle int" {
2328 try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 40, -2, 30, 2147483647 }));
2429
2530 // Upcasting of b
26 var v2: Vector(2, i32) = [2]i32{ 2147483647, undefined };
31 var v2: @Vector(2, i32) = [2]i32{ 2147483647, undefined };
2732 const mask3 = [4]i32{ ~@as(i32, 0), 2, ~@as(i32, 0), 3 };
2833 res = @shuffle(i32, x, v2, mask3);
2934 try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 2147483647, 4 }));
3035
3136 // Upcasting of a
32 var v3: Vector(2, i32) = [2]i32{ 2147483647, -2 };
37 var v3: @Vector(2, i32) = [2]i32{ 2147483647, -2 };
3338 const mask4 = [4]i32{ 0, ~@as(i32, 2), 1, ~@as(i32, 3) };
3439 res = @shuffle(i32, v3, x, mask4);
3540 try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, -2, 4 }));
......@@ -40,10 +45,16 @@ test "@shuffle int" {
4045}
4146
4247test "@shuffle bool" {
48 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
49 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
50 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
51 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
52 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
53
4354 const S = struct {
4455 fn doTheTest() !void {
45 var x: Vector(4, bool) = [4]bool{ false, true, false, true };
46 var v: Vector(2, bool) = [2]bool{ true, false };
56 var x: @Vector(4, bool) = [4]bool{ false, true, false, true };
57 var v: @Vector(2, bool) = [2]bool{ true, false };
4758 const mask = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
4859 var res = @shuffle(bool, x, v, mask);
4960 try expect(mem.eql(bool, &@as([4]bool, res), &[4]bool{ false, false, true, false }));
......@@ -54,15 +65,22 @@ test "@shuffle bool" {
5465}
5566
5667test "@shuffle bool" {
57 // TODO re-enable when LLVM codegen is fixed
58 // https://github.com/ziglang/zig/issues/3246
59 if (true) return error.SkipZigTest;
68 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
69 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
70 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
71 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
72 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
73
74 if (builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm) {
75 // https://github.com/ziglang/zig/issues/3246
76 return error.SkipZigTest;
77 }
6078
6179 const S = struct {
6280 fn doTheTest() !void {
63 var x: Vector(3, bool) = [3]bool{ false, true, false };
64 var v: Vector(2, bool) = [2]bool{ true, false };
65 const mask: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
81 var x: @Vector(3, bool) = [3]bool{ false, true, false };
82 var v: @Vector(2, bool) = [2]bool{ true, false };
83 const mask: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
6684 var res = @shuffle(bool, x, v, mask);
6785 try expect(mem.eql(bool, &@as([4]bool, res), &[4]bool{ false, false, true, false }));
6886 }
test/behavior/translate_c_macros.zig+14
......@@ -30,6 +30,8 @@ test "initializer list expression" {
3030}
3131
3232test "sizeof in macros" {
33 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
34
3335 try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF(u32));
3436 try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF2(u32));
3537}
......@@ -39,13 +41,21 @@ test "reference to a struct type" {
3941}
4042
4143test "cast negative integer to pointer" {
44 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
45 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
4246 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
47 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
48 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
4349
4450 try expectEqual(@intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))), h.MAP_FAILED);
4551}
4652
4753test "casting to union with a macro" {
54 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
55 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
4856 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
57 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
58 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
4959
5060 const l: c_long = 42;
5161 const d: f64 = 2.0;
......@@ -58,7 +68,11 @@ test "casting to union with a macro" {
5868}
5969
6070test "nested comma operator" {
71 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
72 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
6173 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
74 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
75 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
6276
6377 try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR);
6478}
test/behavior/union_with_members.zig+4
......@@ -17,7 +17,11 @@ const ET = union(enum) {
1717};
1818
1919test "enum with members" {
20 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
21 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
2022 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
23 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2125
2226 const a = ET{ .SINT = -42 };
2327 const b = ET{ .UINT = 42 };
test/behavior/widening.zig+27
......@@ -5,6 +5,12 @@ const builtin = @import("builtin");
55const has_f80_rt = @import("builtin").cpu.arch == .x86_64;
66
77test "integer widening" {
8 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
13
814 var a: u8 = 250;
915 var b: u16 = a;
1016 var c: u32 = b;
......@@ -15,12 +21,24 @@ test "integer widening" {
1521}
1622
1723test "implicit unsigned integer to signed integer" {
24 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
25 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
26 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
27 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
28 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
29
1830 var a: u8 = 250;
1931 var b: i16 = a;
2032 try expect(b == 250);
2133}
2234
2335test "float widening" {
36 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
37 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
38 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
39 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
40 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
41
2442 var a: f16 = 12.34;
2543 var b: f32 = a;
2644 var c: f64 = b;
......@@ -35,6 +53,12 @@ test "float widening" {
3553}
3654
3755test "float widening f16 to f128" {
56 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
57 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
58 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
59 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
60 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
61
3862 // TODO https://github.com/ziglang/zig/issues/3282
3963 if (builtin.cpu.arch == .aarch64) return error.SkipZigTest;
4064 if (builtin.cpu.arch == .powerpc64le) return error.SkipZigTest;
......@@ -45,6 +69,9 @@ test "float widening f16 to f128" {
4569}
4670
4771test "cast small unsigned to larger signed" {
72 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
73 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
74
4875 try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));
4976 try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));
5077}