338 lines
13 KiB
GDScript
338 lines
13 KiB
GDScript
# GdUnit generated TestSuite
|
|
extends GdUnitTestSuite
|
|
|
|
# TestSuite generated from
|
|
const __source = 'res://addons/gdUnit4/src/asserts/GdUnitArrayAssertImpl.gd'
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_is_array_assert(_test :String, array, test_parameters = [
|
|
["Array", Array()],
|
|
["PackedByteArray", PackedByteArray()],
|
|
["PackedInt32Array", PackedInt32Array()],
|
|
["PackedInt64Array", PackedInt64Array()],
|
|
["PackedFloat32Array", PackedFloat32Array()],
|
|
["PackedFloat64Array", PackedFloat64Array()],
|
|
["PackedStringArray", PackedStringArray()],
|
|
["PackedVector2Array", PackedVector2Array()],
|
|
["PackedVector3Array", PackedVector3Array()],
|
|
["PackedColorArray", PackedColorArray()] ]
|
|
) -> void:
|
|
var assert_ = assert_that(array)
|
|
assert_object(assert_).is_instanceof(GdUnitArrayAssert)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_is_null(_test :String, value, test_parameters = [
|
|
["Array", Array()],
|
|
["PackedByteArray", PackedByteArray()],
|
|
["PackedInt32Array", PackedInt32Array()],
|
|
["PackedInt64Array", PackedInt64Array()],
|
|
["PackedFloat32Array", PackedFloat32Array()],
|
|
["PackedFloat64Array", PackedFloat64Array()],
|
|
["PackedStringArray", PackedStringArray()],
|
|
["PackedVector2Array", PackedVector2Array()],
|
|
["PackedVector3Array", PackedVector3Array()],
|
|
["PackedColorArray", PackedColorArray()] ]
|
|
) -> void:
|
|
assert_array(null).is_null()
|
|
assert_failure(func(): assert_array(value).is_null()) \
|
|
.is_failed() \
|
|
.has_message("Expecting: '<null>' but was '%s'" % GdDefaultValueDecoder.decode(value))
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_is_not_null(_test :String, array, test_parameters = [
|
|
["Array", Array()],
|
|
["PackedByteArray", PackedByteArray()],
|
|
["PackedInt32Array", PackedInt32Array()],
|
|
["PackedInt64Array", PackedInt64Array()],
|
|
["PackedFloat32Array", PackedFloat32Array()],
|
|
["PackedFloat64Array", PackedFloat64Array()],
|
|
["PackedStringArray", PackedStringArray()],
|
|
["PackedVector2Array", PackedVector2Array()],
|
|
["PackedVector3Array", PackedVector3Array()],
|
|
["PackedColorArray", PackedColorArray()] ]
|
|
) -> void:
|
|
assert_array(array).is_not_null()
|
|
|
|
assert_failure(func(): assert_array(null).is_not_null()) \
|
|
.is_failed() \
|
|
.has_message("Expecting: not to be '<null>'")
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_is_equal(_test :String, array, test_parameters = [
|
|
["Array", Array([1, 2, 3, 4, 5])],
|
|
["PackedByteArray", PackedByteArray([1, 2, 3, 4, 5])],
|
|
["PackedInt32Array", PackedInt32Array([1, 2, 3, 4, 5])],
|
|
["PackedInt64Array", PackedInt64Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat32Array", PackedFloat32Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat64Array", PackedFloat64Array([1, 2, 3, 4, 5])],
|
|
["PackedStringArray", PackedStringArray([1, 2, 3, 4, 5])],
|
|
["PackedVector2Array", PackedVector2Array([Vector2.ZERO, Vector2.LEFT, Vector2.RIGHT, Vector2.UP, Vector2.DOWN])],
|
|
["PackedVector3Array", PackedVector3Array([Vector3.ZERO, Vector3.LEFT, Vector3.RIGHT, Vector3.UP, Vector3.DOWN])],
|
|
["PackedColorArray", PackedColorArray([Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, Color.BLACK])] ]
|
|
) -> void:
|
|
|
|
var other = array.duplicate()
|
|
assert_array(array).is_equal(other)
|
|
# should fail because the array not contains same elements and has diff size
|
|
other.append(array[2])
|
|
assert_failure(func(): assert_array(array).is_equal(other)) \
|
|
.is_failed() \
|
|
.has_message("""
|
|
Expecting:
|
|
'%s'
|
|
but was
|
|
'%s'
|
|
|
|
Differences found:
|
|
Index Current Expected 5 <N/A> $value """
|
|
.dedent()
|
|
.trim_prefix("\n")
|
|
.replace("$value", str(array[2]) ) % [GdArrayTools.as_string(other, false), GdArrayTools.as_string(array, false)])
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_is_not_equal(_test :String, array, test_parameters = [
|
|
["Array", Array([1, 2, 3, 4, 5])],
|
|
["PackedByteArray", PackedByteArray([1, 2, 3, 4, 5])],
|
|
["PackedInt32Array", PackedInt32Array([1, 2, 3, 4, 5])],
|
|
["PackedInt64Array", PackedInt64Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat32Array", PackedFloat32Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat64Array", PackedFloat64Array([1, 2, 3, 4, 5])],
|
|
["PackedStringArray", PackedStringArray([1, 2, 3, 4, 5])],
|
|
["PackedVector2Array", PackedVector2Array([Vector2.ZERO, Vector2.LEFT, Vector2.RIGHT, Vector2.UP, Vector2.DOWN])],
|
|
["PackedVector3Array", PackedVector3Array([Vector3.ZERO, Vector3.LEFT, Vector3.RIGHT, Vector3.UP, Vector3.DOWN])],
|
|
["PackedColorArray", PackedColorArray([Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, Color.BLACK])] ]
|
|
) -> void:
|
|
|
|
var other = array.duplicate()
|
|
other.append(array[2])
|
|
assert_array(array).is_not_equal(other)
|
|
# should fail because the array contains same elements
|
|
assert_failure(func(): assert_array(array).is_not_equal(array.duplicate())) \
|
|
.is_failed() \
|
|
.has_message("""
|
|
Expecting:
|
|
'%s'
|
|
not equal to
|
|
'%s'"""
|
|
.dedent()
|
|
.trim_prefix("\n") % [GdDefaultValueDecoder.decode(array), GdDefaultValueDecoder.decode(array)])
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_is_empty(_test :String, array, test_parameters = [
|
|
["Array", Array([1, 2, 3, 4, 5])],
|
|
["PackedByteArray", PackedByteArray([1, 2, 3, 4, 5])],
|
|
["PackedInt32Array", PackedInt32Array([1, 2, 3, 4, 5])],
|
|
["PackedInt64Array", PackedInt64Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat32Array", PackedFloat32Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat64Array", PackedFloat64Array([1, 2, 3, 4, 5])],
|
|
["PackedStringArray", PackedStringArray([1, 2, 3, 4, 5])],
|
|
["PackedVector2Array", PackedVector2Array([Vector2.ZERO, Vector2.LEFT, Vector2.RIGHT, Vector2.UP, Vector2.DOWN])],
|
|
["PackedVector3Array", PackedVector3Array([Vector3.ZERO, Vector3.LEFT, Vector3.RIGHT, Vector3.UP, Vector3.DOWN])],
|
|
["PackedColorArray", PackedColorArray([Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, Color.BLACK])] ]
|
|
) -> void:
|
|
|
|
var empty = array.duplicate()
|
|
empty.clear()
|
|
assert_array(empty).is_empty()
|
|
# should fail because the array is not empty
|
|
assert_failure(func(): assert_array(array).is_empty()) \
|
|
.is_failed() \
|
|
.has_message("""
|
|
Expecting:
|
|
must be empty but was
|
|
'%s'"""
|
|
.dedent()
|
|
.trim_prefix("\n") % GdDefaultValueDecoder.decode(array))
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_is_not_empty(_test :String, array, test_parameters = [
|
|
["Array", Array([1, 2, 3, 4, 5])],
|
|
["PackedByteArray", PackedByteArray([1, 2, 3, 4, 5])],
|
|
["PackedInt32Array", PackedInt32Array([1, 2, 3, 4, 5])],
|
|
["PackedInt64Array", PackedInt64Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat32Array", PackedFloat32Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat64Array", PackedFloat64Array([1, 2, 3, 4, 5])],
|
|
["PackedStringArray", PackedStringArray([1, 2, 3, 4, 5])],
|
|
["PackedVector2Array", PackedVector2Array([Vector2.ZERO, Vector2.LEFT, Vector2.RIGHT, Vector2.UP, Vector2.DOWN])],
|
|
["PackedVector3Array", PackedVector3Array([Vector3.ZERO, Vector3.LEFT, Vector3.RIGHT, Vector3.UP, Vector3.DOWN])],
|
|
["PackedColorArray", PackedColorArray([Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, Color.BLACK])] ]
|
|
) -> void:
|
|
|
|
assert_array(array).is_not_empty()
|
|
# should fail because the array is empty
|
|
var empty = array.duplicate()
|
|
empty.clear()
|
|
assert_failure(func(): assert_array(empty).is_not_empty()) \
|
|
.is_failed() \
|
|
.has_message("Expecting:\n must not be empty")
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_is_same(value, test_parameters = [
|
|
[[0]],
|
|
[PackedByteArray([0])],
|
|
[PackedFloat32Array([0.0])],
|
|
[PackedFloat64Array([0.0])],
|
|
[PackedInt32Array([0])],
|
|
[PackedInt64Array([0])],
|
|
[PackedStringArray([""])],
|
|
[PackedColorArray([Color.RED])],
|
|
[PackedVector2Array([Vector2.ZERO])],
|
|
[PackedVector3Array([Vector3.ZERO])],
|
|
]) -> void:
|
|
assert_array(value).is_same(value)
|
|
|
|
var v := GdDefaultValueDecoder.decode(value)
|
|
assert_failure(func(): assert_array(value).is_same(value.duplicate()))\
|
|
.is_failed()\
|
|
.has_message("""
|
|
Expecting:
|
|
'%s'
|
|
to refer to the same object
|
|
'%s'"""
|
|
.dedent()
|
|
.trim_prefix("\n") % [v, v])
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_is_not_same(value, test_parameters = [
|
|
[[0]],
|
|
[PackedByteArray([0])],
|
|
[PackedFloat32Array([0.0])],
|
|
[PackedFloat64Array([0.0])],
|
|
[PackedInt32Array([0])],
|
|
[PackedInt64Array([0])],
|
|
[PackedStringArray([""])],
|
|
[PackedColorArray([Color.RED])],
|
|
[PackedVector2Array([Vector2.ZERO])],
|
|
[PackedVector3Array([Vector3.ZERO])],
|
|
]) -> void:
|
|
assert_array(value).is_not_same(value.duplicate())
|
|
|
|
assert_failure(func(): assert_array(value).is_not_same(value))\
|
|
.is_failed()\
|
|
.has_message("Expecting not same:\n '%s'" % GdDefaultValueDecoder.decode(value))
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_has_size(_test :String, array, test_parameters = [
|
|
["Array", Array([1, 2, 3, 4, 5])],
|
|
["PackedByteArray", PackedByteArray([1, 2, 3, 4, 5])],
|
|
["PackedInt32Array", PackedInt32Array([1, 2, 3, 4, 5])],
|
|
["PackedInt64Array", PackedInt64Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat32Array", PackedFloat32Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat64Array", PackedFloat64Array([1, 2, 3, 4, 5])],
|
|
["PackedStringArray", PackedStringArray([1, 2, 3, 4, 5])],
|
|
["PackedVector2Array", PackedVector2Array([Vector2.ZERO, Vector2.LEFT, Vector2.RIGHT, Vector2.UP, Vector2.DOWN])],
|
|
["PackedVector3Array", PackedVector3Array([Vector3.ZERO, Vector3.LEFT, Vector3.RIGHT, Vector3.UP, Vector3.DOWN])],
|
|
["PackedColorArray", PackedColorArray([Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, Color.BLACK])] ]
|
|
) -> void:
|
|
|
|
assert_array(array).has_size(5)
|
|
# should fail because the array has a size of 5
|
|
assert_failure(func(): assert_array(array).has_size(4)) \
|
|
.is_failed() \
|
|
.has_message("""
|
|
Expecting size:
|
|
'4'
|
|
but was
|
|
'5'"""
|
|
.dedent()
|
|
.trim_prefix("\n"))
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_contains(_test :String, array, test_parameters = [
|
|
["Array", Array([1, 2, 3, 4, 5])],
|
|
["PackedByteArray", PackedByteArray([1, 2, 3, 4, 5])],
|
|
["PackedInt32Array", PackedInt32Array([1, 2, 3, 4, 5])],
|
|
["PackedInt64Array", PackedInt64Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat32Array", PackedFloat32Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat64Array", PackedFloat64Array([1, 2, 3, 4, 5])],
|
|
["PackedStringArray", PackedStringArray([1, 2, 3, 4, 5])],
|
|
["PackedVector2Array", PackedVector2Array([Vector2.ZERO, Vector2.LEFT, Vector2.RIGHT, Vector2.UP, Vector2.DOWN])],
|
|
["PackedVector3Array", PackedVector3Array([Vector3.ZERO, Vector3.LEFT, Vector3.RIGHT, Vector3.UP, Vector3.DOWN])],
|
|
["PackedColorArray", PackedColorArray([Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, Color.BLACK])] ]
|
|
) -> void:
|
|
|
|
assert_array(array).contains([array[1], array[3], array[4]])
|
|
# should fail because the array not contains 7 and 6
|
|
var do_contains := [array[1], 7, 6]
|
|
assert_failure(func(): assert_array(array).contains(do_contains)) \
|
|
.is_failed() \
|
|
.has_message("""
|
|
Expecting contains elements:
|
|
'$source'
|
|
do contains (in any order)
|
|
'$contains'
|
|
but could not find elements:
|
|
'[7, 6]'"""
|
|
.dedent()
|
|
.trim_prefix("\n")
|
|
.replace("$source", GdDefaultValueDecoder.decode(array))
|
|
.replace("$contains", GdDefaultValueDecoder.decode(do_contains))
|
|
)
|
|
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_contains_exactly(_test :String, array, test_parameters = [
|
|
["Array", Array([1, 2, 3, 4, 5])],
|
|
["PackedByteArray", PackedByteArray([1, 2, 3, 4, 5])],
|
|
["PackedInt32Array", PackedInt32Array([1, 2, 3, 4, 5])],
|
|
["PackedInt64Array", PackedInt64Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat32Array", PackedFloat32Array([1, 2, 3, 4, 5])],
|
|
["PackedFloat64Array", PackedFloat64Array([1, 2, 3, 4, 5])],
|
|
["PackedStringArray", PackedStringArray([1, 2, 3, 4, 5])],
|
|
["PackedVector2Array", PackedVector2Array([Vector2.ZERO, Vector2.LEFT, Vector2.RIGHT, Vector2.UP, Vector2.DOWN])],
|
|
["PackedVector3Array", PackedVector3Array([Vector3.ZERO, Vector3.LEFT, Vector3.RIGHT, Vector3.UP, Vector3.DOWN])],
|
|
["PackedColorArray", PackedColorArray([Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, Color.BLACK])] ]
|
|
) -> void:
|
|
|
|
assert_array(array).contains_exactly(array.duplicate())
|
|
# should fail because the array not contains same elements but in different order
|
|
var shuffled = array.duplicate()
|
|
shuffled[1] = array[3]
|
|
shuffled[3] = array[1]
|
|
assert_failure(func(): assert_array(array).contains_exactly(shuffled)) \
|
|
.is_failed() \
|
|
.has_message("""
|
|
Expecting contains exactly elements:
|
|
'$source'
|
|
do contains (in same order)
|
|
'$contains'
|
|
but has different order at position '1'
|
|
'$A' vs '$B'"""
|
|
.dedent()
|
|
.trim_prefix("\n")
|
|
.replace("$A", GdDefaultValueDecoder.decode(array[1]))
|
|
.replace("$B", GdDefaultValueDecoder.decode(array[3]))
|
|
.replace("$source", GdDefaultValueDecoder.decode(array))
|
|
.replace("$contains", GdDefaultValueDecoder.decode(shuffled))
|
|
)
|
|
|
|
@warning_ignore("unused_parameter")
|
|
func test_override_failure_message(_test :String, array, test_parameters = [
|
|
["Array", Array()],
|
|
["PackedByteArray", PackedByteArray()],
|
|
["PackedInt32Array", PackedInt32Array()],
|
|
["PackedInt64Array", PackedInt64Array()],
|
|
["PackedFloat32Array", PackedFloat32Array()],
|
|
["PackedFloat64Array", PackedFloat64Array()],
|
|
["PackedStringArray", PackedStringArray()],
|
|
["PackedVector2Array", PackedVector2Array()],
|
|
["PackedVector3Array", PackedVector3Array()],
|
|
["PackedColorArray", PackedColorArray()] ]
|
|
) -> void:
|
|
|
|
assert_failure(func(): assert_array(array) \
|
|
.override_failure_message("Custom failure message") \
|
|
.is_null()) \
|
|
.is_failed() \
|
|
.has_message("Custom failure message")
|