authorgravatar for william@sengir.comWilliam Sengir <william@sengir.com> 2022-03-19 19:38:43-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-21 16:54:19-07:00
logcda8f65489af099a5a93a7475f344c615678aa26
tree4ef7296a0c09c7f6a698cff915c2f553f6e1bf09
parent2f4473b6536ee43e51a17b02d8fad7518ab32c3b

behavior tests: use `expect` instead of `expectEqual` in vector.zig

1 files changed, 38 insertions(+), 34 deletions(-)

test/behavior/vector.zig+38-34
......@@ -3,8 +3,6 @@ const builtin = @import("builtin");
33const mem = std.mem;
44const math = std.math;
55const expect = std.testing.expect;
6const expectEqual = std.testing.expectEqual;
7const expectApproxEqRel = std.testing.expectApproxEqRel;
86const Vector = std.meta.Vector;
97
108test "implicit cast vector to array - bool" {
......@@ -118,10 +116,16 @@ test "implicit cast vector to array" {
118116
119117test "array to vector" {
120118 if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
121 var foo: f32 = 3.14;
122 var arr = [4]f32{ foo, 1.5, 0.0, 0.0 };
123 var vec: Vector(4, f32) = arr;
124 _ = vec;
119 const S = struct {
120 fn doTheTest() !void {
121 var foo: f32 = 3.14;
122 var arr = [4]f32{ foo, 1.5, 0.0, 0.0 };
123 var vec: Vector(4, f32) = arr;
124 try expect(mem.eql(f32, &@as([4]f32, vec), &arr));
125 }
126 };
127 try S.doTheTest();
128 comptime try S.doTheTest();
125129}
126130
127131test "vector casts of sizes not divisible by 8" {
......@@ -160,9 +164,9 @@ test "vector @splat" {
160164 fn testForT(comptime N: comptime_int, v: anytype) !void {
161165 const T = @TypeOf(v);
162166 var vec = @splat(N, v);
163 try expectEqual(Vector(N, T), @TypeOf(vec));
167 try expect(Vector(N, T) == @TypeOf(vec));
164168 var as_array = @as([N]T, vec);
165 for (as_array) |elem| try expectEqual(v, elem);
169 for (as_array) |elem| try expect(v == elem);
166170 }
167171 fn doTheTest() !void {
168172 // Splats with multiple-of-8 bit types that fill a 128bit vector.
......@@ -294,27 +298,27 @@ test "vector comparison operators" {
294298 {
295299 const v1: Vector(4, bool) = [_]bool{ true, false, true, false };
296300 const v2: Vector(4, bool) = [_]bool{ false, true, false, true };
297 try expectEqual(@splat(4, true), v1 == v1);
298 try expectEqual(@splat(4, false), v1 == v2);
299 try expectEqual(@splat(4, true), v1 != v2);
300 try expectEqual(@splat(4, false), v2 != v2);
301 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v1)));
302 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v2)));
303 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v2)));
304 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v2 != v2)));
301305 }
302306 {
303307 const v1 = @splat(4, @as(u32, 0xc0ffeeee));
304308 const v2: Vector(4, c_uint) = v1;
305309 const v3 = @splat(4, @as(u32, 0xdeadbeef));
306 try expectEqual(@splat(4, true), v1 == v2);
307 try expectEqual(@splat(4, false), v1 == v3);
308 try expectEqual(@splat(4, true), v1 != v3);
309 try expectEqual(@splat(4, false), v1 != v2);
310 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v2)));
311 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v3)));
312 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v3)));
313 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 != v2)));
310314 }
311315 {
312316 // Comptime-known LHS/RHS
313317 var v1: @Vector(4, u32) = [_]u32{ 2, 1, 2, 1 };
314318 const v2 = @splat(4, @as(u32, 2));
315319 const v3: @Vector(4, bool) = [_]bool{ true, false, true, false };
316 try expectEqual(v3, v1 == v2);
317 try expectEqual(v3, v2 == v1);
320 try expect(mem.eql(bool, &@as([4]bool, v3), &@as([4]bool, v1 == v2)));
321 try expect(mem.eql(bool, &@as([4]bool, v3), &@as([4]bool, v2 == v1)));
318322 }
319323 }
320324 };
......@@ -329,20 +333,20 @@ test "vector division operators" {
329333 if (!comptime std.meta.trait.isSignedInt(T)) {
330334 const d0 = x / y;
331335 for (@as([4]T, d0)) |v, i| {
332 try expectEqual(x[i] / y[i], v);
336 try expect(x[i] / y[i] == v);
333337 }
334338 }
335339 const d1 = @divExact(x, y);
336340 for (@as([4]T, d1)) |v, i| {
337 try expectEqual(@divExact(x[i], y[i]), v);
341 try expect(@divExact(x[i], y[i]) == v);
338342 }
339343 const d2 = @divFloor(x, y);
340344 for (@as([4]T, d2)) |v, i| {
341 try expectEqual(@divFloor(x[i], y[i]), v);
345 try expect(@divFloor(x[i], y[i]) == v);
342346 }
343347 const d3 = @divTrunc(x, y);
344348 for (@as([4]T, d3)) |v, i| {
345 try expectEqual(@divTrunc(x[i], y[i]), v);
349 try expect(@divTrunc(x[i], y[i]) == v);
346350 }
347351 }
348352
......@@ -350,16 +354,16 @@ test "vector division operators" {
350354 if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) {
351355 const r0 = x % y;
352356 for (@as([4]T, r0)) |v, i| {
353 try expectEqual(x[i] % y[i], v);
357 try expect(x[i] % y[i] == v);
354358 }
355359 }
356360 const r1 = @mod(x, y);
357361 for (@as([4]T, r1)) |v, i| {
358 try expectEqual(@mod(x[i], y[i]), v);
362 try expect(@mod(x[i], y[i]) == v);
359363 }
360364 const r2 = @rem(x, y);
361365 for (@as([4]T, r2)) |v, i| {
362 try expectEqual(@rem(x[i], y[i]), v);
366 try expect(@rem(x[i], y[i]) == v);
363367 }
364368 }
365369
......@@ -411,7 +415,7 @@ test "vector bitwise not operator" {
411415 fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void {
412416 var y = ~x;
413417 for (@as([4]T, y)) |v, i| {
414 try expectEqual(~x[i], v);
418 try expect(~x[i] == v);
415419 }
416420 }
417421 fn doTheTest() !void {
......@@ -444,11 +448,11 @@ test "vector shift operators" {
444448
445449 var z0 = xv >> yv;
446450 for (@as([N]TX, z0)) |v, i| {
447 try expectEqual(x[i] >> y[i], v);
451 try expect(x[i] >> y[i] == v);
448452 }
449453 var z1 = xv << yv;
450454 for (@as([N]TX, z1)) |v, i| {
451 try expectEqual(x[i] << y[i], v);
455 try expect(x[i] << y[i] == v);
452456 }
453457 }
454458 fn doTheTestShiftExact(x: anytype, y: anytype, dir: enum { Left, Right }) !void {
......@@ -462,7 +466,7 @@ test "vector shift operators" {
462466 var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv);
463467 for (@as([N]TX, z)) |v, i| {
464468 const check = if (dir == .Left) x[i] << y[i] else x[i] >> y[i];
465 try expectEqual(check, v);
469 try expect(check == v);
466470 }
467471 }
468472 fn doTheTest() !void {
......@@ -681,9 +685,9 @@ test "saturating add" {
681685 const S = struct {
682686 fn doTheTest() !void {
683687 const u8x3 = std.meta.Vector(3, u8);
684 try expectEqual(u8x3{ 255, 255, 255 }, (u8x3{ 255, 254, 1 } +| u8x3{ 1, 2, 255 }));
688 try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 255, 254, 1 } +| u8x3{ 1, 2, 255 })));
685689 const i8x3 = std.meta.Vector(3, i8);
686 try expectEqual(i8x3{ 127, 127, 127 }, (i8x3{ 127, 126, 1 } +| i8x3{ 1, 2, 127 }));
690 try expect(mem.eql(i8, &@as([3]i8, i8x3{ 127, 127, 127 }), &@as([3]i8, i8x3{ 127, 126, 1 } +| i8x3{ 1, 2, 127 })));
687691 }
688692 };
689693 try S.doTheTest();
......@@ -695,7 +699,7 @@ test "saturating subtraction" {
695699 const S = struct {
696700 fn doTheTest() !void {
697701 const u8x3 = std.meta.Vector(3, u8);
698 try expectEqual(u8x3{ 0, 0, 0 }, (u8x3{ 0, 0, 0 } -| u8x3{ 255, 255, 255 }));
702 try expect(mem.eql(u8, &@as([3]u8, u8x3{ 0, 0, 0 }), &@as([3]u8, u8x3{ 0, 0, 0 } -| u8x3{ 255, 255, 255 })));
699703 }
700704 };
701705 try S.doTheTest();
......@@ -710,7 +714,7 @@ test "saturating multiplication" {
710714 const S = struct {
711715 fn doTheTest() !void {
712716 const u8x3 = std.meta.Vector(3, u8);
713 try expectEqual(u8x3{ 255, 255, 255 }, (u8x3{ 2, 2, 2 } *| u8x3{ 255, 255, 255 }));
717 try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 2, 2, 2 } *| u8x3{ 255, 255, 255 })));
714718 }
715719 };
716720
......@@ -723,7 +727,7 @@ test "saturating shift-left" {
723727 const S = struct {
724728 fn doTheTest() !void {
725729 const u8x3 = std.meta.Vector(3, u8);
726 try expectEqual(u8x3{ 255, 255, 255 }, (u8x3{ 255, 255, 255 } <<| u8x3{ 1, 1, 1 }));
730 try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 255, 255, 255 } <<| u8x3{ 1, 1, 1 })));
727731 }
728732 };
729733 try S.doTheTest();