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");...@@ -3,7 +3,6 @@ const builtin = @import("builtin");
3const mem = std.mem;3const mem = std.mem;
4const math = std.math;4const math = std.math;
5const expect = std.testing.expect;5const expect = std.testing.expect;
6const Vector = std.meta.Vector;
76
8test "implicit cast vector to array - bool" {7test "implicit cast vector to array - bool" {
9 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO8 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
...@@ -14,7 +13,7 @@ test "implicit cast vector to array - bool" {...@@ -14,7 +13,7 @@ test "implicit cast vector to array - bool" {
1413
15 const S = struct {14 const S = struct {
16 fn doTheTest() !void {15 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 };
18 const result_array: [4]bool = a;17 const result_array: [4]bool = a;
19 try expect(mem.eql(bool, &result_array, &[4]bool{ true, false, true, false }));18 try expect(mem.eql(bool, &result_array, &[4]bool{ true, false, true, false }));
20 }19 }
...@@ -32,12 +31,12 @@ test "vector wrap operators" {...@@ -32,12 +31,12 @@ test "vector wrap operators" {
3231
33 const S = struct {32 const S = struct {
34 fn doTheTest() !void {33 fn doTheTest() !void {
35 var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };34 var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
36 var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };35 var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
37 try expect(mem.eql(i32, &@as([4]i32, v +% x), &[4]i32{ -2147483648, 2147483645, 33, 44 }));36 try expect(mem.eql(i32, &@as([4]i32, v +% x), &[4]i32{ -2147483648, 2147483645, 33, 44 }));
38 try expect(mem.eql(i32, &@as([4]i32, v -% x), &[4]i32{ 2147483646, 2147483647, 27, 36 }));37 try expect(mem.eql(i32, &@as([4]i32, v -% x), &[4]i32{ 2147483646, 2147483647, 27, 36 }));
39 try expect(mem.eql(i32, &@as([4]i32, v *% x), &[4]i32{ 2147483647, 2, 90, 160 }));38 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 };
41 try expect(mem.eql(i32, &@as([4]i32, -%z), &[4]i32{ -1, -2, -3, -2147483648 }));40 try expect(mem.eql(i32, &@as([4]i32, -%z), &[4]i32{ -1, -2, -3, -2147483648 }));
42 }41 }
43 };42 };
...@@ -54,8 +53,8 @@ test "vector bin compares with mem.eql" {...@@ -54,8 +53,8 @@ test "vector bin compares with mem.eql" {
5453
55 const S = struct {54 const S = struct {
56 fn doTheTest() !void {55 fn doTheTest() !void {
57 var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };56 var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
58 var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 };57 var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 };
59 try expect(mem.eql(bool, &@as([4]bool, v == x), &[4]bool{ false, false, true, false }));58 try expect(mem.eql(bool, &@as([4]bool, v == x), &[4]bool{ false, false, true, false }));
60 try expect(mem.eql(bool, &@as([4]bool, v != x), &[4]bool{ true, true, false, true }));59 try expect(mem.eql(bool, &@as([4]bool, v != x), &[4]bool{ true, true, false, true }));
61 try expect(mem.eql(bool, &@as([4]bool, v < x), &[4]bool{ false, true, false, false }));60 try expect(mem.eql(bool, &@as([4]bool, v < x), &[4]bool{ false, true, false, false }));
...@@ -77,8 +76,8 @@ test "vector int operators" {...@@ -77,8 +76,8 @@ test "vector int operators" {
7776
78 const S = struct {77 const S = struct {
79 fn doTheTest() !void {78 fn doTheTest() !void {
80 var v: Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };79 var v: @Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
81 var x: Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };80 var x: @Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
82 try expect(mem.eql(i32, &@as([4]i32, v + x), &[4]i32{ 11, 22, 33, 44 }));81 try expect(mem.eql(i32, &@as([4]i32, v + x), &[4]i32{ 11, 22, 33, 44 }));
83 try expect(mem.eql(i32, &@as([4]i32, v - x), &[4]i32{ 9, 18, 27, 36 }));82 try expect(mem.eql(i32, &@as([4]i32, v - x), &[4]i32{ 9, 18, 27, 36 }));
84 try expect(mem.eql(i32, &@as([4]i32, v * x), &[4]i32{ 10, 40, 90, 160 }));83 try expect(mem.eql(i32, &@as([4]i32, v * x), &[4]i32{ 10, 40, 90, 160 }));
...@@ -98,8 +97,8 @@ test "vector float operators" {...@@ -98,8 +97,8 @@ test "vector float operators" {
9897
99 const S = struct {98 const S = struct {
100 fn doTheTest() !void {99 fn doTheTest() !void {
101 var v: Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };100 var v: @Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
102 var x: Vector(4, f32) = [4]f32{ 1, 2, 3, 4 };101 var x: @Vector(4, f32) = [4]f32{ 1, 2, 3, 4 };
103 try expect(mem.eql(f32, &@as([4]f32, v + x), &[4]f32{ 11, 22, 33, 44 }));102 try expect(mem.eql(f32, &@as([4]f32, v + x), &[4]f32{ 11, 22, 33, 44 }));
104 try expect(mem.eql(f32, &@as([4]f32, v - x), &[4]f32{ 9, 18, 27, 36 }));103 try expect(mem.eql(f32, &@as([4]f32, v - x), &[4]f32{ 9, 18, 27, 36 }));
105 try expect(mem.eql(f32, &@as([4]f32, v * x), &[4]f32{ 10, 40, 90, 160 }));104 try expect(mem.eql(f32, &@as([4]f32, v * x), &[4]f32{ 10, 40, 90, 160 }));
...@@ -119,8 +118,8 @@ test "vector bit operators" {...@@ -119,8 +118,8 @@ test "vector bit operators" {
119118
120 const S = struct {119 const S = struct {
121 fn doTheTest() !void {120 fn doTheTest() !void {
122 var v: Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };121 var v: @Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
123 var x: Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 };122 var x: @Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 };
124 try expect(mem.eql(u8, &@as([4]u8, v ^ x), &[4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 }));123 try expect(mem.eql(u8, &@as([4]u8, v ^ x), &[4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 }));
125 try expect(mem.eql(u8, &@as([4]u8, v | x), &[4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 }));124 try expect(mem.eql(u8, &@as([4]u8, v | x), &[4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 }));
126 try expect(mem.eql(u8, &@as([4]u8, v & x), &[4]u8{ 0b10100000, 0b00001010, 0b10101010, 0b00000000 }));125 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" {...@@ -139,7 +138,7 @@ test "implicit cast vector to array" {
139138
140 const S = struct {139 const S = struct {
141 fn doTheTest() !void {140 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 };
143 var result_array: [4]i32 = a;142 var result_array: [4]i32 = a;
144 result_array = a;143 result_array = a;
145 try expect(mem.eql(i32, &result_array, &[4]i32{ 1, 2, 3, 4 }));144 try expect(mem.eql(i32, &result_array, &[4]i32{ 1, 2, 3, 4 }));
...@@ -160,7 +159,7 @@ test "array to vector" {...@@ -160,7 +159,7 @@ test "array to vector" {
160 fn doTheTest() !void {159 fn doTheTest() !void {
161 var foo: f32 = 3.14;160 var foo: f32 = 3.14;
162 var arr = [4]f32{ foo, 1.5, 0.0, 0.0 };161 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;
164 try expect(mem.eql(f32, &@as([4]f32, vec), &arr));163 try expect(mem.eql(f32, &@as([4]f32, vec), &arr));
165 }164 }
166 };165 };
...@@ -178,22 +177,22 @@ test "vector casts of sizes not divisible by 8" {...@@ -178,22 +177,22 @@ test "vector casts of sizes not divisible by 8" {
178 const S = struct {177 const S = struct {
179 fn doTheTest() !void {178 fn doTheTest() !void {
180 {179 {
181 var v: Vector(4, u3) = [4]u3{ 5, 2, 3, 0 };180 var v: @Vector(4, u3) = [4]u3{ 5, 2, 3, 0 };
182 var x: [4]u3 = v;181 var x: [4]u3 = v;
183 try expect(mem.eql(u3, &x, &@as([4]u3, v)));182 try expect(mem.eql(u3, &x, &@as([4]u3, v)));
184 }183 }
185 {184 {
186 var v: Vector(4, u2) = [4]u2{ 1, 2, 3, 0 };185 var v: @Vector(4, u2) = [4]u2{ 1, 2, 3, 0 };
187 var x: [4]u2 = v;186 var x: [4]u2 = v;
188 try expect(mem.eql(u2, &x, &@as([4]u2, v)));187 try expect(mem.eql(u2, &x, &@as([4]u2, v)));
189 }188 }
190 {189 {
191 var v: Vector(4, u1) = [4]u1{ 1, 0, 1, 0 };190 var v: @Vector(4, u1) = [4]u1{ 1, 0, 1, 0 };
192 var x: [4]u1 = v;191 var x: [4]u1 = v;
193 try expect(mem.eql(u1, &x, &@as([4]u1, v)));192 try expect(mem.eql(u1, &x, &@as([4]u1, v)));
194 }193 }
195 {194 {
196 var v: Vector(4, bool) = [4]bool{ false, false, true, false };195 var v: @Vector(4, bool) = [4]bool{ false, false, true, false };
197 var x: [4]bool = v;196 var x: [4]bool = v;
198 try expect(mem.eql(bool, &x, &@as([4]bool, v)));197 try expect(mem.eql(bool, &x, &@as([4]bool, v)));
199 }198 }
...@@ -214,7 +213,7 @@ test "vector @splat" {...@@ -214,7 +213,7 @@ test "vector @splat" {
214 fn testForT(comptime N: comptime_int, v: anytype) !void {213 fn testForT(comptime N: comptime_int, v: anytype) !void {
215 const T = @TypeOf(v);214 const T = @TypeOf(v);
216 var vec = @splat(N, v);215 var vec = @splat(N, v);
217 try expect(Vector(N, T) == @TypeOf(vec));216 try expect(@Vector(N, T) == @TypeOf(vec));
218 var as_array = @as([N]T, vec);217 var as_array = @as([N]T, vec);
219 for (as_array) |elem| try expect(v == elem);218 for (as_array) |elem| try expect(v == elem);
220 }219 }
...@@ -253,7 +252,7 @@ test "load vector elements via comptime index" {...@@ -253,7 +252,7 @@ test "load vector elements via comptime index" {
253252
254 const S = struct {253 const S = struct {
255 fn doTheTest() !void {254 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 };
257 try expect(v[0] == 1);256 try expect(v[0] == 1);
258 try expect(v[1] == 2);257 try expect(v[1] == 2);
259 try expect(loadv(&v[2]) == 3);258 try expect(loadv(&v[2]) == 3);
...@@ -276,7 +275,7 @@ test "store vector elements via comptime index" {...@@ -276,7 +275,7 @@ test "store vector elements via comptime index" {
276275
277 const S = struct {276 const S = struct {
278 fn doTheTest() !void {277 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
281 v[2] = 42;280 v[2] = 42;
282 try expect(v[1] == 5);281 try expect(v[1] == 5);
...@@ -305,7 +304,7 @@ test "load vector elements via runtime index" {...@@ -305,7 +304,7 @@ test "load vector elements via runtime index" {
305304
306 const S = struct {305 const S = struct {
307 fn doTheTest() !void {306 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 };
309 var i: u32 = 0;308 var i: u32 = 0;
310 try expect(v[i] == 1);309 try expect(v[i] == 1);
311 i += 1;310 i += 1;
...@@ -328,7 +327,7 @@ test "store vector elements via runtime index" {...@@ -328,7 +327,7 @@ test "store vector elements via runtime index" {
328327
329 const S = struct {328 const S = struct {
330 fn doTheTest() !void {329 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 };
332 var i: u32 = 2;331 var i: u32 = 2;
333 v[i] = 1;332 v[i] = 1;
334 try expect(v[1] == 5);333 try expect(v[1] == 5);
...@@ -351,7 +350,7 @@ test "initialize vector which is a struct field" {...@@ -351,7 +350,7 @@ test "initialize vector which is a struct field" {
351 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO350 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
352351
353 const Vec4Obj = struct {352 const Vec4Obj = struct {
354 data: Vector(4, f32),353 data: @Vector(4, f32),
355 };354 };
356355
357 const S = struct {356 const S = struct {
...@@ -376,17 +375,17 @@ test "vector comparison operators" {...@@ -376,17 +375,17 @@ test "vector comparison operators" {
376 const S = struct {375 const S = struct {
377 fn doTheTest() !void {376 fn doTheTest() !void {
378 {377 {
379 const v1: Vector(4, bool) = [_]bool{ true, false, true, false };378 var v1: @Vector(4, bool) = [_]bool{ true, false, true, false };
380 const v2: Vector(4, bool) = [_]bool{ false, true, false, true };379 var v2: @Vector(4, bool) = [_]bool{ false, true, false, true };
381 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v1)));380 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v1)));
382 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v2)));381 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v2)));
383 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v2)));382 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v2)));
384 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v2 != v2)));383 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v2 != v2)));
385 }384 }
386 {385 {
387 const v1 = @splat(4, @as(u32, 0xc0ffeeee));386 var v1 = @splat(4, @as(u32, 0xc0ffeeee));
388 const v2: Vector(4, c_uint) = v1;387 var v2: @Vector(4, c_uint) = v1;
389 const v3 = @splat(4, @as(u32, 0xdeadbeef));388 var v3 = @splat(4, @as(u32, 0xdeadbeef));
390 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v2)));389 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v2)));
391 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v3)));390 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v3)));
392 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v3)));391 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v3)));
...@@ -414,7 +413,7 @@ test "vector division operators" {...@@ -414,7 +413,7 @@ test "vector division operators" {
414 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO413 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
415414
416 const S = struct {415 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 {
418 if (!comptime std.meta.trait.isSignedInt(T)) {417 if (!comptime std.meta.trait.isSignedInt(T)) {
419 const d0 = x / y;418 const d0 = x / y;
420 for (@as([4]T, d0)) |v, i| {419 for (@as([4]T, d0)) |v, i| {
...@@ -435,7 +434,7 @@ test "vector division operators" {...@@ -435,7 +434,7 @@ test "vector division operators" {
435 }434 }
436 }435 }
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 {
439 if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) {438 if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) {
440 const r0 = x % y;439 const r0 = x % y;
441 for (@as([4]T, r0)) |v, i| {440 for (@as([4]T, r0)) |v, i| {
...@@ -502,7 +501,7 @@ test "vector bitwise not operator" {...@@ -502,7 +501,7 @@ test "vector bitwise not operator" {
502 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO501 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
503502
504 const S = struct {503 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 {
506 var y = ~x;505 var y = ~x;
507 for (@as([4]T, y)) |v, i| {506 for (@as([4]T, y)) |v, i| {
508 try expect(~x[i] == v);507 try expect(~x[i] == v);
...@@ -538,8 +537,8 @@ test "vector shift operators" {...@@ -538,8 +537,8 @@ test "vector shift operators" {
538 const TX = @typeInfo(@TypeOf(x)).Array.child;537 const TX = @typeInfo(@TypeOf(x)).Array.child;
539 const TY = @typeInfo(@TypeOf(y)).Array.child;538 const TY = @typeInfo(@TypeOf(y)).Array.child;
540539
541 var xv = @as(Vector(N, TX), x);540 var xv = @as(@Vector(N, TX), x);
542 var yv = @as(Vector(N, TY), y);541 var yv = @as(@Vector(N, TY), y);
543542
544 var z0 = xv >> yv;543 var z0 = xv >> yv;
545 for (@as([N]TX, z0)) |v, i| {544 for (@as([N]TX, z0)) |v, i| {
...@@ -555,8 +554,8 @@ test "vector shift operators" {...@@ -555,8 +554,8 @@ test "vector shift operators" {
555 const TX = @typeInfo(@TypeOf(x)).Array.child;554 const TX = @typeInfo(@TypeOf(x)).Array.child;
556 const TY = @typeInfo(@TypeOf(y)).Array.child;555 const TY = @typeInfo(@TypeOf(y)).Array.child;
557556
558 var xv = @as(Vector(N, TX), x);557 var xv = @as(@Vector(N, TX), x);
559 var yv = @as(Vector(N, TY), y);558 var yv = @as(@Vector(N, TY), y);
560559
561 var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv);560 var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv);
562 for (@as([N]TX, z)) |v, i| {561 for (@as([N]TX, z)) |v, i| {
...@@ -768,10 +767,10 @@ test "mask parameter of @shuffle is comptime scope" {...@@ -768,10 +767,10 @@ test "mask parameter of @shuffle is comptime scope" {
768 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO767 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
769 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO768 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);
772 var v4_a = __v4hi{ 0, 0, 0, 0 };771 var v4_a = __v4hi{ 0, 0, 0, 0 };
773 var v4_b = __v4hi{ 0, 0, 0, 0 };772 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){
775 std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),774 std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),
776 std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),775 std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),
777 std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),776 std.zig.c_translation.shuffleVectorIndex(0, @typeInfo(@TypeOf(v4_a)).Vector.len),
...@@ -790,18 +789,18 @@ test "saturating add" {...@@ -790,18 +789,18 @@ test "saturating add" {
790 const S = struct {789 const S = struct {
791 fn doTheTest() !void {790 fn doTheTest() !void {
792 { // Broken out to avoid https://github.com/ziglang/zig/issues/11251791 { // Broken out to avoid https://github.com/ziglang/zig/issues/11251
793 const u8x3 = std.meta.Vector(3, u8);792 const u8x3 = @Vector(3, u8);
794 const lhs = u8x3{ 255, 254, 1 };793 var lhs = u8x3{ 255, 254, 1 };
795 const rhs = u8x3{ 1, 2, 255 };794 var rhs = u8x3{ 1, 2, 255 };
796 const result = lhs +| rhs;795 var result = lhs +| rhs;
797 const expected = u8x3{ 255, 255, 255 };796 const expected = u8x3{ 255, 255, 255 };
798 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));797 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
799 }798 }
800 { // Broken out to avoid https://github.com/ziglang/zig/issues/11251799 { // Broken out to avoid https://github.com/ziglang/zig/issues/11251
801 const i8x3 = std.meta.Vector(3, i8);800 const i8x3 = @Vector(3, i8);
802 const lhs = i8x3{ 127, 126, 1 };801 var lhs = i8x3{ 127, 126, 1 };
803 const rhs = i8x3{ 1, 2, 127 };802 var rhs = i8x3{ 1, 2, 127 };
804 const result = lhs +| rhs;803 var result = lhs +| rhs;
805 const expected = i8x3{ 127, 127, 127 };804 const expected = i8x3{ 127, 127, 127 };
806 try expect(mem.eql(i8, &@as([3]i8, expected), &@as([3]i8, result)));805 try expect(mem.eql(i8, &@as([3]i8, expected), &@as([3]i8, result)));
807 }806 }
...@@ -821,10 +820,10 @@ test "saturating subtraction" {...@@ -821,10 +820,10 @@ test "saturating subtraction" {
821 const S = struct {820 const S = struct {
822 fn doTheTest() !void {821 fn doTheTest() !void {
823 // Broken out to avoid https://github.com/ziglang/zig/issues/11251822 // Broken out to avoid https://github.com/ziglang/zig/issues/11251
824 const u8x3 = std.meta.Vector(3, u8);823 const u8x3 = @Vector(3, u8);
825 const lhs = u8x3{ 0, 0, 0 };824 var lhs = u8x3{ 0, 0, 0 };
826 const rhs = u8x3{ 255, 255, 255 };825 var rhs = u8x3{ 255, 255, 255 };
827 const result = lhs -| rhs;826 var result = lhs -| rhs;
828 const expected = u8x3{ 0, 0, 0 };827 const expected = u8x3{ 0, 0, 0 };
829 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));828 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
830 }829 }
...@@ -846,10 +845,10 @@ test "saturating multiplication" {...@@ -846,10 +845,10 @@ test "saturating multiplication" {
846 const S = struct {845 const S = struct {
847 fn doTheTest() !void {846 fn doTheTest() !void {
848 // Broken out to avoid https://github.com/ziglang/zig/issues/11251847 // Broken out to avoid https://github.com/ziglang/zig/issues/11251
849 const u8x3 = std.meta.Vector(3, u8);848 const u8x3 = @Vector(3, u8);
850 const lhs = u8x3{ 2, 2, 2 };849 var lhs = u8x3{ 2, 2, 2 };
851 const rhs = u8x3{ 255, 255, 255 };850 var rhs = u8x3{ 255, 255, 255 };
852 const result = lhs *| rhs;851 var result = lhs *| rhs;
853 const expected = u8x3{ 255, 255, 255 };852 const expected = u8x3{ 255, 255, 255 };
854 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));853 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
855 }854 }
...@@ -869,10 +868,10 @@ test "saturating shift-left" {...@@ -869,10 +868,10 @@ test "saturating shift-left" {
869 const S = struct {868 const S = struct {
870 fn doTheTest() !void {869 fn doTheTest() !void {
871 // Broken out to avoid https://github.com/ziglang/zig/issues/11251870 // Broken out to avoid https://github.com/ziglang/zig/issues/11251
872 const u8x3 = std.meta.Vector(3, u8);871 const u8x3 = @Vector(3, u8);
873 const lhs = u8x3{ 1, 1, 1 };872 var lhs = u8x3{ 1, 1, 1 };
874 const rhs = u8x3{ 255, 255, 255 };873 var rhs = u8x3{ 255, 255, 255 };
875 const result = lhs <<| rhs;874 var result = lhs <<| rhs;
876 const expected = u8x3{ 255, 255, 255 };875 const expected = u8x3{ 255, 255, 255 };
877 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));876 try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
878 }877 }