fullyExpandSubtrees & ability to disable no long path assert

src/common/internal/file_loader.ts

@@ -73,15 +73,17 @@ export abstract class TestFileLoader extends EventTarget {
     query: TestQuery,
     {
       subqueriesToExpand = [],
+      fullyExpandSubtrees = [],
       maxChunkTime = Infinity,
-    }: { subqueriesToExpand?: string[]; maxChunkTime?: number } = {}
+    }: { subqueriesToExpand?: string[]; fullyExpandSubtrees?: string[]; maxChunkTime?: number } = {}
   ): Promise<TestTree> {
     const tree = await loadTreeForQuery(this, query, {
       subqueriesToExpand: subqueriesToExpand.map(s => {
         const q = parseQuery(s);
         assert(q.level >= 2, () => `subqueriesToExpand entries should not be multi-file:\n  ${q}`);
         return q;
       }),
+      fullyExpandSubtrees: fullyExpandSubtrees.map(s => parseQuery(s)),
       maxChunkTime,
     });
     this.dispatchEvent(new MessageEvent<void>('finish'));

src/common/internal/tree.ts

@@ -286,8 +286,9 @@ export async function loadTreeForQuery(
   queryToLoad: TestQuery,
   {
     subqueriesToExpand,
+    fullyExpandSubtrees = [],
     maxChunkTime = Infinity,
-  }: { subqueriesToExpand: TestQuery[]; maxChunkTime?: number }
+  }: { subqueriesToExpand: TestQuery[]; fullyExpandSubtrees?: TestQuery[]; maxChunkTime?: number }
 ): Promise<TestTree> {
   const suite = queryToLoad.suite;
   const specs = await loader.listing(suite);
@@ -303,6 +304,10 @@ export async function loadTreeForQuery(
       // If toExpand == subquery, no expansion is needed (but it's still "seen").
       if (ordering === Ordering.Equal) seenSubqueriesToExpand[i] = true;
       return ordering !== Ordering.StrictSubset;
+    }) &&
+    fullyExpandSubtrees.every(toExpand => {
+      const ordering = compareQueries(toExpand, subquery);
+      return ordering === Ordering.Unordered;
     });
 
   // L0 = suite-level, e.g. suite:*

src/common/tools/gen_wpt_cts_html.ts

@@ -71,6 +71,13 @@ interface ConfigJSON {
     /** The prefix to trim from every line of the expectations_file. */
     prefix: string;
   };
+  /** Expend all subtrees for provided queries */
+  fullyExpandSubtrees?: {
+    file: string;
+    prefix: string;
+  };
+  /*No long path assert */
+  noLongPathAssert?: boolean;
 }
 
 interface Config {
@@ -79,10 +86,15 @@ interface Config {
   template: string;
   maxChunkTimeMS: number;
   argumentsPrefixes: string[];
+  noLongPathAssert: boolean;
   expectations?: {
     file: string;
     prefix: string;
   };
+  fullyExpandSubtrees?: {
+    file: string;
+    prefix: string;
+  };
 }
 
 let config: Config;
@@ -101,13 +113,20 @@ let config: Config;
         template: path.resolve(jsonFileDir, configJSON.template),
         maxChunkTimeMS: configJSON.maxChunkTimeMS ?? Infinity,
         argumentsPrefixes: configJSON.argumentsPrefixes ?? ['?q='],
+        noLongPathAssert: configJSON.noLongPathAssert ?? false,
       };
       if (configJSON.expectations) {
         config.expectations = {
           file: path.resolve(jsonFileDir, configJSON.expectations.file),
           prefix: configJSON.expectations.prefix,
         };
       }
+      if (configJSON.fullyExpandSubtrees) {
+        config.fullyExpandSubtrees = {
+          file: path.resolve(jsonFileDir, configJSON.fullyExpandSubtrees.file),
+          prefix: configJSON.fullyExpandSubtrees.prefix,
+        };
+      }
       break;
     }
     case 4:
@@ -130,6 +149,7 @@ let config: Config;
         suite,
         maxChunkTimeMS: Infinity,
         argumentsPrefixes: ['?q='],
+        noLongPathAssert: false,
       };
       if (process.argv.length >= 7) {
         config.argumentsPrefixes = (await fs.readFile(argsPrefixesFile, 'utf8'))
@@ -153,36 +173,24 @@ let config: Config;
   config.argumentsPrefixes.sort((a, b) => b.length - a.length);
 
   // Load expectations (if any)
-  let expectationLines = new Set<string>();
-  if (config.expectations) {
-    expectationLines = new Set(
-      (await fs.readFile(config.expectations.file, 'utf8')).split(/\r?\n/).filter(l => l.length)
-    );
-  }
+  const expectations: Map<string, string[]> = await loadQueryFile(
+    config.argumentsPrefixes,
+    config.expectations
+  );
 
-  const expectations: Map<string, string[]> = new Map();
-  for (const prefix of config.argumentsPrefixes) {
-    expectations.set(prefix, []);
-  }
-
-  expLoop: for (const exp of expectationLines) {
-    // Take each expectation for the longest prefix it matches.
-    for (const argsPrefix of config.argumentsPrefixes) {
-      const prefix = config.expectations!.prefix + argsPrefix;
-      if (exp.startsWith(prefix)) {
-        expectations.get(argsPrefix)!.push(exp.substring(prefix.length));
-        continue expLoop;
-      }
-    }
-    console.log('note: ignored expectation: ' + exp);
-  }
+  // Load fullyExpandSubtrees queries (if any)
+  const fullyExpand: Map<string, string[]> = await loadQueryFile(
+    config.argumentsPrefixes,
+    config.fullyExpandSubtrees
+  );
 
   const loader = new DefaultTestFileLoader();
   const lines = [];
   for (const prefix of config.argumentsPrefixes) {
     const rootQuery = new TestQueryMultiFile(config.suite, []);
     const tree = await loader.loadTree(rootQuery, {
       subqueriesToExpand: expectations.get(prefix),
+      fullyExpandSubtrees: fullyExpand.get(prefix),
       maxChunkTime: config.maxChunkTimeMS,
     });
 
@@ -199,19 +207,21 @@ let config: Config;
       alwaysExpandThroughLevel,
     })) {
       assert(query instanceof TestQueryMultiCase);
-      const queryString = query.toString();
-      // Check for a safe-ish path length limit. Filename must be <= 255, and on Windows the whole
-      // path must be <= 259. Leave room for e.g.:
-      // 'c:\b\s\w\xxxxxxxx\layout-test-results\external\wpt\webgpu\cts_worker=0_q=...-actual.txt'
-      assert(
-        queryString.length < 185,
-        `Generated test variant would produce too-long -actual.txt filename. Possible solutions:
+      if (!config.noLongPathAssert) {
+        const queryString = query.toString();
+        // Check for a safe-ish path length limit. Filename must be <= 255, and on Windows the whole
+        // path must be <= 259. Leave room for e.g.:
+        // 'c:\b\s\w\xxxxxxxx\layout-test-results\external\wpt\webgpu\cts_worker=0_q=...-actual.txt'
+        assert(
+          queryString.length < 185,
+          `Generated test variant would produce too-long -actual.txt filename. Possible solutions:
 - Reduce the length of the parts of the test query
 - Reduce the parameterization of the test
 - Make the test function faster and regenerate the listing_meta entry
 - Reduce the specificity of test expectations (if you're using them)
 ${queryString}`
-      );
+        );
+      }
 
       lines.push({
         urlQueryString: prefix + query.toString(), // "?worker=0&q=..."
@@ -232,6 +242,39 @@ ${queryString}`
   process.exit(1);
 });
 
+async function loadQueryFile(
+  argumentsPrefixes: string[],
+  queryFile?: {
+    file: string;
+    prefix: string;
+  }
+): Promise<Map<string, string[]>> {
+  let lines = new Set<string>();
+  if (queryFile) {
+    lines = new Set(
+      (await fs.readFile(queryFile.file, 'utf8')).split(/\r?\n/).filter(l => l.length)
+    );
+  }
+
+  const result: Map<string, string[]> = new Map();
+  for (const prefix of argumentsPrefixes) {
+    result.set(prefix, []);
+  }
+
+  expLoop: for (const exp of lines) {
+    // Take each expectation for the longest prefix it matches.
+    for (const argsPrefix of argumentsPrefixes) {
+      const prefix = queryFile!.prefix + argsPrefix;
+      if (exp.startsWith(prefix)) {
+        result.get(argsPrefix)!.push(exp.substring(prefix.length));
+        continue expLoop;
+      }
+    }
+    console.log('note: ignored expectation: ' + exp);
+  }
+  return result;
+}
+
 async function generateFile(
   lines: Array<{ urlQueryString?: string; comment?: string } | undefined>
 ): Promise<void> {