authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-21 17:03:24-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-21 17:03:24-07:00
log7eddef423d74318ef9190864232f2e224837461e
treeccc577b34bc44433c78a56c4ab7065ac5ee50a2d
parent513a53e9aaa6356faf385e257925a8949bd1b46a

behavior tests: alter test coverage for vectors

* Use `@Vector` syntax instead of `std.meta.Vector`. * Use `var` instead of `const` for tests so that we get runtime coverage instead of only comptime coverage. Comptime coverage is done with `comptime doTheTest()` calls.

1 files changed, 58 insertions(+), 59 deletions(-)

test/behavior/vector.zig+58-59
......@@ -3,7 +3,6 @@ const builtin = @import("builtin");
33const mem = std.mem;
44const math = std.math;
55const expect = std.testing.expect;
6const Vector = std.meta.Vector;
76
87test "implicit cast vector to array - bool" {
98 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
......@@ -14,7 +13,7 @@ test "implicit cast vector to array - bool" {
1413
1514 const S = struct {
1615 fn doTheTest() !void {
17 const a: Vector(4, bool) = [_]bool{ true, false, true, false };
16 const a: @Vector(4, bool) = [_]bool{ true, false, true, false };
1817 const result_array: [4]bool = a;
1918 try expect(mem.eql(bool, &result_array, &[4]bool{ true, false, true, false }));
2019 }
......@@ -32,12 +31,12 @@ test "vector wrap operators" {
3231
3332 const S = struct {
3433 fn doTheTest() !void {
35 var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
36 var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
34 var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
35 var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
3736 try expect(mem.eql(i32, &@as([4]i32, v +% x), &[4]i32{ -2147483648, 2147483645, 33, 44 }));
3837 try expect(mem.eql(i32, &@as([4]i32, v -% x), &[4]i32{ 2147483646, 2147483647, 27, 36 }));
3938 try expect(mem.eql(i32, &@as([4]i32, v *% x), &[4]i32{ 2147483647, 2, 90, 160 }));
40 var z: Vector(4, i32) = [4]i32{ 1, 2, 3, -2147483648 };
39 var z: @Vector(4, i32) = [4]i32{ 1, 2, 3, -2147483648 };
4140 try expect(mem.eql(i32, &@as([4]i32, -%z), &[4]i32{ -1, -2, -3, -2147483648 }));
4241 }
4342 };
......@@ -54,8 +53,8 @@ test "vector bin compares with mem.eql" {
5453
5554 const S = struct {
5655 fn doTheTest() !void {
57 var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
58 var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 };
56 var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
57 var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 };
5958 try expect(mem.eql(bool, &@as([4]bool, v == x), &[4]bool{ false, false, true, false }));
6059 try expect(mem.eql(bool, &@as([4]bool, v != x), &[4]bool{ true, true, false, true }));
6160 try expect(mem.eql(bool, &@as([4]bool, v < x), &[4]bool{ false, true, false, false }));
......@@ -77,8 +76,8 @@ test "vector int operators" {
7776
7877 const S = struct {
7978 fn doTheTest() !void {
80 var v: Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
81 var x: Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
79 var v: @Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
80 var x: @Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
8281 try expect(mem.eql(i32, &@as([4]i32, v + x), &[4]i32{ 11, 22, 33, 44 }));
8382 try expect(mem.eql(i32, &@as([4]i32, v - x), &[4]i32{ 9, 18, 27, 36 }));
8483 try expect(mem.eql(i32, &@as([4]i32, v * x), &[4]i32{ 10, 40, 90, 160 }));
......@@ -98,8 +97,8 @@ test "vector float operators" {
9897
9998 const S = struct {
10099 fn doTheTest() !void {
101 var v: Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
102 var x: Vector(4, f32) = [4]f32{ 1, 2, 3, 4 };
100 var v: @Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
101 var x: @Vector(4, f32) = [4]f32{ 1, 2, 3, 4 };
103102 try expect(mem.eql(f32, &@as([4]f32, v + x), &[4]f32{ 11, 22, 33, 44 }));
104103 try expect(mem.eql(f32, &@as([4]f32, v - x), &[4]f32{ 9, 18, 27, 36 }));
105104 try expect(mem.eql(f32, &@as([4]f32, v * x), &[4]f32{ 10, 40, 90, 160 }));
......@@ -119,8 +118,8 @@ test "vector bit operators" {
119118
120119 const S = struct {
121120 fn doTheTest() !void {
122 var v: Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
123 var x: Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 };
121 var v: @Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
122 var x: @Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 };
124123 try expect(mem.eql(u8, &@as([4]u8, v ^ x), &[4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 }));
125124 try expect(mem.eql(u8, &@as([4]u8, v | x), &[4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 }));
126125 try expect(mem.eql(u8, &@as([4]u8, v & x), &[4]u8{ 0b10100000, 0b00001010, 0b10101010, 0b00000000 }));
......@@ -139,7 +138,7 @@ test "implicit cast vector to array" {
139138
140139 const S = struct {
141140 fn doTheTest() !void {
142 var a: Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
141 var a: @Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
143142 var result_array: [4]i32 = a;
144143 result_array = a;
145144 try expect(mem.eql(i32, &result_array, &[4]i32{ 1, 2, 3, 4 }));
......@@ -160,7 +159,7 @@ test "array to vector" {
160159 fn doTheTest() !void {
161160 var foo: f32 = 3.14;
162161 var arr = [4]f32{ foo, 1.5, 0.0, 0.0 };
163 var vec: Vector(4, f32) = arr;
162 var vec: @Vector(4, f32) = arr;
164163 try expect(mem.eql(f32, &@as([4]f32, vec), &arr));
165164 }
166165 };
......@@ -178,22 +177,22 @@ test "vector casts of sizes not divisible by 8" {
178177 const S = struct {
179178 fn doTheTest() !void {
180179 {
181 var v: Vector(4, u3) = [4]u3{ 5, 2, 3, 0 };
180 var v: @Vector(4, u3) = [4]u3{ 5, 2, 3, 0 };
182181 var x: [4]u3 = v;
183182 try expect(mem.eql(u3, &x, &@as([4]u3, v)));
184183 }
185184 {
186 var v: Vector(4, u2) = [4]u2{ 1, 2, 3, 0 };
185 var v: @Vector(4, u2) = [4]u2{ 1, 2, 3, 0 };
187186 var x: [4]u2 = v;
188187 try expect(mem.eql(u2, &x, &@as([4]u2, v)));
189188 }
190189 {
191 var v: Vector(4, u1) = [4]u1{ 1, 0, 1, 0 };
190 var v: @Vector(4, u1) = [4]u1{ 1, 0, 1, 0 };
192191 var x: [4]u1 = v;
193192 try expect(mem.eql(u1, &x, &@as([4]u1, v)));
194193 }
195194 {
196 var v: Vector(4, bool) = [4]bool{ false, false, true, false };
195 var v: @Vector(4, bool) = [4]bool{ false, false, true, false };
197196 var x: [4]bool = v;
198197 try expect(mem.eql(bool, &x, &@as([4]bool, v)));
199198 }
......@@ -214,7 +213,7 @@ test "vector @splat" {
214213 fn testForT(comptime N: comptime_int, v: anytype) !void {
215214 const T = @TypeOf(v);
216215 var vec = @splat(N, v);
217 try expect(Vector(N, T) == @TypeOf(vec));
216 try expect(@Vector(N, T) == @TypeOf(vec));
218217 var as_array = @as([N]T, vec);
219218 for (as_array) |elem| try expect(v == elem);
220219 }
......@@ -253,7 +252,7 @@ test "load vector elements via comptime index" {
253252
254253 const S = struct {
255254 fn doTheTest() !void {
256 var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
255 var v: @Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
257256 try expect(v[0] == 1);
258257 try expect(v[1] == 2);
259258 try expect(loadv(&v[2]) == 3);
......@@ -276,7 +275,7 @@ test "store vector elements via comptime index" {
276275
277276 const S = struct {
278277 fn doTheTest() !void {
279 var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
278 var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
280279
281280 v[2] = 42;
282281 try expect(v[1] == 5);
......@@ -305,7 +304,7 @@ test "load vector elements via runtime index" {
305304
306305 const S = struct {
307306 fn doTheTest() !void {
308 var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
307 var v: @Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
309308 var i: u32 = 0;
310309 try expect(v[i] == 1);
311310 i += 1;
......@@ -328,7 +327,7 @@ test "store vector elements via runtime index" {
328327
329328 const S = struct {
330329 fn doTheTest() !void {
331 var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
330 var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
332331 var i: u32 = 2;
333332 v[i] = 1;
334333 try expect(v[1] == 5);
......@@ -351,7 +350,7 @@ test "initialize vector which is a struct field" {
351350 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
352351
353352 const Vec4Obj = struct {
354 data: Vector(4, f32),
353 data: @Vector(4, f32),
355354 };
356355
357356 const S = struct {
......@@ -376,17 +375,17 @@ test "vector comparison operators" {
376375 const S = struct {
377376 fn doTheTest() !void {
378377 {
379 const v1: Vector(4, bool) = [_]bool{ true, false, true, false };
380 const v2: Vector(4, bool) = [_]bool{ false, true, false, true };
378 var v1: @Vector(4, bool) = [_]bool{ true, false, true, false };
379 var v2: @Vector(4, bool) = [_]bool{ false, true, false, true };
381380 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v1)));
382381 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v2)));
383382 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v2)));
384383 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v2 != v2)));
385384 }
386385 {
387 const v1 = @splat(4, @as(u32, 0xc0ffeeee));
388 const v2: Vector(4, c_uint) = v1;
389 const v3 = @splat(4, @as(u32, 0xdeadbeef));
386 var v1 = @splat(4, @as(u32, 0xc0ffeeee));
387 var v2: @Vector(4, c_uint) = v1;
388 var v3 = @splat(4, @as(u32, 0xdeadbeef));
390389 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v2)));
391390 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v3)));
392391 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v3)));
......@@ -414,7 +413,7 @@ test "vector division operators" {
414413 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
415414
416415 const S = struct {
417 fn doTheTestDiv(comptime T: type, x: Vector(4, T), y: Vector(4, T)) !void {
416 fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {
418417 if (!comptime std.meta.trait.isSignedInt(T)) {
419418 const d0 = x / y;
420419 for (@as([4]T, d0)) |v, i| {
......@@ -435,7 +434,7 @@ test "vector division operators" {
435434 }
436435 }
437436
438 fn doTheTestMod(comptime T: type, x: Vector(4, T), y: Vector(4, T)) !void {
437 fn doTheTestMod(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {
439438 if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) {
440439 const r0 = x % y;
441440 for (@as([4]T, r0)) |v, i| {
......@@ -502,7 +501,7 @@ test "vector bitwise not operator" {
502501 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
503502
504503 const S = struct {
505 fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void {
504 fn doTheTestNot(comptime T: type, x: @Vector(4, T)) !void {
506505 var y = ~x;
507506 for (@as([4]T, y)) |v, i| {
508507 try expect(~x[i] == v);
......@@ -538,8 +537,8 @@ test "vector shift operators" {
538537 const TX = @typeInfo(@TypeOf(x)).Array.child;
539538 const TY = @typeInfo(@TypeOf(y)).Array.child;
540539
541 var xv = @as(Vector(N, TX), x);
542 var yv = @as(Vector(N, TY), y);
540 var xv = @as(@Vector(N, TX), x);
541 var yv = @as(@Vector(N, TY), y);
543542
544543 var z0 = xv >> yv;
545544 for (@as([N]TX, z0)) |v, i| {
......@@ -555,8 +554,8 @@ test "vector shift operators" {
555554 const TX = @typeInfo(@TypeOf(x)).Array.child;
556555 const TY = @typeInfo(@TypeOf(y)).Array.child;
557556
558 var xv = @as(Vector(N, TX), x);
559 var yv = @as(Vector(N, TY), y);
557 var xv = @as(@Vector(N, TX), x);
558 var yv = @as(@Vector(N, TY), y);
560559
561560 var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv);
562561 for (@as([N]TX, z)) |v, i| {
......@@ -768,10 +767,10 @@ test "mask parameter of @shuffle is comptime scope" {
768767 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
769768 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
770769
771 const __v4hi = std.meta.Vector(4, i16);
770 const __v4hi = @Vector(4, i16);
772771 var v4_a = __v4hi{ 0, 0, 0, 0 };
773772 var v4_b = __v4hi{ 0, 0, 0, 0 };
774 var shuffled: __v4hi = @shuffle(i16, v4_a, v4_b, std.meta.Vector(4, i32){
773 var shuffled: __v4hi = @shuffle(i16, v4_a, v4_b, @Vector(4, i32){
775774 std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),
776775 std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),
777776 std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),
......@@ -790,18 +789,18 @@ test "saturating add" {
790789 const S = struct {
791790 fn doTheTest() !void {
792791 { // Broken out to avoid https://github.com/ziglang/zig/issues/11251
793 const u8x3 = std.meta.Vector(3, u8);
794 const lhs = u8x3{ 255, 254, 1 };
795 const rhs = u8x3{ 1, 2, 255 };
796 const result = lhs +| rhs;
792 const u8x3 = @Vector(3, u8);
793 var lhs = u8x3{ 255, 254, 1 };
794 var rhs = u8x3{ 1, 2, 255 };
795 var result = lhs +| rhs;
797796 const expected = u8x3{ 255, 255, 255 };
798797 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
799798 }
800799 { // Broken out to avoid https://github.com/ziglang/zig/issues/11251
801 const i8x3 = std.meta.Vector(3, i8);
802 const lhs = i8x3{ 127, 126, 1 };
803 const rhs = i8x3{ 1, 2, 127 };
804 const result = lhs +| rhs;
800 const i8x3 = @Vector(3, i8);
801 var lhs = i8x3{ 127, 126, 1 };
802 var rhs = i8x3{ 1, 2, 127 };
803 var result = lhs +| rhs;
805804 const expected = i8x3{ 127, 127, 127 };
806805 try expect(mem.eql(i8, &@as([3]i8, expected), &@as([3]i8, result)));
807806 }
......@@ -821,10 +820,10 @@ test "saturating subtraction" {
821820 const S = struct {
822821 fn doTheTest() !void {
823822 // Broken out to avoid https://github.com/ziglang/zig/issues/11251
824 const u8x3 = std.meta.Vector(3, u8);
825 const lhs = u8x3{ 0, 0, 0 };
826 const rhs = u8x3{ 255, 255, 255 };
827 const result = lhs -| rhs;
823 const u8x3 = @Vector(3, u8);
824 var lhs = u8x3{ 0, 0, 0 };
825 var rhs = u8x3{ 255, 255, 255 };
826 var result = lhs -| rhs;
828827 const expected = u8x3{ 0, 0, 0 };
829828 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
830829 }
......@@ -846,10 +845,10 @@ test "saturating multiplication" {
846845 const S = struct {
847846 fn doTheTest() !void {
848847 // Broken out to avoid https://github.com/ziglang/zig/issues/11251
849 const u8x3 = std.meta.Vector(3, u8);
850 const lhs = u8x3{ 2, 2, 2 };
851 const rhs = u8x3{ 255, 255, 255 };
852 const result = lhs *| rhs;
848 const u8x3 = @Vector(3, u8);
849 var lhs = u8x3{ 2, 2, 2 };
850 var rhs = u8x3{ 255, 255, 255 };
851 var result = lhs *| rhs;
853852 const expected = u8x3{ 255, 255, 255 };
854853 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
855854 }
......@@ -869,10 +868,10 @@ test "saturating shift-left" {
869868 const S = struct {
870869 fn doTheTest() !void {
871870 // Broken out to avoid https://github.com/ziglang/zig/issues/11251
872 const u8x3 = std.meta.Vector(3, u8);
873 const lhs = u8x3{ 1, 1, 1 };
874 const rhs = u8x3{ 255, 255, 255 };
875 const result = lhs <<| rhs;
871 const u8x3 = @Vector(3, u8);
872 var lhs = u8x3{ 1, 1, 1 };
873 var rhs = u8x3{ 255, 255, 255 };
874 var result = lhs <<| rhs;
876875 const expected = u8x3{ 255, 255, 255 };
877876 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
878877 }