Add GdUnit4 and ignore animation warning concerning invalid tracks.

addons/gdUnit4/GdUnitRunner.cfg

@@ -0,0 +1 @@
+{"included":{"res://tests/scenes/game_tests.gd":["test_save_game"]},"server_port":31002,"skipped":{},"version":"1.0"}

addons/gdUnit4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Mike Schulze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

addons/gdUnit4/bin/GdUnitBuildTool.gd

@@ -0,0 +1,111 @@
+#!/usr/bin/env -S godot -s
+extends SceneTree
+
+enum {
+	INIT,
+	PROCESSING,
+	EXIT
+}
+
+const RETURN_SUCCESS  =   0
+const RETURN_ERROR    = 100
+const RETURN_WARNING  = 101
+
+var _console := CmdConsole.new()
+var _cmd_options: = CmdOptions.new([
+	CmdOption.new(
+		"-scp, --src_class_path",
+		"-scp <source_path>",
+		"The full class path of the source file.",
+		TYPE_STRING
+	),
+	CmdOption.new(
+		"-scl, --src_class_line",
+		"-scl <line_number>",
+		"The selected line number to generate test case.",
+		TYPE_INT
+	)
+])
+
+var _status := INIT
+var _source_file :String = ""
+var _source_line :int = -1
+
+
+func _init() -> void:
+	var cmd_parser := CmdArgumentParser.new(_cmd_options, "GdUnitBuildTool.gd")
+	var result := cmd_parser.parse(OS.get_cmdline_args())
+	if result.is_error():
+		show_options()
+		exit(RETURN_ERROR, result.error_message());
+		return
+
+	var cmd_options :Array[CmdCommand] = result.value()
+	for cmd in cmd_options:
+		if cmd.name() == '-scp':
+			_source_file = cmd.arguments()[0]
+			_source_file = ProjectSettings.localize_path(ProjectSettings.localize_path(_source_file))
+		if cmd.name() == '-scl':
+			_source_line = int(cmd.arguments()[0])
+	# verify required arguments
+	if _source_file == "":
+		exit(RETURN_ERROR, "missing required argument -scp <source>")
+		return
+	if _source_line == -1:
+		exit(RETURN_ERROR, "missing required argument -scl <number>")
+		return
+	_status = PROCESSING
+
+
+func _idle(_delta :float) -> void:
+	if _status == PROCESSING:
+		var script := ResourceLoader.load(_source_file) as Script
+		if script == null:
+			exit(RETURN_ERROR, "Can't load source file %s!" % _source_file)
+		var result := GdUnitTestSuiteBuilder.create(script, _source_line)
+		if result.is_error():
+			print_json_error(result.error_message())
+			exit(RETURN_ERROR, result.error_message())
+			return
+		_console.prints_color("Added testcase: %s" % result.value(), Color.CORNFLOWER_BLUE)
+		print_json_result(result.value())
+		exit(RETURN_SUCCESS)
+
+
+func exit(code :int, message :String = "") -> void:
+	_status = EXIT
+	if code == RETURN_ERROR:
+		if not message.is_empty():
+			_console.prints_error(message)
+		_console.prints_error("Abnormal exit with %d" % code)
+	else:
+		_console.prints_color("Exit code: %d" % RETURN_SUCCESS, Color.DARK_SALMON)
+	quit(code)
+
+
+func print_json_result(result :Dictionary) -> void:
+	# convert back to system path
+	var path := ProjectSettings.globalize_path(result["path"]);
+	var json := 'JSON_RESULT:{"TestCases" : [{"line":%d, "path": "%s"}]}' % [result["line"], path]
+	prints(json)
+
+
+func print_json_error(error :String) -> void:
+	prints('JSON_RESULT:{"Error" : "%s"}' % error)
+
+
+func show_options() -> void:
+	_console.prints_color(" Usage:", Color.DARK_SALMON)
+	_console.prints_color("	build -scp <source_path> -scl <line_number>", Color.DARK_SALMON)
+	_console.prints_color("-- Options ---------------------------------------------------------------------------------------",
+		Color.DARK_SALMON).new_line()
+	for option in _cmd_options.default_options():
+		descripe_option(option)
+
+
+func descripe_option(cmd_option :CmdOption) -> void:
+	_console.print_color("  %-40s" % str(cmd_option.commands()), Color.CORNFLOWER_BLUE)
+	_console.prints_color(cmd_option.description(), Color.LIGHT_GREEN)
+	if not cmd_option.help().is_empty():
+		_console.prints_color("%-4s %s" % ["", cmd_option.help()], Color.DARK_TURQUOISE)
+	_console.new_line()

addons/gdUnit4/bin/GdUnitCmdTool.gd

@@ -0,0 +1,622 @@
+#!/usr/bin/env -S godot -s
+extends SceneTree
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+
+#warning-ignore-all:return_value_discarded
+class CLIRunner:
+	extends Node
+
+	enum {
+		READY,
+		INIT,
+		RUN,
+		STOP,
+		EXIT
+	}
+
+	const DEFAULT_REPORT_COUNT = 20
+	const RETURN_SUCCESS = 0
+	const RETURN_ERROR = 100
+	const RETURN_ERROR_HEADLESS_NOT_SUPPORTED = 103
+	const RETURN_ERROR_GODOT_VERSION_NOT_SUPPORTED = 104
+	const RETURN_WARNING = 101
+
+	var _state := READY
+	var _test_suites_to_process: Array
+	var _executor :Variant
+	var _cs_executor :Variant
+	var _report: GdUnitHtmlReport
+	var _report_dir: String
+	var _report_max: int = DEFAULT_REPORT_COUNT
+	var _headless_mode_ignore := false
+	var _runner_config := GdUnitRunnerConfig.new()
+	var _runner_config_file := ""
+	var _console := CmdConsole.new()
+	var _cmd_options := CmdOptions.new([
+			CmdOption.new(
+				"-a, --add",
+				"-a <directory|path of testsuite>",
+				"Adds the given test suite or directory to the execution pipeline.",
+				TYPE_STRING
+			),
+			CmdOption.new(
+				"-i, --ignore",
+				"-i <testsuite_name|testsuite_name:test-name>",
+				"Adds the given test suite or test case to the ignore list.",
+				TYPE_STRING
+			),
+			CmdOption.new(
+					"-c, --continue",
+					"",
+					"""By default GdUnit will abort checked first test failure to be fail fast,
+					instead of stop after first failure you can use this option to run the complete test set.""".dedent()
+			),
+			CmdOption.new(
+				"-conf, --config",
+				"-conf [testconfiguration.cfg]",
+				"Run all tests by given test configuration. Default is 'GdUnitRunner.cfg'",
+				TYPE_STRING,
+				true
+			),
+			CmdOption.new(
+				"-help", "",
+				"Shows this help message."
+			),
+			CmdOption.new("--help-advanced", "",
+				"Shows advanced options."
+			)
+		],
+		[
+			# advanced options
+			CmdOption.new(
+				"-rd, --report-directory",
+				"-rd <directory>",
+				"Specifies the output directory in which the reports are to be written. The default is res://reports/.",
+				TYPE_STRING,
+				true
+			),
+			CmdOption.new(
+				"-rc, --report-count",
+				"-rc <count>",
+				"Specifies how many reports are saved before they are deleted. The default is %s." % str(DEFAULT_REPORT_COUNT),
+				TYPE_INT,
+				true
+			),
+			#CmdOption.new("--list-suites", "--list-suites [directory]", "Lists all test suites located in the given directory.", TYPE_STRING),
+			#CmdOption.new("--describe-suite", "--describe-suite <suite name>", "Shows the description of selected test suite.", TYPE_STRING),
+			CmdOption.new(
+				"--info", "",
+				"Shows the GdUnit version info"
+			),
+			CmdOption.new(
+				"--selftest", "",
+				"Runs the GdUnit self test"
+			),
+			CmdOption.new(
+				"--ignoreHeadlessMode",
+				"--ignoreHeadlessMode",
+				"By default, running GdUnit4 in headless mode is not allowed. You can switch off the headless mode check by set this property."
+			),
+		])
+
+
+	func _ready() -> void:
+		_state = INIT
+		_report_dir = GdUnitFileAccess.current_dir() + "reports"
+		_executor = load("res://addons/gdUnit4/src/core/execution/GdUnitTestSuiteExecutor.gd").new()
+		# stop checked first test failure to fail fast
+		_executor.fail_fast(true)
+		if GdUnit4CSharpApiLoader.is_mono_supported():
+			prints("GdUnit4Net version '%s' loaded." % GdUnit4CSharpApiLoader.version())
+			_cs_executor = GdUnit4CSharpApiLoader.create_executor(self)
+		var err := GdUnitSignals.instance().gdunit_event.connect(_on_gdunit_event)
+		if err != OK:
+			prints("gdUnitSignals failed")
+			push_error("Error checked startup, can't connect executor for 'send_event'")
+			quit(RETURN_ERROR)
+
+
+	func _notification(what: int) -> void:
+		if what == NOTIFICATION_PREDELETE:
+			prints("Finallize .. done")
+
+
+	func _process(_delta :float) -> void:
+		match _state:
+			INIT:
+				init_gd_unit()
+				_state = RUN
+			RUN:
+				# all test suites executed
+				if _test_suites_to_process.is_empty():
+					_state = STOP
+				else:
+					set_process(false)
+					# process next test suite
+					var test_suite := _test_suites_to_process.pop_front() as Node
+					if _cs_executor != null and _cs_executor.IsExecutable(test_suite):
+						_cs_executor.Execute(test_suite)
+						await _cs_executor.ExecutionCompleted
+					else:
+						await _executor.execute(test_suite)
+					set_process(true)
+			STOP:
+				_state = EXIT
+				_on_gdunit_event(GdUnitStop.new())
+				quit(report_exit_code(_report))
+
+
+	func quit(code: int) -> void:
+		_cs_executor = null
+		GdUnitTools.dispose_all()
+		await GdUnitMemoryObserver.gc_on_guarded_instances()
+		await get_tree().physics_frame
+		get_tree().quit(code)
+
+
+	func set_report_dir(path: String) -> void:
+		_report_dir = ProjectSettings.globalize_path(GdUnitFileAccess.make_qualified_path(path))
+		_console.prints_color(
+			"Set write reports to %s" % _report_dir,
+			Color.DEEP_SKY_BLUE
+		)
+
+
+	func set_report_count(count: String) -> void:
+		var report_count := count.to_int()
+		if report_count < 1:
+			_console.prints_error(
+				"Invalid report history count '%s' set back to default %d"
+				% [count, DEFAULT_REPORT_COUNT]
+			)
+			_report_max = DEFAULT_REPORT_COUNT
+		else:
+			_console.prints_color(
+				"Set report history count to %s" % count,
+				Color.DEEP_SKY_BLUE
+			)
+			_report_max = report_count
+
+
+	func disable_fail_fast() -> void:
+		_console.prints_color(
+			"Disabled fail fast!",
+			Color.DEEP_SKY_BLUE
+		)
+		_executor.fail_fast(false)
+
+
+	func run_self_test() -> void:
+		_console.prints_color(
+			"Run GdUnit4 self tests.",
+			Color.DEEP_SKY_BLUE
+		)
+		disable_fail_fast()
+		_runner_config.self_test()
+
+
+	func show_version() -> void:
+		_console.prints_color(
+			"Godot %s" % Engine.get_version_info().get("string"),
+			Color.DARK_SALMON
+		)
+		var config := ConfigFile.new()
+		config.load("addons/gdUnit4/plugin.cfg")
+		_console.prints_color(
+			"GdUnit4 %s" % config.get_value("plugin", "version"),
+			Color.DARK_SALMON
+		)
+		quit(RETURN_SUCCESS)
+
+
+	func check_headless_mode() -> void:
+		_headless_mode_ignore = true
+
+
+	func show_options(show_advanced: bool = false) -> void:
+		_console.prints_color(
+			"""
+			Usage:
+				runtest -a <directory|path of testsuite>
+				runtest -a <directory> -i <path of testsuite|testsuite_name|testsuite_name:test_name>
+				""".dedent(),
+			Color.DARK_SALMON
+		).prints_color(
+			"-- Options ---------------------------------------------------------------------------------------",
+			Color.DARK_SALMON
+		).new_line()
+		for option in _cmd_options.default_options():
+			descripe_option(option)
+		if show_advanced:
+			_console.prints_color(
+				"-- Advanced options --------------------------------------------------------------------------",
+				Color.DARK_SALMON
+			).new_line()
+			for option in _cmd_options.advanced_options():
+				descripe_option(option)
+
+
+	func descripe_option(cmd_option: CmdOption) -> void:
+		_console.print_color(
+			"  %-40s" % str(cmd_option.commands()),
+			Color.CORNFLOWER_BLUE
+		)
+		_console.prints_color(
+			cmd_option.description(),
+			Color.LIGHT_GREEN
+		)
+		if not cmd_option.help().is_empty():
+			_console.prints_color(
+				"%-4s %s" % ["", cmd_option.help()],
+				Color.DARK_TURQUOISE
+			)
+		_console.new_line()
+
+
+	func load_test_config(path := GdUnitRunnerConfig.CONFIG_FILE) -> void:
+		_console.print_color(
+			"Loading test configuration %s\n" % path,
+			Color.CORNFLOWER_BLUE
+		)
+		_runner_config_file = path
+		_runner_config.load_config(path)
+
+
+	func show_help() -> void:
+		show_options()
+		quit(RETURN_SUCCESS)
+
+
+	func show_advanced_help() -> void:
+		show_options(true)
+		quit(RETURN_SUCCESS)
+
+
+	func init_gd_unit() -> void:
+		_console.prints_color(
+			"""
+			--------------------------------------------------------------------------------------------------
+			GdUnit4 Comandline Tool
+			--------------------------------------------------------------------------------------------------""".dedent(),
+			Color.DARK_SALMON
+		).new_line()
+
+		var cmd_parser := CmdArgumentParser.new(_cmd_options, "GdUnitCmdTool.gd")
+		var result := cmd_parser.parse(OS.get_cmdline_args())
+		if result.is_error():
+			show_options()
+			_console.prints_error(result.error_message())
+			_console.prints_error("Abnormal exit with %d" % RETURN_ERROR)
+			_state = STOP
+			quit(RETURN_ERROR)
+			return
+		if result.is_empty():
+			show_help()
+			return
+		# build runner config by given commands
+		var commands :Array[CmdCommand] = []
+		commands.append_array(result.value())
+		result = (
+			CmdCommandHandler.new(_cmd_options)
+				.register_cb("-help", Callable(self, "show_help"))
+				.register_cb("--help-advanced", Callable(self, "show_advanced_help"))
+				.register_cb("-a", Callable(_runner_config, "add_test_suite"))
+				.register_cbv("-a", Callable(_runner_config, "add_test_suites"))
+				.register_cb("-i", Callable(_runner_config, "skip_test_suite"))
+				.register_cbv("-i", Callable(_runner_config, "skip_test_suites"))
+				.register_cb("-rd", set_report_dir)
+				.register_cb("-rc", set_report_count)
+				.register_cb("--selftest", run_self_test)
+				.register_cb("-c", disable_fail_fast)
+				.register_cb("-conf", load_test_config)
+				.register_cb("--info", show_version)
+				.register_cb("--ignoreHeadlessMode", check_headless_mode)
+				.execute(commands)
+		)
+		if result.is_error():
+			_console.prints_error(result.error_message())
+			_state = STOP
+			quit(RETURN_ERROR)
+
+		if DisplayServer.get_name() == "headless":
+			if _headless_mode_ignore:
+				_console.prints_warning("""
+					Headless mode is ignored by option '--ignoreHeadlessMode'"
+
+					Please note that tests that use UI interaction do not work correctly in headless mode.
+					Godot 'InputEvents' are not transported by the Godot engine in headless mode and therefore
+					have no effect in the test!
+					""".dedent()
+				).new_line()
+			else:
+				_console.prints_error("""
+					Headless mode is not supported!
+
+					Please note that tests that use UI interaction do not work correctly in headless mode.
+					Godot 'InputEvents' are not transported by the Godot engine in headless mode and therefore
+					have no effect in the test!
+
+					You can run with '--ignoreHeadlessMode' to swtich off this check.
+					""".dedent()
+				).prints_error(
+					"Abnormal exit with %d" % RETURN_ERROR_HEADLESS_NOT_SUPPORTED
+				)
+				quit(RETURN_ERROR_HEADLESS_NOT_SUPPORTED)
+				return
+
+		_test_suites_to_process = load_testsuites(_runner_config)
+		if _test_suites_to_process.is_empty():
+			_console.prints_warning("No test suites found, abort test run!")
+			_console.prints_color("Exit code: %d" % RETURN_SUCCESS, Color.DARK_SALMON)
+			_state = STOP
+			quit(RETURN_SUCCESS)
+		var total_test_count := _collect_test_case_count(_test_suites_to_process)
+		_on_gdunit_event(GdUnitInit.new(_test_suites_to_process.size(), total_test_count))
+
+
+	func load_testsuites(config: GdUnitRunnerConfig) -> Array[Node]:
+		var test_suites_to_process: Array[Node] = []
+		# Dictionary[String, Dictionary[String, PackedStringArray]]
+		var to_execute := config.to_execute()
+		# scan for the requested test suites
+		var ts_scanner := GdUnitTestSuiteScanner.new()
+		for as_resource_path in to_execute.keys() as Array[String]:
+			var selected_tests: PackedStringArray = to_execute.get(as_resource_path)
+			var scaned_suites := ts_scanner.scan(as_resource_path)
+			skip_test_case(scaned_suites, selected_tests)
+			test_suites_to_process.append_array(scaned_suites)
+		skip_suites(test_suites_to_process, config)
+		return test_suites_to_process
+
+
+	func skip_test_case(test_suites: Array[Node], test_case_names: Array[String]) -> void:
+		if test_case_names.is_empty():
+			return
+		for test_suite in test_suites:
+			for test_case in test_suite.get_children():
+				if not test_case_names.has(test_case.get_name()):
+					test_suite.remove_child(test_case)
+					test_case.free()
+
+
+	func skip_suites(test_suites: Array[Node], config: GdUnitRunnerConfig) -> void:
+		var skipped := config.skipped()
+		if skipped.is_empty():
+			return
+		_console.prints_warning("Found excluded test suite's configured at '%s'" % _runner_config_file)
+		for test_suite in test_suites:
+			# skipp c# testsuites for now
+			if test_suite.get_script() == null:
+				continue
+			skip_suite(test_suite, skipped)
+
+
+	# Dictionary[String, PackedStringArray]
+	func skip_suite(test_suite: Node, skipped: Dictionary) -> void:
+		var skipped_suites :Array[String] = skipped.keys()
+		var suite_name := test_suite.get_name()
+		var test_suite_path: String = (
+			test_suite.get_meta("ResourcePath") if test_suite.get_script() == null
+			else test_suite.get_script().resource_path
+		)
+		for suite_to_skip in skipped_suites:
+			# if suite skipped by path or name
+			if (
+				suite_to_skip == test_suite_path
+				or (suite_to_skip.is_valid_filename() and suite_to_skip == suite_name)
+			):
+				var skipped_tests: Array[String] = skipped.get(suite_to_skip)
+				var skip_reason := "Excluded by config '%s'" % _runner_config_file
+				# if no tests skipped test the complete suite is skipped
+				if skipped_tests.is_empty():
+					_console.prints_warning("Mark test suite '%s' as skipped!" % suite_to_skip)
+					test_suite.__is_skipped = true
+					test_suite.__skip_reason = skip_reason
+				else:
+					# skip tests
+					for test_to_skip in skipped_tests:
+						var test_case: _TestCase = test_suite.find_child(test_to_skip, true, false)
+						if test_case:
+							test_case.skip(true, skip_reason)
+							_console.prints_warning("Mark test case '%s':%s as skipped" % [suite_to_skip, test_to_skip])
+						else:
+							_console.prints_error(
+								"Can't skip test '%s' checked test suite '%s', no test with given name exists!"
+								% [test_to_skip, suite_to_skip]
+							)
+
+
+	func _collect_test_case_count(test_suites: Array[Node]) -> int:
+		var total: int = 0
+		for test_suite in test_suites:
+			total += test_suite.get_child_count()
+		return total
+
+
+	# gdlint: disable=function-name
+	func PublishEvent(data: Dictionary) -> void:
+		_on_gdunit_event(GdUnitEvent.new().deserialize(data))
+
+
+	func _on_gdunit_event(event: GdUnitEvent) -> void:
+		match event.type():
+			GdUnitEvent.INIT:
+				_report = GdUnitHtmlReport.new(_report_dir)
+			GdUnitEvent.STOP:
+				if _report == null:
+					_report = GdUnitHtmlReport.new(_report_dir)
+				var report_path := _report.write()
+				_report.delete_history(_report_max)
+				JUnitXmlReport.new(_report._report_path, _report.iteration()).write(_report)
+				_console.prints_color(
+					build_executed_test_suite_msg(_report.suite_executed_count(), _report.suite_count()),
+					Color.DARK_SALMON
+				).prints_color(
+					build_executed_test_case_msg(_report.test_executed_count(), _report.test_count()),
+					Color.DARK_SALMON
+				).prints_color(
+					"Total time:        %s" % LocalTime.elapsed(_report.duration()),
+					Color.DARK_SALMON
+				).prints_color(
+					"Open Report at: file://%s" % report_path,
+					Color.CORNFLOWER_BLUE
+				)
+			GdUnitEvent.TESTSUITE_BEFORE:
+				_report.add_testsuite_report(
+					GdUnitTestSuiteReport.new(event.resource_path(), event.suite_name(), event.total_count())
+				)
+			GdUnitEvent.TESTSUITE_AFTER:
+				_report.update_test_suite_report(
+					event.resource_path(),
+					event.elapsed_time(),
+					event.is_error(),
+					event.is_failed(),
+					event.is_warning(),
+					event.is_skipped(),
+					event.skipped_count(),
+					event.failed_count(),
+					event.orphan_nodes(),
+					event.reports()
+				)
+			GdUnitEvent.TESTCASE_BEFORE:
+				_report.add_testcase_report(
+					event.resource_path(),
+					GdUnitTestCaseReport.new(
+						event.resource_path(),
+						event.suite_name(),
+						event.test_name()
+					)
+				)
+			GdUnitEvent.TESTCASE_AFTER:
+				var test_report := GdUnitTestCaseReport.new(
+					event.resource_path(),
+					event.suite_name(),
+					event.test_name(),
+					event.is_error(),
+					event.is_failed(),
+					event.failed_count(),
+					event.orphan_nodes(),
+					event.is_skipped(),
+					event.reports(),
+					event.elapsed_time()
+				)
+				_report.update_testcase_report(event.resource_path(), test_report)
+		print_status(event)
+
+
+	func build_executed_test_suite_msg(executed_count :int, total_count :int) -> String:
+		if executed_count == total_count:
+			return "Executed test suites: (%d/%d)" % [executed_count, total_count]
+		return "Executed test suites: (%d/%d), %d skipped" % [executed_count, total_count, (total_count - executed_count)]
+
+
+	func build_executed_test_case_msg(executed_count :int, total_count :int) -> String:
+		if executed_count == total_count:
+			return "Executed test cases: (%d/%d)" % [executed_count, total_count]
+		return "Executed test cases: (%d/%d), %d skipped" % [executed_count, total_count, (total_count - executed_count)]
+
+
+	func report_exit_code(report: GdUnitHtmlReport) -> int:
+		if report.error_count() + report.failure_count() > 0:
+			_console.prints_color("Exit code: %d" % RETURN_ERROR, Color.FIREBRICK)
+			return RETURN_ERROR
+		if report.orphan_count() > 0:
+			_console.prints_color("Exit code: %d" % RETURN_WARNING, Color.GOLDENROD)
+			return RETURN_WARNING
+		_console.prints_color("Exit code: %d" % RETURN_SUCCESS, Color.DARK_SALMON)
+		return RETURN_SUCCESS
+
+
+	func print_status(event: GdUnitEvent) -> void:
+		match event.type():
+			GdUnitEvent.TESTSUITE_BEFORE:
+				_console.prints_color(
+					"Run Test Suite %s " % event.resource_path(),
+					Color.ANTIQUE_WHITE
+				)
+			GdUnitEvent.TESTCASE_BEFORE:
+				_console.print_color(
+					"	Run Test: %s > %s :" % [event.resource_path(), event.test_name()],
+					Color.ANTIQUE_WHITE
+				).prints_color(
+					"STARTED",
+					Color.FOREST_GREEN
+				).save_cursor()
+			GdUnitEvent.TESTCASE_AFTER:
+				#_console.restore_cursor()
+				_console.print_color(
+					"	Run Test: %s > %s :" % [event.resource_path(), event.test_name()],
+					Color.ANTIQUE_WHITE
+				)
+				_print_status(event)
+				_print_failure_report(event.reports())
+			GdUnitEvent.TESTSUITE_AFTER:
+				_print_failure_report(event.reports())
+				_print_status(event)
+				_console.prints_color(
+					"Statistics: | %d tests cases | %d error | %d failed | %d skipped | %d orphans |\n"
+					% [
+						_report.test_count(),
+						_report.error_count(),
+						_report.failure_count(),
+						_report.skipped_count(),
+						_report.orphan_count()
+					],
+					Color.ANTIQUE_WHITE
+				)
+
+
+	func _print_failure_report(reports: Array[GdUnitReport]) -> void:
+		for report in reports:
+			if (
+				report.is_failure()
+				or report.is_error()
+				or report.is_warning()
+				or report.is_skipped()
+			):
+				_console.prints_color(
+					"	Report:",
+					Color.DARK_TURQUOISE, CmdConsole.BOLD | CmdConsole.UNDERLINE
+				)
+				var text := GdUnitTools.richtext_normalize(str(report))
+				for line in text.split("\n"):
+					_console.prints_color("		%s" % line, Color.DARK_TURQUOISE)
+		_console.new_line()
+
+
+	func _print_status(event: GdUnitEvent) -> void:
+		if event.is_skipped():
+			_console.print_color("SKIPPED", Color.GOLDENROD, CmdConsole.BOLD | CmdConsole.ITALIC)
+		elif event.is_failed() or event.is_error():
+			_console.print_color("FAILED", Color.FIREBRICK, CmdConsole.BOLD)
+		elif event.orphan_nodes() > 0:
+			_console.print_color("PASSED", Color.GOLDENROD, CmdConsole.BOLD | CmdConsole.UNDERLINE)
+		else:
+			_console.print_color("PASSED", Color.FOREST_GREEN, CmdConsole.BOLD)
+		_console.prints_color(
+			" %s" % LocalTime.elapsed(event.elapsed_time()), Color.CORNFLOWER_BLUE
+		)
+
+
+var _cli_runner :CLIRunner
+
+
+func _initialize() -> void:
+	if Engine.get_version_info().hex < 0x40200:
+		prints("GdUnit4 requires a minimum of Godot 4.2.x Version!")
+		quit(CLIRunner.RETURN_ERROR_GODOT_VERSION_NOT_SUPPORTED)
+		return
+	DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_MINIMIZED)
+	_cli_runner = CLIRunner.new()
+	root.add_child(_cli_runner)
+
+
+# do not use print statements on _finalize it results in random crashes
+func _finalize() -> void:
+	if OS.is_stdout_verbose():
+		prints("Finallize ..")
+		prints("-Orphan nodes report-----------------------")
+		Window.print_orphan_nodes()
+		prints("Finallize .. done")

addons/gdUnit4/bin/GdUnitCopyLog.gd

@@ -0,0 +1,141 @@
+#!/usr/bin/env -S godot -s
+extends MainLoop
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+# gdlint: disable=max-line-length
+const NO_LOG_TEMPLATE = """
+<!DOCTYPE html>
+<html>
+<head>
+	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+	<meta http-equiv="x-ua-compatible" content="IE=edge"/>
+	<title>Logging</title>
+	<link href="css/style.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+	<div>
+		<h1>No logging available!</h1>
+		</br>
+		<p>For logging to occur, you must check Enable File Logging in Project Settings.</p>
+		<p>You can enable Logging <b>Project Settings</b> > <b>Logging</b> > <b>File Logging</b> > <b>Enable File Logging</b> in the Project Settings.</p>
+	</div>
+</body>
+"""
+
+#warning-ignore-all:return_value_discarded
+var _cmd_options := CmdOptions.new([
+		CmdOption.new(
+			"-rd, --report-directory",
+			"-rd <directory>",
+			"Specifies the output directory in which the reports are to be written. The default is res://reports/.",
+			TYPE_STRING,
+			true
+		)
+	])
+
+var _report_root_path: String
+
+
+func _init() -> void:
+	_report_root_path = GdUnitFileAccess.current_dir() + "reports"
+
+
+func _process(_delta :float) -> bool:
+	# check if reports exists
+	if not reports_available():
+		prints("no reports found")
+		return true
+	# scan for latest report path
+	var iteration := GdUnitFileAccess.find_last_path_index(
+		_report_root_path, GdUnitHtmlReport.REPORT_DIR_PREFIX
+	)
+	var report_path := "%s/%s%d" % [_report_root_path, GdUnitHtmlReport.REPORT_DIR_PREFIX, iteration]
+	# only process if godot logging is enabled
+	if not GdUnitSettings.is_log_enabled():
+		_patch_report(report_path, "")
+		return true
+	# parse possible custom report path,
+	var cmd_parser := CmdArgumentParser.new(_cmd_options, "GdUnitCmdTool.gd")
+	# ignore erros and exit quitly
+	if cmd_parser.parse(OS.get_cmdline_args(), true).is_error():
+		return true
+	CmdCommandHandler.new(_cmd_options).register_cb("-rd", set_report_directory)
+	# scan for latest godot log and copy to report
+	var godot_log := _scan_latest_godot_log()
+	var result := _copy_and_pach(godot_log, report_path)
+	if result.is_error():
+		push_error(result.error_message())
+		return true
+	_patch_report(report_path, godot_log)
+	return true
+
+
+func set_report_directory(path: String) -> void:
+	_report_root_path = path
+
+
+func _scan_latest_godot_log() -> String:
+	var path := GdUnitSettings.get_log_path().get_base_dir()
+	var files_sorted := Array()
+	for file in GdUnitFileAccess.scan_dir(path):
+		var file_name := "%s/%s" % [path, file]
+		files_sorted.append(file_name)
+	# sort by name, the name contains the timestamp so we sort at the end by timestamp
+	files_sorted.sort()
+	return files_sorted[-1]
+
+
+func _patch_report(report_path: String, godot_log: String) -> void:
+	var index_file := FileAccess.open("%s/index.html" % report_path, FileAccess.READ_WRITE)
+	if index_file == null:
+		push_error(
+			"Can't add log path to index.html. Error: %s"
+			% error_string(FileAccess.get_open_error())
+		)
+		return
+	# if no log file available than add a information howto enable it
+	if godot_log.is_empty():
+		FileAccess.open(
+			"%s/logging_not_available.html" % report_path,
+			FileAccess.WRITE).store_string(NO_LOG_TEMPLATE)
+	var log_file := "logging_not_available.html" if godot_log.is_empty() else godot_log.get_file()
+	var content := index_file.get_as_text().replace("${log_file}", log_file)
+	# overide it
+	index_file.seek(0)
+	index_file.store_string(content)
+
+
+func _copy_and_pach(from_file: String, to_dir: String) -> GdUnitResult:
+	var result := GdUnitFileAccess.copy_file(from_file, to_dir)
+	if result.is_error():
+		return result
+	var file := FileAccess.open(from_file, FileAccess.READ)
+	if file == null:
+		return GdUnitResult.error(
+			"Can't find file '%s'. Error: %s"
+			% [from_file, error_string(FileAccess.get_open_error())]
+		)
+	var content := file.get_as_text()
+	# patch out console format codes
+	for color_index in range(0, 256):
+		var to_replace := "[38;5;%dm" % color_index
+		content = content.replace(to_replace, "")
+	content = content\
+		.replace("", "")\
+		.replace(CmdConsole.CSI_BOLD, "")\
+		.replace(CmdConsole.CSI_ITALIC, "")\
+		.replace(CmdConsole.CSI_UNDERLINE, "")
+	var to_file := to_dir + "/" + from_file.get_file()
+	file = FileAccess.open(to_file, FileAccess.WRITE)
+	if file == null:
+		return GdUnitResult.error(
+			"Can't open to write '%s'. Error: %s"
+			% [to_file, error_string(FileAccess.get_open_error())]
+		)
+	file.store_string(content)
+	return GdUnitResult.empty()
+
+
+func reports_available() -> bool:
+	return DirAccess.dir_exists_absolute(_report_root_path)

addons/gdUnit4/bin/ProjectScanner.gd

@@ -0,0 +1,99 @@
+#!/usr/bin/env -S godot -s
+@tool
+extends SceneTree
+
+const CmdConsole = preload("res://addons/gdUnit4/src/cmd/CmdConsole.gd")
+
+
+func _initialize() -> void:
+	set_auto_accept_quit(false)
+	var scanner := SourceScanner.new(self)
+	root.add_child(scanner)
+
+
+# gdlint: disable=trailing-whitespace
+class SourceScanner extends Node:
+
+	enum {
+		INIT,
+		STARTUP,
+		SCAN,
+		QUIT,
+		DONE
+	}
+
+	var _state := INIT
+	var _console := CmdConsole.new()
+	var _elapsed_time := 0.0
+	var _plugin: EditorPlugin
+	var _fs: EditorFileSystem
+	var _scene: SceneTree
+
+
+	func _init(scene :SceneTree) -> void:
+		_scene = scene
+		_console.prints_color("""
+			========================================================================
+			Running project scan:""".dedent(),
+			Color.CORNFLOWER_BLUE
+		)
+		_state = INIT
+
+
+	func _process(delta :float) -> void:
+		_elapsed_time += delta
+		set_process(false)
+		await_inital_scan()
+		await scan_project()
+		set_process(true)
+
+
+	# !! don't use any await in this phase otherwise the editor will be instable !!
+	func await_inital_scan() -> void:
+		if _state == INIT:
+			_console.prints_color("Wait initial scanning ...", Color.DARK_GREEN)
+			_plugin = EditorPlugin.new()
+			_fs = _plugin.get_editor_interface().get_resource_filesystem()
+			_plugin.get_editor_interface().set_plugin_enabled("gdUnit4", false)
+			_state = STARTUP
+
+		if _state == STARTUP:
+			if _fs.is_scanning():
+				_console.progressBar(_fs.get_scanning_progress() * 100 as int)
+			# we wait 10s in addition to be on the save site the scanning is done
+			if _elapsed_time > 10.0:
+				_console.progressBar(100)
+				_console.new_line()
+				_console.prints_color("initial scanning ... done", Color.DARK_GREEN)
+				_state = SCAN
+
+
+	func scan_project() -> void:
+		if _state != SCAN:
+			return
+		_console.prints_color("Scan project: ", Color.SANDY_BROWN)
+		await get_tree().process_frame
+		_fs.scan_sources()
+		await get_tree().create_timer(5).timeout
+		_console.prints_color("Scan: ", Color.SANDY_BROWN)
+		_console.progressBar(0)
+		await get_tree().process_frame
+		_fs.scan()
+		while _fs.is_scanning():
+			await get_tree().process_frame
+			_console.progressBar(_fs.get_scanning_progress() * 100 as int)
+		await get_tree().create_timer(10).timeout
+		_console.progressBar(100)
+		_console.new_line()
+		_plugin.free()
+		_console.prints_color("""
+			Scan project done.
+			========================================================================""".dedent(),
+			Color.CORNFLOWER_BLUE
+		)
+		await get_tree().process_frame
+		await get_tree().physics_frame
+		queue_free()
+		# force quit editor
+		_state = DONE
+		_scene.quit(0)

addons/gdUnit4/plugin.cfg

@@ -0,0 +1,7 @@
+[plugin]
+
+name="gdUnit4"
+description="Unit Testing Framework for Godot Scripts"
+author="Mike Schulze"
+version="4.3.1"
+script="plugin.gd"

addons/gdUnit4/plugin.gd

@@ -0,0 +1,54 @@
+@tool
+extends EditorPlugin
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+const GdUnitTestDiscoverGuard := preload("res://addons/gdUnit4/src/core/discovery/GdUnitTestDiscoverGuard.gd")
+
+
+var _gd_inspector :Node
+var _server_node :Node
+var _gd_console :Node
+var _guard: GdUnitTestDiscoverGuard
+
+
+func _enter_tree() -> void:
+	if Engine.get_version_info().hex < 0x40200:
+		prints("GdUnit4 plugin requires a minimum of Godot 4.2.x Version!")
+		return
+	GdUnitSettings.setup()
+	# install the GdUnit inspector
+	_gd_inspector = load("res://addons/gdUnit4/src/ui/GdUnitInspector.tscn").instantiate()
+	add_control_to_dock(EditorPlugin.DOCK_SLOT_LEFT_UR, _gd_inspector)
+	# install the GdUnit Console
+	_gd_console = load("res://addons/gdUnit4/src/ui/GdUnitConsole.tscn").instantiate()
+	add_control_to_bottom_panel(_gd_console, "gdUnitConsole")
+	_server_node = load("res://addons/gdUnit4/src/network/GdUnitServer.tscn").instantiate()
+	Engine.get_main_loop().root.add_child.call_deferred(_server_node)
+	prints("Loading GdUnit4 Plugin success")
+	if GdUnitSettings.is_update_notification_enabled():
+		var update_tool :Node = load("res://addons/gdUnit4/src/update/GdUnitUpdateNotify.tscn").instantiate()
+		Engine.get_main_loop().root.add_child.call_deferred(update_tool)
+	if GdUnit4CSharpApiLoader.is_mono_supported():
+		prints("GdUnit4Net version '%s' loaded." % GdUnit4CSharpApiLoader.version())
+	# connect to be notified for script changes to be able to discover new tests
+	_guard = GdUnitTestDiscoverGuard.new()
+	resource_saved.connect(_on_resource_saved)
+
+
+func _exit_tree() -> void:
+	if is_instance_valid(_gd_inspector):
+		remove_control_from_docks(_gd_inspector)
+		GodotVersionFixures.free_fix(_gd_inspector)
+	if is_instance_valid(_gd_console):
+		remove_control_from_bottom_panel(_gd_console)
+		_gd_console.free()
+	if is_instance_valid(_server_node):
+		Engine.get_main_loop().root.remove_child.call_deferred(_server_node)
+		_server_node.queue_free()
+	GdUnitTools.dispose_all.call_deferred()
+	prints("Unload GdUnit4 Plugin success")
+
+
+func _on_resource_saved(resource :Resource) -> void:
+	if resource is Script:
+		_guard.discover(resource)

addons/gdUnit4/runtest.cmd

@@ -0,0 +1,25 @@
+@ECHO OFF
+CLS
+
+IF NOT DEFINED GODOT_BIN (
+	ECHO "GODOT_BIN is not set."
+	ECHO "Please set the environment variable 'setx GODOT_BIN <path to godot.exe>'"
+	EXIT /b -1
+)
+
+REM scan if Godot mono used and compile c# classes
+for /f "tokens=5 delims=. " %%i in ('%GODOT_BIN% --version') do set GODOT_TYPE=%%i
+IF "%GODOT_TYPE%" == "mono" (
+	ECHO "Godot mono detected"
+	ECHO Compiling c# classes ... Please Wait
+	dotnet build --debug
+	ECHO done %errorlevel%
+)
+
+%GODOT_BIN% -s -d res://addons/gdUnit4/bin/GdUnitCmdTool.gd %*
+SET exit_code=%errorlevel%
+%GODOT_BIN% --headless --quiet -s -d res://addons/gdUnit4/bin/GdUnitCopyLog.gd %*
+
+ECHO %exit_code%
+
+EXIT /B %exit_code%

addons/gdUnit4/runtest.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+if [ -z "$GODOT_BIN" ]; then
+    echo "'GODOT_BIN' is not set."
+    echo "Please set the environment variable  'export GODOT_BIN=/Applications/Godot.app/Contents/MacOS/Godot'"
+    exit 1
+fi
+
+"$GODOT_BIN" --path . -s -d res://addons/gdUnit4/bin/GdUnitCmdTool.gd $*
+exit_code=$?
+echo "Run tests ends with $exit_code"
+
+"$GODOT_BIN" --headless --path . --quiet -s -d res://addons/gdUnit4/bin/GdUnitCopyLog.gd $* > /dev/null
+exit_code2=$?
+exit $exit_code

addons/gdUnit4/src/Comparator.gd

@@ -0,0 +1,12 @@
+class_name Comparator
+extends Resource
+
+enum {
+	EQUAL,
+	LESS_THAN,
+	LESS_EQUAL,
+	GREATER_THAN,
+	GREATER_EQUAL,
+	BETWEEN_EQUAL,
+	NOT_BETWEEN_EQUAL,
+}

addons/gdUnit4/src/Fuzzers.gd

@@ -0,0 +1,34 @@
+## A fuzzer implementation to provide default implementation
+class_name Fuzzers
+extends Resource
+
+
+## Generates an random string with min/max length and given charset
+static func rand_str(min_length: int, max_length :int, charset := StringFuzzer.DEFAULT_CHARSET) -> Fuzzer:
+	return StringFuzzer.new(min_length, max_length, charset)
+
+
+## Generates an random integer in a range form to
+static func rangei(from: int, to: int) -> Fuzzer:
+	return IntFuzzer.new(from, to)
+
+## Generates a randon float within in a given range
+static func rangef(from: float, to: float) -> Fuzzer:
+	return FloatFuzzer.new(from, to)
+
+## Generates an random Vector2 in a range form to
+static func rangev2(from: Vector2, to: Vector2) -> Fuzzer:
+	return Vector2Fuzzer.new(from, to)
+
+
+## Generates an random Vector3 in a range form to
+static func rangev3(from: Vector3, to: Vector3) -> Fuzzer:
+	return Vector3Fuzzer.new(from, to)
+
+## Generates an integer in a range form to that can be divided exactly by 2
+static func eveni(from: int, to: int) -> Fuzzer:
+	return IntFuzzer.new(from, to, IntFuzzer.EVEN)
+
+## Generates an integer in a range form to that cannot be divided exactly by 2
+static func oddi(from: int, to: int) -> Fuzzer:
+	return IntFuzzer.new(from, to, IntFuzzer.ODD)

addons/gdUnit4/src/GdUnitArrayAssert.gd

@@ -0,0 +1,160 @@
+## An Assertion Tool to verify array values
+class_name GdUnitArrayAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+func is_null() -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current value is not null.
+func is_not_null() -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array is equal to the given one.
+@warning_ignore("unused_parameter")
+func is_equal(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array is equal to the given one, ignoring case considerations.
+@warning_ignore("unused_parameter")
+func is_equal_ignoring_case(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array is not equal to the given one.
+@warning_ignore("unused_parameter")
+func is_not_equal(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array is not equal to the given one, ignoring case considerations.
+@warning_ignore("unused_parameter")
+func is_not_equal_ignoring_case(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array is empty, it has a size of 0.
+func is_empty() -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array is not empty, it has a size of minimum 1.
+func is_not_empty() -> GdUnitArrayAssert:
+	return self
+
+## Verifies that the current Array is the same. [br]
+## Compares the current by object reference equals
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_same(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array is NOT the same. [br]
+## Compares the current by object reference equals
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_not_same(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array has a size of given value.
+@warning_ignore("unused_parameter")
+func has_size(expectd: int) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array contains the given values, in any order.[br]
+## The values are compared by deep parameter comparision, for object reference compare you have to use [method contains_same]
+@warning_ignore("unused_parameter")
+func contains(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array contains exactly only the given values and nothing else, in same order.[br]
+## The values are compared by deep parameter comparision, for object reference compare you have to use [method contains_same_exactly]
+@warning_ignore("unused_parameter")
+func contains_exactly(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array contains exactly only the given values and nothing else, in any order.[br]
+## The values are compared by deep parameter comparision, for object reference compare you have to use [method contains_same_exactly_in_any_order]
+@warning_ignore("unused_parameter")
+func contains_exactly_in_any_order(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array contains the given values, in any order.[br]
+## The values are compared by object reference, for deep parameter comparision use [method contains]
+@warning_ignore("unused_parameter")
+func contains_same(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array contains exactly only the given values and nothing else, in same order.[br]
+## The values are compared by object reference, for deep parameter comparision use [method contains_exactly]
+@warning_ignore("unused_parameter")
+func contains_same_exactly(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array contains exactly only the given values and nothing else, in any order.[br]
+## The values are compared by object reference, for deep parameter comparision use [method contains_exactly_in_any_order]
+@warning_ignore("unused_parameter")
+func contains_same_exactly_in_any_order(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array do NOT contains the given values, in any order.[br]
+## The values are compared by deep parameter comparision, for object reference compare you have to use [method not_contains_same]
+## [b]Example:[/b]
+## [codeblock]
+## # will succeed
+## assert_array([1, 2, 3, 4, 5]).not_contains([6])
+## # will fail
+## assert_array([1, 2, 3, 4, 5]).not_contains([2, 6])
+## [/codeblock]
+@warning_ignore("unused_parameter")
+func not_contains(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Verifies that the current Array do NOT contains the given values, in any order.[br]
+## The values are compared by object reference, for deep parameter comparision use [method not_contains]
+## [b]Example:[/b]
+## [codeblock]
+## # will succeed
+## assert_array([1, 2, 3, 4, 5]).not_contains([6])
+## # will fail
+## assert_array([1, 2, 3, 4, 5]).not_contains([2, 6])
+## [/codeblock]
+@warning_ignore("unused_parameter")
+func not_contains_same(expected :Variant) -> GdUnitArrayAssert:
+	return self
+
+
+## Extracts all values by given function name and optional arguments into a new ArrayAssert.
+## If the elements not accessible by `func_name` the value is converted to `"n.a"`, expecting null values
+@warning_ignore("unused_parameter")
+func extract(func_name: String, args := Array()) -> GdUnitArrayAssert:
+	return self
+
+
+## Extracts all values by given extractor's into a new ArrayAssert.
+## If the elements not extractable than the value is converted to `"n.a"`, expecting null values
+@warning_ignore("unused_parameter")
+func extractv(
+	extractor0 :GdUnitValueExtractor,
+	extractor1 :GdUnitValueExtractor = null,
+	extractor2 :GdUnitValueExtractor = null,
+	extractor3 :GdUnitValueExtractor = null,
+	extractor4 :GdUnitValueExtractor = null,
+	extractor5 :GdUnitValueExtractor = null,
+	extractor6 :GdUnitValueExtractor = null,
+	extractor7 :GdUnitValueExtractor = null,
+	extractor8 :GdUnitValueExtractor = null,
+	extractor9 :GdUnitValueExtractor = null) -> GdUnitArrayAssert:
+	return self

addons/gdUnit4/src/GdUnitAssert.gd

@@ -0,0 +1,41 @@
+## Base interface of all GdUnit asserts
+class_name GdUnitAssert
+extends RefCounted
+
+
+## Verifies that the current value is null.
+@warning_ignore("untyped_declaration")
+func is_null():
+	return self
+
+
+## Verifies that the current value is not null.
+@warning_ignore("untyped_declaration")
+func is_not_null():
+	return self
+
+
+## Verifies that the current value is equal to expected one.
+@warning_ignore("unused_parameter")
+@warning_ignore("untyped_declaration")
+func is_equal(expected):
+	return self
+
+
+## Verifies that the current value is not equal to expected one.
+@warning_ignore("unused_parameter")
+@warning_ignore("untyped_declaration")
+func is_not_equal(expected):
+	return self
+
+
+@warning_ignore("untyped_declaration")
+func test_fail():
+	return self
+
+
+## Overrides the default failure message by given custom message.
+@warning_ignore("unused_parameter")
+@warning_ignore("untyped_declaration")
+func override_failure_message(message :String):
+	return self

addons/gdUnit4/src/GdUnitAwaiter.gd

@@ -0,0 +1,69 @@
+class_name GdUnitAwaiter
+extends RefCounted
+
+const GdUnitAssertImpl = preload("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd")
+
+
+# Waits for a specified signal in an interval of 50ms sent from the <source>, and terminates with an error after the specified timeout has elapsed.
+# source: the object from which the signal is emitted
+# signal_name: signal name
+# args: the expected signal arguments as an array
+# timeout: the timeout in ms, default is set to 2000ms
+func await_signal_on(source :Object, signal_name :String, args :Array = [], timeout_millis :int = 2000) -> Variant:
+	# fail fast if the given source instance invalid
+	var assert_that := GdUnitAssertImpl.new(signal_name)
+	var line_number := GdUnitAssertions.get_line_number()
+	if not is_instance_valid(source):
+		assert_that.report_error(GdAssertMessages.error_await_signal_on_invalid_instance(source, signal_name, args), line_number)
+		return await Engine.get_main_loop().process_frame
+	# fail fast if the given source instance invalid
+	if not is_instance_valid(source):
+		assert_that.report_error(GdAssertMessages.error_await_signal_on_invalid_instance(source, signal_name, args), line_number)
+		return await await_idle_frame()
+	var awaiter := GdUnitSignalAwaiter.new(timeout_millis)
+	var value :Variant = await awaiter.on_signal(source, signal_name, args)
+	if awaiter.is_interrupted():
+		var failure := "await_signal_on(%s, %s) timed out after %sms" % [signal_name, args, timeout_millis]
+		assert_that.report_error(failure, line_number)
+	return value
+
+
+# Waits for a specified signal sent from the <source> between idle frames and aborts with an error after the specified timeout has elapsed
+# source: the object from which the signal is emitted
+# signal_name: signal name
+# args: the expected signal arguments as an array
+# timeout: the timeout in ms, default is set to 2000ms
+func await_signal_idle_frames(source :Object, signal_name :String, args :Array = [], timeout_millis :int = 2000) -> Variant:
+	var line_number := GdUnitAssertions.get_line_number()
+	# fail fast if the given source instance invalid
+	if not is_instance_valid(source):
+		GdUnitAssertImpl.new(signal_name)\
+			.report_error(GdAssertMessages.error_await_signal_on_invalid_instance(source, signal_name, args), line_number)
+		return await await_idle_frame()
+	var awaiter := GdUnitSignalAwaiter.new(timeout_millis, true)
+	var value :Variant = await awaiter.on_signal(source, signal_name, args)
+	if awaiter.is_interrupted():
+		var failure := "await_signal_idle_frames(%s, %s) timed out after %sms" % [signal_name, args, timeout_millis]
+		GdUnitAssertImpl.new(signal_name).report_error(failure, line_number)
+	return value
+
+
+# Waits for for a given amount of milliseconds
+# example:
+#    # waits for 100ms
+#    await GdUnitAwaiter.await_millis(myNode, 100).completed
+# use this waiter and not `await get_tree().create_timer().timeout to prevent errors when a test case is timed out
+func await_millis(milliSec :int) -> void:
+	var timer :Timer = Timer.new()
+	timer.set_name("gdunit_await_millis_timer_%d" % timer.get_instance_id())
+	Engine.get_main_loop().root.add_child(timer)
+	timer.add_to_group("GdUnitTimers")
+	timer.set_one_shot(true)
+	timer.start(milliSec / 1000.0)
+	await timer.timeout
+	timer.queue_free()
+
+
+# Waits until the next idle frame
+func await_idle_frame() -> void:
+	await Engine.get_main_loop().process_frame

addons/gdUnit4/src/GdUnitBoolAssert.gd

@@ -0,0 +1,41 @@
+## An Assertion Tool to verify boolean values
+class_name GdUnitBoolAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+func is_null() -> GdUnitBoolAssert:
+	return self
+
+
+## Verifies that the current value is not null.
+func is_not_null() -> GdUnitBoolAssert:
+	return self
+
+
+## Verifies that the current value is equal to the given one.
+@warning_ignore("unused_parameter")
+func is_equal(expected :Variant) -> GdUnitBoolAssert:
+	return self
+
+
+## Verifies that the current value is not equal to the given one.
+@warning_ignore("unused_parameter")
+func is_not_equal(expected :Variant) -> GdUnitBoolAssert:
+	return self
+
+
+## Verifies that the current value is true.
+func is_true() -> GdUnitBoolAssert:
+	return self
+
+
+## Verifies that the current value is false.
+func is_false() -> GdUnitBoolAssert:
+	return self
+
+
+## Overrides the default failure message by given custom message.
+@warning_ignore("unused_parameter")
+func override_failure_message(message :String) -> GdUnitBoolAssert:
+	return self

addons/gdUnit4/src/GdUnitConstants.gd

@@ -0,0 +1,6 @@
+class_name GdUnitConstants
+extends RefCounted
+
+const NO_ARG :Variant = "<--null-->"
+
+const EXPECT_ASSERT_REPORT_FAILURES := "expect_assert_report_failures"

addons/gdUnit4/src/GdUnitDictionaryAssert.gd

@@ -0,0 +1,105 @@
+## An Assertion Tool to verify dictionary
+class_name GdUnitDictionaryAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+func is_null() -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current value is not null.
+func is_not_null() -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary is equal to the given one, ignoring order.
+@warning_ignore("unused_parameter")
+func is_equal(expected :Variant) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary is not equal to the given one, ignoring order.
+@warning_ignore("unused_parameter")
+func is_not_equal(expected :Variant) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary is empty, it has a size of 0.
+func is_empty() -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary is not empty, it has a size of minimum 1.
+func is_not_empty() -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary is the same. [br]
+## Compares the current by object reference equals
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_same(expected :Variant) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary is NOT the same. [br]
+## Compares the current by object reference equals
+@warning_ignore("unused_parameter")
+func is_not_same(expected :Variant) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary has a size of given value.
+@warning_ignore("unused_parameter")
+func has_size(expected: int) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary contains the given key(s).[br]
+## The keys are compared by deep parameter comparision, for object reference compare you have to use [method contains_same_keys]
+@warning_ignore("unused_parameter")
+func contains_keys(expected :Array) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary contains the given key and value.[br]
+## The key and value are compared by deep parameter comparision, for object reference compare you have to use [method contains_same_key_value]
+@warning_ignore("unused_parameter")
+func contains_key_value(key :Variant, value :Variant) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary not contains the given key(s).[br]
+## This function is [b]deprecated[/b] you have to use [method not_contains_keys] instead
+@warning_ignore("unused_parameter")
+func contains_not_keys(expected :Array) -> GdUnitDictionaryAssert:
+	push_warning("Deprecated: 'contains_not_keys' is deprectated and will be removed soon, use `not_contains_keys` instead!")
+	return not_contains_keys(expected)
+
+
+## Verifies that the current dictionary not contains the given key(s).[br]
+## The keys are compared by deep parameter comparision, for object reference compare you have to use [method not_contains_same_keys]
+@warning_ignore("unused_parameter")
+func not_contains_keys(expected :Array) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary contains the given key(s).[br]
+## The keys are compared by object reference, for deep parameter comparision use [method contains_keys]
+@warning_ignore("unused_parameter")
+func contains_same_keys(expected :Array) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary contains the given key and value.[br]
+## The key and value are compared by object reference, for deep parameter comparision use [method contains_key_value]
+@warning_ignore("unused_parameter")
+func contains_same_key_value(key :Variant, value :Variant) -> GdUnitDictionaryAssert:
+	return self
+
+
+## Verifies that the current dictionary not contains the given key(s).
+## The keys are compared by object reference, for deep parameter comparision use [method not_contains_keys]
+@warning_ignore("unused_parameter")
+func not_contains_same_keys(expected :Array) -> GdUnitDictionaryAssert:
+	return self

addons/gdUnit4/src/GdUnitFailureAssert.gd

@@ -0,0 +1,31 @@
+## An assertion tool to verify GDUnit asserts.
+## This assert is for internal use only, to verify that failed asserts work as expected.
+class_name GdUnitFailureAssert
+extends GdUnitAssert
+
+
+## Verifies if the executed assert was successful
+func is_success() -> GdUnitFailureAssert:
+	return self
+
+## Verifies if the executed assert has failed
+func is_failed() -> GdUnitFailureAssert:
+	return self
+
+
+## Verifies the failure line is equal to expected one.
+@warning_ignore("unused_parameter")
+func has_line(expected :int) -> GdUnitFailureAssert:
+	return self
+
+
+## Verifies the failure message is equal to expected one.
+@warning_ignore("unused_parameter")
+func has_message(expected: String) -> GdUnitFailureAssert:
+	return self
+
+
+## Verifies that the failure message starts with the expected message.
+@warning_ignore("unused_parameter")
+func starts_with_message(expected: String) -> GdUnitFailureAssert:
+	return self

addons/gdUnit4/src/GdUnitFileAssert.gd

@@ -0,0 +1,19 @@
+class_name GdUnitFileAssert
+extends GdUnitAssert
+
+
+func is_file() -> GdUnitFileAssert:
+	return self
+
+
+func exists() -> GdUnitFileAssert:
+	return self
+
+
+func is_script() -> GdUnitFileAssert:
+	return self
+
+
+@warning_ignore("unused_parameter")
+func contains_exactly(expected_rows :Array) -> GdUnitFileAssert:
+	return self

addons/gdUnit4/src/GdUnitFloatAssert.gd

@@ -0,0 +1,83 @@
+## An Assertion Tool to verify float values
+class_name GdUnitFloatAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is equal to expected one.
+@warning_ignore("unused_parameter")
+func is_equal(expected :float) -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is not equal to expected one.
+@warning_ignore("unused_parameter")
+func is_not_equal(expected :float) -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current and expected value are approximately equal.
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_equal_approx(expected :float, approx :float) -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is less than the given one.
+@warning_ignore("unused_parameter")
+func is_less(expected :float) -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is less than or equal the given one.
+@warning_ignore("unused_parameter")
+func is_less_equal(expected :float) -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is greater than the given one.
+@warning_ignore("unused_parameter")
+func is_greater(expected :float) -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is greater than or equal the given one.
+@warning_ignore("unused_parameter")
+func is_greater_equal(expected :float) -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is negative.
+func is_negative() -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is not negative.
+func is_not_negative() -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is equal to zero.
+func is_zero() -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is not equal to zero.
+func is_not_zero() -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is in the given set of values.
+@warning_ignore("unused_parameter")
+func is_in(expected :Array) -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is not in the given set of values.
+@warning_ignore("unused_parameter")
+func is_not_in(expected :Array) -> GdUnitFloatAssert:
+	return self
+
+
+## Verifies that the current value is between the given boundaries (inclusive).
+@warning_ignore("unused_parameter")
+func is_between(from :float, to :float) -> GdUnitFloatAssert:
+	return self

addons/gdUnit4/src/GdUnitFuncAssert.gd

@@ -0,0 +1,56 @@
+## An Assertion Tool to verify function callback values
+class_name GdUnitFuncAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+func is_null() -> GdUnitFuncAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies that the current value is not null.
+func is_not_null() -> GdUnitFuncAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies that the current value is equal to the given one.
+@warning_ignore("unused_parameter")
+func is_equal(expected :Variant) -> GdUnitFuncAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies that the current value is not equal to the given one.
+@warning_ignore("unused_parameter")
+func is_not_equal(expected :Variant) -> GdUnitFuncAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies that the current value is true.
+func is_true() -> GdUnitFuncAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies that the current value is false.
+func is_false() -> GdUnitFuncAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Overrides the default failure message by given custom message.
+@warning_ignore("unused_parameter")
+func override_failure_message(message :String) -> GdUnitFuncAssert:
+	return self
+
+
+## Sets the timeout in ms to wait the function returnd the expected value, if the time over a failure is emitted.[br]
+## e.g.[br]
+## do wait until 5s the function `is_state` is returns 10 [br]
+## [code]assert_func(instance, "is_state").wait_until(5000).is_equal(10)[/code]
+@warning_ignore("unused_parameter")
+func wait_until(timeout :int) -> GdUnitFuncAssert:
+	return self

addons/gdUnit4/src/GdUnitGodotErrorAssert.gd

@@ -0,0 +1,46 @@
+## An assertion tool to verify for Godot runtime errors like assert() and push notifications like push_error().
+class_name GdUnitGodotErrorAssert
+extends GdUnitAssert
+
+
+## Verifies if the executed code runs without any runtime errors
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_success()
+##     [/codeblock]
+func is_success() -> GdUnitGodotErrorAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies if the executed code runs into a runtime error
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_runtime_error(<expected error message>)
+##     [/codeblock]
+@warning_ignore("unused_parameter")
+func is_runtime_error(expected_error :String) -> GdUnitGodotErrorAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies if the executed code has a push_warning() used
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_push_warning(<expected push warning message>)
+##     [/codeblock]
+@warning_ignore("unused_parameter")
+func is_push_warning(expected_warning :String) -> GdUnitGodotErrorAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies if the executed code has a push_error() used
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_push_error(<expected push error message>)
+##     [/codeblock]
+@warning_ignore("unused_parameter")
+func is_push_error(expected_error :String) -> GdUnitGodotErrorAssert:
+	await Engine.get_main_loop().process_frame
+	return self

addons/gdUnit4/src/GdUnitIntAssert.gd

@@ -0,0 +1,87 @@
+## An Assertion Tool to verify integer values
+class_name GdUnitIntAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is equal to expected one.
+@warning_ignore("unused_parameter")
+func is_equal(expected :int) -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is not equal to expected one.
+@warning_ignore("unused_parameter")
+func is_not_equal(expected :int) -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is less than the given one.
+@warning_ignore("unused_parameter")
+func is_less(expected :int) -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is less than or equal the given one.
+@warning_ignore("unused_parameter")
+func is_less_equal(expected :int) -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is greater than the given one.
+@warning_ignore("unused_parameter")
+func is_greater(expected :int) -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is greater than or equal the given one.
+@warning_ignore("unused_parameter")
+func is_greater_equal(expected :int) -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is even.
+func is_even() -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is odd.
+func is_odd() -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is negative.
+func is_negative() -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is not negative.
+func is_not_negative() -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is equal to zero.
+func is_zero() -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is not equal to zero.
+func is_not_zero() -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is in the given set of values.
+@warning_ignore("unused_parameter")
+func is_in(expected :Array) -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is not in the given set of values.
+@warning_ignore("unused_parameter")
+func is_not_in(expected :Array) -> GdUnitIntAssert:
+	return self
+
+
+## Verifies that the current value is between the given boundaries (inclusive).
+@warning_ignore("unused_parameter")
+func is_between(from :int, to :int) -> GdUnitIntAssert:
+	return self

addons/gdUnit4/src/GdUnitObjectAssert.gd

@@ -0,0 +1,49 @@
+## An Assertion Tool to verify Object values
+class_name GdUnitObjectAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is equal to expected one.
+@warning_ignore("unused_parameter")
+func is_equal(expected :Variant) -> GdUnitObjectAssert:
+	return self
+
+
+## Verifies that the current value is not equal to expected one.
+@warning_ignore("unused_parameter")
+func is_not_equal(expected :Variant) -> GdUnitObjectAssert:
+	return self
+
+
+## Verifies that the current value is null.
+func is_null() -> GdUnitObjectAssert:
+	return self
+
+
+## Verifies that the current value is not null.
+func is_not_null() -> GdUnitObjectAssert:
+	return self
+
+
+## Verifies that the current value is the same as the given one.
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_same(expected :Variant) -> GdUnitObjectAssert:
+	return self
+
+
+## Verifies that the current value is not the same as the given one.
+@warning_ignore("unused_parameter")
+func is_not_same(expected :Variant) -> GdUnitObjectAssert:
+	return self
+
+
+## Verifies that the current value is an instance of the given type.
+@warning_ignore("unused_parameter")
+func is_instanceof(expected :Object) -> GdUnitObjectAssert:
+	return self
+
+
+## Verifies that the current value is not an instance of the given type.
+@warning_ignore("unused_parameter")
+func is_not_instanceof(expected :Variant) -> GdUnitObjectAssert:
+	return self

addons/gdUnit4/src/GdUnitResultAssert.gd

@@ -0,0 +1,45 @@
+## An Assertion Tool to verify Results
+class_name GdUnitResultAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+func is_null() -> GdUnitResultAssert:
+	return self
+
+
+## Verifies that the current value is not null.
+func is_not_null() -> GdUnitResultAssert:
+	return self
+
+
+## Verifies that the result is ends up with empty
+func is_empty() -> GdUnitResultAssert:
+	return self
+
+
+## Verifies that the result is ends up with success
+func is_success() -> GdUnitResultAssert:
+	return self
+
+
+## Verifies that the result is ends up with warning
+func is_warning() -> GdUnitResultAssert:
+	return self
+
+
+## Verifies that the result is ends up with error
+func is_error() -> GdUnitResultAssert:
+	return self
+
+
+## Verifies that the result contains the given message
+@warning_ignore("unused_parameter")
+func contains_message(expected :String) -> GdUnitResultAssert:
+	return self
+
+
+## Verifies that the result contains the given value
+@warning_ignore("unused_parameter")
+func is_value(expected :Variant) -> GdUnitResultAssert:
+	return self

addons/gdUnit4/src/GdUnitSceneRunner.gd

@@ -0,0 +1,286 @@
+## The scene runner for GdUnit to simmulate scene interactions
+class_name GdUnitSceneRunner
+extends RefCounted
+
+const NO_ARG = GdUnitConstants.NO_ARG
+
+
+## Sets the mouse cursor to given position relative to the viewport.
+@warning_ignore("unused_parameter")
+func set_mouse_pos(pos :Vector2) -> GdUnitSceneRunner:
+	return self
+
+
+## Gets the current mouse position of the current viewport
+func get_mouse_position() -> Vector2:
+	return Vector2.ZERO
+
+
+## Gets the current global mouse position of the current window
+func get_global_mouse_position() -> Vector2:
+	return Vector2.ZERO
+
+
+## Simulates that an action has been pressed.[br]
+## [member action] : the action e.g. [code]"ui_up"[/code][br]
+@warning_ignore("unused_parameter")
+func simulate_action_pressed(action :String) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates that an action is pressed.[br]
+## [member action] : the action e.g. [code]"ui_up"[/code][br]
+@warning_ignore("unused_parameter")
+func simulate_action_press(action :String) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates that an action has been released.[br]
+## [member action] : the action e.g. [code]"ui_up"[/code][br]
+@warning_ignore("unused_parameter")
+func simulate_action_release(action :String) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates that a key has been pressed.[br]
+## [member key_code] : the key code e.g. [constant KEY_ENTER][br]
+## [member shift_pressed] : false by default set to true if simmulate shift is press[br]
+## [member ctrl_pressed] : false by default set to true if simmulate control is press[br]
+@warning_ignore("unused_parameter")
+func simulate_key_pressed(key_code :int, shift_pressed := false, ctrl_pressed := false) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates that a key is pressed.[br]
+## [member key_code] : the key code e.g. [constant KEY_ENTER][br]
+## [member shift_pressed] : false by default set to true if simmulate shift is press[br]
+## [member ctrl_pressed] : false by default set to true if simmulate control is press[br]
+@warning_ignore("unused_parameter")
+func simulate_key_press(key_code :int, shift_pressed := false, ctrl_pressed := false) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates that a key has been released.[br]
+## [member key_code] : the key code e.g. [constant KEY_ENTER][br]
+## [member shift_pressed] : false by default set to true if simmulate shift is press[br]
+## [member ctrl_pressed] : false by default set to true if simmulate control is press[br]
+@warning_ignore("unused_parameter")
+func simulate_key_release(key_code :int, shift_pressed := false, ctrl_pressed := false) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates a mouse moved to final position.[br]
+## [member pos] : The final mouse position
+@warning_ignore("unused_parameter")
+func simulate_mouse_move(pos :Vector2) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates a mouse move to the relative coordinates (offset).[br]
+## [color=yellow]You must use [b]await[/b] to wait until the simulated mouse movement is complete.[/color][br]
+## [br]
+## [member relative] : The relative position, indicating the mouse position offset.[br]
+## [member time] : The time to move the mouse by the relative position in seconds (default is 1 second).[br]
+## [member trans_type] : Sets the type of transition used (default is TRANS_LINEAR).[br]
+## [codeblock]
+##    func test_move_mouse():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       await runner.simulate_mouse_move_relative(Vector2(100,100))
+## [/codeblock]
+@warning_ignore("unused_parameter")
+func simulate_mouse_move_relative(relative: Vector2, time: float = 1.0, trans_type: Tween.TransitionType = Tween.TRANS_LINEAR) -> GdUnitSceneRunner:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Simulates a mouse move to the absolute coordinates.[br]
+## [color=yellow]You must use [b]await[/b] to wait until the simulated mouse movement is complete.[/color][br]
+## [br]
+## [member position] : The final position of the mouse.[br]
+## [member time] : The time to move the mouse to the final position in seconds (default is 1 second).[br]
+## [member trans_type] : Sets the type of transition used (default is TRANS_LINEAR).[br]
+## [codeblock]
+##    func test_move_mouse():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       await runner.simulate_mouse_move_absolute(Vector2(100,100))
+## [/codeblock]
+@warning_ignore("unused_parameter")
+func simulate_mouse_move_absolute(position: Vector2, time: float = 1.0, trans_type: Tween.TransitionType = Tween.TRANS_LINEAR) -> GdUnitSceneRunner:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Simulates a mouse button pressed.[br]
+## [member buttonIndex] : The mouse button identifier, one of the [enum MouseButton] or button wheel constants.
+@warning_ignore("unused_parameter")
+func simulate_mouse_button_pressed(buttonIndex :MouseButton, double_click := false) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates a mouse button press (holding)[br]
+## [member buttonIndex] : The mouse button identifier, one of the [enum MouseButton] or button wheel constants.
+@warning_ignore("unused_parameter")
+func simulate_mouse_button_press(buttonIndex :MouseButton, double_click := false) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates a mouse button released.[br]
+## [member buttonIndex] : The mouse button identifier, one of the [enum MouseButton] or button wheel constants.
+@warning_ignore("unused_parameter")
+func simulate_mouse_button_release(buttonIndex :MouseButton) -> GdUnitSceneRunner:
+	return self
+
+
+## Sets how fast or slow the scene simulation is processed (clock ticks versus the real).[br]
+## It defaults to 1.0. A value of 2.0 means the game moves twice as fast as real life,
+## whilst a value of 0.5 means the game moves at half the regular speed.
+@warning_ignore("unused_parameter")
+func set_time_factor(time_factor := 1.0) -> GdUnitSceneRunner:
+	return self
+
+
+## Simulates scene processing for a certain number of frames.[br]
+## [member frames] : amount of frames to process[br]
+## [member delta_milli] : the time delta between a frame in milliseconds
+@warning_ignore("unused_parameter")
+func simulate_frames(frames: int, delta_milli :int = -1) -> GdUnitSceneRunner:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Simulates scene processing until the given signal is emitted by the scene.[br]
+## [member signal_name] : the signal to stop the simulation[br]
+## [member args] : optional signal arguments to be matched for stop[br]
+@warning_ignore("unused_parameter")
+func simulate_until_signal(
+	signal_name :String,
+	arg0 :Variant = NO_ARG,
+	arg1 :Variant = NO_ARG,
+	arg2 :Variant = NO_ARG,
+	arg3 :Variant = NO_ARG,
+	arg4 :Variant = NO_ARG,
+	arg5 :Variant = NO_ARG,
+	arg6 :Variant = NO_ARG,
+	arg7 :Variant = NO_ARG,
+	arg8 :Variant = NO_ARG,
+	arg9 :Variant = NO_ARG) -> GdUnitSceneRunner:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Simulates scene processing until the given signal is emitted by the given object.[br]
+## [member source] : the object that should emit the signal[br]
+## [member signal_name] : the signal to stop the simulation[br]
+## [member args] : optional signal arguments to be matched for stop
+@warning_ignore("unused_parameter")
+func simulate_until_object_signal(
+	source :Object,
+	signal_name :String,
+	arg0 :Variant = NO_ARG,
+	arg1 :Variant = NO_ARG,
+	arg2 :Variant = NO_ARG,
+	arg3 :Variant = NO_ARG,
+	arg4 :Variant = NO_ARG,
+	arg5 :Variant = NO_ARG,
+	arg6 :Variant = NO_ARG,
+	arg7 :Variant = NO_ARG,
+	arg8 :Variant = NO_ARG,
+	arg9 :Variant = NO_ARG) -> GdUnitSceneRunner:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+### Waits for all input events are processed
+func await_input_processed() -> void:
+	await Engine.get_main_loop().process_frame
+	await Engine.get_main_loop().physics_frame
+
+
+## Waits for the function return value until specified timeout or fails.[br]
+## [member args] : optional function arguments
+@warning_ignore("unused_parameter")
+func await_func(func_name :String, args := []) -> GdUnitFuncAssert:
+	return null
+
+
+## Waits for the function return value of specified source until specified timeout or fails.[br]
+## [member source : the object where implements the function[br]
+## [member args] : optional function arguments
+@warning_ignore("unused_parameter")
+func await_func_on(source :Object, func_name :String, args := []) -> GdUnitFuncAssert:
+	return null
+
+
+## Waits for given signal is emited by the scene until a specified timeout to fail.[br]
+## [member signal_name] : signal name[br]
+## [member args] : the expected signal arguments as an array[br]
+## [member timeout] : the timeout in ms, default is set to 2000ms
+@warning_ignore("unused_parameter")
+func await_signal(signal_name :String, args := [], timeout := 2000 ) -> void:
+	await Engine.get_main_loop().process_frame
+	pass
+
+
+## Waits for given signal is emited by the <source> until a specified timeout to fail.[br]
+## [member source] : the object from which the signal is emitted[br]
+## [member signal_name] : signal name[br]
+## [member args] : the expected signal arguments as an array[br]
+## [member timeout] : the timeout in ms, default is set to 2000ms
+@warning_ignore("unused_parameter")
+func await_signal_on(source :Object, signal_name :String, args := [], timeout := 2000 ) -> void:
+	pass
+
+
+## maximizes the window to bring the scene visible
+func maximize_view() -> GdUnitSceneRunner:
+	return self
+
+
+## Return the current value of the property with the name <name>.[br]
+## [member name] : name of property[br]
+## [member return] : the value of the property
+@warning_ignore("unused_parameter")
+func get_property(name :String) -> Variant:
+	return null
+
+## Set the  value <value> of the property with the name <name>.[br]
+## [member name] : name of property[br]
+## [member value] : value of property[br]
+## [member return] : true|false depending on valid property name.
+@warning_ignore("unused_parameter")
+func set_property(name :String, value :Variant) -> bool:
+	return false
+
+
+## executes the function specified by <name> in the scene and returns the result.[br]
+## [member name] : the name of the function to execute[br]
+## [member args] : optional function arguments[br]
+## [member return] : the function result
+@warning_ignore("unused_parameter")
+func invoke(
+	name :String,
+	arg0 :Variant = NO_ARG,
+	arg1 :Variant = NO_ARG,
+	arg2 :Variant = NO_ARG,
+	arg3 :Variant = NO_ARG,
+	arg4 :Variant = NO_ARG,
+	arg5 :Variant = NO_ARG,
+	arg6 :Variant = NO_ARG,
+	arg7 :Variant = NO_ARG,
+	arg8 :Variant = NO_ARG,
+	arg9 :Variant = NO_ARG) -> Variant:
+	return null
+
+
+## Searches for the specified node with the name in the current scene and returns it, otherwise null.[br]
+## [member name] : the name of the node to find[br]
+## [member recursive] : enables/disables seraching recursive[br]
+## [member return] : the node if find otherwise null
+@warning_ignore("unused_parameter")
+func find_child(name :String, recursive :bool = true, owned :bool = false) -> Node:
+	return null
+
+
+## Access to current running scene
+func scene() -> Node:
+	return null

addons/gdUnit4/src/GdUnitSignalAssert.gd

@@ -0,0 +1,38 @@
+## An Assertion Tool to verify for emitted signals until a waiting time
+class_name GdUnitSignalAssert
+extends GdUnitAssert
+
+
+## Verifies that given signal is emitted until waiting time
+@warning_ignore("unused_parameter")
+func is_emitted(name :String, args := []) -> GdUnitSignalAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies that given signal is NOT emitted until waiting time
+@warning_ignore("unused_parameter")
+func is_not_emitted(name :String, args := []) -> GdUnitSignalAssert:
+	await Engine.get_main_loop().process_frame
+	return self
+
+
+## Verifies the signal exists checked the emitter
+@warning_ignore("unused_parameter")
+func is_signal_exists(name :String) -> GdUnitSignalAssert:
+	return self
+
+
+## Overrides the default failure message by given custom message.
+@warning_ignore("unused_parameter")
+func override_failure_message(message :String) -> GdUnitSignalAssert:
+	return self
+
+
+## Sets the assert signal timeout in ms, if the time over a failure is reported.[br]
+## e.g.[br]
+## do wait until 5s the instance has emitted the signal `signal_a`[br]
+## [code]assert_signal(instance).wait_until(5000).is_emitted("signal_a")[/code]
+@warning_ignore("unused_parameter")
+func wait_until(timeout :int) -> GdUnitSignalAssert:
+	return self

addons/gdUnit4/src/GdUnitStringAssert.gd

@@ -0,0 +1,79 @@
+## An Assertion Tool to verify String values
+class_name GdUnitStringAssert
+extends GdUnitAssert
+
+
+## Verifies that the current String is equal to the given one.
+@warning_ignore("unused_parameter")
+func is_equal(expected :Variant) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String is equal to the given one, ignoring case considerations.
+@warning_ignore("unused_parameter")
+func is_equal_ignoring_case(expected :Variant) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String is not equal to the given one.
+@warning_ignore("unused_parameter")
+func is_not_equal(expected :Variant) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String is not equal to the given one, ignoring case considerations.
+@warning_ignore("unused_parameter")
+func is_not_equal_ignoring_case(expected :Variant) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String is empty, it has a length of 0.
+func is_empty() -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String is not empty, it has a length of minimum 1.
+func is_not_empty() -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String contains the given String.
+@warning_ignore("unused_parameter")
+func contains(expected: String) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String does not contain the given String.
+@warning_ignore("unused_parameter")
+func not_contains(expected: String) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String does not contain the given String, ignoring case considerations.
+@warning_ignore("unused_parameter")
+func contains_ignoring_case(expected: String) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String does not contain the given String, ignoring case considerations.
+@warning_ignore("unused_parameter")
+func not_contains_ignoring_case(expected: String) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String starts with the given prefix.
+@warning_ignore("unused_parameter")
+func starts_with(expected: String) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String ends with the given suffix.
+@warning_ignore("unused_parameter")
+func ends_with(expected: String) -> GdUnitStringAssert:
+	return self
+
+
+## Verifies that the current String has the expected length by used comparator.
+@warning_ignore("unused_parameter")
+func has_length(length: int, comparator: int = Comparator.EQUAL) -> GdUnitStringAssert:
+	return self

addons/gdUnit4/src/GdUnitTestSuite.gd

@@ -0,0 +1,620 @@
+## The main class for all GdUnit test suites[br]
+## This class is the main class to implement your unit tests[br]
+## You have to extend and implement your test cases as described[br]
+## e.g MyTests.gd [br]
+## [codeblock]
+##    extends GdUnitTestSuite
+##    # testcase
+##    func test_case_a():
+##       assert_that("value").is_equal("value")
+## [/codeblock]
+## @tutorial:  https://mikeschulze.github.io/gdUnit4/faq/test-suite/
+
+@icon("res://addons/gdUnit4/src/ui/assets/TestSuite.svg")
+class_name GdUnitTestSuite
+extends Node
+
+const NO_ARG :Variant = GdUnitConstants.NO_ARG
+
+### internal runtime variables that must not be overwritten!!!
+@warning_ignore("unused_private_class_variable")
+var __is_skipped := false
+@warning_ignore("unused_private_class_variable")
+var __skip_reason :String = "Unknow."
+var __active_test_case :String
+var __awaiter := __gdunit_awaiter()
+# holds the actual execution context
+var __execution_context :RefCounted
+
+
+### We now load all used asserts and tool scripts into the cache according to the principle of "lazy loading"
+### in order to noticeably reduce the loading time of the test suite.
+# We go this hard way to increase the loading performance to avoid reparsing all the used scripts
+# for more detailed info -> https://github.com/godotengine/godot/issues/67400
+func __lazy_load(script_path :String) -> GDScript:
+	return GdUnitAssertions.__lazy_load(script_path)
+
+
+func __gdunit_assert() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd")
+
+
+func __gdunit_tools() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+
+func __gdunit_file_access() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/core/GdUnitFileAccess.gd")
+
+
+func __gdunit_awaiter() -> Object:
+	return __lazy_load("res://addons/gdUnit4/src/GdUnitAwaiter.gd").new()
+
+
+func __gdunit_argument_matchers() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/matchers/GdUnitArgumentMatchers.gd")
+
+
+func __gdunit_object_interactions() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/core/GdUnitObjectInteractions.gd")
+
+
+## This function is called before a test suite starts[br]
+## You can overwrite to prepare test data or initalizize necessary variables
+func before() -> void:
+	pass
+
+
+## This function is called at least when a test suite is finished[br]
+## You can overwrite to cleanup data created during test running
+func after() -> void:
+	pass
+
+
+## This function is called before a test case starts[br]
+## You can overwrite to prepare test case specific data
+func before_test() -> void:
+	pass
+
+
+## This function is called after the test case is finished[br]
+## You can overwrite to cleanup your test case specific data
+func after_test() -> void:
+	pass
+
+
+func is_failure(_expected_failure :String = NO_ARG) -> bool:
+	return Engine.get_meta("GD_TEST_FAILURE") if Engine.has_meta("GD_TEST_FAILURE") else false
+
+
+func set_active_test_case(test_case :String) -> void:
+	__active_test_case = test_case
+
+
+# === Tools ====================================================================
+# Mapps Godot error number to a readable error message. See at ERROR
+# https://docs.godotengine.org/de/stable/classes/class_@globalscope.html#enum-globalscope-error
+func error_as_string(error_number :int) -> String:
+	return error_string(error_number)
+
+
+## A litle helper to auto freeing your created objects after test execution
+func auto_free(obj :Variant) -> Variant:
+	if __execution_context != null:
+		return __execution_context.register_auto_free(obj)
+	else:
+		if is_instance_valid(obj):
+			obj.queue_free()
+		return obj
+
+
+@warning_ignore("native_method_override")
+func add_child(node :Node, force_readable_name := false, internal := Node.INTERNAL_MODE_DISABLED) -> void:
+	super.add_child(node, force_readable_name, internal)
+	if __execution_context != null:
+		__execution_context.orphan_monitor_start()
+
+
+## Discard the error message triggered by a timeout (interruption).[br]
+## By default, an interrupted test is reported as an error.[br]
+## This function allows you to change the message to Success when an interrupted error is reported.
+func discard_error_interupted_by_timeout() -> void:
+	__gdunit_tools().register_expect_interupted_by_timeout(self, __active_test_case)
+
+
+## Creates a new directory under the temporary directory *user://tmp*[br]
+## Useful for storing data during test execution. [br]
+## The directory is automatically deleted after test suite execution
+func create_temp_dir(relative_path :String) -> String:
+	return __gdunit_file_access().create_temp_dir(relative_path)
+
+
+## Deletes the temporary base directory[br]
+## Is called automatically after each execution of the test suite
+func clean_temp_dir() -> void:
+	__gdunit_file_access().clear_tmp()
+
+
+## Creates a new file under the temporary directory *user://tmp* + <relative_path>[br]
+## with given name <file_name> and given file <mode> (default = File.WRITE)[br]
+## If success the returned File is automatically closed after the execution of the test suite
+func create_temp_file(relative_path :String, file_name :String, mode := FileAccess.WRITE) -> FileAccess:
+	return __gdunit_file_access().create_temp_file(relative_path, file_name, mode)
+
+
+## Reads a resource by given path <resource_path> into a PackedStringArray.
+func resource_as_array(resource_path :String) -> PackedStringArray:
+	return __gdunit_file_access().resource_as_array(resource_path)
+
+
+## Reads a resource by given path <resource_path> and returned the content as String.
+func resource_as_string(resource_path :String) -> String:
+	return __gdunit_file_access().resource_as_string(resource_path)
+
+
+## Reads a resource by given path <resource_path> and return Variand translated by str_to_var
+func resource_as_var(resource_path :String) -> Variant:
+	return str_to_var(__gdunit_file_access().resource_as_string(resource_path))
+
+
+## clears the debuger error list[br]
+## PROTOTYPE!!!! Don't use it for now
+func clear_push_errors() -> void:
+	__gdunit_tools().clear_push_errors()
+
+
+## Waits for given signal is emited by the <source> until a specified timeout to fail[br]
+## source: the object from which the signal is emitted[br]
+## signal_name: signal name[br]
+## args: the expected signal arguments as an array[br]
+## timeout: the timeout in ms, default is set to 2000ms
+func await_signal_on(source :Object, signal_name :String, args :Array = [], timeout :int = 2000) -> Variant:
+	return await __awaiter.await_signal_on(source, signal_name, args, timeout)
+
+
+## Waits until the next idle frame
+func await_idle_frame() -> void:
+	await __awaiter.await_idle_frame()
+
+
+## Waits for for a given amount of milliseconds[br]
+## example:[br]
+## [codeblock]
+##    # waits for 100ms
+##    await await_millis(myNode, 100).completed
+## [/codeblock][br]
+## use this waiter and not `await get_tree().create_timer().timeout to prevent errors when a test case is timed out
+func await_millis(timeout :int) -> void:
+	await __awaiter.await_millis(timeout)
+
+
+## Creates a new scene runner to allow simulate interactions checked a scene.[br]
+## The runner will manage the scene instance and release after the runner is released[br]
+## example:[br]
+## [codeblock]
+##    # creates a runner by using a instanciated scene
+##    var scene = load("res://foo/my_scne.tscn").instantiate()
+##    var runner := scene_runner(scene)
+##
+##    # or simply creates a runner by using the scene resource path
+##    var runner := scene_runner("res://foo/my_scne.tscn")
+## [/codeblock]
+func scene_runner(scene :Variant, verbose := false) -> GdUnitSceneRunner:
+	return auto_free(__lazy_load("res://addons/gdUnit4/src/core/GdUnitSceneRunnerImpl.gd").new(scene, verbose))
+
+
+# === Mocking  & Spy ===========================================================
+
+## do return a default value for primitive types or null
+const RETURN_DEFAULTS = GdUnitMock.RETURN_DEFAULTS
+## do call the real implementation
+const CALL_REAL_FUNC = GdUnitMock.CALL_REAL_FUNC
+## do return a default value for primitive types and a fully mocked value for Object types
+## builds full deep mocked object
+const RETURN_DEEP_STUB = GdUnitMock.RETURN_DEEP_STUB
+
+
+## Creates a mock for given class name
+func mock(clazz :Variant, mock_mode := RETURN_DEFAULTS) -> Variant:
+	return __lazy_load("res://addons/gdUnit4/src/mocking/GdUnitMockBuilder.gd").build(clazz, mock_mode)
+
+
+## Creates a spy checked given object instance
+func spy(instance :Variant) -> Variant:
+	return __lazy_load("res://addons/gdUnit4/src/spy/GdUnitSpyBuilder.gd").build(instance)
+
+
+## Configures a return value for the specified function and used arguments.[br]
+## [b]Example:
+## 	[codeblock]
+## 		# overrides the return value of myMock.is_selected() to false
+## 		do_return(false).on(myMock).is_selected()
+## 	[/codeblock]
+func do_return(value :Variant) -> GdUnitMock:
+	return GdUnitMock.new(value)
+
+
+## Verifies certain behavior happened at least once or exact number of times
+func verify(obj :Variant, times := 1) -> Variant:
+	return __gdunit_object_interactions().verify(obj, times)
+
+
+## Verifies no interactions is happen checked this mock or spy
+func verify_no_interactions(obj :Variant) -> GdUnitAssert:
+	return __gdunit_object_interactions().verify_no_interactions(obj)
+
+
+## Verifies the given mock or spy has any unverified interaction.
+func verify_no_more_interactions(obj :Variant) -> GdUnitAssert:
+	return __gdunit_object_interactions().verify_no_more_interactions(obj)
+
+
+## Resets the saved function call counters checked a mock or spy
+func reset(obj :Variant) -> void:
+	__gdunit_object_interactions().reset(obj)
+
+
+## Starts monitoring the specified source to collect all transmitted signals.[br]
+## The collected signals can then be checked with 'assert_signal'.[br]
+## By default, the specified source is automatically released when the test ends.
+## You can control this behavior by setting auto_free to false if you do not want the source to be automatically freed.[br]
+## Usage:
+##	[codeblock]
+##		var emitter := monitor_signals(MyEmitter.new())
+##		# call the function to send the signal
+##		emitter.do_it()
+##		# verify the signial is emitted
+##		await assert_signal(emitter).is_emitted('my_signal')
+##	[/codeblock]
+func monitor_signals(source :Object, _auto_free := true) -> Object:
+	__lazy_load("res://addons/gdUnit4/src/core/thread/GdUnitThreadManager.gd")\
+		.get_current_context()\
+		.get_signal_collector()\
+		.register_emitter(source)
+	return auto_free(source) if _auto_free else source
+
+
+# === Argument matchers ========================================================
+## Argument matcher to match any argument
+func any() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().any()
+
+
+## Argument matcher to match any boolean value
+func any_bool() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_BOOL)
+
+
+## Argument matcher to match any integer value
+func any_int() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_INT)
+
+
+## Argument matcher to match any float value
+func any_float() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_FLOAT)
+
+
+## Argument matcher to match any string value
+func any_string() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_STRING)
+
+
+## Argument matcher to match any Color value
+func any_color() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_COLOR)
+
+
+## Argument matcher to match any Vector typed value
+func any_vector() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_types([
+		TYPE_VECTOR2,
+		TYPE_VECTOR2I,
+		TYPE_VECTOR3,
+		TYPE_VECTOR3I,
+		TYPE_VECTOR4,
+		TYPE_VECTOR4I,
+	])
+
+
+## Argument matcher to match any Vector2 value
+func any_vector2() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR2)
+
+
+## Argument matcher to match any Vector2i value
+func any_vector2i() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR2I)
+
+
+## Argument matcher to match any Vector3 value
+func any_vector3() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR3)
+
+
+## Argument matcher to match any Vector3i value
+func any_vector3i() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR3I)
+
+
+## Argument matcher to match any Vector4 value
+func any_vector4() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR4)
+
+
+## Argument matcher to match any Vector3i value
+func any_vector4i() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR4I)
+
+
+## Argument matcher to match any Rect2 value
+func any_rect2() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_RECT2)
+
+
+## Argument matcher to match any Plane value
+func any_plane() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PLANE)
+
+
+## Argument matcher to match any Quaternion value
+func any_quat() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_QUATERNION)
+
+
+## Argument matcher to match any AABB value
+func any_aabb() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_AABB)
+
+
+## Argument matcher to match any Basis value
+func any_basis() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_BASIS)
+
+
+## Argument matcher to match any Transform2D value
+func any_transform_2d() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_TRANSFORM2D)
+
+
+## Argument matcher to match any Transform3D value
+func any_transform_3d() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_TRANSFORM3D)
+
+
+## Argument matcher to match any NodePath value
+func any_node_path() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_NODE_PATH)
+
+
+## Argument matcher to match any RID value
+func any_rid() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_RID)
+
+
+## Argument matcher to match any Object value
+func any_object() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_OBJECT)
+
+
+## Argument matcher to match any Dictionary value
+func any_dictionary() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_DICTIONARY)
+
+
+## Argument matcher to match any Array value
+func any_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_ARRAY)
+
+
+## Argument matcher to match any PackedByteArray value
+func any_packed_byte_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_BYTE_ARRAY)
+
+
+## Argument matcher to match any PackedInt32Array value
+func any_packed_int32_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_INT32_ARRAY)
+
+
+## Argument matcher to match any PackedInt64Array value
+func any_packed_int64_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_INT64_ARRAY)
+
+
+## Argument matcher to match any PackedFloat32Array value
+func any_packed_float32_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_FLOAT32_ARRAY)
+
+
+## Argument matcher to match any PackedFloat64Array value
+func any_packed_float64_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_FLOAT64_ARRAY)
+
+
+## Argument matcher to match any PackedStringArray value
+func any_packed_string_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_STRING_ARRAY)
+
+
+## Argument matcher to match any PackedVector2Array value
+func any_packed_vector2_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_VECTOR2_ARRAY)
+
+
+## Argument matcher to match any PackedVector3Array value
+func any_packed_vector3_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_VECTOR3_ARRAY)
+
+
+## Argument matcher to match any PackedColorArray value
+func any_packed_color_array() -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_COLOR_ARRAY)
+
+
+## Argument matcher to match any instance of given class
+func any_class(clazz :Object) -> GdUnitArgumentMatcher:
+	return __gdunit_argument_matchers().any_class(clazz)
+
+
+# === value extract utils ======================================================
+## Builds an extractor by given function name and optional arguments
+func extr(func_name :String, args := Array()) -> GdUnitValueExtractor:
+	return __lazy_load("res://addons/gdUnit4/src/extractors/GdUnitFuncValueExtractor.gd").new(func_name, args)
+
+
+## Constructs a tuple by given arguments
+func tuple(arg0 :Variant,
+	arg1 :Variant=NO_ARG,
+	arg2 :Variant=NO_ARG,
+	arg3 :Variant=NO_ARG,
+	arg4 :Variant=NO_ARG,
+	arg5 :Variant=NO_ARG,
+	arg6 :Variant=NO_ARG,
+	arg7 :Variant=NO_ARG,
+	arg8 :Variant=NO_ARG,
+	arg9 :Variant=NO_ARG) -> GdUnitTuple:
+	return GdUnitTuple.new(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+
+
+# === Asserts ==================================================================
+
+## The common assertion tool to verify values.
+## It checks the given value by type to fit to the best assert
+func assert_that(current :Variant) -> GdUnitAssert:
+	match typeof(current):
+		TYPE_BOOL:
+			return assert_bool(current)
+		TYPE_INT:
+			return assert_int(current)
+		TYPE_FLOAT:
+			return assert_float(current)
+		TYPE_STRING:
+			return assert_str(current)
+		TYPE_VECTOR2, TYPE_VECTOR2I, TYPE_VECTOR3, TYPE_VECTOR3I, TYPE_VECTOR4, TYPE_VECTOR4I:
+			return assert_vector(current)
+		TYPE_DICTIONARY:
+			return assert_dict(current)
+		TYPE_ARRAY, TYPE_PACKED_BYTE_ARRAY, TYPE_PACKED_INT32_ARRAY, TYPE_PACKED_INT64_ARRAY,\
+		TYPE_PACKED_FLOAT32_ARRAY, TYPE_PACKED_FLOAT64_ARRAY, TYPE_PACKED_STRING_ARRAY,\
+		TYPE_PACKED_VECTOR2_ARRAY, TYPE_PACKED_VECTOR3_ARRAY, TYPE_PACKED_COLOR_ARRAY:
+			return assert_array(current)
+		TYPE_OBJECT, TYPE_NIL:
+			return assert_object(current)
+		_:
+			return __gdunit_assert().new(current)
+
+
+## An assertion tool to verify boolean values.
+func assert_bool(current :Variant) -> GdUnitBoolAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitBoolAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify String values.
+func assert_str(current :Variant) -> GdUnitStringAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitStringAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify integer values.
+func assert_int(current :Variant) -> GdUnitIntAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitIntAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify float values.
+func assert_float(current :Variant) -> GdUnitFloatAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFloatAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify Vector values.[br]
+## This assertion supports all vector types.[br]
+## Usage:
+##     [codeblock]
+##		assert_vector(Vector2(1.2, 1.000001)).is_equal(Vector2(1.2, 1.000001))
+##     [/codeblock]
+func assert_vector(current :Variant) -> GdUnitVectorAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitVectorAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify arrays.
+func assert_array(current :Variant) -> GdUnitArrayAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitArrayAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify dictionaries.
+func assert_dict(current :Variant) -> GdUnitDictionaryAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitDictionaryAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify FileAccess.
+func assert_file(current :Variant) -> GdUnitFileAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFileAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify Objects.
+func assert_object(current :Variant) -> GdUnitObjectAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitObjectAssertImpl.gd").new(current)
+
+
+func assert_result(current :Variant) -> GdUnitResultAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitResultAssertImpl.gd").new(current)
+
+
+## An assertion tool that waits until a certain time for an expected function return value
+func assert_func(instance :Object, func_name :String, args := Array()) -> GdUnitFuncAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFuncAssertImpl.gd").new(instance, func_name, args)
+
+
+## An Assertion Tool to verify for emitted signals until a certain time.
+func assert_signal(instance :Object) -> GdUnitSignalAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitSignalAssertImpl.gd").new(instance)
+
+
+## An assertion tool to test for failing assertions.[br]
+## This assert is only designed for internal use to verify failing asserts working as expected.[br]
+## Usage:
+##     [codeblock]
+##		assert_failure(func(): assert_bool(true).is_not_equal(true)) \
+##		    .has_message("Expecting:\n 'true'\n not equal to\n 'true'")
+##     [/codeblock]
+func assert_failure(assertion :Callable) -> GdUnitFailureAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd").new().execute(assertion)
+
+
+## An assertion tool to test for failing assertions.[br]
+## This assert is only designed for internal use to verify failing asserts working as expected.[br]
+## Usage:
+##     [codeblock]
+##		await assert_failure_await(func(): assert_bool(true).is_not_equal(true)) \
+##		    .has_message("Expecting:\n 'true'\n not equal to\n 'true'")
+##     [/codeblock]
+func assert_failure_await(assertion :Callable) -> GdUnitFailureAssert:
+	return await __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd").new().execute_and_await(assertion)
+
+
+## An assertion tool to verify for Godot errors.[br]
+## You can use to verify for certain Godot erros like failing assertions, push_error, push_warn.[br]
+## Usage:
+##     [codeblock]
+##		# tests no error was occured during execution the code
+##		await assert_error(func (): return 0 )\
+##		    .is_success()
+##
+##		# tests an push_error('test error') was occured during execution the code
+##		await assert_error(func (): push_error('test error') )\
+##		    .is_push_error('test error')
+##     [/codeblock]
+func assert_error(current :Callable) -> GdUnitGodotErrorAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitGodotErrorAssertImpl.gd").new(current)
+
+
+func assert_not_yet_implemented() -> void:
+	__gdunit_assert().new(null).test_fail()
+
+
+func fail(message :String) -> void:
+	__gdunit_assert().new(null).report_error(message)
+
+
+# --- internal stuff do not override!!!
+func ResourcePath() -> String:
+	return get_script().resource_path

addons/gdUnit4/src/GdUnitTuple.gd

@@ -0,0 +1,28 @@
+## A tuple implementation to hold two or many values
+class_name GdUnitTuple
+extends RefCounted
+
+const NO_ARG :Variant = GdUnitConstants.NO_ARG
+
+var __values :Array = Array()
+
+
+func _init(arg0:Variant,
+	arg1 :Variant=NO_ARG,
+	arg2 :Variant=NO_ARG,
+	arg3 :Variant=NO_ARG,
+	arg4 :Variant=NO_ARG,
+	arg5 :Variant=NO_ARG,
+	arg6 :Variant=NO_ARG,
+	arg7 :Variant=NO_ARG,
+	arg8 :Variant=NO_ARG,
+	arg9 :Variant=NO_ARG) -> void:
+	__values = GdArrayTools.filter_value([arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9], NO_ARG)
+
+
+func values() -> Array:
+	return __values
+
+
+func _to_string() -> String:
+	return "tuple(%s)" % str(__values)

addons/gdUnit4/src/GdUnitValueExtractor.gd

@@ -0,0 +1,9 @@
+## This is the base interface for value extraction
+class_name GdUnitValueExtractor
+extends RefCounted
+
+
+## Extracts a value by given implementation
+func extract_value(value :Variant) -> Variant:
+	push_error("Uninplemented func 'extract_value'")
+	return value

addons/gdUnit4/src/GdUnitVectorAssert.gd

@@ -0,0 +1,57 @@
+## An Assertion Tool to verify Vector values
+class_name GdUnitVectorAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is equal to expected one.
+@warning_ignore("unused_parameter")
+func is_equal(expected :Variant) -> GdUnitVectorAssert:
+	return self
+
+
+## Verifies that the current value is not equal to expected one.
+@warning_ignore("unused_parameter")
+func is_not_equal(expected :Variant) -> GdUnitVectorAssert:
+	return self
+
+
+## Verifies that the current and expected value are approximately equal.
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_equal_approx(expected :Variant, approx :Variant) -> GdUnitVectorAssert:
+	return self
+
+
+## Verifies that the current value is less than the given one.
+@warning_ignore("unused_parameter")
+func is_less(expected :Variant) -> GdUnitVectorAssert:
+	return self
+
+
+## Verifies that the current value is less than or equal the given one.
+@warning_ignore("unused_parameter")
+func is_less_equal(expected :Variant) -> GdUnitVectorAssert:
+	return self
+
+
+## Verifies that the current value is greater than the given one.
+@warning_ignore("unused_parameter")
+func is_greater(expected :Variant) -> GdUnitVectorAssert:
+	return self
+
+
+## Verifies that the current value is greater than or equal the given one.
+@warning_ignore("unused_parameter")
+func is_greater_equal(expected :Variant) -> GdUnitVectorAssert:
+	return self
+
+
+## Verifies that the current value is between the given boundaries (inclusive).
+@warning_ignore("unused_parameter")
+func is_between(from :Variant, to :Variant) -> GdUnitVectorAssert:
+	return self
+
+
+## Verifies that the current value is not between the given boundaries (inclusive).
+@warning_ignore("unused_parameter")
+func is_not_between(from :Variant, to :Variant) -> GdUnitVectorAssert:
+	return self

addons/gdUnit4/src/asserts/CallBackValueProvider.gd

@@ -0,0 +1,25 @@
+# a value provider unsing a callback to get `next` value from a certain function
+class_name CallBackValueProvider
+extends ValueProvider
+
+var _cb :Callable
+var _args :Array
+
+
+func _init(instance :Object, func_name :String, args :Array = Array(), force_error := true) -> void:
+	_cb = Callable(instance, func_name);
+	_args = args
+	if force_error and not _cb.is_valid():
+		push_error("Can't find function '%s' checked instance %s" % [func_name, instance])
+
+
+func get_value() -> Variant:
+	if not _cb.is_valid():
+		return null
+	if _args.is_empty():
+		return await _cb.call()
+	return await _cb.callv(_args)
+
+
+func dispose() -> void:
+	_cb = Callable()

addons/gdUnit4/src/asserts/DefaultValueProvider.gd

@@ -0,0 +1,13 @@
+# default value provider, simple returns the initial value
+class_name DefaultValueProvider
+extends ValueProvider
+
+var _value: Variant
+
+
+func _init(value: Variant) -> void:
+	_value = value
+
+
+func get_value() -> Variant:
+	return _value

addons/gdUnit4/src/asserts/GdAssertMessages.gd

@@ -0,0 +1,615 @@
+class_name GdAssertMessages
+extends Resource
+
+const WARN_COLOR = "#EFF883"
+const ERROR_COLOR = "#CD5C5C"
+const VALUE_COLOR = "#1E90FF"
+const SUB_COLOR :=  Color(1, 0, 0, .3)
+const ADD_COLOR :=  Color(0, 1, 0, .3)
+
+
+static func format_dict(value :Dictionary) -> String:
+	if value.is_empty():
+		return "{ }"
+	var as_rows := var_to_str(value).split("\n")
+	for index in range( 1, as_rows.size()-1):
+		as_rows[index] = "	" + as_rows[index]
+	as_rows[-1] = "  " + as_rows[-1]
+	return "\n".join(as_rows)
+
+
+# improved version of InputEvent as text
+static func input_event_as_text(event :InputEvent) -> String:
+	var text := ""
+	if event is InputEventKey:
+		text += "InputEventKey : key='%s', pressed=%s, keycode=%d, physical_keycode=%s" % [
+					event.as_text(), event.pressed, event.keycode, event.physical_keycode]
+	else:
+		text += event.as_text()
+	if event is InputEventMouse:
+		text += ", global_position %s" % event.global_position
+	if event is InputEventWithModifiers:
+		text += ", shift=%s, alt=%s, control=%s, meta=%s, command=%s" % [
+					event.shift_pressed, event.alt_pressed, event.ctrl_pressed, event.meta_pressed, event.command_or_control_autoremap]
+	return text
+
+
+static func _colored_string_div(characters :String) -> String:
+	return colored_array_div(characters.to_utf8_buffer())
+
+
+static func colored_array_div(characters :PackedByteArray) -> String:
+	if characters.is_empty():
+		return "<empty>"
+	var result := PackedByteArray()
+	var index := 0
+	var missing_chars := PackedByteArray()
+	var additional_chars := PackedByteArray()
+
+	while index < characters.size():
+		var character := characters[index]
+		match character:
+			GdDiffTool.DIV_ADD:
+				index += 1
+				additional_chars.append(characters[index])
+			GdDiffTool.DIV_SUB:
+				index += 1
+				missing_chars.append(characters[index])
+			_:
+				if not missing_chars.is_empty():
+					result.append_array(format_chars(missing_chars, SUB_COLOR))
+					missing_chars = PackedByteArray()
+				if not additional_chars.is_empty():
+					result.append_array(format_chars(additional_chars, ADD_COLOR))
+					additional_chars = PackedByteArray()
+				result.append(character)
+		index += 1
+
+	result.append_array(format_chars(missing_chars, SUB_COLOR))
+	result.append_array(format_chars(additional_chars, ADD_COLOR))
+	return result.get_string_from_utf8()
+
+
+static func _typed_value(value :Variant) -> String:
+	return GdDefaultValueDecoder.decode(value)
+
+
+static func _warning(error :String) -> String:
+	return "[color=%s]%s[/color]" % [WARN_COLOR, error]
+
+
+static func _error(error :String) -> String:
+	return "[color=%s]%s[/color]" % [ERROR_COLOR, error]
+
+
+static func _nerror(number :Variant) -> String:
+	match typeof(number):
+		TYPE_INT:
+			return "[color=%s]%d[/color]" % [ERROR_COLOR, number]
+		TYPE_FLOAT:
+			return "[color=%s]%f[/color]" % [ERROR_COLOR, number]
+		_:
+			return "[color=%s]%s[/color]" % [ERROR_COLOR, str(number)]
+
+
+static func _colored_value(value :Variant) -> String:
+	match typeof(value):
+		TYPE_STRING, TYPE_STRING_NAME:
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _colored_string_div(value)]
+		TYPE_INT:
+			return "'[color=%s]%d[/color]'" % [VALUE_COLOR, value]
+		TYPE_FLOAT:
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _typed_value(value)]
+		TYPE_COLOR:
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _typed_value(value)]
+		TYPE_OBJECT:
+			if value == null:
+				return "'[color=%s]<null>[/color]'" % [VALUE_COLOR]
+			if value is InputEvent:
+				return "[color=%s]<%s>[/color]" % [VALUE_COLOR, input_event_as_text(value)]
+			if value.has_method("_to_string"):
+				return "[color=%s]<%s>[/color]" % [VALUE_COLOR, str(value)]
+			return "[color=%s]<%s>[/color]" % [VALUE_COLOR, value.get_class()]
+		TYPE_DICTIONARY:
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, format_dict(value)]
+		_:
+			if GdArrayTools.is_array_type(value):
+				return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _typed_value(value)]
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, value]
+
+
+
+static func _index_report_as_table(index_reports :Array) -> String:
+	var table := "[table=3]$cells[/table]"
+	var header := "[cell][right][b]$text[/b][/right]\t[/cell]"
+	var cell := "[cell][right]$text[/right]\t[/cell]"
+	var cells := header.replace("$text", "Index") + header.replace("$text", "Current") + header.replace("$text", "Expected")
+	for report :Variant in index_reports:
+		var index :String = str(report["index"])
+		var current :String = str(report["current"])
+		var expected :String = str(report["expected"])
+		cells += cell.replace("$text", index) + cell.replace("$text", current) + cell.replace("$text", expected)
+	return table.replace("$cells", cells)
+
+
+static func orphan_detected_on_suite_setup(count :int) -> String:
+	return "%s\n Detected <%d> orphan nodes during test suite setup stage! [b]Check before() and after()![/b]" % [
+		_warning("WARNING:"), count]
+
+
+static func orphan_detected_on_test_setup(count :int) -> String:
+	return "%s\n Detected <%d> orphan nodes during test setup! [b]Check before_test() and after_test()![/b]" % [
+		_warning("WARNING:"), count]
+
+
+static func orphan_detected_on_test(count :int) -> String:
+	return "%s\n Detected <%d> orphan nodes during test execution!" % [
+		_warning("WARNING:"), count]
+
+
+static func fuzzer_interuped(iterations: int, error: String) -> String:
+	return "%s %s %s\n %s" % [
+		_error("Found an error after"),
+		_colored_value(iterations + 1),
+		_error("test iterations"),
+		error]
+
+
+static func test_timeout(timeout :int) -> String:
+	return "%s\n %s" % [_error("Timeout !"), _colored_value("Test timed out after %s" %  LocalTime.elapsed(timeout))]
+
+
+# gdlint:disable = mixed-tabs-and-spaces
+static func test_suite_skipped(hint :String, skip_count :int) -> String:
+	return """
+		%s
+		  Tests skipped: %s
+		  Reason: %s
+		""".dedent().trim_prefix("\n")\
+		% [_error("Entire test-suite is skipped!"), _colored_value(skip_count), _colored_value(hint)]
+
+
+static func test_skipped(hint :String) -> String:
+	return """
+		%s
+		  Reason: %s
+		""".dedent().trim_prefix("\n")\
+		% [_error("This test is skipped!"), _colored_value(hint)]
+
+
+static func error_not_implemented() -> String:
+	return _error("Test not implemented!")
+
+
+static func error_is_null(current :Variant) -> String:
+	return "%s %s but was %s" % [_error("Expecting:"), _colored_value(null), _colored_value(current)]
+
+
+static func error_is_not_null() -> String:
+	return "%s %s" % [_error("Expecting: not to be"), _colored_value(null)]
+
+
+static func error_equal(current :Variant, expected :Variant, index_reports :Array = []) -> String:
+	var report := """
+		%s
+		 %s
+		 but was
+		 %s""".dedent().trim_prefix("\n") % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+	if not index_reports.is_empty():
+		report += "\n\n%s\n%s" % [_error("Differences found:"), _index_report_as_table(index_reports)]
+	return report
+
+
+static func error_not_equal(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n not equal to\n %s" % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_not_equal_case_insensetiv(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n not equal to (case insensitiv)\n %s" % [
+			_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_is_empty(current :Variant) -> String:
+	return "%s\n must be empty but was\n %s" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_not_empty() -> String:
+	return "%s\n must not be empty" % [_error("Expecting:")]
+
+
+static func error_is_same(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n to refer to the same object\n %s" % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+@warning_ignore("unused_parameter")
+static func error_not_same(_current :Variant, expected :Variant) -> String:
+	return "%s\n %s" % [_error("Expecting not same:"), _colored_value(expected)]
+
+
+static func error_not_same_error(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n but was\n %s" % [_error("Expecting error message:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_is_instanceof(current: GdUnitResult, expected :GdUnitResult) -> String:
+	return "%s\n %s\n But it was %s" % [_error("Expected instance of:"),\
+		_colored_value(expected.or_else(null)), _colored_value(current.or_else(null))]
+
+
+# -- Boolean Assert specific messages -----------------------------------------------------
+static func error_is_true(current :Variant) -> String:
+	return "%s %s but is %s" % [_error("Expecting:"), _colored_value(true), _colored_value(current)]
+
+
+static func error_is_false(current :Variant) -> String:
+	return "%s %s but is %s" % [_error("Expecting:"), _colored_value(false), _colored_value(current)]
+
+
+# - Integer/Float Assert specific messages -----------------------------------------------------
+
+static func error_is_even(current :Variant) -> String:
+	return "%s\n %s must be even" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_odd(current :Variant) -> String:
+	return "%s\n %s must be odd" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_negative(current :Variant) -> String:
+	return "%s\n %s be negative" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_not_negative(current :Variant) -> String:
+	return "%s\n %s be not negative" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_zero(current :Variant) -> String:
+	return "%s\n equal to 0 but is %s" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_not_zero() -> String:
+	return "%s\n not equal to 0" % [_error("Expecting:")]
+
+
+static func error_is_wrong_type(current_type :Variant.Type, expected_type :Variant.Type) -> String:
+	return "%s\n Expecting type %s but is %s" % [
+		_error("Unexpected type comparison:"),
+		_colored_value(GdObjects.type_as_string(current_type)),
+		_colored_value(GdObjects.type_as_string(expected_type))]
+
+
+static func error_is_value(operation :int, current :Variant, expected :Variant, expected2 :Variant = null) -> String:
+	match operation:
+		Comparator.EQUAL:
+			return "%s\n %s but was '%s'" % [_error("Expecting:"), _colored_value(expected), _nerror(current)]
+		Comparator.LESS_THAN:
+			return "%s\n %s but was '%s'" % [_error("Expecting to be less than:"), _colored_value(expected), _nerror(current)]
+		Comparator.LESS_EQUAL:
+			return "%s\n %s but was '%s'" % [_error("Expecting to be less than or equal:"), _colored_value(expected), _nerror(current)]
+		Comparator.GREATER_THAN:
+			return "%s\n %s but was '%s'" % [_error("Expecting to be greater than:"), _colored_value(expected), _nerror(current)]
+		Comparator.GREATER_EQUAL:
+			return "%s\n %s but was '%s'" % [_error("Expecting to be greater than or equal:"), _colored_value(expected), _nerror(current)]
+		Comparator.BETWEEN_EQUAL:
+			return "%s\n %s\n in range between\n %s <> %s" % [
+					_error("Expecting:"), _colored_value(current), _colored_value(expected), _colored_value(expected2)]
+		Comparator.NOT_BETWEEN_EQUAL:
+			return "%s\n %s\n not in range between\n %s <> %s" % [
+					_error("Expecting:"), _colored_value(current), _colored_value(expected), _colored_value(expected2)]
+	return "TODO create expected message"
+
+
+static func error_is_in(current :Variant, expected :Array) -> String:
+	return "%s\n %s\n is in\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(str(expected))]
+
+
+static func error_is_not_in(current :Variant, expected :Array) -> String:
+	return "%s\n %s\n is not in\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(str(expected))]
+
+
+# - StringAssert ---------------------------------------------------------------------------------
+static func error_equal_ignoring_case(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n but was\n %s (ignoring case)" % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_contains(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n do contains\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_not_contains(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n not do contain\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_contains_ignoring_case(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n contains\n %s\n (ignoring case)" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_not_contains_ignoring_case(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n not do contains\n %s\n (ignoring case)" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_starts_with(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n to start with\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_ends_with(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n to end with\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_has_length(current :Variant, expected: int, compare_operator :int) -> String:
+	var current_length :Variant = current.length() if current != null else null
+	match compare_operator:
+		Comparator.EQUAL:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size:"), _colored_value(expected), _nerror(current_length), _colored_value(current)]
+		Comparator.LESS_THAN:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size to be less than:"), _colored_value(expected), _nerror(current_length), _colored_value(current)]
+		Comparator.LESS_EQUAL:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size to be less than or equal:"), _colored_value(expected),
+					_nerror(current_length), _colored_value(current)]
+		Comparator.GREATER_THAN:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size to be greater than:"), _colored_value(expected),
+					_nerror(current_length), _colored_value(current)]
+		Comparator.GREATER_EQUAL:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size to be greater than or equal:"), _colored_value(expected),
+					_nerror(current_length), _colored_value(current)]
+	return "TODO create expected message"
+
+
+# - ArrayAssert specific messgaes ---------------------------------------------------
+
+static func error_arr_contains(current :Variant, expected :Array, not_expect :Array, not_found :Array, by_reference :bool) -> String:
+	var failure_message := "Expecting contains SAME elements:" if by_reference else "Expecting contains elements:"
+	var error := "%s\n %s\n do contains (in any order)\n %s" % [
+					_error(failure_message), _colored_value(current), _colored_value(expected)]
+	if not not_expect.is_empty():
+		error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect)
+	if not not_found.is_empty():
+		var prefix := "but" if not_expect.is_empty() else "and"
+		error += "\n%s could not find elements:\n %s" % [prefix, _colored_value(not_found)]
+	return error
+
+
+static func error_arr_contains_exactly(
+	current :Variant,
+	expected :Variant,
+	not_expect :Variant,
+	not_found :Variant, compare_mode :GdObjects.COMPARE_MODE) -> String:
+	var failure_message := (
+		"Expecting contains exactly elements:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting contains SAME exactly elements:"
+	)
+	if not_expect.is_empty() and not_found.is_empty():
+		var diff := _find_first_diff(current, expected)
+		return "%s\n %s\n do contains (in same order)\n %s\n but has different order %s"  % [
+					_error(failure_message), _colored_value(current), _colored_value(expected), diff]
+
+	var error := "%s\n %s\n do contains (in same order)\n %s" % [
+					_error(failure_message), _colored_value(current), _colored_value(expected)]
+	if not not_expect.is_empty():
+		error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect)
+	if not not_found.is_empty():
+		var prefix := "but" if not_expect.is_empty() else "and"
+		error += "\n%s could not find elements:\n %s" % [prefix, _colored_value(not_found)]
+	return error
+
+
+static func error_arr_contains_exactly_in_any_order(
+	current :Variant,
+	expected :Array,
+	not_expect :Array,
+	not_found :Array,
+	compare_mode :GdObjects.COMPARE_MODE) -> String:
+
+	var failure_message := (
+		"Expecting contains exactly elements:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting contains SAME exactly elements:"
+	)
+	var error := "%s\n %s\n do contains exactly (in any order)\n %s" % [
+					_error(failure_message), _colored_value(current), _colored_value(expected)]
+	if not not_expect.is_empty():
+		error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect)
+	if not not_found.is_empty():
+		var prefix := "but" if not_expect.is_empty() else "and"
+		error += "\n%s could not find elements:\n %s" % [prefix, _colored_value(not_found)]
+	return error
+
+
+static func error_arr_not_contains(current :Array, expected :Array, found :Array, compare_mode :GdObjects.COMPARE_MODE) -> String:
+	var failure_message := "Expecting:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST else "Expecting SAME:"
+	var error := "%s\n %s\n do not contains\n %s" % [
+					_error(failure_message), _colored_value(current), _colored_value(expected)]
+	if not found.is_empty():
+		error += "\n but found elements:\n %s" % _colored_value(found)
+	return error
+
+
+# - DictionaryAssert specific messages ----------------------------------------------
+static func error_contains_keys(current :Array, expected :Array, keys_not_found :Array, compare_mode :GdObjects.COMPARE_MODE) -> String:
+	var failure := (
+		"Expecting contains keys:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting contains SAME keys:"
+	)
+	return "%s\n %s\n to contains:\n %s\n but can't find key's:\n %s" % [
+			_error(failure), _colored_value(current), _colored_value(expected), _colored_value(keys_not_found)]
+
+
+static func error_not_contains_keys(current :Array, expected :Array, keys_not_found :Array, compare_mode :GdObjects.COMPARE_MODE) -> String:
+	var failure := (
+		"Expecting NOT contains keys:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting NOT contains SAME keys"
+	)
+	return "%s\n %s\n do not contains:\n %s\n but contains key's:\n %s" % [
+			_error(failure), _colored_value(current), _colored_value(expected), _colored_value(keys_not_found)]
+
+
+static func error_contains_key_value(key :Variant, value :Variant, current_value :Variant, compare_mode :GdObjects.COMPARE_MODE) -> String:
+	var failure := (
+		"Expecting contains key and value:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting contains SAME key and value:"
+	)
+	return "%s\n %s : %s\n but contains\n %s : %s" % [
+			_error(failure), _colored_value(key), _colored_value(value), _colored_value(key), _colored_value(current_value)]
+
+
+# - ResultAssert specific errors ----------------------------------------------------
+static func error_result_is_empty(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.EMPTY)
+
+
+static func error_result_is_success(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.SUCCESS)
+
+
+static func error_result_is_warning(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.WARN)
+
+
+static func error_result_is_error(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.ERROR)
+
+
+static func error_result_has_message(current :String, expected :String) -> String:
+	return "%s\n %s\n but was\n %s." % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_result_has_message_on_success(expected :String) -> String:
+	return "%s\n %s\n but the GdUnitResult is a success." % [_error("Expecting:"), _colored_value(expected)]
+
+
+static func error_result_is_value(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n but was\n %s." % [_error("Expecting to contain same value:"), _colored_value(expected), _colored_value(current)]
+
+
+static func _result_error_message(current :GdUnitResult, expected_type :int) -> String:
+	if current == null:
+		return _error("Expecting the result must be a %s but was <null>." % result_type(expected_type))
+	if current.is_success():
+		return _error("Expecting the result must be a %s but was SUCCESS." % result_type(expected_type))
+	var error := "Expecting the result must be a %s but was %s:" % [result_type(expected_type), result_type(current._state)]
+	return "%s\n %s" % [_error(error), _colored_value(result_message(current))]
+
+
+static func error_interrupted(func_name :String, expected :Variant, elapsed :String) -> String:
+	func_name = humanized(func_name)
+	if expected == null:
+		return "%s %s but timed out after %s" % [_error("Expected:"), func_name, elapsed]
+	return "%s %s %s but timed out after %s" % [_error("Expected:"), func_name, _colored_value(expected), elapsed]
+
+
+static func error_wait_signal(signal_name :String, args :Array, elapsed :String) -> String:
+	if args.is_empty():
+		return "%s %s but timed out after %s" % [
+				_error("Expecting emit signal:"), _colored_value(signal_name + "()"), elapsed]
+	return "%s %s but timed out after %s" % [
+			_error("Expecting emit signal:"), _colored_value(signal_name + "(" + str(args) + ")"), elapsed]
+
+
+static func error_signal_emitted(signal_name :String, args :Array, elapsed :String) -> String:
+	if args.is_empty():
+		return "%s %s but is emitted after %s" % [
+				_error("Expecting do not emit signal:"), _colored_value(signal_name + "()"), elapsed]
+	return "%s %s but is emitted after %s" % [
+			_error("Expecting do not emit signal:"), _colored_value(signal_name + "(" + str(args) + ")"), elapsed]
+
+
+static func error_await_signal_on_invalid_instance(source :Variant, signal_name :String, args :Array) -> String:
+	return "%s\n await_signal_on(%s, %s, %s)" % [
+			_error("Invalid source! Can't await on signal:"), _colored_value(source), signal_name, args]
+
+
+static func result_type(type :int) -> String:
+	match type:
+		GdUnitResult.SUCCESS: return "SUCCESS"
+		GdUnitResult.WARN: return "WARNING"
+		GdUnitResult.ERROR: return "ERROR"
+		GdUnitResult.EMPTY: return "EMPTY"
+	return "UNKNOWN"
+
+
+static func result_message(result :GdUnitResult) -> String:
+	match result._state:
+		GdUnitResult.SUCCESS: return ""
+		GdUnitResult.WARN: return result.warn_message()
+		GdUnitResult.ERROR: return result.error_message()
+		GdUnitResult.EMPTY: return ""
+	return "UNKNOWN"
+# -----------------------------------------------------------------------------------
+
+# - Spy|Mock specific errors ----------------------------------------------------
+static func error_no_more_interactions(summary :Dictionary) -> String:
+	var interactions := PackedStringArray()
+	for args :Variant in summary.keys():
+		var times :int = summary[args]
+		interactions.append(_format_arguments(args, times))
+	return "%s\n%s\n%s" % [_error("Expecting no more interactions!"), _error("But found interactions on:"), "\n".join(interactions)]
+
+
+static func error_validate_interactions(current_interactions :Dictionary, expected_interactions :Dictionary) -> String:
+	var interactions := PackedStringArray()
+	for args :Variant in current_interactions.keys():
+		var times :int = current_interactions[args]
+		interactions.append(_format_arguments(args, times))
+	var expected_interaction := _format_arguments(expected_interactions.keys()[0], expected_interactions.values()[0])
+	return "%s\n%s\n%s\n%s" % [
+			_error("Expecting interaction on:"), expected_interaction, _error("But found interactions on:"), "\n".join(interactions)]
+
+
+static func _format_arguments(args :Array, times :int) -> String:
+	var fname :String = args[0]
+	var fargs := args.slice(1) as Array
+	var typed_args := _to_typed_args(fargs)
+	var fsignature := _colored_value("%s(%s)" % [fname, ", ".join(typed_args)])
+	return "	%s	%d time's" % [fsignature, times]
+
+
+static func _to_typed_args(args :Array) -> PackedStringArray:
+	var typed := PackedStringArray()
+	for arg :Variant in args:
+		typed.append(_format_arg(arg) + " :" + GdObjects.type_as_string(typeof(arg)))
+	return typed
+
+
+static func _format_arg(arg :Variant) -> String:
+	if arg is InputEvent:
+		return input_event_as_text(arg)
+	return str(arg)
+
+
+static func _find_first_diff(left :Array, right :Array) -> String:
+	for index in left.size():
+		var l :Variant = left[index]
+		var r :Variant = "<no entry>" if index >= right.size() else right[index]
+		if not GdObjects.equals(l, r):
+			return "at position %s\n '%s' vs '%s'" % [_colored_value(index), _typed_value(l), _typed_value(r)]
+	return ""
+
+
+static func error_has_size(current :Variant, expected: int) -> String:
+	var current_size :Variant = null if current == null else current.size()
+	return "%s\n %s\n but was\n %s" % [_error("Expecting size:"), _colored_value(expected), _colored_value(current_size)]
+
+
+static func error_contains_exactly(current: Array, expected: Array) -> String:
+	return "%s\n %s\n but was\n %s" % [_error("Expecting exactly equal:"), _colored_value(expected), _colored_value(current)]
+
+
+static func format_chars(characters :PackedByteArray, type :Color) -> PackedByteArray:
+	if characters.size() == 0:# or characters[0] == 10:
+		return characters
+	var result := PackedByteArray()
+	var message := "[bgcolor=#%s][color=with]%s[/color][/bgcolor]" % [
+					type.to_html(), characters.get_string_from_utf8().replace("\n", "<LF>")]
+	result.append_array(message.to_utf8_buffer())
+	return result
+
+
+static func format_invalid(value :String) -> String:
+	return "[bgcolor=#%s][color=with]%s[/color][/bgcolor]" % [SUB_COLOR.to_html(), value]
+
+
+static func humanized(value :String) -> String:
+	return value.replace("_", " ")

addons/gdUnit4/src/asserts/GdAssertReports.gd

@@ -0,0 +1,55 @@
+class_name GdAssertReports
+extends RefCounted
+
+const LAST_ERROR = "last_assert_error_message"
+const LAST_ERROR_LINE = "last_assert_error_line"
+
+
+static func report_success() -> void:
+	GdUnitSignals.instance().gdunit_set_test_failed.emit(false)
+	GdAssertReports.set_last_error_line_number(-1)
+	Engine.remove_meta(LAST_ERROR)
+
+
+static func report_warning(message :String, line_number :int) -> void:
+	GdUnitSignals.instance().gdunit_set_test_failed.emit(false)
+	send_report(GdUnitReport.new().create(GdUnitReport.WARN, line_number, message))
+
+
+static func report_error(message:String, line_number :int) -> void:
+	GdUnitSignals.instance().gdunit_set_test_failed.emit(true)
+	GdAssertReports.set_last_error_line_number(line_number)
+	Engine.set_meta(LAST_ERROR, message)
+	# if we expect to fail we handle as success test
+	if _do_expect_assert_failing():
+		return
+	send_report(GdUnitReport.new().create(GdUnitReport.FAILURE, line_number, message))
+
+
+static func reset_last_error_line_number() -> void:
+	Engine.remove_meta(LAST_ERROR_LINE)
+
+
+static func set_last_error_line_number(line_number :int) -> void:
+	Engine.set_meta(LAST_ERROR_LINE, line_number)
+
+
+static func get_last_error_line_number() -> int:
+	if Engine.has_meta(LAST_ERROR_LINE):
+		return Engine.get_meta(LAST_ERROR_LINE)
+	return -1
+
+
+static func _do_expect_assert_failing() -> bool:
+	if Engine.has_meta(GdUnitConstants.EXPECT_ASSERT_REPORT_FAILURES):
+		return Engine.get_meta(GdUnitConstants.EXPECT_ASSERT_REPORT_FAILURES)
+	return false
+
+
+static func current_failure() -> String:
+	return Engine.get_meta(LAST_ERROR)
+
+
+static func send_report(report :GdUnitReport) -> void:
+	var execution_context_id := GdUnitThreadManager.get_current_context().get_execution_context_id()
+	GdUnitSignals.instance().gdunit_report.emit(execution_context_id, report)

addons/gdUnit4/src/asserts/GdUnitArrayAssertImpl.gd

@@ -0,0 +1,350 @@
+extends GdUnitArrayAssert
+
+
+var _base :GdUnitAssert
+var _current_value_provider :ValueProvider
+
+
+func _init(current :Variant) -> void:
+	_current_value_provider = DefaultValueProvider.new(current)
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not _validate_value_type(current):
+		report_error("GdUnitArrayAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func report_success() -> GdUnitArrayAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitArrayAssert:
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func override_failure_message(message :String) -> GdUnitArrayAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+func _validate_value_type(value :Variant) -> bool:
+	return value == null or GdArrayTools.is_array_type(value)
+
+
+func get_current_value() -> Variant:
+	return _current_value_provider.get_value()
+
+
+func max_length(left :Variant, right :Variant) -> int:
+	var ls := str(left).length()
+	var rs := str(right).length()
+	return rs if ls < rs else ls
+
+
+func _array_equals_div(current :Array, expected :Array, case_sensitive :bool = false) -> Array:
+	var current_value := PackedStringArray(current)
+	var expected_value := PackedStringArray(expected)
+	var index_report := Array()
+	for index in current_value.size():
+		var c := current_value[index]
+		if index < expected_value.size():
+			var e := expected_value[index]
+			if not GdObjects.equals(c, e, case_sensitive):
+				var length := max_length(c, e)
+				current_value[index] = GdAssertMessages.format_invalid(c.lpad(length))
+				expected_value[index] = e.lpad(length)
+				index_report.push_back({"index" : index, "current" :c, "expected": e})
+		else:
+			current_value[index] = GdAssertMessages.format_invalid(c)
+			index_report.push_back({"index" : index, "current" :c, "expected": "<N/A>"})
+
+	for index in range(current.size(), expected_value.size()):
+		var value := expected_value[index]
+		expected_value[index] = GdAssertMessages.format_invalid(value)
+		index_report.push_back({"index" : index, "current" : "<N/A>", "expected": value})
+	return [current_value, expected_value, index_report]
+
+
+func _array_div(compare_mode :GdObjects.COMPARE_MODE, left :Array[Variant], right :Array[Variant], _same_order := false) -> Array[Variant]:
+	var not_expect := left.duplicate(true)
+	var not_found := right.duplicate(true)
+	for index_c in left.size():
+		var c :Variant = left[index_c]
+		for index_e in right.size():
+			var e :Variant = right[index_e]
+			if GdObjects.equals(c, e, false, compare_mode):
+				GdArrayTools.erase_value(not_expect, e)
+				GdArrayTools.erase_value(not_found, c)
+				break
+	return [not_expect, not_found]
+
+
+func _contains(expected :Variant, compare_mode :GdObjects.COMPARE_MODE) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var by_reference := compare_mode == GdObjects.COMPARE_MODE.OBJECT_REFERENCE
+	var current_value :Variant = get_current_value()
+	if current_value == null:
+		return report_error(GdAssertMessages.error_arr_contains(current_value, expected, [], expected, by_reference))
+	var diffs := _array_div(compare_mode, current_value, expected)
+	#var not_expect := diffs[0] as Array
+	var not_found := diffs[1] as Array
+	if not not_found.is_empty():
+		return report_error(GdAssertMessages.error_arr_contains(current_value, expected, [], not_found, by_reference))
+	return report_success()
+
+
+func _contains_exactly(expected :Variant, compare_mode :GdObjects.COMPARE_MODE) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current_value :Variant = get_current_value()
+	if current_value == null:
+		return report_error(GdAssertMessages.error_arr_contains_exactly(current_value, expected, [], expected, compare_mode))
+	# has same content in same order
+	if GdObjects.equals(Array(current_value), Array(expected), false, compare_mode):
+		return report_success()
+	# check has same elements but in different order
+	if GdObjects.equals_sorted(Array(current_value), Array(expected), false, compare_mode):
+		return report_error(GdAssertMessages.error_arr_contains_exactly(current_value, expected, [], [], compare_mode))
+	# find the difference
+	var diffs := _array_div(compare_mode, current_value, expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+	var not_expect := diffs[0] as Array[Variant]
+	var not_found := diffs[1] as Array[Variant]
+	return report_error(GdAssertMessages.error_arr_contains_exactly(current_value, expected, not_expect, not_found, compare_mode))
+
+
+func _contains_exactly_in_any_order(expected :Variant, compare_mode :GdObjects.COMPARE_MODE) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current_value :Variant = get_current_value()
+	if current_value == null:
+		return report_error(GdAssertMessages.error_arr_contains_exactly_in_any_order(current_value, expected, [], expected, compare_mode))
+	# find the difference
+	var diffs := _array_div(compare_mode, current_value, expected, false)
+	var not_expect := diffs[0] as Array
+	var not_found := diffs[1] as Array
+	if not_expect.is_empty() and not_found.is_empty():
+		return report_success()
+	return report_error(GdAssertMessages.error_arr_contains_exactly_in_any_order(current_value, expected, not_expect, not_found, compare_mode))
+
+
+func _not_contains(expected :Variant, compare_mode :GdObjects.COMPARE_MODE) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current_value :Variant = get_current_value()
+	if current_value == null:
+		return report_error(GdAssertMessages.error_arr_contains_exactly_in_any_order(current_value, expected, [], expected, compare_mode))
+	var diffs := _array_div(compare_mode, current_value, expected)
+	var found := diffs[0] as Array
+	if found.size() == current_value.size():
+		return report_success()
+	var diffs2 := _array_div(compare_mode, expected, diffs[1])
+	return report_error(GdAssertMessages.error_arr_not_contains(current_value, expected, diffs2[0], compare_mode))
+
+
+func is_null() -> GdUnitArrayAssert:
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitArrayAssert:
+	_base.is_not_null()
+	return self
+
+
+# Verifies that the current String is equal to the given one.
+func is_equal(expected :Variant) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current_value :Variant = get_current_value()
+	if current_value == null and expected != null:
+		return report_error(GdAssertMessages.error_equal(null, expected))
+	if not GdObjects.equals(current_value, expected):
+		var diff := _array_equals_div(current_value, expected)
+		var expected_as_list := GdArrayTools.as_string(diff[0], false)
+		var current_as_list := GdArrayTools.as_string(diff[1], false)
+		var index_report :Variant = diff[2]
+		return report_error(GdAssertMessages.error_equal(expected_as_list, current_as_list, index_report))
+	return report_success()
+
+
+# Verifies that the current Array is equal to the given one, ignoring case considerations.
+func is_equal_ignoring_case(expected :Variant) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current_value :Variant = get_current_value()
+	if current_value == null and expected != null:
+		return report_error(GdAssertMessages.error_equal(null, GdArrayTools.as_string(expected)))
+	if not GdObjects.equals(current_value, expected, true):
+		var diff := _array_equals_div(current_value, expected, true)
+		var expected_as_list := GdArrayTools.as_string(diff[0])
+		var current_as_list := GdArrayTools.as_string(diff[1])
+		var index_report :Variant = diff[2]
+		return report_error(GdAssertMessages.error_equal(expected_as_list, current_as_list, index_report))
+	return report_success()
+
+
+func is_not_equal(expected :Variant) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current_value :Variant = get_current_value()
+	if GdObjects.equals(current_value, expected):
+		return report_error(GdAssertMessages.error_not_equal(current_value, expected))
+	return report_success()
+
+
+func is_not_equal_ignoring_case(expected :Variant) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current_value :Variant = get_current_value()
+	if GdObjects.equals(current_value, expected, true):
+		var c := GdArrayTools.as_string(current_value)
+		var e := GdArrayTools.as_string(expected)
+		return report_error(GdAssertMessages.error_not_equal_case_insensetiv(c, e))
+	return report_success()
+
+
+func is_empty() -> GdUnitArrayAssert:
+	var current_value :Variant = get_current_value()
+	if current_value == null or current_value.size() > 0:
+		return report_error(GdAssertMessages.error_is_empty(current_value))
+	return report_success()
+
+
+func is_not_empty() -> GdUnitArrayAssert:
+	var current_value :Variant = get_current_value()
+	if current_value != null and current_value.size() == 0:
+		return report_error(GdAssertMessages.error_is_not_empty())
+	return report_success()
+
+
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_same(expected :Variant) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current :Variant = get_current_value()
+	if not is_same(current, expected):
+		report_error(GdAssertMessages.error_is_same(current, expected))
+	return self
+
+
+func is_not_same(expected :Variant) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current :Variant = get_current_value()
+	if is_same(current, expected):
+		report_error(GdAssertMessages.error_not_same(current, expected))
+	return self
+
+
+func has_size(expected: int) -> GdUnitArrayAssert:
+	var current_value :Variant= get_current_value()
+	if current_value == null or current_value.size() != expected:
+		return report_error(GdAssertMessages.error_has_size(current_value, expected))
+	return report_success()
+
+
+func contains(expected :Variant) -> GdUnitArrayAssert:
+	return _contains(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_exactly(expected :Variant) -> GdUnitArrayAssert:
+	return _contains_exactly(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_exactly_in_any_order(expected :Variant) -> GdUnitArrayAssert:
+	return _contains_exactly_in_any_order(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_same(expected :Variant) -> GdUnitArrayAssert:
+	return _contains(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func contains_same_exactly(expected :Variant) -> GdUnitArrayAssert:
+	return _contains_exactly(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func contains_same_exactly_in_any_order(expected :Variant) -> GdUnitArrayAssert:
+	return _contains_exactly_in_any_order(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func not_contains(expected :Variant) -> GdUnitArrayAssert:
+	return _not_contains(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func not_contains_same(expected :Variant) -> GdUnitArrayAssert:
+	return _not_contains(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func is_instanceof(expected :Variant) -> GdUnitAssert:
+	_base.is_instanceof(expected)
+	return self
+
+
+func extract(func_name :String, args := Array()) -> GdUnitArrayAssert:
+	var extracted_elements := Array()
+	var extractor :GdUnitValueExtractor = ResourceLoader.load("res://addons/gdUnit4/src/extractors/GdUnitFuncValueExtractor.gd",
+		"GDScript", ResourceLoader.CACHE_MODE_REUSE).new(func_name, args)
+	var current :Variant = get_current_value()
+	if current == null:
+		_current_value_provider = DefaultValueProvider.new(null)
+	else:
+		for element :Variant in current:
+			extracted_elements.append(extractor.extract_value(element))
+		_current_value_provider = DefaultValueProvider.new(extracted_elements)
+	return self
+
+
+func extractv(
+	extr0 :GdUnitValueExtractor,
+	extr1 :GdUnitValueExtractor = null,
+	extr2 :GdUnitValueExtractor = null,
+	extr3 :GdUnitValueExtractor = null,
+	extr4 :GdUnitValueExtractor = null,
+	extr5 :GdUnitValueExtractor = null,
+	extr6 :GdUnitValueExtractor = null,
+	extr7 :GdUnitValueExtractor = null,
+	extr8 :GdUnitValueExtractor = null,
+	extr9 :GdUnitValueExtractor = null) -> GdUnitArrayAssert:
+	var extractors :Variant = GdArrayTools.filter_value([extr0, extr1, extr2, extr3, extr4, extr5, extr6, extr7, extr8, extr9], null)
+	var extracted_elements := Array()
+	var current :Variant = get_current_value()
+	if current == null:
+		_current_value_provider = DefaultValueProvider.new(null)
+	else:
+		for element: Variant in current:
+			var ev :Array[Variant] = [
+				GdUnitTuple.NO_ARG,
+				GdUnitTuple.NO_ARG,
+				GdUnitTuple.NO_ARG,
+				GdUnitTuple.NO_ARG,
+				GdUnitTuple.NO_ARG,
+				GdUnitTuple.NO_ARG,
+				GdUnitTuple.NO_ARG,
+				GdUnitTuple.NO_ARG,
+				GdUnitTuple.NO_ARG,
+				GdUnitTuple.NO_ARG
+			]
+			for index :int in extractors.size():
+				var extractor :GdUnitValueExtractor = extractors[index]
+				ev[index] = extractor.extract_value(element)
+			if extractors.size() > 1:
+				extracted_elements.append(GdUnitTuple.new(ev[0], ev[1], ev[2], ev[3], ev[4], ev[5], ev[6], ev[7], ev[8], ev[9]))
+			else:
+				extracted_elements.append(ev[0])
+		_current_value_provider = DefaultValueProvider.new(extracted_elements)
+	return self

addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd

@@ -0,0 +1,72 @@
+extends GdUnitAssert
+
+
+var _current :Variant
+var _current_error_message :String = ""
+var _custom_failure_message :String = ""
+
+
+func _init(current :Variant) -> void:
+	_current = current
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	GdAssertReports.reset_last_error_line_number()
+
+
+func failure_message() -> String:
+	return _current_error_message
+
+
+func current_value() -> Variant:
+	return _current
+
+
+func report_success() -> GdUnitAssert:
+	GdAssertReports.report_success()
+	return self
+
+
+func report_error(error_message :String, failure_line_number: int = -1) -> GdUnitAssert:
+	var line_number := failure_line_number if failure_line_number != -1 else GdUnitAssertions.get_line_number()
+	GdAssertReports.set_last_error_line_number(line_number)
+	_current_error_message = error_message if _custom_failure_message.is_empty() else _custom_failure_message
+	GdAssertReports.report_error(_current_error_message, line_number)
+	Engine.set_meta("GD_TEST_FAILURE", true)
+	return self
+
+
+func test_fail() -> GdUnitAssert:
+	return report_error(GdAssertMessages.error_not_implemented())
+
+
+func override_failure_message(message :String) -> GdUnitAssert:
+	_custom_failure_message = message
+	return self
+
+
+func is_equal(expected :Variant) -> GdUnitAssert:
+	var current :Variant = current_value()
+	if not GdObjects.equals(current, expected):
+		return report_error(GdAssertMessages.error_equal(current, expected))
+	return report_success()
+
+
+func is_not_equal(expected :Variant) -> GdUnitAssert:
+	var current :Variant = current_value()
+	if GdObjects.equals(current, expected):
+		return report_error(GdAssertMessages.error_not_equal(current, expected))
+	return report_success()
+
+
+func is_null() -> GdUnitAssert:
+	var current :Variant = current_value()
+	if current != null:
+		return report_error(GdAssertMessages.error_is_null(current))
+	return report_success()
+
+
+func is_not_null() -> GdUnitAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitAssertions.gd

@@ -0,0 +1,64 @@
+# Preloads all GdUnit assertions
+class_name GdUnitAssertions
+extends RefCounted
+
+
+func _init() -> void:
+	# preload all gdunit assertions to speedup testsuite loading time
+	# gdlint:disable=private-method-call
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitBoolAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitStringAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitIntAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFloatAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitVectorAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitArrayAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitDictionaryAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFileAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitObjectAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitResultAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFuncAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitSignalAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitGodotErrorAssertImpl.gd")
+
+
+### We now load all used asserts and tool scripts into the cache according to the principle of "lazy loading"
+### in order to noticeably reduce the loading time of the test suite.
+# We go this hard way to increase the loading performance to avoid reparsing all the used scripts
+# for more detailed info -> https://github.com/godotengine/godot/issues/67400
+# gdlint:disable=function-name
+static func __lazy_load(script_path :String) -> GDScript:
+	return ResourceLoader.load(script_path, "GDScript", ResourceLoader.CACHE_MODE_REUSE)
+
+
+static func validate_value_type(value :Variant, type :Variant.Type) -> bool:
+	return value == null or typeof(value) == type
+
+
+# Scans the current stack trace for the root cause to extract the line number
+static func get_line_number() -> int:
+	var stack_trace := get_stack()
+	if stack_trace == null or stack_trace.is_empty():
+		return -1
+	for index in stack_trace.size():
+		var stack_info :Dictionary = stack_trace[index]
+		var function :String = stack_info.get("function")
+		# we catch helper asserts to skip over to return the correct line number
+		if function.begins_with("assert_"):
+			continue
+		if function.begins_with("test_"):
+			return stack_info.get("line")
+		var source :String = stack_info.get("source")
+		if source.is_empty() \
+			or source.begins_with("user://") \
+			or source.ends_with("GdUnitAssert.gd") \
+			or source.ends_with("GdUnitAssertions.gd") \
+			or source.ends_with("AssertImpl.gd") \
+			or source.ends_with("GdUnitTestSuite.gd") \
+			or source.ends_with("GdUnitSceneRunnerImpl.gd") \
+			or source.ends_with("GdUnitObjectInteractions.gd") \
+			or source.ends_with("GdUnitAwaiter.gd"):
+			continue
+		return stack_info.get("line")
+	return -1

addons/gdUnit4/src/asserts/GdUnitBoolAssertImpl.gd

@@ -0,0 +1,76 @@
+extends GdUnitBoolAssert
+
+var _base: GdUnitAssert
+
+
+func _init(current :Variant) -> void:
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_BOOL):
+		report_error("GdUnitBoolAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitBoolAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitBoolAssert:
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func override_failure_message(message :String) -> GdUnitBoolAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+# Verifies that the current value is null.
+func is_null() -> GdUnitBoolAssert:
+	_base.is_null()
+	return self
+
+
+# Verifies that the current value is not null.
+func is_not_null() -> GdUnitBoolAssert:
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected :Variant) -> GdUnitBoolAssert:
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected :Variant) -> GdUnitBoolAssert:
+	_base.is_not_equal(expected)
+	return self
+
+
+func is_true() -> GdUnitBoolAssert:
+	if current_value() != true:
+		return report_error(GdAssertMessages.error_is_true(current_value()))
+	return report_success()
+
+
+func is_false() -> GdUnitBoolAssert:
+	if current_value() == true || current_value() == null:
+		return report_error(GdAssertMessages.error_is_false(current_value()))
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitDictionaryAssertImpl.gd

@@ -0,0 +1,182 @@
+extends GdUnitDictionaryAssert
+
+var _base :GdUnitAssert
+
+
+func _init(current :Variant) -> void:
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_DICTIONARY):
+		report_error("GdUnitDictionaryAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func report_success() -> GdUnitDictionaryAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitDictionaryAssert:
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func override_failure_message(message :String) -> GdUnitDictionaryAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func is_null() -> GdUnitDictionaryAssert:
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitDictionaryAssert:
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected :Variant) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_equal(null, GdAssertMessages.format_dict(expected)))
+	if not GdObjects.equals(current, expected):
+		var c := GdAssertMessages.format_dict(current)
+		var e := GdAssertMessages.format_dict(expected)
+		var diff := GdDiffTool.string_diff(c, e)
+		var curent_diff := GdAssertMessages.colored_array_div(diff[1])
+		return report_error(GdAssertMessages.error_equal(curent_diff, e))
+	return report_success()
+
+
+func is_not_equal(expected :Variant) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if GdObjects.equals(current, expected):
+		return report_error(GdAssertMessages.error_not_equal(current, expected))
+	return report_success()
+
+
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_same(expected :Variant) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_equal(null, GdAssertMessages.format_dict(expected)))
+	if not is_same(current, expected):
+		var c := GdAssertMessages.format_dict(current)
+		var e := GdAssertMessages.format_dict(expected)
+		var diff := GdDiffTool.string_diff(c, e)
+		var curent_diff := GdAssertMessages.colored_array_div(diff[1])
+		return report_error(GdAssertMessages.error_is_same(curent_diff, e))
+	return report_success()
+
+
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_not_same(expected :Variant) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if is_same(current, expected):
+		return report_error(GdAssertMessages.error_not_same(current, expected))
+	return report_success()
+
+
+func is_empty() -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null or not current.is_empty():
+		return report_error(GdAssertMessages.error_is_empty(current))
+	return report_success()
+
+
+func is_not_empty() -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null or current.is_empty():
+		return report_error(GdAssertMessages.error_is_not_empty())
+	return report_success()
+
+
+func has_size(expected: int) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	if current.size() != expected:
+		return report_error(GdAssertMessages.error_has_size(current, expected))
+	return report_success()
+
+
+func _contains_keys(expected :Array, compare_mode :GdObjects.COMPARE_MODE) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	# find expected keys
+	var keys_not_found :Array = expected.filter(_filter_by_key.bind(current.keys(), compare_mode))
+	if not keys_not_found.is_empty():
+		return report_error(GdAssertMessages.error_contains_keys(current.keys(), expected, keys_not_found, compare_mode))
+	return report_success()
+
+
+func _contains_key_value(key :Variant, value :Variant, compare_mode :GdObjects.COMPARE_MODE) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	var expected := [key]
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	var keys_not_found :Array = expected.filter(_filter_by_key.bind(current.keys(), compare_mode))
+	if not keys_not_found.is_empty():
+		return report_error(GdAssertMessages.error_contains_keys(current.keys(), expected, keys_not_found, compare_mode))
+	if not GdObjects.equals(current[key], value, false, compare_mode):
+		return report_error(GdAssertMessages.error_contains_key_value(key, value, current[key], compare_mode))
+	return report_success()
+
+
+func _not_contains_keys(expected :Array, compare_mode :GdObjects.COMPARE_MODE) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	var keys_found :Array = current.keys().filter(_filter_by_key.bind(expected, compare_mode, true))
+	if not keys_found.is_empty():
+		return report_error(GdAssertMessages.error_not_contains_keys(current.keys(), expected, keys_found, compare_mode))
+	return report_success()
+
+
+func contains_keys(expected :Array) -> GdUnitDictionaryAssert:
+	return _contains_keys(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_key_value(key :Variant, value :Variant) -> GdUnitDictionaryAssert:
+	return _contains_key_value(key, value, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func not_contains_keys(expected :Array) -> GdUnitDictionaryAssert:
+	return _not_contains_keys(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_same_keys(expected :Array) -> GdUnitDictionaryAssert:
+	return _contains_keys(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func contains_same_key_value(key :Variant, value :Variant) -> GdUnitDictionaryAssert:
+	return _contains_key_value(key, value, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func not_contains_same_keys(expected :Array) -> GdUnitDictionaryAssert:
+	return _not_contains_keys(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func _filter_by_key(element :Variant, values :Array, compare_mode :GdObjects.COMPARE_MODE, is_not :bool = false) -> bool:
+	for key :Variant in values:
+		if GdObjects.equals(key, element, false, compare_mode):
+			return is_not
+	return !is_not

addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd

@@ -0,0 +1,110 @@
+extends GdUnitFailureAssert
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+var _is_failed := false
+var _failure_message :String
+
+
+func _set_do_expect_fail(enabled :bool = true) -> void:
+	Engine.set_meta(GdUnitConstants.EXPECT_ASSERT_REPORT_FAILURES, enabled)
+
+
+func execute_and_await(assertion :Callable, do_await := true) -> GdUnitFailureAssert:
+	# do not report any failure from the original assertion we want to test
+	_set_do_expect_fail(true)
+	var thread_context := GdUnitThreadManager.get_current_context()
+	thread_context.set_assert(null)
+	GdUnitSignals.instance().gdunit_set_test_failed.connect(_on_test_failed)
+	# execute the given assertion as callable
+	if do_await:
+		await assertion.call()
+	else:
+		assertion.call()
+	_set_do_expect_fail(false)
+	# get the assert instance from current tread context
+	var current_assert := thread_context.get_assert()
+	if not is_instance_of(current_assert, GdUnitAssert):
+		_is_failed = true
+		_failure_message = "Invalid Callable! It must be a callable of 'GdUnitAssert'"
+		return self
+	_failure_message = current_assert.failure_message()
+	return self
+
+
+func execute(assertion :Callable) -> GdUnitFailureAssert:
+	execute_and_await(assertion, false)
+	return self
+
+
+func _on_test_failed(value :bool) -> void:
+	_is_failed = value
+
+
+@warning_ignore("unused_parameter")
+func is_equal(_expected :GdUnitAssert) -> GdUnitFailureAssert:
+	return _report_error("Not implemented")
+
+
+@warning_ignore("unused_parameter")
+func is_not_equal(_expected :GdUnitAssert) -> GdUnitFailureAssert:
+	return _report_error("Not implemented")
+
+
+func is_null() -> GdUnitFailureAssert:
+	return _report_error("Not implemented")
+
+
+func is_not_null() -> GdUnitFailureAssert:
+	return _report_error("Not implemented")
+
+
+func is_success() -> GdUnitFailureAssert:
+	if _is_failed:
+		return _report_error("Expect: assertion ends successfully.")
+	return self
+
+
+func is_failed() -> GdUnitFailureAssert:
+	if not _is_failed:
+		return _report_error("Expect: assertion fails.")
+	return self
+
+
+func has_line(expected :int) -> GdUnitFailureAssert:
+	var current := GdAssertReports.get_last_error_line_number()
+	if current != expected:
+		return _report_error("Expect: to failed on line '%d'\n but was '%d'." % [expected, current])
+	return self
+
+
+func has_message(expected :String) -> GdUnitFailureAssert:
+	is_failed()
+	var expected_error := GdUnitTools.normalize_text(GdUnitTools.richtext_normalize(expected))
+	var current_error := GdUnitTools.normalize_text(GdUnitTools.richtext_normalize(_failure_message))
+	if current_error != expected_error:
+		var diffs := GdDiffTool.string_diff(current_error, expected_error)
+		var current := GdAssertMessages.colored_array_div(diffs[1])
+		_report_error(GdAssertMessages.error_not_same_error(current, expected_error))
+	return self
+
+
+func starts_with_message(expected :String) -> GdUnitFailureAssert:
+	var expected_error := GdUnitTools.normalize_text(expected)
+	var current_error := GdUnitTools.normalize_text(GdUnitTools.richtext_normalize(_failure_message))
+	if current_error.find(expected_error) != 0:
+		var diffs := GdDiffTool.string_diff(current_error, expected_error)
+		var current := GdAssertMessages.colored_array_div(diffs[1])
+		_report_error(GdAssertMessages.error_not_same_error(current, expected_error))
+	return self
+
+
+func _report_error(error_message :String, failure_line_number: int = -1) -> GdUnitAssert:
+	var line_number := failure_line_number if failure_line_number != -1 else GdUnitAssertions.get_line_number()
+	GdAssertReports.report_error(error_message, line_number)
+	return self
+
+
+func _report_success() -> GdUnitFailureAssert:
+	GdAssertReports.report_success()
+	return self

addons/gdUnit4/src/asserts/GdUnitFileAssertImpl.gd

@@ -0,0 +1,95 @@
+extends GdUnitFileAssert
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+var _base: GdUnitAssert
+
+
+func _init(current :Variant) -> void:
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_STRING):
+		report_error("GdUnitFileAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> String:
+	return _base.current_value() as String
+
+
+func report_success() -> GdUnitFileAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitFileAssert:
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func override_failure_message(message :String) -> GdUnitFileAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+func is_equal(expected :Variant) -> GdUnitFileAssert:
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected :Variant) -> GdUnitFileAssert:
+	_base.is_not_equal(expected)
+	return self
+
+
+func is_file() -> GdUnitFileAssert:
+	var current := current_value()
+	if FileAccess.open(current, FileAccess.READ) == null:
+		return report_error("Is not a file '%s', error code %s" % [current, FileAccess.get_open_error()])
+	return report_success()
+
+
+func exists() -> GdUnitFileAssert:
+	var current := current_value()
+	if not FileAccess.file_exists(current):
+		return report_error("The file '%s' not exists" %current)
+	return report_success()
+
+
+func is_script() -> GdUnitFileAssert:
+	var current := current_value()
+	if FileAccess.open(current, FileAccess.READ) == null:
+		return report_error("Can't acces the file '%s'! Error code %s" % [current, FileAccess.get_open_error()])
+
+	var script := load(current)
+	if not script is GDScript:
+		return report_error("The file '%s' is not a GdScript" % current)
+	return report_success()
+
+
+func contains_exactly(expected_rows :Array) -> GdUnitFileAssert:
+	var current := current_value()
+	if FileAccess.open(current, FileAccess.READ) == null:
+		return report_error("Can't acces the file '%s'! Error code %s" % [current, FileAccess.get_open_error()])
+
+	var script := load(current)
+	if script is GDScript:
+		var instance :Variant = script.new()
+		var source_code := GdScriptParser.to_unix_format(instance.get_script().source_code)
+		GdUnitTools.free_instance(instance)
+		var rows := Array(source_code.split("\n"))
+		ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitArrayAssertImpl.gd", "GDScript",
+							ResourceLoader.CACHE_MODE_REUSE).new(rows).contains_exactly(expected_rows)
+	return self

addons/gdUnit4/src/asserts/GdUnitFloatAssertImpl.gd

@@ -0,0 +1,144 @@
+extends GdUnitFloatAssert
+
+var _base: GdUnitAssert
+
+
+func _init(current :Variant) -> void:
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_FLOAT):
+		report_error("GdUnitFloatAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitFloatAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitFloatAssert:
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func override_failure_message(message :String) -> GdUnitFloatAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitFloatAssert:
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitFloatAssert:
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected :float) -> GdUnitFloatAssert:
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected :float) -> GdUnitFloatAssert:
+	_base.is_not_equal(expected)
+	return self
+
+
+@warning_ignore("shadowed_global_identifier")
+func is_equal_approx(expected :float, approx :float) -> GdUnitFloatAssert:
+	return is_between(expected-approx, expected+approx)
+
+
+func is_less(expected :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current >= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_THAN, current, expected))
+	return report_success()
+
+
+func is_less_equal(expected :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current > expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_EQUAL, current, expected))
+	return report_success()
+
+
+func is_greater(expected :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current <= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_THAN, current, expected))
+	return report_success()
+
+
+func is_greater_equal(expected :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current < expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_EQUAL, current, expected))
+	return report_success()
+
+
+func is_negative() -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current >= 0.0:
+		return report_error(GdAssertMessages.error_is_negative(current))
+	return report_success()
+
+
+func is_not_negative() -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current < 0.0:
+		return report_error(GdAssertMessages.error_is_not_negative(current))
+	return report_success()
+
+
+func is_zero() -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or not is_equal_approx(0.00000000, current):
+		return report_error(GdAssertMessages.error_is_zero(current))
+	return report_success()
+
+
+func is_not_zero() -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or is_equal_approx(0.00000000, current):
+		return report_error(GdAssertMessages.error_is_not_zero())
+	return report_success()
+
+
+func is_in(expected :Array) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if not expected.has(current):
+		return report_error(GdAssertMessages.error_is_in(current, expected))
+	return report_success()
+
+
+func is_not_in(expected :Array) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if expected.has(current):
+		return report_error(GdAssertMessages.error_is_not_in(current, expected))
+	return report_success()
+
+
+func is_between(from :float, to :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current < from or current > to:
+		return report_error(GdAssertMessages.error_is_value(Comparator.BETWEEN_EQUAL, current, from, to))
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitFuncAssertImpl.gd

@@ -0,0 +1,159 @@
+extends GdUnitFuncAssert
+
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+const DEFAULT_TIMEOUT := 2000
+
+
+var _current_value_provider :ValueProvider
+var _current_error_message :String = ""
+var _custom_failure_message :String = ""
+var _line_number := -1
+var _timeout := DEFAULT_TIMEOUT
+var _interrupted := false
+var _sleep_timer :Timer = null
+
+
+func _init(instance :Object, func_name :String, args := Array()) -> void:
+	_line_number = GdUnitAssertions.get_line_number()
+	GdAssertReports.reset_last_error_line_number()
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	# verify at first the function name exists
+	if not instance.has_method(func_name):
+		report_error("The function '%s' do not exists checked instance '%s'." % [func_name, instance])
+		_interrupted = true
+	else:
+		_current_value_provider = CallBackValueProvider.new(instance, func_name, args)
+
+
+func _notification(_what :int) -> void:
+	if is_instance_valid(_current_value_provider):
+		_current_value_provider.dispose()
+		_current_value_provider = null
+	if is_instance_valid(_sleep_timer):
+		Engine.get_main_loop().root.remove_child(_sleep_timer)
+		_sleep_timer.stop()
+		_sleep_timer.free()
+		_sleep_timer = null
+
+
+func report_success() -> GdUnitFuncAssert:
+	GdAssertReports.report_success()
+	return self
+
+
+func report_error(error_message :String) -> GdUnitFuncAssert:
+	_current_error_message = error_message if _custom_failure_message == "" else _custom_failure_message
+	GdAssertReports.report_error(_current_error_message, _line_number)
+	return self
+
+
+func failure_message() -> String:
+	return _current_error_message
+
+
+func send_report(report :GdUnitReport)-> void:
+	GdUnitSignals.instance().gdunit_report.emit(report)
+
+
+func override_failure_message(message :String) -> GdUnitFuncAssert:
+	_custom_failure_message = message
+	return self
+
+
+func wait_until(timeout := 2000) -> GdUnitFuncAssert:
+	if timeout <= 0:
+		push_warning("Invalid timeout param, alloed timeouts must be grater than 0. Use default timeout instead")
+		_timeout = DEFAULT_TIMEOUT
+	else:
+		_timeout = timeout
+	return self
+
+
+func is_null() -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_null)
+	return self
+
+
+func is_not_null() -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_not_null)
+	return self
+
+
+func is_false() -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_false)
+	return self
+
+
+func is_true() -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_true)
+	return self
+
+
+func is_equal(expected :Variant) -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_equal, expected)
+	return self
+
+
+func is_not_equal(expected :Variant) -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_not_equal, expected)
+	return self
+
+
+# we need actually to define this Callable as functions otherwise we results into leaked scripts here
+# this is actually a Godot bug and needs this kind of workaround
+func cb_is_null(c :Variant, _e :Variant) -> bool: return c == null
+func cb_is_not_null(c :Variant, _e :Variant) -> bool: return c != null
+func cb_is_false(c :Variant, _e :Variant) -> bool: return c == false
+func cb_is_true(c :Variant, _e :Variant) -> bool: return c == true
+func cb_is_equal(c :Variant, e :Variant) -> bool: return GdObjects.equals(c,e)
+func cb_is_not_equal(c :Variant, e :Variant) -> bool: return not GdObjects.equals(c, e)
+
+
+func _validate_callback(predicate :Callable, expected :Variant = null) -> void:
+	if _interrupted:
+		return
+	GdUnitMemoryObserver.guard_instance(self)
+	var time_scale := Engine.get_time_scale()
+	var timer := Timer.new()
+	timer.set_name("gdunit_funcassert_interrupt_timer_%d" % timer.get_instance_id())
+	Engine.get_main_loop().root.add_child(timer)
+	timer.add_to_group("GdUnitTimers")
+	timer.timeout.connect(func do_interrupt() -> void:
+		_interrupted = true
+		, CONNECT_DEFERRED)
+	timer.set_one_shot(true)
+	timer.start((_timeout/1000.0)*time_scale)
+	_sleep_timer = Timer.new()
+	_sleep_timer.set_name("gdunit_funcassert_sleep_timer_%d" % _sleep_timer.get_instance_id() )
+	Engine.get_main_loop().root.add_child(_sleep_timer)
+
+	while true:
+		var current :Variant = await next_current_value()
+		# is interupted or predicate success
+		if _interrupted or predicate.call(current, expected):
+			break
+		if is_instance_valid(_sleep_timer):
+			_sleep_timer.start(0.05)
+			await _sleep_timer.timeout
+
+	_sleep_timer.stop()
+	await Engine.get_main_loop().process_frame
+	if _interrupted:
+		# https://github.com/godotengine/godot/issues/73052
+		#var predicate_name = predicate.get_method()
+		var predicate_name :String = str(predicate).split('::')[1]
+		report_error(GdAssertMessages.error_interrupted(predicate_name.strip_edges().trim_prefix("cb_"), expected, LocalTime.elapsed(_timeout)))
+	else:
+		report_success()
+	_sleep_timer.free()
+	timer.free()
+	GdUnitMemoryObserver.unguard_instance(self)
+
+
+func next_current_value() -> Variant:
+	@warning_ignore("redundant_await")
+	if is_instance_valid(_current_value_provider):
+		return await _current_value_provider.get_value()
+	return "invalid value"

addons/gdUnit4/src/asserts/GdUnitGodotErrorAssertImpl.gd

@@ -0,0 +1,106 @@
+extends GdUnitGodotErrorAssert
+
+var _current_error_message :String
+var _callable :Callable
+
+
+func _init(callable :Callable) -> void:
+	# we only support Godot 4.1.x+ because of await issue https://github.com/godotengine/godot/issues/80292
+	assert(Engine.get_version_info().hex >= 0x40100,
+			"This assertion is not supported for Godot 4.0.x. Please upgrade to the minimum version Godot 4.1.0!")
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	GdAssertReports.reset_last_error_line_number()
+	_callable = callable
+
+
+func _execute() -> Array[ErrorLogEntry]:
+	# execute the given code and monitor for runtime errors
+	if _callable == null or not _callable.is_valid():
+		_report_error("Invalid Callable '%s'" % _callable)
+	else:
+		await _callable.call()
+	return await _error_monitor().scan(true)
+
+
+func _error_monitor() -> GodotGdErrorMonitor:
+	return GdUnitThreadManager.get_current_context().get_execution_context().error_monitor
+
+
+func failure_message() -> String:
+	return _current_error_message
+
+
+func _report_success() -> GdUnitAssert:
+	GdAssertReports.report_success()
+	return self
+
+
+func _report_error(error_message :String, failure_line_number: int = -1) -> GdUnitAssert:
+	var line_number := failure_line_number if failure_line_number != -1 else GdUnitAssertions.get_line_number()
+	_current_error_message = error_message
+	GdAssertReports.report_error(error_message, line_number)
+	return self
+
+
+func _has_log_entry(log_entries :Array[ErrorLogEntry], type :ErrorLogEntry.TYPE, error :String) -> bool:
+	for entry in log_entries:
+		if entry._type == type and entry._message == error:
+			# Erase the log entry we already handled it by this assertion, otherwise it will report at twice
+			_error_monitor().erase_log_entry(entry)
+			return true
+	return false
+
+
+func _to_list(log_entries :Array[ErrorLogEntry]) -> String:
+	if log_entries.is_empty():
+		return "no errors"
+	if log_entries.size() == 1:
+		return log_entries[0]._message
+	var value := ""
+	for entry in log_entries:
+		value += "'%s'\n" % entry._message
+	return value
+
+
+func is_success() -> GdUnitGodotErrorAssert:
+	var log_entries := await _execute()
+	if log_entries.is_empty():
+		return _report_success()
+	return _report_error("""
+		Expecting: no error's are ocured.
+			but found: '%s'
+		""".dedent().trim_prefix("\n") % _to_list(log_entries))
+
+
+func is_runtime_error(expected_error :String) -> GdUnitGodotErrorAssert:
+	var log_entries := await _execute()
+	if _has_log_entry(log_entries, ErrorLogEntry.TYPE.SCRIPT_ERROR, expected_error):
+		return _report_success()
+	return _report_error("""
+		Expecting: a runtime error is triggered.
+			message: '%s'
+			found: %s
+		""".dedent().trim_prefix("\n") % [expected_error, _to_list(log_entries)])
+
+
+func is_push_warning(expected_warning :String) -> GdUnitGodotErrorAssert:
+	var log_entries := await _execute()
+	if _has_log_entry(log_entries, ErrorLogEntry.TYPE.PUSH_WARNING, expected_warning):
+		return _report_success()
+	return _report_error("""
+		Expecting: push_warning() is called.
+			message: '%s'
+			found: %s
+		""".dedent().trim_prefix("\n") % [expected_warning, _to_list(log_entries)])
+
+
+func is_push_error(expected_error :String) -> GdUnitGodotErrorAssert:
+	var log_entries := await _execute()
+	if _has_log_entry(log_entries, ErrorLogEntry.TYPE.PUSH_ERROR, expected_error):
+		return _report_success()
+	return _report_error("""
+		Expecting: push_error() is called.
+			message: '%s'
+			found: %s
+		""".dedent().trim_prefix("\n") % [expected_error, _to_list(log_entries)])

addons/gdUnit4/src/asserts/GdUnitIntAssertImpl.gd

@@ -0,0 +1,153 @@
+extends GdUnitIntAssert
+
+var _base: GdUnitAssert
+
+
+func _init(current :Variant) -> void:
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_INT):
+		report_error("GdUnitIntAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitIntAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitIntAssert:
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func override_failure_message(message :String) -> GdUnitIntAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitIntAssert:
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitIntAssert:
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected :int) -> GdUnitIntAssert:
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected :int) -> GdUnitIntAssert:
+	_base.is_not_equal(expected)
+	return self
+
+
+func is_less(expected :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current >= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_THAN, current, expected))
+	return report_success()
+
+
+func is_less_equal(expected :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current > expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_EQUAL, current, expected))
+	return report_success()
+
+
+func is_greater(expected :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current <= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_THAN, current, expected))
+	return report_success()
+
+
+func is_greater_equal(expected :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current < expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_EQUAL, current, expected))
+	return report_success()
+
+
+func is_even() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current % 2 != 0:
+		return report_error(GdAssertMessages.error_is_even(current))
+	return report_success()
+
+
+func is_odd() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current % 2 == 0:
+		return report_error(GdAssertMessages.error_is_odd(current))
+	return report_success()
+
+
+func is_negative() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current >= 0:
+		return report_error(GdAssertMessages.error_is_negative(current))
+	return report_success()
+
+
+func is_not_negative() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current < 0:
+		return report_error(GdAssertMessages.error_is_not_negative(current))
+	return report_success()
+
+
+func is_zero() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current != 0:
+		return report_error(GdAssertMessages.error_is_zero(current))
+	return report_success()
+
+
+func is_not_zero() -> GdUnitIntAssert:
+	var current :Variant= current_value()
+	if current == 0:
+		return report_error(GdAssertMessages.error_is_not_zero())
+	return report_success()
+
+
+func is_in(expected :Array) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if not expected.has(current):
+		return report_error(GdAssertMessages.error_is_in(current, expected))
+	return report_success()
+
+
+func is_not_in(expected :Array) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if expected.has(current):
+		return report_error(GdAssertMessages.error_is_not_in(current, expected))
+	return report_success()
+
+
+func is_between(from :int, to :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current < from or current > to:
+		return report_error(GdAssertMessages.error_is_value(Comparator.BETWEEN_EQUAL, current, from, to))
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitObjectAssertImpl.gd

@@ -0,0 +1,109 @@
+extends GdUnitObjectAssert
+
+var _base :GdUnitAssert
+
+
+func _init(current :Variant) -> void:
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if (current != null
+		and (GdUnitAssertions.validate_value_type(current, TYPE_BOOL)
+		or GdUnitAssertions.validate_value_type(current, TYPE_INT)
+		or GdUnitAssertions.validate_value_type(current, TYPE_FLOAT)
+		or GdUnitAssertions.validate_value_type(current, TYPE_STRING))):
+			report_error("GdUnitObjectAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitObjectAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitObjectAssert:
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func override_failure_message(message :String) -> GdUnitObjectAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+func is_equal(expected :Variant) -> GdUnitObjectAssert:
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected :Variant) -> GdUnitObjectAssert:
+	_base.is_not_equal(expected)
+	return self
+
+
+func is_null() -> GdUnitObjectAssert:
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitObjectAssert:
+	_base.is_not_null()
+	return self
+
+
+@warning_ignore("shadowed_global_identifier")
+func is_same(expected :Variant) -> GdUnitObjectAssert:
+	var current :Variant = current_value()
+	if not is_same(current, expected):
+		report_error(GdAssertMessages.error_is_same(current, expected))
+		return self
+	report_success()
+	return self
+
+
+func is_not_same(expected :Variant) -> GdUnitObjectAssert:
+	var current :Variant = current_value()
+	if is_same(current, expected):
+		report_error(GdAssertMessages.error_not_same(current, expected))
+		return self
+	report_success()
+	return self
+
+
+func is_instanceof(type :Object) -> GdUnitObjectAssert:
+	var current :Variant = current_value()
+	if current == null or not is_instance_of(current, type):
+		var result_expected: = GdObjects.extract_class_name(type)
+		var result_current: = GdObjects.extract_class_name(current)
+		report_error(GdAssertMessages.error_is_instanceof(result_current, result_expected))
+		return self
+	report_success()
+	return self
+
+
+func is_not_instanceof(type :Variant) -> GdUnitObjectAssert:
+	var current :Variant = current_value()
+	if is_instance_of(current, type):
+		var result: = GdObjects.extract_class_name(type)
+		if result.is_success():
+			report_error("Expected not be a instance of <%s>" % result.value())
+		else:
+			push_error("Internal ERROR: %s" % result.error_message())
+		return self
+	report_success()
+	return self

addons/gdUnit4/src/asserts/GdUnitResultAssertImpl.gd

@@ -0,0 +1,122 @@
+extends GdUnitResultAssert
+
+var _base :GdUnitAssert
+
+
+func _init(current :Variant) -> void:
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not validate_value_type(current):
+		report_error("GdUnitResultAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func validate_value_type(value :Variant) -> bool:
+	return value == null or value is GdUnitResult
+
+
+func current_value() -> GdUnitResult:
+	return _base.current_value() as GdUnitResult
+
+
+func report_success() -> GdUnitResultAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitResultAssert:
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func override_failure_message(message :String) -> GdUnitResultAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitResultAssert:
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitResultAssert:
+	_base.is_not_null()
+	return self
+
+
+func is_empty() -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null or not result.is_empty():
+		report_error(GdAssertMessages.error_result_is_empty(result))
+	else:
+		report_success()
+	return self
+
+
+func is_success() -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null or not result.is_success():
+		report_error(GdAssertMessages.error_result_is_success(result))
+	else:
+		report_success()
+	return self
+
+
+func is_warning() -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null or not result.is_warn():
+		report_error(GdAssertMessages.error_result_is_warning(result))
+	else:
+		report_success()
+	return self
+
+
+func is_error() -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null or not result.is_error():
+		report_error(GdAssertMessages.error_result_is_error(result))
+	else:
+		report_success()
+	return self
+
+
+func contains_message(expected :String) -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null:
+		report_error(GdAssertMessages.error_result_has_message("<null>", expected))
+		return self
+	if result.is_success():
+		report_error(GdAssertMessages.error_result_has_message_on_success(expected))
+	elif result.is_error() and result.error_message() != expected:
+		report_error(GdAssertMessages.error_result_has_message(result.error_message(), expected))
+	elif result.is_warn() and result.warn_message() != expected:
+		report_error(GdAssertMessages.error_result_has_message(result.warn_message(), expected))
+	else:
+		report_success()
+	return self
+
+
+func is_value(expected :Variant) -> GdUnitResultAssert:
+	var result := current_value()
+	var value :Variant = null if result == null else result.value()
+	if not GdObjects.equals(value, expected):
+		report_error(GdAssertMessages.error_result_is_value(value, expected))
+	else:
+		report_success()
+	return self
+
+
+func is_equal(expected :Variant) -> GdUnitResultAssert:
+	return is_value(expected)

addons/gdUnit4/src/asserts/GdUnitSignalAssertImpl.gd

@@ -0,0 +1,110 @@
+extends GdUnitSignalAssert
+
+const DEFAULT_TIMEOUT := 2000
+
+var _signal_collector :GdUnitSignalCollector
+var _emitter :Object
+var _current_error_message :String = ""
+var _custom_failure_message :String = ""
+var _line_number := -1
+var _timeout := DEFAULT_TIMEOUT
+var _interrupted := false
+
+
+func _init(emitter :Object) -> void:
+	# save the actual assert instance on the current thread context
+	var context := GdUnitThreadManager.get_current_context()
+	context.set_assert(self)
+	_signal_collector = context.get_signal_collector()
+	_line_number = GdUnitAssertions.get_line_number()
+	_emitter =  emitter
+	GdAssertReports.reset_last_error_line_number()
+
+
+func report_success() -> GdUnitAssert:
+	GdAssertReports.report_success()
+	return self
+
+
+func report_warning(message :String) -> GdUnitAssert:
+	GdAssertReports.report_warning(message, GdUnitAssertions.get_line_number())
+	return self
+
+
+func report_error(error_message :String) -> GdUnitAssert:
+	_current_error_message = error_message if _custom_failure_message == "" else _custom_failure_message
+	GdAssertReports.report_error(_current_error_message, _line_number)
+	return self
+
+
+func failure_message() -> String:
+	return _current_error_message
+
+
+func send_report(report :GdUnitReport)-> void:
+	GdUnitSignals.instance().gdunit_report.emit(report)
+
+
+func override_failure_message(message :String) -> GdUnitSignalAssert:
+	_custom_failure_message = message
+	return self
+
+
+func wait_until(timeout := 2000) -> GdUnitSignalAssert:
+	if timeout <= 0:
+		report_warning("Invalid timeout parameter, allowed timeouts must be greater than 0, use default timeout instead!")
+		_timeout = DEFAULT_TIMEOUT
+	else:
+		_timeout = timeout
+	return self
+
+
+# Verifies the signal exists checked the emitter
+func is_signal_exists(signal_name :String) -> GdUnitSignalAssert:
+	if not _emitter.has_signal(signal_name):
+		report_error("The signal '%s' not exists checked object '%s'." % [signal_name, _emitter.get_class()])
+	return self
+
+
+# Verifies that given signal is emitted until waiting time
+func is_emitted(name :String, args := []) -> GdUnitSignalAssert:
+	_line_number = GdUnitAssertions.get_line_number()
+	return await _wail_until_signal(name, args, false)
+
+
+# Verifies that given signal is NOT emitted until waiting time
+func is_not_emitted(name :String, args := []) -> GdUnitSignalAssert:
+	_line_number = GdUnitAssertions.get_line_number()
+	return await _wail_until_signal(name, args, true)
+
+
+func _wail_until_signal(signal_name :String, expected_args :Array, expect_not_emitted: bool) -> GdUnitSignalAssert:
+	if _emitter == null:
+		report_error("Can't wait for signal checked a NULL object.")
+		return self
+	# first verify the signal is defined
+	if not _emitter.has_signal(signal_name):
+		report_error("Can't wait for non-existion signal '%s' checked object '%s'." % [signal_name,_emitter.get_class()])
+		return self
+	_signal_collector.register_emitter(_emitter)
+	var time_scale := Engine.get_time_scale()
+	var timer := Timer.new()
+	Engine.get_main_loop().root.add_child(timer)
+	timer.add_to_group("GdUnitTimers")
+	timer.set_one_shot(true)
+	timer.timeout.connect(func on_timeout() -> void: _interrupted = true)
+	timer.start((_timeout/1000.0)*time_scale)
+	var is_signal_emitted := false
+	while not _interrupted and not is_signal_emitted:
+		await Engine.get_main_loop().process_frame
+		if is_instance_valid(_emitter):
+			is_signal_emitted = _signal_collector.match(_emitter, signal_name, expected_args)
+			if is_signal_emitted and expect_not_emitted:
+				report_error(GdAssertMessages.error_signal_emitted(signal_name, expected_args, LocalTime.elapsed(int(_timeout-timer.time_left*1000))))
+
+	if _interrupted and not expect_not_emitted:
+		report_error(GdAssertMessages.error_wait_signal(signal_name, expected_args, LocalTime.elapsed(_timeout)))
+	timer.free()
+	if is_instance_valid(_emitter):
+		_signal_collector.reset_received_signals(_emitter, signal_name, expected_args)
+	return self

addons/gdUnit4/src/asserts/GdUnitStringAssertImpl.gd

@@ -0,0 +1,173 @@
+extends GdUnitStringAssert
+
+var _base :GdUnitAssert
+
+
+func _init(current :Variant) -> void:
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if current != null and typeof(current) != TYPE_STRING and typeof(current) != TYPE_STRING_NAME:
+		report_error("GdUnitStringAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitStringAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitStringAssert:
+	_base.report_error(error)
+	return self
+
+
+func override_failure_message(message :String) -> GdUnitStringAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitStringAssert:
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitStringAssert:
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected :Variant) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_equal(current, expected))
+	if not GdObjects.equals(current, expected):
+		var diffs := GdDiffTool.string_diff(current, expected)
+		var formatted_current := GdAssertMessages.colored_array_div(diffs[1])
+		return report_error(GdAssertMessages.error_equal(formatted_current, expected))
+	return report_success()
+
+
+func is_equal_ignoring_case(expected :Variant) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_equal_ignoring_case(current, expected))
+	if not GdObjects.equals(str(current), expected, true):
+		var diffs := GdDiffTool.string_diff(current, expected)
+		var formatted_current := GdAssertMessages.colored_array_div(diffs[1])
+		return report_error(GdAssertMessages.error_equal_ignoring_case(formatted_current, expected))
+	return report_success()
+
+
+func is_not_equal(expected :Variant) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if GdObjects.equals(current, expected):
+		return report_error(GdAssertMessages.error_not_equal(current, expected))
+	return report_success()
+
+
+func is_not_equal_ignoring_case(expected :Variant) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if GdObjects.equals(current, expected, true):
+		return report_error(GdAssertMessages.error_not_equal(current, expected))
+	return report_success()
+
+
+func is_empty() -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null or not current.is_empty():
+		return report_error(GdAssertMessages.error_is_empty(current))
+	return report_success()
+
+
+func is_not_empty() -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null or current.is_empty():
+		return report_error(GdAssertMessages.error_is_not_empty())
+	return report_success()
+
+
+func contains(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null or current.find(expected) == -1:
+		return report_error(GdAssertMessages.error_contains(current, expected))
+	return report_success()
+
+
+func not_contains(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current != null and current.find(expected) != -1:
+		return report_error(GdAssertMessages.error_not_contains(current, expected))
+	return report_success()
+
+
+func contains_ignoring_case(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null or current.findn(expected) == -1:
+		return report_error(GdAssertMessages.error_contains_ignoring_case(current, expected))
+	return report_success()
+
+
+func not_contains_ignoring_case(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current != null and current.findn(expected) != -1:
+		return report_error(GdAssertMessages.error_not_contains_ignoring_case(current, expected))
+	return report_success()
+
+
+func starts_with(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null or current.find(expected) != 0:
+		return report_error(GdAssertMessages.error_starts_with(current, expected))
+	return report_success()
+
+
+func ends_with(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_ends_with(current, expected))
+	var find :int = current.length() - expected.length()
+	if current.rfind(expected) != find:
+		return report_error(GdAssertMessages.error_ends_with(current, expected))
+	return report_success()
+
+
+# gdlint:disable=max-returns
+func has_length(expected :int, comparator := Comparator.EQUAL) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_has_length(current, expected, comparator))
+	match comparator:
+		Comparator.EQUAL:
+			if current.length() != expected:
+				return report_error(GdAssertMessages.error_has_length(current, expected, comparator))
+		Comparator.LESS_THAN:
+			if current.length() >= expected:
+				return report_error(GdAssertMessages.error_has_length(current, expected, comparator))
+		Comparator.LESS_EQUAL:
+			if current.length() > expected:
+				return report_error(GdAssertMessages.error_has_length(current, expected, comparator))
+		Comparator.GREATER_THAN:
+			if current.length() <= expected:
+				return report_error(GdAssertMessages.error_has_length(current, expected, comparator))
+		Comparator.GREATER_EQUAL:
+			if current.length() < expected:
+				return report_error(GdAssertMessages.error_has_length(current, expected, comparator))
+		_:
+			return report_error("Comparator '%d' not implemented!" % comparator)
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitVectorAssertImpl.gd

@@ -0,0 +1,172 @@
+extends GdUnitVectorAssert
+
+var _base: GdUnitAssert
+var _current_type :int
+
+
+func _init(current :Variant) -> void:
+	_base = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript",
+								ResourceLoader.CACHE_MODE_REUSE).new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not _validate_value_type(current):
+		report_error("GdUnitVectorAssert error, the type <%s> is not supported." % GdObjects.typeof_as_string(current))
+	_current_type = typeof(current)
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func _validate_value_type(value :Variant) -> bool:
+	return (
+		value == null
+		or typeof(value) in [
+			TYPE_VECTOR2,
+			TYPE_VECTOR2I,
+			TYPE_VECTOR3,
+			TYPE_VECTOR3I,
+			TYPE_VECTOR4,
+			TYPE_VECTOR4I
+		]
+	)
+
+
+func _validate_is_vector_type(value :Variant) -> bool:
+	var type := typeof(value)
+	if type == _current_type or _current_type == TYPE_NIL:
+		return true
+	report_error(GdAssertMessages.error_is_wrong_type(_current_type, type))
+	return false
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitVectorAssert:
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitVectorAssert:
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base._current_error_message
+
+
+func override_failure_message(message :String) -> GdUnitVectorAssert:
+	_base.override_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitVectorAssert:
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitVectorAssert:
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected :Variant) -> GdUnitVectorAssert:
+	if not _validate_is_vector_type(expected):
+		return self
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected :Variant) -> GdUnitVectorAssert:
+	if not _validate_is_vector_type(expected):
+		return self
+	_base.is_not_equal(expected)
+	return self
+
+
+@warning_ignore("shadowed_global_identifier")
+func is_equal_approx(expected :Variant, approx :Variant) -> GdUnitVectorAssert:
+	if not _validate_is_vector_type(expected) or not _validate_is_vector_type(approx):
+		return self
+	var current :Variant = current_value()
+	var from :Variant = expected - approx
+	var to :Variant = expected + approx
+	if current == null or (not _is_equal_approx(current, from, to)):
+		return report_error(GdAssertMessages.error_is_value(Comparator.BETWEEN_EQUAL, current, from, to))
+	return report_success()
+
+
+func _is_equal_approx(current :Variant, from :Variant, to :Variant) -> bool:
+	match typeof(current):
+		TYPE_VECTOR2, TYPE_VECTOR2I:
+			return ((current.x >= from.x and current.y >= from.y)
+				and (current.x <= to.x and current.y <= to.y))
+		TYPE_VECTOR3, TYPE_VECTOR3I:
+			return ((current.x >= from.x and current.y >= from.y and current.z >= from.z)
+				and (current.x <= to.x and current.y <= to.y and current.z <= to.z))
+		TYPE_VECTOR4, TYPE_VECTOR4I:
+			return ((current.x >= from.x and current.y >= from.y and current.z >= from.z and current.w >= from.w)
+				and (current.x <= to.x and current.y <= to.y and current.z <= to.z and current.w <= to.w))
+		_:
+			push_error("Missing implementation '_is_equal_approx' for vector type %s" % typeof(current))
+			return false
+
+
+func is_less(expected :Variant) -> GdUnitVectorAssert:
+	if not _validate_is_vector_type(expected):
+		return self
+	var current :Variant = current_value()
+	if current == null or current >= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_THAN, current, expected))
+	return report_success()
+
+
+func is_less_equal(expected :Variant) -> GdUnitVectorAssert:
+	if not _validate_is_vector_type(expected):
+		return self
+	var current :Variant = current_value()
+	if current == null or current > expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_EQUAL, current, expected))
+	return report_success()
+
+
+func is_greater(expected :Variant) -> GdUnitVectorAssert:
+	if not _validate_is_vector_type(expected):
+		return self
+	var current :Variant = current_value()
+	if current == null or current <= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_THAN, current, expected))
+	return report_success()
+
+
+func is_greater_equal(expected :Variant) -> GdUnitVectorAssert:
+	if not _validate_is_vector_type(expected):
+		return self
+	var current :Variant = current_value()
+	if current == null or current < expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_EQUAL, current, expected))
+	return report_success()
+
+
+func is_between(from :Variant, to :Variant) -> GdUnitVectorAssert:
+	if not _validate_is_vector_type(from) or not _validate_is_vector_type(to):
+		return self
+	var current :Variant = current_value()
+	if current == null or not (current >= from and current <= to):
+		return report_error(GdAssertMessages.error_is_value(Comparator.BETWEEN_EQUAL, current, from, to))
+	return report_success()
+
+
+func is_not_between(from :Variant, to :Variant) -> GdUnitVectorAssert:
+	if not _validate_is_vector_type(from) or not _validate_is_vector_type(to):
+		return self
+	var current :Variant = current_value()
+	if (current != null and current >= from and current <= to):
+		return report_error(GdAssertMessages.error_is_value(Comparator.NOT_BETWEEN_EQUAL, current, from, to))
+	return report_success()

addons/gdUnit4/src/asserts/ValueProvider.gd

@@ -0,0 +1,6 @@
+# base interface for assert value provider
+class_name ValueProvider
+extends RefCounted
+
+func get_value() -> Variant:
+	return null

addons/gdUnit4/src/cmd/CmdArgumentParser.gd

@@ -0,0 +1,61 @@
+class_name CmdArgumentParser
+extends RefCounted
+
+var _options :CmdOptions
+var _tool_name :String
+var _parsed_commands :Dictionary = Dictionary()
+
+
+func _init(p_options :CmdOptions, p_tool_name :String) -> void:
+	_options = p_options
+	_tool_name = p_tool_name
+
+
+func parse(args :Array, ignore_unknown_cmd := false) -> GdUnitResult:
+	_parsed_commands.clear()
+
+	# parse until first program argument
+	while not args.is_empty():
+		var arg :String = args.pop_front()
+		if arg.find(_tool_name) != -1:
+			break
+
+	if args.is_empty():
+		return GdUnitResult.empty()
+
+	# now parse all arguments
+	while not args.is_empty():
+		var cmd :String = args.pop_front()
+		var option := _options.get_option(cmd)
+
+		if option:
+			if _parse_cmd_arguments(option, args) == -1:
+				return GdUnitResult.error("The '%s' command requires an argument!" % option.short_command())
+		elif not ignore_unknown_cmd:
+			return GdUnitResult.error("Unknown '%s' command!" % cmd)
+	return GdUnitResult.success(_parsed_commands.values())
+
+
+func options() -> CmdOptions:
+	return _options
+
+
+func _parse_cmd_arguments(option :CmdOption, args :Array) -> int:
+	var command_name := option.short_command()
+	var command :CmdCommand = _parsed_commands.get(command_name, CmdCommand.new(command_name))
+
+	if option.has_argument():
+		if not option.is_argument_optional() and args.is_empty():
+			return -1
+		if _is_next_value_argument(args):
+			command.add_argument(args.pop_front())
+		elif not option.is_argument_optional():
+			return -1
+	_parsed_commands[command_name] = command
+	return 0
+
+
+func _is_next_value_argument(args :Array) -> bool:
+	if args.is_empty():
+		return false
+	return _options.get_option(args[0]) == null

addons/gdUnit4/src/cmd/CmdCommand.gd

@@ -0,0 +1,26 @@
+class_name CmdCommand
+extends RefCounted
+
+var _name: String
+var _arguments: PackedStringArray
+
+
+func _init(p_name :String, p_arguments := []) -> void:
+	_name = p_name
+	_arguments = PackedStringArray(p_arguments)
+
+
+func name() -> String:
+	return _name
+
+
+func arguments() -> PackedStringArray:
+	return _arguments
+
+
+func add_argument(arg :String) -> void:
+	_arguments.append(arg)
+
+
+func _to_string() -> String:
+	return "%s:%s" % [_name, ", ".join(_arguments)]

addons/gdUnit4/src/cmd/CmdCommandHandler.gd

@@ -0,0 +1,104 @@
+class_name CmdCommandHandler
+extends RefCounted
+
+const CB_SINGLE_ARG = 0
+const CB_MULTI_ARGS = 1
+const NO_CB := Callable()
+
+var _cmd_options :CmdOptions
+# holds the command callbacks by key:<cmd_name>:String and value: [<cb single arg>, <cb multible args>]:Array
+# Dictionary[String, Array[Callback]
+var _command_cbs :Dictionary
+
+# we only able to check cb function name since Godot 3.3.x
+var _enhanced_fr_test := false
+
+
+func _init(cmd_options: CmdOptions) -> void:
+	_cmd_options = cmd_options
+	var major: int = Engine.get_version_info()["major"]
+	var minor: int = Engine.get_version_info()["minor"]
+	if major == 3 and minor == 3:
+		_enhanced_fr_test = true
+
+
+# register a callback function for given command
+# cmd_name short name of the command
+# fr_arg a funcref to a function with a single argument
+func register_cb(cmd_name: String, cb: Callable = NO_CB) -> CmdCommandHandler:
+	var registered_cb: Array = _command_cbs.get(cmd_name, [NO_CB, NO_CB])
+	if registered_cb[CB_SINGLE_ARG]:
+		push_error("A function for command '%s' is already registered!" % cmd_name)
+		return self
+	registered_cb[CB_SINGLE_ARG] = cb
+	_command_cbs[cmd_name] = registered_cb
+	return self
+
+
+# register a callback function for given command
+# cb a funcref to a function with a variable number of arguments but expects all parameters to be passed via a single Array.
+func register_cbv(cmd_name: String, cb: Callable) -> CmdCommandHandler:
+	var registered_cb: Array = _command_cbs.get(cmd_name, [NO_CB, NO_CB])
+	if registered_cb[CB_MULTI_ARGS]:
+		push_error("A function for command '%s' is already registered!" % cmd_name)
+		return self
+	registered_cb[CB_MULTI_ARGS] = cb
+	_command_cbs[cmd_name] = registered_cb
+	return self
+
+
+func _validate() -> GdUnitResult:
+	var errors: = PackedStringArray()
+	# Dictionary[StringName, String]
+	var registered_cbs: = Dictionary()
+
+	for cmd_name in _command_cbs.keys() as Array[String]:
+		var cb: Callable = (_command_cbs[cmd_name][CB_SINGLE_ARG]
+			if _command_cbs[cmd_name][CB_SINGLE_ARG]
+			else _command_cbs[cmd_name][CB_MULTI_ARGS])
+		if cb != NO_CB and not cb.is_valid():
+			errors.append("Invalid function reference for command '%s', Check the function reference!" % cmd_name)
+		if _cmd_options.get_option(cmd_name) == null:
+			errors.append("The command '%s' is unknown, verify your CmdOptions!" % cmd_name)
+		# verify for multiple registered command callbacks
+		if _enhanced_fr_test and cb != NO_CB:
+			var cb_method: = cb.get_method()
+			if registered_cbs.has(cb_method):
+				var already_registered_cmd :String = registered_cbs[cb_method]
+				errors.append("The function reference '%s' already registerd for command '%s'!" % [cb_method, already_registered_cmd])
+			else:
+				registered_cbs[cb_method] = cmd_name
+	if errors.is_empty():
+		return GdUnitResult.success(true)
+	return GdUnitResult.error("\n".join(errors))
+
+
+func execute(commands :Array[CmdCommand]) -> GdUnitResult:
+	var result := _validate()
+	if result.is_error():
+		return result
+	for cmd in commands:
+		var cmd_name := cmd.name()
+		if _command_cbs.has(cmd_name):
+			var cb_s :Callable = _command_cbs.get(cmd_name)[CB_SINGLE_ARG]
+			var arguments := cmd.arguments()
+			var cmd_option := _cmd_options.get_option(cmd_name)
+			if cb_s and arguments.size() == 0:
+				cb_s.call()
+			elif cb_s:
+				if cmd_option.type() == TYPE_BOOL:
+					cb_s.call(true if arguments[0] == "true" else false)
+				else:
+					cb_s.call(arguments[0])
+			else:
+				var cb_m :Callable = _command_cbs.get(cmd_name)[CB_MULTI_ARGS]
+				# we need to find the method and determin the arguments to call the right function
+				for m in cb_m.get_object().get_method_list():
+					if m["name"] == cb_m.get_method():
+						if m["args"].size() > 1:
+							cb_m.callv(arguments)
+							break
+						else:
+							cb_m.call(arguments)
+							break
+	return GdUnitResult.success(true)

addons/gdUnit4/src/cmd/CmdConsole.gd

@@ -0,0 +1,145 @@
+# prototype of console with CSI support
+# https://notes.burke.libbey.me/ansi-escape-codes/
+class_name CmdConsole
+extends RefCounted
+
+enum {
+	COLOR_TABLE,
+	COLOR_RGB
+}
+
+const BOLD = 0x1
+const ITALIC = 0x2
+const UNDERLINE = 0x4
+
+const CSI_BOLD = ""
+const CSI_ITALIC = ""
+const CSI_UNDERLINE = ""
+
+# Control Sequence Introducer
+var _debug_show_color_codes := false
+var _color_mode := COLOR_TABLE
+
+
+func color(p_color :Color) -> CmdConsole:
+	# using color table 16 - 231 a  6 x 6 x 6 RGB color cube  (16 + R * 36 + G * 6 + B)
+	if _color_mode == COLOR_TABLE:
+		@warning_ignore("integer_division")
+		var c2 := 16 + (int(p_color.r8/42) * 36) + (int(p_color.g8/42) * 6) + int(p_color.b8/42)
+		if _debug_show_color_codes:
+			printraw("%6d" % [c2])
+		printraw("[38;5;%dm" % c2 )
+	else:
+		printraw("[38;2;%d;%d;%dm" % [p_color.r8, p_color.g8, p_color.b8] )
+	return self
+
+
+func save_cursor() -> CmdConsole:
+	printraw("")
+	return self
+
+
+func restore_cursor() -> CmdConsole:
+	printraw("")
+	return self
+
+
+func end_color() -> CmdConsole:
+	printraw("")
+	return self
+
+
+func row_pos(row :int) -> CmdConsole:
+	printraw("[%d;0H" % row )
+	return self
+
+
+func scroll_area(from :int, to :int) -> CmdConsole:
+	printraw("[%d;%dr" % [from ,to])
+	return self
+
+
+func progress_bar(p_progress :int, p_color :Color = Color.POWDER_BLUE) -> CmdConsole:
+	if p_progress < 0:
+		p_progress = 0
+	if p_progress > 100:
+		p_progress = 100
+	color(p_color)
+	printraw("[%-50s] %-3d%%\r" % ["".lpad(int(p_progress/2.0), "■").rpad(50, "-"), p_progress])
+	end_color()
+	return self
+
+
+func printl(value :String) -> CmdConsole:
+	printraw(value)
+	return self
+
+
+func new_line() -> CmdConsole:
+	prints()
+	return self
+
+
+func reset() -> CmdConsole:
+	return self
+
+
+func bold(enable :bool) -> CmdConsole:
+	if enable:
+		printraw(CSI_BOLD)
+	return self
+
+
+func italic(enable :bool) -> CmdConsole:
+	if enable:
+		printraw(CSI_ITALIC)
+	return self
+
+
+func underline(enable :bool) -> CmdConsole:
+	if enable:
+		printraw(CSI_UNDERLINE)
+	return self
+
+
+func prints_error(message :String) -> CmdConsole:
+	return color(Color.CRIMSON).printl(message).end_color().new_line()
+
+
+func prints_warning(message :String) -> CmdConsole:
+	return color(Color.GOLDENROD).printl(message).end_color().new_line()
+
+
+func prints_color(p_message :String, p_color :Color, p_flags := 0) -> CmdConsole:
+	return print_color(p_message, p_color, p_flags).new_line()
+
+
+func print_color(p_message :String, p_color :Color, p_flags := 0) -> CmdConsole:
+	return color(p_color)\
+		.bold(p_flags&BOLD == BOLD)\
+		.italic(p_flags&ITALIC == ITALIC)\
+		.underline(p_flags&UNDERLINE == UNDERLINE)\
+		.printl(p_message)\
+		.end_color()
+
+
+func print_color_table() -> void:
+	prints_color("Color Table 6x6x6", Color.ANTIQUE_WHITE)
+	_debug_show_color_codes = true
+	for green in range(0, 6):
+		for red in range(0, 6):
+			for blue in range(0, 6):
+				print_color("████████ ", Color8(red*42, green*42, blue*42))
+			new_line()
+		new_line()
+
+	prints_color("Color Table RGB", Color.ANTIQUE_WHITE)
+	_color_mode = COLOR_RGB
+	for green in range(0, 6):
+		for red in range(0, 6):
+			for blue in range(0, 6):
+				print_color("████████ ", Color8(red*42, green*42, blue*42))
+			new_line()
+		new_line()
+	_color_mode = COLOR_TABLE
+	_debug_show_color_codes = false

addons/gdUnit4/src/cmd/CmdOption.gd

@@ -0,0 +1,61 @@
+class_name CmdOption
+extends RefCounted
+
+
+var _commands :PackedStringArray
+var _help :String
+var _description :String
+var _type :int
+var _arg_optional :bool = false
+
+
+# constructs a command option by given arguments
+# commands : a string with comma separated list of available commands begining with the short form
+# help: a help text show howto use
+# description: a full description of the command
+# type: the argument type
+# arg_optional: defines of the argument optional
+func _init(p_commands :String, p_help :String, p_description :String, p_type :int = TYPE_NIL, p_arg_optional :bool = false) -> void:
+	_commands = p_commands.replace(" ", "").replace("\t", "").split(",")
+	_help = p_help
+	_description = p_description
+	_type = p_type
+	_arg_optional = p_arg_optional
+
+
+func commands() -> PackedStringArray:
+	return _commands
+
+
+func short_command() -> String:
+	return _commands[0]
+
+
+func help() -> String:
+	return _help
+
+
+func description() -> String:
+	return _description
+
+
+func type() -> int:
+	return _type
+
+
+func is_argument_optional() -> bool:
+	return _arg_optional
+
+
+func has_argument() -> bool:
+	return _type != TYPE_NIL
+
+
+func describe() -> String:
+	if help().is_empty():
+		return "  %-32s %s \n" % [commands(), description()]
+	return "  %-32s %s \n  %-32s %s\n" % [commands(), description(), "", help()]
+
+
+func _to_string() -> String:
+	return describe()

addons/gdUnit4/src/cmd/CmdOptions.gd

@@ -0,0 +1,31 @@
+class_name CmdOptions
+extends RefCounted
+
+
+var _default_options :Array[CmdOption]
+var _advanced_options :Array[CmdOption]
+
+
+func _init(p_options :Array[CmdOption] = [], p_advanced_options :Array[CmdOption] = []) -> void:
+	# default help options
+	_default_options = p_options
+	_advanced_options = p_advanced_options
+
+
+func default_options() -> Array[CmdOption]:
+	return _default_options
+
+
+func advanced_options() -> Array[CmdOption]:
+	return _advanced_options
+
+
+func options() -> Array[CmdOption]:
+	return default_options() + advanced_options()
+
+
+func get_option(cmd :String) -> CmdOption:
+	for option in options():
+		if Array(option.commands()).has(cmd):
+			return option
+	return null

addons/gdUnit4/src/core/GdArrayTools.gd

@@ -0,0 +1,101 @@
+## Small helper tool to work with Godot Arrays
+class_name GdArrayTools
+extends RefCounted
+
+
+const max_elements := 32
+const ARRAY_TYPES := [
+	TYPE_ARRAY,
+	TYPE_PACKED_BYTE_ARRAY,
+	TYPE_PACKED_INT32_ARRAY,
+	TYPE_PACKED_INT64_ARRAY,
+	TYPE_PACKED_FLOAT32_ARRAY,
+	TYPE_PACKED_FLOAT64_ARRAY,
+	TYPE_PACKED_STRING_ARRAY,
+	TYPE_PACKED_VECTOR2_ARRAY,
+	TYPE_PACKED_VECTOR3_ARRAY,
+	TYPE_PACKED_COLOR_ARRAY
+]
+
+
+static func is_array_type(value :Variant) -> bool:
+	return is_type_array(typeof(value))
+
+
+static func is_type_array(type :int) -> bool:
+	return  type in ARRAY_TYPES
+
+
+## Filters an array by given value[br]
+## If the given value not an array it returns null, will remove all occurence of given value.
+static func filter_value(array :Variant, value :Variant) -> Variant:
+	if not is_array_type(array):
+		return null
+	var filtered_array :Variant = array.duplicate()
+	var index :int = filtered_array.find(value)
+	while index != -1:
+		filtered_array.remove_at(index)
+		index = filtered_array.find(value)
+	return filtered_array
+
+
+## Erases a value from given array by using equals(l,r) to find the element to erase
+static func erase_value(array :Array, value :Variant) -> void:
+	for element :Variant in array:
+		if GdObjects.equals(element, value):
+			array.erase(element)
+
+
+## Scans for the array build in type on a untyped array[br]
+## Returns the buildin type by scan all values and returns the type if all values has the same type.
+## If the values has different types TYPE_VARIANT is returend
+static func scan_typed(array :Array) -> int:
+	if array.is_empty():
+		return TYPE_NIL
+	var actual_type := GdObjects.TYPE_VARIANT
+	for value :Variant in array:
+		var current_type := typeof(value)
+		if not actual_type in [GdObjects.TYPE_VARIANT, current_type]:
+			return GdObjects.TYPE_VARIANT
+		actual_type = current_type
+	return actual_type
+
+
+## Converts given array into a string presentation.[br]
+## This function is different to the original Godot str(<array>) implementation.
+## The string presentaion contains fullquallified typed informations.
+##[br]
+## Examples:
+## 	[codeblock]
+##		# will result in PackedString(["a", "b"])
+## 		GdArrayTools.as_string(PackedStringArray("a", "b"))
+##		# will result in PackedString(["a", "b"])
+##		GdArrayTools.as_string(PackedColorArray(Color.RED, COLOR.GREEN))
+## 	[/codeblock]
+static func as_string(elements :Variant, encode_value := true) -> String:
+	if not is_array_type(elements):
+		return "ERROR: Not an Array Type!"
+	var delemiter := ", "
+	if elements == null:
+		return "<null>"
+	if elements.is_empty():
+		return "<empty>"
+	var prefix := _typeof_as_string(elements) if encode_value else ""
+	var formatted := ""
+	var index := 0
+	for element :Variant in elements:
+		if max_elements != -1 and index > max_elements:
+			return prefix + "[" + formatted + delemiter + "...]"
+		if formatted.length() > 0 :
+			formatted += delemiter
+		formatted += GdDefaultValueDecoder.decode(element) if encode_value else str(element)
+		index += 1
+	return prefix + "[" + formatted + "]"
+
+
+static func _typeof_as_string(value :Variant) -> String:
+	var type := typeof(value)
+	# for untyped array we retun empty string
+	if type == TYPE_ARRAY:
+		return ""
+	return GdObjects.typeof_as_string(value)

addons/gdUnit4/src/core/GdDiffTool.gd

@@ -0,0 +1,155 @@
+# A tool to find differences between two objects
+class_name GdDiffTool
+extends RefCounted
+
+
+const DIV_ADD :int = 214
+const DIV_SUB :int = 215
+
+
+static func _diff(lb: PackedByteArray, rb: PackedByteArray, lookup: Array, ldiff: Array, rdiff: Array) -> void:
+	var loffset := lb.size()
+	var roffset := rb.size()
+
+	while true:
+		#if last character of X and Y matches
+		if loffset > 0 && roffset > 0 && lb[loffset - 1] == rb[roffset - 1]:
+			loffset -= 1
+			roffset -= 1
+			ldiff.push_front(lb[loffset])
+			rdiff.push_front(rb[roffset])
+			continue
+		#current character of Y is not present in X
+		else: if (roffset > 0 && (loffset == 0 || lookup[loffset][roffset - 1] >= lookup[loffset - 1][roffset])):
+			roffset -= 1
+			ldiff.push_front(rb[roffset])
+			ldiff.push_front(DIV_ADD)
+			rdiff.push_front(rb[roffset])
+			rdiff.push_front(DIV_SUB)
+			continue
+		#current character of X is not present in Y
+		else: if (loffset > 0 && (roffset == 0 || lookup[loffset][roffset - 1] < lookup[loffset - 1][roffset])):
+			loffset -= 1
+			ldiff.push_front(lb[loffset])
+			ldiff.push_front(DIV_SUB)
+			rdiff.push_front(lb[loffset])
+			rdiff.push_front(DIV_ADD)
+			continue
+		break
+
+
+# lookup[i][j] stores the length of LCS of substring X[0..i-1], Y[0..j-1]
+static func _createLookUp(lb: PackedByteArray, rb: PackedByteArray) -> Array:
+	var lookup := Array()
+	lookup.resize(lb.size() + 1)
+	for i in lookup.size():
+		var x := []
+		x.resize(rb.size() + 1)
+		lookup[i] = x
+	return lookup
+
+
+static func _buildLookup(lb: PackedByteArray, rb: PackedByteArray) -> Array:
+	var lookup := _createLookUp(lb, rb)
+	# first column of the lookup table will be all 0
+	for i in lookup.size():
+		lookup[i][0] = 0
+	# first row of the lookup table will be all 0
+	for j :int in lookup[0].size():
+		lookup[0][j] = 0
+
+	# fill the lookup table in bottom-up manner
+	for i in range(1, lookup.size()):
+		for j in range(1, lookup[0].size()):
+			# if current character of left and right matches
+			if lb[i - 1] == rb[j - 1]:
+				lookup[i][j] = lookup[i - 1][j - 1] + 1;
+			# else if current character of left and right don't match
+			else:
+				lookup[i][j] = max(lookup[i - 1][j], lookup[i][j - 1]);
+	return lookup
+
+
+static func string_diff(left :Variant, right :Variant) -> Array[PackedByteArray]:
+	var lb := PackedByteArray() if left == null else str(left).to_utf8_buffer()
+	var rb := PackedByteArray() if right == null else str(right).to_utf8_buffer()
+	var ldiff := Array()
+	var rdiff := Array()
+	var lookup := _buildLookup(lb, rb);
+	_diff(lb, rb, lookup, ldiff, rdiff)
+	return [PackedByteArray(ldiff), PackedByteArray(rdiff)]
+
+
+# prototype
+static func longestCommonSubsequence(text1 :String, text2 :String) -> PackedStringArray:
+	var text1Words := text1.split(" ")
+	var text2Words := text2.split(" ")
+	var text1WordCount := text1Words.size()
+	var text2WordCount := text2Words.size()
+	var solutionMatrix := Array()
+	for i in text1WordCount+1:
+		var ar := Array()
+		for n in text2WordCount+1:
+			ar.append(0)
+		solutionMatrix.append(ar)
+
+	for i in range(text1WordCount-1, 0, -1):
+		for j in range(text2WordCount-1, 0, -1):
+			if text1Words[i] == text2Words[j]:
+				solutionMatrix[i][j] = solutionMatrix[i + 1][j + 1] + 1;
+			else:
+				solutionMatrix[i][j] = max(solutionMatrix[i + 1][j], solutionMatrix[i][j + 1]);
+
+	var i := 0
+	var j := 0
+	var lcsResultList := PackedStringArray();
+	while (i < text1WordCount && j < text2WordCount):
+		if text1Words[i] == text2Words[j]:
+			lcsResultList.append(text2Words[j])
+			i += 1
+			j += 1
+		else: if (solutionMatrix[i + 1][j] >= solutionMatrix[i][j + 1]):
+			i += 1
+		else:
+			j += 1
+	return lcsResultList
+
+
+static func markTextDifferences(text1 :String, text2 :String, lcsList :PackedStringArray, insertColor :Color, deleteColor:Color) -> String:
+	var stringBuffer := ""
+	if text1 == null and lcsList == null:
+		return stringBuffer
+
+	var text1Words := text1.split(" ")
+	var text2Words := text2.split(" ")
+	var i := 0
+	var j := 0
+	var word1LastIndex := 0
+	var word2LastIndex := 0
+	for k in lcsList.size():
+		while i < text1Words.size() and j < text2Words.size():
+			if text1Words[i] == lcsList[k] and text2Words[j] == lcsList[k]:
+				stringBuffer += "<SPAN>" + lcsList[k] + " </SPAN>"
+				word1LastIndex = i + 1
+				word2LastIndex = j + 1
+				i = text1Words.size()
+				j = text2Words.size()
+
+			else: if text1Words[i] != lcsList[k]:
+				while i < text1Words.size() and text1Words[i] != lcsList[k]:
+					stringBuffer += "<SPAN style='BACKGROUND-COLOR:" + deleteColor.to_html() + "'>" + text1Words[i] + " </SPAN>"
+					i += 1
+			else: if text2Words[j] != lcsList[k]:
+				while j < text2Words.size() and text2Words[j] != lcsList[k]:
+					stringBuffer += "<SPAN style='BACKGROUND-COLOR:" + insertColor.to_html() + "'>" + text2Words[j] + " </SPAN>"
+					j += 1
+			i = word1LastIndex
+			j = word2LastIndex
+
+			while word1LastIndex < text1Words.size():
+				stringBuffer += "<SPAN style='BACKGROUND-COLOR:" + deleteColor.to_html() + "'>" + text1Words[word1LastIndex] + " </SPAN>"
+				word1LastIndex += 1
+			while word2LastIndex < text2Words.size():
+				stringBuffer += "<SPAN style='BACKGROUND-COLOR:" + insertColor.to_html() + "'>" + text2Words[word2LastIndex] + " </SPAN>"
+				word2LastIndex += 1
+	return stringBuffer

addons/gdUnit4/src/core/GdFunctionDoubler.gd

@@ -0,0 +1,189 @@
+class_name GdFunctionDoubler
+extends RefCounted
+
+const DEFAULT_TYPED_RETURN_VALUES := {
+	TYPE_NIL: "null",
+	TYPE_BOOL: "false",
+	TYPE_INT: "0",
+	TYPE_FLOAT: "0.0",
+	TYPE_STRING: "\"\"",
+	TYPE_STRING_NAME: "&\"\"",
+	TYPE_VECTOR2: "Vector2.ZERO",
+	TYPE_VECTOR2I: "Vector2i.ZERO",
+	TYPE_RECT2: "Rect2()",
+	TYPE_RECT2I: "Rect2i()",
+	TYPE_VECTOR3: "Vector3.ZERO",
+	TYPE_VECTOR3I: "Vector3i.ZERO",
+	TYPE_VECTOR4: "Vector4.ZERO",
+	TYPE_VECTOR4I: "Vector4i.ZERO",
+	TYPE_TRANSFORM2D: "Transform2D()",
+	TYPE_PLANE: "Plane()",
+	TYPE_QUATERNION: "Quaternion()",
+	TYPE_AABB: "AABB()",
+	TYPE_BASIS: "Basis()",
+	TYPE_TRANSFORM3D: "Transform3D()",
+	TYPE_PROJECTION: "Projection()",
+	TYPE_COLOR: "Color()",
+	TYPE_NODE_PATH: "NodePath()",
+	TYPE_RID: "RID()",
+	TYPE_OBJECT: "null",
+	TYPE_CALLABLE: "Callable()",
+	TYPE_SIGNAL: "Signal()",
+	TYPE_DICTIONARY: "Dictionary()",
+	TYPE_ARRAY: "Array()",
+	TYPE_PACKED_BYTE_ARRAY: "PackedByteArray()",
+	TYPE_PACKED_INT32_ARRAY: "PackedInt32Array()",
+	TYPE_PACKED_INT64_ARRAY: "PackedInt64Array()",
+	TYPE_PACKED_FLOAT32_ARRAY: "PackedFloat32Array()",
+	TYPE_PACKED_FLOAT64_ARRAY: "PackedFloat64Array()",
+	TYPE_PACKED_STRING_ARRAY: "PackedStringArray()",
+	TYPE_PACKED_VECTOR2_ARRAY: "PackedVector2Array()",
+	TYPE_PACKED_VECTOR3_ARRAY: "PackedVector3Array()",
+	TYPE_PACKED_COLOR_ARRAY: "PackedColorArray()",
+	GdObjects.TYPE_VARIANT: "null",
+	GdObjects.TYPE_ENUM: "0"
+}
+
+# @GlobalScript enums
+# needs to manually map because of https://github.com/godotengine/godot/issues/73835
+const DEFAULT_ENUM_RETURN_VALUES = {
+	"Side" : "SIDE_LEFT",
+	"Corner" : "CORNER_TOP_LEFT",
+	"Orientation" : "HORIZONTAL",
+	"ClockDirection" : "CLOCKWISE",
+	"HorizontalAlignment" : "HORIZONTAL_ALIGNMENT_LEFT",
+	"VerticalAlignment" : "VERTICAL_ALIGNMENT_TOP",
+	"InlineAlignment" : "INLINE_ALIGNMENT_TOP_TO",
+	"EulerOrder" : "EULER_ORDER_XYZ",
+	"Key" : "KEY_NONE",
+	"KeyModifierMask" : "KEY_CODE_MASK",
+	"MouseButton" : "MOUSE_BUTTON_NONE",
+	"MouseButtonMask" : "MOUSE_BUTTON_MASK_LEFT",
+	"JoyButton" : "JOY_BUTTON_INVALID",
+	"JoyAxis" : "JOY_AXIS_INVALID",
+	"MIDIMessage" : "MIDI_MESSAGE_NONE",
+	"Error" : "OK",
+	"PropertyHint" : "PROPERTY_HINT_NONE",
+	"Variant.Type" : "TYPE_NIL",
+}
+
+var _push_errors :String
+
+
+# Determine the enum default by reflection
+static func get_enum_default(value :String) -> Variant:
+	var script := GDScript.new()
+	script.source_code = """
+	extends Resource
+
+	static func get_enum_default() -> Variant:
+		return %s.values()[0]
+
+	""".dedent() % value
+	script.reload()
+	return script.new().call("get_enum_default")
+
+
+static func default_return_value(func_descriptor :GdFunctionDescriptor) -> String:
+	var return_type :Variant = func_descriptor.return_type()
+	if return_type == GdObjects.TYPE_ENUM:
+		var enum_class := func_descriptor._return_class
+		var enum_path := enum_class.split(".")
+		if enum_path.size() >= 2:
+			var keys := ClassDB.class_get_enum_constants(enum_path[0], enum_path[1])
+			if not keys.is_empty():
+				return "%s.%s" % [enum_path[0], keys[0]]
+			var enum_value :Variant = get_enum_default(enum_class)
+			if enum_value != null:
+				return str(enum_value)
+		# we need fallback for @GlobalScript enums,
+		return DEFAULT_ENUM_RETURN_VALUES.get(func_descriptor._return_class, "0")
+	return DEFAULT_TYPED_RETURN_VALUES.get(return_type, "invalid")
+
+
+func _init(push_errors :bool = false) -> void:
+	_push_errors = "true" if push_errors else "false"
+	for type_key in TYPE_MAX:
+		if not DEFAULT_TYPED_RETURN_VALUES.has(type_key):
+			push_error("missing default definitions! Expexting %d bud is %d" % [DEFAULT_TYPED_RETURN_VALUES.size(), TYPE_MAX])
+			prints("missing default definition for type", type_key)
+			assert(DEFAULT_TYPED_RETURN_VALUES.has(type_key), "Missing Type default definition!")
+
+
+@warning_ignore("unused_parameter")
+func get_template(return_type :Variant, is_vararg :bool) -> String:
+	push_error("Must be implemented!")
+	return ""
+
+func double(func_descriptor :GdFunctionDescriptor) -> PackedStringArray:
+	var func_signature := func_descriptor.typeless()
+	var is_static := func_descriptor.is_static()
+	var is_vararg := func_descriptor.is_vararg()
+	var is_coroutine := func_descriptor.is_coroutine()
+	var func_name := func_descriptor.name()
+	var args := func_descriptor.args()
+	var varargs := func_descriptor.varargs()
+	var return_value := GdFunctionDoubler.default_return_value(func_descriptor)
+	var arg_names := extract_arg_names(args)
+	var vararg_names := extract_arg_names(varargs)
+
+	# save original constructor arguments
+	if func_name == "_init":
+		var constructor_args := ",".join(GdFunctionDoubler.extract_constructor_args(args))
+		var constructor := "func _init(%s) -> void:\n	super(%s)\n	pass\n" % [constructor_args, ", ".join(arg_names)]
+		return constructor.split("\n")
+
+	var double_src := ""
+	double_src += '@warning_ignore("untyped_declaration")\n' if Engine.get_version_info().hex >= 0x40200 else '\n'
+	if func_descriptor.is_engine():
+		double_src += '@warning_ignore("native_method_override")\n'
+	if func_descriptor.return_type() == GdObjects.TYPE_ENUM:
+		double_src += '@warning_ignore("int_as_enum_without_match")\n'
+		double_src += '@warning_ignore("int_as_enum_without_cast")\n'
+	double_src += '@warning_ignore("shadowed_variable")\n'
+	double_src += func_signature
+	# fix to  unix format, this is need when the template is edited under windows than the template is stored with \r\n
+	var func_template := get_template(func_descriptor.return_type(), is_vararg).replace("\r\n", "\n")
+	double_src += func_template\
+		.replace("$(arguments)", ", ".join(arg_names))\
+		.replace("$(varargs)", ", ".join(vararg_names))\
+		.replace("$(await)", GdFunctionDoubler.await_is_coroutine(is_coroutine)) \
+		.replace("$(func_name)", func_name )\
+		.replace("${default_return_value}", return_value)\
+		.replace("$(push_errors)", _push_errors)
+
+	if is_static:
+		double_src = double_src.replace("$(instance)", "__instance().")
+	else:
+		double_src = double_src.replace("$(instance)", "")
+	return double_src.split("\n")
+
+
+func extract_arg_names(argument_signatures :Array[GdFunctionArgument]) -> PackedStringArray:
+	var arg_names := PackedStringArray()
+	for arg in argument_signatures:
+		arg_names.append(arg._name)
+	return arg_names
+
+
+static func extract_constructor_args(args :Array[GdFunctionArgument]) -> PackedStringArray:
+	var constructor_args := PackedStringArray()
+	for arg in args:
+		var arg_name := arg._name
+		var default_value := get_default(arg)
+		if default_value == "null":
+			constructor_args.append(arg_name + ":Variant=" + default_value)
+		else:
+			constructor_args.append(arg_name + ":=" + default_value)
+	return constructor_args
+
+
+static func get_default(arg :GdFunctionArgument) -> String:
+	if arg.has_default():
+		return arg.value_as_string()
+	else:
+		return DEFAULT_TYPED_RETURN_VALUES.get(arg.type(), "null")
+
+
+static func await_is_coroutine(is_coroutine :bool) -> String:
+	return "await " if is_coroutine else ""

addons/gdUnit4/src/core/GdObjects.gd

@@ -0,0 +1,691 @@
+# This is a helper class to compare two objects by equals
+class_name GdObjects
+extends Resource
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+const TYPE_VOID 	= TYPE_MAX + 1000
+const TYPE_VARARG 	= TYPE_MAX + 1001
+const TYPE_VARIANT	= TYPE_MAX + 1002
+const TYPE_FUNC 	= TYPE_MAX + 1003
+const TYPE_FUZZER 	= TYPE_MAX + 1004
+
+const TYPE_NODE 	= TYPE_MAX + 2001
+# missing Godot types
+const TYPE_CONTROL	= TYPE_MAX + 2002
+const TYPE_CANVAS	= TYPE_MAX + 2003
+const TYPE_ENUM		= TYPE_MAX + 2004
+
+
+# used as default value for varargs
+const TYPE_VARARG_PLACEHOLDER_VALUE = "__null__"
+
+
+const TYPE_AS_STRING_MAPPINGS := {
+	TYPE_NIL: "null",
+	TYPE_BOOL: "bool",
+	TYPE_INT: "int",
+	TYPE_FLOAT: "float",
+	TYPE_STRING: "String",
+	TYPE_VECTOR2: "Vector2",
+	TYPE_VECTOR2I: "Vector2i",
+	TYPE_RECT2: "Rect2",
+	TYPE_RECT2I: "Rect2i",
+	TYPE_VECTOR3: "Vector3",
+	TYPE_VECTOR3I: "Vector3i",
+	TYPE_TRANSFORM2D: "Transform2D",
+	TYPE_VECTOR4: "Vector4",
+	TYPE_VECTOR4I: "Vector4i",
+	TYPE_PLANE: "Plane",
+	TYPE_QUATERNION: "Quaternion",
+	TYPE_AABB: "AABB",
+	TYPE_BASIS: "Basis",
+	TYPE_TRANSFORM3D: "Transform3D",
+	TYPE_PROJECTION: "Projection",
+	TYPE_COLOR: "Color",
+	TYPE_STRING_NAME: "StringName",
+	TYPE_NODE_PATH: "NodePath",
+	TYPE_RID: "RID",
+	TYPE_OBJECT: "Object",
+	TYPE_CALLABLE: "Callable",
+	TYPE_SIGNAL: "Signal",
+	TYPE_DICTIONARY: "Dictionary",
+	TYPE_ARRAY: "Array",
+	TYPE_PACKED_BYTE_ARRAY: "PackedByteArray",
+	TYPE_PACKED_INT32_ARRAY: "PackedInt32Array",
+	TYPE_PACKED_INT64_ARRAY: "PackedInt64Array",
+	TYPE_PACKED_FLOAT32_ARRAY: "PackedFloat32Array",
+	TYPE_PACKED_FLOAT64_ARRAY: "PackedFloat64Array",
+	TYPE_PACKED_STRING_ARRAY: "PackedStringArray",
+	TYPE_PACKED_VECTOR2_ARRAY: "PackedVector2Array",
+	TYPE_PACKED_VECTOR3_ARRAY: "PackedVector3Array",
+	TYPE_PACKED_COLOR_ARRAY: "PackedColorArray",
+	TYPE_VOID: "void",
+	TYPE_VARARG: "VarArg",
+	TYPE_FUNC: "Func",
+	TYPE_FUZZER: "Fuzzer",
+	TYPE_VARIANT: "Variant"
+}
+
+
+const NOTIFICATION_AS_STRING_MAPPINGS := {
+	TYPE_OBJECT: {
+		Object.NOTIFICATION_POSTINITIALIZE : "POSTINITIALIZE",
+		Object.NOTIFICATION_PREDELETE: "PREDELETE",
+		EditorSettings.NOTIFICATION_EDITOR_SETTINGS_CHANGED: "EDITOR_SETTINGS_CHANGED",
+	},
+	TYPE_NODE: {
+		Node.NOTIFICATION_ENTER_TREE : "ENTER_TREE",
+		Node.NOTIFICATION_EXIT_TREE: "EXIT_TREE",
+		Node.NOTIFICATION_CHILD_ORDER_CHANGED: "CHILD_ORDER_CHANGED",
+		Node.NOTIFICATION_READY: "READY",
+		Node.NOTIFICATION_PAUSED: "PAUSED",
+		Node.NOTIFICATION_UNPAUSED: "UNPAUSED",
+		Node.NOTIFICATION_PHYSICS_PROCESS: "PHYSICS_PROCESS",
+		Node.NOTIFICATION_PROCESS: "PROCESS",
+		Node.NOTIFICATION_PARENTED: "PARENTED",
+		Node.NOTIFICATION_UNPARENTED: "UNPARENTED",
+		Node.NOTIFICATION_SCENE_INSTANTIATED: "INSTANCED",
+		Node.NOTIFICATION_DRAG_BEGIN: "DRAG_BEGIN",
+		Node.NOTIFICATION_DRAG_END: "DRAG_END",
+		Node.NOTIFICATION_PATH_RENAMED: "PATH_CHANGED",
+		Node.NOTIFICATION_INTERNAL_PROCESS: "INTERNAL_PROCESS",
+		Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS: "INTERNAL_PHYSICS_PROCESS",
+		Node.NOTIFICATION_POST_ENTER_TREE: "POST_ENTER_TREE",
+		Node.NOTIFICATION_WM_MOUSE_ENTER: "WM_MOUSE_ENTER",
+		Node.NOTIFICATION_WM_MOUSE_EXIT: "WM_MOUSE_EXIT",
+		Node.NOTIFICATION_APPLICATION_FOCUS_IN: "WM_FOCUS_IN",
+		Node.NOTIFICATION_APPLICATION_FOCUS_OUT: "WM_FOCUS_OUT",
+		#Node.NOTIFICATION_WM_QUIT_REQUEST: "WM_QUIT_REQUEST",
+		Node.NOTIFICATION_WM_GO_BACK_REQUEST: "WM_GO_BACK_REQUEST",
+		Node.NOTIFICATION_WM_WINDOW_FOCUS_OUT: "WM_UNFOCUS_REQUEST",
+		Node.NOTIFICATION_OS_MEMORY_WARNING: "OS_MEMORY_WARNING",
+		Node.NOTIFICATION_TRANSLATION_CHANGED: "TRANSLATION_CHANGED",
+		Node.NOTIFICATION_WM_ABOUT: "WM_ABOUT",
+		Node.NOTIFICATION_CRASH: "CRASH",
+		Node.NOTIFICATION_OS_IME_UPDATE: "OS_IME_UPDATE",
+		Node.NOTIFICATION_APPLICATION_RESUMED: "APP_RESUMED",
+		Node.NOTIFICATION_APPLICATION_PAUSED: "APP_PAUSED",
+		Node3D.NOTIFICATION_TRANSFORM_CHANGED: "TRANSFORM_CHANGED",
+		Node3D.NOTIFICATION_ENTER_WORLD: "ENTER_WORLD",
+		Node3D.NOTIFICATION_EXIT_WORLD: "EXIT_WORLD",
+		Node3D.NOTIFICATION_VISIBILITY_CHANGED: "VISIBILITY_CHANGED",
+		Skeleton3D.NOTIFICATION_UPDATE_SKELETON: "UPDATE_SKELETON",
+		CanvasItem.NOTIFICATION_DRAW: "DRAW",
+		CanvasItem.NOTIFICATION_VISIBILITY_CHANGED: "VISIBILITY_CHANGED",
+		CanvasItem.NOTIFICATION_ENTER_CANVAS: "ENTER_CANVAS",
+		CanvasItem.NOTIFICATION_EXIT_CANVAS: "EXIT_CANVAS",
+		#Popup.NOTIFICATION_POST_POPUP: "POST_POPUP",
+		#Popup.NOTIFICATION_POPUP_HIDE: "POPUP_HIDE",
+	},
+	TYPE_CONTROL : {
+		Object.NOTIFICATION_PREDELETE: "PREDELETE",
+		Container.NOTIFICATION_SORT_CHILDREN: "SORT_CHILDREN",
+		Control.NOTIFICATION_RESIZED: "RESIZED",
+		Control.NOTIFICATION_MOUSE_ENTER: "MOUSE_ENTER",
+		Control.NOTIFICATION_MOUSE_EXIT: "MOUSE_EXIT",
+		Control.NOTIFICATION_FOCUS_ENTER: "FOCUS_ENTER",
+		Control.NOTIFICATION_FOCUS_EXIT: "FOCUS_EXIT",
+		Control.NOTIFICATION_THEME_CHANGED: "THEME_CHANGED",
+		#Control.NOTIFICATION_MODAL_CLOSE: "MODAL_CLOSE",
+		Control.NOTIFICATION_SCROLL_BEGIN: "SCROLL_BEGIN",
+		Control.NOTIFICATION_SCROLL_END: "SCROLL_END",
+	}
+}
+
+
+enum COMPARE_MODE {
+	OBJECT_REFERENCE,
+	PARAMETER_DEEP_TEST
+}
+
+
+# prototype of better object to dictionary
+static func obj2dict(obj :Object, hashed_objects := Dictionary()) -> Dictionary:
+	if obj == null:
+		return {}
+	var clazz_name := obj.get_class()
+	var dict := Dictionary()
+	var clazz_path := ""
+
+	if is_instance_valid(obj) and obj.get_script() != null:
+		var d := inst_to_dict(obj)
+		clazz_path = d["@path"]
+		if d["@subpath"] != NodePath(""):
+			clazz_name = d["@subpath"]
+			dict["@inner_class"] = true
+		else:
+			clazz_name = clazz_path.get_file().replace(".gd", "")
+	dict["@path"] = clazz_path
+
+	for property in obj.get_property_list():
+		var property_name :String = property["name"]
+		var property_type :int = property["type"]
+		var property_value :Variant = obj.get(property_name)
+		if property_value is GDScript or property_value is Callable or property_value is RegEx:
+			continue
+		if (property["usage"] & PROPERTY_USAGE_SCRIPT_VARIABLE|PROPERTY_USAGE_DEFAULT
+			and not property["usage"] & PROPERTY_USAGE_CATEGORY
+			and not property["usage"] == 0):
+			if property_type == TYPE_OBJECT:
+				# prevent recursion
+				if hashed_objects.has(obj):
+					dict[property_name] = str(property_value)
+					continue
+				hashed_objects[obj] = true
+				dict[property_name] = obj2dict(property_value, hashed_objects)
+			else:
+				dict[property_name] = property_value
+	if obj.has_method("get_children"):
+		var childrens :Array = obj.get_children()
+		dict["childrens"] = childrens.map(func (child :Object) -> Dictionary: return obj2dict(child, hashed_objects))
+
+	return {"%s" % clazz_name : dict}
+
+
+static func equals(obj_a :Variant, obj_b :Variant, case_sensitive :bool = false, compare_mode :COMPARE_MODE = COMPARE_MODE.PARAMETER_DEEP_TEST) -> bool:
+	return _equals(obj_a, obj_b, case_sensitive, compare_mode, [], 0)
+
+
+static func equals_sorted(obj_a :Array, obj_b :Array, case_sensitive :bool = false, compare_mode :COMPARE_MODE = COMPARE_MODE.PARAMETER_DEEP_TEST) -> bool:
+	var a := obj_a.duplicate()
+	var b := obj_b.duplicate()
+	a.sort()
+	b.sort()
+	return equals(a, b, case_sensitive, compare_mode)
+
+
+static func _equals(obj_a :Variant, obj_b :Variant, case_sensitive :bool, compare_mode :COMPARE_MODE, deep_stack :Array, stack_depth :int ) -> bool:
+	var type_a := typeof(obj_a)
+	var type_b := typeof(obj_b)
+	if stack_depth > 32:
+		prints("stack_depth", stack_depth, deep_stack)
+		push_error("GdUnit equals has max stack deep reached!")
+		return false
+
+	# use argument matcher if requested
+	if is_instance_valid(obj_a) and obj_a is GdUnitArgumentMatcher:
+		return (obj_a as GdUnitArgumentMatcher).is_match(obj_b)
+	if is_instance_valid(obj_b) and obj_b is GdUnitArgumentMatcher:
+		return (obj_b as GdUnitArgumentMatcher).is_match(obj_a)
+
+	stack_depth += 1
+	# fast fail is different types
+	if not _is_type_equivalent(type_a, type_b):
+		return false
+	# is same instance
+	if obj_a == obj_b:
+		return true
+	# handle null values
+	if obj_a == null and obj_b != null:
+		return false
+	if obj_b == null and obj_a != null:
+		return false
+
+	match type_a:
+		TYPE_OBJECT:
+			if deep_stack.has(obj_a) or deep_stack.has(obj_b):
+				return true
+			deep_stack.append(obj_a)
+			deep_stack.append(obj_b)
+			if compare_mode == COMPARE_MODE.PARAMETER_DEEP_TEST:
+				# fail fast
+				if not is_instance_valid(obj_a) or not is_instance_valid(obj_b):
+					return false
+				if obj_a.get_class() != obj_b.get_class():
+					return false
+				var a := obj2dict(obj_a)
+				var b := obj2dict(obj_b)
+				return _equals(a, b, case_sensitive, compare_mode, deep_stack, stack_depth)
+			return obj_a == obj_b
+
+		TYPE_ARRAY:
+			if obj_a.size() != obj_b.size():
+				return false
+			for index :int in obj_a.size():
+				if not _equals(obj_a[index], obj_b[index], case_sensitive, compare_mode, deep_stack, stack_depth):
+					return false
+			return true
+
+		TYPE_DICTIONARY:
+			if obj_a.size() != obj_b.size():
+				return false
+			for key :Variant in obj_a.keys():
+				var value_a :Variant = obj_a[key] if obj_a.has(key) else null
+				var value_b :Variant = obj_b[key] if obj_b.has(key) else null
+				if not _equals(value_a, value_b, case_sensitive, compare_mode, deep_stack, stack_depth):
+					return false
+			return true
+
+		TYPE_STRING:
+			if case_sensitive:
+				return obj_a.to_lower() == obj_b.to_lower()
+			else:
+				return obj_a == obj_b
+	return obj_a == obj_b
+
+
+@warning_ignore("shadowed_variable_base_class")
+static func notification_as_string(instance :Variant, notification :int) -> String:
+	var error := "Unknown notification: '%s' at instance:  %s" % [notification, instance]
+	if instance is Node and NOTIFICATION_AS_STRING_MAPPINGS[TYPE_NODE].has(notification):
+		return NOTIFICATION_AS_STRING_MAPPINGS[TYPE_NODE].get(notification, error)
+	if instance is Control and NOTIFICATION_AS_STRING_MAPPINGS[TYPE_CONTROL].has(notification):
+		return NOTIFICATION_AS_STRING_MAPPINGS[TYPE_CONTROL].get(notification, error)
+	return NOTIFICATION_AS_STRING_MAPPINGS[TYPE_OBJECT].get(notification, error)
+
+
+static func string_to_type(value :String) -> int:
+	for type :int in TYPE_AS_STRING_MAPPINGS.keys():
+		if TYPE_AS_STRING_MAPPINGS.get(type) == value:
+			return type
+	return TYPE_NIL
+
+
+static func to_camel_case(value :String) -> String:
+	var p := to_pascal_case(value)
+	if not p.is_empty():
+		p[0] = p[0].to_lower()
+	return p
+
+
+static func to_pascal_case(value :String) -> String:
+	return value.capitalize().replace(" ", "")
+
+
+static func to_snake_case(value :String) -> String:
+	var result := PackedStringArray()
+	for ch in value:
+		var lower_ch := ch.to_lower()
+		if ch != lower_ch and result.size() > 1:
+			result.append('_')
+		result.append(lower_ch)
+	return ''.join(result)
+
+
+static func is_snake_case(value :String) -> bool:
+	for ch in value:
+		if ch == '_':
+			continue
+		if ch == ch.to_upper():
+			return false
+	return true
+
+
+static func type_as_string(type :int) -> String:
+	return TYPE_AS_STRING_MAPPINGS.get(type, "Variant")
+
+
+static func typeof_as_string(value :Variant) -> String:
+	return TYPE_AS_STRING_MAPPINGS.get(typeof(value), "Unknown type")
+
+
+static func all_types() -> PackedInt32Array:
+	return PackedInt32Array(TYPE_AS_STRING_MAPPINGS.keys())
+
+
+static func string_as_typeof(type_name :String) -> int:
+	var type :Variant = TYPE_AS_STRING_MAPPINGS.find_key(type_name)
+	return type if type != null else TYPE_VARIANT
+
+
+static func is_primitive_type(value :Variant) -> bool:
+	return typeof(value) in [TYPE_BOOL, TYPE_STRING, TYPE_STRING_NAME, TYPE_INT, TYPE_FLOAT]
+
+
+static func _is_type_equivalent(type_a :int, type_b :int) -> bool:
+	# don't test for TYPE_STRING_NAME equivalenz
+	if type_a == TYPE_STRING_NAME or type_b == TYPE_STRING_NAME:
+		return true
+	if GdUnitSettings.is_strict_number_type_compare():
+		return type_a == type_b
+	return (
+		(type_a == TYPE_FLOAT and type_b == TYPE_INT)
+		or (type_a == TYPE_INT and type_b == TYPE_FLOAT)
+		or type_a == type_b)
+
+
+static func is_engine_type(value :Object) -> bool:
+	if value is GDScript or value is ScriptExtension:
+		return false
+	return value.is_class("GDScriptNativeClass")
+
+
+static func is_type(value :Variant) -> bool:
+	# is an build-in type
+	if typeof(value) != TYPE_OBJECT:
+		return false
+	# is a engine class type
+	if is_engine_type(value):
+		return true
+	# is a custom class type
+	if value is GDScript and value.can_instantiate():
+		return true
+	return false
+
+
+static func _is_same(left :Variant, right :Variant) -> bool:
+	var left_type := -1 if left == null else typeof(left)
+	var right_type := -1 if right == null else typeof(right)
+
+	# if typ different can't be the same
+	if left_type != right_type:
+		return false
+	if left_type == TYPE_OBJECT and right_type == TYPE_OBJECT:
+		return left.get_instance_id() == right.get_instance_id()
+	return equals(left, right)
+
+
+static func is_object(value :Variant) -> bool:
+	return typeof(value) == TYPE_OBJECT
+
+
+static func is_script(value :Variant) -> bool:
+	return is_object(value) and value is Script
+
+
+static func is_test_suite(script :Script) -> bool:
+	return is_gd_testsuite(script) or GdUnit4CSharpApiLoader.is_test_suite(script.resource_path)
+
+
+static func is_native_class(value :Variant) -> bool:
+	return is_object(value) and is_engine_type(value)
+
+
+static func is_scene(value :Variant) -> bool:
+	return is_object(value) and value is PackedScene
+
+
+static func is_scene_resource_path(value :Variant) -> bool:
+	return value is String and value.ends_with(".tscn")
+
+
+static func is_gd_script(script :Script) -> bool:
+	return script is GDScript
+
+
+static func is_cs_script(script :Script) -> bool:
+	# we need to check by stringify name because checked non mono Godot the class CSharpScript is not available
+	return str(script).find("CSharpScript") != -1
+
+
+static func is_gd_testsuite(script :Script) -> bool:
+	if is_gd_script(script):
+		var stack := [script]
+		while not stack.is_empty():
+			var current := stack.pop_front() as Script
+			var base := current.get_base_script() as Script
+			if base != null:
+				if base.resource_path.find("GdUnitTestSuite") != -1:
+					return true
+				stack.push_back(base)
+	return false
+
+
+static func is_singleton(value :Variant) -> bool:
+	if not is_instance_valid(value) or is_native_class(value):
+		return false
+	for name in Engine.get_singleton_list():
+		if value.is_class(name):
+			return true
+	return false
+
+
+static func is_instance(value :Variant) -> bool:
+	if not is_instance_valid(value) or is_native_class(value):
+		return false
+	if is_script(value) and value.get_instance_base_type() == "":
+		return true
+	if is_scene(value):
+		return true
+	return not value.has_method('new') and not value.has_method('instance')
+
+
+# only object form type Node and attached filename
+static func is_instance_scene(instance :Variant) -> bool:
+	if instance is Node:
+		var node := instance as Node
+		return node.get_scene_file_path() != null and not node.get_scene_file_path().is_empty()
+	return false
+
+
+static func can_be_instantiate(obj :Variant) -> bool:
+	if not obj or is_engine_type(obj):
+		return false
+	return obj.has_method("new")
+
+
+static func create_instance(clazz :Variant) -> GdUnitResult:
+	match typeof(clazz):
+		TYPE_OBJECT:
+			# test is given clazz already an instance
+			if is_instance(clazz):
+				return GdUnitResult.success(clazz)
+			return GdUnitResult.success(clazz.new())
+		TYPE_STRING:
+			if ClassDB.class_exists(clazz):
+				if Engine.has_singleton(clazz):
+					return GdUnitResult.error("Not allowed to create a instance for singelton '%s'." % clazz)
+				if not ClassDB.can_instantiate(clazz):
+					return  GdUnitResult.error("Can't instance Engine class '%s'." % clazz)
+				return GdUnitResult.success(ClassDB.instantiate(clazz))
+			else:
+				var clazz_path :String = extract_class_path(clazz)[0]
+				if not FileAccess.file_exists(clazz_path):
+					return GdUnitResult.error("Class '%s' not found." % clazz)
+				var script := load(clazz_path)
+				if script != null:
+					return GdUnitResult.success(script.new())
+				else:
+					return GdUnitResult.error("Can't create instance for '%s'." % clazz)
+	return GdUnitResult.error("Can't create instance for class '%s'." % clazz)
+
+
+static func extract_class_path(clazz :Variant) -> PackedStringArray:
+	var clazz_path := PackedStringArray()
+	if clazz is String:
+		clazz_path.append(clazz)
+		return clazz_path
+	if is_instance(clazz):
+		# is instance a script instance?
+		var script := clazz.script as GDScript
+		if script != null:
+			return extract_class_path(script)
+		return clazz_path
+
+	if clazz is GDScript:
+		if not clazz.resource_path.is_empty():
+			clazz_path.append(clazz.resource_path)
+			return clazz_path
+		# if not found we go the expensive way and extract the path form the script by creating an instance
+		var arg_list := build_function_default_arguments(clazz, "_init")
+		var instance :Variant = clazz.callv("new", arg_list)
+		var clazz_info := inst_to_dict(instance)
+		GdUnitTools.free_instance(instance)
+		clazz_path.append(clazz_info["@path"])
+		if clazz_info.has("@subpath"):
+			var sub_path :String = clazz_info["@subpath"]
+			if not sub_path.is_empty():
+				var sub_paths := sub_path.split("/")
+				clazz_path += sub_paths
+		return clazz_path
+	return clazz_path
+
+
+static func extract_class_name_from_class_path(clazz_path :PackedStringArray) -> String:
+	var base_clazz := clazz_path[0]
+	# return original class name if engine class
+	if ClassDB.class_exists(base_clazz):
+		return base_clazz
+	var clazz_name := to_pascal_case(base_clazz.get_basename().get_file())
+	for path_index in range(1, clazz_path.size()):
+		clazz_name += "." + clazz_path[path_index]
+	return  clazz_name
+
+
+static func extract_class_name(clazz :Variant) -> GdUnitResult:
+	if clazz == null:
+		return GdUnitResult.error("Can't extract class name form a null value.")
+
+	if is_instance(clazz):
+		# is instance a script instance?
+		var script := clazz.script as GDScript
+		if script != null:
+			return extract_class_name(script)
+		return GdUnitResult.success(clazz.get_class())
+
+	# extract name form full qualified class path
+	if clazz is String:
+		if ClassDB.class_exists(clazz):
+			return GdUnitResult.success(clazz)
+		var source_sript :Script = load(clazz)
+		var clazz_name :String = load("res://addons/gdUnit4/src/core/parse/GdScriptParser.gd").new().get_class_name(source_sript)
+		return GdUnitResult.success(to_pascal_case(clazz_name))
+
+	if is_primitive_type(clazz):
+		return GdUnitResult.error("Can't extract class name for an primitive '%s'" % type_as_string(typeof(clazz)))
+
+	if is_script(clazz):
+		if clazz.resource_path.is_empty():
+			var class_path := extract_class_name_from_class_path(extract_class_path(clazz))
+			return GdUnitResult.success(class_path);
+		return extract_class_name(clazz.resource_path)
+
+	# need to create an instance for a class typ the extract the class name
+	var instance :Variant = clazz.new()
+	if instance == null:
+		return GdUnitResult.error("Can't create a instance for class '%s'" % clazz)
+	var result := extract_class_name(instance)
+	GdUnitTools.free_instance(instance)
+	return result
+
+
+static func extract_inner_clazz_names(clazz_name :String, script_path :PackedStringArray) -> PackedStringArray:
+	var inner_classes := PackedStringArray()
+
+	if ClassDB.class_exists(clazz_name):
+		return inner_classes
+	var script :GDScript = load(script_path[0])
+	var map := script.get_script_constant_map()
+	for key :String in map.keys():
+		var value :Variant = map.get(key)
+		if value is GDScript:
+			var class_path := extract_class_path(value)
+			inner_classes.append(class_path[1])
+	return inner_classes
+
+
+static func extract_class_functions(clazz_name :String, script_path :PackedStringArray) -> Array:
+	if ClassDB.class_get_method_list(clazz_name):
+		return ClassDB.class_get_method_list(clazz_name)
+
+	if not FileAccess.file_exists(script_path[0]):
+		return Array()
+	var script :GDScript = load(script_path[0])
+	if script is GDScript:
+		# if inner class on class path we have to load the script from the script_constant_map
+		if script_path.size() == 2 and script_path[1] != "":
+			var inner_classes := script_path[1]
+			var map := script.get_script_constant_map()
+			script = map[inner_classes]
+		var clazz_functions :Array = script.get_method_list()
+		var base_clazz :String = script.get_instance_base_type()
+		if base_clazz:
+			return extract_class_functions(base_clazz, script_path)
+		return clazz_functions
+	return Array()
+
+
+# scans all registert script classes for given <clazz_name>
+# if the class is public in the global space than return true otherwise false
+# public class means the script class is defined by 'class_name <name>'
+static func is_public_script_class(clazz_name :String) -> bool:
+	var script_classes:Array[Dictionary] = ProjectSettings.get_global_class_list()
+	for class_info in script_classes:
+		if class_info.has("class"):
+			if class_info["class"] == clazz_name:
+				return true
+	return false
+
+
+static func build_function_default_arguments(script :GDScript, func_name :String) -> Array:
+	var arg_list := Array()
+	for func_sig in script.get_script_method_list():
+		if func_sig["name"] == func_name:
+			var args :Array[Dictionary] = func_sig["args"]
+			for arg in args:
+				var value_type :int = arg["type"]
+				var default_value :Variant = default_value_by_type(value_type)
+				arg_list.append(default_value)
+			return arg_list
+	return arg_list
+
+
+static func default_value_by_type(type :int) -> Variant:
+	assert(type < TYPE_MAX)
+	assert(type >= 0)
+
+	match type:
+		TYPE_NIL: return null
+		TYPE_BOOL: return false
+		TYPE_INT: return 0
+		TYPE_FLOAT: return 0.0
+		TYPE_STRING: return ""
+		TYPE_VECTOR2: return Vector2.ZERO
+		TYPE_VECTOR2I: return Vector2i.ZERO
+		TYPE_VECTOR3: return Vector3.ZERO
+		TYPE_VECTOR3I: return Vector3i.ZERO
+		TYPE_VECTOR4: return Vector4.ZERO
+		TYPE_VECTOR4I: return Vector4i.ZERO
+		TYPE_RECT2: return Rect2()
+		TYPE_RECT2I: return Rect2i()
+		TYPE_TRANSFORM2D: return Transform2D()
+		TYPE_PLANE: return Plane()
+		TYPE_QUATERNION: return Quaternion()
+		TYPE_AABB: return AABB()
+		TYPE_BASIS: return Basis()
+		TYPE_TRANSFORM3D: return Transform3D()
+		TYPE_COLOR: return Color()
+		TYPE_NODE_PATH: return NodePath()
+		TYPE_RID: return RID()
+		TYPE_OBJECT: return null
+		TYPE_ARRAY: return []
+		TYPE_DICTIONARY: return {}
+		TYPE_PACKED_BYTE_ARRAY: return PackedByteArray()
+		TYPE_PACKED_COLOR_ARRAY: return PackedColorArray()
+		TYPE_PACKED_INT32_ARRAY: return PackedInt32Array()
+		TYPE_PACKED_INT64_ARRAY: return PackedInt64Array()
+		TYPE_PACKED_FLOAT32_ARRAY: return PackedFloat32Array()
+		TYPE_PACKED_FLOAT64_ARRAY: return PackedFloat64Array()
+		TYPE_PACKED_STRING_ARRAY: return PackedStringArray()
+		TYPE_PACKED_VECTOR2_ARRAY: return PackedVector2Array()
+		TYPE_PACKED_VECTOR3_ARRAY: return PackedVector3Array()
+
+	push_error("Can't determine a default value for type: '%s', Please create a Bug issue and attach the stacktrace please." % type)
+	return null
+
+
+static func find_nodes_by_class(root: Node, cls: String, recursive: bool = false) -> Array[Node]:
+	if not recursive:
+		return _find_nodes_by_class_no_rec(root, cls)
+	return _find_nodes_by_class(root, cls)
+
+
+static func _find_nodes_by_class_no_rec(parent: Node, cls: String) -> Array[Node]:
+	var result :Array[Node] = []
+	for ch in parent.get_children():
+		if ch.get_class() == cls:
+			result.append(ch)
+	return result
+
+
+static func _find_nodes_by_class(root: Node, cls: String) -> Array[Node]:
+	var result :Array[Node] = []
+	var stack  :Array[Node] = [root]
+	while stack:
+		var node :Node = stack.pop_back()
+		if node.get_class() == cls:
+			result.append(node)
+		for ch in node.get_children():
+			stack.push_back(ch)
+	return result

addons/gdUnit4/src/core/GdUnit4Version.gd

@@ -0,0 +1,57 @@
+class_name GdUnit4Version
+extends RefCounted
+
+const VERSION_PATTERN = "[center][color=#9887c4]gd[/color][color=#7a57d6]Unit[/color][color=#9887c4]4[/color] [color=#9887c4]${version}[/color][/center]"
+
+var _major :int
+var _minor :int
+var _patch :int
+
+
+func _init(major :int, minor :int, patch :int) -> void:
+	_major = major
+	_minor = minor
+	_patch = patch
+
+
+static func parse(value :String) -> GdUnit4Version:
+	var regex := RegEx.new()
+	regex.compile("[a-zA-Z:,-]+")
+	var cleaned := regex.sub(value, "", true)
+	var parts := cleaned.split(".")
+	var major := parts[0].to_int()
+	var minor := parts[1].to_int()
+	var patch := parts[2].to_int() if parts.size() > 2 else 0
+	return GdUnit4Version.new(major, minor, patch)
+
+
+static func current() -> GdUnit4Version:
+	var config := ConfigFile.new()
+	config.load('addons/gdUnit4/plugin.cfg')
+	return parse(config.get_value('plugin', 'version'))
+
+
+func equals(other :GdUnit4Version) -> bool:
+	return _major == other._major and _minor == other._minor and _patch == other._patch
+
+
+func is_greater(other :GdUnit4Version) -> bool:
+	if _major > other._major:
+		return true
+	if _major == other._major and _minor > other._minor:
+		return true
+	return _major == other._major and _minor == other._minor and _patch > other._patch
+
+
+static func init_version_label(label :Control) -> void:
+	var config := ConfigFile.new()
+	config.load('addons/gdUnit4/plugin.cfg')
+	var version :String = config.get_value('plugin', 'version')
+	if label is RichTextLabel:
+		label.text = VERSION_PATTERN.replace('${version}', version)
+	else:
+		label.text = "gdUnit4 " + version
+
+
+func _to_string() -> String:
+	return "v%d.%d.%d" % [_major, _minor, _patch]

addons/gdUnit4/src/core/GdUnitClassDoubler.gd

@@ -0,0 +1,122 @@
+# A class doubler used to mock and spy checked implementations
+class_name GdUnitClassDoubler
+extends RefCounted
+
+
+const DOUBLER_INSTANCE_ID_PREFIX := "gdunit_doubler_instance_id_"
+const DOUBLER_TEMPLATE :GDScript = preload("res://addons/gdUnit4/src/core/GdUnitObjectInteractionsTemplate.gd")
+const EXCLUDE_VIRTUAL_FUNCTIONS = [
+	# we have to exclude notifications because NOTIFICATION_PREDELETE is try
+	# to delete already freed spy/mock resources and will result in a conflict
+	"_notification",
+	# https://github.com/godotengine/godot/issues/67461
+	"get_name",
+	"get_path",
+	"duplicate",
+	]
+# define functions to be exclude when spy or mock checked a scene
+const EXLCUDE_SCENE_FUNCTIONS = [
+	# needs to exclude get/set script functions otherwise it endsup in recursive endless loop
+	"set_script",
+	"get_script",
+	# needs to exclude otherwise verify fails checked collection arguments checked calling to string
+	"_to_string",
+]
+const EXCLUDE_FUNCTIONS = ["new", "free", "get_instance_id", "get_tree"]
+
+
+static func check_leaked_instances() -> void:
+	## we check that all registered spy/mock instances are removed from the engine meta data
+	for key in Engine.get_meta_list():
+		if key.begins_with(DOUBLER_INSTANCE_ID_PREFIX):
+			var instance :Variant = Engine.get_meta(key)
+			push_error("GdUnit internal error: an spy/mock instance '%s', class:'%s' is not removed from the engine and will lead in a leaked instance!" % [instance, instance.__SOURCE_CLASS])
+
+
+# loads the doubler template
+# class_info = { "class_name": <>, "class_path" : <>}
+static func load_template(template :String, class_info :Dictionary, instance :Object) -> PackedStringArray:
+	# store instance id
+	var source_code := template\
+		.replace("${instance_id}", "%s%d" % [DOUBLER_INSTANCE_ID_PREFIX, abs(instance.get_instance_id())])\
+		.replace("${source_class}", class_info.get("class_name"))
+	var lines := GdScriptParser.to_unix_format(source_code).split("\n")
+	# replace template class_name with Doubled<class> name and extends form source class
+	lines.insert(0, "class_name Doubled%s" % class_info.get("class_name").replace(".", "_"))
+	lines.insert(1, extends_clazz(class_info))
+	# append Object interactions stuff
+	lines.append_array(GdScriptParser.to_unix_format(DOUBLER_TEMPLATE.source_code).split("\n"))
+	return lines
+
+
+static func extends_clazz(class_info :Dictionary) -> String:
+	var clazz_name :String = class_info.get("class_name")
+	var clazz_path :PackedStringArray = class_info.get("class_path", [])
+	# is inner class?
+	if clazz_path.size() > 1:
+		return "extends %s" % clazz_name
+	if clazz_path.size() == 1 and clazz_path[0].ends_with(".gd"):
+		return "extends '%s'" % clazz_path[0]
+	return "extends %s" % clazz_name
+
+
+# double all functions of given instance
+static func double_functions(instance :Object, clazz_name :String, clazz_path :PackedStringArray, func_doubler: GdFunctionDoubler, exclude_functions :Array) -> PackedStringArray:
+	var doubled_source := PackedStringArray()
+	var parser := GdScriptParser.new()
+	var exclude_override_functions := EXCLUDE_VIRTUAL_FUNCTIONS + EXCLUDE_FUNCTIONS + exclude_functions
+	var functions := Array()
+
+	# double script functions
+	if not ClassDB.class_exists(clazz_name):
+		var result := parser.parse(clazz_name, clazz_path)
+		if result.is_error():
+			push_error(result.error_message())
+			return PackedStringArray()
+		var class_descriptor :GdClassDescriptor = result.value()
+		while class_descriptor != null:
+			for func_descriptor in class_descriptor.functions():
+				if instance != null and not instance.has_method(func_descriptor.name()):
+					#prints("no virtual func implemented",clazz_name, func_descriptor.name() )
+					continue
+				if functions.has(func_descriptor.name()) or exclude_override_functions.has(func_descriptor.name()):
+					continue
+				doubled_source += func_doubler.double(func_descriptor)
+				functions.append(func_descriptor.name())
+			class_descriptor = class_descriptor.parent()
+
+	# double regular class functions
+	var clazz_functions := GdObjects.extract_class_functions(clazz_name, clazz_path)
+	for method : Dictionary in clazz_functions:
+		var func_descriptor := GdFunctionDescriptor.extract_from(method)
+		# exclude private core functions
+		if func_descriptor.is_private():
+			continue
+		if functions.has(func_descriptor.name()) or exclude_override_functions.has(func_descriptor.name()):
+			continue
+		# GD-110: Hotfix do not double invalid engine functions
+		if is_invalid_method_descriptior(method):
+			#prints("'%s': invalid method descriptor found! %s" % [clazz_name, method])
+			continue
+		# do not double on not implemented virtual functions
+		if instance != null and not instance.has_method(func_descriptor.name()):
+			#prints("no virtual func implemented",clazz_name, func_descriptor.name() )
+			continue
+		functions.append(func_descriptor.name())
+		doubled_source.append_array(func_doubler.double(func_descriptor))
+	return doubled_source
+
+
+# GD-110
+static func is_invalid_method_descriptior(method :Dictionary) -> bool:
+	var return_info :Dictionary = method["return"]
+	var type :int = return_info["type"]
+	var usage :int = return_info["usage"]
+	var clazz_name :String = return_info["class_name"]
+	# is method returning a type int with a given 'class_name' we have an enum
+	# and the PROPERTY_USAGE_CLASS_IS_ENUM must be set
+	if type == TYPE_INT and not clazz_name.is_empty() and not (usage & PROPERTY_USAGE_CLASS_IS_ENUM):
+		return true
+	if clazz_name == "Variant.Type":
+		return true
+	return false

addons/gdUnit4/src/core/GdUnitFileAccess.gd

@@ -0,0 +1,211 @@
+class_name GdUnitFileAccess
+extends RefCounted
+
+const GDUNIT_TEMP := "user://tmp"
+
+
+static func current_dir() -> String:
+	return ProjectSettings.globalize_path("res://")
+
+
+static func clear_tmp() -> void:
+	delete_directory(GDUNIT_TEMP)
+
+
+# Creates a new file under
+static func create_temp_file(relative_path :String, file_name :String, mode := FileAccess.WRITE) -> FileAccess:
+	var file_path := create_temp_dir(relative_path) + "/" + file_name
+	var file := FileAccess.open(file_path, mode)
+	if file == null:
+		push_error("Error creating temporary file at: %s, %s" % [file_path, error_string(FileAccess.get_open_error())])
+	return file
+
+
+static func temp_dir() -> String:
+	if not DirAccess.dir_exists_absolute(GDUNIT_TEMP):
+		DirAccess.make_dir_recursive_absolute(GDUNIT_TEMP)
+	return GDUNIT_TEMP
+
+
+static func create_temp_dir(folder_name :String) -> String:
+	var new_folder := temp_dir() + "/" + folder_name
+	if not DirAccess.dir_exists_absolute(new_folder):
+		DirAccess.make_dir_recursive_absolute(new_folder)
+	return new_folder
+
+
+static func copy_file(from_file :String, to_dir :String) -> GdUnitResult:
+	var dir := DirAccess.open(to_dir)
+	if dir != null:
+		var to_file := to_dir + "/" + from_file.get_file()
+		prints("Copy %s to %s" % [from_file, to_file])
+		var error := dir.copy(from_file, to_file)
+		if error != OK:
+			return GdUnitResult.error("Can't copy file form '%s' to '%s'. Error: '%s'" % [from_file, to_file, error_string(error)])
+		return GdUnitResult.success(to_file)
+	return GdUnitResult.error("Directory not found: " + to_dir)
+
+
+static func copy_directory(from_dir :String, to_dir :String, recursive :bool = false) -> bool:
+	if not DirAccess.dir_exists_absolute(from_dir):
+		push_error("Source directory not found '%s'" % from_dir)
+		return false
+
+	# check if destination exists
+	if not DirAccess.dir_exists_absolute(to_dir):
+		# create it
+		var err := DirAccess.make_dir_recursive_absolute(to_dir)
+		if err != OK:
+			push_error("Can't create directory '%s'. Error: %s" % [to_dir, error_string(err)])
+			return false
+	var source_dir := DirAccess.open(from_dir)
+	var dest_dir := DirAccess.open(to_dir)
+	if source_dir != null:
+		source_dir.list_dir_begin()
+		var next := "."
+
+		while next != "":
+			next = source_dir.get_next()
+			if next == "" or next == "." or next == "..":
+				continue
+			var source := source_dir.get_current_dir() + "/" + next
+			var dest := dest_dir.get_current_dir() + "/" + next
+			if source_dir.current_is_dir():
+				if recursive:
+					copy_directory(source + "/", dest, recursive)
+				continue
+			var err := source_dir.copy(source, dest)
+			if err != OK:
+				push_error("Error checked copy file '%s' to '%s'" % [source, dest])
+				return false
+
+		return true
+	else:
+		push_error("Directory not found: " + from_dir)
+		return false
+
+
+static func delete_directory(path :String, only_content := false) -> void:
+	var dir := DirAccess.open(path)
+	if dir != null:
+		dir.list_dir_begin()
+		var file_name := "."
+		while file_name != "":
+			file_name = dir.get_next()
+			if file_name.is_empty() or file_name == "." or file_name == "..":
+				continue
+			var next := path + "/" +file_name
+			if dir.current_is_dir():
+				delete_directory(next)
+			else:
+				# delete file
+				var err := dir.remove(next)
+				if err:
+					push_error("Delete %s failed: %s" % [next, error_string(err)])
+		if not only_content:
+			var err := dir.remove(path)
+			if err:
+				push_error("Delete %s failed: %s" % [path, error_string(err)])
+
+
+static func delete_path_index_lower_equals_than(path :String, prefix :String, index :int) -> int:
+	var dir := DirAccess.open(path)
+	if dir == null:
+		return 0
+	var deleted := 0
+	dir.list_dir_begin()
+	var next := "."
+	while next != "":
+		next = dir.get_next()
+		if next.is_empty() or next == "." or next == "..":
+			continue
+		if next.begins_with(prefix):
+			var current_index := next.split("_")[1].to_int()
+			if current_index <= index:
+				deleted += 1
+				delete_directory(path + "/" + next)
+	return deleted
+
+
+# scans given path for sub directories by given prefix and returns the highest index numer
+# e.g. <prefix_%d>
+static func find_last_path_index(path :String, prefix :String) -> int:
+	var dir := DirAccess.open(path)
+	if dir == null:
+		return 0
+	var last_iteration := 0
+	dir.list_dir_begin()
+	var next := "."
+	while next != "":
+		next = dir.get_next()
+		if next.is_empty() or next == "." or next == "..":
+			continue
+		if next.begins_with(prefix):
+			var iteration := next.split("_")[1].to_int()
+			if iteration > last_iteration:
+				last_iteration = iteration
+	return last_iteration
+
+
+static func scan_dir(path :String) -> PackedStringArray:
+	var dir := DirAccess.open(path)
+	if dir == null or not dir.dir_exists(path):
+		return PackedStringArray()
+	var content := PackedStringArray()
+	dir.list_dir_begin()
+	var next := "."
+	while next != "":
+		next = dir.get_next()
+		if next.is_empty() or next == "." or next == "..":
+			continue
+		content.append(next)
+	return content
+
+
+static func resource_as_array(resource_path :String) -> PackedStringArray:
+	var file := FileAccess.open(resource_path, FileAccess.READ)
+	if file == null:
+		push_error("ERROR: Can't read resource '%s'. %s" % [resource_path, error_string(FileAccess.get_open_error())])
+		return PackedStringArray()
+	var file_content := PackedStringArray()
+	while not file.eof_reached():
+		file_content.append(file.get_line())
+	return file_content
+
+
+static func resource_as_string(resource_path :String) -> String:
+	var file := FileAccess.open(resource_path, FileAccess.READ)
+	if file == null:
+		push_error("ERROR: Can't read resource '%s'. %s" % [resource_path, error_string(FileAccess.get_open_error())])
+		return ""
+	return file.get_as_text(true)
+
+
+static func make_qualified_path(path :String) -> String:
+	if not path.begins_with("res://"):
+		if path.begins_with("//"):
+			return path.replace("//", "res://")
+		if path.begins_with("/"):
+			return "res:/" + path
+	return path
+
+
+static func extract_zip(zip_package :String, dest_path :String) -> GdUnitResult:
+	var zip: ZIPReader = ZIPReader.new()
+	var err := zip.open(zip_package)
+	if err != OK:
+		return GdUnitResult.error("Extracting `%s` failed! Please collect the error log and report this. Error Code: %s" % [zip_package, err])
+	var zip_entries: PackedStringArray = zip.get_files()
+	# Get base path and step over archive folder
+	var archive_path := zip_entries[0]
+	zip_entries.remove_at(0)
+
+	for zip_entry in zip_entries:
+		var new_file_path: String = dest_path + "/" + zip_entry.replace(archive_path, "")
+		if zip_entry.ends_with("/"):
+			DirAccess.make_dir_recursive_absolute(new_file_path)
+			continue
+		var file: FileAccess = FileAccess.open(new_file_path, FileAccess.WRITE)
+		file.store_buffer(zip.read_file(zip_entry))
+	zip.close()
+	return GdUnitResult.success(dest_path)

addons/gdUnit4/src/core/GdUnitObjectInteractions.gd

@@ -0,0 +1,42 @@
+class_name GdUnitObjectInteractions
+extends RefCounted
+
+
+static func verify(interaction_object :Object, interactions_times :int) -> Variant:
+	if not _is_mock_or_spy(interaction_object, "__verify"):
+		return interaction_object
+	return interaction_object.__do_verify_interactions(interactions_times)
+
+
+static func verify_no_interactions(interaction_object :Object) -> GdUnitAssert:
+	var __gd_assert :GdUnitAssert = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript", ResourceLoader.CACHE_MODE_REUSE).new("")
+	if not _is_mock_or_spy(interaction_object, "__verify"):
+		return __gd_assert.report_success()
+	var __summary :Dictionary = interaction_object.__verify_no_interactions()
+	if __summary.is_empty():
+		return __gd_assert.report_success()
+	return __gd_assert.report_error(GdAssertMessages.error_no_more_interactions(__summary))
+
+
+static func verify_no_more_interactions(interaction_object :Object) -> GdUnitAssert:
+	var __gd_assert :GdUnitAssert = ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd", "GDScript", ResourceLoader.CACHE_MODE_REUSE).new("")
+	if not _is_mock_or_spy(interaction_object, "__verify_no_more_interactions"):
+		return __gd_assert
+	var __summary :Dictionary = interaction_object.__verify_no_more_interactions()
+	if __summary.is_empty():
+		return __gd_assert
+	return __gd_assert.report_error(GdAssertMessages.error_no_more_interactions(__summary))
+
+
+static func reset(interaction_object :Object) -> Object:
+	if not _is_mock_or_spy(interaction_object, "__reset"):
+		return interaction_object
+	interaction_object.__reset_interactions()
+	return interaction_object
+
+
+static func _is_mock_or_spy(interaction_object :Object, mock_function_signature :String) -> bool:
+	if interaction_object is GDScript and not interaction_object.get_script().has_script_method(mock_function_signature):
+		push_error("Error: You try to use a non mock or spy!")
+		return false
+	return true

addons/gdUnit4/src/core/GdUnitObjectInteractionsTemplate.gd

@@ -0,0 +1,91 @@
+const GdUnitAssertImpl := preload("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd")
+
+var __expected_interactions :int = -1
+var __saved_interactions := Dictionary()
+var __verified_interactions := Array()
+
+
+func __save_function_interaction(function_args :Array[Variant]) -> void:
+	var __matcher := GdUnitArgumentMatchers.to_matcher(function_args, true)
+	for __index in __saved_interactions.keys().size():
+		var __key :Variant = __saved_interactions.keys()[__index]
+		if __matcher.is_match(__key):
+			__saved_interactions[__key] += 1
+			return
+	__saved_interactions[function_args] = 1
+
+
+func __is_verify_interactions() -> bool:
+	return __expected_interactions != -1
+
+
+func __do_verify_interactions(interactions_times :int = 1) -> Object:
+	__expected_interactions = interactions_times
+	return self
+
+
+func __verify_interactions(function_args :Array[Variant]) -> void:
+	var __summary := Dictionary()
+	var __total_interactions := 0
+	var __matcher := GdUnitArgumentMatchers.to_matcher(function_args, true)
+	for __index in __saved_interactions.keys().size():
+		var __key :Variant = __saved_interactions.keys()[__index]
+		if __matcher.is_match(__key):
+			var __interactions :int = __saved_interactions.get(__key, 0)
+			__total_interactions += __interactions
+			__summary[__key] = __interactions
+			# add as verified
+			__verified_interactions.append(__key)
+
+	var __gd_assert := GdUnitAssertImpl.new("")
+	if __total_interactions != __expected_interactions:
+		var __expected_summary := {function_args : __expected_interactions}
+		var __error_message :String
+		# if no __interactions macht collect not verified __interactions for failure report
+		if __summary.is_empty():
+			var __current_summary := __verify_no_more_interactions()
+			__error_message = GdAssertMessages.error_validate_interactions(__current_summary, __expected_summary)
+		else:
+			__error_message = GdAssertMessages.error_validate_interactions(__summary, __expected_summary)
+		__gd_assert.report_error(__error_message)
+	else:
+		__gd_assert.report_success()
+	__expected_interactions = -1
+
+
+func __verify_no_interactions() -> Dictionary:
+	var __summary := Dictionary()
+	if not __saved_interactions.is_empty():
+		for __index in __saved_interactions.keys().size():
+			var func_call :Variant = __saved_interactions.keys()[__index]
+			__summary[func_call] = __saved_interactions[func_call]
+	return __summary
+
+
+func __verify_no_more_interactions() -> Dictionary:
+	var __summary := Dictionary()
+	var called_functions :Array[Variant] = __saved_interactions.keys()
+	if called_functions != __verified_interactions:
+		# collect the not verified functions
+		var called_but_not_verified := called_functions.duplicate()
+		for __index in __verified_interactions.size():
+			called_but_not_verified.erase(__verified_interactions[__index])
+
+		for __index in called_but_not_verified.size():
+			var not_verified :Variant = called_but_not_verified[__index]
+			__summary[not_verified] = __saved_interactions[not_verified]
+	return __summary
+
+
+func __reset_interactions() -> void:
+	__saved_interactions.clear()
+
+
+func __filter_vargs(arg_values :Array[Variant]) -> Array[Variant]:
+	var filtered :Array[Variant] = []
+	for __index in arg_values.size():
+		var arg :Variant = arg_values[__index]
+		if typeof(arg) == TYPE_STRING and arg == GdObjects.TYPE_VARARG_PLACEHOLDER_VALUE:
+			continue
+		filtered.append(arg)
+	return filtered

addons/gdUnit4/src/core/GdUnitProperty.gd

@@ -0,0 +1,72 @@
+class_name GdUnitProperty
+extends RefCounted
+
+
+var _name :String
+var _help :String
+var _type :int
+var _value :Variant
+var _value_set :PackedStringArray
+var _default :Variant
+
+
+func _init(p_name :String, p_type :int, p_value :Variant, p_default_value :Variant, p_help :="", p_value_set := PackedStringArray()) -> void:
+	_name = p_name
+	_type = p_type
+	_value = p_value
+	_value_set = p_value_set
+	_default = p_default_value
+	_help = p_help
+
+
+func name() -> String:
+	return _name
+
+
+func type() -> int:
+	return _type
+
+
+func value() -> Variant:
+	return _value
+
+
+func value_set() -> PackedStringArray:
+	return _value_set
+
+
+func is_selectable_value() -> bool:
+	return not _value_set.is_empty()
+
+
+func set_value(p_value :Variant) -> void:
+	match _type:
+		TYPE_STRING:
+			_value = str(p_value)
+		TYPE_BOOL:
+			_value = bool(p_value)
+		TYPE_INT:
+			_value = int(p_value)
+		TYPE_FLOAT:
+			_value = float(p_value)
+		_:
+			_value = p_value
+
+
+func default() -> Variant:
+	return _default
+
+
+func category() -> String:
+	var elements := _name.split("/")
+	if elements.size() > 3:
+		return elements[2]
+	return ""
+
+
+func help() -> String:
+	return _help
+
+
+func _to_string() -> String:
+	return "%-64s %-10s %-10s (%s) help:%s set:%s" % [name(), type(), value(), default(), help(), _value_set]

addons/gdUnit4/src/core/GdUnitResult.gd

@@ -0,0 +1,104 @@
+class_name GdUnitResult
+extends RefCounted
+
+enum {
+	SUCCESS,
+	WARN,
+	ERROR,
+	EMPTY
+}
+
+var _state :Variant
+var _warn_message := ""
+var _error_message := ""
+var _value :Variant = null
+
+
+static func empty() -> GdUnitResult:
+	var result := GdUnitResult.new()
+	result._state = EMPTY
+	return result
+
+
+static func success(p_value :Variant) -> GdUnitResult:
+	assert(p_value != null, "The value must not be NULL")
+	var result := GdUnitResult.new()
+	result._value = p_value
+	result._state = SUCCESS
+	return result
+
+
+static func warn(p_warn_message :String, p_value :Variant = null) -> GdUnitResult:
+	assert(not p_warn_message.is_empty()) #,"The message must not be empty")
+	var result := GdUnitResult.new()
+	result._value = p_value
+	result._warn_message = p_warn_message
+	result._state = WARN
+	return result
+
+
+static func error(p_error_message :String) -> GdUnitResult:
+	assert(not p_error_message.is_empty(), "The message must not be empty")
+	var result := GdUnitResult.new()
+	result._value = null
+	result._error_message = p_error_message
+	result._state = ERROR
+	return result
+
+
+func is_success() -> bool:
+	return _state == SUCCESS
+
+
+func is_warn() -> bool:
+	return _state == WARN
+
+
+func is_error() -> bool:
+	return _state == ERROR
+
+
+func is_empty() -> bool:
+	return _state == EMPTY
+
+
+func value() -> Variant:
+	return _value
+
+
+func or_else(p_value :Variant) -> Variant:
+	if not is_success():
+		return p_value
+	return value()
+
+
+func error_message() -> String:
+	return _error_message
+
+
+func warn_message() -> String:
+	return _warn_message
+
+
+func _to_string() -> String:
+	return str(GdUnitResult.serialize(self))
+
+
+static func serialize(result :GdUnitResult) -> Dictionary:
+	if result == null:
+		push_error("Can't serialize a Null object from type GdUnitResult")
+	return {
+		"state" : result._state,
+		"value" : var_to_str(result._value),
+		"warn_msg" : result._warn_message,
+		"err_msg" : result._error_message
+	}
+
+
+static func deserialize(config :Dictionary) -> GdUnitResult:
+	var result := GdUnitResult.new()
+	result._value = str_to_var(config.get("value", ""))
+	result._warn_message = config.get("warn_msg", null)
+	result._error_message = config.get("err_msg", null)
+	result._state = config.get("state")
+	return result

addons/gdUnit4/src/core/GdUnitRunner.gd

@@ -0,0 +1,169 @@
+extends Node
+
+signal sync_rpc_id_result_received
+
+
+@onready var _client :GdUnitTcpClient = $GdUnitTcpClient
+@onready var _executor :GdUnitTestSuiteExecutor = GdUnitTestSuiteExecutor.new()
+
+enum {
+	INIT,
+	RUN,
+	STOP,
+	EXIT
+}
+
+const GDUNIT_RUNNER = "GdUnitRunner"
+
+var _config := GdUnitRunnerConfig.new()
+var _test_suites_to_process :Array[Node]
+var _state :int = INIT
+var _cs_executor :RefCounted
+
+
+func _init() -> void:
+	# minimize scene window checked debug mode
+	if OS.get_cmdline_args().size() == 1:
+		DisplayServer.window_set_title("GdUnit4 Runner (Debug Mode)")
+	else:
+		DisplayServer.window_set_title("GdUnit4 Runner (Release Mode)")
+	DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_MINIMIZED)
+	# store current runner instance to engine meta data to can be access in as a singleton
+	Engine.set_meta(GDUNIT_RUNNER, self)
+	_cs_executor = GdUnit4CSharpApiLoader.create_executor(self)
+
+
+func _ready() -> void:
+	var config_result := _config.load_config()
+	if config_result.is_error():
+		push_error(config_result.error_message())
+		_state = EXIT
+		return
+	_client.connect("connection_failed", _on_connection_failed)
+	GdUnitSignals.instance().gdunit_event.connect(_on_gdunit_event)
+	var result := _client.start("127.0.0.1", _config.server_port())
+	if result.is_error():
+		push_error(result.error_message())
+		return
+	_state = INIT
+
+
+func _on_connection_failed(message :String) -> void:
+	prints("_on_connection_failed", message, _test_suites_to_process)
+	_state = STOP
+
+
+func _notification(what :int) -> void:
+	#prints("GdUnitRunner", self, GdObjects.notification_as_string(what))
+	if what == NOTIFICATION_PREDELETE:
+		Engine.remove_meta(GDUNIT_RUNNER)
+
+
+func _process(_delta :float) -> void:
+	match _state:
+		INIT:
+			# wait until client is connected to the GdUnitServer
+			if _client.is_client_connected():
+				var time := LocalTime.now()
+				prints("Scan for test suites.")
+				_test_suites_to_process = load_test_suits()
+				prints("Scanning of %d test suites took" % _test_suites_to_process.size(), time.elapsed_since())
+				gdUnitInit()
+				_state = RUN
+		RUN:
+			# all test suites executed
+			if _test_suites_to_process.is_empty():
+				_state = STOP
+			else:
+				# process next test suite
+				set_process(false)
+				var test_suite :Node = _test_suites_to_process.pop_front()
+				if _cs_executor != null and _cs_executor.IsExecutable(test_suite):
+					_cs_executor.Execute(test_suite)
+					await _cs_executor.ExecutionCompleted
+				else:
+					await _executor.execute(test_suite)
+				set_process(true)
+		STOP:
+			_state = EXIT
+			# give the engine small amount time to finish the rpc
+			_on_gdunit_event(GdUnitStop.new())
+			await get_tree().create_timer(0.1).timeout
+			await get_tree().process_frame
+			get_tree().quit(0)
+
+
+func load_test_suits() -> Array[Node]:
+	var to_execute := _config.to_execute()
+	if to_execute.is_empty():
+		prints("No tests selected to execute!")
+		_state = EXIT
+		return []
+	# scan for the requested test suites
+	var test_suites :Array[Node] = []
+	var _scanner := GdUnitTestSuiteScanner.new()
+	for resource_path :String in to_execute.keys():
+		var selected_tests :PackedStringArray = to_execute.get(resource_path)
+		var scaned_suites := _scanner.scan(resource_path)
+		_filter_test_case(scaned_suites, selected_tests)
+		test_suites += scaned_suites
+	return test_suites
+
+
+func gdUnitInit() -> void:
+	#enable_manuall_polling()
+	send_message("Scaned %d test suites" % _test_suites_to_process.size())
+	var total_count := _collect_test_case_count(_test_suites_to_process)
+	_on_gdunit_event(GdUnitInit.new(_test_suites_to_process.size(), total_count))
+	if not GdUnitSettings.is_test_discover_enabled():
+		for test_suite in _test_suites_to_process:
+			send_test_suite(test_suite)
+
+
+func _filter_test_case(test_suites :Array[Node], included_tests :PackedStringArray) -> void:
+	if included_tests.is_empty():
+		return
+	for test_suite in test_suites:
+		for test_case in test_suite.get_children():
+			_do_filter_test_case(test_suite, test_case, included_tests)
+
+
+func _do_filter_test_case(test_suite :Node, test_case :Node, included_tests :PackedStringArray) -> void:
+	for included_test in included_tests:
+		var test_meta :PackedStringArray = included_test.split(":")
+		var test_name := test_meta[0]
+		if test_case.get_name() == test_name:
+			# we have a paremeterized test selection
+			if test_meta.size() > 1:
+				var test_param_index := test_meta[1]
+				test_case.set_test_parameter_index(test_param_index.to_int())
+			return
+	# the test is filtered out
+	test_suite.remove_child(test_case)
+	test_case.free()
+
+
+func _collect_test_case_count(testSuites :Array[Node]) -> int:
+	var total :int = 0
+	for test_suite in testSuites:
+		total += test_suite.get_child_count()
+	return total
+
+
+# RPC send functions
+func send_message(message :String) -> void:
+	_client.rpc_send(RPCMessage.of(message))
+
+
+func send_test_suite(test_suite :Node) -> void:
+	_client.rpc_send(RPCGdUnitTestSuite.of(test_suite))
+
+
+func _on_gdunit_event(event :GdUnitEvent) -> void:
+	_client.rpc_send(RPCGdUnitEvent.of(event))
+
+
+# Event bridge from C# GdUnit4.ITestEventListener.cs
+func PublishEvent(data :Dictionary) -> void:
+	var event := GdUnitEvent.new().deserialize(data)
+	_client.rpc_send(RPCGdUnitEvent.of(event))

addons/gdUnit4/src/core/GdUnitRunner.tscn

@@ -0,0 +1,10 @@
+[gd_scene load_steps=3 format=3 uid="uid://belidlfknh74r"]
+
+[ext_resource type="Script" path="res://addons/gdUnit4/src/core/GdUnitRunner.gd" id="1"]
+[ext_resource type="Script" path="res://addons/gdUnit4/src/network/GdUnitTcpClient.gd" id="2"]
+
+[node name="Control" type="Node"]
+script = ExtResource("1")
+
+[node name="GdUnitTcpClient" type="Node" parent="."]
+script = ExtResource("2")

addons/gdUnit4/src/core/GdUnitRunnerConfig.gd

@@ -0,0 +1,154 @@
+class_name GdUnitRunnerConfig
+extends Resource
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+const CONFIG_VERSION = "1.0"
+const VERSION = "version"
+const INCLUDED = "included"
+const SKIPPED = "skipped"
+const SERVER_PORT = "server_port"
+const EXIT_FAIL_FAST ="exit_on_first_fail"
+
+const CONFIG_FILE = "res://addons/gdUnit4/GdUnitRunner.cfg"
+
+var _config := {
+		VERSION : CONFIG_VERSION,
+		# a set of directories or testsuite paths as key and a optional set of testcases as values
+		INCLUDED :  Dictionary(),
+		# a set of skipped directories or testsuite paths
+		SKIPPED : Dictionary(),
+		# the port of running test server for this session
+		SERVER_PORT : -1
+	}
+
+
+func clear() -> GdUnitRunnerConfig:
+	_config[INCLUDED] = Dictionary()
+	_config[SKIPPED] = Dictionary()
+	return self
+
+
+func set_server_port(port :int) -> GdUnitRunnerConfig:
+	_config[SERVER_PORT] = port
+	return self
+
+
+func server_port() -> int:
+	return _config.get(SERVER_PORT, -1)
+
+
+func self_test() -> GdUnitRunnerConfig:
+	add_test_suite("res://addons/gdUnit4/test/")
+	add_test_suite("res://addons/gdUnit4/mono/test/")
+	return self
+
+
+func add_test_suite(p_resource_path :String) -> GdUnitRunnerConfig:
+	var to_execute_ := to_execute()
+	to_execute_[p_resource_path] = to_execute_.get(p_resource_path, PackedStringArray())
+	return self
+
+
+func add_test_suites(resource_paths :PackedStringArray) -> GdUnitRunnerConfig:
+	for resource_path_ in resource_paths:
+		add_test_suite(resource_path_)
+	return self
+
+
+func add_test_case(p_resource_path :String, test_name :StringName, test_param_index :int = -1) -> GdUnitRunnerConfig:
+	var to_execute_ := to_execute()
+	var test_cases :PackedStringArray = to_execute_.get(p_resource_path, PackedStringArray())
+	if test_param_index != -1:
+		test_cases.append("%s:%d" % [test_name, test_param_index])
+	else:
+		test_cases.append(test_name)
+	to_execute_[p_resource_path] = test_cases
+	return self
+
+
+# supports full path or suite name with optional test case name
+# <test_suite_name|path>[:<test_case_name>]
+# '/path/path', res://path/path', 'res://path/path/testsuite.gd' or 'testsuite'
+# 'res://path/path/testsuite.gd:test_case' or 'testsuite:test_case'
+func skip_test_suite(value :StringName) -> GdUnitRunnerConfig:
+	var parts :Array =  GdUnitFileAccess.make_qualified_path(value).rsplit(":")
+	if parts[0] == "res":
+		parts.pop_front()
+	parts[0] = GdUnitFileAccess.make_qualified_path(parts[0])
+	match parts.size():
+		1: skipped()[parts[0]] = PackedStringArray()
+		2: skip_test_case(parts[0], parts[1])
+	return self
+
+
+func skip_test_suites(resource_paths :PackedStringArray) -> GdUnitRunnerConfig:
+	for resource_path_ in resource_paths:
+		skip_test_suite(resource_path_)
+	return self
+
+
+func skip_test_case(p_resource_path :String, test_name :StringName) -> GdUnitRunnerConfig:
+	var to_ignore := skipped()
+	var test_cases :PackedStringArray = to_ignore.get(p_resource_path, PackedStringArray())
+	test_cases.append(test_name)
+	to_ignore[p_resource_path] = test_cases
+	return self
+
+
+# Dictionary[String, Dictionary[String, PackedStringArray]]
+func to_execute() -> Dictionary:
+	return _config.get(INCLUDED, {"res://" : PackedStringArray()})
+
+
+func skipped() -> Dictionary:
+	return _config.get(SKIPPED, {})
+
+
+func save_config(path :String = CONFIG_FILE) -> GdUnitResult:
+	var file := FileAccess.open(path, FileAccess.WRITE)
+	if file == null:
+		var error := FileAccess.get_open_error()
+		return GdUnitResult.error("Can't write test runner configuration '%s'! %s" % [path, error_string(error)])
+	_config[VERSION] = CONFIG_VERSION
+	file.store_string(JSON.stringify(_config))
+	return GdUnitResult.success(path)
+
+
+func load_config(path :String = CONFIG_FILE) -> GdUnitResult:
+	if not FileAccess.file_exists(path):
+		return GdUnitResult.error("Can't find test runner configuration '%s'! Please select a test to run." % path)
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		var error := FileAccess.get_open_error()
+		return GdUnitResult.error("Can't load test runner configuration '%s'! ERROR: %s." % [path, error_string(error)])
+	var content := file.get_as_text()
+	if not content.is_empty() and content[0] == '{':
+		# Parse as json
+		var test_json_conv := JSON.new()
+		var error := test_json_conv.parse(content)
+		if error != OK:
+			return GdUnitResult.error("The runner configuration '%s' is invalid! The format is changed please delete it manually and start a new test run." % path)
+		_config = test_json_conv.get_data() as Dictionary
+		if not _config.has(VERSION):
+			return GdUnitResult.error("The runner configuration '%s' is invalid! The format is changed please delete it manually and start a new test run." % path)
+		fix_value_types()
+	return GdUnitResult.success(path)
+
+
+func fix_value_types() -> void:
+	# fix float value to int json stores all numbers as float
+	var server_port_ :int = _config.get(SERVER_PORT, -1)
+	_config[SERVER_PORT] = server_port_
+	convert_Array_to_PackedStringArray(_config[INCLUDED])
+	convert_Array_to_PackedStringArray(_config[SKIPPED])
+
+
+func convert_Array_to_PackedStringArray(data :Dictionary) -> void:
+	for key in data.keys() as Array[String]:
+		var values :Array = data[key]
+		data[key] = PackedStringArray(values)
+
+
+func _to_string() -> String:
+	return str(_config)

addons/gdUnit4/src/core/GdUnitSceneRunnerImpl.gd

@@ -0,0 +1,486 @@
+# This class provides a runner for scense to simulate interactions like keyboard or mouse
+class_name GdUnitSceneRunnerImpl
+extends GdUnitSceneRunner
+
+
+var GdUnitFuncAssertImpl := ResourceLoader.load("res://addons/gdUnit4/src/asserts/GdUnitFuncAssertImpl.gd", "GDScript", ResourceLoader.CACHE_MODE_REUSE)
+
+
+# mapping of mouse buttons and his masks
+const MAP_MOUSE_BUTTON_MASKS := {
+	MOUSE_BUTTON_LEFT : MOUSE_BUTTON_MASK_LEFT,
+	MOUSE_BUTTON_RIGHT : MOUSE_BUTTON_MASK_RIGHT,
+	MOUSE_BUTTON_MIDDLE : MOUSE_BUTTON_MASK_MIDDLE,
+	# https://github.com/godotengine/godot/issues/73632
+	MOUSE_BUTTON_WHEEL_UP : 1 << (MOUSE_BUTTON_WHEEL_UP - 1),
+	MOUSE_BUTTON_WHEEL_DOWN : 1 << (MOUSE_BUTTON_WHEEL_DOWN - 1),
+	MOUSE_BUTTON_XBUTTON1 : MOUSE_BUTTON_MASK_MB_XBUTTON1,
+	MOUSE_BUTTON_XBUTTON2 : MOUSE_BUTTON_MASK_MB_XBUTTON2,
+}
+
+var _is_disposed := false
+var _current_scene :Node = null
+var _awaiter :GdUnitAwaiter = GdUnitAwaiter.new()
+var _verbose :bool
+var _simulate_start_time :LocalTime
+var _last_input_event :InputEvent = null
+var _mouse_button_on_press := []
+var _key_on_press := []
+var _action_on_press := []
+var _curent_mouse_position :Vector2
+
+# time factor settings
+var _time_factor := 1.0
+var _saved_iterations_per_second :float
+var _scene_auto_free := false
+
+
+func _init(p_scene :Variant, p_verbose :bool, p_hide_push_errors := false) -> void:
+	_verbose = p_verbose
+	_saved_iterations_per_second = Engine.get_physics_ticks_per_second()
+	set_time_factor(1)
+	# handle scene loading by resource path
+	if typeof(p_scene) == TYPE_STRING:
+		if !ResourceLoader.exists(p_scene):
+			if not p_hide_push_errors:
+				push_error("GdUnitSceneRunner: Can't load scene by given resource path: '%s'. The resource does not exists." % p_scene)
+			return
+		if !str(p_scene).ends_with(".tscn") and !str(p_scene).ends_with(".scn") and !str(p_scene).begins_with("uid://"):
+			if not p_hide_push_errors:
+				push_error("GdUnitSceneRunner: The given resource: '%s'. is not a scene." % p_scene)
+			return
+		_current_scene = load(p_scene).instantiate()
+		_scene_auto_free = true
+	else:
+		# verify we have a node instance
+		if not p_scene is Node:
+			if not p_hide_push_errors:
+				push_error("GdUnitSceneRunner: The given instance '%s' is not a Node." % p_scene)
+			return
+		_current_scene = p_scene
+	if _current_scene == null:
+		if not p_hide_push_errors:
+			push_error("GdUnitSceneRunner: Scene must be not null!")
+		return
+	_scene_tree().root.add_child(_current_scene)
+	# do finally reset all open input events when the scene is removed
+	_scene_tree().root.child_exiting_tree.connect(func f(child :Node) -> void:
+		if child == _current_scene:
+			_reset_input_to_default()
+	)
+	_simulate_start_time = LocalTime.now()
+	# we need to set inital a valid window otherwise the warp_mouse() is not handled
+	DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
+	# set inital mouse pos to 0,0
+	var max_iteration_to_wait := 0
+	while get_global_mouse_position() != Vector2.ZERO and max_iteration_to_wait < 100:
+		Input.warp_mouse(Vector2.ZERO)
+		max_iteration_to_wait += 1
+
+
+func _notification(what :int) -> void:
+	if what == NOTIFICATION_PREDELETE and is_instance_valid(self):
+		# reset time factor to normal
+		__deactivate_time_factor()
+		if is_instance_valid(_current_scene):
+			_scene_tree().root.remove_child(_current_scene)
+			# do only free scenes instanciated by this runner
+			if _scene_auto_free:
+				_current_scene.free()
+		_is_disposed = true
+		_current_scene = null
+		# we hide the scene/main window after runner is finished
+		DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_MINIMIZED)
+
+
+func _scene_tree() -> SceneTree:
+	return Engine.get_main_loop() as SceneTree
+
+
+func simulate_action_pressed(action :String) -> GdUnitSceneRunner:
+	simulate_action_press(action)
+	simulate_action_release(action)
+	return self
+
+
+func simulate_action_press(action :String) -> GdUnitSceneRunner:
+	__print_current_focus()
+	var event := InputEventAction.new()
+	event.pressed = true
+	event.action = action
+	_action_on_press.append(action)
+	return _handle_input_event(event)
+
+
+func simulate_action_release(action :String) -> GdUnitSceneRunner:
+	__print_current_focus()
+	var event := InputEventAction.new()
+	event.pressed = false
+	event.action = action
+	_action_on_press.erase(action)
+	return _handle_input_event(event)
+
+
+func simulate_key_pressed(key_code :int, shift_pressed := false, ctrl_pressed := false) -> GdUnitSceneRunner:
+	simulate_key_press(key_code, shift_pressed, ctrl_pressed)
+	simulate_key_release(key_code, shift_pressed, ctrl_pressed)
+	return self
+
+
+func simulate_key_press(key_code :int, shift_pressed := false, ctrl_pressed := false) -> GdUnitSceneRunner:
+	__print_current_focus()
+	var event := InputEventKey.new()
+	event.pressed = true
+	event.keycode = key_code as Key
+	event.physical_keycode = key_code as Key
+	event.alt_pressed = key_code == KEY_ALT
+	event.shift_pressed = shift_pressed or key_code == KEY_SHIFT
+	event.ctrl_pressed = ctrl_pressed or key_code == KEY_CTRL
+	_apply_input_modifiers(event)
+	_key_on_press.append(key_code)
+	return _handle_input_event(event)
+
+
+func simulate_key_release(key_code :int, shift_pressed := false, ctrl_pressed := false) -> GdUnitSceneRunner:
+	__print_current_focus()
+	var event := InputEventKey.new()
+	event.pressed = false
+	event.keycode = key_code as Key
+	event.physical_keycode = key_code as Key
+	event.alt_pressed = key_code == KEY_ALT
+	event.shift_pressed = shift_pressed or key_code == KEY_SHIFT
+	event.ctrl_pressed = ctrl_pressed or key_code == KEY_CTRL
+	_apply_input_modifiers(event)
+	_key_on_press.erase(key_code)
+	return _handle_input_event(event)
+
+
+func set_mouse_pos(pos :Vector2) -> GdUnitSceneRunner:
+	var event := InputEventMouseMotion.new()
+	event.position = pos
+	event.global_position = get_global_mouse_position()
+	_apply_input_modifiers(event)
+	return _handle_input_event(event)
+
+
+func get_mouse_position() -> Vector2:
+	if _last_input_event is InputEventMouse:
+		return _last_input_event.position
+	var current_scene := scene()
+	if current_scene != null:
+		return current_scene.get_viewport().get_mouse_position()
+	return Vector2.ZERO
+
+
+func get_global_mouse_position() -> Vector2:
+	return Engine.get_main_loop().root.get_mouse_position()
+
+
+func simulate_mouse_move(pos :Vector2) -> GdUnitSceneRunner:
+	var event := InputEventMouseMotion.new()
+	event.position = pos
+	event.relative = pos - get_mouse_position()
+	event.global_position = get_global_mouse_position()
+	_apply_input_mouse_mask(event)
+	_apply_input_modifiers(event)
+	return _handle_input_event(event)
+
+
+func simulate_mouse_move_relative(relative: Vector2, time: float = 1.0, trans_type: Tween.TransitionType = Tween.TRANS_LINEAR) -> GdUnitSceneRunner:
+	var tween := _scene_tree().create_tween()
+	_curent_mouse_position = get_mouse_position()
+	var final_position := _curent_mouse_position + relative
+	tween.tween_property(self, "_curent_mouse_position", final_position, time).set_trans(trans_type)
+	tween.play()
+
+	while not get_mouse_position().is_equal_approx(final_position):
+		simulate_mouse_move(_curent_mouse_position)
+		await _scene_tree().process_frame
+	return self
+
+
+func simulate_mouse_move_absolute(position: Vector2, time: float = 1.0, trans_type: Tween.TransitionType = Tween.TRANS_LINEAR) -> GdUnitSceneRunner:
+	var tween := _scene_tree().create_tween()
+	_curent_mouse_position = get_mouse_position()
+	tween.tween_property(self, "_curent_mouse_position", position, time).set_trans(trans_type)
+	tween.play()
+
+	while not get_mouse_position().is_equal_approx(position):
+		simulate_mouse_move(_curent_mouse_position)
+		await _scene_tree().process_frame
+	return self
+
+
+func simulate_mouse_button_pressed(buttonIndex :MouseButton, double_click := false) -> GdUnitSceneRunner:
+	simulate_mouse_button_press(buttonIndex, double_click)
+	simulate_mouse_button_release(buttonIndex)
+	return self
+
+
+func simulate_mouse_button_press(buttonIndex :MouseButton, double_click := false) -> GdUnitSceneRunner:
+	var event := InputEventMouseButton.new()
+	event.button_index = buttonIndex
+	event.pressed = true
+	event.double_click = double_click
+	_apply_input_mouse_position(event)
+	_apply_input_mouse_mask(event)
+	_apply_input_modifiers(event)
+	_mouse_button_on_press.append(buttonIndex)
+	return _handle_input_event(event)
+
+
+func simulate_mouse_button_release(buttonIndex :MouseButton) -> GdUnitSceneRunner:
+	var event := InputEventMouseButton.new()
+	event.button_index = buttonIndex
+	event.pressed = false
+	_apply_input_mouse_position(event)
+	_apply_input_mouse_mask(event)
+	_apply_input_modifiers(event)
+	_mouse_button_on_press.erase(buttonIndex)
+	return _handle_input_event(event)
+
+
+func set_time_factor(time_factor := 1.0) -> GdUnitSceneRunner:
+	_time_factor = min(9.0, time_factor)
+	__activate_time_factor()
+	__print("set time factor: %f" % _time_factor)
+	__print("set physics physics_ticks_per_second: %d" % (_saved_iterations_per_second*_time_factor))
+	return self
+
+
+func simulate_frames(frames: int, delta_milli :int = -1) -> GdUnitSceneRunner:
+	var time_shift_frames :int = max(1, frames / _time_factor)
+	for frame in time_shift_frames:
+		if delta_milli == -1:
+			await _scene_tree().process_frame
+		else:
+			await _scene_tree().create_timer(delta_milli * 0.001).timeout
+	return self
+
+
+func simulate_until_signal(
+	signal_name :String,
+	arg0 :Variant = NO_ARG,
+	arg1 :Variant = NO_ARG,
+	arg2 :Variant = NO_ARG,
+	arg3 :Variant = NO_ARG,
+	arg4 :Variant = NO_ARG,
+	arg5 :Variant = NO_ARG,
+	arg6 :Variant = NO_ARG,
+	arg7 :Variant = NO_ARG,
+	arg8 :Variant = NO_ARG,
+	arg9 :Variant = NO_ARG) -> GdUnitSceneRunner:
+	var args :Array = GdArrayTools.filter_value([arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9], NO_ARG)
+	await _awaiter.await_signal_idle_frames(scene(), signal_name, args, 10000)
+	return self
+
+
+func simulate_until_object_signal(
+	source :Object,
+	signal_name :String,
+	arg0 :Variant = NO_ARG,
+	arg1 :Variant = NO_ARG,
+	arg2 :Variant = NO_ARG,
+	arg3 :Variant = NO_ARG,
+	arg4 :Variant = NO_ARG,
+	arg5 :Variant = NO_ARG,
+	arg6 :Variant = NO_ARG,
+	arg7 :Variant = NO_ARG,
+	arg8 :Variant = NO_ARG,
+	arg9 :Variant = NO_ARG) -> GdUnitSceneRunner:
+	var args :Array = GdArrayTools.filter_value([arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9], NO_ARG)
+	await _awaiter.await_signal_idle_frames(source, signal_name, args, 10000)
+	return self
+
+
+func await_func(func_name :String, args := []) -> GdUnitFuncAssert:
+	return GdUnitFuncAssertImpl.new(scene(), func_name, args)
+
+
+func await_func_on(instance :Object, func_name :String, args := []) -> GdUnitFuncAssert:
+	return GdUnitFuncAssertImpl.new(instance, func_name, args)
+
+
+func await_signal(signal_name :String, args := [], timeout := 2000 ) -> void:
+	await _awaiter.await_signal_on(scene(), signal_name, args, timeout)
+
+
+func await_signal_on(source :Object, signal_name :String, args := [], timeout := 2000 ) -> void:
+	await _awaiter.await_signal_on(source, signal_name, args, timeout)
+
+
+# maximizes the window to bring the scene visible
+func maximize_view() -> GdUnitSceneRunner:
+	DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
+	DisplayServer.window_move_to_foreground()
+	return self
+
+
+func _property_exists(name :String) -> bool:
+	return scene().get_property_list().any(func(properties :Dictionary) -> bool: return properties["name"] == name)
+
+
+func get_property(name :String) -> Variant:
+	if not _property_exists(name):
+		return "The property '%s' not exist checked loaded scene." % name
+	return scene().get(name)
+
+
+func set_property(name :String, value :Variant) -> bool:
+	if not _property_exists(name):
+		push_error("The property named '%s' cannot be set, it does not exist!" % name)
+		return false;
+	scene().set(name, value)
+	return true
+
+
+func invoke(
+	name :String,
+	arg0 :Variant = NO_ARG,
+	arg1 :Variant = NO_ARG,
+	arg2 :Variant = NO_ARG,
+	arg3 :Variant = NO_ARG,
+	arg4 :Variant = NO_ARG,
+	arg5 :Variant = NO_ARG,
+	arg6 :Variant = NO_ARG,
+	arg7 :Variant = NO_ARG,
+	arg8 :Variant = NO_ARG,
+	arg9 :Variant = NO_ARG) -> Variant:
+	var args :Array = GdArrayTools.filter_value([arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9], NO_ARG)
+	if scene().has_method(name):
+		return scene().callv(name, args)
+	return "The method '%s' not exist checked loaded scene." % name
+
+
+func find_child(name :String, recursive :bool = true, owned :bool = false) -> Node:
+	return scene().find_child(name, recursive, owned)
+
+
+func _scene_name() -> String:
+	var scene_script :GDScript = scene().get_script()
+	var scene_name :String = scene().get_name()
+	if not scene_script:
+		return scene_name
+	if not scene_name.begins_with("@"):
+		return scene_name
+	return scene_script.resource_name.get_basename()
+
+
+func __activate_time_factor() -> void:
+	Engine.set_time_scale(_time_factor)
+	Engine.set_physics_ticks_per_second((_saved_iterations_per_second * _time_factor) as int)
+
+
+func __deactivate_time_factor() -> void:
+	Engine.set_time_scale(1)
+	Engine.set_physics_ticks_per_second(_saved_iterations_per_second as int)
+
+
+# copy over current active modifiers
+func _apply_input_modifiers(event :InputEvent) -> void:
+	if _last_input_event is InputEventWithModifiers and event is InputEventWithModifiers:
+		event.meta_pressed = event.meta_pressed or _last_input_event.meta_pressed
+		event.alt_pressed = event.alt_pressed or _last_input_event.alt_pressed
+		event.shift_pressed = event.shift_pressed or _last_input_event.shift_pressed
+		event.ctrl_pressed = event.ctrl_pressed or _last_input_event.ctrl_pressed
+		# this line results into reset the control_pressed state!!!
+		#event.command_or_control_autoremap = event.command_or_control_autoremap or _last_input_event.command_or_control_autoremap
+
+
+# copy over current active mouse mask and combine with curren mask
+func _apply_input_mouse_mask(event :InputEvent) -> void:
+	# first apply last mask
+	if _last_input_event is InputEventMouse and event is InputEventMouse:
+		event.button_mask |= _last_input_event.button_mask
+	if event is InputEventMouseButton:
+		var button_mask :int = MAP_MOUSE_BUTTON_MASKS.get(event.get_button_index(), 0)
+		if event.is_pressed():
+			event.button_mask |= button_mask
+		else:
+			event.button_mask ^= button_mask
+
+
+# copy over last mouse position if need
+func _apply_input_mouse_position(event :InputEvent) -> void:
+	if _last_input_event is InputEventMouse and event is InputEventMouseButton:
+		event.position = _last_input_event.position
+
+
+## handle input action via Input modifieres
+func _handle_actions(event :InputEventAction) -> bool:
+	if not InputMap.event_is_action(event, event.action, true):
+		return false
+	__print("	process action %s (%s) <- %s" % [scene(), _scene_name(), event.as_text()])
+	if event.is_pressed():
+		Input.action_press(event.action, InputMap.action_get_deadzone(event.action))
+	else:
+		Input.action_release(event.action)
+	return true
+
+
+# for handling read https://docs.godotengine.org/en/stable/tutorials/inputs/inputevent.html?highlight=inputevent#how-does-it-work
+func _handle_input_event(event :InputEvent) -> GdUnitSceneRunner:
+	if event is InputEventMouse:
+		Input.warp_mouse(event.position)
+	Input.parse_input_event(event)
+
+	if event is InputEventAction:
+		_handle_actions(event)
+
+	Input.flush_buffered_events()
+	var current_scene := scene()
+	if is_instance_valid(current_scene):
+		__print("	process event %s (%s) <- %s" % [current_scene, _scene_name(), event.as_text()])
+		if(current_scene.has_method("_gui_input")):
+			current_scene._gui_input(event)
+		if(current_scene.has_method("_unhandled_input")):
+			current_scene._unhandled_input(event)
+		current_scene.get_viewport().set_input_as_handled()
+
+	# save last input event needs to be merged with next InputEventMouseButton
+	_last_input_event = event
+	return self
+
+
+func _reset_input_to_default() -> void:
+	# reset all mouse button to inital state if need
+	for m_button :int in _mouse_button_on_press.duplicate():
+		if Input.is_mouse_button_pressed(m_button):
+			simulate_mouse_button_release(m_button)
+	_mouse_button_on_press.clear()
+
+	for key_scancode :int in _key_on_press.duplicate():
+		if Input.is_key_pressed(key_scancode):
+			simulate_key_release(key_scancode)
+	_key_on_press.clear()
+
+	for action :String in _action_on_press.duplicate():
+		if Input.is_action_pressed(action):
+			simulate_action_release(action)
+	_action_on_press.clear()
+
+	Input.flush_buffered_events()
+	_last_input_event = null
+
+
+func __print(message :String) -> void:
+	if _verbose:
+		prints(message)
+
+
+func __print_current_focus() -> void:
+	if not _verbose:
+		return
+	var focused_node := scene().get_viewport().gui_get_focus_owner()
+	if focused_node:
+		prints("	focus checked %s" % focused_node)
+	else:
+		prints("	no focus set")
+
+
+func scene() -> Node:
+	if is_instance_valid(_current_scene):
+		return _current_scene
+	if not _is_disposed:
+		push_error("The current scene instance is not valid anymore! check your test is valid. e.g. check for missing awaits.")
+	return null

addons/gdUnit4/src/core/GdUnitScriptType.gd

@@ -0,0 +1,16 @@
+class_name GdUnitScriptType
+extends RefCounted
+
+const UNKNOWN := ""
+const CS := "cs"
+const GD := "gd"
+
+
+static func type_of(script :Script) -> String:
+	if script == null:
+		return UNKNOWN
+	if GdObjects.is_gd_script(script):
+		return GD
+	if GdObjects.is_cs_script(script):
+		return CS
+	return UNKNOWN

addons/gdUnit4/src/core/GdUnitSettings.gd

@@ -0,0 +1,378 @@
+@tool
+class_name GdUnitSettings
+extends RefCounted
+
+
+const MAIN_CATEGORY = "gdunit4"
+# Common Settings
+const COMMON_SETTINGS = MAIN_CATEGORY + "/settings"
+
+const GROUP_COMMON = COMMON_SETTINGS + "/common"
+const UPDATE_NOTIFICATION_ENABLED = GROUP_COMMON + "/update_notification_enabled"
+const SERVER_TIMEOUT = GROUP_COMMON + "/server_connection_timeout_minutes"
+
+const GROUP_TEST = COMMON_SETTINGS + "/test"
+const TEST_TIMEOUT = GROUP_TEST + "/test_timeout_seconds"
+const TEST_LOOKUP_FOLDER = GROUP_TEST + "/test_lookup_folder"
+const TEST_SITE_NAMING_CONVENTION = GROUP_TEST + "/test_suite_naming_convention"
+const TEST_DISCOVER_ENABLED = GROUP_TEST + "/test_discovery"
+
+
+# Report Setiings
+const REPORT_SETTINGS = MAIN_CATEGORY + "/report"
+const GROUP_GODOT = REPORT_SETTINGS + "/godot"
+const REPORT_PUSH_ERRORS = GROUP_GODOT + "/push_error"
+const REPORT_SCRIPT_ERRORS = GROUP_GODOT + "/script_error"
+const REPORT_ORPHANS  = REPORT_SETTINGS + "/verbose_orphans"
+const GROUP_ASSERT = REPORT_SETTINGS + "/assert"
+const REPORT_ASSERT_WARNINGS = GROUP_ASSERT + "/verbose_warnings"
+const REPORT_ASSERT_ERRORS   = GROUP_ASSERT + "/verbose_errors"
+const REPORT_ASSERT_STRICT_NUMBER_TYPE_COMPARE = GROUP_ASSERT + "/strict_number_type_compare"
+
+# Godot debug stdout/logging settings
+const CATEGORY_LOGGING := "debug/file_logging/"
+const STDOUT_ENABLE_TO_FILE = CATEGORY_LOGGING + "enable_file_logging"
+const STDOUT_WITE_TO_FILE = CATEGORY_LOGGING + "log_path"
+
+
+# GdUnit Templates
+const TEMPLATES = MAIN_CATEGORY + "/templates"
+const TEMPLATES_TS = TEMPLATES + "/testsuite"
+const TEMPLATE_TS_GD = TEMPLATES_TS + "/GDScript"
+const TEMPLATE_TS_CS = TEMPLATES_TS + "/CSharpScript"
+
+
+# UI Setiings
+const UI_SETTINGS = MAIN_CATEGORY + "/ui"
+const GROUP_UI_INSPECTOR = UI_SETTINGS + "/inspector"
+const INSPECTOR_NODE_COLLAPSE = GROUP_UI_INSPECTOR + "/node_collapse"
+const INSPECTOR_TREE_VIEW_MODE = GROUP_UI_INSPECTOR + "/tree_view_mode"
+const INSPECTOR_TREE_SORT_MODE = GROUP_UI_INSPECTOR + "/tree_sort_mode"
+
+
+# Shortcut Setiings
+const SHORTCUT_SETTINGS = MAIN_CATEGORY + "/Shortcuts"
+const GROUP_SHORTCUT_INSPECTOR = SHORTCUT_SETTINGS + "/inspector"
+const SHORTCUT_INSPECTOR_RERUN_TEST = GROUP_SHORTCUT_INSPECTOR + "/rerun_test"
+const SHORTCUT_INSPECTOR_RERUN_TEST_DEBUG = GROUP_SHORTCUT_INSPECTOR + "/rerun_test_debug"
+const SHORTCUT_INSPECTOR_RUN_TEST_OVERALL = GROUP_SHORTCUT_INSPECTOR + "/run_test_overall"
+const SHORTCUT_INSPECTOR_RUN_TEST_STOP = GROUP_SHORTCUT_INSPECTOR + "/run_test_stop"
+
+const GROUP_SHORTCUT_EDITOR = SHORTCUT_SETTINGS + "/editor"
+const SHORTCUT_EDITOR_RUN_TEST = GROUP_SHORTCUT_EDITOR + "/run_test"
+const SHORTCUT_EDITOR_RUN_TEST_DEBUG = GROUP_SHORTCUT_EDITOR + "/run_test_debug"
+const SHORTCUT_EDITOR_CREATE_TEST = GROUP_SHORTCUT_EDITOR + "/create_test"
+
+const GROUP_SHORTCUT_FILESYSTEM = SHORTCUT_SETTINGS + "/filesystem"
+const SHORTCUT_FILESYSTEM_RUN_TEST = GROUP_SHORTCUT_FILESYSTEM + "/run_test"
+const SHORTCUT_FILESYSTEM_RUN_TEST_DEBUG = GROUP_SHORTCUT_FILESYSTEM + "/run_test_debug"
+
+
+# Toolbar Setiings
+const GROUP_UI_TOOLBAR = UI_SETTINGS + "/toolbar"
+const INSPECTOR_TOOLBAR_BUTTON_RUN_OVERALL = GROUP_UI_TOOLBAR + "/run_overall"
+
+# defaults
+# server connection timeout in minutes
+const DEFAULT_SERVER_TIMEOUT :int = 30
+# test case runtime timeout in seconds
+const DEFAULT_TEST_TIMEOUT :int = 60*5
+# the folder to create new test-suites
+const DEFAULT_TEST_LOOKUP_FOLDER := "test"
+
+# help texts
+const HELP_TEST_LOOKUP_FOLDER := "Sets the subfolder for the search/creation of test suites. (leave empty to use source folder)"
+
+enum NAMING_CONVENTIONS {
+	AUTO_DETECT,
+	SNAKE_CASE,
+	PASCAL_CASE,
+}
+
+
+static func setup() -> void:
+	create_property_if_need(UPDATE_NOTIFICATION_ENABLED, true, "Enables/Disables the update notification checked startup.")
+	create_property_if_need(SERVER_TIMEOUT, DEFAULT_SERVER_TIMEOUT, "Sets the server connection timeout in minutes.")
+	create_property_if_need(TEST_TIMEOUT, DEFAULT_TEST_TIMEOUT, "Sets the test case runtime timeout in seconds.")
+	create_property_if_need(TEST_LOOKUP_FOLDER, DEFAULT_TEST_LOOKUP_FOLDER, HELP_TEST_LOOKUP_FOLDER)
+	create_property_if_need(TEST_SITE_NAMING_CONVENTION, NAMING_CONVENTIONS.AUTO_DETECT, "Sets test-suite genrate script name convention.", NAMING_CONVENTIONS.keys())
+	create_property_if_need(TEST_DISCOVER_ENABLED, false, "Enables/Disables the automatic detection of tests by finding tests in test lookup folders at runtime.")
+	create_property_if_need(REPORT_PUSH_ERRORS, false, "Enables/Disables report of push_error() as failure!")
+	create_property_if_need(REPORT_SCRIPT_ERRORS, true, "Enables/Disables report of script errors as failure!")
+	create_property_if_need(REPORT_ORPHANS, true, "Enables/Disables orphan reporting.")
+	create_property_if_need(REPORT_ASSERT_ERRORS, true, "Enables/Disables error reporting checked asserts.")
+	create_property_if_need(REPORT_ASSERT_WARNINGS, true, "Enables/Disables warning reporting checked asserts")
+	create_property_if_need(REPORT_ASSERT_STRICT_NUMBER_TYPE_COMPARE, true, "Enabled/disabled number values will be compared strictly by type. (real vs int)")
+	# inspector
+	create_property_if_need(INSPECTOR_NODE_COLLAPSE, true,
+		"Enables/Disables that the testsuite node is closed after a successful test run.")
+	create_property_if_need(INSPECTOR_TREE_VIEW_MODE, GdUnitInspectorTreeConstants.TREE_VIEW_MODE.TREE,
+		"Sets the inspector panel presentation.", GdUnitInspectorTreeConstants.TREE_VIEW_MODE.keys())
+	create_property_if_need(INSPECTOR_TREE_SORT_MODE, GdUnitInspectorTreeConstants.SORT_MODE.UNSORTED,
+		"Sets the inspector panel presentation.", GdUnitInspectorTreeConstants.SORT_MODE.keys())
+	create_property_if_need(INSPECTOR_TOOLBAR_BUTTON_RUN_OVERALL, false,
+		"Shows/Hides the 'Run overall Tests' button in the inspector toolbar.")
+	create_property_if_need(TEMPLATE_TS_GD, GdUnitTestSuiteTemplate.default_GD_template(), "Defines the test suite template")
+	create_shortcut_properties_if_need()
+	migrate_properties()
+
+
+static func migrate_properties() -> void:
+	var TEST_ROOT_FOLDER := "gdunit4/settings/test/test_root_folder"
+	if get_property(TEST_ROOT_FOLDER) != null:
+		migrate_property(TEST_ROOT_FOLDER,\
+			TEST_LOOKUP_FOLDER,\
+			DEFAULT_TEST_LOOKUP_FOLDER,\
+			HELP_TEST_LOOKUP_FOLDER,\
+			func(value :Variant) -> String: return DEFAULT_TEST_LOOKUP_FOLDER if value == null else value)
+
+
+static func create_shortcut_properties_if_need() -> void:
+	# inspector
+	create_property_if_need(SHORTCUT_INSPECTOR_RERUN_TEST, GdUnitShortcut.default_keys(GdUnitShortcut.ShortCut.RERUN_TESTS), "Rerun of the last tests performed.")
+	create_property_if_need(SHORTCUT_INSPECTOR_RERUN_TEST_DEBUG, GdUnitShortcut.default_keys(GdUnitShortcut.ShortCut.RERUN_TESTS_DEBUG), "Rerun of the last tests performed (Debug).")
+	create_property_if_need(SHORTCUT_INSPECTOR_RUN_TEST_OVERALL, GdUnitShortcut.default_keys(GdUnitShortcut.ShortCut.RUN_TESTS_OVERALL), "Runs all tests (Debug).")
+	create_property_if_need(SHORTCUT_INSPECTOR_RUN_TEST_STOP, GdUnitShortcut.default_keys(GdUnitShortcut.ShortCut.STOP_TEST_RUN), "Stops the current test execution.")
+	# script editor
+	create_property_if_need(SHORTCUT_EDITOR_RUN_TEST, GdUnitShortcut.default_keys(GdUnitShortcut.ShortCut.RUN_TESTCASE), "Runs the currently selected test.")
+	create_property_if_need(SHORTCUT_EDITOR_RUN_TEST_DEBUG, GdUnitShortcut.default_keys(GdUnitShortcut.ShortCut.RUN_TESTCASE_DEBUG), "Runs the currently selected test (Debug).")
+	create_property_if_need(SHORTCUT_EDITOR_CREATE_TEST, GdUnitShortcut.default_keys(GdUnitShortcut.ShortCut.CREATE_TEST), "Creates a new test case for the currently selected function.")
+	# filesystem
+	create_property_if_need(SHORTCUT_FILESYSTEM_RUN_TEST, GdUnitShortcut.default_keys(GdUnitShortcut.ShortCut.NONE), "Runs all test suites on the selected folder or file.")
+	create_property_if_need(SHORTCUT_FILESYSTEM_RUN_TEST_DEBUG, GdUnitShortcut.default_keys(GdUnitShortcut.ShortCut.NONE), "Runs all test suites on the selected folder or file (Debug).")
+
+
+static func create_property_if_need(name :String, default :Variant, help :="", value_set := PackedStringArray()) -> void:
+	if not ProjectSettings.has_setting(name):
+		#prints("GdUnit4: Set inital settings '%s' to '%s'." % [name, str(default)])
+		ProjectSettings.set_setting(name, default)
+
+	ProjectSettings.set_initial_value(name, default)
+	help += "" if value_set.is_empty() else " %s" % value_set
+	set_help(name, default, help)
+
+
+static func set_help(property_name :String, value :Variant, help :String) -> void:
+	ProjectSettings.add_property_info({
+		"name": property_name,
+		"type": typeof(value),
+		"hint": PROPERTY_HINT_TYPE_STRING,
+		"hint_string": help
+	})
+
+
+static func get_setting(name :String, default :Variant) -> Variant:
+	if ProjectSettings.has_setting(name):
+		return ProjectSettings.get_setting(name)
+	return default
+
+
+static func is_update_notification_enabled() -> bool:
+	if ProjectSettings.has_setting(UPDATE_NOTIFICATION_ENABLED):
+		return ProjectSettings.get_setting(UPDATE_NOTIFICATION_ENABLED)
+	return false
+
+
+static func set_update_notification(enable :bool) -> void:
+	ProjectSettings.set_setting(UPDATE_NOTIFICATION_ENABLED, enable)
+	ProjectSettings.save()
+
+
+static func get_log_path() -> String:
+	return ProjectSettings.get_setting(STDOUT_WITE_TO_FILE)
+
+
+static func set_log_path(path :String) -> void:
+	ProjectSettings.set_setting(STDOUT_ENABLE_TO_FILE, true)
+	ProjectSettings.set_setting(STDOUT_WITE_TO_FILE, path)
+	ProjectSettings.save()
+
+
+static func set_inspector_tree_sort_mode(sort_mode: GdUnitInspectorTreeConstants.SORT_MODE) -> void:
+	var property := get_property(INSPECTOR_TREE_SORT_MODE)
+	property.set_value(sort_mode)
+	update_property(property)
+
+
+static func get_inspector_tree_sort_mode() -> GdUnitInspectorTreeConstants.SORT_MODE:
+	var property := get_property(INSPECTOR_TREE_SORT_MODE)
+	return property.value() if property != null else GdUnitInspectorTreeConstants.SORT_MODE.UNSORTED
+
+
+static func set_inspector_tree_view_mode(tree_view_mode: GdUnitInspectorTreeConstants.TREE_VIEW_MODE) -> void:
+	var property := get_property(INSPECTOR_TREE_VIEW_MODE)
+	property.set_value(tree_view_mode)
+	update_property(property)
+
+
+static func get_inspector_tree_view_mode() -> GdUnitInspectorTreeConstants.TREE_VIEW_MODE:
+	var property := get_property(INSPECTOR_TREE_VIEW_MODE)
+	return property.value() if property != null else GdUnitInspectorTreeConstants.TREE_VIEW_MODE.TREE
+
+
+# the configured server connection timeout in ms
+static func server_timeout() -> int:
+	return get_setting(SERVER_TIMEOUT, DEFAULT_SERVER_TIMEOUT) * 60 * 1000
+
+
+# the configured test case timeout in ms
+static func test_timeout() -> int:
+	return get_setting(TEST_TIMEOUT, DEFAULT_TEST_TIMEOUT) * 1000
+
+
+# the root folder to store/generate test-suites
+static func test_root_folder() -> String:
+	return get_setting(TEST_LOOKUP_FOLDER, DEFAULT_TEST_LOOKUP_FOLDER)
+
+
+static func is_verbose_assert_warnings() -> bool:
+	return get_setting(REPORT_ASSERT_WARNINGS, true)
+
+
+static func is_verbose_assert_errors() -> bool:
+	return get_setting(REPORT_ASSERT_ERRORS, true)
+
+
+static func is_verbose_orphans() -> bool:
+	return get_setting(REPORT_ORPHANS, true)
+
+
+static func is_strict_number_type_compare() -> bool:
+	return get_setting(REPORT_ASSERT_STRICT_NUMBER_TYPE_COMPARE, true)
+
+
+static func is_report_push_errors() -> bool:
+	return get_setting(REPORT_PUSH_ERRORS, false)
+
+
+static func is_report_script_errors() -> bool:
+	return get_setting(REPORT_SCRIPT_ERRORS, true)
+
+
+static func is_inspector_node_collapse() -> bool:
+	return get_setting(INSPECTOR_NODE_COLLAPSE, true)
+
+
+static func is_inspector_toolbar_button_show() -> bool:
+	return get_setting(INSPECTOR_TOOLBAR_BUTTON_RUN_OVERALL, true)
+
+
+static func is_test_discover_enabled() -> bool:
+	return get_setting(TEST_DISCOVER_ENABLED, false)
+
+
+static func set_test_discover_enabled(enable :bool) -> void:
+	var property := get_property(TEST_DISCOVER_ENABLED)
+	property.set_value(enable)
+	update_property(property)
+
+
+static func is_log_enabled() -> bool:
+	return ProjectSettings.get_setting(STDOUT_ENABLE_TO_FILE)
+
+
+static func list_settings(category :String) -> Array[GdUnitProperty]:
+	var settings :Array[GdUnitProperty] = []
+	for property in ProjectSettings.get_property_list():
+		var property_name :String = property["name"]
+		if property_name.begins_with(category):
+			var value :Variant = ProjectSettings.get_setting(property_name)
+			var default :Variant = ProjectSettings.property_get_revert(property_name)
+			var help :String = property["hint_string"]
+			var value_set := extract_value_set_from_help(help)
+			settings.append(GdUnitProperty.new(property_name, property["type"], value, default, help, value_set))
+	return settings
+
+
+static func extract_value_set_from_help(value :String) -> PackedStringArray:
+	var regex := RegEx.new()
+	regex.compile("\\[(.+)\\]")
+	var matches := regex.search_all(value)
+	if matches.is_empty():
+		return PackedStringArray()
+	var values :String =  matches[0].get_string(1)
+	return values.replacen(" ", "").replacen("\"", "").split(",", false)
+
+
+static func update_property(property :GdUnitProperty) -> Variant:
+	var current_value :Variant = ProjectSettings.get_setting(property.name())
+	if current_value != property.value():
+		var error :Variant = validate_property_value(property)
+		if error != null:
+			return error
+		ProjectSettings.set_setting(property.name(), property.value())
+		GdUnitSignals.instance().gdunit_settings_changed.emit(property)
+		_save_settings()
+	return null
+
+
+static func reset_property(property :GdUnitProperty) -> void:
+	ProjectSettings.set_setting(property.name(), property.default())
+	GdUnitSignals.instance().gdunit_settings_changed.emit(property)
+	_save_settings()
+
+
+static func validate_property_value(property :GdUnitProperty) -> Variant:
+	match property.name():
+		TEST_LOOKUP_FOLDER:
+			return validate_lookup_folder(property.value())
+		_: return null
+
+
+static func validate_lookup_folder(value :String) -> Variant:
+	if value.is_empty() or value == "/":
+		return null
+	if value.contains("res:"):
+		return "Test Lookup Folder: do not allowed to contains 'res://'"
+	if not value.is_valid_filename():
+		return "Test Lookup Folder: contains invalid characters! e.g (: / \\ ? * \" | % < >)"
+	return null
+
+
+static func save_property(name :String, value :Variant) -> void:
+	ProjectSettings.set_setting(name, value)
+	_save_settings()
+
+
+static func _save_settings() -> void:
+	var err := ProjectSettings.save()
+	if err != OK:
+		push_error("Save GdUnit4 settings failed : %s" % error_string(err))
+		return
+
+
+static func has_property(name :String) -> bool:
+	return ProjectSettings.get_property_list().any(func(property :Dictionary) -> bool: return property["name"] == name)
+
+
+static func get_property(name :String) -> GdUnitProperty:
+	for property in ProjectSettings.get_property_list():
+		var property_name :String = property["name"]
+		if property_name == name:
+			var value :Variant = ProjectSettings.get_setting(property_name)
+			var default :Variant = ProjectSettings.property_get_revert(property_name)
+			var help :String = property["hint_string"]
+			var value_set := extract_value_set_from_help(help)
+			return GdUnitProperty.new(property_name, property["type"], value, default, help, value_set)
+	return null
+
+
+static func migrate_property(old_property :String, new_property :String, default_value :Variant, help :String, converter := Callable()) -> void:
+	var property := get_property(old_property)
+	if property == null:
+		prints("Migration not possible, property '%s' not found" % old_property)
+		return
+	var value :Variant = converter.call(property.value()) if converter.is_valid() else property.value()
+	ProjectSettings.set_setting(new_property, value)
+	ProjectSettings.set_initial_value(new_property, default_value)
+	set_help(new_property, value, help)
+	ProjectSettings.clear(old_property)
+	prints("Succesfull migrated property '%s' -> '%s' value: %s" % [old_property, new_property, value])
+
+
+static func dump_to_tmp() -> void:
+	ProjectSettings.save_custom("user://project_settings.godot")
+
+
+static func restore_dump_from_tmp() -> void:
+	DirAccess.copy_absolute("user://project_settings.godot", "res://project.godot")

addons/gdUnit4/src/core/GdUnitSignalAwaiter.gd

@@ -0,0 +1,76 @@
+class_name GdUnitSignalAwaiter
+extends RefCounted
+
+signal signal_emitted(action :Variant)
+
+const NO_ARG :Variant = GdUnitConstants.NO_ARG
+
+var _wait_on_idle_frame := false
+var _interrupted := false
+var _time_left :float = 0
+var _timeout_millis :int
+
+
+func _init(timeout_millis :int, wait_on_idle_frame := false) -> void:
+	_timeout_millis = timeout_millis
+	_wait_on_idle_frame = wait_on_idle_frame
+
+
+func _on_signal_emmited(
+	arg0 :Variant = NO_ARG,
+	arg1 :Variant = NO_ARG,
+	arg2 :Variant = NO_ARG,
+	arg3 :Variant = NO_ARG,
+	arg4 :Variant = NO_ARG,
+	arg5 :Variant = NO_ARG,
+	arg6 :Variant = NO_ARG,
+	arg7 :Variant = NO_ARG,
+	arg8 :Variant = NO_ARG,
+	arg9 :Variant = NO_ARG) -> void:
+	var signal_args :Variant = GdArrayTools.filter_value([arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9], NO_ARG)
+	signal_emitted.emit(signal_args)
+
+
+func is_interrupted() -> bool:
+	return _interrupted
+
+
+func elapsed_time() -> float:
+	return _time_left
+
+
+func on_signal(source :Object, signal_name :String, expected_signal_args :Array) -> Variant:
+	# register checked signal to wait for
+	source.connect(signal_name, _on_signal_emmited)
+	# install timeout timer
+	var timer := Timer.new()
+	Engine.get_main_loop().root.add_child(timer)
+	timer.add_to_group("GdUnitTimers")
+	timer.set_one_shot(true)
+	timer.timeout.connect(_do_interrupt, CONNECT_DEFERRED)
+	timer.start(_timeout_millis * 0.001 * Engine.get_time_scale())
+
+	# holds the emited value
+	var value :Variant
+	# wait for signal is emitted or a timeout is happen
+	while true:
+		value = await signal_emitted
+		if _interrupted:
+			break
+		if not (value is Array):
+			value = [value]
+		if expected_signal_args.size() == 0 or GdObjects.equals(value, expected_signal_args):
+			break
+		await Engine.get_main_loop().process_frame
+
+	source.disconnect(signal_name, _on_signal_emmited)
+	_time_left = timer.time_left
+	await Engine.get_main_loop().process_frame
+	if value is Array and value.size() == 1:
+		return value[0]
+	return value
+
+
+func _do_interrupt() -> void:
+	_interrupted = true
+	signal_emitted.emit(null)

addons/gdUnit4/src/core/GdUnitSignalCollector.gd

@@ -0,0 +1,115 @@
+# It connects to all signals of given emitter and collects received signals and arguments
+# The collected signals are cleand finally when the emitter is freed.
+class_name GdUnitSignalCollector
+extends RefCounted
+
+const NO_ARG :Variant = GdUnitConstants.NO_ARG
+const SIGNAL_BLACK_LIST = []#["tree_exiting", "tree_exited", "child_exiting_tree"]
+
+# {
+#	emitter<Object> : {
+#		signal_name<String> : [signal_args<Array>],
+#		...
+#	}
+# }
+var _collected_signals :Dictionary = {}
+
+
+func clear() -> void:
+	for emitter :Object in _collected_signals.keys():
+		if is_instance_valid(emitter):
+			unregister_emitter(emitter)
+
+
+# connect to all possible signals defined by the emitter
+# prepares the signal collection to store received signals and arguments
+func register_emitter(emitter :Object) -> void:
+	if is_instance_valid(emitter):
+		# check emitter is already registerd
+		if _collected_signals.has(emitter):
+			return
+		_collected_signals[emitter] = Dictionary()
+		# connect to 'tree_exiting' of the emitter to finally release all acquired resources/connections.
+		if emitter is Node and !emitter.tree_exiting.is_connected(unregister_emitter):
+			emitter.tree_exiting.connect(unregister_emitter.bind(emitter))
+		# connect to all signals of the emitter we want to collect
+		for signal_def in emitter.get_signal_list():
+			var signal_name :String = signal_def["name"]
+			# set inital collected to empty
+			if not is_signal_collecting(emitter, signal_name):
+				_collected_signals[emitter][signal_name] = Array()
+			if SIGNAL_BLACK_LIST.find(signal_name) != -1:
+				continue
+			if !emitter.is_connected(signal_name, _on_signal_emmited):
+				var err := emitter.connect(signal_name, _on_signal_emmited.bind(emitter, signal_name))
+				if err != OK:
+					push_error("Can't connect to signal %s on %s. Error: %s" % [signal_name, emitter, error_string(err)])
+
+
+# unregister all acquired resources/connections, otherwise it ends up in orphans
+# is called when the emitter is removed from the parent
+func unregister_emitter(emitter :Object) -> void:
+	if is_instance_valid(emitter):
+		for signal_def in emitter.get_signal_list():
+			var signal_name :String = signal_def["name"]
+			if emitter.is_connected(signal_name, _on_signal_emmited):
+				emitter.disconnect(signal_name, _on_signal_emmited.bind(emitter, signal_name))
+		_collected_signals.erase(emitter)
+
+
+# receives the signal from the emitter with all emitted signal arguments and additional the emitter and signal_name as last two arguements
+func _on_signal_emmited(
+	arg0 :Variant= NO_ARG,
+	arg1 :Variant= NO_ARG,
+	arg2 :Variant= NO_ARG,
+	arg3 :Variant= NO_ARG,
+	arg4 :Variant= NO_ARG,
+	arg5 :Variant= NO_ARG,
+	arg6 :Variant= NO_ARG,
+	arg7 :Variant= NO_ARG,
+	arg8 :Variant= NO_ARG,
+	arg9 :Variant= NO_ARG,
+	arg10 :Variant= NO_ARG,
+	arg11 :Variant= NO_ARG) -> void:
+	var signal_args :Array = GdArrayTools.filter_value([arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11], NO_ARG)
+	# extract the emitter and signal_name from the last two arguments (see line 61 where is added)
+	var signal_name :String = signal_args.pop_back()
+	var emitter :Object = signal_args.pop_back()
+	#prints("_on_signal_emmited:", emitter, signal_name, signal_args)
+	if is_signal_collecting(emitter, signal_name):
+		_collected_signals[emitter][signal_name].append(signal_args)
+
+
+func reset_received_signals(emitter :Object, signal_name: String, signal_args :Array) -> void:
+	#_debug_signal_list("before claer");
+	if _collected_signals.has(emitter):
+		var signals_by_emitter :Dictionary = _collected_signals[emitter]
+		if signals_by_emitter.has(signal_name):
+			_collected_signals[emitter][signal_name].erase(signal_args)
+	#_debug_signal_list("after claer");
+
+
+func is_signal_collecting(emitter :Object, signal_name :String) -> bool:
+	return _collected_signals.has(emitter) and _collected_signals[emitter].has(signal_name)
+
+
+func match(emitter :Object, signal_name :String, args :Array) -> bool:
+	#prints("match", signal_name,  _collected_signals[emitter][signal_name]);
+	if _collected_signals.is_empty() or not _collected_signals.has(emitter):
+		return false
+	for received_args :Variant in _collected_signals[emitter][signal_name]:
+		#prints("testing", signal_name, received_args, "vs", args)
+		if GdObjects.equals(received_args, args):
+			return true
+	return false
+
+
+func _debug_signal_list(message :String) -> void:
+	prints("-----", message, "-------")
+	prints("senders {")
+	for emitter :Object in _collected_signals:
+		prints("\t", emitter)
+		for signal_name :String in _collected_signals[emitter]:
+			var args :Variant = _collected_signals[emitter][signal_name]
+			prints("\t\t", signal_name, args)
+	prints("}")

addons/gdUnit4/src/core/GdUnitSignals.gd

@@ -0,0 +1,36 @@
+class_name GdUnitSignals
+extends RefCounted
+
+signal gdunit_client_connected(client_id :int)
+signal gdunit_client_disconnected(client_id :int)
+signal gdunit_client_terminated()
+
+signal gdunit_event(event :GdUnitEvent)
+signal gdunit_event_debug(event :GdUnitEvent)
+signal gdunit_add_test_suite(test_suite :GdUnitTestSuiteDto)
+signal gdunit_message(message :String)
+signal gdunit_report(execution_context_id :int, report :GdUnitReport)
+signal gdunit_set_test_failed(is_failed :bool)
+
+signal gdunit_settings_changed(property :GdUnitProperty)
+
+const META_KEY := "GdUnitSignals"
+
+
+static func instance() -> GdUnitSignals:
+	if Engine.has_meta(META_KEY):
+		return Engine.get_meta(META_KEY)
+	var instance_ := GdUnitSignals.new()
+	Engine.set_meta(META_KEY, instance_)
+	return instance_
+
+
+static func dispose() -> void:
+	var signals := instance()
+	# cleanup connected signals
+	for signal_ in signals.get_signal_list():
+		for connection in signals.get_signal_connection_list(signal_["name"]):
+			connection["signal"].disconnect(connection["callable"])
+	Engine.remove_meta(META_KEY)
+	while signals.get_reference_count() > 0:
+		signals.unreference()

addons/gdUnit4/src/core/GdUnitSingleton.gd

@@ -0,0 +1,53 @@
+################################################################################
+# Provides access to a global accessible singleton
+#
+# This is a workarount to the existing auto load singleton because of some bugs
+# around plugin handling
+################################################################################
+class_name GdUnitSingleton
+extends Object
+
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+const MEATA_KEY := "GdUnitSingletons"
+
+
+static func instance(name :String, clazz :Callable) -> Variant:
+	if Engine.has_meta(name):
+		return Engine.get_meta(name)
+	var singleton :Variant = clazz.call()
+	if  is_instance_of(singleton, RefCounted):
+		push_error("Invalid singleton implementation detected for '%s' is `%s`!" % [name, singleton.get_class()])
+		return
+
+	Engine.set_meta(name, singleton)
+	GdUnitTools.prints_verbose("Register singleton '%s:%s'" % [name, singleton])
+	var singletons :PackedStringArray = Engine.get_meta(MEATA_KEY, PackedStringArray())
+	singletons.append(name)
+	Engine.set_meta(MEATA_KEY, singletons)
+	return singleton
+
+
+static func unregister(p_singleton :String) -> void:
+	var singletons :PackedStringArray = Engine.get_meta(MEATA_KEY, PackedStringArray())
+	if singletons.has(p_singleton):
+		GdUnitTools.prints_verbose("\n	Unregister singleton '%s'" % p_singleton);
+		var index := singletons.find(p_singleton)
+		singletons.remove_at(index)
+		var instance_ :Object = Engine.get_meta(p_singleton)
+		GdUnitTools.prints_verbose("	Free singleton instance '%s:%s'" % [p_singleton, instance_])
+		GdUnitTools.free_instance(instance_)
+		Engine.remove_meta(p_singleton)
+		GdUnitTools.prints_verbose("	Successfully freed '%s'" % p_singleton)
+	Engine.set_meta(MEATA_KEY, singletons)
+
+
+static func dispose() -> void:
+	# use a copy because unregister is modify the singletons array
+	var singletons := PackedStringArray(Engine.get_meta(MEATA_KEY, PackedStringArray()))
+	GdUnitTools.prints_verbose("----------------------------------------------------------------")
+	GdUnitTools.prints_verbose("Cleanup singletons %s" % singletons)
+	for singleton in singletons:
+		unregister(singleton)
+	Engine.remove_meta(MEATA_KEY)
+	GdUnitTools.prints_verbose("----------------------------------------------------------------")

addons/gdUnit4/src/core/GdUnitTestSuiteBuilder.gd

@@ -0,0 +1,18 @@
+class_name GdUnitTestSuiteBuilder
+extends RefCounted
+
+
+static func create(source :Script, line_number :int) -> GdUnitResult:
+	var test_suite_path := GdUnitTestSuiteScanner.resolve_test_suite_path(source.resource_path, GdUnitSettings.test_root_folder())
+	# we need to save and close the testsuite and source if is current opened before modify
+	ScriptEditorControls.save_an_open_script(source.resource_path)
+	ScriptEditorControls.save_an_open_script(test_suite_path, true)
+	if GdObjects.is_cs_script(source):
+		return GdUnit4CSharpApiLoader.create_test_suite(source.resource_path, line_number+1, test_suite_path)
+	var parser := GdScriptParser.new()
+	var lines := source.source_code.split("\n")
+	var current_line := lines[line_number]
+	var func_name := parser.parse_func_name(current_line)
+	if func_name.is_empty():
+		return GdUnitResult.error("No function found at line: %d." % line_number)
+	return GdUnitTestSuiteScanner.create_test_case(test_suite_path, func_name, source.resource_path)

addons/gdUnit4/src/core/GdUnitTestSuiteScanner.gd

@@ -0,0 +1,368 @@
+class_name GdUnitTestSuiteScanner
+extends RefCounted
+
+const TEST_FUNC_TEMPLATE ="""
+
+func test_${func_name}() -> void:
+	# remove this line and complete your test
+	assert_not_yet_implemented()
+"""
+
+
+# we exclude the gdunit source directorys by default
+const exclude_scan_directories = [
+	"res://addons/gdUnit4/bin",
+	"res://addons/gdUnit4/src",
+	"res://reports"]
+
+
+var _script_parser := GdScriptParser.new()
+var _included_resources :PackedStringArray = []
+var _excluded_resources :PackedStringArray = []
+var _expression_runner := GdUnitExpressionRunner.new()
+var _regex_extends_clazz_name := RegEx.create_from_string("extends[\\s]+([\\S]+)")
+
+
+func prescan_testsuite_classes() -> void:
+	# scan and cache extends GdUnitTestSuite by class name an resource paths
+	var script_classes :Array[Dictionary] = ProjectSettings.get_global_class_list()
+	for script_meta in script_classes:
+		var base_class :String = script_meta["base"]
+		var resource_path :String = script_meta["path"]
+		if base_class == "GdUnitTestSuite":
+			_included_resources.append(resource_path)
+		elif ClassDB.class_exists(base_class):
+			_excluded_resources.append(resource_path)
+
+
+func scan(resource_path :String) -> Array[Node]:
+	prescan_testsuite_classes()
+	# if single testsuite requested
+	if FileAccess.file_exists(resource_path):
+		var test_suite := _parse_is_test_suite(resource_path)
+		if test_suite != null:
+			return [test_suite]
+		return [] as Array[Node]
+	var base_dir := DirAccess.open(resource_path)
+	if base_dir == null:
+			prints("Given directory or file does not exists:", resource_path)
+			return []
+	return _scan_test_suites(base_dir, [])
+
+
+func _scan_test_suites(dir :DirAccess, collected_suites :Array[Node]) -> Array[Node]:
+	if exclude_scan_directories.has(dir.get_current_dir()):
+		return collected_suites
+	prints("Scanning for test suites in:", dir.get_current_dir())
+	dir.list_dir_begin() # TODOGODOT4 fill missing arguments https://github.com/godotengine/godot/pull/40547
+	var file_name := dir.get_next()
+	while file_name != "":
+		var resource_path := GdUnitTestSuiteScanner._file(dir, file_name)
+		if dir.current_is_dir():
+			var sub_dir := DirAccess.open(resource_path)
+			if sub_dir != null:
+				_scan_test_suites(sub_dir, collected_suites)
+		else:
+			var time := LocalTime.now()
+			var test_suite := _parse_is_test_suite(resource_path)
+			if test_suite:
+				collected_suites.append(test_suite)
+			if OS.is_stdout_verbose() and time.elapsed_since_ms() > 300:
+				push_warning("Scanning of test-suite '%s' took more than 300ms: " % resource_path, time.elapsed_since())
+		file_name = dir.get_next()
+	return collected_suites
+
+
+static func _file(dir :DirAccess, file_name :String) -> String:
+	var current_dir := dir.get_current_dir()
+	if current_dir.ends_with("/"):
+		return current_dir + file_name
+	return current_dir + "/" + file_name
+
+
+func _parse_is_test_suite(resource_path :String) -> Node:
+	if not GdUnitTestSuiteScanner._is_script_format_supported(resource_path):
+		return null
+	if GdUnit4CSharpApiLoader.is_test_suite(resource_path):
+		return GdUnit4CSharpApiLoader.parse_test_suite(resource_path)
+
+	# We use the global cache to fast scan for test suites.
+	if _excluded_resources.has(resource_path):
+		return null
+	# Check in the global class cache whether the GdUnitTestSuite class has been extended.
+	if _included_resources.has(resource_path):
+		return _parse_test_suite(ResourceLoader.load(resource_path))
+
+	# Otherwise we need to scan manual, we need to exclude classes where direct extends form Godot classes
+	# the resource loader can fail to load e.g. plugin classes with do preload other scripts
+	var extends_from := get_extends_classname(resource_path)
+	# If not extends is defined or extends from a Godot class
+	if extends_from.is_empty() or ClassDB.class_exists(extends_from):
+		return null
+	# Finally, we need to load the class to determine it is a test suite
+	var script := ResourceLoader.load(resource_path)
+	if not GdObjects.is_test_suite(script):
+		return null
+	return _parse_test_suite(ResourceLoader.load(resource_path))
+
+
+static func _is_script_format_supported(resource_path :String) -> bool:
+	var ext := resource_path.get_extension()
+	if ext == "gd":
+		return true
+	return GdUnit4CSharpApiLoader.is_csharp_file(resource_path)
+
+
+func _parse_test_suite(script :GDScript) -> GdUnitTestSuite:
+	if not GdObjects.is_test_suite(script):
+		return null
+
+	var test_suite :GdUnitTestSuite = script.new()
+	test_suite.set_name(GdUnitTestSuiteScanner.parse_test_suite_name(script))
+	# add test cases to test suite and parse test case line nummber
+	var test_case_names := _extract_test_case_names(script)
+	_parse_and_add_test_cases(test_suite, script, test_case_names)
+	# not all test case parsed?
+	# we have to scan the base class to
+	if not test_case_names.is_empty():
+		var base_script :GDScript = test_suite.get_script().get_base_script()
+		while base_script is GDScript:
+			# do not parse testsuite itself
+			if base_script.resource_path.find("GdUnitTestSuite") == -1:
+				_parse_and_add_test_cases(test_suite, base_script, test_case_names)
+			base_script = base_script.get_base_script()
+	return test_suite
+
+
+func _extract_test_case_names(script :GDScript) -> PackedStringArray:
+	var names := PackedStringArray()
+	for method in script.get_script_method_list():
+		var funcName :String = method["name"]
+		if funcName.begins_with("test"):
+			names.append(funcName)
+	return names
+
+
+static func parse_test_suite_name(script :Script) -> String:
+	return script.resource_path.get_file().replace(".gd", "")
+
+
+func _handle_test_suite_arguments(test_suite :Node, script :GDScript, fd :GdFunctionDescriptor) -> void:
+	for arg in fd.args():
+		match arg.name():
+			_TestCase.ARGUMENT_SKIP:
+				var result :Variant = _expression_runner.execute(script, arg.value_as_string())
+				if result is bool:
+					test_suite.__is_skipped = result
+				else:
+					push_error("Test expression '%s' cannot be evaluated because it is not of type bool!" % arg.value_as_string())
+			_TestCase.ARGUMENT_SKIP_REASON:
+				test_suite.__skip_reason = arg.value_as_string()
+			_:
+				push_error("Unsuported argument `%s` found on before() at '%s'!" % [arg.name(), script.resource_path])
+
+
+func _handle_test_case_arguments(test_suite :Node, script :GDScript, fd :GdFunctionDescriptor) -> void:
+	var timeout := _TestCase.DEFAULT_TIMEOUT
+	var iterations := Fuzzer.ITERATION_DEFAULT_COUNT
+	var seed_value := -1
+	var is_skipped := false
+	var skip_reason := "Unknown."
+	var fuzzers :Array[GdFunctionArgument] = []
+	var test := _TestCase.new()
+
+	for arg in fd.args():
+		# verify argument is allowed
+		# is test using fuzzers?
+		if arg.type() == GdObjects.TYPE_FUZZER:
+			fuzzers.append(arg)
+		elif arg.has_default():
+			match arg.name():
+				_TestCase.ARGUMENT_TIMEOUT:
+					timeout = arg.default()
+				_TestCase.ARGUMENT_SKIP:
+					var result :Variant = _expression_runner.execute(script, arg.value_as_string())
+					if result is bool:
+						is_skipped = result
+					else:
+						push_error("Test expression '%s' cannot be evaluated because it is not of type bool!" % arg.value_as_string())
+				_TestCase.ARGUMENT_SKIP_REASON:
+					skip_reason = arg.value_as_string()
+				Fuzzer.ARGUMENT_ITERATIONS:
+					iterations = arg.default()
+				Fuzzer.ARGUMENT_SEED:
+					seed_value = arg.default()
+	# create new test
+	test.configure(fd.name(), fd.line_number(), script.resource_path, timeout, fuzzers, iterations, seed_value)
+	test.set_function_descriptor(fd)
+	test.skip(is_skipped, skip_reason)
+	_validate_argument(fd, test)
+	test_suite.add_child(test)
+
+
+func _parse_and_add_test_cases(test_suite :Node, script :GDScript, test_case_names :PackedStringArray) -> void:
+	var test_cases_to_find := Array(test_case_names)
+	var functions_to_scan := test_case_names.duplicate()
+	functions_to_scan.append("before")
+	var source := _script_parser.load_source_code(script, [script.resource_path])
+	var function_descriptors := _script_parser.parse_functions(source, "", [script.resource_path], functions_to_scan)
+	for fd in function_descriptors:
+		if fd.name() == "before":
+			_handle_test_suite_arguments(test_suite, script, fd)
+		if test_cases_to_find.has(fd.name()):
+			_handle_test_case_arguments(test_suite, script, fd)
+
+
+const TEST_CASE_ARGUMENTS = [_TestCase.ARGUMENT_TIMEOUT, _TestCase.ARGUMENT_SKIP, _TestCase.ARGUMENT_SKIP_REASON, Fuzzer.ARGUMENT_ITERATIONS, Fuzzer.ARGUMENT_SEED]
+
+func _validate_argument(fd :GdFunctionDescriptor, test_case :_TestCase) -> void:
+	if fd.is_parameterized():
+		return
+	for argument in fd.args():
+		if argument.type() == GdObjects.TYPE_FUZZER or argument.name() in TEST_CASE_ARGUMENTS:
+			continue
+		test_case.skip(true, "Unknown test case argument '%s' found." % argument.name())
+
+
+# converts given file name by configured naming convention
+static func _to_naming_convention(file_name :String) -> String:
+	var nc :int = GdUnitSettings.get_setting(GdUnitSettings.TEST_SITE_NAMING_CONVENTION, 0)
+	match nc:
+		GdUnitSettings.NAMING_CONVENTIONS.AUTO_DETECT:
+			if GdObjects.is_snake_case(file_name):
+				return GdObjects.to_snake_case(file_name + "Test")
+			return GdObjects.to_pascal_case(file_name + "Test")
+		GdUnitSettings.NAMING_CONVENTIONS.SNAKE_CASE:
+			return GdObjects.to_snake_case(file_name + "Test")
+		GdUnitSettings.NAMING_CONVENTIONS.PASCAL_CASE:
+			return GdObjects.to_pascal_case(file_name + "Test")
+	push_error("Unexpected case")
+	return "-<Unexpected>-"
+
+
+static func resolve_test_suite_path(source_script_path :String, test_root_folder :String = "test") -> String:
+	var file_name := source_script_path.get_basename().get_file()
+	var suite_name := _to_naming_convention(file_name)
+	if test_root_folder.is_empty() or test_root_folder == "/":
+		return source_script_path.replace(file_name, suite_name)
+
+	# is user tmp
+	if source_script_path.begins_with("user://tmp"):
+		return normalize_path(source_script_path.replace("user://tmp", "user://tmp/" + test_root_folder)).replace(file_name, suite_name)
+
+	# at first look up is the script under a "src" folder located
+	var test_suite_path :String
+	var src_folder := source_script_path.find("/src/")
+	if src_folder != -1:
+		test_suite_path = source_script_path.replace("/src/", "/"+test_root_folder+"/")
+	else:
+		var paths := source_script_path.split("/", false)
+		# is a plugin script?
+		if paths[1] == "addons":
+			test_suite_path = "%s//addons/%s/%s" % [paths[0], paths[2], test_root_folder]
+			# rebuild plugin path
+			for index in range(3, paths.size()):
+				test_suite_path += "/" + paths[index]
+		else:
+			test_suite_path = paths[0] + "//" + test_root_folder
+			for index in range(1, paths.size()):
+				test_suite_path += "/" + paths[index]
+	return normalize_path(test_suite_path).replace(file_name, suite_name)
+
+
+static func normalize_path(path :String) -> String:
+	return path.replace("///", "/")
+
+
+static func create_test_suite(test_suite_path :String, source_path :String) -> GdUnitResult:
+	# create directory if not exists
+	if not DirAccess.dir_exists_absolute(test_suite_path.get_base_dir()):
+		var error_ := DirAccess.make_dir_recursive_absolute(test_suite_path.get_base_dir())
+		if error_ != OK:
+			return GdUnitResult.error("Can't create directoy  at: %s. Error code %s" % [test_suite_path.get_base_dir(), error_])
+	var script := GDScript.new()
+	script.source_code = GdUnitTestSuiteTemplate.build_template(source_path)
+	var error := ResourceSaver.save(script, test_suite_path)
+	if error != OK:
+		return GdUnitResult.error("Can't create test suite at: %s. Error code %s" % [test_suite_path, error])
+	return GdUnitResult.success(test_suite_path)
+
+
+static func get_test_case_line_number(resource_path :String, func_name :String) -> int:
+	var file := FileAccess.open(resource_path, FileAccess.READ)
+	if file != null:
+		var script_parser := GdScriptParser.new()
+		var line_number := 0
+		while not file.eof_reached():
+			var row := GdScriptParser.clean_up_row(file.get_line())
+			line_number += 1
+			# ignore comments and empty lines and not test functions
+			if row.begins_with("#") || row.length() == 0 || row.find("functest") == -1:
+				continue
+			# abort if test case name found
+			if script_parser.parse_func_name(row) == "test_" + func_name:
+				return line_number
+	return -1
+
+
+func get_extends_classname(resource_path :String) -> String:
+	var file := FileAccess.open(resource_path, FileAccess.READ)
+	if file != null:
+		while not file.eof_reached():
+			var row := file.get_line()
+			# skip comments and empty lines
+			if row.begins_with("#") || row.length() == 0:
+				continue
+			# Stop at first function
+			if row.contains("func"):
+				return ""
+			var result := _regex_extends_clazz_name.search(row)
+			if result != null:
+				return result.get_string(1)
+	return ""
+
+
+static func add_test_case(resource_path :String, func_name :String)  -> GdUnitResult:
+	var script := load(resource_path) as GDScript
+	# count all exiting lines and add two as space to add new test case
+	var line_number := count_lines(script) + 2
+	var func_body := TEST_FUNC_TEMPLATE.replace("${func_name}", func_name)
+	if Engine.is_editor_hint():
+		var settings := EditorInterface.get_editor_settings()
+		var ident_type :int = settings.get_setting("text_editor/behavior/indent/type")
+		var ident_size :int = settings.get_setting("text_editor/behavior/indent/size")
+		if ident_type == 1:
+			func_body = func_body.replace("	", "".lpad(ident_size, " "))
+	script.source_code += func_body
+	var error := ResourceSaver.save(script, resource_path)
+	if error != OK:
+		return GdUnitResult.error("Can't add test case at: %s to '%s'. Error code %s" % [func_name, resource_path, error])
+	return GdUnitResult.success({ "path" : resource_path, "line" : line_number})
+
+
+static func count_lines(script : GDScript) -> int:
+	return script.source_code.split("\n").size()
+
+
+static func test_suite_exists(test_suite_path :String) -> bool:
+	return FileAccess.file_exists(test_suite_path)
+
+static func test_case_exists(test_suite_path :String, func_name :String) -> bool:
+	if not test_suite_exists(test_suite_path):
+		return false
+	var script := ResourceLoader.load(test_suite_path) as GDScript
+	for f in script.get_script_method_list():
+		if f["name"] == "test_" + func_name:
+			return true
+	return false
+
+static func create_test_case(test_suite_path :String, func_name :String, source_script_path :String) -> GdUnitResult:
+	if test_case_exists(test_suite_path, func_name):
+		var line_number := get_test_case_line_number(test_suite_path, func_name)
+		return GdUnitResult.success({ "path" : test_suite_path, "line" : line_number})
+
+	if not test_suite_exists(test_suite_path):
+		var result := create_test_suite(test_suite_path, source_script_path)
+		if result.is_error():
+			return result
+	return add_test_case(test_suite_path, func_name)

addons/gdUnit4/src/core/GdUnitTools.gd

@@ -0,0 +1,115 @@
+extends RefCounted
+
+
+static var _richtext_normalize: RegEx
+
+
+static func normalize_text(text :String) -> String:
+	return text.replace("\r", "");
+
+
+static func richtext_normalize(input :String) -> String:
+	if _richtext_normalize == null:
+		_richtext_normalize = to_regex("\\[/?(b|color|bgcolor|right|table|cell).*?\\]")
+	return _richtext_normalize.sub(input, "", true).replace("\r", "")
+
+
+static func to_regex(pattern :String) -> RegEx:
+	var regex := RegEx.new()
+	var err := regex.compile(pattern)
+	if err != OK:
+		push_error("Can't compiling regx '%s'.\n ERROR: %s" % [pattern, error_string(err)])
+	return regex
+
+
+static func prints_verbose(message :String) -> void:
+	if OS.is_stdout_verbose():
+		prints(message)
+
+
+static func free_instance(instance :Variant, is_stdout_verbose :=false) -> bool:
+	if instance is Array:
+		for element :Variant in instance:
+			free_instance(element)
+		instance.clear()
+		return true
+	# do not free an already freed instance
+	if not is_instance_valid(instance):
+		return false
+	# do not free a class refernece
+	if typeof(instance) == TYPE_OBJECT and (instance as Object).is_class("GDScriptNativeClass"):
+		return false
+	if is_stdout_verbose:
+		print_verbose("GdUnit4:gc():free instance ", instance)
+	release_double(instance)
+	if instance is RefCounted:
+		instance.notification(Object.NOTIFICATION_PREDELETE)
+		return true
+	else:
+		# is instance already freed?
+		#if not is_instance_valid(instance) or ClassDB.class_get_property(instance, "new"):
+		#	return false
+		#release_connections(instance)
+		if instance is Timer:
+			instance.stop()
+			instance.call_deferred("free")
+			await Engine.get_main_loop().process_frame
+			return true
+		if instance is Node and instance.get_parent() != null:
+			if is_stdout_verbose:
+				print_verbose("GdUnit4:gc():remove node from parent ",  instance.get_parent(), instance)
+			instance.get_parent().remove_child(instance)
+			instance.set_owner(null)
+		instance.free()
+		return !is_instance_valid(instance)
+
+
+static func _release_connections(instance :Object) -> void:
+	if is_instance_valid(instance):
+		# disconnect from all connected signals to force freeing, otherwise it ends up in orphans
+		for connection in instance.get_incoming_connections():
+			var signal_ :Signal = connection["signal"]
+			var callable_ :Callable = connection["callable"]
+			#prints(instance, connection)
+			#prints("signal", signal_.get_name(), signal_.get_object())
+			#prints("callable", callable_.get_object())
+			if instance.has_signal(signal_.get_name()) and instance.is_connected(signal_.get_name(), callable_):
+				#prints("disconnect signal", signal_.get_name(), callable_)
+				instance.disconnect(signal_.get_name(), callable_)
+	release_timers()
+
+
+static func release_timers() -> void:
+	# we go the new way to hold all gdunit timers in group 'GdUnitTimers'
+	if Engine.get_main_loop().root == null:
+		return
+	for node :Node in Engine.get_main_loop().root.get_children():
+		if is_instance_valid(node) and node.is_in_group("GdUnitTimers"):
+			if is_instance_valid(node):
+				Engine.get_main_loop().root.remove_child(node)
+				node.stop()
+				node.free()
+
+
+# the finally cleaup unfreed resources and singletons
+static func dispose_all() -> void:
+	release_timers()
+	GdUnitSignals.dispose()
+	GdUnitSingleton.dispose()
+
+
+# if instance an mock or spy we need manually freeing the self reference
+static func release_double(instance :Object) -> void:
+	if instance.has_method("__release_double"):
+		instance.call("__release_double")
+
+
+static func clear_push_errors() -> void:
+	var runner :Node = Engine.get_meta("GdUnitRunner")
+	if runner != null:
+		runner.clear_push_errors()
+
+
+static func register_expect_interupted_by_timeout(test_suite :Node, test_case_name :String) -> void:
+	var test_case :Node = test_suite.find_child(test_case_name, false, false)
+	test_case.expect_to_interupt()

addons/gdUnit4/src/core/GodotVersionFixures.gd

@@ -0,0 +1,29 @@
+## This service class contains helpers to wrap Godot functions and handle them carefully depending on the current Godot version
+class_name GodotVersionFixures
+extends RefCounted
+
+
+@warning_ignore("shadowed_global_identifier")
+static func type_convert(value: Variant, type: int) -> Variant:
+	return convert(value, type)
+
+
+@warning_ignore("shadowed_global_identifier")
+static func convert(value: Variant, type: int) -> Variant:
+	return type_convert(value, type)
+
+
+# handle global_position fixed by https://github.com/godotengine/godot/pull/88473
+static func set_event_global_position(event: InputEventMouseMotion, global_position: Vector2) -> void:
+	if Engine.get_version_info().hex >= 0x40202 or Engine.get_version_info().hex == 0x40104:
+		event.global_position = event.position
+	else:
+		event.global_position = global_position
+
+
+# we crash on macOS when using free() inside the plugin _exit_tree
+static func free_fix(instance: Object) -> void:
+	if OS.get_distribution_name().contains("mac"):
+		instance.queue_free()
+	else:
+		instance.free()

addons/gdUnit4/src/core/LocalTime.gd

@@ -0,0 +1,110 @@
+# This class provides Date/Time functionallity to Godot
+class_name LocalTime
+extends Resource
+
+enum TimeUnit {
+	MILLIS = 1,
+	SECOND = 2,
+	MINUTE = 3,
+	HOUR   = 4,
+	DAY    = 5,
+	MONTH  = 6,
+	YEAR   = 7
+}
+
+const SECONDS_PER_MINUTE:int = 60
+const MINUTES_PER_HOUR:int = 60
+const HOURS_PER_DAY:int = 24
+const MILLIS_PER_SECOND:int = 1000
+const MILLIS_PER_MINUTE:int = MILLIS_PER_SECOND * SECONDS_PER_MINUTE
+const MILLIS_PER_HOUR:int   = MILLIS_PER_MINUTE * MINUTES_PER_HOUR
+
+var _time :int
+var _hour :int
+var _minute :int
+var _second :int
+var _millisecond :int
+
+
+static func now() -> LocalTime:
+	return LocalTime.new(_get_system_time_msecs())
+
+
+static func of_unix_time(time_ms :int) -> LocalTime:
+	return LocalTime.new(time_ms)
+
+
+static func local_time(hours :int, minutes :int, seconds :int, milliseconds :int) -> LocalTime:
+	return LocalTime.new(MILLIS_PER_HOUR * hours\
+		+ MILLIS_PER_MINUTE * minutes\
+		+ MILLIS_PER_SECOND * seconds\
+		+ milliseconds)
+
+
+func elapsed_since() -> String:
+	return LocalTime.elapsed(LocalTime._get_system_time_msecs() - _time)
+
+
+func elapsed_since_ms() -> int:
+	return LocalTime._get_system_time_msecs() - _time
+
+
+func plus(time_unit :TimeUnit, value :int) -> LocalTime:
+	var addValue:int = 0
+	match time_unit:
+		TimeUnit.MILLIS:
+			addValue = value
+		TimeUnit.SECOND:
+			addValue = value * MILLIS_PER_SECOND
+		TimeUnit.MINUTE:
+			addValue = value * MILLIS_PER_MINUTE
+		TimeUnit.HOUR:
+			addValue = value * MILLIS_PER_HOUR
+	_init(_time + addValue)
+	return self
+
+
+static func elapsed(p_time_ms :int) -> String:
+	var local_time_ := LocalTime.new(p_time_ms)
+	if local_time_._hour > 0:
+		return "%dh %dmin %ds %dms" % [local_time_._hour, local_time_._minute, local_time_._second, local_time_._millisecond]
+	if local_time_._minute > 0:
+		return "%dmin %ds %dms" % [local_time_._minute, local_time_._second, local_time_._millisecond]
+	if local_time_._second > 0:
+		return "%ds %dms" % [local_time_._second, local_time_._millisecond]
+	return "%dms" % local_time_._millisecond
+
+
+@warning_ignore("integer_division")
+# create from epoch timestamp in ms
+func _init(time :int) -> void:
+	_time = time
+	_hour  =  (time / MILLIS_PER_HOUR) % 24
+	_minute =  (time / MILLIS_PER_MINUTE) % 60
+	_second =  (time / MILLIS_PER_SECOND) % 60
+	_millisecond = time % 1000
+
+
+func hour() -> int:
+	return _hour
+
+
+func minute() -> int:
+	return _minute
+
+
+func second() -> int:
+	return _second
+
+
+func millis() -> int:
+	return _millisecond
+
+
+func _to_string() -> String:
+	return "%02d:%02d:%02d.%03d" % [_hour, _minute, _second, _millisecond]
+
+
+# wraper to old OS.get_system_time_msecs() function
+static func _get_system_time_msecs() -> int:
+	return Time.get_unix_time_from_system() * 1000 as int

addons/gdUnit4/src/core/_TestCase.gd

@@ -0,0 +1,238 @@
+class_name _TestCase
+extends Node
+
+signal completed()
+
+# default timeout 5min
+const DEFAULT_TIMEOUT := -1
+const ARGUMENT_TIMEOUT := "timeout"
+const ARGUMENT_SKIP := "do_skip"
+const ARGUMENT_SKIP_REASON := "skip_reason"
+
+var _iterations: int = 1
+var _current_iteration: int = -1
+var _seed: int
+var _fuzzers: Array[GdFunctionArgument] = []
+var _test_param_index := -1
+var _line_number: int = -1
+var _script_path: String
+var _skipped := false
+var _skip_reason := ""
+var _expect_to_interupt := false
+var _timer: Timer
+var _interupted: bool = false
+var _failed := false
+var _report: GdUnitReport = null
+var _parameter_set_resolver: GdUnitTestParameterSetResolver
+var _is_disposed := false
+
+var timeout: int = DEFAULT_TIMEOUT:
+	set(value):
+		timeout = value
+	get:
+		if timeout == DEFAULT_TIMEOUT:
+			timeout = GdUnitSettings.test_timeout()
+		return timeout
+
+
+@warning_ignore("shadowed_variable_base_class")
+func configure(p_name: String, p_line_number: int, p_script_path: String, p_timeout: int=DEFAULT_TIMEOUT, p_fuzzers: Array[GdFunctionArgument]=[], p_iterations: int=1, p_seed: int=-1) -> _TestCase:
+	set_name(p_name)
+	_line_number = p_line_number
+	_fuzzers = p_fuzzers
+	_iterations = p_iterations
+	_seed = p_seed
+	_script_path = p_script_path
+	timeout = p_timeout
+	return self
+
+
+func execute(p_test_parameter := Array(), p_iteration := 0) -> void:
+	_failure_received(false)
+	_current_iteration = p_iteration - 1
+	if _current_iteration == - 1:
+		_set_failure_handler()
+		set_timeout()
+	if not p_test_parameter.is_empty():
+		update_fuzzers(p_test_parameter, p_iteration)
+		_execute_test_case(name, p_test_parameter)
+	else:
+		_execute_test_case(name, [])
+	await completed
+
+
+func execute_paramaterized(p_test_parameter: Array) -> void:
+	_failure_received(false)
+	set_timeout()
+	# We need here to add a empty array to override the `test_parameters` to prevent initial "default" parameters from being used.
+	# This prevents objects in the argument list from being unnecessarily re-instantiated.
+	var test_parameters := p_test_parameter.duplicate() # is strictly need to duplicate the paramters before extend
+	test_parameters.append([])
+	_execute_test_case(name, test_parameters)
+	await completed
+
+
+func dispose() -> void:
+	if _is_disposed:
+		return
+	_is_disposed = true
+	Engine.remove_meta("GD_TEST_FAILURE")
+	stop_timer()
+	_remove_failure_handler()
+	_fuzzers.clear()
+	_report = null
+
+
+@warning_ignore("shadowed_variable_base_class", "redundant_await")
+func _execute_test_case(name: String, test_parameter: Array) -> void:
+	# needs at least on await otherwise it breaks the awaiting chain
+	await get_parent().callv(name, test_parameter)
+	await Engine.get_main_loop().process_frame
+	completed.emit()
+
+
+func update_fuzzers(input_values: Array, iteration: int) -> void:
+	for fuzzer :Variant in input_values:
+		if fuzzer is Fuzzer:
+			fuzzer._iteration_index = iteration + 1
+
+
+func set_timeout() -> void:
+	if is_instance_valid(_timer):
+		return
+	var time: float = timeout / 1000.0
+	_timer = Timer.new()
+	add_child(_timer)
+	_timer.set_name("gdunit_test_case_timer_%d" % _timer.get_instance_id())
+	_timer.timeout.connect(func do_interrupt() -> void:
+		if is_fuzzed():
+			_report = GdUnitReport.new().create(GdUnitReport.INTERUPTED, line_number(), GdAssertMessages.fuzzer_interuped(_current_iteration, "timedout"))
+		else:
+			_report = GdUnitReport.new().create(GdUnitReport.INTERUPTED, line_number(), GdAssertMessages.test_timeout(timeout))
+		_interupted = true
+		completed.emit()
+		, CONNECT_DEFERRED)
+	_timer.set_one_shot(true)
+	_timer.set_wait_time(time)
+	_timer.set_autostart(false)
+	_timer.start()
+
+
+func _set_failure_handler() -> void:
+	if not GdUnitSignals.instance().gdunit_set_test_failed.is_connected(_failure_received):
+		GdUnitSignals.instance().gdunit_set_test_failed.connect(_failure_received)
+
+
+func _remove_failure_handler() -> void:
+	if GdUnitSignals.instance().gdunit_set_test_failed.is_connected(_failure_received):
+		GdUnitSignals.instance().gdunit_set_test_failed.disconnect(_failure_received)
+
+
+func _failure_received(is_failed: bool) -> void:
+	# is already failed?
+	if _failed:
+		return
+	_failed = is_failed
+	Engine.set_meta("GD_TEST_FAILURE", is_failed)
+
+
+func stop_timer() -> void:
+	# finish outstanding timeouts
+	if is_instance_valid(_timer):
+		_timer.stop()
+		_timer.call_deferred("free")
+		_timer = null
+
+
+func expect_to_interupt() -> void:
+	_expect_to_interupt = true
+
+
+func is_interupted() -> bool:
+	return _interupted
+
+
+func is_expect_interupted() -> bool:
+	return _expect_to_interupt
+
+
+func is_parameterized() -> bool:
+	return _parameter_set_resolver.is_parameterized()
+
+
+func is_skipped() -> bool:
+	return _skipped
+
+
+func report() -> GdUnitReport:
+	return _report
+
+
+func skip_info() -> String:
+	return _skip_reason
+
+
+func line_number() -> int:
+	return _line_number
+
+
+func iterations() -> int:
+	return _iterations
+
+
+func seed_value() -> int:
+	return _seed
+
+
+func is_fuzzed() -> bool:
+	return not _fuzzers.is_empty()
+
+
+func fuzzer_arguments() -> Array[GdFunctionArgument]:
+	return _fuzzers
+
+
+func script_path() -> String:
+	return _script_path
+
+
+func ResourcePath() -> String:
+	return _script_path
+
+
+func generate_seed() -> void:
+	if _seed != -1:
+		seed(_seed)
+
+
+func skip(skipped: bool, reason: String="") -> void:
+	_skipped = skipped
+	_skip_reason = reason
+
+
+func set_function_descriptor(fd: GdFunctionDescriptor) -> void:
+	_parameter_set_resolver = GdUnitTestParameterSetResolver.new(fd)
+
+
+func set_test_parameter_index(index: int) -> void:
+	_test_param_index = index
+
+
+func test_parameter_index() -> int:
+	return _test_param_index
+
+
+func test_case_names() -> PackedStringArray:
+	return _parameter_set_resolver.build_test_case_names(self)
+
+
+func load_parameter_sets() -> Array:
+	return _parameter_set_resolver.load_parameter_sets(self, true)
+
+
+func parameter_set_resolver() -> GdUnitTestParameterSetResolver:
+	return _parameter_set_resolver
+
+
+func _to_string() -> String:
+	return "%s :%d (%dms)" % [get_name(), _line_number, timeout]

addons/gdUnit4/src/core/command/GdUnitCommand.gd

@@ -0,0 +1,41 @@
+class_name GdUnitCommand
+extends RefCounted
+
+
+func _init(p_name :String, p_is_enabled: Callable, p_runnable: Callable, p_shortcut :GdUnitShortcut.ShortCut = GdUnitShortcut.ShortCut.NONE) -> void:
+	assert(p_name != null, "(%s) missing parameter 'name'" % p_name)
+	assert(p_is_enabled != null, "(%s) missing parameter 'is_enabled'" % p_name)
+	assert(p_runnable != null, "(%s) missing parameter 'runnable'" % p_name)
+	assert(p_shortcut != null, "(%s) missing parameter 'shortcut'" % p_name)
+	self.name = p_name
+	self.is_enabled = p_is_enabled
+	self.shortcut = p_shortcut
+	self.runnable = p_runnable
+
+
+var name: String:
+	set(value):
+		name = value
+	get:
+		return name
+
+
+var shortcut: GdUnitShortcut.ShortCut:
+	set(value):
+		shortcut = value
+	get:
+		return shortcut
+
+
+var is_enabled: Callable:
+	set(value):
+		is_enabled = value
+	get:
+		return is_enabled
+
+
+var runnable: Callable:
+	set(value):
+		runnable = value
+	get:
+		return runnable

addons/gdUnit4/src/core/command/GdUnitCommandHandler.gd

@@ -0,0 +1,364 @@
+class_name GdUnitCommandHandler
+extends Object
+
+signal gdunit_runner_start()
+signal gdunit_runner_stop(client_id :int)
+
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+const CMD_RUN_OVERALL = "Debug Overall TestSuites"
+const CMD_RUN_TESTCASE = "Run TestCases"
+const CMD_RUN_TESTCASE_DEBUG = "Run TestCases (Debug)"
+const CMD_RUN_TESTSUITE = "Run TestSuites"
+const CMD_RUN_TESTSUITE_DEBUG = "Run TestSuites (Debug)"
+const CMD_RERUN_TESTS = "ReRun Tests"
+const CMD_RERUN_TESTS_DEBUG = "ReRun Tests (Debug)"
+const CMD_STOP_TEST_RUN = "Stop Test Run"
+const CMD_CREATE_TESTCASE = "Create TestCase"
+
+const SETTINGS_SHORTCUT_MAPPING := {
+	"N/A" : GdUnitShortcut.ShortCut.NONE,
+	GdUnitSettings.SHORTCUT_INSPECTOR_RERUN_TEST : GdUnitShortcut.ShortCut.RERUN_TESTS,
+	GdUnitSettings.SHORTCUT_INSPECTOR_RERUN_TEST_DEBUG : GdUnitShortcut.ShortCut.RERUN_TESTS_DEBUG,
+	GdUnitSettings.SHORTCUT_INSPECTOR_RUN_TEST_OVERALL : GdUnitShortcut.ShortCut.RUN_TESTS_OVERALL,
+	GdUnitSettings.SHORTCUT_INSPECTOR_RUN_TEST_STOP : GdUnitShortcut.ShortCut.STOP_TEST_RUN,
+	GdUnitSettings.SHORTCUT_EDITOR_RUN_TEST : GdUnitShortcut.ShortCut.RUN_TESTCASE,
+	GdUnitSettings.SHORTCUT_EDITOR_RUN_TEST_DEBUG : GdUnitShortcut.ShortCut.RUN_TESTCASE_DEBUG,
+	GdUnitSettings.SHORTCUT_EDITOR_CREATE_TEST : GdUnitShortcut.ShortCut.CREATE_TEST,
+	GdUnitSettings.SHORTCUT_FILESYSTEM_RUN_TEST : GdUnitShortcut.ShortCut.RUN_TESTCASE,
+	GdUnitSettings.SHORTCUT_FILESYSTEM_RUN_TEST_DEBUG : GdUnitShortcut.ShortCut.RUN_TESTCASE_DEBUG
+}
+
+# the current test runner config
+var _runner_config := GdUnitRunnerConfig.new()
+
+# holds the current connected gdUnit runner client id
+var _client_id :int
+# if no debug mode we have an process id
+var _current_runner_process_id :int = 0
+# hold is current an test running
+var _is_running :bool = false
+# holds if the current running tests started in debug mode
+var _running_debug_mode :bool
+
+var _commands := {}
+var _shortcuts := {}
+
+
+static func instance() -> GdUnitCommandHandler:
+	return GdUnitSingleton.instance("GdUnitCommandHandler", func() -> GdUnitCommandHandler: return GdUnitCommandHandler.new())
+
+
+func _init() -> void:
+	assert_shortcut_mappings(SETTINGS_SHORTCUT_MAPPING)
+
+	GdUnitSignals.instance().gdunit_event.connect(_on_event)
+	GdUnitSignals.instance().gdunit_client_connected.connect(_on_client_connected)
+	GdUnitSignals.instance().gdunit_client_disconnected.connect(_on_client_disconnected)
+	GdUnitSignals.instance().gdunit_settings_changed.connect(_on_settings_changed)
+	# preload previous test execution
+	_runner_config.load_config()
+
+	init_shortcuts()
+	var is_running := func(_script :Script) -> bool: return _is_running
+	var is_not_running := func(_script :Script) -> bool: return !_is_running
+	register_command(GdUnitCommand.new(CMD_RUN_OVERALL, is_not_running, cmd_run_overall.bind(true), GdUnitShortcut.ShortCut.RUN_TESTS_OVERALL))
+	register_command(GdUnitCommand.new(CMD_RUN_TESTCASE, is_not_running, cmd_editor_run_test.bind(false), GdUnitShortcut.ShortCut.RUN_TESTCASE))
+	register_command(GdUnitCommand.new(CMD_RUN_TESTCASE_DEBUG, is_not_running, cmd_editor_run_test.bind(true), GdUnitShortcut.ShortCut.RUN_TESTCASE_DEBUG))
+	register_command(GdUnitCommand.new(CMD_RUN_TESTSUITE, is_not_running, cmd_run_test_suites.bind(false)))
+	register_command(GdUnitCommand.new(CMD_RUN_TESTSUITE_DEBUG, is_not_running, cmd_run_test_suites.bind(true)))
+	register_command(GdUnitCommand.new(CMD_RERUN_TESTS, is_not_running, cmd_run.bind(false), GdUnitShortcut.ShortCut.RERUN_TESTS))
+	register_command(GdUnitCommand.new(CMD_RERUN_TESTS_DEBUG, is_not_running, cmd_run.bind(true), GdUnitShortcut.ShortCut.RERUN_TESTS_DEBUG))
+	register_command(GdUnitCommand.new(CMD_CREATE_TESTCASE, is_not_running, cmd_create_test, GdUnitShortcut.ShortCut.CREATE_TEST))
+	register_command(GdUnitCommand.new(CMD_STOP_TEST_RUN, is_running, cmd_stop.bind(_client_id), GdUnitShortcut.ShortCut.STOP_TEST_RUN))
+
+
+	# do not reschedule inside of test run (called on GdUnitCommandHandlerTest)
+	if Engine.has_meta("GdUnitRunner"):
+		return
+	# schedule discover tests if enabled
+	if GdUnitSettings.is_test_discover_enabled():
+		var timer :SceneTreeTimer = Engine.get_main_loop().create_timer(5)
+		timer.timeout.connect(cmd_discover_tests)
+
+
+func _notification(what :int) -> void:
+	if what == NOTIFICATION_PREDELETE:
+		_commands.clear()
+		_shortcuts.clear()
+
+
+func _do_process() -> void:
+	check_test_run_stopped_manually()
+
+
+# is checking if the user has press the editor stop scene
+func check_test_run_stopped_manually() -> void:
+	if is_test_running_but_stop_pressed():
+		if GdUnitSettings.is_verbose_assert_warnings():
+			push_warning("Test Runner scene was stopped manually, force stopping the current test run!")
+		cmd_stop(_client_id)
+
+
+func is_test_running_but_stop_pressed() -> bool:
+	return _running_debug_mode and _is_running and not EditorInterface.is_playing_scene()
+
+
+func assert_shortcut_mappings(mappings :Dictionary) -> void:
+	for shortcut :int in GdUnitShortcut.ShortCut.values():
+		assert(mappings.values().has(shortcut), "missing settings mapping for shortcut '%s'!" % GdUnitShortcut.ShortCut.keys()[shortcut])
+
+
+func init_shortcuts() -> void:
+	for shortcut :int in GdUnitShortcut.ShortCut.values():
+		if shortcut == GdUnitShortcut.ShortCut.NONE:
+			continue
+		var property_name :String = SETTINGS_SHORTCUT_MAPPING.find_key(shortcut)
+		var property := GdUnitSettings.get_property(property_name)
+		var keys := GdUnitShortcut.default_keys(shortcut)
+		if property != null:
+			keys = property.value()
+		var inputEvent := create_shortcut_input_even(keys)
+		register_shortcut(shortcut, inputEvent)
+
+
+func create_shortcut_input_even(key_codes : PackedInt32Array) -> InputEventKey:
+	var inputEvent :InputEventKey = InputEventKey.new()
+	inputEvent.pressed = true
+	for key_code in key_codes:
+		match key_code:
+			KEY_ALT:
+				inputEvent.alt_pressed = true
+			KEY_SHIFT:
+				inputEvent.shift_pressed = true
+			KEY_CTRL:
+				inputEvent.ctrl_pressed = true
+			_:
+				inputEvent.keycode = key_code as Key
+				inputEvent.physical_keycode = key_code as Key
+	return inputEvent
+
+
+func register_shortcut(p_shortcut :GdUnitShortcut.ShortCut, p_input_event :InputEvent) -> void:
+	GdUnitTools.prints_verbose("register shortcut: '%s' to '%s'" % [GdUnitShortcut.ShortCut.keys()[p_shortcut], p_input_event.as_text()])
+	var shortcut := Shortcut.new()
+	shortcut.set_events([p_input_event])
+	var command_name :String = get_shortcut_command(p_shortcut)
+	_shortcuts[p_shortcut] = GdUnitShortcutAction.new(p_shortcut, shortcut, command_name)
+
+
+func get_shortcut(shortcut_type :GdUnitShortcut.ShortCut) -> Shortcut:
+	return get_shortcut_action(shortcut_type).shortcut
+
+
+func get_shortcut_action(shortcut_type :GdUnitShortcut.ShortCut) -> GdUnitShortcutAction:
+	return _shortcuts.get(shortcut_type)
+
+
+func get_shortcut_command(p_shortcut :GdUnitShortcut.ShortCut) -> String:
+	return GdUnitShortcut.CommandMapping.get(p_shortcut, "unknown command")
+
+
+func register_command(p_command :GdUnitCommand) -> void:
+	_commands[p_command.name] = p_command
+
+
+func command(cmd_name :String) -> GdUnitCommand:
+	return _commands.get(cmd_name)
+
+
+func cmd_run_test_suites(test_suite_paths :PackedStringArray, debug :bool, rerun := false) -> void:
+	# create new runner runner_config for fresh run otherwise use saved one
+	if not rerun:
+		var result := _runner_config.clear()\
+			.add_test_suites(test_suite_paths)\
+			.save_config()
+		if result.is_error():
+			push_error(result.error_message())
+			return
+	cmd_run(debug)
+
+
+func cmd_run_test_case(test_suite_resource_path :String, test_case :String, test_param_index :int, debug :bool, rerun := false) -> void:
+	# create new runner config for fresh run otherwise use saved one
+	if not rerun:
+		var result := _runner_config.clear()\
+			.add_test_case(test_suite_resource_path, test_case, test_param_index)\
+			.save_config()
+		if result.is_error():
+			push_error(result.error_message())
+			return
+	cmd_run(debug)
+
+
+func cmd_run_overall(debug :bool) -> void:
+	var test_suite_paths :PackedStringArray = GdUnitCommandHandler.scan_test_directorys("res://" , GdUnitSettings.test_root_folder(), [])
+	var result := _runner_config.clear()\
+		.add_test_suites(test_suite_paths)\
+		.save_config()
+	if result.is_error():
+		push_error(result.error_message())
+		return
+	cmd_run(debug)
+
+
+func cmd_run(debug :bool) -> void:
+	# don't start is already running
+	if _is_running:
+		return
+	# save current selected excution config
+	var result := _runner_config.set_server_port(Engine.get_meta("gdunit_server_port")).save_config()
+	if result.is_error():
+		push_error(result.error_message())
+		return
+	# before start we have to save all changes
+	ScriptEditorControls.save_all_open_script()
+	gdunit_runner_start.emit()
+	_current_runner_process_id = -1
+	_running_debug_mode = debug
+	if debug:
+		run_debug_mode()
+	else:
+		run_release_mode()
+
+
+func cmd_stop(client_id :int) -> void:
+	# don't stop if is already stopped
+	if not _is_running:
+		return
+	_is_running = false
+	gdunit_runner_stop.emit(client_id)
+	if _running_debug_mode:
+		EditorInterface.stop_playing_scene()
+	else: if _current_runner_process_id > 0:
+		var result := OS.kill(_current_runner_process_id)
+		if result != OK:
+			push_error("ERROR checked stopping GdUnit Test Runner. error code: %s" % result)
+	_current_runner_process_id = -1
+
+
+func cmd_editor_run_test(debug :bool) -> void:
+	var cursor_line := active_base_editor().get_caret_line()
+	#run test case?
+	var regex := RegEx.new()
+	regex.compile("(^func[ ,\t])(test_[a-zA-Z0-9_]*)")
+	var result := regex.search(active_base_editor().get_line(cursor_line))
+	if result:
+		var func_name := result.get_string(2).strip_edges()
+		prints("Run test:", func_name, "debug", debug)
+		if func_name.begins_with("test_"):
+			cmd_run_test_case(active_script().resource_path, func_name, -1, debug)
+			return
+	# otherwise run the full test suite
+	var selected_test_suites := [active_script().resource_path]
+	cmd_run_test_suites(selected_test_suites, debug)
+
+
+func cmd_create_test() -> void:
+	var cursor_line := active_base_editor().get_caret_line()
+	var result := GdUnitTestSuiteBuilder.create(active_script(), cursor_line)
+	if result.is_error():
+		# show error dialog
+		push_error("Failed to create test case: %s" % result.error_message())
+		return
+	var info := result.value() as Dictionary
+	ScriptEditorControls.edit_script(info.get("path"), info.get("line"))
+
+
+func cmd_discover_tests() -> void:
+	await GdUnitTestDiscoverer.run()
+
+
+static func scan_test_directorys(base_directory :String, test_directory: String, test_suite_paths :PackedStringArray) -> PackedStringArray:
+	print_verbose("Scannning for test directory '%s' at %s" % [test_directory, base_directory])
+	for directory in DirAccess.get_directories_at(base_directory):
+		if directory.begins_with("."):
+			continue
+		var current_directory := normalize_path(base_directory + "/" + directory)
+		if GdUnitTestSuiteScanner.exclude_scan_directories.has(current_directory):
+			continue
+		if match_test_directory(directory, test_directory):
+			test_suite_paths.append(current_directory)
+		else:
+			scan_test_directorys(current_directory, test_directory, test_suite_paths)
+	return test_suite_paths
+
+
+static func normalize_path(path :String) -> String:
+	return path.replace("///", "//")
+
+
+static func match_test_directory(directory :String, test_directory: String) -> bool:
+	return directory == test_directory or test_directory.is_empty() or test_directory == "/" or test_directory == "res://"
+
+
+func run_debug_mode() -> void:
+	EditorInterface.play_custom_scene("res://addons/gdUnit4/src/core/GdUnitRunner.tscn")
+	_is_running = true
+
+
+func run_release_mode() -> void:
+	var arguments := Array()
+	if OS.is_stdout_verbose():
+		arguments.append("--verbose")
+	arguments.append("--no-window")
+	arguments.append("--path")
+	arguments.append(ProjectSettings.globalize_path("res://"))
+	arguments.append("res://addons/gdUnit4/src/core/GdUnitRunner.tscn")
+	_current_runner_process_id = OS.create_process(OS.get_executable_path(), arguments, false);
+	_is_running = true
+
+
+func active_base_editor() -> TextEdit:
+	return EditorInterface.get_script_editor().get_current_editor().get_base_editor()
+
+
+func active_script() -> Script:
+	return EditorInterface.get_script_editor().get_current_script()
+
+
+
+################################################################################
+# signals handles
+################################################################################
+func _on_event(event :GdUnitEvent) -> void:
+	if event.type() == GdUnitEvent.STOP:
+		cmd_stop(_client_id)
+
+
+func _on_stop_pressed() -> void:
+	cmd_stop(_client_id)
+
+
+func _on_run_pressed(debug := false) -> void:
+	cmd_run(debug)
+
+
+func _on_run_overall_pressed(_debug := false) -> void:
+	cmd_run_overall(true)
+
+
+func _on_settings_changed(property :GdUnitProperty) -> void:
+	if SETTINGS_SHORTCUT_MAPPING.has(property.name()):
+		var shortcut :GdUnitShortcut.ShortCut = SETTINGS_SHORTCUT_MAPPING.get(property.name())
+		var input_event := create_shortcut_input_even(property.value())
+		prints("Shortcut changed: '%s' to '%s'" % [GdUnitShortcut.ShortCut.keys()[shortcut], input_event.as_text()])
+		register_shortcut(shortcut, input_event)
+	if property.name() == GdUnitSettings.TEST_DISCOVER_ENABLED:
+		var timer :SceneTreeTimer = Engine.get_main_loop().create_timer(3)
+		timer.timeout.connect(cmd_discover_tests)
+
+
+################################################################################
+# Network stuff
+################################################################################
+func _on_client_connected(client_id :int) -> void:
+	_client_id = client_id
+
+
+func _on_client_disconnected(client_id :int) -> void:
+	# only stops is not in debug mode running and the current client
+	if not _running_debug_mode and _client_id == client_id:
+		cmd_stop(client_id)
+	_client_id = -1

addons/gdUnit4/src/core/command/GdUnitShortcut.gd

@@ -0,0 +1,58 @@
+class_name GdUnitShortcut
+extends RefCounted
+
+
+enum ShortCut {
+	NONE,
+	RUN_TESTS_OVERALL,
+	RUN_TESTCASE,
+	RUN_TESTCASE_DEBUG,
+	RERUN_TESTS,
+	RERUN_TESTS_DEBUG,
+	STOP_TEST_RUN,
+	CREATE_TEST,
+}
+
+
+const CommandMapping = {
+	ShortCut.RUN_TESTS_OVERALL: GdUnitCommandHandler.CMD_RUN_OVERALL,
+	ShortCut.RUN_TESTCASE: GdUnitCommandHandler.CMD_RUN_TESTCASE,
+	ShortCut.RUN_TESTCASE_DEBUG: GdUnitCommandHandler.CMD_RUN_TESTCASE_DEBUG,
+	ShortCut.RERUN_TESTS: GdUnitCommandHandler.CMD_RERUN_TESTS,
+	ShortCut.RERUN_TESTS_DEBUG: GdUnitCommandHandler.CMD_RERUN_TESTS_DEBUG,
+	ShortCut.STOP_TEST_RUN: GdUnitCommandHandler.CMD_STOP_TEST_RUN,
+	ShortCut.CREATE_TEST: GdUnitCommandHandler.CMD_CREATE_TESTCASE,
+}
+
+
+const DEFAULTS_MACOS := {
+	ShortCut.NONE : [],
+	ShortCut.RUN_TESTCASE : [Key.KEY_META, Key.KEY_ALT, Key.KEY_F5],
+	ShortCut.RUN_TESTCASE_DEBUG : [Key.KEY_META, Key.KEY_ALT, Key.KEY_F6],
+	ShortCut.RUN_TESTS_OVERALL : [Key.KEY_META, Key.KEY_F7],
+	ShortCut.STOP_TEST_RUN : [Key.KEY_META, Key.KEY_F8],
+	ShortCut.RERUN_TESTS : [Key.KEY_META, Key.KEY_F5],
+	ShortCut.RERUN_TESTS_DEBUG : [Key.KEY_META, Key.KEY_F6],
+	ShortCut.CREATE_TEST : [Key.KEY_META, Key.KEY_ALT, Key.KEY_F10],
+}
+
+const DEFAULTS_WINDOWS := {
+	ShortCut.NONE : [],
+	ShortCut.RUN_TESTCASE : [Key.KEY_CTRL, Key.KEY_ALT, Key.KEY_F5],
+	ShortCut.RUN_TESTCASE_DEBUG : [Key.KEY_CTRL,Key.KEY_ALT,  Key.KEY_F6],
+	ShortCut.RUN_TESTS_OVERALL : [Key.KEY_CTRL, Key.KEY_F7],
+	ShortCut.STOP_TEST_RUN : [Key.KEY_CTRL, Key.KEY_F8],
+	ShortCut.RERUN_TESTS : [Key.KEY_CTRL, Key.KEY_F5],
+	ShortCut.RERUN_TESTS_DEBUG : [Key.KEY_CTRL, Key.KEY_F6],
+	ShortCut.CREATE_TEST : [Key.KEY_CTRL, Key.KEY_ALT, Key.KEY_F10],
+}
+
+
+static func default_keys(shortcut :ShortCut) -> PackedInt32Array:
+	match OS.get_name().to_lower():
+		'windows':
+			return DEFAULTS_WINDOWS[shortcut]
+		'macos':
+			return DEFAULTS_MACOS[shortcut]
+		_:
+			return DEFAULTS_WINDOWS[shortcut]

addons/gdUnit4/src/core/command/GdUnitShortcutAction.gd

@@ -0,0 +1,36 @@
+class_name GdUnitShortcutAction
+extends RefCounted
+
+
+func _init(p_type :GdUnitShortcut.ShortCut, p_shortcut :Shortcut, p_command :String) -> void:
+	assert(p_type != null, "missing parameter 'type'")
+	assert(p_shortcut != null, "missing parameter 'shortcut'")
+	assert(p_command != null, "missing parameter 'command'")
+	self.type = p_type
+	self.shortcut = p_shortcut
+	self.command = p_command
+
+
+var type: GdUnitShortcut.ShortCut:
+	set(value):
+		type = value
+	get:
+		return type
+
+
+var shortcut: Shortcut:
+	set(value):
+		shortcut = value
+	get:
+		return shortcut
+
+
+var command: String:
+	set(value):
+		command = value
+	get:
+		return command
+
+
+func _to_string() -> String:
+	return "GdUnitShortcutAction: %s (%s) -> %s" % [GdUnitShortcut.ShortCut.keys()[type], shortcut.get_as_text(), command]

addons/gdUnit4/src/core/discovery/GdUnitTestDiscoverGuard.gd

@@ -0,0 +1,86 @@
+extends RefCounted
+
+# contains all tracked test suites where discovered since editor start
+# key : test suite resource_path
+# value: the list of discovered test case names
+var _discover_cache := {}
+
+
+func _init() -> void:
+	# Register for discovery events to sync the cache
+	GdUnitSignals.instance().gdunit_add_test_suite.connect(sync_cache)
+
+
+func sync_cache(dto :GdUnitTestSuiteDto) -> void:
+	var resource_path := dto.path()
+	var discovered_test_cases :Array[String] = []
+	for test_case in dto.test_cases():
+		discovered_test_cases.append(test_case.name())
+	_discover_cache[resource_path] = discovered_test_cases
+
+
+func discover(script: Script) -> void:
+	if GdObjects.is_test_suite(script):
+		# a new test suite is discovered
+		if not _discover_cache.has(script.resource_path):
+			var scanner := GdUnitTestSuiteScanner.new()
+			var test_suite := scanner._parse_test_suite(script)
+			var dto :GdUnitTestSuiteDto = GdUnitTestSuiteDto.of(test_suite)
+			GdUnitSignals.instance().gdunit_event.emit(GdUnitEventTestDiscoverTestSuiteAdded.new(script.resource_path, test_suite.get_name(), dto))
+			sync_cache(dto)
+			test_suite.queue_free()
+			return
+
+		var tests_added :Array[String] = []
+		var tests_removed := PackedStringArray()
+		var script_test_cases := extract_test_functions(script)
+		var discovered_test_cases :Array[String] = _discover_cache.get(script.resource_path, [] as Array[String])
+
+		# first detect removed/renamed tests
+		for test_case in discovered_test_cases:
+			if not script_test_cases.has(test_case):
+				tests_removed.append(test_case)
+		# second detect new added tests
+		for test_case in script_test_cases:
+			if not discovered_test_cases.has(test_case):
+				tests_added.append(test_case)
+
+		# finally notify changes to the inspector
+		if not tests_removed.is_empty() or not tests_added.is_empty():
+			var scanner := GdUnitTestSuiteScanner.new()
+			var test_suite := scanner._parse_test_suite(script)
+			var suite_name := test_suite.get_name()
+
+			# emit deleted tests
+			for test_name in tests_removed:
+				discovered_test_cases.erase(test_name)
+				GdUnitSignals.instance().gdunit_event.emit(GdUnitEventTestDiscoverTestRemoved.new(script.resource_path, suite_name, test_name))
+
+			# emit new discovered tests
+			for test_name in tests_added:
+				discovered_test_cases.append(test_name)
+				var test_case := test_suite.find_child(test_name, false, false)
+				var dto := GdUnitTestCaseDto.new()
+				dto = dto.deserialize(dto.serialize(test_case))
+				GdUnitSignals.instance().gdunit_event.emit(GdUnitEventTestDiscoverTestAdded.new(script.resource_path, suite_name, dto))
+			# update the cache
+			_discover_cache[script.resource_path] = discovered_test_cases
+			test_suite.queue_free()
+
+
+func extract_test_functions(script :Script) -> PackedStringArray:
+	return script.get_script_method_list()\
+		.map(map_func_names)\
+		.filter(filter_test_cases)
+
+
+func map_func_names(method_info :Dictionary) -> String:
+	return method_info["name"]
+
+
+func filter_test_cases(value :String) -> bool:
+	return value.begins_with("test_")
+
+
+func filter_by_test_cases(method_info :Dictionary, value :String) -> bool:
+	return method_info["name"] == value

addons/gdUnit4/src/core/discovery/GdUnitTestDiscoverer.gd

@@ -0,0 +1,25 @@
+class_name GdUnitTestDiscoverer
+extends RefCounted
+
+
+static func run() -> void:
+	prints("Running test discovery ..")
+	GdUnitSignals.instance().gdunit_event.emit(GdUnitEventTestDiscoverStart.new())
+	await Engine.get_main_loop().create_timer(.5).timeout
+
+	var test_suite_directories :PackedStringArray = GdUnitCommandHandler.scan_test_directorys("res://" , GdUnitSettings.test_root_folder(), [])
+	var scanner := GdUnitTestSuiteScanner.new()
+	var _test_suites_to_process :Array[Node] = []
+	for test_suite_dir in test_suite_directories:
+		_test_suites_to_process.append_array(scanner.scan(test_suite_dir))
+
+	var test_case_count :int = _test_suites_to_process.reduce(func (accum :int, test_suite :Node) -> int:
+				return accum + test_suite.get_child_count(), 0)
+
+	for test_suite in _test_suites_to_process:
+		var ts_dto := GdUnitTestSuiteDto.of(test_suite)
+		GdUnitSignals.instance().gdunit_add_test_suite.emit(ts_dto)
+
+	prints("%d test suites discovered." % _test_suites_to_process.size())
+	GdUnitSignals.instance().gdunit_event.emit(GdUnitEventTestDiscoverEnd.new(_test_suites_to_process.size(), test_case_count))
+	await Engine.get_main_loop().process_frame

addons/gdUnit4/src/core/event/GdUnitEvent.gd

@@ -0,0 +1,190 @@
+class_name GdUnitEvent
+extends Resource
+
+const WARNINGS = "warnings"
+const FAILED = "failed"
+const ERRORS = "errors"
+const SKIPPED = "skipped"
+const ELAPSED_TIME = "elapsed_time"
+const ORPHAN_NODES = "orphan_nodes"
+const ERROR_COUNT = "error_count"
+const FAILED_COUNT = "failed_count"
+const SKIPPED_COUNT = "skipped_count"
+
+enum {
+	INIT,
+	STOP,
+	TESTSUITE_BEFORE,
+	TESTSUITE_AFTER,
+	TESTCASE_BEFORE,
+	TESTCASE_AFTER,
+	DISCOVER_START,
+	DISCOVER_END,
+	DISCOVER_SUITE_ADDED,
+	DISCOVER_TEST_ADDED,
+	DISCOVER_TEST_REMOVED,
+}
+
+var _event_type :int
+var _resource_path :String
+var _suite_name :String
+var _test_name :String
+var _total_count :int = 0
+var _statistics := Dictionary()
+var _reports :Array[GdUnitReport] = []
+
+
+func suite_before(p_resource_path :String, p_suite_name :String, p_total_count :int) -> GdUnitEvent:
+	_event_type = TESTSUITE_BEFORE
+	_resource_path = p_resource_path
+	_suite_name = p_suite_name
+	_test_name = "before"
+	_total_count = p_total_count
+	return self
+
+
+func suite_after(p_resource_path :String, p_suite_name :String, p_statistics :Dictionary = {}, p_reports :Array[GdUnitReport] = []) -> GdUnitEvent:
+	_event_type = TESTSUITE_AFTER
+	_resource_path = p_resource_path
+	_suite_name  = p_suite_name
+	_test_name = "after"
+	_statistics = p_statistics
+	_reports = p_reports
+	return self
+
+
+func test_before(p_resource_path :String, p_suite_name :String, p_test_name :String) -> GdUnitEvent:
+	_event_type = TESTCASE_BEFORE
+	_resource_path = p_resource_path
+	_suite_name  = p_suite_name
+	_test_name = p_test_name
+	return self
+
+
+func test_after(p_resource_path :String, p_suite_name :String, p_test_name :String, p_statistics :Dictionary = {}, p_reports :Array[GdUnitReport] = []) -> GdUnitEvent:
+	_event_type = TESTCASE_AFTER
+	_resource_path = p_resource_path
+	_suite_name  = p_suite_name
+	_test_name = p_test_name
+	_statistics = p_statistics
+	_reports = p_reports
+	return self
+
+
+func type() -> int:
+	return _event_type
+
+
+func suite_name() -> String:
+	return _suite_name
+
+
+func test_name() -> String:
+	return _test_name
+
+
+func elapsed_time() -> int:
+	return _statistics.get(ELAPSED_TIME, 0)
+
+
+func orphan_nodes() -> int:
+	return  _statistics.get(ORPHAN_NODES, 0)
+
+
+func statistic(p_type :String) -> int:
+	return _statistics.get(p_type, 0)
+
+
+func total_count() -> int:
+	return _total_count
+
+
+func success_count() -> int:
+	return total_count() - error_count() - failed_count() - skipped_count()
+
+
+func error_count() -> int:
+	return _statistics.get(ERROR_COUNT, 0)
+
+
+func failed_count() -> int:
+	return _statistics.get(FAILED_COUNT, 0)
+
+
+func skipped_count() -> int:
+	return _statistics.get(SKIPPED_COUNT, 0)
+
+
+func resource_path() -> String:
+	return _resource_path
+
+
+func is_success() -> bool:
+	return not is_warning() and not is_failed() and not is_error() and not is_skipped()
+
+
+func is_warning() -> bool:
+	return _statistics.get(WARNINGS, false)
+
+
+func is_failed() -> bool:
+	return _statistics.get(FAILED, false)
+
+
+func is_error() -> bool:
+	return _statistics.get(ERRORS, false)
+
+
+func is_skipped() -> bool:
+	return _statistics.get(SKIPPED, false)
+
+
+func reports() -> Array[GdUnitReport]:
+	return _reports
+
+
+func _to_string() -> String:
+	return "Event: %s %s:%s, %s, %s" % [_event_type, _suite_name, _test_name, _statistics, _reports]
+
+
+func serialize() -> Dictionary:
+	var serialized := {
+		"type"         : _event_type,
+		"resource_path": _resource_path,
+		"suite_name"   : _suite_name,
+		"test_name"    : _test_name,
+		"total_count"  : _total_count,
+		"statistics"    : _statistics
+	}
+	serialized["reports"] = _serialize_TestReports()
+	return serialized
+
+
+func deserialize(serialized :Dictionary) -> GdUnitEvent:
+	_event_type    = serialized.get("type", null)
+	_resource_path = serialized.get("resource_path", null)
+	_suite_name    = serialized.get("suite_name", null)
+	_test_name     = serialized.get("test_name", "unknown")
+	_total_count   = serialized.get("total_count", 0)
+	_statistics    = serialized.get("statistics", Dictionary())
+	if serialized.has("reports"):
+		# needs this workaround to copy typed values in the array
+		var reports_to_deserializ :Array[Dictionary] = []
+		reports_to_deserializ.append_array(serialized.get("reports"))
+		_reports = _deserialize_reports(reports_to_deserializ)
+	return self
+
+
+func _serialize_TestReports() -> Array[Dictionary]:
+	var serialized_reports :Array[Dictionary] = []
+	for report in _reports:
+		serialized_reports.append(report.serialize())
+	return serialized_reports
+
+
+func _deserialize_reports(p_reports :Array[Dictionary]) -> Array[GdUnitReport]:
+	var deserialized_reports :Array[GdUnitReport] = []
+	for report in p_reports:
+		var test_report := GdUnitReport.new().deserialize(report)
+		deserialized_reports.append(test_report)
+	return deserialized_reports

addons/gdUnit4/src/core/event/GdUnitEventInit.gd

@@ -0,0 +1,19 @@
+class_name GdUnitInit
+extends GdUnitEvent
+
+
+var _total_testsuites :int
+
+
+func _init(p_total_testsuites :int, p_total_count :int) -> void:
+	_event_type = INIT
+	_total_testsuites = p_total_testsuites
+	_total_count = p_total_count
+
+
+func total_test_suites() -> int:
+	return _total_testsuites
+
+
+func total_tests() -> int:
+	return _total_count

addons/gdUnit4/src/core/event/GdUnitEventStop.gd

@@ -0,0 +1,6 @@
+class_name GdUnitStop
+extends GdUnitEvent
+
+
+func _init() -> void:
+	_event_type = STOP

addons/gdUnit4/src/core/event/GdUnitEventTestDiscoverEnd.gd

@@ -0,0 +1,19 @@
+class_name GdUnitEventTestDiscoverEnd
+extends GdUnitEvent
+
+
+var _total_testsuites: int
+
+
+func _init(testsuite_count: int, test_count: int) -> void:
+	_event_type = DISCOVER_END
+	_total_testsuites = testsuite_count
+	_total_count = test_count
+
+
+func total_test_suites() -> int:
+	return _total_testsuites
+
+
+func total_tests() -> int:
+	return _total_count

addons/gdUnit4/src/core/event/GdUnitEventTestDiscoverStart.gd

@@ -0,0 +1,6 @@
+class_name GdUnitEventTestDiscoverStart
+extends GdUnitEvent
+
+
+func _init() -> void:
+	_event_type = DISCOVER_START

addons/gdUnit4/src/core/event/GdUnitEventTestDiscoverTestAdded.gd

@@ -0,0 +1,17 @@
+class_name GdUnitEventTestDiscoverTestAdded
+extends GdUnitEvent
+
+
+var _test_case_dto: GdUnitTestCaseDto
+
+
+func _init(arg_resource_path: String, arg_suite_name: String, arg_test_case_dto: GdUnitTestCaseDto) -> void:
+	_event_type = DISCOVER_TEST_ADDED
+	_resource_path = arg_resource_path
+	_suite_name  = arg_suite_name
+	_test_name = arg_test_case_dto.name()
+	_test_case_dto = arg_test_case_dto
+
+
+func test_case_dto() -> GdUnitTestCaseDto:
+	return _test_case_dto

addons/gdUnit4/src/core/event/GdUnitEventTestDiscoverTestRemoved.gd

@@ -0,0 +1,9 @@
+class_name GdUnitEventTestDiscoverTestRemoved
+extends GdUnitEvent
+
+
+func _init(arg_resource_path: String, arg_suite_name: String, arg_test_name: String) -> void:
+	_event_type = DISCOVER_TEST_REMOVED
+	_resource_path = arg_resource_path
+	_suite_name  = arg_suite_name
+	_test_name = arg_test_name