gdharness 1.3.41 → 1.3.43

package/build/godot/tests/listed.gd

@@ -1,5 +1,4 @@
 extends SceneTree
-
 ## gdUnit4's command-line runner over the suites a file lists, in the file's order. One `-a` a suite
 ## outgrows the command line once a game has a few hundred suites (Windows stops at 32767
 ## characters), so the suites come from the file named after `--` with [constant LISTED], and the
@@ -26,7 +25,8 @@ const ROWS: String = "--rows-in"
 ## row an engine found to tell one that no engine ran.
 const LEFT_OUT: String = "gdharness left out"
 ## Printed before each row an entry of [constant SKIPPING] leaves out, as
-## `res://suite.gd > test_case:row`, so the caller can tell an entry naming a row that does not exist.
+## `res://suite.gd > test_case:row`, so the caller can tell an entry naming a row that does not
+## exist.
 const IGNORED_ROW: String = "gdharness ignored"
 ## Printed after a case or a suite's hooks that gdUnit4 says left orphan nodes, as
 ## `res://suite.gd > test_case left 2: Node "Sandbox" of res://sandbox.gd, Timer "Timer"`, with
@@ -76,6 +76,249 @@ const WALK_HOLD: StringName = &"gdharness_scripts_held_past_the_shutdown_walk"
 var _runner: GdhRunner = null
 
 
+func _initialize() -> void:
+	_runner = started(OS.get_cmdline_user_args())
+	_runner.own_path = get_script().resource_path
+	root.add_child(_runner)
+
+
+## As gdUnit4's own `GdUnitCmdTool.gd` ends, which names in a verbose run the nodes left orphaned.
+func _finalize() -> void:
+	queue_delete(_runner)
+	if OS.is_stdout_verbose():
+		print("Orphan nodes left as the run ends:")
+		Window.print_orphan_nodes()
+
+
+## The runner over the suites [param given] lists, to be added to the tree, which starts it. Shared
+## by this script and the suites scene of the tests addon, which loads this file from where the
+## server ships it and calls this, since the addon itself names no gdUnit4 class.
+static func started(given: PackedStringArray) -> GdhRunner:
+	# First, so the marker is older than every script the run loads.
+	var oldest: Array[GDScript] = []
+	if GdhShutdownWalk.guarded():
+		oldest = GdhShutdownWalk.marker(WALK_ENDED)
+	OS.low_processor_usage_mode_sleep_usec = FRAME_SLEEP_USEC
+	var at: int = given.find(GDUNIT)
+	var asked: PackedStringArray = given if at < 0 else given.slice(0, at)
+	var unread: PackedStringArray = []
+	for flag: String in REPORTS_OFF:
+		if asked.has(flag):
+			var _unread: bool = unread.append(REPORTS_OFF[flag])
+	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)
+	var runner: GdhRunner = GdhRunner.new()
+	runner.walk_scripts = oldest
+	if at >= 0:
+		runner.given = given.slice(at + 1)
+	if asked.has(TOGETHER):
+		runner.together = compiled_together(suites)
+	var expected_out: String = argument_after(asked, EXPECTED_OUT)
+	if not expected_out.is_empty():
+		write_expected(expected_out, suites)
+	runner.add_test_suites(suites)
+	for entry: String in listed(asked, SKIPPING):
+		if is_one_row(entry):
+			runner.left_out_rows[entry] = true
+		elif is_one_case(entry):
+			runner.left_out[entry] = true
+		else:
+			runner.skip_test_suite(entry)
+	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))
+	return runner
+
+
+## Turns off the hooks among [param hooks] whose scripts [param unread] names, answering the scripts
+## of those it turned off. Through the mark gdUnit4's own `is_enabled` reads, rather than its
+## `enable_hook`, which writes the setting into `project.godot`: a run changes nothing in the tree.
+static func unread_off(
+	hooks: GdUnitTestSessionHookService, unread: PackedStringArray
+) -> PackedStringArray:
+	var off: PackedStringArray = []
+	for hook: GdUnitTestSessionHook in hooks.enigne_hooks:
+		var path: String = hook.get_script().resource_path
+		if unread.has(path):
+			hook.set_meta("enabled", false)
+			var _added: bool = off.append(path)
+	return off
+
+
+## [param suites] compiled inside one script, answered for the caller to hold so gdUnit4's own loads
+## find them compiled. The engine keeps what it read of a class only while the compile that asked
+## for it runs (`GDScriptCache`), so a suite compiled on its own reads again every class it reaches
+## a member of, some seventy milliseconds a suite. As the preloads of one script naming every class
+## of the game's own first, held from that script's compile, they share one reading of each: two
+## hundred suites compiled in a third of the time they took one at a time. The names are public,
+## since a private one unread is a warning and every warning an error, and each a variable, since a
+## class is no constant expression. A suite that does not compile fails here and again when gdUnit4
+## loads it, which reports it as it would have. A directory listed is left to gdUnit4 to walk.
+static func compiled_together(suites: PackedStringArray) -> GDScript:
+	var lines: PackedStringArray = ["extends RefCounted"]
+	var at: int = 0
+	for named: String in held_classes():
+		var _held: bool = lines.append("var held_%d: Variant = %s" % [at, named])
+		at += 1
+	at = 0
+	for path: String in suites:
+		if not path.ends_with(".gd"):
+			continue
+		var _suite: bool = lines.append('var suite_%d: Variant = preload("%s")' % [at, path])
+		at += 1
+	var together: GDScript = GDScript.new()
+	together.source_code = "\n".join(lines) + "\n"
+	var _compiled: Error = together.reload()
+	return together
+
+
+## The classes [method compiled_together] names before the suites: the game's own GDScript classes,
+## none of an addon's or a suite's, then gdUnit4's suite. Only GDScript shares the engine's reading,
+## and a sandboxed mod's SafeGDScript class would load the sandbox's compiler, some 290 MB and up to
+## 2.5 s, for nothing.
+static func held_classes(
+	classes: Array[Dictionary] = ProjectSettings.get_global_class_list()
+) -> PackedStringArray:
+	var held: PackedStringArray = []
+	for known: Dictionary in classes:
+		var path: String = known["path"]
+		var own: bool = not path.begins_with("res://addons/") and not path.ends_with("_test.gd")
+		if own and known["language"] == &"GDScript":
+			var _own: bool = held.append(str(known["class"]))
+	var _suite: bool = held.append("GdUnitTestSuite")
+	return held
+
+
+## What the file after [param flag] in [param args] names, one a line in order, or none when no file
+## is named: gdUnit4 then says it found nothing, which a gate refuses.
+static func listed(args: PackedStringArray, flag: String) -> PackedStringArray:
+	var path: String = argument_after(args, flag)
+	if path.is_empty():
+		return PackedStringArray()
+	var named: PackedStringArray = []
+	for line: String in FileAccess.get_file_as_string(path).split("\n", false):
+		if not line.strip_edges().is_empty():
+			var _named: bool = named.append(line.strip_edges())
+	return named
+
+
+## Whether [param entry] of a [constant SKIPPING] file names one case of one suite file, as
+## `res://suite.gd:test_case`, rather than a suite or a case by gdUnit4's looser names, which go to
+## gdUnit4 as they are.
+## Whether [param entry] names one row of a parameterised case, as `res://suite.gd:test_case:row`.
+static func is_one_row(entry: String) -> bool:
+	var at: int = entry.rfind(":")
+	var row: String = entry.substr(at + 1)
+	return (
+		at > 0
+		and row.is_valid_int()
+		and not row.begins_with("-")
+		and is_one_case(entry.substr(0, at))
+	)
+
+
+static func is_one_case(entry: String) -> bool:
+	var at: int = entry.rfind(":")
+	return (
+		entry.begins_with("res://")
+		and at > "res://".length()
+		and entry.substr(0, at).ends_with(".gd")
+		and entry.substr(at + 1).is_valid_ascii_identifier()
+	)
+
+
+## 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)
+	if at < 0 or at + 1 >= args.size():
+		return ""
+	return args[at + 1]
+
+
+## What each of [param suites] declares in [param constant], by suite path and then case name, read
+## off the compiled suite's constants so a declaration is whatever the engine made of it. A
+## directory listed is walked for its scripts, as gdUnit4 walks it for suites. Only a script whose
+## source names the constant is loaded: gdUnit4 stops on a suite that does not load only when its
+## own load is the one that fails, so a broken suite loaded here first let the rest of its directory
+## run.
+static func expected_by_suite(suites: PackedStringArray, constant: String) -> Dictionary:
+	var expected: Dictionary = {}
+	for path: String in scripts_in(suites):
+		if (
+			not FileAccess.file_exists(path)
+			or not FileAccess.get_file_as_string(path).contains(constant)
+		):
+			continue
+		var suite: Script = load(path)
+		var declared: Variant = suite.get_script_constant_map().get(constant)
+		if declared is Dictionary:
+			expected[path] = declared
+	return expected
+
+
+## The scripts [param paths] names: each script, and every script under each directory.
+static func scripts_in(paths: PackedStringArray) -> PackedStringArray:
+	var found: PackedStringArray = []
+	var pending: PackedStringArray = []
+	for path: String in paths:
+		if path.ends_with(".gd"):
+			var _script: bool = found.append(path)
+		else:
+			var _directory: bool = pending.append(path.trim_suffix("/"))
+	while not pending.is_empty():
+		var directory: String = pending[pending.size() - 1]
+		pending.remove_at(pending.size() - 1)
+		for file: String in DirAccess.get_files_at(directory):
+			if file.ends_with(".gd"):
+				var _file: bool = found.append("%s/%s" % [directory, file])
+		for inner: String in DirAccess.get_directories_at(directory):
+			var _inner: bool = pending.append("%s/%s" % [directory, inner])
+	return found
+
+
+static func write_expected(path: String, suites: PackedStringArray) -> void:
+	var file: FileAccess = FileAccess.open(path, FileAccess.WRITE)
+	if file == null:
+		push_error(
+			"Could not write the expected errors to %s: %s" % [path, FileAccess.get_open_error()]
+		)
+		return
+	var expected: Dictionary = {}
+	for kind: String in EXPECTED:
+		expected[kind] = expected_by_suite(suites, EXPECTED[kind])
+	var _stored: bool = file.store_string(JSON.stringify(expected))
+	file.close()
+
+
 ## gdUnit4's runner reading its options after this script's path rather than after its own tool's,
 ## which it looks for by name and otherwise finds none of them, printing its help.
 class GdhRunner:
@@ -90,14 +333,16 @@ class GdhRunner:
 	var together: GDScript = null
 	## The cases dealt by their rows, by `res://suite.gd:test_case`.
 	var row_shares: Dictionary[String, GdhRowShare] = {}
-	## The cases to leave out, by `res://suite.gd:test_case` of the suite running them. gdUnit4's own
-	## list is matched against the script declaring a case, which for a case a suite inherits is its
-	## base, so an inherited case left out under its suite ran in every engine the suite was dealt to,
-	## and a case of `res://tests/a_test.gd` was also left out of `res://more/tests/a_test.gd`.
+	## The cases to leave out, by `res://suite.gd:test_case` of the suite running them. gdUnit4's
+	## own list is matched against the script declaring a case, which for a case a suite inherits is
+	## its base, so an inherited case left out under its suite ran in every engine the suite was
+	## dealt to, and a case of `res://tests/a_test.gd` was also left out of
+	## `res://more/tests/a_test.gd`.
 	var left_out: Dictionary[String, bool] = {}
 	## The rows of parameterised cases to leave out, by `res://suite.gd:test_case:row`.
 	var left_out_rows: Dictionary[String, bool] = {}
-	## The cases gdUnit4 said it finished, which [GdhSessionCheck] holds the session's lookups against.
+	## The cases gdUnit4 said it finished, which [GdhSessionCheck] holds the session's lookups
+	## against.
 	var cases_ended: int = 0
 	## The marker of the shutdown walk's oldest end, made as the run starts.
 	var walk_scripts: Array[GDScript] = []
@@ -135,8 +380,8 @@ class GdhRunner:
 		return options_of(OS.get_cmdline_args(), own_path)
 
 	## gdUnit4's own discovery, with each case filed under the suite it was found in before it is
-	## asked whether to leave the case out. gdUnit4 files a case under the script declaring it, which
-	## for a case a suite inherits is its base: its reports added such a case to no suite, so
+	## asked whether to leave the case out. gdUnit4 files a case under the script declaring it,
+	## which for a case a suite inherits is its base: its reports added such a case to no suite, so
 	## project_test counted none of them, and a parameterised one ran as a suite of the base's own,
 	## outside the suite inheriting it and its hooks, and was judged a case that suite never ran.
 	func discover_tests() -> Array[GdUnitTestCase]:
@@ -169,7 +414,9 @@ class GdhRunner:
 	func is_skipped(test: GdUnitTestCase) -> bool:
 		if left_out.has("%s:%s" % [test.suite_resource_path, test.test_name]) or super(test):
 			return true
-		var row: String = "%s:%s:%d" % [test.suite_resource_path, test.test_name, test.attribute_index]
+		var row: String = (
+			"%s:%s:%d" % [test.suite_resource_path, test.test_name, test.attribute_index]
+		)
 		if test.attribute_index >= 0 and left_out_rows.has(row):
 			print(
 				(
@@ -178,19 +425,27 @@ class GdhRunner:
 				)
 			)
 			return true
-		var share: GdhRowShare = row_shares.get("%s:%s" % [test.suite_resource_path, test.test_name], null)
+		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])
+		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.
+	## 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:
 		match event.type():
 			GdUnitEvent.SESSION_START:
-				_test_session = GdhIndexedSession.of(_test_session)
+				if not GdhIndexedSession.indexes_itself(_test_session):
+					_test_session = GdhIndexedSession.of(_test_session)
 			GdUnitEvent.TESTSUITE_BEFORE:
 				suite_running = event.resource_path()
 				orphans_at_suite = orphan_ids()
@@ -216,8 +471,12 @@ class GdhRunner:
 			if not case_began:
 				say_left("before or after", left)
 				return
-			say_left("before", left.filter(func(id: int) -> bool: return orphans_from_before.has(id)))
-			say_left("after", left.filter(func(id: int) -> bool: return not orphans_from_before.has(id)))
+			say_left(
+				"before", left.filter(func(id: int) -> bool: return orphans_from_before.has(id))
+			)
+			say_left(
+				"after", left.filter(func(id: int) -> bool: return not orphans_from_before.has(id))
+			)
 
 	## The orphans now that were not there in [param before] and no line has named yet.
 	func new_orphans(before: Dictionary[int, bool]) -> Array[int]:
@@ -237,7 +496,9 @@ class GdhRunner:
 			orphans_named[id] = true
 			if named.size() < ORPHANS_NAMED:
 				var _named: bool = named.append(described(instance_from_id(id) as Node))
-		var more: String = "" if ids.size() <= named.size() else ", and %d more" % (ids.size() - named.size())
+		var more: String = (
+			"" if ids.size() <= named.size() else ", and %d more" % (ids.size() - named.size())
+		)
 		print(
 			(
 				"%s %s > %s left %d: %s%s"
@@ -268,8 +529,8 @@ class GdhRunner:
 				said += " of " + script.resource_path
 		return said
 
-	## [param args] with everything up to the script at [param own] given as gdUnit4's tool name. The
-	## path is compared with its separators and, on Windows, its case folded, since the engine
+	## [param args] with everything up to the script at [param own] given as gdUnit4's tool name.
+	## The path is compared with its separators and, on Windows, its case folded, since the engine
 	## reports the script as `X:/a/listed.gd` when it was started as `X:\a\listed.gd`.
 	static func options_of(args: PackedStringArray, own: String) -> PackedStringArray:
 		var wanted: String = spelt(own)
@@ -309,13 +570,14 @@ class GdhRowShare:
 class GdhIndexedSession:
 	extends GdUnitTestSession
 
-	## The cases found by id, which [GdhSessionCheck] reads to tell that the console used this session.
+	## 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:
 		super(cases, reports_in)
-		for test: GdUnitTestCase in _test_cases:
+		for test: GdUnitTestCase in cases:
 			_by_id[str(test.guid)] = test
 
 	func find_test_by_id(id: GdUnitGUID) -> GdUnitTestCase:
@@ -328,7 +590,20 @@ class GdhIndexedSession:
 	static func of(made: GdUnitTestSession) -> GdUnitTestSession:
 		if made is GdhIndexedSession:
 			return made
-		return GdhIndexedSession.new(made._test_cases, made.report_path)
+		# Read by name, since a gdUnit4 whose session indexes its cases has no such member and a
+		# script naming it would not compile there.
+		var cases: Array[GdUnitTestCase] = []
+		var held: Variant = made.get(&"_test_cases")
+		if held is Array:
+			var listed: Array = held
+			cases.assign(listed)
+		return GdhIndexedSession.new(cases, made.report_path)
+
+	## Whether [param made] already finds a case by its id in a dictionary, as a gdUnit4 session
+	## with [code]test_count()[/code] does: gdUnit4 added both in one change, and took away the
+	## array of cases [method of] reads.
+	static func indexes_itself(made: GdUnitTestSession) -> bool:
+		return made.has_method(&"test_count")
 
 
 ## A session hook of the runner's own, failing the run when the [GdhIndexedSession] is not the
@@ -346,16 +621,20 @@ class GdhSessionCheck:
 		_runner = runner
 
 	func startup(session: GdUnitTestSession) -> GdUnitResult:
-		if session is GdhIndexedSession:
+		if session is GdhIndexedSession or GdhIndexedSession.indexes_itself(session):
 			return GdUnitResult.success()
-		return GdUnitResult.error(
-			(
+		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."
+					(
+						"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()
 				)
-				% GdUnit4Version.current()
 			)
 		)
 
@@ -363,14 +642,18 @@ class GdhSessionCheck:
 		var indexed: GdhIndexedSession = session as GdhIndexedSession
 		if indexed == null or _runner.cases_ended == 0 or indexed.lookups > 0:
 			return GdUnitResult.success()
-		return GdUnitResult.error(
-			(
+		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."
+					(
+						"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]
 				)
-				% [GdUnit4Version.current(), _runner.cases_ended]
 			)
 		)
 
@@ -396,8 +679,8 @@ class GdhShutdownWalk:
 	static func marker(said: String) -> Array[GDScript]:
 		var printing: GDScript = GDScript.new()
 		printing.source_code = (
-			'extends RefCounted\n\nvar said: String = ""\n\n\nfunc _notification(what: int) -> void:\n'
-			+ "\tif what == NOTIFICATION_PREDELETE:\n\t\tprint(said)\n"
+			'extends RefCounted\n\nvar said: String = ""\n\n\nfunc _notification(what: int) -> '
+			+ "void:\n\tif what == NOTIFICATION_PREDELETE:\n\t\tprint(said)\n"
 		)
 		var marking: GDScript = GDScript.new()
 		marking.source_code = (
@@ -434,233 +717,3 @@ class GdhShutdownWalk:
 				if not inner.begins_with("."):
 					var _inner: bool = pending.append(directory.path_join(inner))
 		ThemeDB.set_meta(WALK_HOLD, held)
-
-
-func _initialize() -> void:
-	_runner = started(OS.get_cmdline_user_args())
-	_runner.own_path = get_script().resource_path
-	root.add_child(_runner)
-
-
-## As gdUnit4's own `GdUnitCmdTool.gd` ends, which names in a verbose run the nodes left orphaned.
-func _finalize() -> void:
-	queue_delete(_runner)
-	if OS.is_stdout_verbose():
-		print("Orphan nodes left as the run ends:")
-		Window.print_orphan_nodes()
-
-
-## The runner over the suites [param given] lists, to be added to the tree, which starts it. Shared
-## by this script and the suites scene of the tests addon, which loads this file from where the
-## server ships it and calls this, since the addon itself names no gdUnit4 class.
-static func started(given: PackedStringArray) -> GdhRunner:
-	# First, so the marker is older than every script the run loads.
-	var oldest: Array[GDScript] = []
-	if GdhShutdownWalk.guarded():
-		oldest = GdhShutdownWalk.marker(WALK_ENDED)
-	OS.low_processor_usage_mode_sleep_usec = FRAME_SLEEP_USEC
-	var at: int = given.find(GDUNIT)
-	var asked: PackedStringArray = given if at < 0 else given.slice(0, at)
-	var unread: PackedStringArray = []
-	for flag: String in REPORTS_OFF:
-		if asked.has(flag):
-			var _unread: bool = unread.append(REPORTS_OFF[flag])
-	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)
-	var runner: GdhRunner = GdhRunner.new()
-	runner.walk_scripts = oldest
-	if at >= 0:
-		runner.given = given.slice(at + 1)
-	if asked.has(TOGETHER):
-		runner.together = compiled_together(suites)
-	var expected_out: String = argument_after(asked, EXPECTED_OUT)
-	if not expected_out.is_empty():
-		write_expected(expected_out, suites)
-	runner.add_test_suites(suites)
-	for entry: String in listed(asked, SKIPPING):
-		if is_one_row(entry):
-			runner.left_out_rows[entry] = true
-		elif is_one_case(entry):
-			runner.left_out[entry] = true
-		else:
-			runner.skip_test_suite(entry)
-	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))
-	return runner
-
-
-## Turns off the hooks among [param hooks] whose scripts [param unread] names, answering the scripts
-## of those it turned off. Through the mark gdUnit4's own `is_enabled` reads, rather than its
-## `enable_hook`, which writes the setting into `project.godot`: a run changes nothing in the tree.
-static func unread_off(hooks: GdUnitTestSessionHookService, unread: PackedStringArray) -> PackedStringArray:
-	var off: PackedStringArray = []
-	for hook: GdUnitTestSessionHook in hooks.enigne_hooks:
-		var path: String = hook.get_script().resource_path
-		if unread.has(path):
-			hook.set_meta("enabled", false)
-			var _added: bool = off.append(path)
-	return off
-
-
-## [param suites] compiled inside one script, answered for the caller to hold so gdUnit4's own loads
-## find them compiled. The engine keeps what it read of a class only while the compile that asked for
-## it runs (`GDScriptCache`), so a suite compiled on its own reads again every class it reaches a
-## member of, some seventy milliseconds a suite. As the preloads of one script naming every class of
-## the game's own first, held from that script's compile, they share one reading of each: two hundred
-## suites compiled in a third of the time they took one at a time. The names are public, since a
-## private one unread is a warning and every warning an error, and each a variable, since a class is
-## no constant expression. A suite that does not compile fails here and again when gdUnit4 loads it,
-## which reports it as it would have. A directory listed is left to gdUnit4 to walk.
-static func compiled_together(suites: PackedStringArray) -> GDScript:
-	var lines: PackedStringArray = ["extends RefCounted"]
-	var at: int = 0
-	for named: String in held_classes():
-		var _held: bool = lines.append("var held_%d: Variant = %s" % [at, named])
-		at += 1
-	at = 0
-	for path: String in suites:
-		if not path.ends_with(".gd"):
-			continue
-		var _suite: bool = lines.append('var suite_%d: Variant = preload("%s")' % [at, path])
-		at += 1
-	var together: GDScript = GDScript.new()
-	together.source_code = "\n".join(lines) + "\n"
-	var _compiled: Error = together.reload()
-	return together
-
-
-## The classes [method compiled_together] names before the suites: the game's own GDScript classes,
-## none of an addon's or a suite's, then gdUnit4's suite. Only GDScript shares the engine's reading,
-## and a sandboxed mod's SafeGDScript class would load the sandbox's compiler, some 290 MB and up to
-## 2.5 s, for nothing.
-static func held_classes(
-	classes: Array[Dictionary] = ProjectSettings.get_global_class_list()
-) -> PackedStringArray:
-	var held: PackedStringArray = []
-	for known: Dictionary in classes:
-		var path: String = known["path"]
-		var own: bool = not path.begins_with("res://addons/") and not path.ends_with("_test.gd")
-		if own and known["language"] == &"GDScript":
-			var _own: bool = held.append(str(known["class"]))
-	var _suite: bool = held.append("GdUnitTestSuite")
-	return held
-
-
-## What the file after [param flag] in [param args] names, one a line in order, or none when no file
-## is named: gdUnit4 then says it found nothing, which a gate refuses.
-static func listed(args: PackedStringArray, flag: String) -> PackedStringArray:
-	var path: String = argument_after(args, flag)
-	if path.is_empty():
-		return PackedStringArray()
-	var named: PackedStringArray = []
-	for line: String in FileAccess.get_file_as_string(path).split("\n", false):
-		if not line.strip_edges().is_empty():
-			var _named: bool = named.append(line.strip_edges())
-	return named
-
-
-## Whether [param entry] of a [constant SKIPPING] file names one case of one suite file, as
-## `res://suite.gd:test_case`, rather than a suite or a case by gdUnit4's looser names, which go to
-## gdUnit4 as they are.
-## Whether [param entry] names one row of a parameterised case, as `res://suite.gd:test_case:row`.
-static func is_one_row(entry: String) -> bool:
-	var at: int = entry.rfind(":")
-	var row: String = entry.substr(at + 1)
-	return at > 0 and row.is_valid_int() and not row.begins_with("-") and is_one_case(entry.substr(0, at))
-
-
-static func is_one_case(entry: String) -> bool:
-	var at: int = entry.rfind(":")
-	return (
-		entry.begins_with("res://")
-		and at > "res://".length()
-		and entry.substr(0, at).ends_with(".gd")
-		and entry.substr(at + 1).is_valid_ascii_identifier()
-	)
-
-
-## 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)
-	if at < 0 or at + 1 >= args.size():
-		return ""
-	return args[at + 1]
-
-
-## What each of [param suites] declares in [param constant], by suite path and then case name, read
-## off the compiled suite's constants so a declaration is whatever the engine made of it. A directory
-## listed is walked for its scripts, as gdUnit4 walks it for suites. Only a script whose source names
-## the constant is loaded: gdUnit4 stops on a suite that does not load only when its own load is the
-## one that fails, so a broken suite loaded here first let the rest of its directory run.
-static func expected_by_suite(suites: PackedStringArray, constant: String) -> Dictionary:
-	var expected: Dictionary = {}
-	for path: String in scripts_in(suites):
-		if not FileAccess.file_exists(path) or not FileAccess.get_file_as_string(path).contains(constant):
-			continue
-		var suite: Script = load(path)
-		var declared: Variant = suite.get_script_constant_map().get(constant)
-		if declared is Dictionary:
-			expected[path] = declared
-	return expected
-
-
-## The scripts [param paths] names: each script, and every script under each directory.
-static func scripts_in(paths: PackedStringArray) -> PackedStringArray:
-	var found: PackedStringArray = []
-	var pending: PackedStringArray = []
-	for path: String in paths:
-		if path.ends_with(".gd"):
-			var _script: bool = found.append(path)
-		else:
-			var _directory: bool = pending.append(path.trim_suffix("/"))
-	while not pending.is_empty():
-		var directory: String = pending[pending.size() - 1]
-		pending.remove_at(pending.size() - 1)
-		for file: String in DirAccess.get_files_at(directory):
-			if file.ends_with(".gd"):
-				var _file: bool = found.append("%s/%s" % [directory, file])
-		for inner: String in DirAccess.get_directories_at(directory):
-			var _inner: bool = pending.append("%s/%s" % [directory, inner])
-	return found
-
-
-static func write_expected(path: String, suites: PackedStringArray) -> void:
-	var file: FileAccess = FileAccess.open(path, FileAccess.WRITE)
-	if file == null:
-		push_error("Could not write the expected errors to %s: %s" % [path, FileAccess.get_open_error()])
-		return
-	var expected: Dictionary = {}
-	for kind: String in EXPECTED:
-		expected[kind] = expected_by_suite(suites, EXPECTED[kind])
-	var _stored: bool = file.store_string(JSON.stringify(expected))
-	file.close()