gdharness 1.3.5 → 1.3.7

package/build/godot/addons/gdharness_editor/reading.gd

@@ -152,7 +152,7 @@ static func not_of_kind(
 	if not found.is_empty():
 		told += ' The node at "%s" is %s, not %s.' % [node_path, with_article(found), with_article(kind)]
 	if holders.is_empty():
-		return told + " The scene holds no %s." % kind
+		return told + " The scene holds no %s; scene_node add with nodeType %s puts one in it." % [kind, kind]
 	var quoted: PackedStringArray = []
 	for holder: String in holders.slice(0, NAMED_CHILDREN):
 		var _quoted: bool = quoted.append('"%s"' % holder)

package/build/godot/addons/gdharness_editor/tool_executor.gd

@@ -120,6 +120,7 @@ func _init_tools() -> void:
 		"play_scene": [_play_tools, "play_scene"],
 		"restart_editor": [_play_tools, "restart_editor"],
 		"quit_editor": [_play_tools, "quit_editor"],
+		"editor_servers": [_play_tools, "editor_servers"],
 		"stop_playing": [_play_tools, "stop_playing"],
 		"playing_status": [_play_tools, "playing_status"],
 		# The script profiler on a game the editor plays

package/build/godot/addons/gdharness_editor/tools/play_tools.gd

@@ -170,17 +170,18 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 			)
 		}
 
-	var unsaved: Dictionary = _save_everything()
-	if not unsaved.is_empty():
-		return unsaved
+	var saving: Dictionary = _save_everything()
+	if not saving.has("saved"):
+		return saving
 
 	# Deferred so this answer is on its way out before the editor goes.
 	EditorInterface.restart_editor.call_deferred(true)
 
-	return {"ok": true, "restarting": true, "saved": true}
+	return {"ok": true, "restarting": true, "saved": saving["saved"]}
 
 
-## Saves every open scene, answering a refusal naming what is still unsaved, or {}.
+## Saves every open scene, answering a refusal naming what is still unsaved, or the scenes that had
+## changes and were saved, under `saved`.
 ##
 ## Read back rather than assumed: save_all_scenes answers nothing and passes over a scene that has
 ## never been saved, which has no path to go to, so an untitled scene was lost with the editor while
@@ -188,10 +189,11 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 static func _save_everything() -> Dictionary:
 	if EditorInterface.is_playing_scene():
 		EditorInterface.stop_playing_scene()
+	var changed: PackedStringArray = EditorInterface.get_unsaved_scenes()
 	EditorInterface.save_all_scenes()
 	var left: PackedStringArray = EditorInterface.get_unsaved_scenes()
 	if left.is_empty():
-		return {}
+		return {"ok": true, "saved": changed}
 	var named: Array[String] = []
 	for scene: String in left:
 		named.append(scene if not scene.is_empty() else "a scene that has never been saved")
@@ -221,14 +223,62 @@ static func _save_everything() -> Dictionary:
 ## Saved first, exactly as the restart above saves. The editor is going either way, and unsaved
 ## scenes are not this tool's to lose.
 func quit_editor(_args: Dictionary) -> Dictionary:
-	var unsaved: Dictionary = _save_everything()
-	if not unsaved.is_empty():
-		return unsaved
+	var saving: Dictionary = _save_everything()
+	if not saving.has("saved"):
+		return saving
 
 	# Deferred so this answer is on its way out before the editor goes.
 	_leave.call_deferred()
 
-	return {"ok": true, "quitting": true, "saved": true}
+	return {"ok": true, "quitting": true, "saved": saving["saved"]}
+
+
+## What the editor said as it started each of its servers, and the debug adapter started again when
+## [param args] names it under `rebind`.
+##
+## Godot binds each server once and says whether it could only in the editor's log panel, as a line
+## like `--- Failed to start Debug adapter server on port 6006: Already in use ---`, so those lines
+## are the one account of why a port it names has nothing on it. They are read before anything is
+## started again, so the answer carries the first attempt's reason as well as the next one's.
+##
+## The debug adapter binds as its node enters the tree, which is early in the editor's start and
+## seconds before the language server, and does not try again; taking its node out of the tree and
+## putting it back runs that start once more. The language server starts on the editor's first
+## frame after it is ready and only once, so re-entering the tree would stop it for good, and it is
+## never touched here.
+func editor_servers(args: Dictionary) -> Dictionary:
+	var said: PackedStringArray = _servers_said()
+	var rebound: bool = false
+	if GdhRead.as_bool(args.get("rebind", false)):
+		var adapter: Node = _debug_adapter()
+		if adapter != null:
+			var parent: Node = adapter.get_parent()
+			var at: int = adapter.get_index()
+			parent.remove_child(adapter)
+			parent.add_child(adapter)
+			parent.move_child(adapter, at)
+			rebound = true
+	return {"ok": true, "said": said, "rebound": rebound, "saidSince": _servers_said().slice(said.size())}
+
+
+## The lines the editor's log panel holds about its language server and debug adapter, in order.
+static func _servers_said() -> PackedStringArray:
+	var lines: PackedStringArray = []
+	var root: Node = EditorInterface.get_base_control().get_tree().root
+	for panel: Node in root.find_children("*", "EditorLog", true, false):
+		for shown: Node in panel.find_children("*", "RichTextLabel", true, false):
+			for line: String in (shown as RichTextLabel).get_parsed_text().split("\n", false):
+				var stripped: String = line.strip_edges()
+				if stripped.begins_with("---") and stripped.contains(" server"):
+					var _kept: bool = lines.append(stripped)
+	return lines
+
+
+## The editor's debug adapter node, found by its engine class, or null in an editor without one.
+static func _debug_adapter() -> Node:
+	var root: Node = EditorInterface.get_base_control().get_tree().root
+	var found: Array[Node] = root.find_children("*", "DebugAdapterServer", true, false)
+	return found[0] if not found.is_empty() else null
 
 
 ## Asked of the tree the editor's own window is in, because this object is not in one.

package/build/godot/addons/gdharness_editor/tools/resource_tools.gd

@@ -285,6 +285,17 @@ func modify_resource(args: Dictionary) -> Dictionary:
 	var resource: Resource = ResourceLoader.load(res_path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	if resource == null:
 		return {"ok": false, "error": "%s did not load as a resource." % res_path}
+	# A scene's own properties are its packed bundle, so a property named for a scene is one of its
+	# nodes', and "PackedScene has no property" left the caller looking for the tool that sets it.
+	if resource is PackedScene:
+		return {
+			"ok": false,
+			"error":
+			(
+				"%s is a scene: scene_node set changes one node's properties, the root's at nodePath \".\"."
+				% res_path
+			)
+		}
 
 	var properties: Dictionary = _parse_properties_dict(args.get("properties", ""))
 	var refused: String = _properties.write_all(resource, properties)

package/build/godot/addons/gdharness_runtime/reading.gd

@@ -152,7 +152,7 @@ static func not_of_kind(
 	if not found.is_empty():
 		told += ' The node at "%s" is %s, not %s.' % [node_path, with_article(found), with_article(kind)]
 	if holders.is_empty():
-		return told + " The scene holds no %s." % kind
+		return told + " The scene holds no %s; scene_node add with nodeType %s puts one in it." % [kind, kind]
 	var quoted: PackedStringArray = []
 	for holder: String in holders.slice(0, NAMED_CHILDREN):
 		var _quoted: bool = quoted.append('"%s"' % holder)

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -67,6 +67,13 @@ const SCRIPT_FLAGS: PackedStringArray = ["-s", "--script"]
 ## Serve a script run anyway, for somebody driving a `-s` script rather than a game.
 const SCRIPT_RUNS_SETTING: String = "gdharness/runtime/serve_script_runs"
 
+## The `res://` folders of scenes that are not the game, such as a bench: a run started on one is
+## not served. Kept in step with `QUIET_SCENES_SETTING` in src/setup.ts.
+const QUIET_SCENES_SETTING: String = "gdharness/runtime/quiet_scenes_under"
+
+## What the engine takes a bare argument for as the scene to run, by its extension.
+const SCENE_EXTENSIONS: PackedStringArray = ["tscn", "scn", "escn", "res", "tres"]
+
 ## The variable the editor addon puts into its own environment, which every game the editor plays
 ## inherits: it says which editor played this game, so a server can tell the editor's game from
 ## another of the same project that some other server started. Kept in step with
@@ -123,6 +130,9 @@ var _commands: Dictionary = {}
 var _loaded_version: String = _read_marker(VERSION_MARKER)
 var _loaded_digest: String = _read_marker(DIGEST_MARKER)
 var _profile_received: bool = false
+## Whether whatever started this game asked for a profile from its start, read before the variable
+## is taken out of the environment.
+var _profiled_from_start: bool = false
 var _close_asked: bool = false
 var _close_frames: int = 0
 var _profiler_calibrated: bool = false
@@ -200,7 +210,9 @@ static func _window_dimension(axis: String, fallback: int) -> int:
 func _wait_for_the_profiler() -> void:
 	if OS.get_environment(PROFILE_FROM_START).is_empty():
 		return
-	# Read once: a process this game starts inherits its environment and must not wait as well.
+	_profiled_from_start = true
+	# Read once: a process this game starts inherits its environment and must not wait as well, nor
+	# be served as a profiled run where a quiet scene would not be, as a bench's workers are.
 	OS.unset_environment(PROFILE_FROM_START)
 	if not EngineDebugger.is_active():
 		return
@@ -446,6 +458,15 @@ func _start_server() -> void:
 		_enabled = false
 		return
 
+	# Nor a scene the project says is not the game. A bench is handed to the engine as a scene, the
+	# way a screen is, so it announced as the game for as long as it ran, and so did every worker
+	# engine it started, all under the project's own path. One started to be profiled from its start
+	# is served all the same, since only this addon hands the totals back as it quits.
+	var prefixes: Variant = ProjectSettings.get_setting(QUIET_SCENES_SETTING, PackedStringArray())
+	if not _profiled_from_start and not quiet_scene_in(OS.get_cmdline_args(), prefixes).is_empty():
+		_enabled = false
+		return
+
 	_server = TCPServer.new()
 	# listen() defaults bind_address to "*", which exposes the game to the whole network.
 	var bind_address: String = str(ProjectSettings.get_setting(BIND_ADDRESS_SETTING, DEFAULT_BIND_ADDRESS))
@@ -474,6 +495,29 @@ func _start_server() -> void:
 		print(listening)
 
 
+## The scene [param given] names for the engine to run, as a `res://` path, when it lies under one of
+## [param prefixes]; otherwise empty. The engine takes any bare argument ending in a scene's
+## extension for the scene, relative to the project or absolute, so each is read as it would.
+static func quiet_scene_in(given: PackedStringArray, prefixes: Variant) -> String:
+	# A PackedStringArray as project.godot writes one, or an Array of strings as a hand might.
+	var folders: PackedStringArray = []
+	if prefixes is PackedStringArray:
+		folders = prefixes
+	elif prefixes is Array:
+		var listed: Array = prefixes
+		for prefix: Variant in listed:
+			if prefix is String:
+				var _kept: bool = folders.append(str(prefix))
+	for argument: String in given:
+		if argument.begins_with("-") or not SCENE_EXTENSIONS.has(argument.get_extension().to_lower()):
+			continue
+		var scene: String = ProjectSettings.localize_path(argument)
+		for folder: String in folders:
+			if not folder.is_empty() and scene.begins_with(folder):
+				return scene
+	return ""
+
+
 ## Whether the engine was told to run a script rather than the game.
 func _script_run() -> bool:
 	var given: PackedStringArray = OS.get_cmdline_args()

package/build/godot/addons/gdharness_runtime/runtime_capture.gd

@@ -10,6 +10,9 @@ const GdhScreen = preload("runtime_screen.gd")
 ## How far zoom enlarges at most. Sixteen makes a 3-pixel ring 48 pixels across, past any need to
 ## see it, and a 200-pixel region 3200, past the size anybody reads a picture at.
 const ZOOM_MOST: int = 16
+## Measured on a downstream game's 1280x720 frame: its interface text and pixel art read as they do
+## in the PNG, at a fifth of the PNG's size.
+const JPEG_QUALITY: float = 0.8
 
 var _host: Node
 var _values: GdhValues
@@ -385,16 +388,28 @@ func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false
 				% screenshot_path.get_base_dir()
 			)
 		)
-	var save_error: Error = image.save_png(screenshot_path)
+	var answer: Dictionary = saved(image, screenshot_path)
+	answer.merge(described)
+	return answer
+
+
+## [param image] saved as a PNG at [param png_path], and as a JPEG beside it, which the server sends
+## instead when it is the smaller: a rendered frame is several times smaller as one, and every
+## picture sent stays in the caller's session. Not for a picture with transparency, which a JPEG
+## would flatten.
+static func saved(image: Image, png_path: String) -> Dictionary:
+	var save_error: Error = image.save_png(png_path)
 	if save_error != OK:
 		return {"type": "error", "message": "Failed to save screenshot as PNG: " + str(save_error)}
-
 	var answer: Dictionary = {
 		"type": "screenshot_file",
 		"format": "png",
 		"width": image.get_width(),
 		"height": image.get_height(),
-		"path": screenshot_path
+		"path": png_path
 	}
-	answer.merge(described)
+	if image.detect_alpha() == Image.ALPHA_NONE:
+		var jpeg_path: String = png_path.get_basename() + ".jpg"
+		if image.save_jpg(jpeg_path, JPEG_QUALITY) == OK:
+			answer["jpegPath"] = jpeg_path
 	return answer

package/build/godot/addons/gdharness_runtime/runtime_hover.gd

@@ -9,7 +9,7 @@ extends RefCounted
 ## platform when the pointer crosses into the window, sets it. An injected event never crosses
 ## anything, and on gdharness's own desktop no pointer ever enters a window, so nothing was hovered.
 ## A BaseButton takes a mouse press only while hovered, so every click on a button in such a window
-## was dropped while the press itself was routed to it. Reported from Tall Tales Inn, whose strip
+## was dropped while the press itself was routed to it. Reported from Game C, whose strip
 ## window holds its first-run question, and traced through Godot 4.7.2's source.
 ##
 ## What is supplied is what the engine does once the window has been entered: the control its own

package/build/godot/addons/gdharness_runtime/runtime_paths.gd

@@ -257,7 +257,7 @@ static func can_read(holder: Variant, named: String) -> bool:
 ## counted as unclean for a read.
 ##
 ## A step written in double quotes is the key inside them, so a key holding a colon is one step:
-## Alchemill keys its stock by namespaced ids, "stock:\"base:dew\"", and split at that colon the
+## Game D keys its stock by namespaced ids, "stock:\"base:dew\"", and split at that colon the
 ## step named a key "base" the map had never had.
 static func _key_in(map: Dictionary, named: String) -> Array:
 	var word: String = key_written(named)

package/build/godot/operations/reading.gd

@@ -152,7 +152,7 @@ static func not_of_kind(
 	if not found.is_empty():
 		told += ' The node at "%s" is %s, not %s.' % [node_path, with_article(found), with_article(kind)]
 	if holders.is_empty():
-		return told + " The scene holds no %s." % kind
+		return told + " The scene holds no %s; scene_node add with nodeType %s puts one in it." % [kind, kind]
 	var quoted: PackedStringArray = []
 	for holder: String in holders.slice(0, NAMED_CHILDREN):
 		var _quoted: bool = quoted.append('"%s"' % holder)

package/build/godot/tests/listed.gd

@@ -0,0 +1,263 @@
+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
+## cases to leave out from the one named with [constant SKIPPING]. Every other argument is gdUnit4's
+## own, as `GdUnitCmdTool.gd` takes them.
+##
+## Started from outside the project, `-s` with this file's absolute path, so it declares no class of
+## its own and reaches gdUnit4 through the project's global classes. Besides the file of suites it
+## finds each case by its id in a dictionary ([GdhIndexedSession]), can compile the suites together
+## before gdUnit4 loads them ([constant TOGETHER]), can turn off the reports the caller does
+## not read ([constant REPORTS_OFF]), and writes the errors each suite declares it expects
+## ([constant EXPECTED_OUT]).
+
+const LISTED: String = "--suites-in"
+const SKIPPING: String = "--skipping-in"
+## 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.
+const REPORTS_OFF: Dictionary[String, String] = {
+	"--html-report-off": "res://addons/gdUnit4/src/core/hooks/GdUnitHtmlReporterTestSessionHook.gd",
+	"--junit-report-off": "res://addons/gdUnit4/src/core/hooks/GdUnitXMLReporterTestSessionHook.gd",
+}
+## Compiles the suites together beside every class of the game ([method compiled_together]) before
+## gdUnit4 loads them. A gate asks for it, since it runs every suite and wants every script that
+## does not compile named. project_test does not: its answer is about the scripts its run reached,
+## and the compile names every broken script of the game, then once more as the one script it made.
+const TOGETHER: String = "--compile-together"
+## The file to write the errors every suite declares it expects into, as JSON keyed by suite path and
+## then case name.
+const EXPECTED_OUT: String = "--expected-errors-out"
+## The constant a suite declares its expected errors in: case name to the exact texts it prints.
+const EXPECTED: String = "GDHARNESS_EXPECTED_ERRORS"
+## The tool name gdUnit4 reads its options after.
+const TOOL: String = "GdUnitCmdTool.gd"
+## How long a windowless engine sleeps after each frame. The engine's own default is the
+## low-processor pause, 6.8 ms measured, which a run of suites awaiting frames spends thousands of
+## times; zero makes a frame's delta round to nothing, and a tween then never moves.
+const FRAME_SLEEP_USEC: int = 1000
+
+var _runner: GdhRunner = null
+## The suites of the run, compiled by [method compiled_together] and held for as long as it runs.
+var _together: GDScript = null
+
+
+## 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:
+	extends GdUnitTestCIRunner
+
+	var own_path: String = ""
+
+	func get_cmdline_args() -> PackedStringArray:
+		return options_of(OS.get_cmdline_args(), own_path)
+
+	## 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)
+		super(event)
+
+	## [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)
+		var at: int = -1
+		for index: int in args.size():
+			if spelt(args[index]) == wanted:
+				at = index
+				break
+		if at < 0:
+			return args
+		var options: PackedStringArray = [TOOL]
+		options.append_array(args.slice(at + 1))
+		return options
+
+	static func spelt(path: String) -> String:
+		var forward: String = path.replace("\\", "/")
+		return forward.to_lower() if OS.get_name() == "Windows" else forward
+
+
+## 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
+## in an engine of 2300 cases).
+class GdhIndexedSession:
+	extends GdUnitTestSession
+
+	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:
+			_by_id[str(test.guid)] = test
+
+	func find_test_by_id(id: GdUnitGUID) -> GdUnitTestCase:
+		var found: GdUnitTestCase = _by_id.get(str(id), null)
+		return found
+
+	## [param made] as an indexed session of its cases, reporting where it does; one already indexed
+	## as it is.
+	static func of(made: GdUnitTestSession) -> GdUnitTestSession:
+		if made is GdhIndexedSession:
+			return made
+		return GdhIndexedSession.new(made._test_cases, made.report_path)
+
+
+func _initialize() -> void:
+	OS.low_processor_usage_mode_sleep_usec = FRAME_SLEEP_USEC
+	var asked: PackedStringArray = OS.get_cmdline_user_args()
+	var unread: PackedStringArray = []
+	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 suites: PackedStringArray = listed(asked, LISTED)
+	if asked.has(TOGETHER):
+		_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 = GdhRunner.new()
+	_runner.own_path = get_script().resource_path
+	_runner.add_test_suites(suites)
+	_runner.skip_test_suites(listed(asked, SKIPPING))
+	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()
+
+
+## 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
+
+
+## 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]
+
+
+## The errors each of [param suites] declares it expects, 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) -> 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(EXPECTED):
+			continue
+		var suite: Script = load(path)
+		var declared: Variant = suite.get_script_constant_map().get(EXPECTED)
+		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 _stored: bool = file.store_string(JSON.stringify(expected_by_suite(suites)))
+	file.close()