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");...@@ -3,8 +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 expectEqual = std.testing.expectEqual;
7const expectApproxEqRel = std.testing.expectApproxEqRel;
8const Vector = std.meta.Vector;6const Vector = std.meta.Vector;
97
10test "implicit cast vector to array - bool" {8test "implicit cast vector to array - bool" {
...@@ -118,10 +116,16 @@ test "implicit cast vector to array" {...@@ -118,10 +116,16 @@ test "implicit cast vector to array" {
118116
119test "array to vector" {117test "array to vector" {
120 if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO118 if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
121 var foo: f32 = 3.14;119 const S = struct {
122 var arr = [4]f32{ foo, 1.5, 0.0, 0.0 };120 fn doTheTest() !void {
123 var vec: Vector(4, f32) = arr;121 var foo: f32 = 3.14;
124 _ = vec;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();
125}129}
126130
127test "vector casts of sizes not divisible by 8" {131test "vector casts of sizes not divisible by 8" {
...@@ -160,9 +164,9 @@ test "vector @splat" {...@@ -160,9 +164,9 @@ test "vector @splat" {
160 fn testForT(comptime N: comptime_int, v: anytype) !void {164 fn testForT(comptime N: comptime_int, v: anytype) !void {
161 const T = @TypeOf(v);165 const T = @TypeOf(v);
162 var vec = @splat(N, v);166 var vec = @splat(N, v);
163 try expectEqual(Vector(N, T), @TypeOf(vec));167 try expect(Vector(N, T) == @TypeOf(vec));
164 var as_array = @as([N]T, vec);168 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);
166 }170 }
167 fn doTheTest() !void {171 fn doTheTest() !void {
168 // Splats with multiple-of-8 bit types that fill a 128bit vector.172 // Splats with multiple-of-8 bit types that fill a 128bit vector.
...@@ -294,27 +298,27 @@ test "vector comparison operators" {...@@ -294,27 +298,27 @@ test "vector comparison operators" {
294 {298 {
295 const v1: Vector(4, bool) = [_]bool{ true, false, true, false };299 const v1: Vector(4, bool) = [_]bool{ true, false, true, false };
296 const v2: Vector(4, bool) = [_]bool{ false, true, false, true };300 const v2: Vector(4, bool) = [_]bool{ false, true, false, true };
297 try expectEqual(@splat(4, true), v1 == v1);301 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v1)));
298 try expectEqual(@splat(4, false), v1 == v2);302 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v2)));
299 try expectEqual(@splat(4, true), v1 != v2);303 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v2)));
300 try expectEqual(@splat(4, false), v2 != v2);304 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v2 != v2)));
301 }305 }
302 {306 {
303 const v1 = @splat(4, @as(u32, 0xc0ffeeee));307 const v1 = @splat(4, @as(u32, 0xc0ffeeee));
304 const v2: Vector(4, c_uint) = v1;308 const v2: Vector(4, c_uint) = v1;
305 const v3 = @splat(4, @as(u32, 0xdeadbeef));309 const v3 = @splat(4, @as(u32, 0xdeadbeef));
306 try expectEqual(@splat(4, true), v1 == v2);310 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 == v2)));
307 try expectEqual(@splat(4, false), v1 == v3);311 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 == v3)));
308 try expectEqual(@splat(4, true), v1 != v3);312 try expect(mem.eql(bool, &@as([4]bool, @splat(4, true)), &@as([4]bool, v1 != v3)));
309 try expectEqual(@splat(4, false), v1 != v2);313 try expect(mem.eql(bool, &@as([4]bool, @splat(4, false)), &@as([4]bool, v1 != v2)));
310 }314 }
311 {315 {
312 // Comptime-known LHS/RHS316 // Comptime-known LHS/RHS
313 var v1: @Vector(4, u32) = [_]u32{ 2, 1, 2, 1 };317 var v1: @Vector(4, u32) = [_]u32{ 2, 1, 2, 1 };
314 const v2 = @splat(4, @as(u32, 2));318 const v2 = @splat(4, @as(u32, 2));
315 const v3: @Vector(4, bool) = [_]bool{ true, false, true, false };319 const v3: @Vector(4, bool) = [_]bool{ true, false, true, false };
316 try expectEqual(v3, v1 == v2);320 try expect(mem.eql(bool, &@as([4]bool, v3), &@as([4]bool, v1 == v2)));
317 try expectEqual(v3, v2 == v1);321 try expect(mem.eql(bool, &@as([4]bool, v3), &@as([4]bool, v2 == v1)));
318 }322 }
319 }323 }
320 };324 };
...@@ -329,20 +333,20 @@ test "vector division operators" {...@@ -329,20 +333,20 @@ test "vector division operators" {
329 if (!comptime std.meta.trait.isSignedInt(T)) {333 if (!comptime std.meta.trait.isSignedInt(T)) {
330 const d0 = x / y;334 const d0 = x / y;
331 for (@as([4]T, d0)) |v, i| {335 for (@as([4]T, d0)) |v, i| {
332 try expectEqual(x[i] / y[i], v);336 try expect(x[i] / y[i] == v);
333 }337 }
334 }338 }
335 const d1 = @divExact(x, y);339 const d1 = @divExact(x, y);
336 for (@as([4]T, d1)) |v, i| {340 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);
338 }342 }
339 const d2 = @divFloor(x, y);343 const d2 = @divFloor(x, y);
340 for (@as([4]T, d2)) |v, i| {344 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);
342 }346 }
343 const d3 = @divTrunc(x, y);347 const d3 = @divTrunc(x, y);
344 for (@as([4]T, d3)) |v, i| {348 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);
346 }350 }
347 }351 }
348352
...@@ -350,16 +354,16 @@ test "vector division operators" {...@@ -350,16 +354,16 @@ test "vector division operators" {
350 if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) {354 if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) {
351 const r0 = x % y;355 const r0 = x % y;
352 for (@as([4]T, r0)) |v, i| {356 for (@as([4]T, r0)) |v, i| {
353 try expectEqual(x[i] % y[i], v);357 try expect(x[i] % y[i] == v);
354 }358 }
355 }359 }
356 const r1 = @mod(x, y);360 const r1 = @mod(x, y);
357 for (@as([4]T, r1)) |v, i| {361 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);
359 }363 }
360 const r2 = @rem(x, y);364 const r2 = @rem(x, y);
361 for (@as([4]T, r2)) |v, i| {365 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);
363 }367 }
364 }368 }
365369
...@@ -411,7 +415,7 @@ test "vector bitwise not operator" {...@@ -411,7 +415,7 @@ test "vector bitwise not operator" {
411 fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void {415 fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void {
412 var y = ~x;416 var y = ~x;
413 for (@as([4]T, y)) |v, i| {417 for (@as([4]T, y)) |v, i| {
414 try expectEqual(~x[i], v);418 try expect(~x[i] == v);
415 }419 }
416 }420 }
417 fn doTheTest() !void {421 fn doTheTest() !void {
...@@ -444,11 +448,11 @@ test "vector shift operators" {...@@ -444,11 +448,11 @@ test "vector shift operators" {
444448
445 var z0 = xv >> yv;449 var z0 = xv >> yv;
446 for (@as([N]TX, z0)) |v, i| {450 for (@as([N]TX, z0)) |v, i| {
447 try expectEqual(x[i] >> y[i], v);451 try expect(x[i] >> y[i] == v);
448 }452 }
449 var z1 = xv << yv;453 var z1 = xv << yv;
450 for (@as([N]TX, z1)) |v, i| {454 for (@as([N]TX, z1)) |v, i| {
451 try expectEqual(x[i] << y[i], v);455 try expect(x[i] << y[i] == v);
452 }456 }
453 }457 }
454 fn doTheTestShiftExact(x: anytype, y: anytype, dir: enum { Left, Right }) !void {458 fn doTheTestShiftExact(x: anytype, y: anytype, dir: enum { Left, Right }) !void {
...@@ -462,7 +466,7 @@ test "vector shift operators" {...@@ -462,7 +466,7 @@ test "vector shift operators" {
462 var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv);466 var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv);
463 for (@as([N]TX, z)) |v, i| {467 for (@as([N]TX, z)) |v, i| {
464 const check = if (dir == .Left) x[i] << y[i] else x[i] >> y[i];468 const check = if (dir == .Left) x[i] << y[i] else x[i] >> y[i];
465 try expectEqual(check, v);469 try expect(check == v);
466 }470 }
467 }471 }
468 fn doTheTest() !void {472 fn doTheTest() !void {
...@@ -681,9 +685,9 @@ test "saturating add" {...@@ -681,9 +685,9 @@ test "saturating add" {
681 const S = struct {685 const S = struct {
682 fn doTheTest() !void {686 fn doTheTest() !void {
683 const u8x3 = std.meta.Vector(3, u8);687 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 })));
685 const i8x3 = std.meta.Vector(3, i8);689 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 })));
687 }691 }
688 };692 };
689 try S.doTheTest();693 try S.doTheTest();
...@@ -695,7 +699,7 @@ test "saturating subtraction" {...@@ -695,7 +699,7 @@ test "saturating subtraction" {
695 const S = struct {699 const S = struct {
696 fn doTheTest() !void {700 fn doTheTest() !void {
697 const u8x3 = std.meta.Vector(3, u8);701 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 })));
699 }703 }
700 };704 };
701 try S.doTheTest();705 try S.doTheTest();
...@@ -710,7 +714,7 @@ test "saturating multiplication" {...@@ -710,7 +714,7 @@ test "saturating multiplication" {
710 const S = struct {714 const S = struct {
711 fn doTheTest() !void {715 fn doTheTest() !void {
712 const u8x3 = std.meta.Vector(3, u8);716 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 })));
714 }718 }
715 };719 };
716720
...@@ -723,7 +727,7 @@ test "saturating shift-left" {...@@ -723,7 +727,7 @@ test "saturating shift-left" {
723 const S = struct {727 const S = struct {
724 fn doTheTest() !void {728 fn doTheTest() !void {
725 const u8x3 = std.meta.Vector(3, u8);729 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 })));
727 }731 }
728 };732 };
729 try S.doTheTest();733 try S.doTheTest();