wgsl-test 0.2.5 → 0.2.6

package/src/WebGPUTestSetup.ts

@@ -1,30 +1,45 @@
-import * as webgpu from "webgpu";
+export const isDeno = !!(globalThis as any).Deno;
 
 let sharedGpu: GPU | undefined;
+let sharedAdapter: GPUAdapter | undefined;
 let sharedDevice: GPUDevice | undefined;
 
 /** get or create shared GPU device for testing */
 export async function getGPUDevice(): Promise<GPUDevice> {
   if (!sharedDevice) {
-    const gpu = await setupWebGPU();
-    const adapter = await gpu.requestAdapter();
-    if (!adapter) throw new Error("Failed to get GPU adapter");
+    const adapter = await getGPUAdapter();
     sharedDevice = await adapter.requestDevice();
   }
   return sharedDevice;
 }
 
+/** get or create shared GPU object for testing */
+export async function getGPU(): Promise<GPU> {
+  if (!sharedGpu) {
+    if (isDeno) {
+      sharedGpu = navigator.gpu;
+    } else {
+      const webgpu = await import("webgpu");
+      Object.assign(globalThis, webgpu.globals);
+      sharedGpu = webgpu.create([]);
+    }
+  }
+  return sharedGpu;
+}
+
+/** get or create shared GPU adapter for testing */
+export async function getGPUAdapter(): Promise<GPUAdapter> {
+  if (!sharedAdapter) {
+    const gpu = await getGPU();
+    const adapter = await gpu.requestAdapter();
+    if (!adapter) throw new Error("Failed to get GPU adapter");
+    sharedAdapter = adapter;
+  }
+  return sharedAdapter;
+}
+
 /** destroy globally shared GPU test device */
 export function destroySharedDevice(): void {
   sharedDevice?.destroy();
   sharedDevice = undefined;
 }
-
-/** initialize WebGPU for testing */
-async function setupWebGPU(): Promise<GPU> {
-  if (!sharedGpu) {
-    Object.assign(globalThis, webgpu.globals);
-    sharedGpu = webgpu.create([]);
-  }
-  return sharedGpu;
-}

package/src/index.ts

@@ -26,7 +26,10 @@ export * from "./CompileShader.ts";
 export * from "./ExampleImages.ts";
 export * from "./ImageHelpers.ts";
 export * from "./TestComputeShader.ts";
+export * from "./TestDiscovery.ts";
 export * from "./TestFragmentShader.ts";
+export * from "./TestVirtualLib.ts";
+export * from "./TestWesl.ts";
 export * from "./WebGPUTestSetup.ts";
 
 // Re-export module augmentation from vitest-image-snapshot for packaged builds

package/src/test/BackendCheck.test.ts

@@ -0,0 +1,12 @@
+import { expect, test } from "vitest";
+import { getGPUDevice, isDeno } from "../WebGPUTestSetup.ts";
+
+test("check WebGPU backend", async () => {
+  const device = await getGPUDevice();
+  expect(device).toBeTruthy();
+
+  console.log(
+    "==> Backend:",
+    isDeno ? "wgpu (Deno native)" : "Dawn (Node webgpu package)",
+  );
+});

package/src/test/TestDiscovery.test.ts

@@ -0,0 +1,77 @@
+import { expect, test } from "vitest";
+import { parseSrcModule } from "wesl";
+import { findTestFunctions } from "../TestDiscovery.ts";
+
+function parse(src: string) {
+  return parseSrcModule({
+    modulePath: "test",
+    debugFilePath: "test.wesl",
+    src,
+  });
+}
+
+test("finds single @test function", () => {
+  const ast = parse(`
+    @test fn myTest() { }
+  `);
+  const tests = findTestFunctions(ast);
+  expect(tests).toHaveLength(1);
+  expect(tests[0].name).toBe("myTest");
+});
+
+test("finds multiple @test functions", () => {
+  const ast = parse(`
+    @test fn testOne() { }
+    fn helper() { }
+    @test fn testTwo() { }
+  `);
+  const tests = findTestFunctions(ast);
+  expect(tests).toHaveLength(2);
+  expect(tests.map(t => t.name)).toEqual(["testOne", "testTwo"]);
+});
+
+test("ignores non-test functions", () => {
+  const ast = parse(`
+    fn notATest() { }
+    @compute @workgroup_size(1) fn compute() { }
+  `);
+  const tests = findTestFunctions(ast);
+  expect(tests).toHaveLength(0);
+});
+
+test("preserves FnElem for access to returnType", () => {
+  const ast = parse(`
+    @test fn returnsFloat() -> f32 { return 1.0; }
+  `);
+  const tests = findTestFunctions(ast);
+  expect(tests).toHaveLength(1);
+  expect(tests[0].fn.returnType).toBeDefined();
+});
+
+test("handles @test with other attributes", () => {
+  const ast = parse(`
+    @test @must_use fn withMustUse() -> bool { return true; }
+  `);
+  const tests = findTestFunctions(ast);
+  expect(tests).toHaveLength(1);
+  expect(tests[0].name).toBe("withMustUse");
+});
+
+test("extracts description from @test(description)", () => {
+  const ast = parse(`
+    @test(pythagorean_triple) fn lengthSq3() { }
+  `);
+  const tests = findTestFunctions(ast);
+  expect(tests).toHaveLength(1);
+  expect(tests[0].name).toBe("lengthSq3");
+  expect(tests[0].description).toBe("pythagorean_triple");
+});
+
+test("description is undefined for plain @test", () => {
+  const ast = parse(`
+    @test fn simpleTest() { }
+  `);
+  const tests = findTestFunctions(ast);
+  expect(tests).toHaveLength(1);
+  expect(tests[0].description).toBeUndefined();
+});

package/src/test/TestWesl.test.ts

@@ -0,0 +1,111 @@
+import { readFileSync } from "node:fs";
+import { afterAll, beforeAll, expect, test } from "vitest";
+import { expectWesl, runWesl } from "../TestWesl.ts";
+import { destroySharedDevice, getGPUDevice } from "../WebGPUTestSetup.ts";
+
+let device: GPUDevice;
+const fixturesDir = new URL(
+  "./fixtures/wesl_test_pkg/shaders/",
+  import.meta.url,
+);
+
+function loadFixture(name: string): string {
+  return readFileSync(new URL(name, fixturesDir), "utf-8");
+}
+
+beforeAll(async () => {
+  device = await getGPUDevice();
+});
+
+afterAll(() => {
+  destroySharedDevice();
+});
+
+test("passing test with expect()", async () => {
+  const src = loadFixture("passing_expect.wesl");
+  const results = await runWesl({ device, src });
+  expect(results).toHaveLength(1);
+  expect(results[0].name).toBe("checkTrue");
+  expect(results[0].passed).toBe(true);
+});
+
+test("failing test with expect()", async () => {
+  const src = loadFixture("failing_expect.wesl");
+  const results = await runWesl({ device, src });
+  expect(results).toHaveLength(1);
+  expect(results[0].passed).toBe(false);
+});
+
+test("passing test with expectNear()", async () => {
+  const src = loadFixture("passing_near.wesl");
+  const results = await runWesl({ device, src });
+  expect(results).toHaveLength(1);
+  expect(results[0].passed).toBe(true);
+});
+
+test("failing test with expectNear() reports actual and expected", async () => {
+  const src = loadFixture("failing_near.wesl");
+  const results = await runWesl({ device, src });
+  expect(results).toHaveLength(1);
+  expect(results[0].passed).toBe(false);
+  expect(results[0].actual?.[0]).toBeCloseTo(1.0);
+  expect(results[0].expected?.[0]).toBeCloseTo(2.0);
+});
+
+test("multiple @test functions in one module", async () => {
+  const src = loadFixture("multiple_tests.wesl");
+  const results = await runWesl({ device, src });
+  expect(results).toHaveLength(3);
+  expect(results[0].name).toBe("first");
+  expect(results[0].passed).toBe(true);
+  expect(results[1].name).toBe("second");
+  expect(results[1].passed).toBe(false);
+  expect(results[2].name).toBe("third");
+  expect(results[2].passed).toBe(true);
+});
+
+test("no @test functions returns empty array", async () => {
+  const src = loadFixture("no_tests.wesl");
+  const results = await runWesl({ device, src });
+  expect(results).toHaveLength(0);
+});
+
+test("expectEq passes for equal values", async () => {
+  const src = loadFixture("expect_eq.wesl");
+  const results = await runWesl({ device, src });
+  const equalResult = results.find(r => r.name === "equalInts");
+  expect(equalResult?.passed).toBe(true);
+});
+
+test("expectEq fails for different values", async () => {
+  const src = loadFixture("expect_eq.wesl");
+  const results = await runWesl({ device, src });
+  const unequalResult = results.find(r => r.name === "unequalInts");
+  expect(unequalResult?.passed).toBe(false);
+});
+
+test("expectWesl passes when all tests pass", async () => {
+  const src = loadFixture("passing_expect.wesl");
+  await expectWesl({ device, src }); // should not throw
+});
+
+test("expectWesl throws on failure with details", async () => {
+  const src = loadFixture("failing_near.wesl");
+  await expect(expectWesl({ device, src })).rejects.toThrow(
+    "WESL tests failed",
+  );
+});
+
+test("passing test with expectUlp()", async () => {
+  const src = loadFixture("passing_ulp.wesl");
+  const results = await runWesl({ device, src });
+  expect(results).toHaveLength(2);
+  expect(results.every(r => r.passed)).toBe(true);
+});
+
+test("failing test with expectUlp()", async () => {
+  const src = loadFixture("failing_ulp.wesl");
+  const results = await runWesl({ device, src });
+  expect(results).toHaveLength(1);
+  expect(results[0].passed).toBe(false);
+});

package/src/test/fixtures/wesl_test_pkg/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "wesl_test_pkg",
+  "private": true
+}

package/src/test/fixtures/wesl_test_pkg/shaders/expect_eq.wesl

@@ -0,0 +1,9 @@
+import wgsl_test::expectEq;
+
+@test fn equalInts() {
+  expectEq(42u, 42u);
+}
+
+@test fn unequalInts() {
+  expectEq(42u, 99u);
+}

package/src/test/fixtures/wesl_test_pkg/shaders/failing_expect.wesl

@@ -0,0 +1,5 @@
+import wgsl_test::expect;
+
+@test fn checkFalse() {
+  expect(false);
+}

package/src/test/fixtures/wesl_test_pkg/shaders/failing_near.wesl

@@ -0,0 +1,5 @@
+import wgsl_test::expectNear;
+
+@test fn notClose() {
+  expectNear(1.0, 2.0);
+}

package/src/test/fixtures/wesl_test_pkg/shaders/failing_ulp.wesl

@@ -0,0 +1,8 @@
+import wgsl_test::expectUlp;
+
+@test fn tooFar() {
+  // 1.0 and 1.0 + 3 ULP should fail with maxUlp=1
+  let a = 1.0;
+  let b = bitcast<f32>(bitcast<u32>(a) + 3u);
+  expectUlp(a, b, 1u);
+}

package/src/test/fixtures/wesl_test_pkg/shaders/multiple_tests.wesl

@@ -0,0 +1,7 @@
+import wgsl_test::expect;
+
+@test fn first() { expect(true); }
+
+@test fn second() { expect(false); }
+
+@test fn third() { expect(true); }

package/src/test/fixtures/wesl_test_pkg/shaders/no_tests.wesl

@@ -0,0 +1 @@
+fn helper() -> f32 { return 1.0; }

package/src/test/fixtures/wesl_test_pkg/shaders/passing_expect.wesl

@@ -0,0 +1,5 @@
+import wgsl_test::expect;
+
+@test fn checkTrue() {
+  expect(true);
+}

package/src/test/fixtures/wesl_test_pkg/shaders/passing_near.wesl

@@ -0,0 +1,5 @@
+import wgsl_test::expectNear;
+
+@test fn closeEnough() {
+  expectNear(1.0, 1.0005);  // within relTol=1e-3
+}

package/src/test/fixtures/wesl_test_pkg/shaders/passing_ulp.wesl

@@ -0,0 +1,12 @@
+import wgsl_test::expectUlp;
+
+@test fn withinOneUlp() {
+  // 1.0 and the next representable float differ by 1 ULP
+  let a = 1.0;
+  let b = bitcast<f32>(bitcast<u32>(a) + 1u);  // next float after 1.0
+  expectUlp(a, b, 1u);
+}
+
+@test fn exactMatch() {
+  expectUlp(42.0, 42.0, 0u);
+}

package/src/test/fixtures/wesl_test_pkg/wesl.toml

@@ -0,0 +1,3 @@
+include = ["shaders/**/*.wesl"]
+root = "shaders"
+dependencies = []

package/src/test_lib.wesl

@@ -0,0 +1,89 @@
+// Test assertion library for @test functions
+
+const relTol: f32 = 1e-3;
+const absTol: f32 = 1e-6;
+
+struct TestResult {
+  passed: u32,
+  failCount: u32,
+  actual: vec4f,
+  expected: vec4f,
+}
+
+@group(0) @binding(0) var<storage, read_write> testResult: TestResult;
+
+fn expect(condition: bool) {
+  if (!condition && testResult.failCount == 0u) {
+    testResult.passed = 0u;
+    testResult.failCount = 1u;
+  }
+}
+
+fn expectEq(actual: u32, expected: u32) {
+  testResult.actual = vec4f(f32(actual), 0.0, 0.0, 0.0);
+  testResult.expected = vec4f(f32(expected), 0.0, 0.0, 0.0);
+  if (actual != expected && testResult.failCount == 0u) {
+    testResult.passed = 0u;
+    testResult.failCount = 1u;
+  }
+}
+
+fn expectWithin(actual: f32, expected: f32, relTol: f32, absTol: f32) {
+  testResult.actual = vec4f(actual, 0.0, 0.0, 0.0);
+  testResult.expected = vec4f(expected, 0.0, 0.0, 0.0);
+  let diff = abs(actual - expected);
+  let tolerance = max(absTol, relTol * max(abs(actual), abs(expected)));
+  if (diff > tolerance && testResult.failCount == 0u) {
+    testResult.passed = 0u;
+    testResult.failCount = 1u;
+  }
+}
+
+fn expectNear(actual: f32, expected: f32) {
+  expectWithin(actual, expected, relTol, absTol);
+}
+
+fn expectWithinVec2(actual: vec2f, expected: vec2f, relTol: f32, absTol: f32) {
+  testResult.actual = vec4f(actual, 0.0, 0.0);
+  testResult.expected = vec4f(expected, 0.0, 0.0);
+  let diff = abs(actual - expected);
+  let tolerance = max(vec2f(absTol), relTol * max(abs(actual), abs(expected)));
+  if (any(diff > tolerance) && testResult.failCount == 0u) {
+    testResult.passed = 0u;
+    testResult.failCount = 1u;
+  }
+}
+
+fn expectNearVec2(actual: vec2f, expected: vec2f) {
+  expectWithinVec2(actual, expected, relTol, absTol);
+}
+
+fn expectWithinVec3(actual: vec3f, expected: vec3f, relTol: f32, absTol: f32) {
+  testResult.actual = vec4f(actual, 0.0);
+  testResult.expected = vec4f(expected, 0.0);
+  let diff = abs(actual - expected);
+  let tolerance = max(vec3f(absTol), relTol * max(abs(actual), abs(expected)));
+  if (any(diff > tolerance) && testResult.failCount == 0u) {
+    testResult.passed = 0u;
+    testResult.failCount = 1u;
+  }
+}
+
+fn expectNearVec3(actual: vec3f, expected: vec3f) {
+  expectWithinVec3(actual, expected, relTol, absTol);
+}
+
+fn expectWithinVec4(actual: vec4f, expected: vec4f, relTol: f32, absTol: f32) {
+  testResult.actual = actual;
+  testResult.expected = expected;
+  let diff = abs(actual - expected);
+  let tolerance = max(vec4f(absTol), relTol * max(abs(actual), abs(expected)));
+  if (any(diff > tolerance) && testResult.failCount == 0u) {
+    testResult.passed = 0u;
+    testResult.failCount = 1u;
+  }
+}
+
+fn expectNearVec4(actual: vec4f, expected: vec4f) {
+  expectWithinVec4(actual, expected, relTol, absTol);
+}