773 lines
23 KiB
GDScript
773 lines
23 KiB
GDScript
extends "res://addons/gut/test.gd"
|
|
|
|
func before_each():
|
|
gut.file_touch('user://some_test_file')
|
|
|
|
func after_each():
|
|
gut.file_delete('user://some_test_file')
|
|
|
|
|
|
func test_pending():
|
|
pending('This test is not implemented yet')
|
|
pending()
|
|
|
|
func test_equals():
|
|
var one = 1
|
|
var node1 = Node.new()
|
|
var node2 = node1
|
|
|
|
assert_eq(one, 1, 'one should equal one') # PASS
|
|
assert_eq('racecar', 'racecar') # PASS
|
|
assert_eq(node2, node1) # PASS
|
|
assert_eq([1, 2, 3], [1, 2, 3]) # PASS
|
|
var d1_pass = {'a':1}
|
|
var d2_pass = d1_pass
|
|
assert_eq(d1_pass, d2_pass) # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_eq(1, 2) # FAIL
|
|
assert_eq('hello', 'world') # FAIL
|
|
assert_eq(self, node1) # FAIL
|
|
assert_eq([1, 'two', 3], [1, 2, 3, 4]) # FAIL
|
|
assert_eq({'a':1}, {'a':1}) # FAIL
|
|
|
|
func test_not_equal():
|
|
var two = 2
|
|
var node1 = Node.new()
|
|
|
|
gut.p('-- passing --')
|
|
assert_ne(two, 1, 'Two should not equal one.') # PASS
|
|
assert_ne('hello', 'world') # PASS
|
|
assert_ne(self, node1) # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_ne(two, 2) # FAIL
|
|
assert_ne('one', 'one') # FAIL
|
|
assert_ne('2', 2) # FAIL
|
|
|
|
func test_almost_equals():
|
|
|
|
gut.p('-- passing --')
|
|
assert_almost_eq(0, 1, 1, '0 within range of 1 +/- 1') # PASS
|
|
assert_almost_eq(2, 1, 1, '2 within range of 1 +/- 1') # PASS
|
|
|
|
assert_almost_eq(1.2, 1.0, .5, '1.2 within range of 1 +/- .5') # PASS
|
|
assert_almost_eq(.5, 1.0, .5, '.5 within range of 1 +/- .5') # PASS
|
|
|
|
assert_almost_eq(Vector2(.5, 1.5), Vector2(1.0, 1.0), Vector2(.5, .5)) # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_almost_eq(1, 3, 1, '1 outside range of 3 +/- 1') # FAIL
|
|
assert_almost_eq(2.6, 3.0, .2, '2.6 outside range of 3 +/- .2') # FAIL
|
|
|
|
assert_almost_eq(Vector2(.5, 1.5), Vector2(1.0, 1.0), Vector2(.25, .25)) # PASS
|
|
|
|
func test_almost_not_equals():
|
|
gut.p('-- passing --')
|
|
assert_almost_ne(1, 3, 1, '1 outside range of 3 +/- 1') # PASS
|
|
assert_almost_ne(2.6, 3.0, .2, '2.6 outside range of 3 +/- .2') # PASS
|
|
|
|
assert_almost_ne(Vector2(.5, 1.5), Vector2(1.0, 1.0), Vector2(.25, .25)) # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_almost_ne(0, 1, 1, '0 within range of 1 +/- 1') # FAIL
|
|
assert_almost_ne(2, 1, 1, '2 within range of 1 +/- 1') # FAIL
|
|
|
|
assert_almost_ne(1.2, 1.0, .5, '1.2 within range of 1 +/- .5') # FAIL
|
|
assert_almost_ne(.5, 1.0, .5, '.5 within range of 1 +/- .5') # FAIL
|
|
|
|
assert_almost_ne(Vector2(.5, 1.5), Vector2(1.0, 1.0), Vector2(.5, .5)) # FAIL
|
|
|
|
func test_greater_than():
|
|
var bigger = 5
|
|
var smaller = 0
|
|
|
|
gut.p('-- passing --')
|
|
assert_gt(bigger, smaller, 'Bigger should be greater than smaller') # PASS
|
|
assert_gt('b', 'a') # PASS
|
|
assert_gt('a', 'A') # PASS
|
|
assert_gt(1.1, 1) # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_gt('a', 'a') # FAIL
|
|
assert_gt(1.0, 1) # FAIL
|
|
assert_gt(smaller, bigger) # FAIL
|
|
|
|
func test_less_than():
|
|
var bigger = 5
|
|
var smaller = 0
|
|
gut.p('-- passing --')
|
|
assert_lt(smaller, bigger, 'Smaller should be less than bigger') # PASS
|
|
assert_lt('a', 'b') # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_lt('z', 'x') # FAIL
|
|
assert_lt(-5, -5) # FAIL
|
|
|
|
func test_true():
|
|
gut.p('-- passing --')
|
|
assert_true(true, 'True should be true') # PASS
|
|
assert_true(5 == 5, 'That expressions should be true') # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_true(false) # FAIL
|
|
assert_true('a' == 'b') # FAIL
|
|
assert_true('b') # FAIL
|
|
assert_true(1)
|
|
|
|
func test_false():
|
|
gut.p('-- passing --')
|
|
assert_false(false, 'False is false') # PASS
|
|
assert_false(1 == 2) # PASS
|
|
assert_false('a' == 'z') # PASS
|
|
assert_false(self.has_user_signal('nope')) # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_false(true) # FAIL
|
|
assert_false('ABC' == 'ABC') # FAIL
|
|
assert_false(null) # FAIL
|
|
assert_false(0)
|
|
|
|
|
|
func test_null():
|
|
gut.p('-- passing --')
|
|
assert_null(null)
|
|
|
|
gut.p('-- failing --')
|
|
assert_null('a')
|
|
assert_null(1)
|
|
|
|
func test_not_null():
|
|
gut.p('-- passing --')
|
|
assert_not_null('a')
|
|
assert_not_null(1)
|
|
|
|
gut.p('-- failing --')
|
|
assert_not_null(null)
|
|
|
|
|
|
func test_assert_between():
|
|
gut.p('-- passing --')
|
|
assert_between(5, 0, 10, 'Five should be between 0 and 10') # PASS
|
|
assert_between(10, 0, 10) # PASS
|
|
assert_between(0, 0, 10) # PASS
|
|
assert_between(2.25, 2, 4.0) # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_between('a', 'b', 'c') # FAIL
|
|
assert_between(1, 5, 10) # FAIL
|
|
|
|
|
|
func test_assert_not_between():
|
|
gut.p('-- passing --')
|
|
assert_not_between(1, 5, 10) # PASS
|
|
assert_not_between('a', 'b', 'd') # PASS
|
|
assert_not_between('d', 'b', 'd') # PASS
|
|
assert_not_between(10, 0, 10) # PASS
|
|
assert_not_between(-2, -2, 10) # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_not_between(5, 0, 10, 'Five shouldnt be between 0 and 10') # FAIL
|
|
assert_not_between(0.25, -2.0, 4.0) # FAIL
|
|
|
|
|
|
func test_has():
|
|
var an_array = [1, 2, 3, 'four', 'five']
|
|
var a_hash = { 'one':1, 'two':2, '3':'three'}
|
|
|
|
gut.p('-- passing --')
|
|
assert_has(an_array, 'four') # PASS
|
|
assert_has(an_array, 2) # PASS
|
|
# the hash's has method checks indexes not values
|
|
assert_has(a_hash, 'one') # PASS
|
|
assert_has(a_hash, '3') # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_has(an_array, 5) # FAIL
|
|
assert_has(an_array, self) # FAIL
|
|
assert_has(a_hash, 3) # FAIL
|
|
assert_has(a_hash, 'three') # FAIL
|
|
|
|
func test_does_not_have():
|
|
var an_array = [1, 2, 3, 'four', 'five']
|
|
var a_hash = { 'one':1, 'two':2, '3':'three'}
|
|
|
|
gut.p('-- passing --')
|
|
assert_does_not_have(an_array, 5) # PASS
|
|
assert_does_not_have(an_array, self) # PASS
|
|
assert_does_not_have(a_hash, 3) # PASS
|
|
assert_does_not_have(a_hash, 'three')
|
|
|
|
gut.p('-- failing --')
|
|
assert_does_not_have(an_array, 'four') # FAIL
|
|
assert_does_not_have(an_array, 2) # FAIL
|
|
# the hash's has method checks indexes not values
|
|
assert_does_not_have(a_hash, 'one') # FAIL
|
|
assert_does_not_have(a_hash, '3') # FAIL
|
|
|
|
func test_string_contains():
|
|
gut.p('-- passing --')
|
|
assert_string_contains('abc 123', 'a')
|
|
assert_string_contains('abc 123', 'BC', false)
|
|
assert_string_contains('abc 123', '3')
|
|
|
|
gut.p('-- failing --')
|
|
assert_string_contains('abc 123', 'A')
|
|
assert_string_contains('abc 123', 'BC')
|
|
assert_string_contains('abc 123', '012')
|
|
|
|
func test_string_starts_with():
|
|
gut.p('-- passing --')
|
|
assert_string_starts_with('abc 123', 'a')
|
|
assert_string_starts_with('abc 123', 'ABC', false)
|
|
assert_string_starts_with('abc 123', 'abc 123')
|
|
|
|
gut.p('-- failing --')
|
|
assert_string_starts_with('abc 123', 'z')
|
|
assert_string_starts_with('abc 123', 'ABC')
|
|
assert_string_starts_with('abc 123', 'abc 1234')
|
|
|
|
func test_string_ends_with():
|
|
gut.p('-- passing --')
|
|
assert_string_ends_with('abc 123', '123')
|
|
assert_string_ends_with('abc 123', 'C 123', false)
|
|
assert_string_ends_with('abc 123', 'abc 123')
|
|
|
|
gut.p('-- failing --')
|
|
assert_string_ends_with('abc 123', '1234')
|
|
assert_string_ends_with('abc 123', 'C 123')
|
|
assert_string_ends_with('abc 123', 'nope')
|
|
|
|
func test_assert_file_exists():
|
|
gut.p('-- passing --')
|
|
assert_file_exists('res://addons/gut/gut.gd') # PASS
|
|
assert_file_exists('user://some_test_file') # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_file_exists('user://file_does_not.exist') # FAIL
|
|
assert_file_exists('res://some_dir/another_dir/file_does_not.exist') # FAIL
|
|
|
|
func test_assert_file_does_not_exist():
|
|
gut.p('-- passing --')
|
|
assert_file_does_not_exist('user://file_does_not.exist') # PASS
|
|
assert_file_does_not_exist('res://some_dir/another_dir/file_does_not.exist') # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_file_does_not_exist('res://addons/gut/gut.gd') # FAIL
|
|
|
|
func test_assert_file_empty():
|
|
gut.p('-- passing --')
|
|
assert_file_empty('user://some_test_file') # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_file_empty('res://addons/gut/gut.gd')
|
|
|
|
func test_assert_file_not_empty():
|
|
gut.p('-- passing --')
|
|
assert_file_not_empty('res://addons/gut/gut.gd') # PASS
|
|
|
|
gut.p('-- failing --')
|
|
assert_file_not_empty('user://some_test_file') # FAIL
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class SomeClass:
|
|
var _count = 0
|
|
|
|
func get_count():
|
|
return _count
|
|
func set_count(number):
|
|
_count = number
|
|
|
|
func get_nothing():
|
|
pass
|
|
func set_nothing(val):
|
|
pass
|
|
|
|
func test_assert_accessors():
|
|
var some_class = SomeClass.new()
|
|
gut.p('-- passing --')
|
|
assert_accessors(some_class, 'count', 0, 20) # 4 PASSING
|
|
|
|
gut.p('-- failing --')
|
|
# 1 FAILING, 3 PASSING
|
|
assert_accessors(some_class, 'count', 'not_default', 20)
|
|
# 2 FAILING, 2 PASSING
|
|
assert_accessors(some_class, 'nothing', 'hello', 22)
|
|
# 2 FAILING
|
|
assert_accessors(some_class, 'does_not_exist', 'does_not', 'matter')
|
|
|
|
func test_assert_has_method():
|
|
var some_class = SomeClass.new()
|
|
gut.p('-- passing --')
|
|
assert_has_method(some_class, 'get_nothing')
|
|
assert_has_method(some_class, 'set_count')
|
|
|
|
gut.p('-- failing --')
|
|
assert_has_method(some_class, 'method_does_not_exist')
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class ExportClass:
|
|
@export var some_number = 5
|
|
@export var some_scene: PackedScene
|
|
var some_variable = 1
|
|
|
|
func test_assert_exports():
|
|
var obj = ExportClass.new()
|
|
|
|
gut.p('-- passing --')
|
|
assert_exports(obj, "some_number", TYPE_INT)
|
|
assert_exports(obj, "some_scene", TYPE_OBJECT)
|
|
|
|
gut.p('-- failing --')
|
|
assert_exports(obj, 'some_number', TYPE_VECTOR2)
|
|
assert_exports(obj, 'some_scene', TYPE_AABB)
|
|
assert_exports(obj, 'some_variable', TYPE_INT)
|
|
# ------------------------------------------------------------------------------
|
|
|
|
class MovingNode:
|
|
extends Node2D
|
|
var _speed = 2
|
|
|
|
func _ready():
|
|
set_process(true)
|
|
|
|
func _process(delta):
|
|
set_position(get_position() + Vector2(_speed * delta, 0))
|
|
|
|
func test_illustrate_yield():
|
|
var moving_node = MovingNode.new()
|
|
add_child_autofree(moving_node)
|
|
moving_node.set_position(Vector2(0, 0))
|
|
|
|
# While the yield happens, the node should move
|
|
await yield_for(2)
|
|
assert_gt(moving_node.get_position().x, 0)
|
|
assert_between(moving_node.get_position().x, 3.9, 4, 'it should move almost 4 whatevers at speed 2')
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class TimedSignaler:
|
|
extends Node2D
|
|
var _time = 0
|
|
|
|
signal the_signal
|
|
func _init(time):
|
|
_time = time
|
|
|
|
func start():
|
|
var t = Timer.new()
|
|
add_child(t)
|
|
t.set_wait_time(_time)
|
|
t.connect('timeout',Callable(self,'_on_timer_timeout'))
|
|
t.set_one_shot(true)
|
|
t.start()
|
|
|
|
func _on_timer_timeout():
|
|
emit_signal('the_signal')
|
|
|
|
func test_illustrate_yield_to_with_less_time():
|
|
var t = TimedSignaler.new(5)
|
|
add_child_autofree(t)
|
|
t.start()
|
|
await wait_for_signal(t.the_signal, 1)
|
|
# since we setup t to emit after 5 seconds, this will fail because we
|
|
# only yielded for 1 second vail yield_to
|
|
assert_signal_emitted(t, 'the_signal', 'This will fail')
|
|
|
|
func test_illustrate_yield_to_with_more_time():
|
|
var t = TimedSignaler.new(1)
|
|
add_child_autofree(t)
|
|
t.start()
|
|
await wait_for_signal(t.the_signal, 5)
|
|
# since we wait longer than it will take to emit the signal, this assert
|
|
# will pass
|
|
assert_signal_emitted(t, 'the_signal', 'This will pass')
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class SignalObject:
|
|
func _init():
|
|
add_user_signal('some_signal')
|
|
add_user_signal('other_signal')
|
|
|
|
func test_assert_signal_emitted():
|
|
var obj = SignalObject.new()
|
|
|
|
watch_signals(obj)
|
|
obj.emit_signal('some_signal')
|
|
|
|
gut.p('-- passing --')
|
|
assert_signal_emitted(obj, 'some_signal')
|
|
|
|
gut.p('-- failing --')
|
|
# Fails with specific message that the object does not have the signal
|
|
assert_signal_emitted(obj, 'signal_does_not_exist')
|
|
# Fails because the object passed is not being watched
|
|
assert_signal_emitted(SignalObject.new(), 'some_signal')
|
|
# Fails because the signal was not emitted
|
|
assert_signal_emitted(obj, 'other_signal')
|
|
|
|
func test_assert_signal_not_emitted():
|
|
var obj = SignalObject.new()
|
|
|
|
watch_signals(obj)
|
|
obj.emit_signal('some_signal')
|
|
|
|
gut.p('-- passing --')
|
|
assert_signal_not_emitted(obj, 'other_signal')
|
|
|
|
gut.p('-- failing --')
|
|
# Fails with specific message that the object does not have the signal
|
|
assert_signal_not_emitted(obj, 'signal_does_not_exist')
|
|
# Fails because the object passed is not being watched
|
|
assert_signal_not_emitted(SignalObject.new(), 'some_signal')
|
|
# Fails because the signal was emitted
|
|
assert_signal_not_emitted(obj, 'some_signal')
|
|
|
|
func test_assert_signal_emitted_with_parameters():
|
|
var obj = SignalObject.new()
|
|
|
|
watch_signals(obj)
|
|
# emit the signal 3 times to illustrate how the index works in
|
|
# assert_signal_emitted_with_parameters
|
|
obj.emit_signal('some_signal', 1, 2, 3)
|
|
obj.emit_signal('some_signal', 'a', 'b', 'c')
|
|
obj.emit_signal('some_signal', 'one', 'two', 'three')
|
|
|
|
gut.p('-- passing --')
|
|
# Passes b/c the default parameters to check are the last emission of
|
|
# the signal
|
|
assert_signal_emitted_with_parameters(obj, 'some_signal', ['one', 'two', 'three'])
|
|
# Passes because the parameters match the specified emission based on index.
|
|
assert_signal_emitted_with_parameters(obj, 'some_signal', [1, 2, 3], 0)
|
|
|
|
gut.p('-- failing --')
|
|
# Fails with specific message that the object does not have the signal
|
|
assert_signal_emitted_with_parameters(obj, 'signal_does_not_exist', [])
|
|
# Fails because the object passed is not being watched
|
|
assert_signal_emitted_with_parameters(SignalObject.new(), 'some_signal', [])
|
|
# Fails because parameters do not match latest emission
|
|
assert_signal_emitted_with_parameters(obj, 'some_signal', [1, 2, 3])
|
|
# Fails because the parameters for the specified index do not match
|
|
assert_signal_emitted_with_parameters(obj, 'some_signal', [1, 2, 3], 1)
|
|
|
|
func test_assert_signal_emit_count():
|
|
var obj_a = SignalObject.new()
|
|
var obj_b = SignalObject.new()
|
|
|
|
watch_signals(obj_a)
|
|
watch_signals(obj_b)
|
|
obj_a.emit_signal('some_signal')
|
|
obj_a.emit_signal('some_signal')
|
|
|
|
obj_b.emit_signal('some_signal')
|
|
obj_b.emit_signal('other_signal')
|
|
|
|
gut.p('-- passing --')
|
|
assert_signal_emit_count(obj_a, 'some_signal', 2)
|
|
assert_signal_emit_count(obj_a, 'other_signal', 0)
|
|
|
|
assert_signal_emit_count(obj_b, 'other_signal', 1)
|
|
|
|
gut.p('-- failing --')
|
|
# Fails with specific message that the object does not have the signal
|
|
assert_signal_emit_count(obj_a, 'signal_does_not_exist', 99)
|
|
# Fails because the object passed is not being watched
|
|
assert_signal_emit_count(SignalObject.new(), 'some_signal', 99)
|
|
# The following fail for obvious reasons
|
|
assert_signal_emit_count(obj_a, 'some_signal', 0)
|
|
assert_signal_emit_count(obj_b, 'other_signal', 283)
|
|
|
|
func test_assert_has_signal():
|
|
var obj = SignalObject.new()
|
|
|
|
gut.p('-- passing --')
|
|
assert_has_signal(obj, 'some_signal')
|
|
assert_has_signal(obj, 'other_signal')
|
|
|
|
gut.p('-- failing --')
|
|
assert_has_signal(obj, 'not_a real SIGNAL')
|
|
assert_has_signal(obj, 'yea, this one doesn\'t exist either')
|
|
# Fails because the signal is not a user signal. Node2D does have the
|
|
# specified signal but it can't be checked this way. It could be watched
|
|
# and asserted that it fired though.
|
|
assert_has_signal(Node2D.new(), 'exit_tree')
|
|
|
|
func test_get_signal_parameters():
|
|
var obj = SignalObject.new()
|
|
watch_signals(obj)
|
|
obj.emit_signal('some_signal', 1, 2, 3)
|
|
obj.emit_signal('some_signal', 'a', 'b', 'c')
|
|
|
|
gut.p('-- passing --')
|
|
# passes because get_signal_parameters returns the most recent emission
|
|
# by default
|
|
assert_eq(get_signal_parameters(obj, 'some_signal'), ['a', 'b', 'c'])
|
|
assert_eq(get_signal_parameters(obj, 'some_signal', 0), [1, 2, 3])
|
|
# if the signal was not fired null is returned
|
|
assert_eq(get_signal_parameters(obj, 'other_signal'), null)
|
|
# if the signal does not exist or isn't being watched null is returned
|
|
assert_eq(get_signal_parameters(obj, 'signal_dne'), null)
|
|
|
|
gut.p('-- failing --')
|
|
assert_eq(get_signal_parameters(obj, 'some_signal'), [1, 2, 3])
|
|
assert_eq(get_signal_parameters(obj, 'some_signal', 0), ['a', 'b', 'c'])
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class BaseClass:
|
|
var a = 1
|
|
class SubClass:
|
|
extends BaseClass
|
|
|
|
|
|
func test_assert_is():
|
|
gut.p('-- passing --')
|
|
assert_is(Node2D.new(), Node2D)
|
|
assert_is(Label.new(), CanvasItem)
|
|
assert_is(SubClass.new(), BaseClass)
|
|
# Since this is a test script that inherits from test.gd, so
|
|
# this passes. It's not obvious w/o seeing the whole script
|
|
# so I'm telling you. You'll just have to trust me.
|
|
assert_is(self, load('res://addons/gut/test.gd'))
|
|
|
|
var Gut = load('res://addons/gut/gut.gd')
|
|
var a_gut = Gut.new()
|
|
assert_is(a_gut, Gut)
|
|
|
|
gut.p('-- failing --')
|
|
assert_is(Node2D.new(), Node2D.new())
|
|
assert_is(BaseClass.new(), SubClass)
|
|
assert_is('a', 'b')
|
|
assert_is([], Node)
|
|
|
|
# ------------------------------------------------------------------------------
|
|
func test_assert_called():
|
|
var DOUBLE_ME_PATH = 'res://test/resources/doubler_test_objects/double_extends_node2d.gd'
|
|
|
|
var doubled = double(DOUBLE_ME_PATH).new()
|
|
doubled.set_value(4)
|
|
doubled.set_value(5)
|
|
doubled.has_two_params_one_default('a')
|
|
doubled.has_two_params_one_default('a', 'b')
|
|
doubled.get_position()
|
|
doubled.set_position(Vector2(100, 100))
|
|
|
|
gut.p('-- passing --')
|
|
assert_called(doubled, 'set_value')
|
|
assert_called(doubled, 'set_value', [5])
|
|
assert_called(doubled, 'has_two_params_one_default', ['a', null])
|
|
assert_called(doubled, 'has_two_params_one_default', ['a', 'b'])
|
|
assert_called(doubled, 'get_position')
|
|
|
|
gut.p('-- failing --')
|
|
assert_called(doubled, 'get_value')
|
|
assert_called(doubled, 'set_value', ['nope'])
|
|
# This fails b/c double_me.gd does not implement a version of this method and
|
|
# is not yet being tracked by gut. This should change in future.
|
|
assert_called(doubled, 'set_position')
|
|
# This fails b/c Gut isn't smart enough to fill in default values for you...
|
|
# ast least not yet.
|
|
assert_called(doubled, 'has_two_params_one_default', ['a'])
|
|
# This fails with a specific message indicating that you have to pass an
|
|
# instance of a doubled class.
|
|
assert_called(GDScript.new(), 'some_method')
|
|
|
|
func test_assert_call_count():
|
|
var DOUBLE_ME_PATH = 'res://test/resources/doubler_test_objects/double_extends_node2d.gd'
|
|
|
|
var doubled = double(DOUBLE_ME_PATH).new()
|
|
doubled.set_value(4)
|
|
doubled.set_value(5)
|
|
doubled.has_two_params_one_default('a')
|
|
doubled.has_two_params_one_default('a', 'b')
|
|
doubled.set_position(Vector2(100, 100))
|
|
|
|
gut.p('-- passing --')
|
|
assert_call_count(doubled, 'set_value', 2)
|
|
assert_call_count(doubled, 'set_value', 1, [4])
|
|
assert_call_count(doubled, 'has_two_params_one_default', 1, ['a', null])
|
|
assert_call_count(doubled, 'get_value', 0)
|
|
|
|
gut.p('-- failing --')
|
|
assert_call_count(doubled, 'set_value', 5)
|
|
assert_call_count(doubled, 'set_value', 2, [4])
|
|
assert_call_count(doubled, 'get_value', 1)
|
|
# This fails with a specific message indicating that you have to pass an
|
|
# instance of a doubled class even though technically the method was called.
|
|
assert_call_count(GDScript.new(), 'some_method', 0)
|
|
# This fails b/c double_extends_node2d does not have it's own implementation
|
|
# of set_position. The function is supplied by the parent class and these
|
|
# methods are not yet being recorded.
|
|
assert_call_count(doubled, 'set_position', 1)
|
|
|
|
func test_get_call_parameters():
|
|
var DOUBLE_ME_PATH = 'res://test/resources/doubler_test_objects/double_extends_node2d.gd'
|
|
|
|
var doubled = double(DOUBLE_ME_PATH).new()
|
|
doubled.set_value(5)
|
|
doubled.has_two_params_one_default('a')
|
|
doubled.has_two_params_one_default('x', 'y')
|
|
|
|
# prints [5]
|
|
print(get_call_parameters(doubled, 'set_value'))
|
|
# prints [x, y]
|
|
print(get_call_parameters(doubled, 'has_two_params_one_default'))
|
|
# prints [a, Null]
|
|
print(get_call_parameters(doubled, 'has_two_params_one_default', 0))
|
|
|
|
func test_replace_node():
|
|
# This scene has:
|
|
# Node2D
|
|
# - Label
|
|
# - MyPanel
|
|
# - MyButton
|
|
#
|
|
# And code:
|
|
#
|
|
# double_me_scene.gd:
|
|
# extends Node2D
|
|
#
|
|
# onready var label = get_node('Label')
|
|
#
|
|
# func return_hello():
|
|
# return 'hello'
|
|
#
|
|
# func set_label_text(text):
|
|
# $Label.set_text(text)
|
|
#
|
|
# func get_button():
|
|
# return $MyPanel/MyButton
|
|
var DOUBLE_ME_SCENE = 'res://test/resources/doubler_test_objects/double_me_scene.tscn'
|
|
|
|
var scene = load(DOUBLE_ME_SCENE).instantiate()
|
|
add_child_autofree(scene)
|
|
var replace_label = Label.new()
|
|
replace_node(scene, 'Label', replace_label)
|
|
|
|
# Passing
|
|
scene.set_label_text('asdf')
|
|
assert_eq(replace_label.get_text(), 'asdf', "Since set_label_text references the label using $ this will point to the new one.")
|
|
|
|
var replace_button = Button.new()
|
|
replace_node(scene, 'MyPanel/MyButton', replace_button)
|
|
assert_eq(scene.get_button(), replace_button, 'Get button uses $ so this will work.')
|
|
|
|
# Failing
|
|
assert_eq(scene.label, replace_label, 'The variable "label" was set as onready so it will not be updated')
|
|
|
|
class Signaler:
|
|
signal the_signal
|
|
|
|
class Connector:
|
|
func connect_this():
|
|
pass
|
|
func other_method():
|
|
pass
|
|
|
|
func test_assert_connected():
|
|
var signaler = Signaler.new()
|
|
var connector = Connector.new()
|
|
signaler.connect('the_signal',Callable(connector,'connect_this'))
|
|
|
|
# Passing
|
|
assert_connected(signaler, connector, 'the_signal')
|
|
assert_connected(signaler, connector, 'the_signal', 'connect_this')
|
|
|
|
# Failing
|
|
var foo = Connector.new()
|
|
assert_connected(signaler, connector, 'the_signal', 'other_method')
|
|
assert_connected(signaler, connector, 'other_signal')
|
|
assert_connected(signaler, foo, 'the_signal')
|
|
|
|
|
|
func test_nested_difference():
|
|
var v1 = {'a':{'b':{'c':{'d':1}}}}
|
|
var v2 = {'a':{'b':{'c':{'d':2}}}}
|
|
var result = compare_deep(v1, v2)
|
|
gut.p(result.summary)
|
|
|
|
gut.p('Traversing differences:')
|
|
gut.p(result.differences['a'].differences['b'].differences['c'])
|
|
|
|
|
|
func test_mix_of_array_and_dictionaries_deep():
|
|
var a1 = [
|
|
'a', 'b', 'c',
|
|
[1, 2, 3, 4],
|
|
{'a':1, 'b':2, 'c':3},
|
|
[{'a':1}, {'b':2}]
|
|
]
|
|
var a2 = [
|
|
'a', 2, 'c',
|
|
['a', 2, 3, 'd'],
|
|
{'a':11, 'b':12, 'c':13},
|
|
[{'a':'diff'}, {'b':2}]
|
|
]
|
|
var result = compare_deep(a1, a2)
|
|
gut.p(result.summary)
|
|
|
|
gut.p('Traversing differences:')
|
|
gut.p(result.differences[5].differences[0].differences['a'])
|
|
|
|
|
|
|
|
|
|
|
|
func test_assert_eq_deep():
|
|
var complex_example = [
|
|
'a', 'b', 'c',
|
|
[1, 2, 3, 4],
|
|
{'a':1, 'b':2, 'c':3},
|
|
[{'a':1}, {'b':2}]
|
|
]
|
|
|
|
# Passing
|
|
assert_eq_deep([1, 2, {'a':1}], [1, 2, {'a':1}])
|
|
assert_eq_deep({'a':1, 'b':{'c':1}}, {'b':{'c':1}, 'a':1})
|
|
|
|
var shallow_copy = complex_example.duplicate(false)
|
|
var deep_copy = complex_example.duplicate(true)
|
|
assert_eq_deep(complex_example, shallow_copy)
|
|
assert_eq_deep(complex_example, deep_copy)
|
|
assert_eq_deep(shallow_copy, deep_copy)
|
|
|
|
# Failing
|
|
assert_eq_deep([1, 2, {'a':1}], [1, 2, {'a':1.0}]) # floats != ints
|
|
|
|
|
|
var SetGetTestNode = load("res://test/resources/test_assert_setget_test_objects/test_node.gd")
|
|
|
|
func test_assert_property():
|
|
gut.p('-- passing --')
|
|
assert_property(SetGetTestNode, 'has_both', 4, 9)
|
|
var test_node = SetGetTestNode.new()
|
|
assert_property(test_node, 'has_both', 4, 9)
|
|
|
|
gut.p('-- failing --')
|
|
assert_property(SetGetTestNode, 'has_setter', 2, 5) # missing getter
|
|
assert_property(SetGetTestNode, 'has_getter', 3, 7) # missing setter
|
|
assert_property(SetGetTestNode, 'has_both', 0, 10) # wrong default value
|
|
assert_property(SetGetTestNode, 'has_both_dnu_setget', 8, 10) # does not use setget
|
|
|
|
func test_assert_setget():
|
|
gut.p('-- passing --')
|
|
assert_setget(SetGetTestNode, 'has_both')
|
|
assert_setget(SetGetTestNode, 'non_default_both', '__set_default_both', '__get_default_both')
|
|
assert_setget(SetGetTestNode, 'non_default_getter', null, '__get_non_default_getter')
|
|
assert_setget(SetGetTestNode, 'non_default_setter', '__set_non_default_setter')
|
|
|
|
# These pass because it's not possible to check
|
|
# that a setter or getter does not exist
|
|
|
|
|
|
gut.p('-- failing --')
|
|
assert_setget(SetGetTestNode, 'no_setget') # does not use setget
|
|
assert_setget(SetGetTestNode, 'has_setter') # missing getter
|
|
assert_setget(SetGetTestNode, 'has_getter') # missing setter
|
|
assert_setget(SetGetTestNode, 'has_both', 'wrong_name', 'wrong_name') # wrong names
|
|
|
|
|
|
# assert_setget(HealthBar, 'label') # FAIL => setter or getter has to be specified
|
|
# assert_setget(HealthBar, 'label', true) # FAIL => setter does not exist
|
|
|
|
|