gdharness 1.3.10 → 1.3.11

package/build/cli.js

@@ -15127,6 +15127,13 @@ function funcOf(name) {
   const colon = name.indexOf(":");
   return colon < 0 ? name : name.slice(0, colon);
 }
+function rowOf(name) {
+  const row = /^[^:]+:(\d+)(?: |$)/.exec(name)?.[1];
+  return row === undefined ? null : Number(row);
+}
+function rowRuns(share, row) {
+  return "only" in share ? row !== null && share.only.includes(row) : row === null || !share.besides.includes(row);
+}
 function readRun(printed) {
   const lines = stripVTControlCharacters(printed).replaceAll(`\r
 `, `
@@ -15146,7 +15153,15 @@ function readRun(printed) {
     }
     afterCase = [];
   };
+  const leftOut = new Map;
   for (const [at, line] of lines.entries()) {
+    const left = LEFT_OUT.exec(line);
+    if (left !== null) {
+      const key = `${left[1] ?? ""} > ${left[2] ?? ""}`;
+      const row = Number(left[3]);
+      leftOut.set(key, [...leftOut.get(key) ?? [], row < 0 ? null : row]);
+      continue;
+    }
     const opened = SUITE_OPENED.exec(line);
     if (opened?.[1] !== undefined) {
       settleAfterCase("after");
@@ -15166,6 +15181,7 @@ function readRun(printed) {
         open.cases.push({
           name,
           func: funcOf(name),
+          row: rowOf(name),
           verdict: caseLine[3] ?? "",
           seconds: secondsOf(caseLine[4] ?? ""),
           at
@@ -15225,7 +15241,7 @@ function readRun(printed) {
 `);
   const starved = STARVED.flatMap((pattern) => [...joined.matchAll(pattern)].map((found) => found[0]));
   const unloadable = scriptErrorsPrinted(lines).map((error) => `${error.path}${error.line === null ? "" : `:${String(error.line)}`}: ${error.message}`);
-  return { lines, suites, errors, leaks, starved, executed, unloadable, stoppedIn };
+  return { lines, suites, errors, leaks, starved, executed, unloadable, stoppedIn, leftOut };
 }
 function withNestedErrors(printed, piped) {
   const nested = piped.flatMap((entry, at) => {
@@ -15253,6 +15269,56 @@ function exitNamed(code) {
   const gdunit = GDUNIT_EXITS.get(code);
   return gdunit === undefined ? String(code) : `${String(code)} (${gdunit})`;
 }
+function rowsAcross(engines) {
+  const dealtOut = new Map;
+  for (const { handed, printed } of engines) {
+    for (const suite of handed) {
+      for (const func of Object.keys(suite.rows ?? {})) {
+        const key = `${suite.path} > ${func}`;
+        const entry = dealtOut.get(key) ?? { path: suite.path, func, holders: [] };
+        entry.holders.push(printed);
+        dealtOut.set(key, entry);
+      }
+    }
+  }
+  const faults = [];
+  for (const [key, { path, func, holders }] of dealtOut) {
+    const suites = holders.map((printed) => printed.suites.get(path));
+    if (suites.some((suite) => suite?.closed === null || suite?.closed === undefined)) {
+      continue;
+    }
+    const counts = new Map;
+    for (const ran of suites.flatMap((suite) => suite?.cases ?? []).filter((ran) => ran.func === func)) {
+      counts.set(ran.row, (counts.get(ran.row) ?? 0) + 1);
+    }
+    const said = (row) => row === null ? "the case whole" : `row ${String(row)}`;
+    if (counts.size === 0) {
+      faults.push({
+        suite: path,
+        fault: `${key} ran in none of the ${String(holders.length)} engines its rows were dealt to`
+      });
+      continue;
+    }
+    const twice = [...counts].filter(([, times]) => times > 1).map(([row]) => said(row));
+    if (twice.length > 0) {
+      faults.push({ suite: path, fault: `${key} ran ${named(twice)} in more than one engine` });
+    }
+    const rows = [...counts.keys()].filter((row) => row !== null);
+    if (rows.length > 0 && counts.has(null)) {
+      faults.push({ suite: path, fault: `${key} ran both whole and by its rows` });
+    }
+    const left = holders.flatMap((printed) => printed.leftOut.get(key) ?? []).filter((row) => row !== null);
+    const top = Math.max(-1, ...rows, ...left);
+    const gaps = Array.from({ length: top + 1 }, (_, row) => row).filter((row) => !counts.has(row));
+    if (gaps.length > 0) {
+      faults.push({
+        suite: path,
+        fault: `${key} did not run ${named(gaps.map(said))} in any of the ${String(holders.length)} engines its rows were dealt to`
+      });
+    }
+  }
+  return faults;
+}
 function named(items) {
   const shown = items.slice(0, MOST_NAMED).join(", ");
   return items.length > MOST_NAMED ? `${shown} and ${String(items.length - MOST_NAMED)} more` : shown;
@@ -15273,7 +15339,7 @@ function judgeEngine(printed, handed, end) {
   if (printed.executed === null || printed.executed === 0) {
     faults.push(printed.executed === null ? "the run never printed its summary" : "the run executed no test case at all, whatever it exited with");
   }
-  for (const { path, cases } of handed.suites) {
+  for (const { path, cases, rows = {} } of handed.suites) {
     const suite = printed.suites.get(path);
     if (suite === undefined) {
       faults.push(`${path} never started`);
@@ -15290,11 +15356,18 @@ function judgeEngine(printed, handed, end) {
       failing.add(path);
     }
     const finished = new Set(suite.cases.map((ran) => ran.func));
-    const missing = cases.filter((func) => !finished.has(func));
+    const missing = cases.filter((func) => !finished.has(func) && rows[func] === undefined);
     if (missing.length > 0 && suite.closed !== null) {
       faults.push(`${path} closed without running ${named(missing)}`);
       failing.add(path);
     }
+    for (const [func, share] of Object.entries(rows)) {
+      const strays = suite.cases.filter((ran) => ran.func === func && !rowRuns(share, ran.row)).map((ran) => ran.row === null ? "the case whole" : `row ${String(ran.row)}`);
+      if (strays.length > 0) {
+        faults.push(`${path} > ${func} ran ${named(strays)}, which ${strays.length === 1 ? "was" : "were"} dealt to another engine`);
+        failing.add(path);
+      }
+    }
     const wanted = new Set(cases);
     const unasked = [...finished].filter((func) => !wanted.has(func));
     if (unasked.length > 0) {
@@ -15416,7 +15489,7 @@ ${String(error.warning)}`);
   const neverPrinted = [...owed.values()].flatMap((debt) => debt.texts.map((text) => ({ suite: debt.suite, during: debt.during, text, warning: debt.warning })));
   return { printed: unexpected, neverPrinted };
 }
-var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, DRIVER_FALLBACK, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_EXITS, TAIL = 60, MOST_NAMED = 8;
+var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, LEFT_OUT, DRIVER_FALLBACK, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_EXITS, TAIL = 60, MOST_NAMED = 8;
 var init_suite_judge = __esm(() => {
   init_engine_leaks();
   init_junit();
@@ -15427,6 +15500,7 @@ var init_suite_judge = __esm(() => {
   ERROR_LINE = /^\s*(?:SCRIPT |USER )?ERROR: (.*?)\s*$/;
   WARNING_LINE = /^\s*(?:SCRIPT |USER )?WARNING: (.*?)\s*$/;
   EXECUTED = /^Executed test cases\s*:\s*\((\d+)\//;
+  LEFT_OUT = /^gdharness left out (res:\/\/.+?\.gd) > ([^:\s]+):(-?\d+)\s*$/;
   DRIVER_FALLBACK = /^\s*WARNING: Your video card drivers .*, switching to /;
   ORPHANS_REPORTED = /^\s*WARNING: Detected \d+ (?:possible )?orphan nodes\.\s*$/;
   STARVED = [
@@ -15587,7 +15661,7 @@ function writeJson(file, value) {
   writeWhole(file, `${JSON.stringify(value, null, 1)}
 `);
 }
-function timesAfter(times, suites, runs, now) {
+function timesAfter(times, suites, runs, now, cutShort = new Set) {
   const next = {};
   for (const [path, time] of Object.entries(times)) {
     const suite = now(path);
@@ -15596,7 +15670,12 @@ function timesAfter(times, suites, runs, now) {
     }
     const cases = Object.fromEntries(Object.entries(time.cases).filter(([func]) => suite.cases.includes(func)));
     const dropped = Object.entries(time.cases).filter(([func]) => !(func in cases)).reduce((sum, [, seconds]) => sum + seconds, 0);
-    next[path] = { seconds: round(Math.max(0, time.seconds - dropped)), cases };
+    const rows = Object.fromEntries(Object.entries(time.rows ?? {}).filter(([func]) => suite.cases.includes(func)));
+    next[path] = {
+      seconds: round(Math.max(0, time.seconds - dropped)),
+      cases,
+      ...Object.keys(rows).length > 0 ? { rows } : {}
+    };
   }
   const declared = new Map(suites.map((suite) => [suite.path, suite]));
   const measured = new Map;
@@ -15605,15 +15684,24 @@ function timesAfter(times, suites, runs, now) {
       if (printed.closed === null || !declared.has(printed.path)) {
         continue;
       }
-      const entry = measured.get(printed.path) ?? { cases: new Map, around: 0 };
+      const entry = measured.get(printed.path) ?? {
+        cases: new Map,
+        rows: new Map,
+        around: 0
+      };
       const own = new Map;
       for (const ran of printed.cases) {
         own.set(ran.func, (own.get(ran.func) ?? 0) + ran.seconds);
+        if (ran.row !== null) {
+          const rows = entry.rows.get(ran.func) ?? new Map;
+          rows.set(ran.row, ran.seconds);
+          entry.rows.set(ran.func, rows);
+        }
       }
       const inCases = [...own.values()].reduce((sum, seconds) => sum + seconds, 0);
       entry.around = Math.max(entry.around, printed.closed.seconds - inCases);
       for (const [func, seconds] of own) {
-        entry.cases.set(func, seconds);
+        entry.cases.set(func, (entry.cases.get(func) ?? 0) + seconds);
       }
       measured.set(printed.path, entry);
     }
@@ -15621,17 +15709,33 @@ function timesAfter(times, suites, runs, now) {
   for (const [path, entry] of measured) {
     const suite = declared.get(path);
     const cases = {};
+    const rows = {};
     for (const func of suite?.cases ?? []) {
-      const seconds = entry.cases.get(func) ?? times[path]?.cases[func];
+      const measuredRows = entry.rows.get(func);
+      const keptRows = measuredRows === undefined ? times[path]?.rows?.[func] : rowsAfter(times[path]?.rows?.[func], measuredRows, cutShort.has(`${path}:${func}`));
+      if (keptRows !== undefined) {
+        rows[func] = keptRows.map(round);
+      }
+      const seconds = measuredRows === undefined || keptRows === undefined ? entry.cases.get(func) ?? times[path]?.cases[func] : keptRows.reduce((sum, row) => sum + row, 0);
       if (seconds !== undefined) {
         cases[func] = round(seconds);
       }
     }
     const inCases = Object.values(cases).reduce((sum, seconds) => sum + seconds, 0);
-    next[path] = { seconds: round(entry.around + inCases), cases };
+    next[path] = {
+      seconds: round(entry.around + inCases),
+      cases,
+      ...Object.keys(rows).length > 0 ? { rows } : {}
+    };
   }
   return next;
 }
+function rowsAfter(before, measured, cutShort) {
+  const count = Math.max(...measured.keys()) + 1;
+  const whole = !cutShort && measured.size === count;
+  const length = whole ? count : Math.max(count, before?.length ?? 0);
+  return Array.from({ length }, (_, row) => measured.get(row) ?? before?.[row] ?? 0);
+}
 function round(seconds) {
   return Math.round(seconds * 1000) / 1000;
 }
@@ -15652,24 +15756,39 @@ function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
     const costOf = (func) => time?.cases[func] ?? caseCost;
     const around = time === undefined ? aroundCost : Math.max(0, time.seconds - Object.values(time.cases).reduce((sum, s) => sum + s, 0));
     const whole = around + suite.cases.reduce((sum, func) => sum + costOf(func), 0);
-    if (suite.windowed || whole <= splitPast || suite.cases.length < 2) {
-      return [
-        {
-          suite: suite.path,
-          cases: suite.cases,
-          cost: whole,
-          windowed: suite.windowed,
-          headless: suite.headless
-        }
-      ];
-    }
-    return suite.cases.map((func) => ({
+    const wholly = {
       suite: suite.path,
-      cases: [func],
-      cost: around + costOf(func),
-      windowed: false,
+      cases: suite.cases,
+      cost: whole,
+      windowed: suite.windowed,
       headless: suite.headless
-    }));
+    };
+    if (suite.windowed || whole <= splitPast) {
+      return [wholly];
+    }
+    const units = suite.cases.flatMap((func) => {
+      const rows = time?.rows?.[func] ?? [];
+      if (rows.length < 2 || around + costOf(func) <= splitPast) {
+        return [
+          {
+            suite: suite.path,
+            cases: [func],
+            cost: around + costOf(func),
+            windowed: false,
+            headless: suite.headless
+          }
+        ];
+      }
+      return rows.map((seconds, index) => ({
+        suite: suite.path,
+        cases: [func],
+        row: { index, rest: index === rows.length - 1 },
+        cost: around + seconds,
+        windowed: false,
+        headless: suite.headless
+      }));
+    });
+    return units.length < 2 ? [wholly] : units;
   });
 }
 function dealt(units, declared, most) {
@@ -15677,7 +15796,7 @@ function dealt(units, declared, most) {
     return [];
   }
   const windowed = units.filter((unit) => unit.windowed);
-  const headless = units.filter((unit) => !unit.windowed).sort((a, b) => b.cost - a.cost || a.suite.localeCompare(b.suite) || (a.cases[0] ?? "").localeCompare(b.cases[0] ?? ""));
+  const headless = units.filter((unit) => !unit.windowed).sort((a, b) => b.cost - a.cost || a.suite.localeCompare(b.suite) || (a.cases[0] ?? "").localeCompare(b.cases[0] ?? "") || (a.row?.index ?? 0) - (b.row?.index ?? 0));
   const together = windowed.reduce((sum, unit) => sum + unit.cost, 0);
   const restart = windowed.length > 0 ? ENGINE_START_SECONDS : 0;
   const total = units.reduce((sum, unit) => sum + unit.cost, 0);
@@ -15691,8 +15810,8 @@ function dealt(units, declared, most) {
     loads[lightest] = (loads[lightest] ?? 0) + unit.cost;
   }
   return [
-    ...windowed.length > 0 ? [planOf(windowed, declared, true, 0)] : [],
-    ...bins.flatMap((bin, lane) => bin.length === 0 ? [] : [planOf(bin, declared, false, lane)])
+    ...windowed.length > 0 ? [planOf(windowed, declared, true, 0, units)] : [],
+    ...bins.flatMap((bin, lane) => bin.length === 0 ? [] : [planOf(bin, declared, false, lane, units)])
   ];
 }
 function lanesOf(plans) {
@@ -15713,16 +15832,34 @@ function headlessInAWindow(plans, units) {
   return plans.filter((plan) => plan.windowed).flatMap((plan) => plan.suites.map((suite) => suite.path)).filter((path) => said.has(path));
 }
 function inOneEngine(units, declared) {
-  return planOf(units, declared, units.some((unit) => unit.windowed), 0);
+  return planOf(units, declared, units.some((unit) => unit.windowed), 0, units);
 }
-function planOf(bin, declared, windowed, lane) {
+function planOf(bin, declared, windowed, lane, all) {
   const held = new Map;
   for (const unit of bin) {
-    held.set(unit.suite, [...held.get(unit.suite) ?? [], ...unit.cases]);
+    const cases = held.get(unit.suite) ?? [];
+    held.set(unit.suite, [...cases, ...unit.cases.filter((func) => !cases.includes(func))]);
   }
   const skipping = [...held].flatMap(([path, cases]) => (declared.get(path) ?? []).filter((func) => !cases.includes(func)).map((func) => `${path}:${func}`));
+  const rowsOf = (units, path, func) => units.flatMap((unit) => unit.suite === path && unit.cases[0] === func && unit.row !== undefined ? [unit.row.index] : []);
+  const sharesOf = (path, cases) => {
+    const shares = {};
+    for (const func of cases) {
+      const mine = rowsOf(bin, path, func);
+      const dealtOut = rowsOf(all, path, func);
+      if (mine.length === 0 || mine.length === dealtOut.length) {
+        continue;
+      }
+      const rest = bin.some((unit) => unit.suite === path && unit.cases[0] === func && unit.row?.rest === true);
+      shares[func] = rest ? { besides: dealtOut.filter((row) => !mine.includes(row)) } : { only: mine.sort((a, b) => a - b) };
+    }
+    return shares;
+  };
   return {
-    suites: [...held].map(([path, cases]) => ({ path, cases: [...cases].sort() })),
+    suites: [...held].map(([path, cases]) => {
+      const rows = sharesOf(path, cases);
+      return { path, cases: [...cases].sort(), ...Object.keys(rows).length > 0 ? { rows } : {} };
+    }),
     skipping,
     cost: bin.reduce((sum, unit) => sum + unit.cost, 0),
     windowed,
@@ -57155,10 +57292,16 @@ ${existsSync19(path) ? readFileSync20(path, "latin1") : "missing"}`)
       const one = windowedAnyway.length === 1;
       console.log(`${named(windowedAnyway)} ${one ? "says it runs" : "say they run"} headless and ${one ? "runs" : "run"} with a window here, since an ordered run is one engine and a suite in it needs a window. Run ${one ? "it" : "them"} without the windowed suites to run ${one ? "it" : "them"} headless.`);
     }
-    const split = [...new Set(units.map((unit) => unit.suite))].filter((path) => units.filter((unit) => unit.suite === path).length > 1);
+    const split = [...new Set(units.map((unit) => unit.suite))].filter((path) => units.filter((unit) => unit.suite === path && unit.row === undefined).length > 1);
     if (plans.length > 1 && split.length > 0) {
       console.log(`Dealt out case by case, since ${split.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(split)}.`);
     }
+    const byRows = [
+      ...new Set(units.flatMap((unit) => unit.row === undefined ? [] : [`${unit.suite} > ${unit.cases[0] ?? ""}`]))
+    ];
+    if (plans.length > 1 && byRows.length > 0) {
+      console.log(`Dealt out row by row, since ${byRows.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(byRows)}.`);
+    }
     const lanes = [...new Set(plans.map((plan) => plan.lane))].map((lane) => plans.flatMap((plan, index) => plan.lane === lane ? [{ plan, index }] : []));
     let ran = (await inTurns(lanes, room.engines, (lane) => runLane(launch, lane, units))).flat().sort((a, b) => a.index - b.index);
     if (ran.some((engine) => engine.verdict.starved) && ran.some((engine) => !engine.verdict.passed)) {
@@ -57169,9 +57312,10 @@ ${existsSync19(path) ? readFileSync20(path, "latin1") : "missing"}`)
       }
       ran = again;
     }
-    writeJson(timesFile, timesAfter(readTimes(timesFile), wholeSuites, ran.map((engine) => engine.printed), (path) => scripts.suite(path)));
-    recordPassed(passedFile, ran, printsOf);
-    return report(ran, startedAt, runDirectory, options.printOutput);
+    writeJson(timesFile, timesAfter(readTimes(timesFile), wholeSuites, ran.map((engine) => engine.printed), (path) => scripts.suite(path), new Set(ran.flatMap((engine) => engine.plan.suites.filter((suite) => (engine.printed.suites.get(suite.path)?.closed ?? null) === null).flatMap((suite) => suite.cases.map((func) => `${suite.path}:${func}`))))));
+    const across = rowsAcross(ran.map((engine) => ({ handed: engine.plan.suites, printed: engine.printed })));
+    recordPassed(passedFile, ran, printsOf, new Set(across.map((fault) => fault.suite)));
+    return report(ran, across.map((fault) => fault.fault), startedAt, runDirectory, options.printOutput);
   } finally {
     process12.off("SIGINT", interrupted);
     process12.off("SIGTERM", interrupted);
@@ -57207,9 +57351,9 @@ function readRecord(file) {
     return {};
   }
 }
-function recordPassed(file, ran, printsOf) {
+function recordPassed(file, ran, printsOf, failedAcross) {
   const passed = readRecord(file);
-  const failedSomewhere = new Set;
+  const failedSomewhere = new Set(failedAcross);
   const passedSomewhere = new Set;
   for (const engine of ran) {
     const passing = new Set(engine.verdict.passedSuites);
@@ -57270,12 +57414,19 @@ async function runEngine2(launch, plan, index, units, again = "", slot = null) {
   mkdirSync8(join22(directory, "user"), { recursive: true });
   const suitesFile = join22(directory, "suites.txt");
   const skippingFile = join22(directory, "skipping.txt");
+  const rowsFile = join22(directory, "rows.txt");
   const expectedFile = join22(directory, "expected.json");
   writeFileSync10(suitesFile, `${plan.suites.map((suite) => suite.path).join(`
 `)}
 `);
   writeFileSync10(skippingFile, `${plan.skipping.join(`
 `)}
+`);
+  writeFileSync10(rowsFile, `${plan.suites.flatMap((suite) => Object.entries(suite.rows ?? {}).map(([func, share]) => [
+    `${suite.path}:${func}`,
+    ..."only" in share ? ["only", ...share.only] : ["besides", ...share.besides]
+  ].join("\t"))).join(`
+`)}
 `);
   const viewport = viewportOf(launch.projectPath);
   const display = plan.windowed ? viewport === null ? [] : ["--resolution", `${String(viewport.width)}x${String(viewport.height)}`] : ["--headless"];
@@ -57298,6 +57449,8 @@ async function runEngine2(launch, plan, index, units, again = "", slot = null) {
     suitesFile,
     "--skipping-in",
     skippingFile,
+    "--rows-in",
+    rowsFile,
     "--html-report-off",
     "--junit-report-off",
     "--compile-together",
@@ -57443,7 +57596,7 @@ function endTree(child) {
     process12.kill(-child.pid, "SIGKILL");
   } catch {}
 }
-function report(ran, startedAt, runDirectory, printOutput) {
+function report(ran, across, startedAt, runDirectory, printOutput) {
   if (printOutput) {
     for (const engine of ran) {
       console.log("");
@@ -57466,18 +57619,25 @@ function report(ran, startedAt, runDirectory, printOutput) {
     }
     console.log(`everything it printed: ${engine.log}`);
   }
+  if (across.length > 0) {
+    console.log("");
+    console.log("--- the cases dealt by their rows, over every engine holding them:");
+    for (const fault of across) {
+      console.log(`  ${fault}`);
+    }
+  }
   const cases = ran.reduce((sum, engine) => sum + [...engine.printed.suites.values()].reduce((n, s) => n + s.cases.length, 0), 0);
   const suites = new Set(ran.flatMap((engine) => engine.plan.suites.map((suite) => suite.path))).size;
   const longest = Math.max(0, ...ran.map((engine) => engine.seconds));
   const took = (Date.now() - startedAt) / 1000;
   const totals = `${plural(cases, "case")} in ${plural(suites, "suite")} across ${plural(ran.length, "engine")}, ${took.toFixed(1)} s; the longest engine took ${longest.toFixed(1)} s.`;
   console.log("");
-  if (failed.length === 0) {
+  if (failed.length === 0 && across.length === 0) {
     rmSync10(runDirectory, { recursive: true, force: true });
     console.log(`Passed: ${totals}`);
     return 0;
   }
-  const problems = failed.reduce((sum, engine) => sum + engine.verdict.faults.length, 0);
+  const problems = failed.reduce((sum, engine) => sum + engine.verdict.faults.length, across.length);
   console.log(`Failed: ${plural(problems, "problem")}, listed above. Ran ${totals}`);
   console.log(`Every engine's output is kept under ${runDirectory} until the next run.`);
   return 1;

package/build/godot/tests/listed.gd

@@ -15,6 +15,16 @@ extends SceneTree
 
 const LISTED: String = "--suites-in"
 const SKIPPING: String = "--skipping-in"
+## The file of the parameterised cases dealt by their rows, one a line and tab-separated:
+## `res://suite.gd:test_case`, then `only` and the rows this engine runs, or `besides` and the rows
+## it leaves to the others, for the engine that takes every row dealt nowhere else. Apart from
+## [constant SKIPPING], since gdUnit4 reads `suite:case:row` there as the case and leaves out every
+## row of it.
+const ROWS: String = "--rows-in"
+## Printed before each row an engine leaves out, as `res://suite.gd > test_case:row`, -1 for a case
+## that is not parameterised. gdUnit4 prints nothing for a case it skips, and the caller needs every
+## row an engine found to tell one that no engine ran.
+const LEFT_OUT: String = "gdharness left out"
 ## The flags turning off a report, with the gdUnit4 hook that writes it. A gate reads what a run
 ## prints, and each report finds every case it hears of in the session to write them all out as the
 ## run ends; project_test reads the JUnit one and turns off only the HTML one.
@@ -54,10 +64,23 @@ class GdhRunner:
 	extends GdUnitTestCIRunner
 
 	var own_path: String = ""
+	## The cases dealt by their rows, by `res://suite.gd:test_case`.
+	var row_shares: Dictionary[String, GdhRowShare] = {}
 
 	func get_cmdline_args() -> PackedStringArray:
 		return options_of(OS.get_cmdline_args(), own_path)
 
+	## gdUnit4 asks this of every case it finds, a parameterised case once a row, each row carrying
+	## its index.
+	func is_skipped(test: GdUnitTestCase) -> bool:
+		if super(test):
+			return true
+		var share: GdhRowShare = row_shares.get("%s:%s" % [test.suite_resource_path, test.test_name], null)
+		if share == null or not share.leaves_out(test.attribute_index):
+			return false
+		print("%s %s > %s:%d" % [LEFT_OUT, test.suite_resource_path, test.test_name, test.attribute_index])
+		return true
+
 	## The session gdUnit4 has just made, swapped for a [GdhIndexedSession] of the same cases as it
 	## is announced: everything that reads the session, the hooks, the cases and the console printing
 	## every case, is handed it after this.
@@ -87,6 +110,19 @@ class GdhRunner:
 		return forward.to_lower() if OS.get_name() == "Windows" else forward
 
 
+## The rows of one parameterised case an engine runs: those named, or every row but those.
+class GdhRowShare:
+	extends RefCounted
+
+	var only: bool = true
+	var rows: PackedInt32Array = []
+
+	## Whether the engine leaves out [param row], which is -1 for a case that is not parameterised
+	## and so runs only in the engine taking the rows besides.
+	func leaves_out(row: int) -> bool:
+		return rows.has(row) != only
+
+
 ## gdUnit4's session finding a case by its id in a dictionary, where its own walks every case of the
 ## session, `GdUnitTestSession.find_test_by_id`: the console asks it twice a case and each report
 ## twice more, so a run's time in it grew with the square of its cases (17.9 s of processor time
@@ -132,6 +168,7 @@ func _initialize() -> void:
 	_runner.own_path = get_script().resource_path
 	_runner.add_test_suites(suites)
 	_runner.skip_test_suites(listed(asked, SKIPPING))
+	_runner.row_shares = row_shares_of(listed(asked, ROWS))
 	root.add_child(_runner)
 
 
@@ -213,6 +250,22 @@ static func listed(args: PackedStringArray, flag: String) -> PackedStringArray:
 	return named
 
 
+## The row shares [param lines] of a [constant ROWS] file give, by case.
+static func row_shares_of(lines: PackedStringArray) -> Dictionary[String, GdhRowShare]:
+	var shares: Dictionary[String, GdhRowShare] = {}
+	for line: String in lines:
+		var parts: PackedStringArray = line.split("\t")
+		if parts.size() < 2:
+			continue
+		var share: GdhRowShare = GdhRowShare.new()
+		share.only = parts[1] == "only"
+		for row: String in parts.slice(2):
+			if row.is_valid_int():
+				var _added: bool = share.rows.append(row.to_int())
+		shares[parts[0]] = share
+	return shares
+
+
 ## The argument after [param flag] in [param args], or "" when there is none.
 static func argument_after(args: PackedStringArray, flag: String) -> String:
 	var at: int = args.find(flag)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.10",
+  "version": "1.3.11",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",