Commit a0ec2266fe

antlilja <liljaanton2001@gmail.com>
2023-07-07 20:41:33
Update tests to new splat syntax
master
1 parent 16d17ad
Changed files (9)
test
behavior
bitcast.zig
cast.zig
math.zig
vector.zig
cases
compile_errors
bad_splat_type.zig
branch_in_comptime_only_scope_uses_condbr_inline.zig
safety
signed-unsigned vector cast.zig
truncating vector cast.zig
unsigned-signed vector cast.zig
test/behavior/bitcast.zig
@@ -396,7 +396,7 @@ test "bitcast vector to integer and back" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14;
-    var x = @splat(16, true);
+    var x: @Vector(16, bool) = @splat(true);
     x[1] = false;
     try expect(@as(u16, @bitCast(x)) == comptime @as(u16, @bitCast(@as(@Vector(16, bool), arr))));
 }
test/behavior/cast.zig
@@ -639,7 +639,7 @@ test "vector casts" {
         }
 
         fn doTheTestFloat() !void {
-            var vec = @splat(2, @as(f32, 1234.0));
+            var vec: @Vector(2, f32) = @splat(1234.0);
             var wider: @Vector(2, f64) = vec;
             try expect(wider[0] == 1234.0);
             try expect(wider[1] == 1234.0);
test/behavior/math.zig
@@ -111,13 +111,17 @@ test "@clz vectors" {
 }
 
 fn testClzVectors() !void {
+    const Vu4 = @Vector(64, u4);
+    const Vu8 = @Vector(64, u8);
+    const Vu128 = @Vector(64, u128);
+
     @setEvalBranchQuota(10_000);
-    try testOneClzVector(u8, 64, @splat(64, @as(u8, 0b10001010)), @splat(64, @as(u4, 0)));
-    try testOneClzVector(u8, 64, @splat(64, @as(u8, 0b00001010)), @splat(64, @as(u4, 4)));
-    try testOneClzVector(u8, 64, @splat(64, @as(u8, 0b00011010)), @splat(64, @as(u4, 3)));
-    try testOneClzVector(u8, 64, @splat(64, @as(u8, 0b00000000)), @splat(64, @as(u4, 8)));
-    try testOneClzVector(u128, 64, @splat(64, @as(u128, 0xffffffffffffffff)), @splat(64, @as(u8, 64)));
-    try testOneClzVector(u128, 64, @splat(64, @as(u128, 0x10000000000000000)), @splat(64, @as(u8, 63)));
+    try testOneClzVector(u8, 64, @as(Vu8, @splat(0b10001010)), @as(Vu4, @splat(0)));
+    try testOneClzVector(u8, 64, @as(Vu8, @splat(0b00001010)), @as(Vu4, @splat(4)));
+    try testOneClzVector(u8, 64, @as(Vu8, @splat(0b00011010)), @as(Vu4, @splat(3)));
+    try testOneClzVector(u8, 64, @as(Vu8, @splat(0b00000000)), @as(Vu4, @splat(8)));
+    try testOneClzVector(u128, 64, @as(Vu128, @splat(0xffffffffffffffff)), @as(Vu8, @splat(64)));
+    try testOneClzVector(u128, 64, @as(Vu128, @splat(0x10000000000000000)), @as(Vu8, @splat(63)));
 }
 
 fn testOneClzVector(
@@ -180,11 +184,13 @@ test "@ctz vectors" {
 }
 
 fn testCtzVectors() !void {
+    const Vu4 = @Vector(64, u4);
+    const Vu8 = @Vector(64, u8);
     @setEvalBranchQuota(10_000);
-    try testOneCtzVector(u8, 64, @splat(64, @as(u8, 0b10100000)), @splat(64, @as(u4, 5)));
-    try testOneCtzVector(u8, 64, @splat(64, @as(u8, 0b10001010)), @splat(64, @as(u4, 1)));
-    try testOneCtzVector(u8, 64, @splat(64, @as(u8, 0b00000000)), @splat(64, @as(u4, 8)));
-    try testOneCtzVector(u16, 64, @splat(64, @as(u16, 0b00000000)), @splat(64, @as(u5, 16)));
+    try testOneCtzVector(u8, 64, @as(Vu8, @splat(0b10100000)), @as(Vu4, @splat(5)));
+    try testOneCtzVector(u8, 64, @as(Vu8, @splat(0b10001010)), @as(Vu4, @splat(1)));
+    try testOneCtzVector(u8, 64, @as(Vu8, @splat(0b00000000)), @as(Vu4, @splat(8)));
+    try testOneCtzVector(u16, 64, @as(@Vector(64, u16), @splat(0b00000000)), @as(@Vector(64, u5), @splat(16)));
 }
 
 fn testOneCtzVector(
test/behavior/vector.zig
@@ -299,8 +299,7 @@ test "vector @splat" {
     const S = struct {
         fn testForT(comptime N: comptime_int, v: anytype) !void {
             const T = @TypeOf(v);
-            var vec = @splat(N, v);
-            try expect(@Vector(N, T) == @TypeOf(vec));
+            var vec: @Vector(N, T) = @splat(v);
             var as_array = @as([N]T, vec);
             for (as_array) |elem| try expect(v == elem);
         }
@@ -458,26 +457,28 @@ test "vector comparison operators" {
     const S = struct {
         fn doTheTest() !void {
             {
-                var v1: @Vector(4, bool) = [_]bool{ true, false, true, false };
-                var v2: @Vector(4, bool) = [_]bool{ false, true, false, true };
-                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 V = @Vector(4, bool);
+                var v1: V = [_]bool{ true, false, true, false };
+                var v2: V = [_]bool{ false, true, false, true };
+                try expect(mem.eql(bool, &@as([4]bool, @as(V, @splat(true))), &@as([4]bool, v1 == v1)));
+                try expect(mem.eql(bool, &@as([4]bool, @as(V, @splat(false))), &@as([4]bool, v1 == v2)));
+                try expect(mem.eql(bool, &@as([4]bool, @as(V, @splat(true))), &@as([4]bool, v1 != v2)));
+                try expect(mem.eql(bool, &@as([4]bool, @as(V, @splat(false))), &@as([4]bool, v2 != v2)));
             }
             {
-                var v1 = @splat(4, @as(u32, 0xc0ffeeee));
+                const V = @Vector(4, bool);
+                var v1: @Vector(4, u32) = @splat(0xc0ffeeee);
                 var v2: @Vector(4, c_uint) = v1;
-                var v3 = @splat(4, @as(u32, 0xdeadbeef));
-                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)));
+                var v3: @Vector(4, u32) = @splat(0xdeadbeef);
+                try expect(mem.eql(bool, &@as([4]bool, @as(V, @splat(true))), &@as([4]bool, v1 == v2)));
+                try expect(mem.eql(bool, &@as([4]bool, @as(V, @splat(false))), &@as([4]bool, v1 == v3)));
+                try expect(mem.eql(bool, &@as([4]bool, @as(V, @splat(true))), &@as([4]bool, v1 != v3)));
+                try expect(mem.eql(bool, &@as([4]bool, @as(V, @splat(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 v2: @Vector(4, u32) = @splat(2);
                 const v3: @Vector(4, bool) = [_]bool{ true, false, true, false };
                 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)));
@@ -847,8 +848,10 @@ test "vector @reduce comptime" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
-    const value = @Vector(4, i32){ 1, -1, 1, -1 };
-    const result = value > @splat(4, @as(i32, 0));
+    const V = @Vector(4, i32);
+
+    const value = V{ 1, -1, 1, -1 };
+    const result = value > @as(V, @splat(0));
     // result is { true, false, true, false };
     try comptime expect(@TypeOf(result) == @Vector(4, bool));
     const is_all_true = @reduce(.And, result);
@@ -1270,7 +1273,7 @@ test "array operands to shuffle are coerced to vectors" {
     const mask = [5]i32{ -1, 0, 1, 2, 3 };
 
     var a = [5]u32{ 3, 5, 7, 9, 0 };
-    var b = @shuffle(u32, a, @splat(5, @as(u24, 0)), mask);
+    var b = @shuffle(u32, a, @as(@Vector(5, u24), @splat(0)), mask);
     try expectEqual([_]u32{ 0, 3, 5, 7, 9 }, b);
 }
test/cases/compile_errors/bad_splat_type.zig
@@ -1,11 +0,0 @@
-export fn entry() void {
-    const c = 4;
-    var v = @splat(4, c);
-    _ = v;
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :3:23: error: expected integer, float, bool, or pointer for the vector element type; found 'comptime_int'
test/cases/compile_errors/branch_in_comptime_only_scope_uses_condbr_inline.zig
@@ -1,13 +1,13 @@
 pub export fn entry1() void {
     var x: u32 = 3;
-    _ = @shuffle(u32, [_]u32{0}, @splat(1, @as(u32, 0)), [_]i8{
+    _ = @shuffle(u32, [_]u32{0}, @as(@Vector(1, u32), @splat(0)), [_]i8{
         if (x > 1) 1 else -1,
     });
 }
 
 pub export fn entry2() void {
     var y: ?i8 = -1;
-    _ = @shuffle(u32, [_]u32{0}, @splat(1, @as(u32, 0)), [_]i8{
+    _ = @shuffle(u32, [_]u32{0}, @as(@Vector(1, u32), @splat(0)), [_]i8{
         y orelse 1,
     });
 }
test/cases/safety/signed-unsigned vector cast.zig
@@ -9,7 +9,7 @@ pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usi
 }
 
 pub fn main() !void {
-    var x = @splat(4, @as(i32, -2147483647));
+    var x: @Vector(4, i32) = @splat(-2147483647);
     var y: @Vector(4, u32) = @intCast(x);
     _ = y;
     return error.TestFailed;
test/cases/safety/truncating vector cast.zig
@@ -9,7 +9,7 @@ pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usi
 }
 
 pub fn main() !void {
-    var x = @splat(4, @as(u32, 0xdeadbeef));
+    var x: @Vector(4, u32) = @splat(0xdeadbeef);
     var y: @Vector(4, u16) = @intCast(x);
     _ = y;
     return error.TestFailed;
test/cases/safety/unsigned-signed vector cast.zig
@@ -9,7 +9,7 @@ pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usi
 }
 
 pub fn main() !void {
-    var x = @splat(4, @as(u32, 0x80000000));
+    var x: @Vector(4, u32) = @splat(0x80000000);
     var y: @Vector(4, i32) = @intCast(x);
     _ = y;
     return error.TestFailed;