gdharness 1.3.10 → 1.3.12

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,16 +64,33 @@ 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] = {}
+	## The cases gdUnit4 said it finished, which [GdhSessionCheck] holds the session's lookups against.
+	var cases_ended: int = 0
 
 	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.
 	func _on_gdunit_event(event: GdUnitEvent) -> void:
 		if event.type() == GdUnitEvent.SESSION_START:
 			_test_session = GdhIndexedSession.of(_test_session)
+		elif event.type() == GdUnitEvent.TESTCASE_AFTER:
+			cases_ended += 1
 		super(event)
 
 	## [param args] with everything up to the script at [param own] given as gdUnit4's tool name. The
@@ -87,6 +114,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
@@ -94,6 +134,8 @@ class GdhRunner:
 class GdhIndexedSession:
 	extends GdUnitTestSession
 
+	## The cases found by id, which [GdhSessionCheck] reads to tell that the console used this session.
+	var lookups: int = 0
 	var _by_id: Dictionary[String, GdUnitTestCase] = {}
 
 	func _init(cases: Array[GdUnitTestCase], reports_in: String) -> void:
@@ -102,6 +144,7 @@ class GdhIndexedSession:
 			_by_id[str(test.guid)] = test
 
 	func find_test_by_id(id: GdUnitGUID) -> GdUnitTestCase:
+		lookups += 1
 		var found: GdUnitTestCase = _by_id.get(str(id), null)
 		return found
 
@@ -113,6 +156,50 @@ class GdhIndexedSession:
 		return GdhIndexedSession.new(made._test_cases, made.report_path)
 
 
+## A session hook of the runner's own, failing the run when the [GdhIndexedSession] is not the
+## session gdUnit4 works from. The swap holds only while gdUnit4 announces a session before it hands
+## it to the hooks and the console, and a gdUnit4 that changed that order would otherwise run every
+## suite as before, only slower, with nothing said. Checked in the gdUnit4 the game installed, on
+## every run, rather than in the one gdharness tests against.
+class GdhSessionCheck:
+	extends GdUnitTestSessionHook
+
+	var _runner: GdhRunner = null
+
+	func _init(runner: GdhRunner) -> void:
+		super("gdharness session check", "Fails the run when gdUnit4 works from another session.")
+		_runner = runner
+
+	func startup(session: GdUnitTestSession) -> GdUnitResult:
+		if session is GdhIndexedSession:
+			return GdUnitResult.success()
+		return GdUnitResult.error(
+			(
+				(
+					"gdharness test: gdUnit4 %s handed its session hooks the session before announcing it, so"
+					+ " the runner's indexed session is not the one they read. This gdUnit4 starts a session"
+					+ " differently from the ones gdharness knows; report it to gdharness with the version."
+				)
+				% GdUnit4Version.current()
+			)
+		)
+
+	func shutdown(session: GdUnitTestSession) -> GdUnitResult:
+		var indexed: GdhIndexedSession = session as GdhIndexedSession
+		if indexed == null or _runner.cases_ended == 0 or indexed.lookups > 0:
+			return GdUnitResult.success()
+		return GdUnitResult.error(
+			(
+				(
+					"gdharness test: gdUnit4 %s ran %d cases without looking one up in the runner's indexed"
+					+ " session, so its console reads another session. This gdUnit4 starts a session"
+					+ " differently from the ones gdharness knows; report it to gdharness with the version."
+				)
+				% [GdUnit4Version.current(), _runner.cases_ended]
+			)
+		)
+
+
 func _initialize() -> void:
 	OS.low_processor_usage_mode_sleep_usec = FRAME_SLEEP_USEC
 	var asked: PackedStringArray = OS.get_cmdline_user_args()
@@ -120,8 +207,19 @@ func _initialize() -> void:
 	for flag: String in REPORTS_OFF:
 		if asked.has(flag):
 			var _unread: bool = unread.append(REPORTS_OFF[flag])
-	if not unread.is_empty():
-		var _off: PackedStringArray = unread_off(GdUnitTestSessionHookService.instance(), unread)
+	var hooks: GdUnitTestSessionHookService = GdUnitTestSessionHookService.instance()
+	var off: PackedStringArray = unread_off(hooks, unread)
+	for path: String in unread:
+		if not off.has(path):
+			push_error(
+				(
+					(
+						"gdharness test: gdUnit4 %s registers no session hook %s, so the report it writes is not"
+						+ " turned off; report it to gdharness with the version."
+					)
+					% [GdUnit4Version.current(), path]
+				)
+			)
 	var suites: PackedStringArray = listed(asked, LISTED)
 	if asked.has(TOGETHER):
 		_together = compiled_together(suites)
@@ -132,6 +230,10 @@ 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))
+	# Added to the list itself rather than through `register`, which saves every hook it holds into
+	# `project.godot`.
+	hooks.enigne_hooks.append(GdhSessionCheck.new(_runner))
 	root.add_child(_runner)
 
 
@@ -213,6 +315,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/build/keeper.js

@@ -119,6 +119,9 @@ public static class GdharnessDesktop {
   [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
   [DllImport("kernel32.dll")] static extern bool TerminateProcess(IntPtr handle, uint code);
   [DllImport("kernel32.dll")] static extern uint SetErrorMode(uint mode);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool SetProcessAffinityMask(IntPtr process, UIntPtr mask);
+  [DllImport("kernel32.dll")] static extern uint ResumeThread(IntPtr thread);
+  const uint CreateSuspended = 0x4;
   const uint FailCriticalErrors = 0x1;
   const uint NoOpenFileErrorBox = 0x8000;
 
@@ -180,7 +183,8 @@ public static class GdharnessDesktop {
   public static int RunSpec(string specFile) {
     string[] lines = File.ReadAllLines(specFile);
     Func<int, string> field = delegate(int index) { return Encoding.UTF8.GetString(Convert.FromBase64String(lines[index])); };
-    return Run(field(0), field(1), field(2), field(3) == "1", field(4), field(5), field(6));
+    string affinity = lines.Length > 7 ? field(7) : "";
+    return Run(field(0), field(1), field(2), field(3) == "1", field(4), field(5), field(6), affinity.Length == 0 ? 0UL : ulong.Parse(affinity));
   }
 
   static void Step(string stepFile, string step) {
@@ -189,7 +193,9 @@ public static class GdharnessDesktop {
     }
   }
 
-  public static int Run(string desktop, string commandLine, string pidFile, bool noActivate, string stopFile, string directory, string stepFile) {
+  // With an affinity, the process starts suspended and is held to those processors before its
+  // first thread runs, so every thread it starts afterwards is held to them as well.
+  public static int Run(string desktop, string commandLine, string pidFile, bool noActivate, string stopFile, string directory, string stepFile, ulong affinity) {
     StartupInfo startup = new StartupInfo();
     startup.cb = Marshal.SizeOf(typeof(StartupInfo));
     if (desktop.Length > 0) {
@@ -219,9 +225,19 @@ public static class GdharnessDesktop {
     }
     try {
     Step(stepFile, "starting the process");
-    if (!CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, true, DetachedProcess, IntPtr.Zero, directory, ref startup, out started)) {
+    uint creation = DetachedProcess | (affinity == 0 ? 0u : CreateSuspended);
+    if (!CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, true, creation, IntPtr.Zero, directory, ref startup, out started)) {
       throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcessW " + commandLine);
     }
+    if (affinity != 0) {
+      Step(stepFile, "holding the process to its processors");
+      if (!SetProcessAffinityMask(started.process, new UIntPtr(affinity))) {
+        int error = Marshal.GetLastWin32Error();
+        TerminateProcess(started.process, 1);
+        throw new Win32Exception(error, "SetProcessAffinityMask " + affinity);
+      }
+      ResumeThread(started.thread);
+    }
     File.WriteAllText(pidFile, started.processId.ToString());
     if (noActivate) {
       HoldTheForeground(started);
@@ -381,7 +397,8 @@ function throughHelper(how, command, args, files, assembly = helperAssembly()) {
     how.noActivate === true ? "1" : "0",
     files.stop,
     how.directory,
-    files.step
+    files.step,
+    how.affinity === undefined ? "" : how.affinity.toString()
   ];
   writeFileSync(files.spec, fields.map((field) => Buffer.from(field, "utf8").toString("base64")).join(`
 `), "utf8");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.10",
+  "version": "1.3.12",
   "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",