296 lines
9.1 KiB
GDScript
296 lines
9.1 KiB
GDScript
#warning-ignore-all:unused_argument
|
|
class_name ParameterizedTestCaseTest
|
|
extends GdUnitTestSuite
|
|
|
|
var _collected_tests = {}
|
|
var _expected_tests = {
|
|
"test_parameterized_bool_value" : [
|
|
[0, false],
|
|
[1, true]
|
|
],
|
|
"test_parameterized_int_values" : [
|
|
[1, 2, 3, 6],
|
|
[3, 4, 5, 12],
|
|
[6, 7, 8, 21]
|
|
],
|
|
"test_parameterized_float_values" : [
|
|
[2.2, 2.2, 4.4],
|
|
[2.2, 2.3, 4.5],
|
|
[3.3, 2.2, 5.5]
|
|
],
|
|
"test_parameterized_string_values" : [
|
|
["2.2", "2.2", "2.22.2"],
|
|
["foo", "bar", "foobar"],
|
|
["a", "b", "ab"]
|
|
],
|
|
"test_parameterized_Vector2_values" : [
|
|
[Vector2.ONE, Vector2.ONE, Vector2(2, 2)],
|
|
[Vector2.LEFT, Vector2.RIGHT, Vector2.ZERO],
|
|
[Vector2.ZERO, Vector2.LEFT, Vector2.LEFT]
|
|
],
|
|
"test_parameterized_Vector3_values" : [
|
|
[Vector3.ONE, Vector3.ONE, Vector3(2, 2, 2)],
|
|
[Vector3.LEFT, Vector3.RIGHT, Vector3.ZERO],
|
|
[Vector3.ZERO, Vector3.LEFT, Vector3.LEFT]
|
|
],
|
|
"test_parameterized_obj_values" : [
|
|
[TestObj.new("abc"), TestObj.new("def"), "abcdef"]
|
|
],
|
|
"test_parameterized_dict_values" : [
|
|
[{"key_a":"value_a"}, '{"key_a":"value_a"}'],
|
|
[{"key_b":"value_b"}, '{"key_b":"value_b"}']
|
|
],
|
|
"test_with_dynamic_paramater_resolving" : [
|
|
["test_a"],
|
|
["test_b"],
|
|
["test_c"],
|
|
["test_d"]
|
|
],
|
|
"test_with_dynamic_paramater_resolving2" : [
|
|
["test_a"],
|
|
["test_b"],
|
|
["test_c"]
|
|
],
|
|
"test_with_extern_parameter_set" : [
|
|
["test_a"],
|
|
["test_b"],
|
|
["test_c"]
|
|
]
|
|
}
|
|
|
|
|
|
var _test_node_before :Node
|
|
var _test_node_before_test :Node
|
|
|
|
|
|
func before() -> void:
|
|
_test_node_before = auto_free(SubViewport.new())
|
|
|
|
|
|
func before_test() -> void:
|
|
_test_node_before_test = auto_free(SubViewport.new())
|
|
|
|
|
|
func after():
|
|
for test_name in _expected_tests.keys():
|
|
if _collected_tests.has(test_name):
|
|
var current_values = _collected_tests[test_name]
|
|
var expected_values = _expected_tests[test_name]
|
|
assert_that(current_values)\
|
|
.override_failure_message("Expecting '%s' called with parameters:\n %s\n but was\n %s" % [test_name, expected_values, current_values])\
|
|
.is_equal(expected_values)
|
|
else:
|
|
fail("Missing test '%s' executed!" % test_name)
|
|
|
|
|
|
func collect_test_call(test_name :String, values :Array) -> void:
|
|
if not _collected_tests.has(test_name):
|
|
_collected_tests[test_name] = Array()
|
|
_collected_tests[test_name].append(values)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_parameterized_bool_value(a: int, expected :bool, test_parameters := [
|
|
[0, false],
|
|
[1, true]]):
|
|
collect_test_call("test_parameterized_bool_value", [a, expected])
|
|
assert_that(bool(a)).is_equal(expected)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_parameterized_int_values(a: int, b :int, c :int, expected :int, test_parameters := [
|
|
[1, 2, 3, 6],
|
|
[3, 4, 5, 12],
|
|
[6, 7, 8, 21] ]):
|
|
|
|
collect_test_call("test_parameterized_int_values", [a, b, c, expected])
|
|
assert_that(a+b+c).is_equal(expected)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_parameterized_float_values(a: float, b :float, expected :float, test_parameters := [
|
|
[2.2, 2.2, 4.4],
|
|
[2.2, 2.3, 4.5],
|
|
[3.3, 2.2, 5.5] ]):
|
|
|
|
collect_test_call("test_parameterized_float_values", [a, b, expected])
|
|
assert_float(a+b).is_equal(expected)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_parameterized_string_values(a: String, b :String, expected :String, test_parameters := [
|
|
["2.2", "2.2", "2.22.2"],
|
|
["foo", "bar", "foobar"],
|
|
["a", "b", "ab"] ]):
|
|
|
|
collect_test_call("test_parameterized_string_values", [a, b, expected])
|
|
assert_that(a+b).is_equal(expected)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_parameterized_Vector2_values(a: Vector2, b :Vector2, expected :Vector2, test_parameters := [
|
|
[Vector2.ONE, Vector2.ONE, Vector2(2, 2)],
|
|
[Vector2.LEFT, Vector2.RIGHT, Vector2.ZERO],
|
|
[Vector2.ZERO, Vector2.LEFT, Vector2.LEFT] ]):
|
|
|
|
collect_test_call("test_parameterized_Vector2_values", [a, b, expected])
|
|
assert_that(a+b).is_equal(expected)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_parameterized_Vector3_values(a: Vector3, b :Vector3, expected :Vector3, test_parameters := [
|
|
[Vector3.ONE, Vector3.ONE, Vector3(2, 2, 2)],
|
|
[Vector3.LEFT, Vector3.RIGHT, Vector3.ZERO],
|
|
[Vector3.ZERO, Vector3.LEFT, Vector3.LEFT] ]):
|
|
|
|
collect_test_call("test_parameterized_Vector3_values", [a, b, expected])
|
|
assert_that(a+b).is_equal(expected)
|
|
|
|
|
|
class TestObj extends RefCounted:
|
|
var _value :String
|
|
|
|
func _init(value :String):
|
|
_value = value
|
|
|
|
func _to_string() -> String:
|
|
return _value
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_parameterized_obj_values(a: Object, b :Object, expected :String, test_parameters := [
|
|
[TestObj.new("abc"), TestObj.new("def"), "abcdef"]]):
|
|
|
|
collect_test_call("test_parameterized_obj_values", [a, b, expected])
|
|
assert_that(a.to_string()+b.to_string()).is_equal(expected)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_parameterized_dict_values(data: Dictionary, expected :String, test_parameters := [
|
|
[{"key_a" : "value_a"}, '{"key_a":"value_a"}'],
|
|
[{"key_b" : "value_b"}, '{"key_b":"value_b"}']
|
|
]):
|
|
collect_test_call("test_parameterized_dict_values", [data, expected])
|
|
assert_that(str(data).replace(" ", "")).is_equal(expected)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_dictionary_div_number_types(
|
|
value : Dictionary,
|
|
expected : Dictionary,
|
|
test_parameters : Array = [
|
|
[{ top = 50.0, bottom = 50.0, left = 50.0, right = 50.0}, { top = 50, bottom = 50, left = 50, right = 50}],
|
|
[{ top = 50.0, bottom = 50.0, left = 50.0, right = 50.0}, { top = 50.0, bottom = 50.0, left = 50.0, right = 50.0}],
|
|
[{ top = 50, bottom = 50, left = 50, right = 50}, { top = 50.0, bottom = 50.0, left = 50.0, right = 50.0}],
|
|
[{ top = 50, bottom = 50, left = 50, right = 50}, { top = 50, bottom = 50, left = 50, right = 50}],
|
|
]
|
|
) -> void:
|
|
# allow to compare type unsave
|
|
ProjectSettings.set_setting(GdUnitSettings.REPORT_ASSERT_STRICT_NUMBER_TYPE_COMPARE, false)
|
|
assert_that(value).is_equal(expected)
|
|
ProjectSettings.set_setting(GdUnitSettings.REPORT_ASSERT_STRICT_NUMBER_TYPE_COMPARE, true)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_with_string_paramset(
|
|
values : Array,
|
|
expected : String,
|
|
test_parameters : Array = [
|
|
[ ["a"], "a" ],
|
|
[ ["a", "very", "long", "argument"], "a very long argument" ],
|
|
]
|
|
):
|
|
var current := " ".join(values)
|
|
assert_that(current.strip_edges()).is_equal(expected)
|
|
|
|
|
|
# https://github.com/MikeSchulze/gdUnit4/issues/213
|
|
@warning_ignore("unused_parameter")
|
|
func test_with_string_contains_brackets(
|
|
test_index :int,
|
|
value :String,
|
|
test_parameters := [
|
|
[1, "flowchart TD\nid>This is a flag shaped node]"],
|
|
[2, "flowchart TD\nid(((This is a double circle node)))"],
|
|
[3, "flowchart TD\nid((This is a circular node))"],
|
|
[4, "flowchart TD\nid>This is a flag shaped node]"],
|
|
[5, "flowchart TD\nid{'This is a rhombus node'}"],
|
|
[6, 'flowchart TD\nid((This is a circular node))'],
|
|
[7, 'flowchart TD\nid>This is a flag shaped node]'],
|
|
[8, 'flowchart TD\nid{"This is a rhombus node"}'],
|
|
[9, """
|
|
flowchart TD
|
|
id{"This is a rhombus node"}
|
|
"""],
|
|
]
|
|
):
|
|
match test_index:
|
|
1: assert_str(value).is_equal("flowchart TD\nid>This is a flag shaped node]")
|
|
2: assert_str(value).is_equal("flowchart TD\nid(((This is a double circle node)))")
|
|
3: assert_str(value).is_equal("flowchart TD\nid((This is a circular node))")
|
|
4: assert_str(value).is_equal("flowchart TD\nid>" + "This is a flag shaped node]")
|
|
5: assert_str(value).is_equal("flowchart TD\nid{'This is a rhombus node'}")
|
|
6: assert_str(value).is_equal('flowchart TD\nid((This is a circular node))')
|
|
7: assert_str(value).is_equal('flowchart TD\nid>This is a flag shaped node]')
|
|
8: assert_str(value).is_equal('flowchart TD\nid{"This is a rhombus node"}')
|
|
9: assert_str(value).is_equal("""
|
|
flowchart TD
|
|
id{"This is a rhombus node"}
|
|
""")
|
|
|
|
|
|
func test_with_dynamic_parameter_resolving(name: String, value, expected, test_parameters := [
|
|
["test_a", auto_free(Node2D.new()), Node2D],
|
|
["test_b", auto_free(Node3D.new()), Node3D],
|
|
["test_c", _test_node_before, SubViewport],
|
|
["test_d", _test_node_before_test, SubViewport],
|
|
]) -> void:
|
|
# all values must be resolved
|
|
assert_that(value).is_not_null().is_instanceof(expected)
|
|
if name == "test_c":
|
|
assert_that(value).is_same(_test_node_before)
|
|
if name == "test_d":
|
|
assert_that(value).is_same(_test_node_before_test)
|
|
# the argument 'test_parameters' must be replaced by <null> set to avoid re-instantiate of test arguments
|
|
assert_that(test_parameters).is_empty()
|
|
collect_test_call("test_with_dynamic_paramater_resolving", [name])
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_with_dynamic_parameter_resolving2(
|
|
name: String,
|
|
type,
|
|
log_level,
|
|
expected_logs,
|
|
test_parameters = [
|
|
["test_a", null, "LOG", {}],
|
|
[
|
|
"test_b",
|
|
Node2D,
|
|
null,
|
|
{Node2D: "ERROR"}
|
|
],
|
|
[
|
|
"test_c",
|
|
Node2D,
|
|
"LOG",
|
|
{Node2D: "LOG"}
|
|
]
|
|
]
|
|
):
|
|
# the argument 'test_parameters' must be replaced by <null> set to avoid re-instantiate of test arguments
|
|
assert_that(test_parameters).is_empty()
|
|
collect_test_call("test_with_dynamic_paramater_resolving2", [name])
|
|
|
|
|
|
var _test_set =[
|
|
["test_a"],
|
|
["test_b"],
|
|
["test_c"]
|
|
]
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_with_extern_parameter_set(value, test_parameters = _test_set):
|
|
assert_that(value).is_not_empty()
|
|
assert_that(test_parameters).is_empty()
|
|
collect_test_call("test_with_extern_parameter_set", [value])
|