update gdunit

addons/gdUnit4/GdUnitRunner.cfg

@@ -1 +1 @@
-{"included":{"res://test/":[]},"server_port":31002,"skipped":{},"version":"1.0"}
+{"included":{"res://test/nodes/decorators/time_limiter_test.gd":["test_return_failure_when_child_exceeds_time_limiter"]},"server_port":31002,"skipped":{},"version":"1.0"}

addons/gdUnit4/bin/GdUnitCmdTool.gd

@@ -289,8 +289,8 @@ class CLIRunner extends Node:
 		return total
 
 
-	func PublishEvent(data) -> void:
-		_on_gdunit_event(GdUnitEvent.new().deserialize(data.AsDictionary()))
+	func PublishEvent(data :Dictionary) -> void:
+		_on_gdunit_event(GdUnitEvent.new().deserialize(data))
 
 
 	func _on_gdunit_event(event :GdUnitEvent):
@@ -398,8 +398,6 @@ func _initialize():
 
 func _finalize():
 	prints("Finallize ..")
-	if is_instance_valid(_cli_runner):
-		_cli_runner.free()
 	prints("-Orphan nodes report-----------------------")
 	Window.print_orphan_nodes()
 	prints("Finallize .. done")

addons/gdUnit4/bin/GdUnitCopyLog.gd

@@ -91,13 +91,13 @@ func _patch_report(report_path :String, godot_log :String) -> void:
 	index_file.seek(0)
 	index_file.store_string(content)
 
-func _copy_and_pach(from_file: String, to_dir: String) -> Result:
+func _copy_and_pach(from_file: String, to_dir: String) -> GdUnitResult:
 	var result := GdUnitTools.copy_file(from_file, to_dir)
 	if result.is_error():
 		return result
 	var file := FileAccess.open(from_file, FileAccess.READ)
 	if file == null:
-		return Result.error("Can't find file '%s'. Error: %s" % [from_file, GdUnitTools.error_as_string(FileAccess.get_open_error())])
+		return GdUnitResult.error("Can't find file '%s'. Error: %s" % [from_file, GdUnitTools.error_as_string(FileAccess.get_open_error())])
 	var content := file.get_as_text()
 	# patch out console format codes
 	for color_index in range(0, 256):
@@ -110,9 +110,9 @@ func _copy_and_pach(from_file: String, to_dir: String) -> Result:
 	var to_file := to_dir + "/" + from_file.get_file()
 	file = FileAccess.open(to_file, FileAccess.WRITE)
 	if file == null:
-		return Result.error("Can't open to write '%s'. Error: %s" % [to_file, GdUnitTools.error_as_string(FileAccess.get_open_error())])
+		return GdUnitResult.error("Can't open to write '%s'. Error: %s" % [to_file, GdUnitTools.error_as_string(FileAccess.get_open_error())])
 	file.store_string(content)
-	return Result.empty()
+	return GdUnitResult.empty()
 
 func reports_available() -> bool:
 	return DirAccess.dir_exists_absolute(_report_root_path)

addons/gdUnit4/bin/ProjectScanner.gd

@@ -11,11 +11,6 @@ func _initialize():
 	root.add_child(scanner)
 
 
-func _process(_delta):
-	if not is_instance_valid(scanner):
-		quit(0)
-
-
 func _finalize():
 	prints("__finalize")
 
@@ -58,7 +53,7 @@ class SourceScanner extends Node:
 			_console.prints_color("======================================", Color.CORNFLOWER_BLUE)
 			_console.new_line()
 			await get_tree().process_frame
-			queue_free()
+			get_tree().quit(0)
 
 
 	func scan_project() -> void:
@@ -90,4 +85,6 @@ class SourceScanner extends Node:
 			_console.progressBar(fs.get_scanning_progress() * 100 as int)
 		_console.progressBar(100)
 		_console.new_line()
+		await get_tree().process_frame
 		plugin.queue_free()
+		await get_tree().process_frame

addons/gdUnit4/src/asserts/GdAssertMessages.gd

@@ -225,7 +225,7 @@ static func error_not_same_error(current, expected) -> 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: Result, expected :Result) -> String:
+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))]
 
@@ -408,35 +408,35 @@ static func error_contains_key_value(key, value, current_value, compare_mode :Gd
 
 
 # - ResultAssert specific errors ----------------------------------------------------
-static func error_result_is_empty(current :Result) -> String:
-	return _result_error_message(current, Result.EMPTY)
+static func error_result_is_empty(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.EMPTY)
 
 
-static func error_result_is_success(current :Result) -> String:
-	return _result_error_message(current, Result.SUCCESS)
+static func error_result_is_success(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.SUCCESS)
 
 
-static func error_result_is_warning(current :Result) -> String:
-	return _result_error_message(current, Result.WARN)
+static func error_result_is_warning(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.WARN)
 
 
-static func error_result_is_error(current :Result) -> String:
-	return _result_error_message(current, Result.ERROR)
+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 Result is a success." % [_error("Expecting:"), _colored_value(expected)]
+	return "%s\n %s\n but the GdUnitResult is a success." % [_error("Expecting:"), _colored_value(expected)]
 
 
 static func error_result_is_value(current, expected) -> 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 :Result, expected_type :int) -> String:
+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():
@@ -468,19 +468,19 @@ static func error_await_signal_on_invalid_instance(source, signal_name :String,
 
 static func result_type(type :int) -> String:
 	match type:
-		Result.SUCCESS: return "SUCCESS"
-		Result.WARN: return "WARNING"
-		Result.ERROR: return "ERROR"
-		Result.EMPTY: return "EMPTY"
+		GdUnitResult.SUCCESS: return "SUCCESS"
+		GdUnitResult.WARN: return "WARNING"
+		GdUnitResult.ERROR: return "ERROR"
+		GdUnitResult.EMPTY: return "EMPTY"
 	return "UNKNOWN"
 
 
-static func result_message(result :Result) -> String:
+static func result_message(result :GdUnitResult) -> String:
 	match result._state:
-		Result.SUCCESS: return ""
-		Result.WARN: return result.warn_message()
-		Result.ERROR: return result.error_message()
-		Result.EMPTY: return ""
+		GdUnitResult.SUCCESS: return ""
+		GdUnitResult.WARN: return result.warn_message()
+		GdUnitResult.ERROR: return result.error_message()
+		GdUnitResult.EMPTY: return ""
 	return "UNKNOWN"
 # -----------------------------------------------------------------------------------
 

addons/gdUnit4/src/asserts/GdUnitResultAssertImpl.gd

@@ -19,11 +19,11 @@ func _notification(event):
 
 
 func __validate_value_type(value) -> bool:
-	return value == null or value is Result
+	return value == null or value is GdUnitResult
 
 
-func __current() -> Result:
-	return _base.__current() as Result
+func __current() -> GdUnitResult:
+	return _base.__current() as GdUnitResult
 
 
 func report_success() -> GdUnitResultAssert:

addons/gdUnit4/src/cmd/CmdArgumentParser.gd

@@ -11,7 +11,7 @@ func _init(p_options :CmdOptions, p_tool_name :String):
 	_tool_name = p_tool_name
 
 
-func parse(args :Array, ignore_unknown_cmd := false) -> Result:
+func parse(args :Array, ignore_unknown_cmd := false) -> GdUnitResult:
 	_parsed_commands.clear()
 
 	# parse until first program argument
@@ -21,7 +21,7 @@ func parse(args :Array, ignore_unknown_cmd := false) -> Result:
 			break
 
 	if args.is_empty():
-		return Result.empty()
+		return GdUnitResult.empty()
 
 	# now parse all arguments
 	while not args.is_empty():
@@ -30,10 +30,10 @@ func parse(args :Array, ignore_unknown_cmd := false) -> Result:
 
 		if option:
 			if _parse_cmd_arguments(option, args) == -1:
-				return Result.error("The '%s' command requires an argument!" % option.short_command())
+				return GdUnitResult.error("The '%s' command requires an argument!" % option.short_command())
 		elif not ignore_unknown_cmd:
-			return Result.error("Unknown '%s' command!" % cmd)
-	return Result.success(_parsed_commands.values())
+			return GdUnitResult.error("Unknown '%s' command!" % cmd)
+	return GdUnitResult.success(_parsed_commands.values())
 
 
 func options() -> CmdOptions:

addons/gdUnit4/src/cmd/CmdCommandHandler.gd

@@ -47,7 +47,7 @@ func register_cbv(cmd_name: String, cb: Callable) -> CmdCommandHandler:
 	return self
 
 
-func _validate() -> Result:
+func _validate() -> GdUnitResult:
 	var errors: = PackedStringArray()
 	var registered_cbs: = Dictionary()
 
@@ -66,12 +66,12 @@ func _validate() -> Result:
 			else:
 				registered_cbs[cb_method] = cmd_name
 	if errors.is_empty():
-		return Result.success(true)
+		return GdUnitResult.success(true)
 	else:
-		return Result.error("\n".join(errors))
+		return GdUnitResult.error("\n".join(errors))
 
 
-func execute(commands :Array) -> Result:
+func execute(commands :Array) -> GdUnitResult:
 	var result := _validate()
 	if result.is_error():
 		return result
@@ -89,4 +89,4 @@ func execute(commands :Array) -> Result:
 					cb_s.call(cmd.arguments()[CB_SINGLE_ARG])
 				else:
 					cb_m.callv(cmd.arguments())
-	return Result.success(true)
+	return GdUnitResult.success(true)

addons/gdUnit4/src/core/GdObjects.gd

@@ -445,30 +445,30 @@ static func can_be_instantiate(obj :Variant) -> bool:
 	return obj.has_method("new")
 
 
-static func create_instance(clazz) -> Result:
+static func create_instance(clazz) -> GdUnitResult:
 	match typeof(clazz):
 		TYPE_OBJECT:
 			# test is given clazz already an instance
 			if is_instance(clazz):
-				return Result.success(clazz)
-			return Result.success(clazz.new())
+				return GdUnitResult.success(clazz)
+			return GdUnitResult.success(clazz.new())
 		TYPE_STRING:
 			if ClassDB.class_exists(clazz):
 				if Engine.has_singleton(clazz):
-					return Result.error("Not allowed to create a instance for singelton '%s'." % clazz)
+					return GdUnitResult.error("Not allowed to create a instance for singelton '%s'." % clazz)
 				if not ClassDB.can_instantiate(clazz):
-					return  Result.error("Can't instance Engine class '%s'." % clazz)
-				return Result.success(ClassDB.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 Result.error("Class '%s' not found." % clazz)
+					return GdUnitResult.error("Class '%s' not found." % clazz)
 				var script = load(clazz_path)
 				if script != null:
-					return Result.success(script.new())
+					return GdUnitResult.success(script.new())
 				else:
-					return Result.error("Can't create instance for '%s'." % clazz)
-	return Result.error("Can't create instance for class '%s'." % clazz)
+					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) -> PackedStringArray:
@@ -513,38 +513,38 @@ static func extract_class_name_from_class_path(clazz_path :PackedStringArray) ->
 	return  clazz_name
 
 
-static func extract_class_name(clazz) -> Result:
+static func extract_class_name(clazz) -> GdUnitResult:
 	if clazz == null:
-		return Result.error("Can't extract class name form a null value.")
+		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 Result.success(clazz.get_class())
+		return GdUnitResult.success(clazz.get_class())
 
 	# extract name form full qualified class path
 	if clazz is String:
 		if ClassDB.class_exists(clazz):
-			return Result.success(clazz)
+			return GdUnitResult.success(clazz)
 		var source_sript :Script = load(clazz)
 		var clazz_name = load("res://addons/gdUnit4/src/core/parse/GdScriptParser.gd").new().get_class_name(source_sript)
-		return Result.success(to_pascal_case(clazz_name))
+		return GdUnitResult.success(to_pascal_case(clazz_name))
 
 	if is_primitive_type(clazz):
-		return Result.error("Can't extract class name for an primitive '%s'" % type_as_string(typeof(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 Result.success(class_path);
+			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 = clazz.new()
 	if instance == null:
-		return Result.error("Can't create a instance for class '%s'" % clazz)
+		return GdUnitResult.error("Can't create a instance for class '%s'" % clazz)
 	var result := extract_class_name(instance)
 	GdUnitTools.free_instance(instance)
 	return result