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

1 files changed, 38 insertions, 34 deletions

diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index 7efd018a65..697969f42e 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -3,8 +3,6 @@ const builtin = @import("builtin");
 const mem = std.mem;
 const math = std.math;
 const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
-const expectApproxEqRel = std.testing.expectApproxEqRel;
 const Vector = std.meta.Vector;
 
 test "implicit cast vector to array - bool" {
@@ -118,10 +116,16 @@ test "implicit cast vector to array" {
 
 test "array to vector" {
     if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
-    var foo: f32 = 3.14;
-    var arr = [4]f32{ foo, 1.5, 0.0, 0.0 };
-    var vec: Vector(4, f32) = arr;
-    _ = vec;
+    const S = struct {
+        fn doTheTest() !void {
+            var foo: f32 = 3.14;
+            var arr = [4]f32{ foo, 1.5, 0.0, 0.0 };
+            var vec: Vector(4, f32) = arr;
+            try expect(mem.eql(f32, &@as([4]f32, vec), &arr));
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
 }
 
 test "vector casts of sizes not divisible by 8" {
@@ -160,9 +164,9 @@ test "vector @splat" {
         fn testForT(comptime N: comptime_int, v: anytype) !void {
             const T = @TypeOf(v);
             var vec = @splat(N, v);
-            try expectEqual(Vector(N, T), @TypeOf(vec));
+            try expect(Vector(N, T) == @TypeOf(vec));
             var as_array = @as([N]T, vec);
-            for (as_array) |elem| try expectEqual(v, elem);
+            for (as_array) |elem| try expect(v == elem);
         }
         fn doTheTest() !void {
             // Splats with multiple-of-8 bit types that fill a 128bit vector.
@@ -294,27 +298,27 @@ test "vector comparison operators" {
             {
                 const v1: Vector(4, bool) = [_]bool{ true, false, true, false };
                 const v2: Vector(4, bool) = [_]bool{ false, true, false, true };
-                try expectEqual(@splat(4, true), v1 == v1);
-                try expectEqual(@splat(4, false), v1 == v2);
-                try expectEqual(@splat(4, true), v1 != v2);
-                try expectEqual(@splat(4, false), v2 != v2);
+                try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v1)));
+                try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v2)));
+                try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v2)));
+                try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v2 != v2)));
             }
             {
                 const v1 = @splat(4, @as(u32, 0xc0ffeeee));
                 const v2: Vector(4, c_uint) = v1;
                 const v3 = @splat(4, @as(u32, 0xdeadbeef));
-                try expectEqual(@splat(4, true), v1 == v2);
-                try expectEqual(@splat(4, false), v1 == v3);
-                try expectEqual(@splat(4, true), v1 != v3);
-                try expectEqual(@splat(4, false), v1 != v2);
+                try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v2)));
+                try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v3)));
+                try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v3)));
+                try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 != v2)));
             }
             {
                 // Comptime-known LHS/RHS
                 var v1: @Vector(4, u32) = [_]u32{ 2, 1, 2, 1 };
                 const v2 = @splat(4, @as(u32, 2));
                 const v3: @Vector(4, bool) = [_]bool{ true, false, true, false };
-                try expectEqual(v3, v1 == v2);
-                try expectEqual(v3, v2 == v1);
+                try expect(mem.eql(bool, &@as([4]bool, v3), &@as([4]bool, v1 == v2)));
+                try expect(mem.eql(bool, &@as([4]bool, v3), &@as([4]bool, v2 == v1)));
             }
         }
     };
@@ -329,20 +333,20 @@ test "vector division operators" {
             if (!comptime std.meta.trait.isSignedInt(T)) {
                 const d0 = x / y;
                 for (@as([4]T, d0)) |v, i| {
-                    try expectEqual(x[i] / y[i], v);
+                    try expect(x[i] / y[i] == v);
                 }
             }
             const d1 = @divExact(x, y);
             for (@as([4]T, d1)) |v, i| {
-                try expectEqual(@divExact(x[i], y[i]), v);
+                try expect(@divExact(x[i], y[i]) == v);
             }
             const d2 = @divFloor(x, y);
             for (@as([4]T, d2)) |v, i| {
-                try expectEqual(@divFloor(x[i], y[i]), v);
+                try expect(@divFloor(x[i], y[i]) == v);
             }
             const d3 = @divTrunc(x, y);
             for (@as([4]T, d3)) |v, i| {
-                try expectEqual(@divTrunc(x[i], y[i]), v);
+                try expect(@divTrunc(x[i], y[i]) == v);
             }
         }
 
@@ -350,16 +354,16 @@ test "vector division operators" {
             if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) {
                 const r0 = x % y;
                 for (@as([4]T, r0)) |v, i| {
-                    try expectEqual(x[i] % y[i], v);
+                    try expect(x[i] % y[i] == v);
                 }
             }
             const r1 = @mod(x, y);
             for (@as([4]T, r1)) |v, i| {
-                try expectEqual(@mod(x[i], y[i]), v);
+                try expect(@mod(x[i], y[i]) == v);
             }
             const r2 = @rem(x, y);
             for (@as([4]T, r2)) |v, i| {
-                try expectEqual(@rem(x[i], y[i]), v);
+                try expect(@rem(x[i], y[i]) == v);
             }
         }
 
@@ -411,7 +415,7 @@ test "vector bitwise not operator" {
         fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void {
             var y = ~x;
             for (@as([4]T, y)) |v, i| {
-                try expectEqual(~x[i], v);
+                try expect(~x[i] == v);
             }
         }
         fn doTheTest() !void {
@@ -444,11 +448,11 @@ test "vector shift operators" {
 
             var z0 = xv >> yv;
             for (@as([N]TX, z0)) |v, i| {
-                try expectEqual(x[i] >> y[i], v);
+                try expect(x[i] >> y[i] == v);
             }
             var z1 = xv << yv;
             for (@as([N]TX, z1)) |v, i| {
-                try expectEqual(x[i] << y[i], v);
+                try expect(x[i] << y[i] == v);
             }
         }
         fn doTheTestShiftExact(x: anytype, y: anytype, dir: enum { Left, Right }) !void {
@@ -462,7 +466,7 @@ test "vector shift operators" {
             var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv);
             for (@as([N]TX, z)) |v, i| {
                 const check = if (dir == .Left) x[i] << y[i] else x[i] >> y[i];
-                try expectEqual(check, v);
+                try expect(check == v);
             }
         }
         fn doTheTest() !void {
@@ -681,9 +685,9 @@ test "saturating add" {
     const S = struct {
         fn doTheTest() !void {
             const u8x3 = std.meta.Vector(3, u8);
-            try expectEqual(u8x3{ 255, 255, 255 }, (u8x3{ 255, 254, 1 } +| u8x3{ 1, 2, 255 }));
+            try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 255, 254, 1 } +| u8x3{ 1, 2, 255 })));
             const i8x3 = std.meta.Vector(3, i8);
-            try expectEqual(i8x3{ 127, 127, 127 }, (i8x3{ 127, 126, 1 } +| i8x3{ 1, 2, 127 }));
+            try expect(mem.eql(i8, &@as([3]i8, i8x3{ 127, 127, 127 }), &@as([3]i8, i8x3{ 127, 126, 1 } +| i8x3{ 1, 2, 127 })));
         }
     };
     try S.doTheTest();
@@ -695,7 +699,7 @@ test "saturating subtraction" {
     const S = struct {
         fn doTheTest() !void {
             const u8x3 = std.meta.Vector(3, u8);
-            try expectEqual(u8x3{ 0, 0, 0 }, (u8x3{ 0, 0, 0 } -| u8x3{ 255, 255, 255 }));
+            try expect(mem.eql(u8, &@as([3]u8, u8x3{ 0, 0, 0 }), &@as([3]u8, u8x3{ 0, 0, 0 } -| u8x3{ 255, 255, 255 })));
         }
     };
     try S.doTheTest();
@@ -710,7 +714,7 @@ test "saturating multiplication" {
     const S = struct {
         fn doTheTest() !void {
             const u8x3 = std.meta.Vector(3, u8);
-            try expectEqual(u8x3{ 255, 255, 255 }, (u8x3{ 2, 2, 2 } *| u8x3{ 255, 255, 255 }));
+            try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 2, 2, 2 } *| u8x3{ 255, 255, 255 })));
         }
     };
 
@@ -723,7 +727,7 @@ test "saturating shift-left" {
     const S = struct {
         fn doTheTest() !void {
             const u8x3 = std.meta.Vector(3, u8);
-            try expectEqual(u8x3{ 255, 255, 255 }, (u8x3{ 255, 255, 255 } <<| u8x3{ 1, 1, 1 }));
+            try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 255, 255, 255 } <<| u8x3{ 1, 1, 1 })));
         }
     };
     try S.doTheTest();