gdharness 1.3.12 → 1.3.13

package/build/godot/operations/project_file.gd

@@ -5,21 +5,25 @@ extends RefCounted
 ## The engine writes each section's keys in the order it registered them, and an engine running a
 ## script registers them in another order than the editor does, so a one-setting change moved lines
 ## nobody touched across several sections and a commit of it read as a rewrite. The save is still the
-## engine's, for what only it gets right: the header, each value's text and dropping a key that is
-## back at its default. Only the order is taken from the file as it was.
+## engine's, for what only it gets right: the header and each value's text. The order is taken from
+## the file as it was, and so is every line of a key the call did not change: the engine leaves out
+## each key at its default, so a project holding `unsafe_call_argument=0` on purpose lost the line to
+## a change of another key.
 
 const PATH: String = "res://project.godot"
 
 
 ## Saves the project's settings, keeping the sections and keys already in the file where they were.
-## A key or a section new to the file goes where the engine put it relative to its neighbours.
-static func save() -> Error:
+## A key or a section new to the file goes where the engine put it relative to its neighbours. Only
+## the settings in [param changed] may leave the file, as the engine leaves out one set back to its
+## default or erased.
+static func save(changed: PackedStringArray) -> Error:
 	var before: String = FileAccess.get_file_as_string(PATH)
 	var err: Error = ProjectSettings.save()
 	if err != OK or before.is_empty():
 		return err
 	var written: String = FileAccess.get_file_as_string(PATH)
-	var kept: String = in_order_of(before, written)
+	var kept: String = in_order_of(before, written, changed)
 	if kept == written:
 		return OK
 	var file: FileAccess = FileAccess.open(PATH, FileAccess.WRITE)
@@ -31,14 +35,33 @@ static func save() -> Error:
 	return OK
 
 
-## [param written] with its sections and their keys put in the order [param before] has them. Every
-## line of the result is a line of [param written], so nothing the engine wrote is lost or changed.
-static func in_order_of(before: String, written: String) -> String:
+## [param written] with its sections and their keys put in the order [param before] has them, and
+## each line [param before] has for a key [param written] lacks put back, unless that key's setting
+## is in [param changed]. Every other line of the result is a line of [param written], so nothing the
+## engine wrote is lost or changed.
+static func in_order_of(before: String, written: String, changed: PackedStringArray) -> String:
 	var old: Dictionary = _parsed(before)
 	var fresh: Dictionary = _parsed(written)
 	var old_sections: Array[Dictionary] = old["sections"]
 	var fresh_sections: Array[Dictionary] = fresh["sections"]
 
+	var by_name: Dictionary[String, Dictionary] = {}
+	var fresh_names: Array[String] = []
+	var entry_of: Dictionary[String, Dictionary] = {}
+	var fresh_keys: Dictionary[String, Array] = {}
+	for section: Dictionary in fresh_sections:
+		var name: String = section["name"]
+		by_name[name] = section
+		fresh_names.append(name)
+		var texts: Dictionary[String, String] = {}
+		var keys: Array[String] = []
+		for entry: Dictionary in section["entries"]:
+			var key: String = entry["key"]
+			texts[key] = str(entry["text"])
+			keys.append(key)
+		entry_of[name] = texts
+		fresh_keys[name] = keys
+
 	var old_names: Array[String] = []
 	var old_keys: Dictionary[String, Array] = {}
 	for section: Dictionary in old_sections:
@@ -48,39 +71,74 @@ static func in_order_of(before: String, written: String) -> String:
 		for entry: Dictionary in section["entries"]:
 			keys.append(str(entry["key"]))
 		old_keys[name] = keys
+		var kept: Array[Dictionary] = []
+		for entry: Dictionary in section["entries"]:
+			var key: String = entry["key"]
+			if (
+				not (by_name.has(name) and entry_of[name].has(key))
+				and not changed.has(_setting_of(name, key))
+			):
+				kept.append(entry)
+		if kept.is_empty():
+			continue
+		if not by_name.has(name):
+			by_name[name] = section
+			fresh_names.append(name)
+			entry_of[name] = {}
+			fresh_keys[name] = []
+		for entry: Dictionary in kept:
+			entry_of[name][str(entry["key"])] = str(entry["text"])
+			fresh_keys[name].append(str(entry["key"]))
 
-	var by_name: Dictionary[String, Dictionary] = {}
-	var fresh_names: Array[String] = []
+	# The blank lines closing a section belong to its place in the file rather than to the section,
+	# so the last one keeps the ending the engine gave the file wherever it moved from. A section put
+	# back sits between two others, which the engine parts with a blank line.
+	var names: Array[String] = _merged(old_names, fresh_names)
+	var tails: Array[String] = []
 	for section: Dictionary in fresh_sections:
-		var name: String = section["name"]
-		by_name[name] = section
-		fresh_names.append(name)
+		tails.append(str(section["tail"]))
+	while tails.size() < names.size():
+		# Not checked: a position inside the array cannot be refused.
+		var _inserted: int = tails.insert(maxi(tails.size() - 1, 0), "\n")
 
 	var text: String = fresh["preamble"]
-	var at: int = 0
-	for name: String in _merged(old_names, fresh_names):
-		var section: Dictionary = by_name[name]
-		var entries: Array[Dictionary] = section["entries"]
-		var entry_of: Dictionary[String, String] = {}
-		var fresh_keys: Array[String] = []
-		for entry: Dictionary in entries:
-			var key: String = entry["key"]
-			entry_of[key] = str(entry["text"])
-			fresh_keys.append(key)
+	for at: int in names.size():
+		var name: String = names[at]
 		var known: Array = old_keys.get(name, [])
 		var held: Array[String] = []
 		held.assign(known)
-		text += str(section["head"])
-		for key: String in _merged(held, fresh_keys):
-			text += entry_of[key]
-		# The blank lines closing a section belong to its place in the file rather than to the
-		# section, so the last one keeps the ending the engine gave the file wherever it moved from.
-		var placed: Dictionary = fresh_sections[at]
-		text += str(placed["tail"])
-		at += 1
+		var listed: Array = fresh_keys[name]
+		var wanted: Array[String] = []
+		wanted.assign(listed)
+		text += str(by_name[name]["head"])
+		for key: String in _merged(held, wanted):
+			text += str(entry_of[name][key])
+		text += tails[at]
 	return text
 
 
+## The setting [param key] in section [param section] stands for, as the engine names it: the
+## section and the key joined, a quoted key read without its quotes.
+static func _setting_of(section: String, key: String) -> String:
+	var bare: String = key
+	if bare.length() >= 2 and bare.begins_with('"') and bare.ends_with('"'):
+		bare = bare.substr(1, bare.length() - 2).c_unescape()
+	return bare if section.is_empty() else section + "/" + bare
+
+
+## Whether project.godot has a line for [param setting_path]. A setting at its default is in the
+## file only when the file says so, which the value alone cannot tell.
+static func sets(setting_path: String) -> bool:
+	var parsed: Dictionary = _parsed(FileAccess.get_file_as_string(PATH))
+	var sections: Array[Dictionary] = parsed["sections"]
+	for section: Dictionary in sections:
+		var entries: Array[Dictionary] = section["entries"]
+		for entry: Dictionary in entries:
+			if _setting_of(str(section["name"]), str(entry["key"])) == setting_path:
+				return true
+	return false
+
+
 ## The names of [param wanted] in the order [param held] lists them, those [param held] lacks each
 ## placed after the name [param wanted] puts before it. Names [param wanted] lacks are left out.
 static func _merged(held: Array[String], wanted: Array[String]) -> Array[String]:

package/build/godot/operations/serialisation.gd

@@ -222,6 +222,8 @@ func deserialize_value(value: Variant) -> Variant:
 	# to compile a script that gives a Variant to a typed parameter: the operations are compiled
 	# under the target project's warning levels, so one such project lost every headless call.
 	var tag: String = str(fields["_type"])
+	if GdhShapes.LIST_TAGS.has(tag):
+		return GdhShapes.packed_tagged(fields, fitted)
 	var builder: String = BUILDERS.get(tag, "")
 	if builder.is_empty() or not GdhShapes.buildable(fields, tag):
 		return fields

package/build/godot/operations/value_shapes.gd

@@ -20,6 +20,18 @@ const PACKED_ELEMENTS: Dictionary = {
 	TYPE_PACKED_VECTOR4_ARRAY: TYPE_VECTOR4,
 	TYPE_PACKED_COLOR_ARRAY: TYPE_COLOR,
 }
+## The tags of the packed arrays that cross as a plain list, and the type each builds.
+const LIST_TAGS: Dictionary = {
+	"PackedInt32Array": TYPE_PACKED_INT32_ARRAY,
+	"PackedInt64Array": TYPE_PACKED_INT64_ARRAY,
+	"PackedFloat32Array": TYPE_PACKED_FLOAT32_ARRAY,
+	"PackedFloat64Array": TYPE_PACKED_FLOAT64_ARRAY,
+	"PackedStringArray": TYPE_PACKED_STRING_ARRAY,
+	"PackedVector2Array": TYPE_PACKED_VECTOR2_ARRAY,
+	"PackedVector3Array": TYPE_PACKED_VECTOR3_ARRAY,
+	"PackedVector4Array": TYPE_PACKED_VECTOR4_ARRAY,
+	"PackedColorArray": TYPE_PACKED_COLOR_ARRAY,
+}
 
 # What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
 # tag somebody wrote by mistake or wrote for a different shape, and building one out of defaults
@@ -44,6 +56,15 @@ const REQUIRED: Dictionary = {
 	"Color": [["r", "g", "b"]],
 	"NodePath": [["path"]],
 	"PackedByteArray": [["base64"]],
+	"PackedInt32Array": [["value"]],
+	"PackedInt64Array": [["value"]],
+	"PackedFloat32Array": [["value"]],
+	"PackedFloat64Array": [["value"]],
+	"PackedStringArray": [["value"]],
+	"PackedVector2Array": [["value"]],
+	"PackedVector3Array": [["value"]],
+	"PackedVector4Array": [["value"]],
+	"PackedColorArray": [["value"]],
 	"float": [["value"]],
 	"int": [["value"]],
 	"RID": [["id"]],
@@ -79,6 +100,10 @@ static func written_as(type: int) -> String:
 	var alternatives: Array = REQUIRED.get(tag, [])
 	if alternatives.is_empty() or tag in ["float", "int", "Dictionary"]:
 		return ""
+	# A packed list is written as the plain list wherever its type is declared, so its tag is no
+	# remedy there.
+	if PACKED_ELEMENTS.has(type) and type != TYPE_PACKED_BYTE_ARRAY:
+		return ""
 	var keys: Array = alternatives[0]
 	var optional: Array = OPTIONAL.get(tag, [])
 	var parts: Array[String] = []
@@ -172,6 +197,20 @@ static func fraction(value: Variant, type: int, elements: Array = []) -> bool:
 	return false
 
 
+## A packed array tagged with its type, {"_type": "PackedStringArray", "value": [...]}, for where
+## nothing declares what a plain list is to become: a setting the engine does not declare, or a
+## Variant property, takes a list as an Array. Each item is fitted as a declared list's would be,
+## and a list with an item that does not fit stays the tag it arrived as, for the caller to refuse.
+static func packed_tagged(fields: Dictionary, fit: Callable) -> Variant:
+	var tag: String = str(fields["_type"])
+	if not buildable(fields, tag) or not fields["value"] is Array:
+		return fields
+	var type: int = LIST_TAGS[tag]
+	var items: Array = fields["value"]
+	var built: Variant = packed_from(items, type, fit)
+	return built if typeof(built) == type else fields
+
+
 ## The packed array [param type] built from [param items], each fitted by [param fit] to what the
 ## array holds, or [param items] as they are when one cannot become that, for the caller to refuse.
 ## Element by element, so a point given as its fields is read as one: converted whole, a list of

package/build/godot/tests/listed.gd

@@ -48,14 +48,22 @@ const EXPECTED: Dictionary[String, String] = {
 }
 ## The tool name gdUnit4 reads its options after.
 const TOOL: String = "GdUnitCmdTool.gd"
+## Ends the runner's own arguments: everything after it is gdUnit4's options, for a run with no
+## script path on its command line to find them after.
+const GDUNIT: String = "--gdh-gdunit"
 ## 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
+## What the engine's shutdown prints as it clears the newest script and the oldest, on an engine
+## whose walk [GdhShutdownWalk] guards. Kept in step with the server's engine-leaks.ts, which reads
+## a run printing the first and not the second as a walk that stopped part way.
+const WALK_BEGAN: String = "gdharness: the engine's shutdown began clearing scripts"
+const WALK_ENDED: String = "gdharness: the engine's shutdown cleared every script"
+## The meta of the theme database holding the scripts [method GdhShutdownWalk.hold] keeps.
+const WALK_HOLD: StringName = &"gdharness_scripts_held_past_the_shutdown_walk"
 
 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,
@@ -64,12 +72,38 @@ class GdhRunner:
 	extends GdUnitTestCIRunner
 
 	var own_path: String = ""
+	## gdUnit4's options when they were given after [constant GDUNIT] rather than read from the
+	## engine's command line, as the suites scene gives them: a played scene has no script path to
+	## find them after.
+	var given: PackedStringArray = []
+	## The suites compiled by [method compiled_together], held for as long as the run goes on.
+	var together: GDScript = null
 	## 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
+	## The marker of the shutdown walk's oldest end, made as the run starts.
+	var walk_scripts: Array[GDScript] = []
+
+	## As the run ends, the marker of the walk's newest end, and every script held past the walk, on
+	## an engine whose walk can stop part way ([GdhShutdownWalk]).
+	func _notification(what: int) -> void:
+		if what != NOTIFICATION_EXIT_TREE or not GdhShutdownWalk.guarded():
+			return
+		var also: Array[GDScript] = walk_scripts.duplicate()
+		also.append_array(GdhShutdownWalk.marker(WALK_BEGAN))
+		if together != null:
+			also.append(together)
+		var own: GDScript = ResourceLoader.get_cached_ref(own_path) as GDScript
+		if own != null:
+			also.append(own)
+		GdhShutdownWalk.hold(also)
 
 	func get_cmdline_args() -> PackedStringArray:
+		if not given.is_empty():
+			var options: PackedStringArray = [TOOL]
+			options.append_array(given)
+			return options
 		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
@@ -200,9 +234,92 @@ class GdhSessionCheck:
 		)
 
 
+## The engine's shutdown walk over its scripts, on an engine below 4.8. It clears them from the
+## newest, and a script whose release frees the next one, as the last reference to its base can,
+## leaves the walk on freed memory, where it ends (godot#117991, fixed in 4.8 by godot#120976).
+## Every script it never reached keeps what it holds, which the engine then reports as leaked at
+## exit, so a run of suites that leaked nothing failed on it.
+class GdhShutdownWalk:
+	extends RefCounted
+
+	## Whether the engine of [param version] is one whose walk can stop part way.
+	static func guarded(version: Dictionary = Engine.get_version_info()) -> bool:
+		var major: int = version.get("major", 0)
+		var minor: int = version.get("minor", 0)
+		return major == 4 and minor < 8
+
+	## A script the walk clears as it passes it, printing [param said] then, made now so it takes
+	## this place in the walk. It holds an instance of itself, which keeps it alive past the engine
+	## dropping its cache of scripts until the walk clears it, and the instance that prints, whose
+	## script is older and so is not cleared yet.
+	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"
+		)
+		var marking: GDScript = GDScript.new()
+		marking.source_code = (
+			"extends RefCounted\n\nstatic var kept: RefCounted = null\n"
+			+ "static var printing: RefCounted = null\n"
+		)
+		if printing.reload() != OK or marking.reload() != OK:
+			push_error("gdharness test could not make the marker of the engine's shutdown: " + said)
+			return []
+		var instance: Object = printing.new()
+		instance.set("said", said)
+		marking.set("kept", marking.new())
+		marking.set("printing", instance)
+		return [printing, marking]
+
+	## Every script loaded from a file under res://, and [param also], held until the theme database
+	## goes, which is after the walk and before the GDScript language does. Freed in the walk, a
+	## script can take the next one with it and end the walk; held, none is freed there, so the walk
+	## reaches every script and what the engine reports at exit is only what was leaked. A script a
+	## run leaks is held by what leaked it as well, and is still reported.
+	static func hold(also: Array[GDScript]) -> void:
+		var held: Array[GDScript] = also.duplicate()
+		var pending: PackedStringArray = ["res://"]
+		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):
+				var path: String = directory.path_join(file)
+				if file.ends_with(".gd") and ResourceLoader.has_cached(path):
+					var script: GDScript = ResourceLoader.get_cached_ref(path) as GDScript
+					if script != null:
+						held.append(script)
+			for inner: String in DirAccess.get_directories_at(directory):
+				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 asked: PackedStringArray = OS.get_cmdline_user_args()
+	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):
@@ -221,28 +338,22 @@ func _initialize() -> void:
 				)
 			)
 	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):
-		_together = compiled_together(suites)
+		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 = GdhRunner.new()
-	_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))
+	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)
-
-
-## 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()
+	hooks.enigne_hooks.append(GdhSessionCheck.new(runner))
+	return runner
 
 
 ## Turns off the hooks among [param hooks] whose scripts [param unread] names, answering the scripts