Minimata
bdce8b969c
Some checks failed
Create tag and build when new code gets to main / Export (push) Failing after 6m41s
209 lines
7.1 KiB
GDScript
209 lines
7.1 KiB
GDScript
extends GdUnitStringAssert
|
|
|
|
var _base: GdUnitAssertImpl
|
|
|
|
|
|
func _init(current :Variant) -> void:
|
|
_base = GdUnitAssertImpl.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:
|
|
@warning_ignore("return_value_discarded")
|
|
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.failure_message()
|
|
|
|
|
|
func current_value() -> Variant:
|
|
return _base.current_value()
|
|
|
|
|
|
func report_success() -> GdUnitStringAssert:
|
|
@warning_ignore("return_value_discarded")
|
|
_base.report_success()
|
|
return self
|
|
|
|
|
|
func report_error(error :String) -> GdUnitStringAssert:
|
|
@warning_ignore("return_value_discarded")
|
|
_base.report_error(error)
|
|
return self
|
|
|
|
|
|
func override_failure_message(message: String) -> GdUnitStringAssert:
|
|
@warning_ignore("return_value_discarded")
|
|
_base.override_failure_message(message)
|
|
return self
|
|
|
|
|
|
func append_failure_message(message: String) -> GdUnitStringAssert:
|
|
@warning_ignore("return_value_discarded")
|
|
_base.append_failure_message(message)
|
|
return self
|
|
|
|
|
|
func is_null() -> GdUnitStringAssert:
|
|
@warning_ignore("return_value_discarded")
|
|
_base.is_null()
|
|
return self
|
|
|
|
|
|
func is_not_null() -> GdUnitStringAssert:
|
|
@warning_ignore("return_value_discarded")
|
|
_base.is_not_null()
|
|
return self
|
|
|
|
|
|
func is_equal(expected: Variant) -> GdUnitStringAssert:
|
|
return _is_equal(expected, false, GdAssertMessages.error_equal)
|
|
|
|
|
|
func is_equal_ignoring_case(expected: Variant) -> GdUnitStringAssert:
|
|
return _is_equal(expected, true, GdAssertMessages.error_equal_ignoring_case)
|
|
|
|
|
|
@warning_ignore_start("unsafe_call_argument")
|
|
func _is_equal(expected: Variant, ignore_case: bool, message_cb: Callable) -> GdUnitStringAssert:
|
|
var current: Variant = current_value()
|
|
if current == null:
|
|
return report_error(message_cb.call(current, expected))
|
|
var cur_value := str(current)
|
|
if not GdObjects.equals(cur_value, expected, ignore_case):
|
|
var exp_value := str(expected)
|
|
if contains_bbcode(cur_value):
|
|
# mask user bbcode
|
|
# https://docs.godotengine.org/en/4.5/tutorials/ui/bbcode_in_richtextlabel.html#handling-user-input-safely
|
|
return report_error(message_cb.call(cur_value.replace("[", "[lb]"), exp_value.replace("[", "[lb]")))
|
|
var diffs := GdDiffTool.string_diff(cur_value, exp_value)
|
|
var formatted_current := GdAssertMessages.colored_array_div(diffs[1])
|
|
return report_error(message_cb.call(formatted_current, exp_value))
|
|
return report_success()
|
|
@warning_ignore_restore("unsafe_call_argument")
|
|
|
|
|
|
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()
|
|
@warning_ignore("unsafe_cast")
|
|
if current == null or not (current as String).is_empty():
|
|
return report_error(GdAssertMessages.error_is_empty(current))
|
|
return report_success()
|
|
|
|
|
|
func is_not_empty() -> GdUnitStringAssert:
|
|
var current :Variant = current_value()
|
|
@warning_ignore("unsafe_cast")
|
|
if current == null or (current as String).is_empty():
|
|
return report_error(GdAssertMessages.error_is_not_empty())
|
|
return report_success()
|
|
|
|
|
|
func contains(expected :String) -> GdUnitStringAssert:
|
|
var current :Variant = current_value()
|
|
@warning_ignore("unsafe_cast")
|
|
if current == null or (current as String).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()
|
|
@warning_ignore("unsafe_cast")
|
|
if current != null and (current as String).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()
|
|
@warning_ignore("unsafe_cast")
|
|
if current == null or (current as String).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()
|
|
@warning_ignore("unsafe_cast")
|
|
if current != null and (current as String).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()
|
|
@warning_ignore("unsafe_cast")
|
|
if current == null or (current as String).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))
|
|
@warning_ignore("unsafe_cast")
|
|
var find :int = (current as String).length() - expected.length()
|
|
@warning_ignore("unsafe_cast")
|
|
if (current as String).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))
|
|
var str_current: String = current
|
|
match comparator:
|
|
Comparator.EQUAL:
|
|
if str_current.length() != expected:
|
|
return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
|
|
Comparator.LESS_THAN:
|
|
if str_current.length() >= expected:
|
|
return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
|
|
Comparator.LESS_EQUAL:
|
|
if str_current.length() > expected:
|
|
return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
|
|
Comparator.GREATER_THAN:
|
|
if str_current.length() <= expected:
|
|
return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
|
|
Comparator.GREATER_EQUAL:
|
|
if str_current.length() < expected:
|
|
return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
|
|
_:
|
|
return report_error("Comparator '%d' not implemented!" % comparator)
|
|
return report_success()
|
|
|
|
|
|
func contains_bbcode(value: String) -> bool:
|
|
var rtl := RichTextLabel.new()
|
|
rtl.bbcode_enabled = true
|
|
rtl.parse_bbcode(value)
|
|
var has_bbcode := rtl.get_parsed_text() != value
|
|
rtl.free()
|
|
return has_bbcode
|