1 files changed, 351 insertions, 0 deletions
diff --git a/dom/webgpu/tests/cts/checkout/src/unittests/test_group.spec.ts b/dom/webgpu/tests/cts/checkout/src/unittests/test_group.spec.ts
new file mode 100644
index 0000000000..cc6dce72fb
--- /dev/null
+++ b/dom/webgpu/tests/cts/checkout/src/unittests/test_group.spec.ts
@@ -0,0 +1,351 @@
+export const description = `
+Unit tests for TestGroup.
+`;
+
+import { Fixture } from '../common/framework/fixture.js';
+import { makeTestGroup } from '../common/framework/test_group.js';
+import { makeTestGroupForUnitTesting } from '../common/internal/test_group.js';
+import { assert } from '../common/util/util.js';
+
+import { TestGroupTest } from './test_group_test.js';
+import { UnitTest } from './unit_test.js';
+
+export const g = makeTestGroup(TestGroupTest);
+
+g.test('UnitTest_fixture').fn(async t0 => {
+  let seen = 0;
+  function count(t: Fixture): void {
+    seen++;
+  }
+
+  const g = makeTestGroupForUnitTesting(UnitTest);
+
+  g.test('test').fn(count);
+  g.test('testp')
+    .paramsSimple([{ a: 1 }])
+    .fn(count);
+
+  await t0.run(g);
+  t0.expect(seen === 2);
+});
+
+g.test('custom_fixture').fn(async t0 => {
+  let seen = 0;
+  class Counter extends UnitTest {
+    count(): void {
+      seen++;
+    }
+  }
+
+  const g = makeTestGroupForUnitTesting(Counter);
+
+  g.test('test').fn(t => {
+    t.count();
+  });
+  g.test('testp')
+    .paramsSimple([{ a: 1 }])
+    .fn(t => {
+      t.count();
+    });
+
+  await t0.run(g);
+  t0.expect(seen === 2);
+});
+
+g.test('stack').fn(async t0 => {
+  const g = makeTestGroupForUnitTesting(UnitTest);
+
+  const doNestedThrow1 = () => {
+    throw new Error('goodbye');
+  };
+
+  const doNestedThrow2 = () => doNestedThrow1();
+
+  g.test('fail').fn(t => {
+    t.fail();
+  });
+  g.test('throw').fn(t => {
+    throw new Error('hello');
+  });
+  g.test('throw_nested').fn(t => {
+    doNestedThrow2();
+  });
+
+  const res = await t0.run(g);
+
+  const search = /unittests[/\\]test_group\.spec\.[tj]s/;
+  t0.expect(res.size > 0);
+  for (const { logs } of res.values()) {
+    assert(logs !== undefined, 'expected logs');
+    t0.expect(logs.some(l => search.test(l.toJSON())));
+    t0.expect(search.test(logs[logs.length - 1].toJSON()));
+  }
+});
+
+g.test('no_fn').fn(t => {
+  const g = makeTestGroupForUnitTesting(UnitTest);
+
+  g.test('missing');
+
+  t.shouldThrow('Error', () => {
+    g.validate();
+  });
+});
+
+g.test('duplicate_test_name').fn(t => {
+  const g = makeTestGroupForUnitTesting(UnitTest);
+  g.test('abc').fn(() => {});
+
+  t.shouldThrow('Error', () => {
+    g.test('abc').fn(() => {});
+  });
+});
+
+g.test('duplicate_test_params,none').fn(() => {
+  {
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    g.test('abc')
+      .paramsSimple([])
+      .fn(() => {});
+    g.validate();
+  }
+
+  {
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    g.test('abc').fn(() => {});
+    g.validate();
+  }
+
+  {
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    g.test('abc')
+      .paramsSimple([
+        { a: 1 }, //
+      ])
+      .fn(() => {});
+    g.validate();
+  }
+});
+
+g.test('duplicate_test_params,basic').fn(t => {
+  {
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    const builder = g.test('abc');
+    t.shouldThrow('Error', () => {
+      builder.paramsSimple([
+        { a: 1 }, //
+        { a: 1 },
+      ]);
+      g.validate();
+    });
+  }
+  {
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    g.test('abc')
+      .params(u =>
+        u.expandWithParams(() => [
+          { a: 1 }, //
+          { a: 1 },
+        ])
+      )
+      .fn(() => {});
+    t.shouldThrow('Error', () => {
+      g.validate();
+    });
+  }
+  {
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    g.test('abc')
+      .paramsSimple([
+        { a: 1, b: 3 }, //
+        { b: 3, a: 1 },
+      ])
+      .fn(() => {});
+    t.shouldThrow('Error', () => {
+      g.validate();
+    });
+  }
+});
+
+g.test('duplicate_test_params,with_different_private_params').fn(t => {
+  {
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    const builder = g.test('abc');
+    t.shouldThrow('Error', () => {
+      builder.paramsSimple([
+        { a: 1, _b: 1 }, //
+        { a: 1, _b: 2 },
+      ]);
+    });
+  }
+  {
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    g.test('abc')
+      .params(u =>
+        u.expandWithParams(() => [
+          { a: 1, _b: 1 }, //
+          { a: 1, _b: 2 },
+        ])
+      )
+      .fn(() => {});
+    t.shouldThrow('Error', () => {
+      g.validate();
+    });
+  }
+});
+
+g.test('invalid_test_name').fn(t => {
+  const g = makeTestGroupForUnitTesting(UnitTest);
+
+  const badChars = Array.from('"`~@#$+=\\|!^&*[]<>{}-\'. ');
+  for (const char of badChars) {
+    const name = 'a' + char + 'b';
+    t.shouldThrow(
+      'Error',
+      () => {
+        g.test(name).fn(() => {});
+      },
+      name
+    );
+  }
+});
+
+g.test('param_value,valid').fn(() => {
+  const g = makeTestGroup(UnitTest);
+  g.test('a').paramsSimple([{ x: JSON.stringify({ a: 1, b: 2 }) }]);
+});
+
+g.test('param_value,invalid').fn(t => {
+  for (const badChar of ';=*') {
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    const builder = g.test('a');
+    t.shouldThrow('Error', () => {
+      builder.paramsSimple([{ badChar }]);
+    });
+  }
+});
+
+g.test('subcases').fn(async t0 => {
+  const g = makeTestGroupForUnitTesting(UnitTest);
+  g.test('a')
+    .paramsSubcasesOnly(u =>
+      u //
+        .combineWithParams([{ a: 1 }])
+    )
+    .fn(t => {
+      t.expect(t.params.a === 1, 'a must be 1');
+    });
+
+  function* gen({ a, b }: { a?: number; b?: number }) {
+    if (b === 2) {
+      yield { ret: 2 };
+    } else if (a === 1) {
+      yield { ret: 1 };
+    } else {
+      yield { ret: -1 };
+    }
+  }
+  g.test('b')
+    .params(u =>
+      u
+        .combineWithParams([{ a: 1 }, { b: 2 }])
+        .beginSubcases()
+        .expandWithParams(gen)
+    )
+    .fn(t => {
+      const { a, b, ret } = t.params;
+      t.expect((a === 1 && ret === 1) || (b === 2 && ret === 2));
+    });
+
+  const result = await t0.run(g);
+  t0.expect(Array.from(result.values()).every(v => v.status === 'pass'));
+});
+
+g.test('exceptions')
+  .params(u =>
+    u
+      .combine('useSubcases', [false, true]) //
+      .combine('useDOMException', [false, true])
+  )
+  .fn(async t0 => {
+    const { useSubcases, useDOMException } = t0.params;
+    const g = makeTestGroupForUnitTesting(UnitTest);
+
+    const b1 = g.test('a');
+    let b2;
+    if (useSubcases) {
+      b2 = b1.paramsSubcasesOnly(u => u);
+    } else {
+      b2 = b1.params(u => u);
+    }
+    b2.fn(t => {
+      if (useDOMException) {
+        throw new DOMException('Message!', 'Name!');
+      } else {
+        throw new Error('Message!');
+      }
+    });
+
+    const result = await t0.run(g);
+    const values = Array.from(result.values());
+    t0.expect(values.length === 1);
+    t0.expect(values[0].status === 'fail');
+  });
+
+g.test('throws').fn(async t0 => {
+  const g = makeTestGroupForUnitTesting(UnitTest);
+
+  g.test('a').fn(t => {
+    throw new Error();
+  });
+
+  const result = await t0.run(g);
+  const values = Array.from(result.values());
+  t0.expect(values.length === 1);
+  t0.expect(values[0].status === 'fail');
+});
+
+g.test('shouldThrow').fn(async t0 => {
+  t0.shouldThrow('TypeError', () => {
+    throw new TypeError();
+  });
+
+  const g = makeTestGroupForUnitTesting(UnitTest);
+
+  g.test('a').fn(t => {
+    t.shouldThrow('Error', () => {
+      throw new TypeError();
+    });
+  });
+
+  const result = await t0.run(g);
+  const values = Array.from(result.values());
+  t0.expect(values.length === 1);
+  t0.expect(values[0].status === 'fail');
+});
+
+g.test('shouldReject').fn(async t0 => {
+  t0.shouldReject(
+    'TypeError',
+    (async () => {
+      throw new TypeError();
+    })()
+  );
+
+  const g = makeTestGroupForUnitTesting(UnitTest);
+
+  g.test('a').fn(async t => {
+    t.shouldReject(
+      'Error',
+      (async () => {
+        throw new TypeError();
+      })()
+    );
+  });
+
+  const result = await t0.run(g);
+  // Fails even though shouldReject doesn't fail until after the test function ends
+  const values = Array.from(result.values());
+  t0.expect(values.length === 1);
+  t0.expect(values[0].status === 'fail');
+});