;
-
- /**
- * Parameterize the test, generating multiple cases, without subcases.
- */
- paramsSimple(cases: Iterable
): TestBuilderWithParams;
-
- /**
- * Parameterize the test, generating one case with multiple subcases.
- */
- paramsSubcasesOnly(subcases: Iterable
): TestBuilderWithParams;
- /**
- * Parameterize the test, generating one case with multiple subcases.
- *
- * The `unit` value passed to the `subcases` callback is an immutable constant
- * `SubcaseParamsBuilder<{}>`, with one empty case `{}` and one empty subcase `{}`.
- */
- paramsSubcasesOnly(
- subcases: (unit: SubcaseParamsBuilder<{}, {}>) => SubcaseParamsBuilder<{}, P>
- ): TestBuilderWithParams;
-}
-
-interface TestBuilderWithParams<
- S extends SubcaseBatchState,
- F extends Fixture,
- CaseP extends {},
- SubcaseP extends {}
-> {
- /**
- * Limit subcases to a maximum number of per testcase.
- * @param b the maximum number of subcases per testcase.
- *
- * If the number of subcases exceeds `b`, add an internal
- * numeric, incrementing `batch__` param to split subcases
- * into groups of at most `b` subcases.
- */
- batch(b: number): this;
- /**
- * Run a function on shared subcase batch state before each
- * batch of subcases.
- * @param fn the function to run. It is called with the test
- * fixture's shared subcase batch state.
- *
- * Generally, this function should be careful to avoid mutating
- * any state on the shared subcase batch state which could result
- * in unexpected order-dependent test behavior.
- */
- beforeAllSubcases(fn: BeforeAllSubcasesFn): this;
- /**
- * Set the test function.
- * @param fn the test function.
- */
- fn(fn: TestFn>): void;
- /**
- * Mark the test as unimplemented.
- */
- unimplemented(): void;
-}
-
-class TestBuilder {
- readonly testPath: string[];
- isUnimplemented: boolean;
- description: string | undefined;
- readonly testCreationStack: Error;
-
- private readonly fixture: FixtureClass;
- private testFn: TestFn | undefined;
- private beforeFn: BeforeAllSubcasesFn | undefined;
- private testCases?: ParamsBuilderBase<{}, {}> = undefined;
- private batchSize: number = 0;
-
- constructor(testPath: string[], fixture: FixtureClass, testCreationStack: Error) {
- this.testPath = testPath;
- this.isUnimplemented = false;
- this.fixture = fixture;
- this.testCreationStack = testCreationStack;
- }
-
- desc(description: string): this {
- this.description = description.trim();
- return this;
- }
-
- specURL(url: string): this {
- return this;
- }
-
- beforeAllSubcases(fn: BeforeAllSubcasesFn): this {
- assert(this.beforeFn === undefined);
- this.beforeFn = fn;
- return this;
- }
-
- fn(fn: TestFn): void {
- // eslint-disable-next-line no-warning-comments
- // MAINTENANCE_TODO: add "TODO" if there's no description? (and make sure it only ends up on
- // actual tests, not on test parents in the tree, which is what happens if you do it here, not
- // sure why)
- assert(this.testFn === undefined);
- this.testFn = fn;
- }
-
- batch(b: number): this {
- this.batchSize = b;
- return this;
- }
-
- unimplemented(): void {
- assert(this.testFn === undefined);
-
- this.description =
- (this.description ? this.description + '\n\n' : '') + 'TODO: .unimplemented()';
- this.isUnimplemented = true;
-
- this.testFn = () => {
- throw new SkipTestCase('test unimplemented');
- };
- }
-
- validate(): void {
- const testPathString = this.testPath.join(kPathSeparator);
- assert(this.testFn !== undefined, () => {
- let s = `Test is missing .fn(): ${testPathString}`;
- if (this.testCreationStack.stack) {
- s += `\n-> test created at:\n${this.testCreationStack.stack}`;
- }
- return s;
- });
-
- if (this.testCases === undefined) {
- return;
- }
-
- const seen = new Set();
- for (const [caseParams, subcases] of builderIterateCasesWithSubcases(this.testCases)) {
- for (const subcaseParams of subcases ?? [{}]) {
- const params = mergeParams(caseParams, subcaseParams);
- assert(this.batchSize === 0 || !('batch__' in params));
-
- // stringifyPublicParams also checks for invalid params values
- const testcaseString = stringifyPublicParams(params);
-
- // A (hopefully) unique representation of a params value.
- const testcaseStringUnique = stringifyPublicParamsUniquely(params);
- assert(
- !seen.has(testcaseStringUnique),
- `Duplicate public test case params for test ${testPathString}: ${testcaseString}`
- );
- seen.add(testcaseStringUnique);
- }
- }
- }
-
- params(
- cases: ((unit: CaseParamsBuilder<{}>) => ParamsBuilderBase<{}, {}>) | ParamsBuilderBase<{}, {}>
- ): TestBuilder {
- assert(this.testCases === undefined, 'test case is already parameterized');
- if (cases instanceof Function) {
- this.testCases = cases(kUnitCaseParamsBuilder);
- } else {
- this.testCases = cases;
- }
- return this;
- }
-
- paramsSimple(cases: Iterable<{}>): TestBuilder {
- assert(this.testCases === undefined, 'test case is already parameterized');
- this.testCases = kUnitCaseParamsBuilder.combineWithParams(cases);
- return this;
- }
-
- paramsSubcasesOnly(
- subcases: Iterable<{}> | ((unit: SubcaseParamsBuilder<{}, {}>) => SubcaseParamsBuilder<{}, {}>)
- ): TestBuilder {
- if (subcases instanceof Function) {
- return this.params(subcases(kUnitCaseParamsBuilder.beginSubcases()));
- } else {
- return this.params(kUnitCaseParamsBuilder.beginSubcases().combineWithParams(subcases));
- }
- }
-
- *iterate(): IterableIterator {
- assert(this.testFn !== undefined, 'No test function (.fn()) for test');
- this.testCases ??= kUnitCaseParamsBuilder;
- for (const [caseParams, subcases] of builderIterateCasesWithSubcases(this.testCases)) {
- if (this.batchSize === 0 || subcases === undefined) {
- yield new RunCaseSpecific(
- this.testPath,
- caseParams,
- this.isUnimplemented,
- subcases,
- this.fixture,
- this.testFn,
- this.beforeFn,
- this.testCreationStack
- );
- } else {
- const subcaseArray = Array.from(subcases);
- if (subcaseArray.length <= this.batchSize) {
- yield new RunCaseSpecific(
- this.testPath,
- caseParams,
- this.isUnimplemented,
- subcaseArray,
- this.fixture,
- this.testFn,
- this.beforeFn,
- this.testCreationStack
- );
- } else {
- for (let i = 0; i < subcaseArray.length; i = i + this.batchSize) {
- yield new RunCaseSpecific(
- this.testPath,
- { ...caseParams, batch__: i / this.batchSize },
- this.isUnimplemented,
- subcaseArray.slice(i, Math.min(subcaseArray.length, i + this.batchSize)),
- this.fixture,
- this.testFn,
- this.beforeFn,
- this.testCreationStack
- );
- }
- }
- }
- }
- }
-}
-
-class RunCaseSpecific implements RunCase {
- readonly id: TestCaseID;
- readonly isUnimplemented: boolean;
-
- private readonly params: {};
- private readonly subcases: Iterable<{}> | undefined;
- private readonly fixture: FixtureClass;
- private readonly fn: TestFn;
- private readonly beforeFn?: BeforeAllSubcasesFn;
- private readonly testCreationStack: Error;
-
- constructor(
- testPath: string[],
- params: {},
- isUnimplemented: boolean,
- subcases: Iterable<{}> | undefined,
- fixture: FixtureClass,
- fn: TestFn,
- beforeFn: BeforeAllSubcasesFn | undefined,
- testCreationStack: Error
- ) {
- this.id = { test: testPath, params: extractPublicParams(params) };
- this.isUnimplemented = isUnimplemented;
- this.params = params;
- this.subcases = subcases;
- this.fixture = fixture;
- this.fn = fn;
- this.beforeFn = beforeFn;
- this.testCreationStack = testCreationStack;
- }
-
- async runTest(
- rec: TestCaseRecorder,
- sharedState: SubcaseBatchState,
- params: TestParams,
- throwSkip: boolean,
- expectedStatus: Expectation
- ): Promise {
- try {
- rec.beginSubCase();
- if (expectedStatus === 'skip') {
- throw new SkipTestCase('Skipped by expectations');
- }
-
- const inst = new this.fixture(sharedState, rec, params);
- try {
- await inst.init();
- await this.fn(inst as Fixture & { params: {} });
- } finally {
- // Runs as long as constructor succeeded, even if initialization or the test failed.
- await inst.finalize();
- }
- } catch (ex) {
- // There was an exception from constructor, init, test, or finalize.
- // An error from init or test may have been a SkipTestCase.
- // An error from finalize may have been an eventualAsyncExpectation failure
- // or unexpected validation/OOM error from the GPUDevice.
- if (throwSkip && ex instanceof SkipTestCase) {
- throw ex;
- }
- rec.threw(ex);
- } finally {
- try {
- rec.endSubCase(expectedStatus);
- } catch (ex) {
- assert(ex instanceof UnexpectedPassError);
- ex.message = `Testcase passed unexpectedly.`;
- ex.stack = this.testCreationStack.stack;
- rec.warn(ex);
- }
- }
- }
-
- async run(
- rec: TestCaseRecorder,
- selfQuery: TestQuerySingleCase,
- expectations: TestQueryWithExpectation[]
- ): Promise {
- const getExpectedStatus = (selfQueryWithSubParams: TestQuerySingleCase) => {
- let didSeeFail = false;
- for (const exp of expectations) {
- const ordering = compareQueries(exp.query, selfQueryWithSubParams);
- if (ordering === Ordering.Unordered || ordering === Ordering.StrictSubset) {
- continue;
- }
-
- switch (exp.expectation) {
- // Skip takes precedence. If there is any expectation indicating a skip,
- // signal it immediately.
- case 'skip':
- return 'skip';
- case 'fail':
- // Otherwise, indicate that we might expect a failure.
- didSeeFail = true;
- break;
- default:
- unreachable();
- }
- }
- return didSeeFail ? 'fail' : 'pass';
- };
-
- const { testHeartbeatCallback, maxSubcasesInFlight } = globalTestConfig;
- try {
- rec.start();
- const sharedState = this.fixture.MakeSharedState(this.params);
- try {
- await sharedState.init();
- if (this.beforeFn) {
- await this.beforeFn(sharedState);
- }
- await sharedState.postInit();
- testHeartbeatCallback();
-
- let allPreviousSubcasesFinalizedPromise: Promise = Promise.resolve();
- if (this.subcases) {
- let totalCount = 0;
- let skipCount = 0;
-
- // If there are too many subcases in flight, starting the next subcase will register
- // `resolvePromiseBlockingSubcase` and wait until `subcaseFinishedCallback` is called.
- let subcasesInFlight = 0;
- let resolvePromiseBlockingSubcase: (() => void) | undefined = undefined;
- const subcaseFinishedCallback = () => {
- subcasesInFlight -= 1;
- // If there is any subcase waiting on a previous subcase to finish,
- // unblock it now, and clear the resolve callback.
- if (resolvePromiseBlockingSubcase) {
- resolvePromiseBlockingSubcase();
- resolvePromiseBlockingSubcase = undefined;
- }
- };
-
- for (const subParams of this.subcases) {
- // Make a recorder that will defer all calls until `allPreviousSubcasesFinalizedPromise`
- // resolves. Waiting on `allPreviousSubcasesFinalizedPromise` ensures that
- // logs from all the previous subcases have been flushed before flushing new logs.
- const subcasePrefix = 'subcase: ' + stringifyPublicParams(subParams);
- const subRec = new Proxy(rec, {
- get: (target, k: keyof TestCaseRecorder) => {
- const prop = TestCaseRecorder.prototype[k];
- if (typeof prop === 'function') {
- testHeartbeatCallback();
- return function (...args: Parameters) {
- void allPreviousSubcasesFinalizedPromise.then(() => {
- // Prepend the subcase name to all error messages.
- for (const arg of args) {
- if (arg instanceof Error) {
- try {
- arg.message = subcasePrefix + '\n' + arg.message;
- } catch {
- // If that fails (e.g. on DOMException), try to put it in the stack:
- let stack = subcasePrefix;
- if (arg.stack) stack += '\n' + arg.stack;
- try {
- arg.stack = stack;
- } catch {
- // If that fails too, just silence it.
- }
- }
- }
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- const rv = (prop as any).apply(target, args);
- // Because this proxy executes functions in a deferred manner,
- // it should never be used for functions that need to return a value.
- assert(rv === undefined);
- });
- };
- }
- return prop;
- },
- });
-
- const params = mergeParams(this.params, subParams);
- const subcaseQuery = new TestQuerySingleCase(
- selfQuery.suite,
- selfQuery.filePathParts,
- selfQuery.testPathParts,
- params
- );
-
- // Limit the maximum number of subcases in flight.
- if (subcasesInFlight >= maxSubcasesInFlight) {
- await new Promise(resolve => {
- // There should only be one subcase waiting at a time.
- assert(resolvePromiseBlockingSubcase === undefined);
- resolvePromiseBlockingSubcase = resolve;
- });
- }
-
- subcasesInFlight += 1;
- // Runs async without waiting so that subsequent subcases can start.
- // All finalization steps will be waited on at the end of the testcase.
- const finalizePromise = this.runTest(
- subRec,
- sharedState,
- params,
- /* throwSkip */ true,
- getExpectedStatus(subcaseQuery)
- )
- .then(() => {
- subRec.info(new Error('OK'));
- })
- .catch(ex => {
- if (ex instanceof SkipTestCase) {
- // Convert SkipTestCase to info messages
- ex.message = 'subcase skipped: ' + ex.message;
- subRec.info(ex);
- ++skipCount;
- } else {
- // Since we are catching all error inside runTest(), this should never happen
- subRec.threw(ex);
- }
- })
- .finally(subcaseFinishedCallback);
-
- allPreviousSubcasesFinalizedPromise = allPreviousSubcasesFinalizedPromise.then(
- () => finalizePromise
- );
- ++totalCount;
- }
-
- // Wait for all subcases to finalize and report their results.
- await allPreviousSubcasesFinalizedPromise;
-
- if (skipCount === totalCount) {
- rec.skipped(new SkipTestCase('all subcases were skipped'));
- }
- } else {
- await this.runTest(
- rec,
- sharedState,
- this.params,
- /* throwSkip */ false,
- getExpectedStatus(selfQuery)
- );
- }
- } finally {
- testHeartbeatCallback();
- // Runs as long as the shared state constructor succeeded, even if initialization or a test failed.
- await sharedState.finalize();
- testHeartbeatCallback();
- }
- } catch (ex) {
- // There was an exception from sharedState/fixture constructor, init, beforeFn, or test.
- // An error from beforeFn may have been SkipTestCase.
- // An error from finalize may have been an eventualAsyncExpectation failure
- // or unexpected validation/OOM error from the GPUDevice.
- rec.threw(ex);
- } finally {
- rec.finish();
- }
- }
-}
diff --git a/dom/webgpu/tests/cts/checkout/src/common/internal/test_suite_listing.ts b/dom/webgpu/tests/cts/checkout/src/common/internal/test_suite_listing.ts
deleted file mode 100644
index 2d2b555366e4..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/internal/test_suite_listing.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-// A listing of all specs within a single suite. This is the (awaited) type of
-// `groups` in '{cts,unittests}/listing.ts' and `listing` in the auto-generated
-// 'out/{cts,unittests}/listing.js' files (see tools/gen_listings).
-export type TestSuiteListing = TestSuiteListingEntry[];
-
-export type TestSuiteListingEntry = TestSuiteListingEntrySpec | TestSuiteListingEntryReadme;
-
-interface TestSuiteListingEntrySpec {
- readonly file: string[];
-}
-
-interface TestSuiteListingEntryReadme {
- readonly file: string[];
- readonly readme: string;
-}
diff --git a/dom/webgpu/tests/cts/checkout/src/common/internal/tree.ts b/dom/webgpu/tests/cts/checkout/src/common/internal/tree.ts
deleted file mode 100644
index 204a4f693a10..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/internal/tree.ts
+++ /dev/null
@@ -1,575 +0,0 @@
-import { RunCase, RunFn } from '../internal/test_group.js';
-import { assert } from '../util/util.js';
-
-import { TestFileLoader } from './file_loader.js';
-import { TestParamsRW } from './params_utils.js';
-import { compareQueries, Ordering } from './query/compare.js';
-import {
- TestQuery,
- TestQueryMultiCase,
- TestQuerySingleCase,
- TestQueryMultiFile,
- TestQueryMultiTest,
-} from './query/query.js';
-import { kBigSeparator, kWildcard, kPathSeparator, kParamSeparator } from './query/separators.js';
-import { stringifySingleParam } from './query/stringify_params.js';
-import { StacklessError } from './util.js';
-
-// `loadTreeForQuery()` loads a TestTree for a given queryToLoad.
-// The resulting tree is a linked-list all the way from `suite:*` to queryToLoad,
-// and under queryToLoad is a tree containing every case matched by queryToLoad.
-//
-// `subqueriesToExpand` influences the `collapsible` flag on nodes in the resulting tree.
-// A node is considered "collapsible" if none of the subqueriesToExpand is a StrictSubset
-// of that node.
-//
-// In WebKit/Blink-style web_tests, an expectation file marks individual cts.https.html "variants
-// as "Failure", "Crash", etc. By passing in the list of expectations as the subqueriesToExpand,
-// we can programmatically subdivide the cts.https.html "variants" list to be able to implement
-// arbitrarily-fine suppressions (instead of having to suppress entire test files, which would
-// lose a lot of coverage).
-//
-// `iterateCollapsedNodes()` produces the list of queries for the variants list.
-//
-// Though somewhat complicated, this system has important benefits:
-// - Avoids having to suppress entire test files, which would cause large test coverage loss.
-// - Minimizes the number of page loads needed for fine-grained suppressions.
-// (In the naive case, we could do one page load per test case - but the test suite would
-// take impossibly long to run.)
-// - Enables developers to put any number of tests in one file as appropriate, without worrying
-// about expectation granularity.
-
-interface TestTreeNodeBase {
- readonly query: T;
- /**
- * Readable "relative" name for display in standalone runner.
- * Not always the exact relative name, because sometimes there isn't
- * one (e.g. s:f:* relative to s:f,*), but something that is readable.
- */
- readonly readableRelativeName: string;
- subtreeCounts?: { tests: number; nodesWithTODO: number };
-}
-
-export interface TestSubtree extends TestTreeNodeBase {
- readonly children: Map;
- readonly collapsible: boolean;
- description?: string;
- readonly testCreationStack?: Error;
-}
-
-export interface TestTreeLeaf extends TestTreeNodeBase {
- readonly run: RunFn;
- readonly isUnimplemented?: boolean;
- subtreeCounts?: undefined;
-}
-
-export type TestTreeNode = TestSubtree | TestTreeLeaf;
-
-/**
- * When iterating through "collapsed" tree nodes, indicates how many "query levels" to traverse
- * through before starting to collapse nodes.
- *
- * Corresponds with TestQueryLevel, but excludes 4 (SingleCase):
- * - 1 = MultiFile. Expands so every file is in the collapsed tree.
- * - 2 = MultiTest. Expands so every test is in the collapsed tree.
- * - 3 = MultiCase. Expands so every case is in the collapsed tree (i.e. collapsing disabled).
- */
-export type ExpandThroughLevel = 1 | 2 | 3;
-
-export class TestTree {
- /**
- * The `queryToLoad` that this test tree was created for.
- * Test trees are always rooted at `suite:*`, but they only contain nodes that fit
- * within `forQuery`.
- *
- * This is used for `iterateCollapsedNodes` which only starts collapsing at the next
- * `TestQueryLevel` after `forQuery`.
- */
- readonly forQuery: TestQuery;
- readonly root: TestSubtree;
-
- constructor(forQuery: TestQuery, root: TestSubtree) {
- this.forQuery = forQuery;
- TestTree.propagateCounts(root);
- this.root = root;
- assert(
- root.query.level === 1 && root.query.depthInLevel === 0,
- 'TestTree root must be the root (suite:*)'
- );
- }
-
- /**
- * Iterate through the leaves of a version of the tree which has been pruned to exclude
- * subtrees which:
- * - are at a deeper `TestQueryLevel` than `this.forQuery`, and
- * - were not a `Ordering.StrictSubset` of any of the `subqueriesToExpand` during tree creation.
- */
- iterateCollapsedNodes({
- includeIntermediateNodes = false,
- includeEmptySubtrees = false,
- alwaysExpandThroughLevel,
- }: {
- /** Whether to include intermediate tree nodes or only collapsed-leaves. */
- includeIntermediateNodes?: boolean;
- /** Whether to include collapsed-leaves with no children. */
- includeEmptySubtrees?: boolean;
- /** Never collapse nodes up through this level. */
- alwaysExpandThroughLevel: ExpandThroughLevel;
- }): IterableIterator> {
- const expandThroughLevel = Math.max(this.forQuery.level, alwaysExpandThroughLevel);
- return TestTree.iterateSubtreeNodes(this.root, {
- includeIntermediateNodes,
- includeEmptySubtrees,
- expandThroughLevel,
- });
- }
-
- iterateLeaves(): IterableIterator> {
- return TestTree.iterateSubtreeLeaves(this.root);
- }
-
- /**
- * Dissolve nodes which have only one child, e.g.:
- * a,* { a,b,* { a,b:* { ... } } }
- * collapses down into:
- * a,* { a,b:* { ... } }
- * which is less needlessly verbose when displaying the tree in the standalone runner.
- */
- dissolveSingleChildTrees(): void {
- const newRoot = dissolveSingleChildTrees(this.root);
- assert(newRoot === this.root);
- }
-
- toString(): string {
- return TestTree.subtreeToString('(root)', this.root, '');
- }
-
- static *iterateSubtreeNodes(
- subtree: TestSubtree,
- opts: {
- includeIntermediateNodes: boolean;
- includeEmptySubtrees: boolean;
- expandThroughLevel: number;
- }
- ): IterableIterator {
- if (opts.includeIntermediateNodes) {
- yield subtree;
- }
-
- for (const [, child] of subtree.children) {
- if ('children' in child) {
- // Is a subtree
- const collapsible = child.collapsible && child.query.level > opts.expandThroughLevel;
- if (child.children.size > 0 && !collapsible) {
- yield* TestTree.iterateSubtreeNodes(child, opts);
- } else if (child.children.size > 0 || opts.includeEmptySubtrees) {
- // Don't yield empty subtrees (e.g. files with no tests) unless includeEmptySubtrees
- yield child;
- }
- } else {
- // Is a leaf
- yield child;
- }
- }
- }
-
- static *iterateSubtreeLeaves(subtree: TestSubtree): IterableIterator {
- for (const [, child] of subtree.children) {
- if ('children' in child) {
- yield* TestTree.iterateSubtreeLeaves(child);
- } else {
- yield child;
- }
- }
- }
-
- /** Propagate the subtreeTODOs/subtreeTests state upward from leaves to parent nodes. */
- static propagateCounts(subtree: TestSubtree): { tests: number; nodesWithTODO: number } {
- subtree.subtreeCounts ??= { tests: 0, nodesWithTODO: 0 };
- for (const [, child] of subtree.children) {
- if ('children' in child) {
- const counts = TestTree.propagateCounts(child);
- subtree.subtreeCounts.tests += counts.tests;
- subtree.subtreeCounts.nodesWithTODO += counts.nodesWithTODO;
- }
- }
- return subtree.subtreeCounts;
- }
-
- /** Displays counts in the format `(Nodes with TODOs) / (Total test count)`. */
- static countsToString(tree: TestTreeNode): string {
- if (tree.subtreeCounts) {
- return `${tree.subtreeCounts.nodesWithTODO} / ${tree.subtreeCounts.tests}`;
- } else {
- return '';
- }
- }
-
- static subtreeToString(name: string, tree: TestTreeNode, indent: string): string {
- const collapsible = 'run' in tree ? '>' : tree.collapsible ? '+' : '-';
- let s =
- indent +
- `${collapsible} ${TestTree.countsToString(tree)} ${JSON.stringify(name)} => ${tree.query}`;
- if ('children' in tree) {
- if (tree.description !== undefined) {
- s += `\n${indent} | ${JSON.stringify(tree.description)}`;
- }
-
- for (const [name, child] of tree.children) {
- s += '\n' + TestTree.subtreeToString(name, child, indent + ' ');
- }
- }
- return s;
- }
-}
-
-// MAINTENANCE_TODO: Consider having subqueriesToExpand actually impact the depth-order of params
-// in the tree.
-export async function loadTreeForQuery(
- loader: TestFileLoader,
- queryToLoad: TestQuery,
- subqueriesToExpand: TestQuery[]
-): Promise {
- const suite = queryToLoad.suite;
- const specs = await loader.listing(suite);
-
- const subqueriesToExpandEntries = Array.from(subqueriesToExpand.entries());
- const seenSubqueriesToExpand: boolean[] = new Array(subqueriesToExpand.length);
- seenSubqueriesToExpand.fill(false);
-
- const isCollapsible = (subquery: TestQuery) =>
- subqueriesToExpandEntries.every(([i, toExpand]) => {
- const ordering = compareQueries(toExpand, subquery);
-
- // If toExpand == subquery, no expansion is needed (but it's still "seen").
- if (ordering === Ordering.Equal) seenSubqueriesToExpand[i] = true;
- return ordering !== Ordering.StrictSubset;
- });
-
- // L0 = suite-level, e.g. suite:*
- // L1 = file-level, e.g. suite:a,b:*
- // L2 = test-level, e.g. suite:a,b:c,d:*
- // L3 = case-level, e.g. suite:a,b:c,d:
- let foundCase = false;
- // L0 is suite:*
- const subtreeL0 = makeTreeForSuite(suite, isCollapsible);
- for (const entry of specs) {
- if (entry.file.length === 0 && 'readme' in entry) {
- // Suite-level readme.
- setSubtreeDescriptionAndCountTODOs(subtreeL0, entry.readme);
- continue;
- }
-
- {
- const queryL1 = new TestQueryMultiFile(suite, entry.file);
- const orderingL1 = compareQueries(queryL1, queryToLoad);
- if (orderingL1 === Ordering.Unordered) {
- // File path is not matched by this query.
- continue;
- }
- }
-
- if ('readme' in entry) {
- // Entry is a README that is an ancestor or descendant of the query.
- // (It's included for display in the standalone runner.)
-
- // readmeSubtree is suite:a,b,*
- // (This is always going to dedup with a file path, if there are any test spec files under
- // the directory that has the README).
- const readmeSubtree: TestSubtree = addSubtreeForDirPath(
- subtreeL0,
- entry.file,
- isCollapsible
- );
- setSubtreeDescriptionAndCountTODOs(readmeSubtree, entry.readme);
- continue;
- }
- // Entry is a spec file.
-
- const spec = await loader.importSpecFile(queryToLoad.suite, entry.file);
- // subtreeL1 is suite:a,b:*
- const subtreeL1: TestSubtree = addSubtreeForFilePath(
- subtreeL0,
- entry.file,
- isCollapsible
- );
- setSubtreeDescriptionAndCountTODOs(subtreeL1, spec.description);
-
- let groupHasTests = false;
- for (const t of spec.g.iterate()) {
- groupHasTests = true;
- {
- const queryL2 = new TestQueryMultiCase(suite, entry.file, t.testPath, {});
- const orderingL2 = compareQueries(queryL2, queryToLoad);
- if (orderingL2 === Ordering.Unordered) {
- // Test path is not matched by this query.
- continue;
- }
- }
-
- // subtreeL2 is suite:a,b:c,d:*
- const subtreeL2: TestSubtree = addSubtreeForTestPath(
- subtreeL1,
- t.testPath,
- t.testCreationStack,
- isCollapsible
- );
- // This is 1 test. Set tests=1 then count TODOs.
- subtreeL2.subtreeCounts ??= { tests: 1, nodesWithTODO: 0 };
- if (t.description) setSubtreeDescriptionAndCountTODOs(subtreeL2, t.description);
-
- // MAINTENANCE_TODO: If tree generation gets too slow, avoid actually iterating the cases in a
- // file if there's no need to (based on the subqueriesToExpand).
- for (const c of t.iterate()) {
- {
- const queryL3 = new TestQuerySingleCase(suite, entry.file, c.id.test, c.id.params);
- const orderingL3 = compareQueries(queryL3, queryToLoad);
- if (orderingL3 === Ordering.Unordered || orderingL3 === Ordering.StrictSuperset) {
- // Case is not matched by this query.
- continue;
- }
- }
-
- // Leaf for case is suite:a,b:c,d:x=1;y=2
- addLeafForCase(subtreeL2, c, isCollapsible);
-
- foundCase = true;
- }
- }
- if (!groupHasTests && !subtreeL1.subtreeCounts) {
- throw new StacklessError(
- `${subtreeL1.query} has no tests - it must have "TODO" in its description`
- );
- }
- }
-
- for (const [i, sq] of subqueriesToExpandEntries) {
- const subquerySeen = seenSubqueriesToExpand[i];
- if (!subquerySeen) {
- throw new StacklessError(
- `subqueriesToExpand entry did not match anything \
-(could be wrong, or could be redundant with a previous subquery):\n ${sq.toString()}`
- );
- }
- }
- assert(foundCase, `Query \`${queryToLoad.toString()}\` does not match any cases`);
-
- return new TestTree(queryToLoad, subtreeL0);
-}
-
-function setSubtreeDescriptionAndCountTODOs(
- subtree: TestSubtree,
- description: string
-) {
- assert(subtree.description === undefined);
- subtree.description = description.trim();
- subtree.subtreeCounts ??= { tests: 0, nodesWithTODO: 0 };
- if (subtree.description.indexOf('TODO') !== -1) {
- subtree.subtreeCounts.nodesWithTODO++;
- }
-}
-
-function makeTreeForSuite(
- suite: string,
- isCollapsible: (sq: TestQuery) => boolean
-): TestSubtree {
- const query = new TestQueryMultiFile(suite, []);
- return {
- readableRelativeName: suite + kBigSeparator,
- query,
- children: new Map(),
- collapsible: isCollapsible(query),
- };
-}
-
-function addSubtreeForDirPath(
- tree: TestSubtree,
- file: string[],
- isCollapsible: (sq: TestQuery) => boolean
-): TestSubtree {
- const subqueryFile: string[] = [];
- // To start, tree is suite:*
- // This loop goes from that -> suite:a,* -> suite:a,b,*
- for (const part of file) {
- subqueryFile.push(part);
- tree = getOrInsertSubtree(part, tree, () => {
- const query = new TestQueryMultiFile(tree.query.suite, subqueryFile);
- return {
- readableRelativeName: part + kPathSeparator + kWildcard,
- query,
- collapsible: isCollapsible(query),
- };
- });
- }
- return tree;
-}
-
-function addSubtreeForFilePath(
- tree: TestSubtree,
- file: string[],
- isCollapsible: (sq: TestQuery) => boolean
-): TestSubtree {
- // To start, tree is suite:*
- // This goes from that -> suite:a,* -> suite:a,b,*
- tree = addSubtreeForDirPath(tree, file, isCollapsible);
- // This goes from that -> suite:a,b:*
- const subtree = getOrInsertSubtree('', tree, () => {
- const query = new TestQueryMultiTest(tree.query.suite, tree.query.filePathParts, []);
- assert(file.length > 0, 'file path is empty');
- return {
- readableRelativeName: file[file.length - 1] + kBigSeparator + kWildcard,
- query,
- collapsible: isCollapsible(query),
- };
- });
- return subtree;
-}
-
-function addSubtreeForTestPath(
- tree: TestSubtree,
- test: readonly string[],
- testCreationStack: Error,
- isCollapsible: (sq: TestQuery) => boolean
-): TestSubtree {
- const subqueryTest: string[] = [];
- // To start, tree is suite:a,b:*
- // This loop goes from that -> suite:a,b:c,* -> suite:a,b:c,d,*
- for (const part of test) {
- subqueryTest.push(part);
- tree = getOrInsertSubtree(part, tree, () => {
- const query = new TestQueryMultiTest(
- tree.query.suite,
- tree.query.filePathParts,
- subqueryTest
- );
- return {
- readableRelativeName: part + kPathSeparator + kWildcard,
- query,
- collapsible: isCollapsible(query),
- };
- });
- }
- // This goes from that -> suite:a,b:c,d:*
- return getOrInsertSubtree('', tree, () => {
- const query = new TestQueryMultiCase(
- tree.query.suite,
- tree.query.filePathParts,
- subqueryTest,
- {}
- );
- assert(subqueryTest.length > 0, 'subqueryTest is empty');
- return {
- readableRelativeName: subqueryTest[subqueryTest.length - 1] + kBigSeparator + kWildcard,
- kWildcard,
- query,
- testCreationStack,
- collapsible: isCollapsible(query),
- };
- });
-}
-
-function addLeafForCase(
- tree: TestSubtree,
- t: RunCase,
- checkCollapsible: (sq: TestQuery) => boolean
-): void {
- const query = tree.query;
- let name: string = '';
- const subqueryParams: TestParamsRW = {};
-
- // To start, tree is suite:a,b:c,d:*
- // This loop goes from that -> suite:a,b:c,d:x=1;* -> suite:a,b:c,d:x=1;y=2;*
- for (const [k, v] of Object.entries(t.id.params)) {
- name = stringifySingleParam(k, v);
- subqueryParams[k] = v;
-
- tree = getOrInsertSubtree(name, tree, () => {
- const subquery = new TestQueryMultiCase(
- query.suite,
- query.filePathParts,
- query.testPathParts,
- subqueryParams
- );
- return {
- readableRelativeName: name + kParamSeparator + kWildcard,
- query: subquery,
- collapsible: checkCollapsible(subquery),
- };
- });
- }
-
- // This goes from that -> suite:a,b:c,d:x=1;y=2
- const subquery = new TestQuerySingleCase(
- query.suite,
- query.filePathParts,
- query.testPathParts,
- subqueryParams
- );
- checkCollapsible(subquery); // mark seenSubqueriesToExpand
- insertLeaf(tree, subquery, t);
-}
-
-function getOrInsertSubtree(
- key: string,
- parent: TestSubtree,
- createSubtree: () => Omit, 'children'>
-): TestSubtree {
- let v: TestSubtree;
- const child = parent.children.get(key);
- if (child !== undefined) {
- assert('children' in child); // Make sure cached subtree is not actually a leaf
- v = child as TestSubtree;
- } else {
- v = { ...createSubtree(), children: new Map() };
- parent.children.set(key, v);
- }
- return v;
-}
-
-function insertLeaf(parent: TestSubtree, query: TestQuerySingleCase, t: RunCase) {
- const leaf: TestTreeLeaf = {
- readableRelativeName: readableNameForCase(query),
- query,
- run: (rec, expectations) => t.run(rec, query, expectations || []),
- isUnimplemented: t.isUnimplemented,
- };
-
- // This is a leaf (e.g. s:f:t:x=1;* -> s:f:t:x=1). The key is always ''.
- const key = '';
- assert(!parent.children.has(key), `Duplicate testcase: ${query}`);
- parent.children.set(key, leaf);
-}
-
-function dissolveSingleChildTrees(tree: TestTreeNode): TestTreeNode {
- if ('children' in tree) {
- const shouldDissolveThisTree =
- tree.children.size === 1 && tree.query.depthInLevel !== 0 && tree.description === undefined;
- if (shouldDissolveThisTree) {
- // Loops exactly once
- for (const [, child] of tree.children) {
- // Recurse on child
- return dissolveSingleChildTrees(child);
- }
- }
-
- for (const [k, child] of tree.children) {
- // Recurse on each child
- const newChild = dissolveSingleChildTrees(child);
- if (newChild !== child) {
- tree.children.set(k, newChild);
- }
- }
- }
- return tree;
-}
-
-/** Generate a readable relative name for a case (used in standalone). */
-function readableNameForCase(query: TestQuerySingleCase): string {
- const paramsKeys = Object.keys(query.params);
- if (paramsKeys.length === 0) {
- return query.testPathParts[query.testPathParts.length - 1] + kBigSeparator;
- } else {
- const lastKey = paramsKeys[paramsKeys.length - 1];
- return stringifySingleParam(lastKey, query.params[lastKey]);
- }
-}
diff --git a/dom/webgpu/tests/cts/checkout/src/common/internal/util.ts b/dom/webgpu/tests/cts/checkout/src/common/internal/util.ts
deleted file mode 100644
index 37a5db356828..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/internal/util.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-/**
- * Error without a stack, which can be used to fatally exit from `tool/` scripts with a
- * user-friendly message (and no confusing stack).
- */
-export class StacklessError extends Error {
- constructor(message: string) {
- super(message);
- this.stack = undefined;
- }
-}
diff --git a/dom/webgpu/tests/cts/checkout/src/common/internal/version.ts b/dom/webgpu/tests/cts/checkout/src/common/internal/version.ts
deleted file mode 100644
index 53cc97482e6b..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/internal/version.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const version = 'unknown';
diff --git a/dom/webgpu/tests/cts/checkout/src/common/runtime/cmdline.ts b/dom/webgpu/tests/cts/checkout/src/common/runtime/cmdline.ts
deleted file mode 100644
index 463546c06d32..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/runtime/cmdline.ts
+++ /dev/null
@@ -1,278 +0,0 @@
-/* eslint no-console: "off" */
-
-import * as fs from 'fs';
-
-import { dataCache } from '../framework/data_cache.js';
-import { globalTestConfig } from '../framework/test_config.js';
-import { DefaultTestFileLoader } from '../internal/file_loader.js';
-import { prettyPrintLog } from '../internal/logging/log_message.js';
-import { Logger } from '../internal/logging/logger.js';
-import { LiveTestCaseResult } from '../internal/logging/result.js';
-import { parseQuery } from '../internal/query/parseQuery.js';
-import { parseExpectationsForTestQuery } from '../internal/query/query.js';
-import { Colors } from '../util/colors.js';
-import { setGPUProvider } from '../util/navigator_gpu.js';
-import { assert, unreachable } from '../util/util.js';
-
-import sys from './helper/sys.js';
-
-function usage(rc: number): never {
- console.log(`Usage:
- tools/run_${sys.type} [OPTIONS...] QUERIES...
- tools/run_${sys.type} 'unittests:*' 'webgpu:buffers,*'
-Options:
- --colors Enable ANSI colors in output.
- --coverage Emit coverage data.
- --verbose Print result/log of every test as it runs.
- --list Print all testcase names that match the given query and exit.
- --debug Include debug messages in logging.
- --print-json Print the complete result JSON in the output.
- --expectations Path to expectations file.
- --gpu-provider Path to node module that provides the GPU implementation.
- --gpu-provider-flag Flag to set on the gpu-provider as =
- --unroll-const-eval-loops Unrolls loops in constant-evaluation shader execution tests
- --quiet Suppress summary information in output
-`);
- return sys.exit(rc);
-}
-
-// The interface that exposes creation of the GPU, and optional interface to code coverage.
-interface GPUProviderModule {
- // @returns a GPU with the given flags
- create(flags: string[]): GPU;
- // An optional interface to a CodeCoverageProvider
- coverage?: CodeCoverageProvider;
-}
-
-interface CodeCoverageProvider {
- // Starts collecting code coverage
- begin(): void;
- // Ends collecting of code coverage, returning the coverage data.
- // This data is opaque (implementation defined).
- end(): string;
-}
-
-type listModes = 'none' | 'cases' | 'unimplemented';
-
-Colors.enabled = false;
-
-let verbose = false;
-let emitCoverage = false;
-let listMode: listModes = 'none';
-let debug = false;
-let printJSON = false;
-let quiet = false;
-let loadWebGPUExpectations: Promise | undefined = undefined;
-let gpuProviderModule: GPUProviderModule | undefined = undefined;
-let dataPath: string | undefined = undefined;
-
-const queries: string[] = [];
-const gpuProviderFlags: string[] = [];
-for (let i = 0; i < sys.args.length; ++i) {
- const a = sys.args[i];
- if (a.startsWith('-')) {
- if (a === '--colors') {
- Colors.enabled = true;
- } else if (a === '--coverage') {
- emitCoverage = true;
- } else if (a === '--verbose') {
- verbose = true;
- } else if (a === '--list') {
- listMode = 'cases';
- } else if (a === '--list-unimplemented') {
- listMode = 'unimplemented';
- } else if (a === '--debug') {
- debug = true;
- } else if (a === '--data') {
- dataPath = sys.args[++i];
- } else if (a === '--print-json') {
- printJSON = true;
- } else if (a === '--expectations') {
- const expectationsFile = new URL(sys.args[++i], `file://${sys.cwd()}`).pathname;
- loadWebGPUExpectations = import(expectationsFile).then(m => m.expectations);
- } else if (a === '--gpu-provider') {
- const modulePath = sys.args[++i];
- gpuProviderModule = require(modulePath);
- } else if (a === '--gpu-provider-flag') {
- gpuProviderFlags.push(sys.args[++i]);
- } else if (a === '--quiet') {
- quiet = true;
- } else if (a === '--unroll-const-eval-loops') {
- globalTestConfig.unrollConstEvalLoops = true;
- } else {
- console.log('unrecognized flag: ', a);
- usage(1);
- }
- } else {
- queries.push(a);
- }
-}
-
-let codeCoverage: CodeCoverageProvider | undefined = undefined;
-
-if (gpuProviderModule) {
- setGPUProvider(() => gpuProviderModule!.create(gpuProviderFlags));
- if (emitCoverage) {
- codeCoverage = gpuProviderModule.coverage;
- if (codeCoverage === undefined) {
- console.error(
- `--coverage specified, but the GPUProviderModule does not support code coverage.
-Did you remember to build with code coverage instrumentation enabled?`
- );
- sys.exit(1);
- }
- }
-}
-
-if (dataPath !== undefined) {
- dataCache.setStore({
- load: (path: string) => {
- return new Promise((resolve, reject) => {
- fs.readFile(`${dataPath}/${path}`, 'utf8', (err, data) => {
- if (err !== null) {
- reject(err.message);
- } else {
- resolve(data);
- }
- });
- });
- },
- });
-}
-if (verbose) {
- dataCache.setDebugLogger(console.log);
-}
-
-if (queries.length === 0) {
- console.log('no queries specified');
- usage(0);
-}
-
-(async () => {
- const loader = new DefaultTestFileLoader();
- assert(queries.length === 1, 'currently, there must be exactly one query on the cmd line');
- const filterQuery = parseQuery(queries[0]);
- const testcases = await loader.loadCases(filterQuery);
- const expectations = parseExpectationsForTestQuery(
- await (loadWebGPUExpectations ?? []),
- filterQuery
- );
-
- Logger.globalDebugMode = debug;
- const log = new Logger();
-
- const failed: Array<[string, LiveTestCaseResult]> = [];
- const warned: Array<[string, LiveTestCaseResult]> = [];
- const skipped: Array<[string, LiveTestCaseResult]> = [];
-
- let total = 0;
-
- if (codeCoverage !== undefined) {
- codeCoverage.begin();
- }
-
- for (const testcase of testcases) {
- const name = testcase.query.toString();
- switch (listMode) {
- case 'cases':
- console.log(name);
- continue;
- case 'unimplemented':
- if (testcase.isUnimplemented) {
- console.log(name);
- }
- continue;
- default:
- break;
- }
-
- const [rec, res] = log.record(name);
- await testcase.run(rec, expectations);
-
- if (verbose) {
- printResults([[name, res]]);
- }
-
- total++;
- switch (res.status) {
- case 'pass':
- break;
- case 'fail':
- failed.push([name, res]);
- break;
- case 'warn':
- warned.push([name, res]);
- break;
- case 'skip':
- skipped.push([name, res]);
- break;
- default:
- unreachable('unrecognized status');
- }
- }
-
- if (codeCoverage !== undefined) {
- const coverage = codeCoverage.end();
- console.log(`Code-coverage: [[${coverage}]]`);
- }
-
- if (listMode !== 'none') {
- return;
- }
-
- assert(total > 0, 'found no tests!');
-
- // MAINTENANCE_TODO: write results out somewhere (a file?)
- if (printJSON) {
- console.log(log.asJSON(2));
- }
-
- if (!quiet) {
- if (skipped.length) {
- console.log('');
- console.log('** Skipped **');
- printResults(skipped);
- }
- if (warned.length) {
- console.log('');
- console.log('** Warnings **');
- printResults(warned);
- }
- if (failed.length) {
- console.log('');
- console.log('** Failures **');
- printResults(failed);
- }
-
- const passed = total - warned.length - failed.length - skipped.length;
- const pct = (x: number) => ((100 * x) / total).toFixed(2);
- const rpt = (x: number) => {
- const xs = x.toString().padStart(1 + Math.log10(total), ' ');
- return `${xs} / ${total} = ${pct(x).padStart(6, ' ')}%`;
- };
- console.log('');
- console.log(`** Summary **
-Passed w/o warnings = ${rpt(passed)}
-Passed with warnings = ${rpt(warned.length)}
-Skipped = ${rpt(skipped.length)}
-Failed = ${rpt(failed.length)}`);
- }
-
- if (failed.length || warned.length) {
- sys.exit(1);
- }
-})().catch(ex => {
- console.log(ex.stack ?? ex.toString());
- sys.exit(1);
-});
-
-function printResults(results: Array<[string, LiveTestCaseResult]>): void {
- for (const [name, r] of results) {
- console.log(`[${r.status}] ${name} (${r.timems}ms). Log:`);
- if (r.logs) {
- for (const l of r.logs) {
- console.log(prettyPrintLog(l));
- }
- }
- }
-}
diff --git a/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/options.ts b/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/options.ts
deleted file mode 100644
index bec14694a3b9..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/options.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-let windowURL: URL | undefined = undefined;
-function getWindowURL() {
- if (windowURL === undefined) {
- windowURL = new URL(window.location.toString());
- }
- return windowURL;
-}
-
-export function optionEnabled(
- opt: string,
- searchParams: URLSearchParams = getWindowURL().searchParams
-): boolean {
- const val = searchParams.get(opt);
- return val !== null && val !== '0';
-}
-
-export function optionString(
- opt: string,
- searchParams: URLSearchParams = getWindowURL().searchParams
-): string {
- return searchParams.get(opt) || '';
-}
diff --git a/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/sys.ts b/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/sys.ts
deleted file mode 100644
index d2e07ff26d30..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/sys.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-/* eslint no-process-exit: "off" */
-/* eslint @typescript-eslint/no-namespace: "off" */
-
-function node() {
- const { existsSync } = require('fs');
-
- return {
- type: 'node',
- existsSync,
- args: process.argv.slice(2),
- cwd: () => process.cwd(),
- exit: (code?: number | undefined) => process.exit(code),
- };
-}
-
-declare global {
- namespace Deno {
- function readFileSync(path: string): Uint8Array;
- const args: string[];
- const cwd: () => string;
- function exit(code?: number): never;
- }
-}
-
-function deno() {
- function existsSync(path: string) {
- try {
- Deno.readFileSync(path);
- return true;
- } catch (err) {
- return false;
- }
- }
-
- return {
- type: 'deno',
- existsSync,
- args: Deno.args,
- cwd: Deno.cwd,
- exit: Deno.exit,
- };
-}
-
-const sys = typeof globalThis.process !== 'undefined' ? node() : deno();
-
-export default sys;
diff --git a/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/test_worker-worker.ts b/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/test_worker-worker.ts
deleted file mode 100644
index 9af555f36d3f..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/test_worker-worker.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { setBaseResourcePath } from '../../framework/resources.js';
-import { DefaultTestFileLoader } from '../../internal/file_loader.js';
-import { Logger } from '../../internal/logging/logger.js';
-import { parseQuery } from '../../internal/query/parseQuery.js';
-import { TestQueryWithExpectation } from '../../internal/query/query.js';
-import { assert } from '../../util/util.js';
-
-// Should be DedicatedWorkerGlobalScope, but importing lib "webworker" conflicts with lib "dom".
-/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
-declare const self: any;
-
-const loader = new DefaultTestFileLoader();
-
-setBaseResourcePath('../../../resources');
-
-self.onmessage = async (ev: MessageEvent) => {
- const query: string = ev.data.query;
- const expectations: TestQueryWithExpectation[] = ev.data.expectations;
- const debug: boolean = ev.data.debug;
-
- Logger.globalDebugMode = debug;
- const log = new Logger();
-
- const testcases = Array.from(await loader.loadCases(parseQuery(query)));
- assert(testcases.length === 1, 'worker query resulted in != 1 cases');
-
- const testcase = testcases[0];
- const [rec, result] = log.record(testcase.query.toString());
- await testcase.run(rec, expectations);
-
- self.postMessage({ query, result });
-};
diff --git a/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/test_worker.ts b/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/test_worker.ts
deleted file mode 100644
index 2ddc3a951b63..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/runtime/helper/test_worker.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { LogMessageWithStack } from '../../internal/logging/log_message.js';
-import { TransferredTestCaseResult, LiveTestCaseResult } from '../../internal/logging/result.js';
-import { TestCaseRecorder } from '../../internal/logging/test_case_recorder.js';
-import { TestQueryWithExpectation } from '../../internal/query/query.js';
-
-export class TestWorker {
- private readonly debug: boolean;
- private readonly worker: Worker;
- private readonly resolvers = new Map void>();
-
- constructor(debug: boolean) {
- this.debug = debug;
-
- const selfPath = import.meta.url;
- const selfPathDir = selfPath.substring(0, selfPath.lastIndexOf('/'));
- const workerPath = selfPathDir + '/test_worker-worker.js';
- this.worker = new Worker(workerPath, { type: 'module' });
- this.worker.onmessage = ev => {
- const query: string = ev.data.query;
- const result: TransferredTestCaseResult = ev.data.result;
- if (result.logs) {
- for (const l of result.logs) {
- Object.setPrototypeOf(l, LogMessageWithStack.prototype);
- }
- }
- this.resolvers.get(query)!(result as LiveTestCaseResult);
-
- // MAINTENANCE_TODO(kainino0x): update the Logger with this result (or don't have a logger and
- // update the entire results JSON somehow at some point).
- };
- }
-
- async run(
- rec: TestCaseRecorder,
- query: string,
- expectations: TestQueryWithExpectation[] = []
- ): Promise {
- this.worker.postMessage({ query, expectations, debug: this.debug });
- const workerResult = await new Promise(resolve => {
- this.resolvers.set(query, resolve);
- });
- rec.injectResult(workerResult);
- }
-}
diff --git a/dom/webgpu/tests/cts/checkout/src/common/runtime/server.ts b/dom/webgpu/tests/cts/checkout/src/common/runtime/server.ts
deleted file mode 100644
index 350a864a3465..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/runtime/server.ts
+++ /dev/null
@@ -1,227 +0,0 @@
-/* eslint no-console: "off" */
-
-import * as fs from 'fs';
-import * as http from 'http';
-import { AddressInfo } from 'net';
-
-import { dataCache } from '../framework/data_cache.js';
-import { globalTestConfig } from '../framework/test_config.js';
-import { DefaultTestFileLoader } from '../internal/file_loader.js';
-import { prettyPrintLog } from '../internal/logging/log_message.js';
-import { Logger } from '../internal/logging/logger.js';
-import { LiveTestCaseResult, Status } from '../internal/logging/result.js';
-import { parseQuery } from '../internal/query/parseQuery.js';
-import { TestQueryWithExpectation } from '../internal/query/query.js';
-import { TestTreeLeaf } from '../internal/tree.js';
-import { Colors } from '../util/colors.js';
-import { setGPUProvider } from '../util/navigator_gpu.js';
-
-import sys from './helper/sys.js';
-
-function usage(rc: number): never {
- console.log(`Usage:
- tools/run_${sys.type} [OPTIONS...]
-Options:
- --colors Enable ANSI colors in output.
- --coverage Add coverage data to each result.
- --data Path to the data cache directory.
- --verbose Print result/log of every test as it runs.
- --gpu-provider Path to node module that provides the GPU implementation.
- --gpu-provider-flag Flag to set on the gpu-provider as =
- --unroll-const-eval-loops Unrolls loops in constant-evaluation shader execution tests
- --u Flag to set on the gpu-provider as =
-
-Provides an HTTP server used for running tests via an HTTP RPC interface
-To run a test, perform an HTTP GET or POST at the URL:
- http://localhost:port/run?
-To shutdown the server perform an HTTP GET or POST at the URL:
- http://localhost:port/terminate
-`);
- return sys.exit(rc);
-}
-
-interface RunResult {
- // The result of the test
- status: Status;
- // Any additional messages printed
- message: string;
- // Code coverage data, if the server was started with `--coverage`
- // This data is opaque (implementation defined).
- coverageData?: string;
-}
-
-// The interface that exposes creation of the GPU, and optional interface to code coverage.
-interface GPUProviderModule {
- // @returns a GPU with the given flags
- create(flags: string[]): GPU;
- // An optional interface to a CodeCoverageProvider
- coverage?: CodeCoverageProvider;
-}
-
-interface CodeCoverageProvider {
- // Starts collecting code coverage
- begin(): void;
- // Ends collecting of code coverage, returning the coverage data.
- // This data is opaque (implementation defined).
- end(): string;
-}
-
-if (!sys.existsSync('src/common/runtime/cmdline.ts')) {
- console.log('Must be run from repository root');
- usage(1);
-}
-
-Colors.enabled = false;
-
-let emitCoverage = false;
-let verbose = false;
-let gpuProviderModule: GPUProviderModule | undefined = undefined;
-let dataPath: string | undefined = undefined;
-
-const gpuProviderFlags: string[] = [];
-for (let i = 0; i < sys.args.length; ++i) {
- const a = sys.args[i];
- if (a.startsWith('-')) {
- if (a === '--colors') {
- Colors.enabled = true;
- } else if (a === '--coverage') {
- emitCoverage = true;
- } else if (a === '--data') {
- dataPath = sys.args[++i];
- } else if (a === '--gpu-provider') {
- const modulePath = sys.args[++i];
- gpuProviderModule = require(modulePath);
- } else if (a === '--gpu-provider-flag') {
- gpuProviderFlags.push(sys.args[++i]);
- } else if (a === '--unroll-const-eval-loops') {
- globalTestConfig.unrollConstEvalLoops = true;
- } else if (a === '--help') {
- usage(1);
- } else if (a === '--verbose') {
- verbose = true;
- } else {
- console.log(`unrecognised flag: ${a}`);
- }
- }
-}
-
-let codeCoverage: CodeCoverageProvider | undefined = undefined;
-
-if (gpuProviderModule) {
- setGPUProvider(() => gpuProviderModule!.create(gpuProviderFlags));
-
- if (emitCoverage) {
- codeCoverage = gpuProviderModule.coverage;
- if (codeCoverage === undefined) {
- console.error(
- `--coverage specified, but the GPUProviderModule does not support code coverage.
-Did you remember to build with code coverage instrumentation enabled?`
- );
- sys.exit(1);
- }
- }
-}
-
-if (dataPath !== undefined) {
- dataCache.setStore({
- load: (path: string) => {
- return new Promise((resolve, reject) => {
- fs.readFile(`${dataPath}/${path}`, 'utf8', (err, data) => {
- if (err !== null) {
- reject(err.message);
- } else {
- resolve(data);
- }
- });
- });
- },
- });
-}
-if (verbose) {
- dataCache.setDebugLogger(console.log);
-}
-
-(async () => {
- Logger.globalDebugMode = verbose;
- const log = new Logger();
- const testcases = new Map();
-
- async function runTestcase(
- testcase: TestTreeLeaf,
- expectations: TestQueryWithExpectation[] = []
- ): Promise {
- const name = testcase.query.toString();
- const [rec, res] = log.record(name);
- await testcase.run(rec, expectations);
- return res;
- }
-
- const server = http.createServer(
- async (request: http.IncomingMessage, response: http.ServerResponse) => {
- if (request.url === undefined) {
- response.end('invalid url');
- return;
- }
-
- const loadCasesPrefix = '/load?';
- const runPrefix = '/run?';
- const terminatePrefix = '/terminate';
-
- if (request.url.startsWith(loadCasesPrefix)) {
- const query = request.url.substr(loadCasesPrefix.length);
- try {
- const webgpuQuery = parseQuery(query);
- const loader = new DefaultTestFileLoader();
- for (const testcase of await loader.loadCases(webgpuQuery)) {
- testcases.set(testcase.query.toString(), testcase);
- }
- response.statusCode = 200;
- response.end();
- } catch (err) {
- response.statusCode = 500;
- response.end(`load failed with error: ${err}\n${(err as Error).stack}`);
- }
- } else if (request.url.startsWith(runPrefix)) {
- const name = request.url.substr(runPrefix.length);
- try {
- const testcase = testcases.get(name);
- if (testcase) {
- if (codeCoverage !== undefined) {
- codeCoverage.begin();
- }
- const result = await runTestcase(testcase);
- const coverageData = codeCoverage !== undefined ? codeCoverage.end() : undefined;
- let message = '';
- if (result.logs !== undefined) {
- message = result.logs.map(log => prettyPrintLog(log)).join('\n');
- }
- const status = result.status;
- const res: RunResult = { status, message, coverageData };
- response.statusCode = 200;
- response.end(JSON.stringify(res));
- } else {
- response.statusCode = 404;
- response.end(`test case '${name}' not found`);
- }
- } catch (err) {
- response.statusCode = 500;
- response.end(`run failed with error: ${err}`);
- }
- } else if (request.url.startsWith(terminatePrefix)) {
- server.close();
- sys.exit(1);
- } else {
- response.statusCode = 404;
- response.end('unhandled url request');
- }
- }
- );
-
- server.listen(0, () => {
- const address = server.address() as AddressInfo;
- console.log(`Server listening at [[${address.port}]]`);
- });
-})().catch(ex => {
- console.error(ex.stack ?? ex.toString());
- sys.exit(1);
-});
diff --git a/dom/webgpu/tests/cts/checkout/src/common/runtime/standalone.ts b/dom/webgpu/tests/cts/checkout/src/common/runtime/standalone.ts
deleted file mode 100644
index 0dd158fd68dc..000000000000
--- a/dom/webgpu/tests/cts/checkout/src/common/runtime/standalone.ts
+++ /dev/null
@@ -1,625 +0,0 @@
-// Implements the standalone test runner (see also: /standalone/index.html).
-
-import { dataCache } from '../framework/data_cache.js';
-import { setBaseResourcePath } from '../framework/resources.js';
-import { globalTestConfig } from '../framework/test_config.js';
-import { DefaultTestFileLoader } from '../internal/file_loader.js';
-import { Logger } from '../internal/logging/logger.js';
-import { LiveTestCaseResult } from '../internal/logging/result.js';
-import { parseQuery } from '../internal/query/parseQuery.js';
-import { TestQueryLevel } from '../internal/query/query.js';
-import { TestTreeNode, TestSubtree, TestTreeLeaf, TestTree } from '../internal/tree.js';
-import { setDefaultRequestAdapterOptions } from '../util/navigator_gpu.js';
-import { assert, ErrorWithExtra, unreachable } from '../util/util.js';
-
-import { optionEnabled, optionString } from './helper/options.js';
-import { TestWorker } from './helper/test_worker.js';
-
-window.onbeforeunload = () => {
- // Prompt user before reloading if there are any results
- return haveSomeResults ? false : undefined;
-};
-
-let haveSomeResults = false;
-
-// The possible options for the tests.
-interface StandaloneOptions {
- runnow: boolean;
- worker: boolean;
- debug: boolean;
- unrollConstEvalLoops: boolean;
- powerPreference: string;
-}
-
-// Extra per option info.
-interface StandaloneOptionInfo {
- description: string;
- parser?: (key: string) => boolean | string;
- selectValueDescriptions?: { value: string; description: string }[];
-}
-
-// Type for info for every option. This definition means adding an option
-// will generate a compile time error if not extra info is provided.
-type StandaloneOptionsInfos = Record;
-
-const optionsInfo: StandaloneOptionsInfos = {
- runnow: { description: 'run immediately on load' },
- worker: { description: 'run in a worker' },
- debug: { description: 'show more info' },
- unrollConstEvalLoops: { description: 'unroll const eval loops in WGSL' },
- powerPreference: {
- description: 'set default powerPreference for some tests',
- parser: optionString,
- selectValueDescriptions: [
- { value: '', description: 'default' },
- { value: 'low-power', description: 'low-power' },
- { value: 'high-performance', description: 'high-performance' },
- ],
- },
-};
-
-/**
- * Converts camel case to snake case.
- * Examples:
- * fooBar -> foo_bar
- * parseHTMLFile -> parse_html_file
- */
-function camelCaseToSnakeCase(id: string) {
- return id
- .replace(/(.)([A-Z][a-z]+)/g, '$1_$2')
- .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
- .toLowerCase();
-}
-
-/**
- * Creates a StandaloneOptions from the current URL search parameters.
- */
-function getOptionsInfoFromSearchParameters(
- optionsInfos: StandaloneOptionsInfos
-): StandaloneOptions {
- const optionValues: Record = {};
- for (const [optionName, info] of Object.entries(optionsInfos)) {
- const parser = info.parser || optionEnabled;
- optionValues[optionName] = parser(camelCaseToSnakeCase(optionName));
- }
- return (optionValues as unknown) as StandaloneOptions;
-}
-
-// This is just a cast in one place.
-function optionsToRecord(options: StandaloneOptions) {
- return (options as unknown) as Record;
-}
-
-const options = getOptionsInfoFromSearchParameters(optionsInfo);
-const { runnow, debug, unrollConstEvalLoops, powerPreference } = options;
-globalTestConfig.unrollConstEvalLoops = unrollConstEvalLoops;
-
-Logger.globalDebugMode = debug;
-const logger = new Logger();
-
-setBaseResourcePath('../out/resources');
-
-const worker = options.worker ? new TestWorker(debug) : undefined;
-
-const autoCloseOnPass = document.getElementById('autoCloseOnPass') as HTMLInputElement;
-const resultsVis = document.getElementById('resultsVis')!;
-const progressElem = document.getElementById('progress')!;
-const progressTestNameElem = progressElem.querySelector('.progress-test-name')!;
-const stopButtonElem = progressElem.querySelector('button')!;
-let runDepth = 0;
-let stopRequested = false;
-
-stopButtonElem.addEventListener('click', () => {
- stopRequested = true;
-});
-
-if (powerPreference) {
- setDefaultRequestAdapterOptions({ powerPreference: powerPreference as GPUPowerPreference });
-}
-
-dataCache.setStore({
- load: async (path: string) => {
- const response = await fetch(`data/${path}`);
- if (!response.ok) {
- return Promise.reject(response.statusText);
- }
- return await response.text();
- },
-});
-
-interface SubtreeResult {
- pass: number;
- fail: number;
- warn: number;
- skip: number;
- total: number;
- timems: number;
-}
-
-function emptySubtreeResult() {
- return { pass: 0, fail: 0, warn: 0, skip: 0, total: 0, timems: 0 };
-}
-
-function mergeSubtreeResults(...results: SubtreeResult[]) {
- const target = emptySubtreeResult();
- for (const result of results) {
- target.pass += result.pass;
- target.fail += result.fail;
- target.warn += result.warn;
- target.skip += result.skip;
- target.total += result.total;
- target.timems += result.timems;
- }
- return target;
-}
-
-type SetCheckedRecursively = () => void;
-type GenerateSubtreeHTML = (parent: HTMLElement) => SetCheckedRecursively;
-type RunSubtree = () => Promise;
-
-interface VisualizedSubtree {
- generateSubtreeHTML: GenerateSubtreeHTML;
- runSubtree: RunSubtree;
-}
-
-// DOM generation
-
-function memoize(fn: () => T): () => T {
- let value: T | undefined;
- return () => {
- if (value === undefined) {
- value = fn();
- }
- return value;
- };
-}
-
-function makeTreeNodeHTML(tree: TestTreeNode, parentLevel: TestQueryLevel): VisualizedSubtree {
- let subtree: VisualizedSubtree;
-
- if ('children' in tree) {
- subtree = makeSubtreeHTML(tree, parentLevel);
- } else {
- subtree = makeCaseHTML(tree);
- }
-
- const generateMyHTML = (parentElement: HTMLElement) => {
- const div = $('').appendTo(parentElement)[0];
- return subtree.generateSubtreeHTML(div);
- };
- return { runSubtree: subtree.runSubtree, generateSubtreeHTML: generateMyHTML };
-}
-
-function makeCaseHTML(t: TestTreeLeaf): VisualizedSubtree {
- // Becomes set once the case has been run once.
- let caseResult: LiveTestCaseResult | undefined;
-
- // Becomes set once the DOM for this case exists.
- let clearRenderedResult: (() => void) | undefined;
- let updateRenderedResult: (() => void) | undefined;
-
- const name = t.query.toString();
- const runSubtree = async () => {
- if (clearRenderedResult) clearRenderedResult();
-
- const result: SubtreeResult = emptySubtreeResult();
- progressTestNameElem.textContent = name;
-
- haveSomeResults = true;
- const [rec, res] = logger.record(name);
- caseResult = res;
- if (worker) {
- await worker.run(rec, name);
- } else {
- await t.run(rec);
- }
-
- result.total++;
- result.timems += caseResult.timems;
- switch (caseResult.status) {
- case 'pass':
- result.pass++;
- break;
- case 'fail':
- result.fail++;
- break;
- case 'skip':
- result.skip++;
- break;
- case 'warn':
- result.warn++;
- break;
- default:
- unreachable();
- }
-
- if (updateRenderedResult) updateRenderedResult();
-
- return result;
- };
-
- const generateSubtreeHTML = (div: HTMLElement) => {
- div.classList.add('testcase');
-
- const caselogs = $('
').addClass('testcaselogs').hide();
- const [casehead, setChecked] = makeTreeNodeHeaderHTML(t, runSubtree, 2, checked => {
- checked ? caselogs.show() : caselogs.hide();
- });
- const casetime = $('
').addClass('testcasetime').html('ms').appendTo(casehead);
- div.appendChild(casehead);
- div.appendChild(caselogs[0]);
-
- clearRenderedResult = () => {
- div.removeAttribute('data-status');
- casetime.text('ms');
- caselogs.empty();
- };
-
- updateRenderedResult = () => {
- if (caseResult) {
- div.setAttribute('data-status', caseResult.status);
-
- casetime.text(caseResult.timems.toFixed(4) + ' ms');
-
- if (caseResult.logs) {
- caselogs.empty();
- for (const l of caseResult.logs) {
- const caselog = $('
').addClass('testcaselog').appendTo(caselogs);
- $('