gdharness 1.3.12 → 1.3.14

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

@@ -19,6 +19,9 @@ const DIGEST_MARKER: String = "res://addons/gdharness_editor/.gdharness-digest"
 ## step with `announcementPath` in src/bridge-announce.ts.
 const ANNOUNCEMENT: String = "res://.godot/gdharness-bridge.json"
 const ANNOUNCE_PROTOCOL: int = 1
+## Where each editor of this project says which ports it serves; see [method _ports_record].
+const EDITORS_RECORDED: String = "res://.godot/gdharness-editors"
+const EDITORS_RECORDED_PROTOCOL: int = 1
 const RECONNECT_DELAY: float = 3.0
 const MAX_RECONNECT_DELAY: float = 30.0
 
@@ -128,6 +131,52 @@ func _ready() -> void:
 
 	set_process(true)
 	_initialized = true
+	_record_ports()
+
+
+func _exit_tree() -> void:
+	var record: String = _ports_record()
+	if FileAccess.file_exists(record):
+		var _removed: Error = DirAccess.remove_absolute(record)
+
+
+## The file saying which ports this editor serves, named by its process id, so `gdharness lsp` can
+## find its language server when a server moved it off the default. One for each process rather
+## than one for the project, because a gate's `--import` loads this addon too, and its plugin is
+## shown none of the options that would say so; the reader tells the two apart by command line.
+## Kept in step with `editorRecordsIn` in src/lsp-bridge.ts.
+static func _ports_record() -> String:
+	return ProjectSettings.globalize_path(EDITORS_RECORDED).path_join("%d.json" % OS.get_process_id())
+
+
+func _record_ports() -> void:
+	if not Engine.is_editor_hint():
+		return
+	var made: Error = DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(EDITORS_RECORDED))
+	if made != OK and made != ERR_ALREADY_EXISTS:
+		return
+	var file: FileAccess = FileAccess.open(_ports_record(), FileAccess.WRITE)
+	if file == null:
+		return
+	var written: bool = (
+		file
+		. store_string(
+			(
+				JSON
+				. stringify(
+					{
+						"protocol": EDITORS_RECORDED_PROTOCOL,
+						"pid": OS.get_process_id(),
+						"lsp_port": _serves(LSP_ASKED, LSP_SETTING),
+						"dap_port": _serves(DAP_ASKED, DAP_SETTING),
+						"written_at_ms": int(Time.get_unix_time_from_system() * 1000.0),
+					}
+				)
+			)
+		)
+	)
+	if not written:
+		push_warning("gdharness: could not write " + _ports_record())
 
 
 func _process(_delta: float) -> void:

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

@@ -77,10 +77,13 @@ func is_installed_by_gdharness(path: String) -> bool:
 	return FileAccess.file_exists(path + ".gdharness-version")
 
 
-# Files under `path` whose name ends with `extension`, which is passed with its dot.
-func find_files(path: String, extension: String) -> Array[String]:
+# Files under `path` whose name ends with `extension`, which is passed with its dot. An addon
+# gdharness installed is walked into when [param with_ours] is set, for a caller rebuilding what
+# the engine itself would: the engine lists the global classes of every addon, and a list rebuilt
+# without ours dropped the one class the tests addon declares.
+func find_files(path: String, extension: String, with_ours: bool = false) -> Array[String]:
 	var files: Array[String] = []
-	if is_stepped_over(path) or is_installed_by_gdharness(path):
+	if is_stepped_over(path) or (not with_ours and is_installed_by_gdharness(path)):
 		return files
 
 	var dir: DirAccess = DirAccess.open(path)
@@ -92,7 +95,7 @@ func find_files(path: String, extension: String) -> Array[String]:
 
 		while file_name != "":
 			if dir.current_is_dir() and not file_name.begins_with("."):
-				files.append_array(find_files(path + file_name + "/", extension))
+				files.append_array(find_files(path + file_name + "/", extension, with_ours))
 			elif file_name.ends_with(extension):
 				files.append(path + file_name)
 

package/build/godot/addons/gdharness_editor/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/addons/gdharness_editor/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/addons/gdharness_runtime/runtime_autoload.gd

@@ -71,6 +71,10 @@ const SCRIPT_RUNS_SETTING: String = "gdharness/runtime/serve_script_runs"
 ## not served. Kept in step with `QUIET_SCENES_SETTING` in src/setup.ts.
 const QUIET_SCENES_SETTING: String = "gdharness/runtime/quiet_scenes_under"
 
+## What every user argument `gdharness spread` hands its engines starts with. Kept in step with
+## the constants of GdhShare in addons/gdharness_tests/share.gd.
+const SPREAD_ARGUMENTS: String = "--gdh-share"
+
 ## 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"]
 
@@ -489,6 +493,12 @@ func _start_server() -> void:
 		_enabled = false
 		return
 
+	# Nor an engine `gdharness spread` started, whatever folder its scene is in: its workers and the
+	# engine gathering their outcomes play a bench rather than the game, several at once.
+	if spread_engine(OS.get_cmdline_user_args()):
+		_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))
@@ -540,6 +550,15 @@ static func quiet_scene_in(given: PackedStringArray, prefixes: Variant) -> Strin
 	return ""
 
 
+## Whether [param given], the engine's user arguments, are those `gdharness spread` hands its
+## engines, which the tests addon's GdhShare reads.
+static func spread_engine(given: PackedStringArray) -> bool:
+	for argument: String in given:
+		if argument.begins_with(SPREAD_ARGUMENTS):
+			return true
+	return false
+
+
 ## 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_changes.gd

@@ -694,12 +694,27 @@ static func _reads_the_result(asked: Variant) -> bool:
 
 ## What [param asked] reads off the object a call answered with: every variable its script declares
 ## when [param asked] is true, or the properties a list names, each a path walked from the object.
+## Off each object of a list or a dictionary the call answered with too, in the result's shape.
 ##
-## In the same answer because an object handed back is otherwise only its class and an id, and
-## reading one field of it meant finding the same object again by a path into the game's private
-## state, which works only where the caller already knows a key. A name that is not there is listed
-## rather than refusing the answer, since the call has run by then and its result is what was asked.
+## In the same answer because an object handed back is otherwise only its class and its instance
+## id, and reading one field of it meant finding the same object again by a path into the game's
+## private state, which works only where the caller already knows a key; a catalogue of records
+## handed back as a list took one call per record. A name that is not there is listed rather than
+## refusing the answer, since the call has run by then and its result is what was asked.
 func _read_off_result(result: Variant, asked: Variant) -> Dictionary:
+	var missing: Array[String] = []
+	if result is Array:
+		var list: Array = result
+		var read_each: Array = []
+		for index: int in list.size():
+			read_each.append(_read_off_element(list[index], "[%d]" % index, asked, missing))
+		return _read_off_many(read_each, list, "Array", missing)
+	if result is Dictionary:
+		var map: Dictionary = result
+		var read_by_key: Dictionary = {}
+		for key: Variant in map:
+			read_by_key[str(key)] = _read_off_element(map[key], "[%s]" % str(key), asked, missing)
+		return _read_off_many(read_by_key, map.values(), "Dictionary", missing)
 	if result is Object and not is_instance_valid(result):
 		return {
 			"properties_note": "the call answered an object that has since been freed, so nothing was read"
@@ -710,6 +725,49 @@ func _read_off_result(result: Variant, asked: Variant) -> Dictionary:
 			"the call answered %s, which has no properties to read" % type_string(typeof(result))
 		}
 	var object: Object = result
+	var one: Dictionary = _read_off_object(object, asked)
+	missing = one["missing"]
+	var answered: Dictionary = {"result_properties": one["read"]}
+	if not missing.is_empty():
+		answered["result_properties_missing"] = missing
+	return answered
+
+
+## What was read off one element of a list or a dictionary a call answered with, or null for one
+## that is no object; why a name was not there goes into [param missing], led by [param named].
+func _read_off_element(element: Variant, named: String, asked: Variant, missing: Array[String]) -> Variant:
+	if not element is Object:
+		return null
+	if not is_instance_valid(element):
+		missing.append("%s is an object that has since been freed" % named)
+		return null
+	var object: Object = element
+	var one: Dictionary = _read_off_object(object, asked)
+	var whys: Array[String] = one["missing"]
+	for why: String in whys:
+		missing.append("%s %s" % [named, why])
+	return one["read"]
+
+
+## The answer for a list or a dictionary, [param read] holding what each element gave, unless none
+## of [param elements] is an object.
+static func _read_off_many(
+	read: Variant, elements: Array, shape: String, missing: Array[String]
+) -> Dictionary:
+	if not elements.any(func(element: Variant) -> bool: return element is Object):
+		return {
+			"properties_note":
+			"the call answered %s with no object in it, so there are no properties to read" % shape
+		}
+	var answered: Dictionary = {"result_properties": read}
+	if not missing.is_empty():
+		answered["result_properties_missing"] = missing
+	return answered
+
+
+## What [param asked] reads off [param object], under read, and why each name it could not read is
+## not there, under missing.
+func _read_off_object(object: Object, asked: Variant) -> Dictionary:
 	var wanted: Array[String] = []
 	if asked is Array:
 		for name: Variant in asked:
@@ -724,10 +782,7 @@ func _read_off_result(result: Variant, asked: Variant) -> Dictionary:
 			missing.append(str(walked["message"]))
 		else:
 			read[path] = _values.serialize(walked["value"])
-	var answered: Dictionary = {"result_properties": read}
-	if not missing.is_empty():
-		answered["result_properties_missing"] = missing
-	return answered
+	return {"read": read, "missing": missing}
 
 
 ## The variables the script attached to [param object] declares, in the order it declares them.

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

@@ -892,10 +892,12 @@ class GdhTrace:
 		elif value is Dictionary:
 			var map: Dictionary = value
 			_last = map.duplicate(true)
+		# Game time unrounded: a frame can be a tenth of a millisecond long, and a rate worked out over
+		# one from times cut to a ten-thousandth was off by its own size.
 		var change: Dictionary = {
 			"frame": frame,
 			"elapsed_ms": elapsed,
-			"game_time": snappedf(game_time, 0.0001),
+			"game_time": game_time,
 			"value": values.serialize(value),
 		}
 		if changes.size() < MOST_CHANGES:

package/build/godot/addons/gdharness_runtime/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/addons/gdharness_runtime/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/addons/gdharness_tests/bench.gd

@@ -0,0 +1,28 @@
+class_name GdhBench
+extends RefCounted
+
+## Work played a step a frame, for the script profiler. The engine sends the profiler what each
+## frame called and holds names for only so many functions a frame, so work played inside one frame
+## comes back with most of its functions unnamed; spread over frames, every step is named.
+##
+##     func _ready() -> void:
+##         var timed: Dictionary = await GdhBench.each_frame(get_tree(), 400, _run.advance)
+##         print("bench: %d days, %.2f ms a day" % [timed["steps"], timed["ms_each"]])
+##         get_tree().quit()
+
+
+## Calls [param step] once a frame, up to [param most] times, and stops early when it returns
+## false. Answers how many steps ran under "steps", and under "ms_each" the wall-clock milliseconds a
+## step took on average, the step alone and not the frame around it.
+static func each_frame(tree: SceneTree, most: int, step: Callable) -> Dictionary:
+	var steps: int = 0
+	var spent_usec: int = 0
+	while steps < most:
+		await tree.process_frame
+		var began: int = Time.get_ticks_usec()
+		var going: Variant = step.call()
+		spent_usec += Time.get_ticks_usec() - began
+		steps += 1
+		if going is bool and going == false:
+			break
+	return {"steps": steps, "ms_each": spent_usec / 1000.0 / maxf(1.0, float(steps))}

package/build/godot/addons/gdharness_tests/bench.gd.uid

@@ -0,0 +1 @@
+uid://dk4ffqm2xbsn7

package/build/godot/addons/gdharness_tests/event.gd

@@ -0,0 +1,92 @@
+class_name GdhEvent
+extends RefCounted
+## Input events built in one line, for a case that hands them to a control or to the engine.
+##
+## A position is the point in the window, which is where `Input.parse_input_event` delivers the
+## event and what a control's own `_gui_input` reads when it is handed the event directly. The
+## global position is set to the same point, as the window's own events carry it, for code that
+## reads that field instead.
+
+
+## [param button] pressed at [param at], or released when [param pressed] is false.
+static func click(
+	at: Vector2, button: MouseButton = MOUSE_BUTTON_LEFT, pressed: bool = true
+) -> InputEventMouseButton:
+	var made: InputEventMouseButton = InputEventMouseButton.new()
+	made.button_index = button
+	made.pressed = pressed
+	made.position = at
+	made.global_position = at
+	if pressed:
+		made.button_mask = _mask_of(button)
+	return made
+
+
+## The release of [param button] at [param at], which ends the press [method click] began.
+static func release(at: Vector2, button: MouseButton = MOUSE_BUTTON_LEFT) -> InputEventMouseButton:
+	return click(at, button, false)
+
+
+## One turn of the wheel at [param at], up or down. The engine sends a wheel turn as a press.
+static func wheel(at: Vector2, up: bool = true) -> InputEventMouseButton:
+	return click(at, MOUSE_BUTTON_WHEEL_UP if up else MOUSE_BUTTON_WHEEL_DOWN)
+
+
+## The mouse moved to [param at] by [param moved], holding [param held], a mask of buttons such
+## as MOUSE_BUTTON_MASK_LEFT for a drag.
+static func motion(at: Vector2, moved: Vector2 = Vector2.ZERO, held: int = 0) -> InputEventMouseMotion:
+	var made: InputEventMouseMotion = InputEventMouseMotion.new()
+	made.position = at
+	made.global_position = at
+	made.relative = moved
+	made.button_mask = held
+	return made
+
+
+## [param key_pressed] pressed, or released when [param pressed] is false. The key is set as both the
+## keycode and the physical keycode, so a binding to either matches it.
+static func key(key_pressed: Key, pressed: bool = true) -> InputEventKey:
+	var made: InputEventKey = InputEventKey.new()
+	made.keycode = key_pressed
+	made.physical_keycode = key_pressed
+	made.pressed = pressed
+	return made
+
+
+## [param button] of the pad [param device] pressed, or released when [param pressed] is false.
+static func pad(button: JoyButton, pressed: bool = true, device: int = 0) -> InputEventJoypadButton:
+	var made: InputEventJoypadButton = InputEventJoypadButton.new()
+	made.button_index = button
+	made.pressed = pressed
+	made.pressure = 1.0 if pressed else 0.0
+	made.device = device
+	return made
+
+
+## [param axis_moved] of the pad [param device] at [param value], from -1 to 1.
+static func axis(axis_moved: JoyAxis, value: float, device: int = 0) -> InputEventJoypadMotion:
+	var made: InputEventJoypadMotion = InputEventJoypadMotion.new()
+	made.axis = axis_moved
+	made.axis_value = value
+	made.device = device
+	return made
+
+
+## The action [param action_named] pressed at [param strength], or released when [param pressed] is false.
+static func action(action_named: StringName, pressed: bool = true, strength: float = 1.0) -> InputEventAction:
+	var made: InputEventAction = InputEventAction.new()
+	made.action = action_named
+	made.pressed = pressed
+	made.strength = strength if pressed else 0.0
+	return made
+
+
+static func _mask_of(button: MouseButton) -> int:
+	match button:
+		MOUSE_BUTTON_LEFT:
+			return MOUSE_BUTTON_MASK_LEFT
+		MOUSE_BUTTON_RIGHT:
+			return MOUSE_BUTTON_MASK_RIGHT
+		MOUSE_BUTTON_MIDDLE:
+			return MOUSE_BUTTON_MASK_MIDDLE
+	return 0

package/build/godot/addons/gdharness_tests/event.gd.uid

@@ -0,0 +1 @@
+uid://cmwm44sgxytkj