619 lines
21 KiB
GDScript3
619 lines
21 KiB
GDScript3
|
extends GutTest
|
||
|
|
|
||
|
|
class BaseTest:
|
||
|
|
extends GutInternalTester
|
||
|
|
|
||
|
|
const DOUBLE_WITH_STATIC = 'res://test/resources/doubler_test_objects/has_static_method.gd'
|
||
|
|
|
||
|
|
var DoubleWithStatic = load(DOUBLE_WITH_STATIC)
|
||
|
|
var Doubler = load('res://addons/gut/doubler.gd')
|
||
|
|
|
||
|
|
var print_source_when_failing = true
|
||
|
|
|
||
|
|
func get_source(thing):
|
||
|
|
var to_return = null
|
||
|
|
if(GutUtils.is_instance(thing)):
|
||
|
|
to_return = thing.get_script().get_source_code()
|
||
|
|
else:
|
||
|
|
to_return = thing.source_code
|
||
|
|
return to_return
|
||
|
|
|
||
|
|
|
||
|
|
func assert_source_contains(thing, look_for, text=''):
|
||
|
|
var source = get_source(thing)
|
||
|
|
var msg = str('Expected source for ', str(thing), ' to contain "', look_for, '": ', text)
|
||
|
|
if(source == null || source.find(look_for) == -1):
|
||
|
|
fail_test(msg)
|
||
|
|
if(print_source_when_failing):
|
||
|
|
var header = str('------ Source for ', _strutils.type2str(thing), ' ------')
|
||
|
|
gut.p(header)
|
||
|
|
gut.p(GutUtils.add_line_numbers(source))
|
||
|
|
else:
|
||
|
|
pass_test(msg)
|
||
|
|
|
||
|
|
|
||
|
|
func assert_source_not_contains(thing, look_for, text=''):
|
||
|
|
var source = get_source(thing)
|
||
|
|
var msg = str('Expected source for ', _strutils.type2str(thing), ' to not contain "', look_for, '": ', text)
|
||
|
|
if(source == null || source.find(look_for) == -1):
|
||
|
|
pass_test(msg)
|
||
|
|
else:
|
||
|
|
fail_test(msg)
|
||
|
|
if(print_source_when_failing):
|
||
|
|
var header = str('------ Source for ', _strutils.type2str(thing), ' ------')
|
||
|
|
gut.p(header)
|
||
|
|
gut.p(GutUtils.add_line_numbers(source))
|
||
|
|
|
||
|
|
|
||
|
|
func print_source(thing):
|
||
|
|
var source = get_source(thing)
|
||
|
|
gut.p(GutUtils.add_line_numbers(source))
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
class TestTheBasics:
|
||
|
|
extends BaseTest
|
||
|
|
|
||
|
|
var _doubler = null
|
||
|
|
|
||
|
|
var stubber = GutUtils.Stubber.new()
|
||
|
|
func before_each():
|
||
|
|
stubber.clear()
|
||
|
|
_doubler = Doubler.new()
|
||
|
|
_doubler.set_stubber(stubber)
|
||
|
|
_doubler.set_gut(gut)
|
||
|
|
_doubler.set_strategy(DOUBLE_STRATEGY.SCRIPT_ONLY)
|
||
|
|
var lgr = GutUtils.GutLogger.new()
|
||
|
|
lgr.set_gut(gut)
|
||
|
|
_doubler.set_logger(lgr)
|
||
|
|
_doubler.print_source = false
|
||
|
|
|
||
|
|
func test_get_set_stubber():
|
||
|
|
var dblr = Doubler.new()
|
||
|
|
var default_stubber = dblr.get_stubber()
|
||
|
|
assert_accessors(dblr, 'stubber', default_stubber, GutUtils.Stubber.new())
|
||
|
|
|
||
|
|
func test_can_get_set_spy():
|
||
|
|
assert_accessors(Doubler.new(), 'spy', null, GDScript.new())
|
||
|
|
|
||
|
|
func test_get_set_gut():
|
||
|
|
assert_accessors(Doubler.new(), 'gut', null, GDScript.new())
|
||
|
|
|
||
|
|
func test_get_set_logger():
|
||
|
|
assert_ne(_doubler.get_logger(), null)
|
||
|
|
var l = load('res://addons/gut/logger.gd').new()
|
||
|
|
_doubler.set_logger(l)
|
||
|
|
assert_eq(_doubler.get_logger(), l)
|
||
|
|
|
||
|
|
func test_doubler_sets_logger_of_method_maker():
|
||
|
|
assert_eq(_doubler.get_logger(), _doubler._method_maker.get_logger())
|
||
|
|
|
||
|
|
func test_setting_logger_sets_it_on_method_maker():
|
||
|
|
var l = load('res://addons/gut/logger.gd').new()
|
||
|
|
_doubler.set_logger(l)
|
||
|
|
assert_eq(_doubler.get_logger(), _doubler._method_maker.get_logger())
|
||
|
|
|
||
|
|
func test_get_set_strategy():
|
||
|
|
assert_accessors(_doubler, 'strategy', GutUtils.DOUBLE_STRATEGY.SCRIPT_ONLY, GutUtils.DOUBLE_STRATEGY.INCLUDE_NATIVE)
|
||
|
|
|
||
|
|
func test_cannot_set_strategy_to_invalid_values():
|
||
|
|
var default = _doubler.get_strategy()
|
||
|
|
_doubler.set_strategy(-1)
|
||
|
|
assert_tracked_gut_error()
|
||
|
|
assert_eq(_doubler.get_strategy(), default, 'original value retained')
|
||
|
|
|
||
|
|
func test_can_set_strategy_in_constructor():
|
||
|
|
var d = Doubler.new(GutUtils.DOUBLE_STRATEGY.INCLUDE_NATIVE)
|
||
|
|
assert_eq(d.get_strategy(), GutUtils.DOUBLE_STRATEGY.INCLUDE_NATIVE)
|
||
|
|
|
||
|
|
|
||
|
|
class TestDoublingScripts:
|
||
|
|
extends BaseTest
|
||
|
|
|
||
|
|
var _doubler = null
|
||
|
|
|
||
|
|
var stubber = GutUtils.Stubber.new()
|
||
|
|
func before_each():
|
||
|
|
stubber.clear()
|
||
|
|
_doubler = Doubler.new()
|
||
|
|
_doubler.set_stubber(stubber)
|
||
|
|
_doubler.set_gut(gut)
|
||
|
|
|
||
|
|
|
||
|
|
func test_doubling_object_includes_methods():
|
||
|
|
var inst = _doubler.double(DoubleMe)
|
||
|
|
inst = inst.new()
|
||
|
|
assert_source_contains(inst, 'func get_value(')
|
||
|
|
assert_source_contains(inst, 'func set_value(')
|
||
|
|
|
||
|
|
func test_doubling_methods_have_parameters_1():
|
||
|
|
var inst = _doubler.double(DoubleMe).new()
|
||
|
|
assert_source_contains(inst, 'has_one_param(p_one=', 'first parameter for one param method is defined')
|
||
|
|
|
||
|
|
# Don't see a way to see which have defaults and which do not, so we default
|
||
|
|
# everything.
|
||
|
|
func test_all_parameters_are_defaulted_to_null():
|
||
|
|
var inst = _doubler.double(DoubleMe).new()
|
||
|
|
assert_source_contains(inst,
|
||
|
|
'has_two_params_one_default(' +
|
||
|
|
'p_one=__gutdbl.default_val("has_two_params_one_default",0), '+
|
||
|
|
'p_two=__gutdbl.default_val("has_two_params_one_default",1))')
|
||
|
|
# assert_true(text.match('*has_two_params_one_default(p_arg0=__gut_default_val("has_two_params_one_default",0), p_arg1=__gut_default_val("has_two_params_one_default",1))*'))
|
||
|
|
|
||
|
|
func test_doubled_thing_includes_stubber_metadata():
|
||
|
|
var doubled = _doubler.double(DoubleMe).new()
|
||
|
|
assert_ne(doubled.get('__gutdbl'), null)
|
||
|
|
|
||
|
|
func test_doubled_thing_has_original_path_in_metadata():
|
||
|
|
var doubled = _doubler.double(DoubleMe).new()
|
||
|
|
assert_eq(doubled.__gutdbl.thepath, DOUBLE_ME_PATH)
|
||
|
|
|
||
|
|
func test_doublecd_thing_has_gut_metadata():
|
||
|
|
var doubled = _doubler.double(DoubleMe).new()
|
||
|
|
assert_eq(doubled.__gutdbl.gut_ref.get_ref(), gut)
|
||
|
|
|
||
|
|
func test_keeps_extends():
|
||
|
|
var doubled = _doubler.double(DoubleExtendsNode2D).new()
|
||
|
|
assert_is(doubled, Node2D)
|
||
|
|
|
||
|
|
func test_does_not_add_duplicate_methods():
|
||
|
|
var TheClass = load('res://test/resources/parsing_and_loading_samples/extends_another_thing.gd')
|
||
|
|
_doubler.double(TheClass)
|
||
|
|
assert_true(true, 'If we get here then the duplicates were removed.')
|
||
|
|
|
||
|
|
func test_returns_class_that_can_be_instanced():
|
||
|
|
var Doubled = _doubler.double(DoubleMe)
|
||
|
|
var doubled = Doubled.new()
|
||
|
|
assert_ne(doubled, null)
|
||
|
|
|
||
|
|
func test_doubles_retain_signals():
|
||
|
|
var d = _doubler.double(DOUBLE_ME_PATH).new()
|
||
|
|
assert_has_signal(d, 'signal_signal')
|
||
|
|
|
||
|
|
func test_double_includes_list_of_doubled_methods():
|
||
|
|
var d = _doubler.double(DOUBLE_ME_PATH).new()
|
||
|
|
assert_ne(d.__gutdbl_values.doubled_methods.size(), 0)
|
||
|
|
|
||
|
|
func test_doubled_methods_includes_overloaded_methods():
|
||
|
|
var d = _doubler.double(DOUBLE_ME_PATH).new()
|
||
|
|
assert_has(d.__gutdbl_values.doubled_methods, '_ready')
|
||
|
|
|
||
|
|
func test_doubled_methods_includes_script_methods():
|
||
|
|
var d = _doubler.double(DOUBLE_ME_PATH).new()
|
||
|
|
assert_has(d.__gutdbl_values.doubled_methods, 'might_await')
|
||
|
|
|
||
|
|
func test_doubled_methods_does_not_included_non_overloaded_methods():
|
||
|
|
var d = _doubler.double(DOUBLE_ME_PATH).new()
|
||
|
|
assert_does_not_have(d.__gutdbl_values.doubled_methods, '_input')
|
||
|
|
|
||
|
|
|
||
|
|
class TestAddingIgnoredMethods:
|
||
|
|
extends BaseTest
|
||
|
|
var _doubler = null
|
||
|
|
|
||
|
|
var stubber = GutUtils.Stubber.new()
|
||
|
|
func before_each():
|
||
|
|
stubber.clear()
|
||
|
|
_doubler = Doubler.new()
|
||
|
|
_doubler.set_stubber(stubber)
|
||
|
|
_doubler.set_gut(gut)
|
||
|
|
_doubler.print_source = false
|
||
|
|
|
||
|
|
func test_can_add_to_ignore_list():
|
||
|
|
assert_eq(_doubler.get_ignored_methods().size(), 0, 'initial size')
|
||
|
|
_doubler.add_ignored_method(DoubleWithStatic, 'some_method')
|
||
|
|
assert_eq(_doubler.get_ignored_methods().size(), 1, 'after add')
|
||
|
|
|
||
|
|
func test_when_ignored_methods_are_a_local_method_mthey_are_not_present_in_double_code():
|
||
|
|
_doubler.add_ignored_method(DoubleMe, 'has_one_param')
|
||
|
|
var c = _doubler.double(DoubleMe)
|
||
|
|
assert_source_not_contains(c.new(), 'has_one_param')
|
||
|
|
|
||
|
|
func test_when_ignored_methods_are_a_super_method_they_are_not_present_in_double_code():
|
||
|
|
_doubler.add_ignored_method(DoubleMe, 'is_connected')
|
||
|
|
var c = _doubler.double(DoubleMe, GutUtils.DOUBLE_STRATEGY.INCLUDE_NATIVE)
|
||
|
|
assert_source_not_contains(c.new(), 'is_connected')
|
||
|
|
|
||
|
|
func test_can_double_classes_with_static_methods():
|
||
|
|
_doubler.add_ignored_method(DoubleWithStatic, 'this_is_a_static_method')
|
||
|
|
var d = _doubler.double(DoubleWithStatic).new()
|
||
|
|
assert_null(d.this_is_not_static())
|
||
|
|
|
||
|
|
|
||
|
|
class TestDoubleScene:
|
||
|
|
extends BaseTest
|
||
|
|
var _doubler = null
|
||
|
|
|
||
|
|
var stubber = GutUtils.Stubber.new()
|
||
|
|
func before_each():
|
||
|
|
stubber.clear()
|
||
|
|
_doubler = Doubler.new()
|
||
|
|
_doubler.set_stubber(stubber)
|
||
|
|
_doubler.set_gut(gut)
|
||
|
|
_doubler.print_source = false
|
||
|
|
|
||
|
|
func test_can_double_scene():
|
||
|
|
var obj = _doubler.double_scene(DoubleMeScene)
|
||
|
|
var inst = obj.instantiate()
|
||
|
|
assert_eq(inst.return_hello(), null)
|
||
|
|
|
||
|
|
func test_can_add_doubled_scene_to_tree():
|
||
|
|
var inst = _doubler.double_scene(DoubleMeScene).instantiate()
|
||
|
|
add_child(inst)
|
||
|
|
assert_ne(inst.label, null)
|
||
|
|
remove_child(inst)
|
||
|
|
|
||
|
|
func test_metadata_for_scenes_script_points_to_scene_not_script():
|
||
|
|
var inst = _doubler.double_scene(DoubleMeScene).instantiate()
|
||
|
|
assert_eq(inst.__gutdbl.thepath, DOUBLE_ME_SCENE_PATH)
|
||
|
|
|
||
|
|
func test_can_override_strategy_when_doubling_scene():
|
||
|
|
_doubler.set_strategy(GutUtils.DOUBLE_STRATEGY.SCRIPT_ONLY)
|
||
|
|
var inst = autofree(_doubler.double_scene(DoubleMeScene, GutUtils.DOUBLE_STRATEGY.INCLUDE_NATIVE).instantiate())
|
||
|
|
assert_source_contains(inst, 'func is_blocking_signals')
|
||
|
|
|
||
|
|
func test_full_start_has_block_signals():
|
||
|
|
_doubler.set_strategy(GutUtils.DOUBLE_STRATEGY.INCLUDE_NATIVE)
|
||
|
|
var inst = autofree(_doubler.double_scene(DoubleMeScene).instantiate())
|
||
|
|
assert_source_contains(inst, 'func is_blocking_signals')
|
||
|
|
|
||
|
|
|
||
|
|
class TestDoubleStrategyIncludeNative:
|
||
|
|
extends BaseTest
|
||
|
|
|
||
|
|
func _hide_call_back():
|
||
|
|
pass
|
||
|
|
|
||
|
|
var doubler = null
|
||
|
|
var stubber = GutUtils.Stubber.new()
|
||
|
|
|
||
|
|
func before_each():
|
||
|
|
stubber.clear()
|
||
|
|
doubler = Doubler.new(GutUtils.DOUBLE_STRATEGY.INCLUDE_NATIVE)
|
||
|
|
doubler.set_stubber(stubber)
|
||
|
|
doubler.print_source = false
|
||
|
|
|
||
|
|
func test_built_in_overloading_ony_happens_on_full_strategy():
|
||
|
|
doubler.set_strategy(GutUtils.DOUBLE_STRATEGY.SCRIPT_ONLY)
|
||
|
|
var inst = autofree(doubler.double(DoubleMe).new())
|
||
|
|
var txt = get_source(inst)
|
||
|
|
assert_false(txt == '', "text is not empty")
|
||
|
|
assert_source_not_contains(inst, 'func is_blocking_signals', 'does not have non-overloaded methods')
|
||
|
|
|
||
|
|
func test_can_override_strategy_when_doubling_script():
|
||
|
|
doubler.set_strategy(GutUtils.DOUBLE_STRATEGY.SCRIPT_ONLY)
|
||
|
|
var inst = doubler.double(DoubleMe, GutUtils.DOUBLE_STRATEGY.INCLUDE_NATIVE).new()
|
||
|
|
autofree(inst)
|
||
|
|
assert_source_contains(inst, 'func is_blocking_signals')
|
||
|
|
|
||
|
|
func test_when_everything_included_you_can_still_make_an_a_new_object():
|
||
|
|
var inst = autofree(doubler.double(DoubleMe).new())
|
||
|
|
assert_ne(inst, null)
|
||
|
|
|
||
|
|
func test_when_everything_included_you_can_still_make_a_new_node2d():
|
||
|
|
var inst = autofree(doubler.double(DoubleExtendsNode2D).new())
|
||
|
|
assert_ne(inst, null)
|
||
|
|
|
||
|
|
func test_when_everything_included_you_can_still_double_a_scene():
|
||
|
|
var inst = autofree(doubler.double_scene(DoubleMeScene).instantiate())
|
||
|
|
add_child(inst)
|
||
|
|
assert_ne(inst, null, "instantiate is not null")
|
||
|
|
assert_ne(inst.label, null, "Can get to a label on the instantiate")
|
||
|
|
# pause so _process gets called
|
||
|
|
await wait_seconds(3)
|
||
|
|
|
||
|
|
func test_double_includes_methods_in_super():
|
||
|
|
var inst = autofree(doubler.double(DoubleExtendsWindowDialog).new())
|
||
|
|
assert_source_contains(inst, 'connect(')
|
||
|
|
|
||
|
|
func test_can_call_a_built_in_that_has_default_parameters():
|
||
|
|
|
||
|
|
var inst = autofree(doubler.double(DoubleExtendsWindowDialog).new())
|
||
|
|
inst.size_changed.connect(self._hide_call_back)
|
||
|
|
pass_test("if we got here, it worked")
|
||
|
|
|
||
|
|
|
||
|
|
func test_doubled_builtins_call_super():
|
||
|
|
var inst = autofree(doubler.partial_double(DoubleExtendsWindowDialog).new())
|
||
|
|
# Make sure the function is in the doubled class definition
|
||
|
|
assert_source_contains(inst, 'func add_user_signal(p_signal')
|
||
|
|
# Make sure that when called it retains old functionality.
|
||
|
|
inst.add_user_signal('new_one', [])
|
||
|
|
inst.add_user_signal('new_two', ['a', 'b'])
|
||
|
|
assert_has_signal(inst, 'new_one')
|
||
|
|
assert_has_signal(inst, 'new_two')
|
||
|
|
|
||
|
|
func test_doubled_builtins_are_added_as_stubs_to_call_super():
|
||
|
|
var inst = autofree(doubler.partial_double(DoubleExtendsWindowDialog).new())
|
||
|
|
assert_true(doubler.get_stubber().should_call_super(inst, 'add_user_signal'))
|
||
|
|
|
||
|
|
func test_doubled_methods_includes_non_overloaded_methods():
|
||
|
|
var inst = autofree(doubler.double(DoubleMe).new())
|
||
|
|
assert_has(inst.__gutdbl_values.doubled_methods, 'get_parent')
|
||
|
|
|
||
|
|
func test_doubled_methods_does_not_included_non_overloaded_virtual_methods():
|
||
|
|
var inst = autofree(doubler.double(DoubleMe).new())
|
||
|
|
assert_does_not_have(inst.__gutdbl_values.doubled_methods, '_input')
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
class TestPartialDoubles:
|
||
|
|
extends BaseTest
|
||
|
|
|
||
|
|
var doubler = null
|
||
|
|
var stubber = GutUtils.Stubber.new()
|
||
|
|
|
||
|
|
func before_each():
|
||
|
|
stubber.clear()
|
||
|
|
doubler = Doubler.new()
|
||
|
|
doubler.set_stubber(stubber)
|
||
|
|
|
||
|
|
func test_can_make_partial_of_script():
|
||
|
|
var inst = autofree(doubler.partial_double(DoubleMe).new())
|
||
|
|
inst.set_value(10)
|
||
|
|
assert_eq(inst.get_value(), 10)
|
||
|
|
|
||
|
|
func test_double_script_does_not_make_partials():
|
||
|
|
var inst = autofree(doubler.double(DoubleMe).new())
|
||
|
|
assert_eq(inst.get_value(), null)
|
||
|
|
|
||
|
|
func test_can_make_partial_of_scene():
|
||
|
|
var inst = autofree(doubler.partial_double_scene(DoubleMeScene).instantiate())
|
||
|
|
assert_eq(inst.return_hello(), 'hello')
|
||
|
|
|
||
|
|
func test_double_scene_does_not_call_supers():
|
||
|
|
var inst = autofree(doubler.double_scene(DoubleMeScene).instantiate())
|
||
|
|
assert_eq(inst.return_hello(), null)
|
||
|
|
|
||
|
|
func test_init_is_not_stubbed_to_call_super():
|
||
|
|
var inst = autofree(doubler.partial_double(DoubleMe).new())
|
||
|
|
var text = get_source(inst)
|
||
|
|
assert_false(text.match("*__gutdbl.should_call_super('_init'*"), 'should not call super _init')
|
||
|
|
|
||
|
|
func test_can_partial_and_normal_double_in_same_test():
|
||
|
|
var dbl = autofree(doubler.double(DoubleMe).new())
|
||
|
|
var p_double = autofree(doubler.partial_double(DoubleMe).new())
|
||
|
|
|
||
|
|
assert_null(dbl.get_value(), 'double get_value')
|
||
|
|
assert_eq(p_double.get_value(), 0, 'partial get_value')
|
||
|
|
if(is_failing()):
|
||
|
|
print(doubler.get_stubber().to_s())
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
class TestDoubleGDNaviteClasses:
|
||
|
|
extends BaseTest
|
||
|
|
|
||
|
|
var _doubler = null
|
||
|
|
var _stubber = GutUtils.Stubber.new()
|
||
|
|
|
||
|
|
func before_each():
|
||
|
|
_stubber.clear()
|
||
|
|
_doubler = Doubler.new()
|
||
|
|
_doubler.set_stubber(_stubber)
|
||
|
|
_doubler.print_source = false
|
||
|
|
|
||
|
|
# ---------
|
||
|
|
# Note: Orphans in these tests are caused by the script parser holding onto
|
||
|
|
# the native instances it creates. These are released when the script parser
|
||
|
|
# is unreferenced. See test_script_parser.gd for more info. Decided not to
|
||
|
|
# fight the orhpans here.
|
||
|
|
# ---------
|
||
|
|
func test_can_double_Node2D():
|
||
|
|
var d_node_2d = _doubler.double_gdnative(Node2D)
|
||
|
|
assert_not_null(d_node_2d)
|
||
|
|
|
||
|
|
func test_can_partial_double_Node2D():
|
||
|
|
var pd_node_2d = _doubler.partial_double_gdnative(Node2D)
|
||
|
|
assert_not_null(pd_node_2d)
|
||
|
|
|
||
|
|
func test_can_make_instances_of_native_doubles():
|
||
|
|
var crect_double_inst = _doubler.double_gdnative(ColorRect).new()
|
||
|
|
autofree(crect_double_inst)
|
||
|
|
assert_not_null(crect_double_inst)
|
||
|
|
|
||
|
|
func test_can_make_double_of_ref_counted_native():
|
||
|
|
var dbl = _doubler.double_gdnative(StreamPeerTCP)
|
||
|
|
assert_not_null(dbl)
|
||
|
|
|
||
|
|
|
||
|
|
class TestDoubleInnerClasses:
|
||
|
|
extends BaseTest
|
||
|
|
|
||
|
|
var doubler = null
|
||
|
|
|
||
|
|
func before_each():
|
||
|
|
doubler = Doubler.new()
|
||
|
|
doubler.set_stubber(GutUtils.Stubber.new())
|
||
|
|
var lgr = GutUtils.GutLogger.new()
|
||
|
|
lgr.set_gut(gut)
|
||
|
|
doubler.set_logger(lgr)
|
||
|
|
|
||
|
|
func test_when_inner_class_not_registered_it_generates_error():
|
||
|
|
doubler.double(InnerClasses.InnerA)
|
||
|
|
assert_tracked_gut_error()
|
||
|
|
|
||
|
|
func test_when_inner_class_registered_it_makes_a_double():
|
||
|
|
doubler.inner_class_registry.register(InnerClasses)
|
||
|
|
var Dbl = doubler.double(InnerClasses.InnerA)
|
||
|
|
assert_tracked_gut_error(doubler, 0)
|
||
|
|
assert_not_null(Dbl, 'made a double')
|
||
|
|
|
||
|
|
func test_doubled_instance_returns_null_for_get_b1():
|
||
|
|
doubler.inner_class_registry.register(InnerClasses)
|
||
|
|
var dbld = doubler.double(InnerClasses.InnerB.InnerB1).new()
|
||
|
|
assert_null(dbld.get_b1())
|
||
|
|
|
||
|
|
func test_can_make_an_instance_of_a_double_of_a_registered_inner_class():
|
||
|
|
doubler.inner_class_registry.register(InnerClasses)
|
||
|
|
var inst = doubler.double(InnerClasses.InnerB.InnerB1).new()
|
||
|
|
assert_not_null(inst, 'inst is not null')
|
||
|
|
assert_is(inst, InnerClasses.InnerB.InnerB1)
|
||
|
|
|
||
|
|
func test_doubled_inners_that_extend_inners_get_full_inheritance():
|
||
|
|
doubler.inner_class_registry.register(InnerClasses)
|
||
|
|
var inst = doubler.double(InnerClasses.InnerCA).new()
|
||
|
|
assert_has_method(inst, 'get_a')
|
||
|
|
assert_has_method(inst, 'get_ca')
|
||
|
|
|
||
|
|
func test_doubled_inners_have_subpath_set_in_metadata():
|
||
|
|
doubler.inner_class_registry.register(InnerClasses)
|
||
|
|
var inst = doubler.double(InnerClasses.InnerCA).new()
|
||
|
|
assert_eq(inst.__gutdbl.subpath, 'InnerCA')
|
||
|
|
|
||
|
|
func test_non_inners_have_empty_subpath():
|
||
|
|
var inst = doubler.double(InnerClasses).new()
|
||
|
|
assert_eq(inst.__gutdbl.subpath, '')
|
||
|
|
|
||
|
|
func test_can_override_strategy_when_doubling():
|
||
|
|
doubler.inner_class_registry.register(InnerClasses)
|
||
|
|
var d = doubler.double(InnerClasses.InnerA, DOUBLE_STRATEGY.INCLUDE_NATIVE)
|
||
|
|
# make sure it has something from Object that isn't implemented
|
||
|
|
assert_source_contains(d.new() , 'func disconnect(p_signal')
|
||
|
|
assert_eq(doubler.get_strategy(), DOUBLE_STRATEGY.SCRIPT_ONLY, 'strategy should have been reset')
|
||
|
|
|
||
|
|
func test_doubled_inners_retain_signals():
|
||
|
|
doubler.inner_class_registry.register(InnerClasses)
|
||
|
|
var inst = doubler.double(InnerClasses.InnerWithSignals).new()
|
||
|
|
assert_has_signal(inst, 'signal_signal')
|
||
|
|
|
||
|
|
func test_double_inner_does_not_call_supers():
|
||
|
|
doubler.inner_class_registry.register(InnerClasses)
|
||
|
|
var inst = doubler.double(InnerClasses.InnerA).new()
|
||
|
|
assert_eq(inst.get_a(), null)
|
||
|
|
|
||
|
|
func test_can_make_partial_of_inner_script():
|
||
|
|
doubler.inner_class_registry.register(InnerClasses)
|
||
|
|
var inst = doubler.partial_double(InnerClasses.InnerA).new()
|
||
|
|
assert_eq(inst.get_a(), 'a')
|
||
|
|
|
||
|
|
func test_partial_double_errors_if_inner_not_registered():
|
||
|
|
doubler.partial_double(InnerClasses.InnerA)
|
||
|
|
assert_tracked_gut_error()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
class TestAutofree:
|
||
|
|
extends BaseTest
|
||
|
|
|
||
|
|
class InitHasDefaultParams:
|
||
|
|
var a = 'b'
|
||
|
|
|
||
|
|
func _init(value='asdf'):
|
||
|
|
a = value
|
||
|
|
|
||
|
|
func test_doubles_are_autofreed():
|
||
|
|
var doubled = double(DoubleExtendsNode2D).new()
|
||
|
|
gut.get_autofree().free_all()
|
||
|
|
assert_no_new_orphans()
|
||
|
|
|
||
|
|
func test_partial_doubles_are_autofreed():
|
||
|
|
var doubled = partial_double(DoubleExtendsNode2D).new()
|
||
|
|
gut.get_autofree().free_all()
|
||
|
|
assert_no_new_orphans()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
class TestDoubleSingletons:
|
||
|
|
extends BaseTest
|
||
|
|
|
||
|
|
var doubler = null
|
||
|
|
|
||
|
|
func before_each():
|
||
|
|
doubler = Doubler.new()
|
||
|
|
doubler.set_stubber(GutUtils.Stubber.new())
|
||
|
|
var lgr = GutUtils.GutLogger.new()
|
||
|
|
lgr.set_gut(gut)
|
||
|
|
doubler.set_logger(lgr)
|
||
|
|
|
||
|
|
func test_can_make_a_double_of_OS():
|
||
|
|
var d = doubler.double_singleton(Input)
|
||
|
|
assert_not_null(d)
|
||
|
|
|
||
|
|
func test_doubles_are_ref_counted():
|
||
|
|
var d = doubler.double_singleton(Time)
|
||
|
|
var inst = d.new()
|
||
|
|
assert_is(inst, RefCounted)
|
||
|
|
|
||
|
|
func test_adds_gut_data():
|
||
|
|
var d = doubler.double_singleton(OS)
|
||
|
|
var inst = d.new()
|
||
|
|
|
||
|
|
assert_typeof(inst.__gutdbl_values, TYPE_DICTIONARY)
|
||
|
|
assert_has_method(inst, '__gutdbl_check_method__')
|
||
|
|
assert_not_null(inst.__gutdbl)
|
||
|
|
assert_has_method(inst, '__gutdbl_done')
|
||
|
|
|
||
|
|
func test_populates_gut_data_singleton_values():
|
||
|
|
var d = doubler.double_singleton(OS)
|
||
|
|
var inst = d.new()
|
||
|
|
assert_eq(inst.__gutdbl_values.singleton_name, "OS")
|
||
|
|
assert_eq(inst.__gutdbl_values.singleton, OS.get_instance_id(), 'singleton instance id')
|
||
|
|
|
||
|
|
|
||
|
|
func test_double_has_singleton_methods():
|
||
|
|
var d = doubler.double_singleton(OS)
|
||
|
|
var inst = d.new()
|
||
|
|
|
||
|
|
assert_has_method(inst, 'get_data_dir')
|
||
|
|
|
||
|
|
|
||
|
|
func test_double_has_enums():
|
||
|
|
var inst = doubler.double_singleton(Time).new()
|
||
|
|
assert_eq(inst.MONTH_JANUARY, 1)
|
||
|
|
|
||
|
|
|
||
|
|
func test_double_has_signal():
|
||
|
|
var inst = doubler.double_singleton(AudioServer).new()
|
||
|
|
assert_has_signal(inst, 'bus_layout_changed')
|
||
|
|
|
||
|
|
var _on_bus_renamed_bus_index = 999
|
||
|
|
var _on_bus_renamed_old_name = ''
|
||
|
|
var _on_bus_renamed_new_name = ''
|
||
|
|
func _on_bus_renamed(bus_index, old_name, new_name):
|
||
|
|
_on_bus_renamed_bus_index = bus_index
|
||
|
|
_on_bus_renamed_old_name = old_name
|
||
|
|
_on_bus_renamed_new_name = new_name
|
||
|
|
|
||
|
|
func test_can_connect_to_signal_with_parameters():
|
||
|
|
var inst = doubler.double_singleton(AudioServer).new()
|
||
|
|
inst.bus_renamed.connect(_on_bus_renamed)
|
||
|
|
assert_connected(inst.bus_renamed, self)
|
||
|
|
inst.bus_renamed.emit(-1, 'old', 'new')
|
||
|
|
assert_eq(_on_bus_renamed_bus_index, -1)
|
||
|
|
assert_eq(_on_bus_renamed_old_name, 'old')
|
||
|
|
assert_eq(_on_bus_renamed_new_name, 'new')
|
||
|
|
|
||
|
|
func test_singltons_contain_properties():
|
||
|
|
var inst = doubler.double_singleton(OS).new()
|
||
|
|
assert_true(inst.delta_smoothing)
|
||
|
|
assert_false(inst.low_processor_usage_mode)
|
||
|
|
|
||
|
|
func test_can_double_all_singletons(p = use_parameters(GutUtils.GodotSingletons.class_ref)):
|
||
|
|
var D = doubler.double_singleton(p)
|
||
|
|
assert_not_null(D, 'singleton: ' + p.get_class())
|
||
|
|
if(is_passing()):
|
||
|
|
assert_not_null(D.new(), 'instance')
|
||
|
|
|
||
|
|
func test_can_make_partial_double_of_singleton():
|
||
|
|
var D = doubler.partial_double_singleton(Time)
|
||
|
|
assert_not_null(D)
|
||
|
|
|
||
|
|
func test_partial_double_singletons_call_super():
|
||
|
|
var D = doubler.partial_double_singleton(Time)
|
||
|
|
var inst = D.new()
|
||
|
|
assert_not_null(inst.get_ticks_msec())
|
||
|
|
|
||
|
|
func test_singleton_doubles_have_doubled_methods_populated():
|
||
|
|
var inst = doubler.double_singleton(Performance).new()
|
||
|
|
assert_ne(inst.__gutdbl_values.doubled_methods.size(), 0)
|
||
|
|
|
||
|
|
func test_singleton_doubles_do_not_have_object_methods():
|
||
|
|
var inst = doubler.double_singleton(Performance).new()
|
||
|
|
assert_does_not_have(inst.__gutdbl_values.doubled_methods, 'get_property_list')
|
||
|
|
|
||
|
|
func test_singleton_doubles_have_singleton_methods():
|
||
|
|
var inst = doubler.double_singleton(Performance).new()
|
||
|
|
assert_has(inst.__gutdbl_values.doubled_methods, 'get_custom_monitor_names')
|
||
|
|
|