improving tests; CI skip

test/maths.zig

@@ -3,56 +3,59 @@ const root = @import("root.zig");
 const compileNzsl = root.compileNzsl;
 const case = root.case;
 
-test "FMul vec4[f32]" {
+test "Mul vec4" {
     const allocator = std.testing.allocator;
-    const shader =
+    const types = [_]type{ f32, i32 };
+    inline for (types) |T| {
+        const prng: std.Random.DefaultPrng = .init(@intCast(std.time.microTimestamp()));
+
+        const base_color: [4]T = undefined;
+        std.Random.shuffle(prng, T, base_color);
+        const ratio: [4]T = undefined;
+        std.Random.shuffle(prng, T, ratio);
+
+        const expected = [4]T{
+            base_color[0] * ratio[0],
+            base_color[1] * ratio[1],
+            base_color[2] * ratio[2],
+            base_color[3] * ratio[3],
+        };
+
+        const shader = try std.fmt.allocPrint(
+            allocator,
             \\ [nzsl_version("1.1")]
             \\ module;
             \\ 
             \\ struct FragOut
-        \\ {
-        \\     [location(0)] color: vec4[f32]
-        \\ }
+            \\ {{
+            \\     [location(0)] color: vec4[{s}]
+            \\ }}
             \\
             \\ [entry(frag)]
             \\ fn main() -> FragOut
-        \\ {
-        \\     let ratio = vec4[f32](2.0, 2.0, 8.0, 0.25);
+            \\ {{
+            \\     let ratio = vec4[{s}]({d}, {d}, {d}, {d});
             \\
             \\     let output: FragOut;
-        \\     output.color = vec4[f32](4.0, 3.0, 2.0, 1.0) * ratio;
+            \\     output.color = vec4[{s}]({d}, {d}, {d}, {d}) * ratio;
             \\     return output;
-        \\ }
-    ;
+            \\ }}
+        ,
+            @typeName(T),
+            @typeName(T),
+            ratio[0],
+            ratio[1],
+            ratio[2],
+            ratio[3],
+            @typeName(T),
+            base_color[0],
+            base_color[1],
+            base_color[2],
+            base_color[3],
+        );
         const code = try compileNzsl(allocator, shader);
         defer allocator.free(code);
 
-    try case.expectOutput(f32, code, "color", &.{ 8, 6, 16, 0.25 });
+        try case.expectOutput(f32, code, "color", &expected);
     }
-
-test "IMul vec4[i32]" {
-    const allocator = std.testing.allocator;
-    const shader =
-        \\ [nzsl_version("1.1")]
-        \\ module;
-        \\ 
-        \\ struct FragOut
-        \\ {
-        \\     [location(0)] color: vec4[i32]
-        \\ }
-        \\
-        \\ [entry(frag)]
-        \\ fn main() -> FragOut
-        \\ {
-        \\     let ratio = vec4[i32](2, 2, 8, 25);
-        \\
-        \\     let output: FragOut;
-        \\     output.color = vec4[i32](4, 3, 2, 1) * ratio;
-        \\     return output;
-        \\ }
-    ;
-    const code = try compileNzsl(allocator, shader);
-    defer allocator.free(code);
-
-    try case.expectOutput(i32, code, "color", &.{ 8, 6, 16, 25 });
 }