gdharness 1.0.23 → 1.0.25

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

@@ -6,6 +6,51 @@ extends RefCounted
 
 const Values = preload("runtime_values.gd")
 
+## The calls a path makes on a list or a map: those that take no arguments and change nothing.
+##
+## Named rather than asked of the engine, because asking about a method a list does not have logs an
+## error into the game's output, and a typo in a path is not the game's error. The ones that change
+## what they are called on, such as clear(), sort() and pop_back(), are left out: a path is how a
+## read and a wait reach what they read, and a wait asks many times.
+const LIST_CALLS: Array[String] = [
+	"size",
+	"is_empty",
+	"front",
+	"back",
+	"max",
+	"min",
+	"pick_random",
+	"hash",
+	"duplicate",
+	"duplicate_deep",
+	"is_read_only",
+	"is_typed",
+	"get_typed_builtin",
+	"get_typed_class_name",
+	"get_typed_script",
+]
+const MAP_CALLS: Array[String] = [
+	"size",
+	"is_empty",
+	"keys",
+	"values",
+	"hash",
+	"duplicate",
+	"duplicate_deep",
+	"is_read_only",
+	"is_typed",
+	"is_typed_key",
+	"is_typed_value",
+	"get_typed_key_builtin",
+	"get_typed_key_class_name",
+	"get_typed_key_script",
+	"get_typed_value_builtin",
+	"get_typed_value_class_name",
+	"get_typed_value_script",
+]
+## The calls an empty list has nothing to answer, which the engine reports as an error when asked.
+const NEEDS_AN_ELEMENT: Array[String] = ["front", "back", "pick_random"]
+
 
 ## What [param reaching] names something on, which is the node itself until the name has a colon
 ## in it, and the last name along that path.
@@ -23,7 +68,9 @@ const Values = preload("runtime_values.gd")
 ## and walks into what it returned. Some of what hangs off a node is only reachable by asking:
 ## which control holds the focus is a question for the viewport a control is in, and the viewport
 ## is a method's answer rather than a property. Spelled with the brackets so a reader sees a call
-## where one happens, and so a method can never shadow a property of the same name.
+## where one happens, and so a method can never shadow a property of the same name. A list or a map
+## answers the calls that read it, "board:size()" or "inbox:keys()", listed in [constant LIST_CALLS]
+## and [constant MAP_CALLS].
 ##
 ## Answers with a `message` instead when a step along the way is not there or holds something that
 ## is not an object, naming the step rather than the whole path: "/root/Main:_game has no property
@@ -117,9 +164,14 @@ static func nothing_under(holder: Variant, named: String, called: String) -> Str
 static func can_read(holder: Variant, named: String) -> bool:
 	if holder is Array:
 		var items: Array = holder
+		var list_call: String = method_of(named)
+		if not list_call.is_empty():
+			return list_call in LIST_CALLS and not (items.is_empty() and list_call in NEEDS_AN_ELEMENT)
 		return _index_in(named, items.size()) != -1
 	if holder is Dictionary:
 		var map: Dictionary = holder
+		if not method_of(named).is_empty():
+			return method_of(named) in MAP_CALLS
 		return map.has(named) or map.has(StringName(named))
 	if holder is Object:
 		var object: Object = holder
@@ -173,6 +225,8 @@ static func write(holder: Variant, named: String, value: Variant) -> void:
 ## What [param holder] holds under [param named], or answers to it when [param named] is a call.
 ## Only ever called once [method can_read] agrees.
 static func read_under(holder: Variant, named: String) -> Variant:
+	if (holder is Array or holder is Dictionary) and not method_of(named).is_empty():
+		return Callable.create(holder, method_of(named)).call()
 	if holder is Array:
 		var items: Array = holder
 		return items[_index_in(named, items.size())]
@@ -207,10 +261,17 @@ static func _index_in(named: String, size: int) -> int:
 ## so a list says how long it is and a map says what it is keyed by. The step is named rather than
 ## the whole path, because the step is the typo.
 static func nothing_there(holder: Variant, named: String, called_as: String) -> String:
+	var container_call: String = method_of(named)
 	if holder is Array:
 		var items: Array = holder
+		if container_call in NEEDS_AN_ELEMENT and items.is_empty():
+			return "%s is an empty list, so it has no %s" % [called_as, named]
+		if not container_call.is_empty():
+			return container_calls_refused(called_as, "a list", container_call)
 		return "%s is a list of %d, so there is no %s in it" % [called_as, items.size(), named]
 	if holder is Dictionary:
+		if not container_call.is_empty():
+			return container_calls_refused(called_as, "a map", container_call)
 		var map: Dictionary = holder
 		var keys: Array = map.keys()
 		# Eight of them, because a map keyed by something unexpected is told by the first few and a
@@ -242,6 +303,19 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 	return "%s has no property %s" % [called_as, named]
 
 
+## Why [param method] is not a call a path makes on [param sort] ("a list" or "a map"), naming
+## the calls it does make.
+static func container_calls_refused(called_as: String, sort: String, method: String) -> String:
+	var calls: Array[String] = LIST_CALLS if sort == "a list" else MAP_CALLS
+	var spelled: Array[String] = []
+	for each: String in calls:
+		spelled.append(each + "()")
+	return (
+		"%s is %s, and %s() is not one of the calls a path makes on one, which read it and take no arguments: %s"
+		% [called_as, sort, method, ", ".join(spelled)]
+	)
+
+
 ## Whether [param holder] declares [param named]. Asked of the list rather than read, because a
 ## property read back as null answers it wrongly.
 static func _has_property(holder: Object, named: String) -> bool:

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

@@ -379,11 +379,17 @@ static func _drawn(node: Node) -> bool:
 ## Public because three questions are the same question: what a screen reads as, which nodes say a
 ## given word, and whether anything has come to say it yet. Two copies of what a node says is how
 ## the three of them come to disagree about a SpinBox.
+##
+## Read rather than looked up in the property list, which the engine builds afresh on every call: a
+## wait asks this of every node on the screen every frame, and on a hall of 3,500 nodes the lookup
+## took the game it was watching from 60 frames a second to 11. A node without the property reads
+## as null, which is not a string.
 static func said_by(node: Node) -> String:
-	for property: Dictionary in node.get_property_list():
-		if str(property.get("name", "")) == "text" and Read.as_int(property.get("type", 0)) == TYPE_STRING:
-			return str(node.get("text")).strip_edges()
-	return ""
+	var text: Variant = node.get("text")
+	if not text is String:
+		return ""
+	var words: String = text
+	return words.strip_edges()
 
 
 func get_rect(params: Dictionary) -> Dictionary:
@@ -695,17 +701,33 @@ func call_method(params: Dictionary) -> Dictionary:
 	if reached.has("message"):
 		return reached
 
-	# A list or a map can be stepped through on the way, and is not a thing with methods when the
-	# path stops on one: said in those terms rather than as "has no method", which reads as a
-	# misspelling of a method that was never going to be there.
+	# A list or a map answers the calls a path makes on one, and nothing else: said in those terms
+	# rather than as "has no method", which reads as a misspelling of a method that was never going
+	# to be there, and with the element spelled out, since a method on what it holds is the usual aim.
 	if not reached["holder"] is Object:
 		var sort: String = "a list" if reached["holder"] is Array else "a map"
+		var spelled: String = str(reached["name"])
+		if Paths.method_of(spelled).is_empty():
+			spelled += "()"
+		if args.is_empty() and Paths.can_read(reached["holder"], spelled):
+			var answered: Variant = Paths.read_under(reached["holder"], spelled)
+			return {
+				"type": "method_result",
+				"path": node_path,
+				"method": method,
+				"result": _values.serialize(answered),
+			}
+		var why: String = (
+			"%s:%s takes no arguments" % [reached["called"], spelled]
+			if Paths.can_read(reached["holder"], spelled)
+			else Paths.nothing_there(reached["holder"], spelled, str(reached["called"]))
+		)
 		return {
 			"type": "error",
 			"message":
 			(
-				"%s is %s, which has no methods: name the element to call it on, as in %s:0:%s"
-				% [reached["called"], sort, reached["called"], reached["name"]]
+				"%s. A method of what %s holds is called on the element, as in %s:0:%s"
+				% [why, sort, reached["called"], reached["name"]]
 			)
 		}
 	var holder: Object = reached["holder"]

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

@@ -15,6 +15,10 @@ const CEILING_MSEC: int = 120000
 ## The most frames one wait may cover, which is about half a minute of a game drawing slowly.
 const MOST_FRAMES: int = 600
 
+## How long a wait for words leaves between looks, as a multiple of what the last look took: nine
+## gives looking about a tenth of the time.
+const LOOKS_APART: int = 9
+
 var _host: Node
 var _values: Values
 
@@ -140,6 +144,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": refused}
 
 	var started: int = Time.get_ticks_msec()
+	var frames: int = 0
 	# The type is checked every time round, not only at the top: a property that holds an object a
 	# frame later is the same error arriving late.
 	while (
@@ -148,6 +153,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 		and Time.get_ticks_msec() - started < timeout_ms
 	):
 		await _host.get_tree().process_frame
+		frames += 1
 		if not is_instance_valid(node):
 			return {"type": "error", "message": "%s was freed while waiting" % node_path}
 		watched = _watched(node, node_path, property)
@@ -162,6 +168,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 		"met": Values.comparable(current, wanted) and current == wanted,
 		"value": _values.serialize(current),
 		"elapsed_ms": Time.get_ticks_msec() - started,
+		"frames": frames,
 	}
 
 
@@ -232,13 +239,36 @@ static func _watched(node: Node, node_path: String, property: String) -> Diction
 ## answered met in two milliseconds while the sweep was still animating, and every wait on that
 ## screen fell back to counting frames. [param include_hidden] asks the other question, for a
 ## caller waiting on words a hidden node holds.
+##
+## Paced by what a look costs, so the watching leaves the game its speed: every frame while a look is
+## cheap, and on a screen large enough for one to cost a real share of a frame, often enough that
+## looking takes about a tenth of the time. Every frame on a hall of 3,500 nodes held the game at a
+## sixth of its frame rate, and its clock, which advances by the frame's delta, lost three quarters
+## of its time, so a wait for a date timed out on a clock that turned a day every thirty seconds.
+## The answer says how many frames the wait spanned and how many looks it took, which is how a
+## caller sees what it cost.
 func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_hidden: bool) -> Dictionary:
 	var started: int = Time.get_ticks_msec()
 	var words: String = Queries.as_said(said)
-	var found: bool = _anything_says(node_path, words, include_hidden)
-	while not found and Time.get_ticks_msec() - started < timeout_ms:
+	var frames: int = 0
+	var looks: int = 0
+	var next_look: int = 0
+	var found: bool = false
+	while true:
+		if Time.get_ticks_usec() >= next_look:
+			var looking: int = Time.get_ticks_usec()
+			found = _anything_says(node_path, words, include_hidden)
+			looks += 1
+			next_look = Time.get_ticks_usec() + (Time.get_ticks_usec() - looking) * LOOKS_APART
+		if found or Time.get_ticks_msec() - started >= timeout_ms:
+			break
 		await _host.get_tree().process_frame
+		frames += 1
+	# One more look at the end, so words that arrived between two paced looks are not answered as
+	# never having come.
+	if not found:
 		found = _anything_says(node_path, words, include_hidden)
+		looks += 1
 
 	return {
 		"type": "condition",
@@ -247,6 +277,8 @@ func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_
 		"met": found,
 		"include_hidden": include_hidden,
 		"elapsed_ms": Time.get_ticks_msec() - started,
+		"frames": frames,
+		"looks": looks,
 	}