class_name GdAssertMessages extends Resource const WARN_COLOR = "#EFF883" const ERROR_COLOR = "#CD5C5C" const VALUE_COLOR = "#1E90FF" const SUB_COLOR := Color(1, 0, 0, .15) const ADD_COLOR := Color(0, 1, 0, .15) # Dictionary of control characters and their readable representations const CONTROL_CHARS = { "\n": "", # Line Feed "\r": "", # Carriage Return "\t": "", # Tab "\b": "", # Backspace "\f": "", # Form Feed "\v": "", # Vertical Tab "\a": "", # Bell "": "" # Escape } static func format_dict(value :Variant) -> String: if not value is Dictionary: return str(value) var dict_value: Dictionary = value if dict_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: var key_event := event as InputEventKey text += """ InputEventKey : keycode=%s (%s) pressed: %s physical_keycode: %s location: %s echo: %s""" % [ key_event.keycode, event.as_text_keycode(), key_event.pressed, key_event.physical_keycode, key_event.location, key_event.echo] else: text += event.as_text() if event is InputEventMouse: var mouse_event := event as InputEventMouse text += """ global_position: %s""" % mouse_event.global_position if event is InputEventWithModifiers: var mouse_event := event as InputEventWithModifiers text += """ -------- mods: %s shift: %s alt: %s control: %s meta: %s command: %s""" % [ mouse_event.get_modifiers_mask(), mouse_event.shift_pressed, mouse_event.alt_pressed, mouse_event.ctrl_pressed, mouse_event.meta_pressed, mouse_event.command_or_control_autoremap] return text.dedent() static func _colored_string_div(characters: String) -> String: return colored_array_div(characters.to_utf32_buffer().to_int32_array()) static func colored_array_div(characters: PackedInt32Array) -> String: if characters.is_empty(): return "" var result := PackedInt32Array() var index := 0 var missing_chars := PackedInt32Array() var additional_chars := PackedInt32Array() while index < characters.size(): var character := characters[index] match character: GdDiffTool.DIV_ADD: index += 1 @warning_ignore("return_value_discarded") additional_chars.append(characters[index]) GdDiffTool.DIV_SUB: index += 1 @warning_ignore("return_value_discarded") missing_chars.append(characters[index]) _: if not missing_chars.is_empty(): result.append_array(format_chars(missing_chars, SUB_COLOR)) missing_chars = PackedInt32Array() if not additional_chars.is_empty(): result.append_array(format_chars(additional_chars, ADD_COLOR)) additional_chars = PackedInt32Array() @warning_ignore("return_value_discarded") 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.to_byte_array().get_string_from_utf32() 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: Variant, color: Color) -> String: return "[color=%s]%s[/color]" % [color.to_html(), value] 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(str(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][/color]'" % [VALUE_COLOR] if value is InputEvent: var ie: InputEvent = value return "[color=%s]<%s>[/color]" % [VALUE_COLOR, input_event_as_text(ie)] var obj_value: Object = value if obj_value.has_method("_to_string"): return "[color=%s]<%s>[/color]" % [VALUE_COLOR, str(value)] return "[color=%s]<%s>[/color]" % [VALUE_COLOR, obj_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_warning(orphans_count: int) -> String: return """ %s: Found %s possible orphan nodes. Add %s to the end of the test to collect details.""".dedent().trim_prefix("\n") % [ _warning("WARNING:"), _nerror(orphans_count), _colored_value("collect_orphan_node_details()") ] static func orphan_detected_on_suite_setup(orphans: Array[GdUnitOrphanNodeInfo]) -> String: return """ %s Detected %s orphan nodes! [b]Verify your test suite setup.[/b] %s""".dedent().trim_prefix("\n") % [ _warning("WARNING:"), _nerror(orphans.size()), _build_orphan_node_stacktrace(orphans)] static func orphan_detected_on_test_setup(orphans: Array[GdUnitOrphanNodeInfo]) -> String: return """ %s Detected %s orphan nodes on test setup! [b]Check before_test() and after_test()![/b] %s""".dedent().trim_prefix("\n") % [ _warning("WARNING:"), _nerror(orphans.size()), _build_orphan_node_stacktrace(orphans) ] static func orphan_detected_on_test(orphans: Array[GdUnitOrphanNodeInfo]) -> String: return """ %s Detected %s orphan nodes! %s""".dedent().trim_prefix("\n") % [ _warning("WARNING:"), _nerror(orphans.size()), _build_orphan_node_stacktrace(orphans) ] static func _build_orphan_node_stacktrace(orphans: Array[GdUnitOrphanNodeInfo]) -> String: var stack_trace := "\n" for orphan in orphans: stack_trace += orphan.as_trace(orphan, true) + "\n" return stack_trace.indent(" ") 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))] static func test_session_terminated() -> String: return "%s" % _error("Test Session Terminated") # gdlint:disable = mixed-tabs-and-spaces static func test_suite_skipped(hint :String, skip_count :int) -> String: return """ %s Skipped %s tests Reason: %s """.dedent().trim_prefix("\n")\ % [_error("The 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: @warning_ignore("unsafe_method_access") 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: Variant, not_expect: Variant, not_found: Variant, 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 is_empty(not_expect): error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect) if not is_empty(not_found): var prefix := "but" if is_empty(not_expect) 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 is_empty(not_expect) and is_empty(not_found): var arr_current: Array = current var arr_expected: Array = expected var diff := _find_first_diff(arr_current, arr_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 is_empty(not_expect): error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect) if not is_empty(not_found): var prefix := "but" if is_empty(not_expect) 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: 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:" ) 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 is_empty(not_expect): error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect) if not is_empty(not_found): var prefix := "but" if is_empty(not_expect) 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: Variant, expected: Variant, found: Variant, 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 is_empty(found): 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 ." % 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 :Array in summary.keys(): var times :int = summary[args] @warning_ignore("return_value_discarded") 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 collected_interactions := PackedStringArray() for args: Array in current_interactions.keys(): var times: int = current_interactions[args] @warning_ignore("return_value_discarded") collected_interactions.append(_format_arguments(args, times)) var arguments: Array = expected_interactions.keys()[0] var interactions: int = expected_interactions.values()[0] var expected_interaction := _format_arguments(arguments, interactions) return "%s\n%s\n%s\n%s" % [ _error("Expecting interaction on:"), expected_interaction, _error("But found interactions on:"), "\n".join(collected_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: @warning_ignore("return_value_discarded") typed.append(_format_arg(arg) + " :" + GdObjects.type_as_string(typeof(arg))) return typed static func _format_arg(arg :Variant) -> String: if arg is InputEvent: var ie: InputEvent = arg return input_event_as_text(ie) 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 = "" 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: @warning_ignore("unsafe_method_access") 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: PackedInt32Array, type: Color) -> PackedInt32Array: if characters.size() == 0:# or characters[0] == 10: return characters # Replace each control character with its readable form var formatted_text := characters.to_byte_array().get_string_from_utf32() for control_char: String in CONTROL_CHARS: var replace_text: String = CONTROL_CHARS[control_char] formatted_text = formatted_text.replace(control_char, replace_text) # Handle special ASCII control characters (0x00-0x1F, 0x7F) var ascii_text := "" for i in formatted_text.length(): var character := formatted_text[i] var code := character.unicode_at(0) if code < 0x20 and not CONTROL_CHARS.has(character): # Control characters not handled above ascii_text += "<0x%02X>" % code elif code == 0x7F: # DEL character ascii_text += "" else: ascii_text += character var message := "[bgcolor=#%s][color=white]%s[/color][/bgcolor]" % [ type.to_html(), ascii_text ] var result := PackedInt32Array() result.append_array(message.to_utf32_buffer().to_int32_array()) 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("_", " ") static func build_failure_message(failure :String, additional_failure_message: String, custom_failure_message: String) -> String: var message := failure if custom_failure_message.is_empty() else custom_failure_message if additional_failure_message.is_empty(): return message return """ %s [color=LIME_GREEN][b]Additional info:[/b][/color] %s""".dedent().trim_prefix("\n") % [message, additional_failure_message] static func is_empty(value: Variant) -> bool: var arry_value: Array = value return arry_value != null and arry_value.is_empty()