godot: inital Godot 4 migration

1 files changed, 0 insertions, 1687 deletions

diff --git a/addons/gut/test.gd b/addons/gut/test.gd
deleted file mode 100644
index 3fc0e8f..0000000
--- a/addons/gut/test.gd
+++ /dev/null
@@ -1,1687 +0,0 @@
-class_name GutTest
-# ##############################################################################
-#(G)odot (U)nit (T)est class
-#
-# ##############################################################################
-# The MIT License (MIT)
-# =====================
-#
-# Copyright (c) 2020 Tom "Butch" Wesley
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ##############################################################################
-# View readme for usage details.
-#
-# Version - see gut.gd
-# ##############################################################################
-# Class that all test scripts must extend.
-#
-# This provides all the asserts and other testing features.  Test scripts are
-# run by the Gut class in gut.gd
-# ##############################################################################
-extends Node
-
-# ------------------------------------------------------------------------------
-# Helper class to hold info for objects to double.  This extracts info and has
-# some convenience methods.  This is key in being able to make the "smart double"
-# method which makes doubling much easier for the user.
-# -----------------------------------------------------------------------------
-class DoubleInfo:
-	var path
-	var subpath
-	var strategy
-	var make_partial
-	var extension
-	var _utils = load('res://addons/gut/utils.gd').get_instance()
-	var _is_native = false
-	var is_valid = false
-
-	# Flexible init method.  p2 can be subpath or stategy unless p3 is
-	# specified, then p2 must be subpath and p3 is strategy.
-	#
-	# Examples:
-	#   (object_to_double)
-	#   (object_to_double, subpath)
-	#   (object_to_double, strategy)
-	#   (object_to_double, subpath, strategy)
-	func _init(thing, p2=null, p3=null):
-		strategy = p2
-
-		# short-circuit and ensure that is_valid
-		# is not set to true.
-		if(_utils.is_instance(thing)):
-			return
-
-		if(typeof(p2) == TYPE_STRING):
-			strategy = p3
-			subpath = p2
-
-		if(typeof(thing) == TYPE_OBJECT):
-			if(_utils.is_native_class(thing)):
-				path = thing
-				_is_native = true
-				extension = 'native_class_not_used'
-			else:
-				path = thing.resource_path
-		else:
-			path = thing
-
-		if(!_is_native):
-			extension = path.get_extension()
-
-		is_valid = true
-
-	func is_scene():
-		return extension == 'tscn'
-
-	func is_script():
-		return extension == 'gd'
-
-	func is_native():
-		return _is_native
-
-# ------------------------------------------------------------------------------
-# Begin test.gd
-# ------------------------------------------------------------------------------
-var _utils = load('res://addons/gut/utils.gd').get_instance()
-var _compare = _utils.Comparator.new()
-
-# constant for signal when calling yield_for
-const YIELD = 'timeout'
-
-# Need a reference to the instance that is running the tests.  This
-# is set by the gut class when it runs the tests.  This gets you
-# access to the asserts in the tests you write.
-var gut = null
-
-var _disable_strict_datatype_checks = false
-# Holds all the text for a test's fail/pass.  This is used for testing purposes
-# to see the text of a failed sub-test in test_test.gd
-var _fail_pass_text = []
-
-const EDITOR_PROPERTY = PROPERTY_USAGE_SCRIPT_VARIABLE | PROPERTY_USAGE_DEFAULT
-const VARIABLE_PROPERTY = PROPERTY_USAGE_SCRIPT_VARIABLE
-
-# Used with assert_setget
-enum {
-	DEFAULT_SETTER_GETTER,
-	SETTER_ONLY,
-	GETTER_ONLY
-}
-
-# Summary counts for the test.
-var _summary = {
-	asserts = 0,
-	passed = 0,
-	failed = 0,
-	tests = 0,
-	pending = 0
-}
-
-# This is used to watch signals so we can make assertions about them.
-var _signal_watcher = load('res://addons/gut/signal_watcher.gd').new()
-
-# Convenience copy of _utils.DOUBLE_STRATEGY
-var DOUBLE_STRATEGY = null
-var _lgr = _utils.get_logger()
-var _strutils = _utils.Strutils.new()
-
-# syntax sugar
-var ParameterFactory = _utils.ParameterFactory
-var CompareResult = _utils.CompareResult
-var InputFactory = _utils.InputFactory
-var InputSender = _utils.InputSender
-
-func _init():
-	DOUBLE_STRATEGY = _utils.DOUBLE_STRATEGY # yes, this is right
-
-func _str(thing):
-	return _strutils.type2str(thing)
-
-# ------------------------------------------------------------------------------
-# Fail an assertion.  Causes test and script to fail as well.
-# ------------------------------------------------------------------------------
-func _fail(text):
-	_summary.asserts += 1
-	_summary.failed += 1
-	_fail_pass_text.append('failed:  ' + text)
-	if(gut):
-		_lgr.failed(text)
-		gut._fail(text)
-
-# ------------------------------------------------------------------------------
-# Pass an assertion.
-# ------------------------------------------------------------------------------
-func _pass(text):
-	_summary.asserts += 1
-	_summary.passed += 1
-	_fail_pass_text.append('passed:  ' + text)
-	if(gut):
-		_lgr.passed(text)
-		gut._pass(text)
-
-# ------------------------------------------------------------------------------
-# Checks if the datatypes passed in match.  If they do not then this will cause
-# a fail to occur.  If they match then TRUE is returned, FALSE if not.  This is
-# used in all the assertions that compare values.
-# ------------------------------------------------------------------------------
-func _do_datatypes_match__fail_if_not(got, expected, text):
-	var did_pass = true
-
-	if(!_disable_strict_datatype_checks):
-		var got_type = typeof(got)
-		var expect_type = typeof(expected)
-		if(got_type != expect_type and got != null and expected != null):
-			# If we have a mismatch between float and int (types 2 and 3) then
-			# print out a warning but do not fail.
-			if([2, 3].has(got_type) and [2, 3].has(expect_type)):
-				_lgr.warn(str('Warn:  Float/Int comparison.  Got ', _strutils.types[got_type],
-					' but expected ', _strutils.types[expect_type]))
-			else:
-				_fail('Cannot compare ' + _strutils.types[got_type] + '[' + _str(got) + '] to ' + \
-					_strutils.types[expect_type] + '[' + _str(expected) + '].  ' + text)
-				did_pass = false
-
-	return did_pass
-
-# ------------------------------------------------------------------------------
-# Create a string that lists all the methods that were called on an spied
-# instance.
-# ------------------------------------------------------------------------------
-func _get_desc_of_calls_to_instance(inst):
-	var BULLET = '  * '
-	var calls = gut.get_spy().get_call_list_as_string(inst)
-	# indent all the calls
-	calls = BULLET + calls.replace("\n", "\n" + BULLET)
-	# remove trailing newline and bullet
-	calls = calls.substr(0, calls.length() - BULLET.length() - 1)
-	return "Calls made on " + str(inst) + "\n" + calls
-
-# ------------------------------------------------------------------------------
-# Signal assertion helper.  Do not call directly, use _can_make_signal_assertions
-# ------------------------------------------------------------------------------
-func _fail_if_does_not_have_signal(object, signal_name):
-	var did_fail = false
-	if(!_signal_watcher.does_object_have_signal(object, signal_name)):
-		_fail(str('Object ', object, ' does not have the signal [', signal_name, ']'))
-		did_fail = true
-	return did_fail
-
-# ------------------------------------------------------------------------------
-# Signal assertion helper.  Do not call directly, use _can_make_signal_assertions
-# ------------------------------------------------------------------------------
-func _fail_if_not_watching(object):
-	var did_fail = false
-	if(!_signal_watcher.is_watching_object(object)):
-		_fail(str('Cannot make signal assertions because the object ', object, \
-				  ' is not being watched.  Call watch_signals(some_object) to be able to make assertions about signals.'))
-		did_fail = true
-	return did_fail
-
-# ------------------------------------------------------------------------------
-# Returns text that contains original text and a list of all the signals that
-# were emitted for the passed in object.
-# ------------------------------------------------------------------------------
-func _get_fail_msg_including_emitted_signals(text, object):
-	return str(text," (Signals emitted: ", _signal_watcher.get_signals_emitted(object), ")")
-
-# ------------------------------------------------------------------------------
-# This validates that parameters is an array and generates a specific error
-# and a failure with a specific message
-# ------------------------------------------------------------------------------
-func _fail_if_parameters_not_array(parameters):
-	var invalid = parameters != null and typeof(parameters) != TYPE_ARRAY
-	if(invalid):
-		_lgr.error('The "parameters" parameter must be an array of expected parameter values.')
-		_fail('Cannot compare paramter values because an array was not passed.')
-	return invalid
-
-
-func _create_obj_from_type(type):
-	var obj = null
-	if type.is_class("PackedScene"):
-		obj = type.instance()
-		add_child(obj)
-	else:
-		obj = type.new()
-	return obj
-
-
-# #######################
-# Virtual Methods
-# #######################
-
-# alias for prerun_setup
-func before_all():
-	pass
-
-# alias for setup
-func before_each():
-	pass
-
-# alias for postrun_teardown
-func after_all():
-	pass
-
-# alias for teardown
-func after_each():
-	pass
-
-# #######################
-# Public
-# #######################
-
-func get_logger():
-	return _lgr
-
-func set_logger(logger):
-	_lgr = logger
-
-
-# #######################
-# Asserts
-# #######################
-
-# ------------------------------------------------------------------------------
-# Asserts that the expected value equals the value got.
-# ------------------------------------------------------------------------------
-func assert_eq(got, expected, text=""):
-
-	if(_do_datatypes_match__fail_if_not(got, expected, text)):
-		var disp = "[" + _str(got) + "] expected to equal [" + _str(expected) + "]:  " + text
-		var result = null
-
-		if(typeof(got) == TYPE_ARRAY):
-			result = _compare.shallow(got, expected)
-		else:
-			result = _compare.simple(got, expected)
-
-		if(typeof(got) in [TYPE_ARRAY, TYPE_DICTIONARY]):
-			disp = str(result.summary, '  ', text)
-
-		if(result.are_equal):
-			_pass(disp)
-		else:
-			_fail(disp)
-
-
-# ------------------------------------------------------------------------------
-# Asserts that the value got does not equal the "not expected" value.
-# ------------------------------------------------------------------------------
-func assert_ne(got, not_expected, text=""):
-	if(_do_datatypes_match__fail_if_not(got, not_expected, text)):
-		var disp = "[" + _str(got) + "] expected to not equal [" + _str(not_expected) + "]:  " + text
-		var result = null
-
-		if(typeof(got) == TYPE_ARRAY):
-			result = _compare.shallow(got, not_expected)
-		else:
-			result = _compare.simple(got, not_expected)
-
-		if(typeof(got) in [TYPE_ARRAY, TYPE_DICTIONARY]):
-			disp = str(result.summary, '  ', text)
-
-		if(result.are_equal):
-			_fail(disp)
-		else:
-			_pass(disp)
-
-
-# ------------------------------------------------------------------------------
-# Asserts that the expected value almost equals the value got.
-# ------------------------------------------------------------------------------
-func assert_almost_eq(got, expected, error_interval, text=''):
-	var disp = "[" + _str(got) + "] expected to equal [" + _str(expected) + "] +/- [" + str(error_interval) + "]:  " + text
-	if(_do_datatypes_match__fail_if_not(got, expected, text) and _do_datatypes_match__fail_if_not(got, error_interval, text)):
-		if not _is_almost_eq(got, expected, error_interval):
-			_fail(disp)
-		else:
-			_pass(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts that the expected value does not almost equal the value got.
-# ------------------------------------------------------------------------------
-func assert_almost_ne(got, not_expected, error_interval, text=''):
-	var disp = "[" + _str(got) + "] expected to not equal [" + _str(not_expected) + "] +/- [" + str(error_interval) + "]:  " + text
-	if(_do_datatypes_match__fail_if_not(got, not_expected, text) and _do_datatypes_match__fail_if_not(got, error_interval, text)):
-		if _is_almost_eq(got, not_expected, error_interval):
-			_fail(disp)
-		else:
-			_pass(disp)
-
-# ------------------------------------------------------------------------------
-# Helper function which correctly compares two variables,
-# while properly handling vector2/3 types
-# ------------------------------------------------------------------------------
-func _is_almost_eq(got, expected, error_interval) -> bool:
-	var result = false
-	if typeof(got) == TYPE_VECTOR2:
-		if got.x >= (expected.x - error_interval.x) and got.x <= (expected.x + error_interval.x):
-			if got.y >= (expected.y - error_interval.y) and got.y <= (expected.y + error_interval.y):
-				result = true
-	elif typeof(got) == TYPE_VECTOR3:
-		if got.x >= (expected.x - error_interval.x) and got.x <= (expected.x + error_interval.x):
-			if got.y >= (expected.y - error_interval.y) and got.y <= (expected.y + error_interval.y):
-				if got.z >= (expected.z - error_interval.z) and got.z <= (expected.z + error_interval.z):
-					result = true
-	elif(got >= (expected - error_interval) and got <= (expected + error_interval)):
-		result = true
-	return(result)
-
-# ------------------------------------------------------------------------------
-# Asserts got is greater than expected
-# ------------------------------------------------------------------------------
-func assert_gt(got, expected, text=""):
-	var disp = "[" + _str(got) + "] expected to be > than [" + _str(expected) + "]:  " + text
-	if(_do_datatypes_match__fail_if_not(got, expected, text)):
-		if(got > expected):
-			_pass(disp)
-		else:
-			_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts got is less than expected
-# ------------------------------------------------------------------------------
-func assert_lt(got, expected, text=""):
-	var disp = "[" + _str(got) + "] expected to be < than [" + _str(expected) + "]:  " + text
-	if(_do_datatypes_match__fail_if_not(got, expected, text)):
-		if(got < expected):
-			_pass(disp)
-		else:
-			_fail(disp)
-
-# ------------------------------------------------------------------------------
-# asserts that got is true
-# ------------------------------------------------------------------------------
-func assert_true(got, text=""):
-	if(typeof(got) == TYPE_BOOL):
-		if(got):
-			_pass(text)
-		else:
-			_fail(text)
-	else:
-		var msg = str("Cannot convert ", _strutils.type2str(got), " to boolean")
-		_fail(msg)
-
-# ------------------------------------------------------------------------------
-# Asserts that got is false
-# ------------------------------------------------------------------------------
-func assert_false(got, text=""):
-	if(typeof(got) == TYPE_BOOL):
-		if(got):
-			_fail(text)
-		else:
-			_pass(text)
-	else:
-		var msg = str("Cannot convert ", _strutils.type2str(got), " to boolean")
-		_fail(msg)
-
-# ------------------------------------------------------------------------------
-# Asserts value is between (inclusive) the two expected values.
-# ------------------------------------------------------------------------------
-func assert_between(got, expect_low, expect_high, text=""):
-	var disp = "[" + _str(got) + "] expected to be between [" + _str(expect_low) + "] and [" + str(expect_high) + "]:  " + text
-
-	if(_do_datatypes_match__fail_if_not(got, expect_low, text) and _do_datatypes_match__fail_if_not(got, expect_high, text)):
-		if(expect_low > expect_high):
-			disp = "INVALID range.  [" + str(expect_low) + "] is not less than [" + str(expect_high) + "]"
-			_fail(disp)
-		else:
-			if(got < expect_low or got > expect_high):
-				_fail(disp)
-			else:
-				_pass(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts value is not between (exclusive) the two expected values.
-# ------------------------------------------------------------------------------
-func assert_not_between(got, expect_low, expect_high, text=""):
-	var disp = "[" + _str(got) + "] expected not to be between [" + _str(expect_low) + "] and [" + str(expect_high) + "]:  " + text
-
-	if(_do_datatypes_match__fail_if_not(got, expect_low, text) and _do_datatypes_match__fail_if_not(got, expect_high, text)):
-		if(expect_low > expect_high):
-			disp = "INVALID range.  [" + str(expect_low) + "] is not less than [" + str(expect_high) + "]"
-			_fail(disp)
-		else:
-			if(got > expect_low and got < expect_high):
-				_fail(disp)
-			else:
-				_pass(disp)
-
-# ------------------------------------------------------------------------------
-# Uses the 'has' method of the object passed in to determine if it contains
-# the passed in element.
-# ------------------------------------------------------------------------------
-func assert_has(obj, element, text=""):
-	var disp = str('Expected [', _str(obj), '] to contain value:  [', _str(element), ']:  ', text)
-	if(obj.has(element)):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# ------------------------------------------------------------------------------
-func assert_does_not_have(obj, element, text=""):
-	var disp = str('Expected [', _str(obj), '] to NOT contain value:  [', _str(element), ']:  ', text)
-	if(obj.has(element)):
-		_fail(disp)
-	else:
-		_pass(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts that a file exists
-# ------------------------------------------------------------------------------
-func assert_file_exists(file_path):
-	var disp = 'expected [' + file_path + '] to exist.'
-	var f = File.new()
-	if(f.file_exists(file_path)):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts that a file should not exist
-# ------------------------------------------------------------------------------
-func assert_file_does_not_exist(file_path):
-	var disp = 'expected [' + file_path + '] to NOT exist'
-	var f = File.new()
-	if(!f.file_exists(file_path)):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts the specified file is empty
-# ------------------------------------------------------------------------------
-func assert_file_empty(file_path):
-	var disp = 'expected [' + file_path + '] to be empty'
-	var f = File.new()
-	if(f.file_exists(file_path) and gut.is_file_empty(file_path)):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts the specified file is not empty
-# ------------------------------------------------------------------------------
-func assert_file_not_empty(file_path):
-	var disp = 'expected [' + file_path + '] to contain data'
-	if(!gut.is_file_empty(file_path)):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts the object has the specified method
-# ------------------------------------------------------------------------------
-func assert_has_method(obj, method, text=''):
-	var disp = _str(obj) + ' should have method: ' + method
-	if(text != ''):
-		disp = _str(obj) + ' ' + text
-	assert_true(obj.has_method(method), disp)
-
-# Old deprecated method name
-func assert_get_set_methods(obj, property, default, set_to):
-	_lgr.deprecated('assert_get_set_methods', 'assert_accessors')
-	assert_accessors(obj, property, default, set_to)
-
-# ------------------------------------------------------------------------------
-# Verifies the object has get and set methods for the property passed in.  The
-# property isn't tied to anything, just a name to be appended to the end of
-# get_ and set_.  Asserts the get_ and set_ methods exist, if not, it stops there.
-# If they exist then it asserts get_ returns the expected default then calls
-# set_ and asserts get_ has the value it was set to.
-# ------------------------------------------------------------------------------
-func assert_accessors(obj, property, default, set_to):
-	var fail_count = _summary.failed
-	var get_func = 'get_' + property
-	var set_func = 'set_' + property
-
-	if(obj.has_method('is_' + property)):
-		get_func = 'is_' + property
-
-	assert_has_method(obj, get_func, 'should have getter starting with get_ or is_')
-	assert_has_method(obj, set_func)
-	# SHORT CIRCUIT
-	if(_summary.failed > fail_count):
-		return
-	assert_eq(obj.call(get_func), default, 'It should have the expected default value.')
-	obj.call(set_func, set_to)
-	assert_eq(obj.call(get_func), set_to, 'The set value should have been returned.')
-
-
-# ---------------------------------------------------------------------------
-# Property search helper.  Used to retrieve Dictionary of specified property
-# from passed object. Returns null if not found.
-# If provided, property_usage constrains the type of property returned by
-# passing either:
-# EDITOR_PROPERTY for properties defined as: export(int) var some_value
-# VARIABLE_PROPERTY for properties defined as: var another_value
-# ---------------------------------------------------------------------------
-func _find_object_property(obj, property_name, property_usage=null):
-	var result = null
-	var found = false
-	var properties = obj.get_property_list()
-
-	while !found and !properties.empty():
-		var property = properties.pop_back()
-		if property['name'] == property_name:
-			if property_usage == null or property['usage'] == property_usage:
-				result = property
-				found = true
-	return result
-
-# ------------------------------------------------------------------------------
-# Asserts a class exports a variable.
-# ------------------------------------------------------------------------------
-func assert_exports(obj, property_name, type):
-	var disp = 'expected %s to have editor property [%s]' % [_str(obj), property_name]
-	var property = _find_object_property(obj, property_name, EDITOR_PROPERTY)
-	if property != null:
-		disp += ' of type [%s]. Got type [%s].' % [_strutils.types[type], _strutils.types[property['type']]]
-		if property['type'] == type:
-			_pass(disp)
-		else:
-			_fail(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Signal assertion helper.
-#
-# Verifies that the object and signal are valid for making signal assertions.
-# This will fail with specific messages that indicate why they are not valid.
-# This returns true/false to indicate if the object and signal are valid.
-# ------------------------------------------------------------------------------
-func _can_make_signal_assertions(object, signal_name):
-	return !(_fail_if_not_watching(object) or _fail_if_does_not_have_signal(object, signal_name))
-
-# ------------------------------------------------------------------------------
-# Check if an object is connected to a signal on another object. Returns True
-# if it is and false otherwise
-# ------------------------------------------------------------------------------
-func _is_connected(signaler_obj, connect_to_obj, signal_name, method_name=""):
-	if(method_name != ""):
-		return signaler_obj.is_connected(signal_name, connect_to_obj, method_name)
-	else:
-		var connections = signaler_obj.get_signal_connection_list(signal_name)
-		for conn in connections:
-			if((conn.source == signaler_obj) and (conn.target == connect_to_obj)):
-				return true
-		return false
-# ------------------------------------------------------------------------------
-# Watch the signals for an object.  This must be called before you can make
-# any assertions about the signals themselves.
-# ------------------------------------------------------------------------------
-func watch_signals(object):
-	_signal_watcher.watch_signals(object)
-
-# ------------------------------------------------------------------------------
-# Asserts that an object is connected to a signal on another object
-#
-# This will fail with specific messages if the target object is not connected
-# to the specified signal on the source object.
-# ------------------------------------------------------------------------------
-func assert_connected(signaler_obj, connect_to_obj, signal_name, method_name=""):
-	pass
-	var method_disp = ''
-	if (method_name != ""):
-		method_disp = str(' using method: [', method_name, '] ')
-	var disp = str('Expected object ', _str(signaler_obj),\
-		' to be connected to signal: [', signal_name, '] on ',\
-		_str(connect_to_obj), method_disp)
-	if(_is_connected(signaler_obj, connect_to_obj, signal_name, method_name)):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts that an object is not connected to a signal on another object
-#
-# This will fail with specific messages if the target object is connected
-# to the specified signal on the source object.
-# ------------------------------------------------------------------------------
-func assert_not_connected(signaler_obj, connect_to_obj, signal_name, method_name=""):
-	var method_disp = ''
-	if (method_name != ""):
-		method_disp = str(' using method: [', method_name, '] ')
-	var disp = str('Expected object ', _str(signaler_obj),\
-		' to not be connected to signal: [', signal_name, '] on ',\
-		_str(connect_to_obj), method_disp)
-	if(_is_connected(signaler_obj, connect_to_obj, signal_name, method_name)):
-		_fail(disp)
-	else:
-		_pass(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts that a signal has been emitted at least once.
-#
-# This will fail with specific messages if the object is not being watched or
-# the object does not have the specified signal
-# ------------------------------------------------------------------------------
-func assert_signal_emitted(object, signal_name, text=""):
-	var disp = str('Expected object ', _str(object), ' to have emitted signal [', signal_name, ']:  ', text)
-	if(_can_make_signal_assertions(object, signal_name)):
-		if(_signal_watcher.did_emit(object, signal_name)):
-			_pass(disp)
-		else:
-			_fail(_get_fail_msg_including_emitted_signals(disp, object))
-
-# ------------------------------------------------------------------------------
-# Asserts that a signal has not been emitted.
-#
-# This will fail with specific messages if the object is not being watched or
-# the object does not have the specified signal
-# ------------------------------------------------------------------------------
-func assert_signal_not_emitted(object, signal_name, text=""):
-	var disp = str('Expected object ', _str(object), ' to NOT emit signal [', signal_name, ']:  ', text)
-	if(_can_make_signal_assertions(object, signal_name)):
-		if(_signal_watcher.did_emit(object, signal_name)):
-			_fail(disp)
-		else:
-			_pass(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts that a signal was fired with the specified parameters.  The expected
-# parameters should be passed in as an array.  An optional index can be passed
-# when a signal has fired more than once.  The default is to retrieve the most
-# recent emission of the signal.
-#
-# This will fail with specific messages if the object is not being watched or
-# the object does not have the specified signal
-# ------------------------------------------------------------------------------
-func assert_signal_emitted_with_parameters(object, signal_name, parameters, index=-1):
-	if(typeof(parameters) != TYPE_ARRAY):
-		_lgr.error("The expected parameters must be wrapped in an array, you passed:  " + _str(parameters))
-		_fail("Bad Parameters")
-		return
-
-	var disp = str('Expected object ', _str(object), ' to emit signal [', signal_name, '] with parameters ', parameters, ', got ')
-	if(_can_make_signal_assertions(object, signal_name)):
-		if(_signal_watcher.did_emit(object, signal_name)):
-			var parms_got = _signal_watcher.get_signal_parameters(object, signal_name, index)
-			var diff_result = _compare.deep(parameters, parms_got)
-			if(diff_result.are_equal()):
-				_pass(str(disp, parms_got))
-			else:
-				_fail(str('Expected object ', _str(object), ' to emit signal [', signal_name, '] with parameters ', diff_result.summarize()))
-		else:
-			var text = str('Object ', object, ' did not emit signal [', signal_name, ']')
-			_fail(_get_fail_msg_including_emitted_signals(text, object))
-
-# ------------------------------------------------------------------------------
-# Assert that a signal has been emitted a specific number of times.
-#
-# This will fail with specific messages if the object is not being watched or
-# the object does not have the specified signal
-# ------------------------------------------------------------------------------
-func assert_signal_emit_count(object, signal_name, times, text=""):
-	if(_can_make_signal_assertions(object, signal_name)):
-		var count = _signal_watcher.get_emit_count(object, signal_name)
-		var disp = str('Expected the signal [', signal_name, '] emit count of [', count, '] to equal [', times, ']: ', text)
-		if(count== times):
-			_pass(disp)
-		else:
-			_fail(_get_fail_msg_including_emitted_signals(disp, object))
-
-# ------------------------------------------------------------------------------
-# Assert that the passed in object has the specified signal
-# ------------------------------------------------------------------------------
-func assert_has_signal(object, signal_name, text=""):
-	var disp = str('Expected object ', _str(object), ' to have signal [', signal_name, ']:  ', text)
-	if(_signal_watcher.does_object_have_signal(object, signal_name)):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Returns the number of times a signal was emitted.  -1 returned if the object
-# is not being watched.
-# ------------------------------------------------------------------------------
-func get_signal_emit_count(object, signal_name):
-	return _signal_watcher.get_emit_count(object, signal_name)
-
-# ------------------------------------------------------------------------------
-# Get the parmaters of a fired signal.  If the signal was not fired null is
-# returned.  You can specify an optional index (use get_signal_emit_count to
-# determine the number of times it was emitted).  The default index is the
-# latest time the signal was fired (size() -1 insetead of 0).  The parameters
-# returned are in an array.
-# ------------------------------------------------------------------------------
-func get_signal_parameters(object, signal_name, index=-1):
-	return _signal_watcher.get_signal_parameters(object, signal_name, index)
-
-# ------------------------------------------------------------------------------
-# Get the parameters for a method call to a doubled object.  By default it will
-# return the most recent call.  You can optionally specify an index.
-#
-# Returns:
-# * an array of parameter values if a call the method was found
-# * null when a call to the method was not found or the index specified was
-#   invalid.
-# ------------------------------------------------------------------------------
-func get_call_parameters(object, method_name, index=-1):
-	var to_return = null
-	if(_utils.is_double(object)):
-		to_return = gut.get_spy().get_call_parameters(object, method_name, index)
-	else:
-		_lgr.error('You must pass a doulbed object to get_call_parameters.')
-
-	return to_return
-
-# ------------------------------------------------------------------------------
-# Returns the call count for a method with optional paramter matching.
-# ------------------------------------------------------------------------------
-func get_call_count(object, method_name, parameters=null):
-	return gut.get_spy().call_count(object, method_name, parameters)
-
-# ------------------------------------------------------------------------------
-# Deprecated. Use assert_is.
-# ------------------------------------------------------------------------------
-func assert_extends(object, a_class, text=''):
-	_lgr.deprecated('assert_extends', 'assert_is')
-	assert_is(object, a_class, text)
-
-# ------------------------------------------------------------------------------
-# Assert that object is an instance of a_class
-# ------------------------------------------------------------------------------
-func assert_is(object, a_class, text=''):
-	var disp  = ''#var disp = str('Expected [', _str(object), '] to be type of [', a_class, ']: ', text)
-	var NATIVE_CLASS = 'GDScriptNativeClass'
-	var GDSCRIPT_CLASS = 'GDScript'
-	var bad_param_2 = 'Parameter 2 must be a Class (like Node2D or Label).  You passed '
-
-	if(typeof(object) != TYPE_OBJECT):
-		_fail(str('Parameter 1 must be an instance of an object.  You passed:  ', _str(object)))
-	elif(typeof(a_class) != TYPE_OBJECT):
-		_fail(str(bad_param_2, _str(a_class)))
-	else:
-		var a_str = _str(a_class)
-		disp = str('Expected [', _str(object), '] to extend [', a_str, ']: ', text)
-		if(a_class.get_class() != NATIVE_CLASS and a_class.get_class() != GDSCRIPT_CLASS):
-			_fail(str(bad_param_2, a_str))
-		else:
-			if(object is a_class):
-				_pass(disp)
-			else:
-				_fail(disp)
-
-func _get_typeof_string(the_type):
-	var to_return = ""
-	if(_strutils.types.has(the_type)):
-		to_return += str(the_type, '(',  _strutils.types[the_type], ')')
-	else:
-		to_return += str(the_type)
-	return to_return
-
-# ------------------------------------------------------------------------------
-# ------------------------------------------------------------------------------
-func assert_typeof(object, type, text=''):
-	var disp = str('Expected [typeof(', object, ') = ')
-	disp += _get_typeof_string(typeof(object))
-	disp += '] to equal ['
-	disp += _get_typeof_string(type) +  ']'
-	disp += '.  ' + text
-	if(typeof(object) == type):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# ------------------------------------------------------------------------------
-func assert_not_typeof(object, type, text=''):
-	var disp = str('Expected [typeof(', object, ') = ')
-	disp += _get_typeof_string(typeof(object))
-	disp += '] to not equal ['
-	disp += _get_typeof_string(type) +  ']'
-	disp += '.  ' + text
-	if(typeof(object) != type):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Assert that text contains given search string.
-# The match_case flag determines case sensitivity.
-# ------------------------------------------------------------------------------
-func assert_string_contains(text, search, match_case=true):
-	var empty_search = 'Expected text and search strings to be non-empty. You passed \'%s\' and \'%s\'.'
-	var disp = 'Expected \'%s\' to contain \'%s\', match_case=%s' % [text, search, match_case]
-	if(text == '' or search == ''):
-		_fail(empty_search % [text, search])
-	elif(match_case):
-		if(text.find(search) == -1):
-			_fail(disp)
-		else:
-			_pass(disp)
-	else:
-		if(text.to_lower().find(search.to_lower()) == -1):
-			_fail(disp)
-		else:
-			_pass(disp)
-
-# ------------------------------------------------------------------------------
-# Assert that text starts with given search string.
-# match_case flag determines case sensitivity.
-# ------------------------------------------------------------------------------
-func assert_string_starts_with(text, search, match_case=true):
-	var empty_search = 'Expected text and search strings to be non-empty. You passed \'%s\' and \'%s\'.'
-	var disp = 'Expected \'%s\' to start with \'%s\', match_case=%s' % [text, search, match_case]
-	if(text == '' or search == ''):
-		_fail(empty_search % [text, search])
-	elif(match_case):
-		if(text.find(search) == 0):
-			_pass(disp)
-		else:
-			_fail(disp)
-	else:
-		if(text.to_lower().find(search.to_lower()) == 0):
-			_pass(disp)
-		else:
-			_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Assert that text ends with given search string.
-# match_case flag determines case sensitivity.
-# ------------------------------------------------------------------------------
-func assert_string_ends_with(text, search, match_case=true):
-	var empty_search = 'Expected text and search strings to be non-empty. You passed \'%s\' and \'%s\'.'
-	var disp = 'Expected \'%s\' to end with \'%s\', match_case=%s' % [text, search, match_case]
-	var required_index = len(text) - len(search)
-	if(text == '' or search == ''):
-		_fail(empty_search % [text, search])
-	elif(match_case):
-		if(text.find(search) == required_index):
-			_pass(disp)
-		else:
-			_fail(disp)
-	else:
-		if(text.to_lower().find(search.to_lower()) == required_index):
-			_pass(disp)
-		else:
-			_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Assert that a method was called on an instance of a doubled class.  If
-# parameters are supplied then the params passed in when called must match.
-# TODO make 3rd parameter "param_or_text" and add fourth parameter of "text" and
-#      then work some magic so this can have a "text" parameter without being
-#      annoying.
-# ------------------------------------------------------------------------------
-func assert_called(inst, method_name, parameters=null):
-	var disp = str('Expected [',method_name,'] to have been called on ',_str(inst))
-
-	if(_fail_if_parameters_not_array(parameters)):
-		return
-
-	if(!_utils.is_double(inst)):
-		_fail('You must pass a doubled instance to assert_called.  Check the wiki for info on using double.')
-	else:
-		if(gut.get_spy().was_called(inst, method_name, parameters)):
-			_pass(disp)
-		else:
-			if(parameters != null):
-				disp += str(' with parameters ', parameters)
-			_fail(str(disp, "\n", _get_desc_of_calls_to_instance(inst)))
-
-# ------------------------------------------------------------------------------
-# Assert that a method was not called on an instance of a doubled class.  If
-# parameters are specified then this will only fail if it finds a call that was
-# sent matching parameters.
-# ------------------------------------------------------------------------------
-func assert_not_called(inst, method_name, parameters=null):
-	var disp = str('Expected [', method_name, '] to NOT have been called on ', _str(inst))
-
-	if(_fail_if_parameters_not_array(parameters)):
-		return
-
-	if(!_utils.is_double(inst)):
-		_fail('You must pass a doubled instance to assert_not_called.  Check the wiki for info on using double.')
-	else:
-		if(gut.get_spy().was_called(inst, method_name, parameters)):
-			if(parameters != null):
-				disp += str(' with parameters ', parameters)
-			_fail(str(disp, "\n", _get_desc_of_calls_to_instance(inst)))
-		else:
-			_pass(disp)
-
-# ------------------------------------------------------------------------------
-# Assert that a method on an instance of a doubled class was called a number
-# of times.  If parameters are specified then only calls with matching
-# parameter values will be counted.
-# ------------------------------------------------------------------------------
-func assert_call_count(inst, method_name, expected_count, parameters=null):
-	var count = gut.get_spy().call_count(inst, method_name, parameters)
-
-	if(_fail_if_parameters_not_array(parameters)):
-		return
-
-	var param_text = ''
-	if(parameters):
-		param_text = ' with parameters ' + str(parameters)
-	var disp = 'Expected [%s] on %s to be called [%s] times%s.  It was called [%s] times.'
-	disp = disp % [method_name, _str(inst), expected_count, param_text, count]
-
-	if(!_utils.is_double(inst)):
-		_fail('You must pass a doubled instance to assert_call_count.  Check the wiki for info on using double.')
-	else:
-		if(count == expected_count):
-			_pass(disp)
-		else:
-			_fail(str(disp, "\n", _get_desc_of_calls_to_instance(inst)))
-
-# ------------------------------------------------------------------------------
-# Asserts the passed in value is null
-# ------------------------------------------------------------------------------
-func assert_null(got, text=''):
-	var disp = str('Expected [', _str(got), '] to be NULL:  ', text)
-	if(got == null):
-		_pass(disp)
-	else:
-		_fail(disp)
-
-# ------------------------------------------------------------------------------
-# Asserts the passed in value is null
-# ------------------------------------------------------------------------------
-func assert_not_null(got, text=''):
-	var disp = str('Expected [', _str(got), '] to be anything but NULL:  ', text)
-	if(got == null):
-		_fail(disp)
-	else:
-		_pass(disp)
-
-# -----------------------------------------------------------------------------
-# Asserts object has been freed from memory
-# We pass in a title (since if it is freed, we lost all identity data)
-# -----------------------------------------------------------------------------
-func assert_freed(obj, title='something'):
-	var disp = title
-	if(is_instance_valid(obj)):
-		disp = _strutils.type2str(obj) + title
-	assert_true(not is_instance_valid(obj), "Expected [%s] to be freed" % disp)
-
-# ------------------------------------------------------------------------------
-# Asserts Object has not been freed from memory
-# -----------------------------------------------------------------------------
-func assert_not_freed(obj, title):
-	var disp = title
-	if(is_instance_valid(obj)):
-		disp = _strutils.type2str(obj) + title
-	assert_true(is_instance_valid(obj), "Expected [%s] to not be freed" % disp)
-
-# ------------------------------------------------------------------------------
-# Asserts that the current test has not introduced any new orphans.  This only
-# applies to the test code that preceedes a call to this method so it should be
-# the last thing your test does.
-# ------------------------------------------------------------------------------
-func assert_no_new_orphans(text=''):
-	var count = gut.get_orphan_counter().get_counter('test')
-	var msg = ''
-	if(text != ''):
-		msg = ':  ' + text
-	# Note that get_counter will return -1 if the counter does not exist.  This
-	# can happen with a misplaced assert_no_new_orphans.  Checking for > 0
-	# ensures this will not cause some weird failure.
-	if(count > 0):
-		_fail(str('Expected no orphans, but found ', count, msg))
-	else:
-		_pass('No new orphans found.' + msg)
-
-# ------------------------------------------------------------------------------
-# Returns a dictionary that contains
-# - an is_valid flag whether validation was successful or not and
-# - a message that gives some information about the validation errors.
-# ------------------------------------------------------------------------------
-func _validate_assert_setget_called_input(type, name_property
-			, name_setter, name_getter):
-	var obj = null
-	var result = {"is_valid": true, "msg": ""}
-
-	if null == type or typeof(type) != TYPE_OBJECT or not type.is_class("Resource"):
-		result.is_valid = false
-		result.msg = str("The type parameter should be a ressource, ", _str(type), ' was passed.')
-		return result
-
-	if null == double(type):
-		result.is_valid = false
-		result.msg = str("Attempt to double the type parameter failed. The type parameter should be a ressource that can be doubled.")
-		return result
-
-	obj = _create_obj_from_type(type)
-	var property = _find_object_property(obj, str(name_property))
-
-	if null == property:
-		result.is_valid = false
-		result.msg += str("The property %s does not exist." % _str(name_property))
-	if name_setter == "" and name_getter == "":
-		result.is_valid = false
-		result.msg += str("Either setter or getter method must be specified.")
-	if name_setter != "" and not obj.has_method(str(name_setter)):
-		result.is_valid = false
-		result.msg += str("Setter method %s does not exist.  " % _str(name_setter))
-	if name_getter != "" and not obj.has_method(str(name_getter)):
-		result.is_valid = false
-		result.msg += str("Getter method %s does not exist.  " %_str(name_getter))
-
-	obj.free()
-	return result
-
-# ------------------------------------------------------------------------------
-# Validates the singleton_name is a string and exists.  Errors when conditions
-# are not met.  Returns true/false if singleton_name is valid or not.
-# ------------------------------------------------------------------------------
-func _validate_singleton_name(singleton_name):
-	var is_valid = true
-	if(typeof(singleton_name) != TYPE_STRING):
-		_lgr.error("double_singleton requires a Godot singleton name, you passed " + _str(singleton_name))
-		is_valid = false
-	# Sometimes they have underscores in front of them, sometimes they do not.
-	# The doubler is smart enought of ind the right thing, so this has to be
-	# that smart as well.
-	elif(!ClassDB.class_exists(singleton_name) and !ClassDB.class_exists('_' + singleton_name)):
-		var txt = str("The singleton [", singleton_name, "] could not be found.  ",
-					"Check the GlobalScope page for a list of singletons.")
-		_lgr.error(txt)
-		is_valid = false
-	return is_valid
-
-
-# ------------------------------------------------------------------------------
-# Asserts the given setter and getter methods are called when the given property
-# is accessed.
-# ------------------------------------------------------------------------------
-func _assert_setget_called(type, name_property, setter = "", getter  = ""):
-	var name_setter = _utils.nvl(setter, "")
-	var name_getter = _utils.nvl(getter, "")
-
-	var validation = _validate_assert_setget_called_input(type, name_property, str(name_setter), str(name_getter))
-	if not validation.is_valid:
-		_fail(validation.msg)
-		return
-
-	var message = ""
-	var amount_calls_setter = 0
-	var amount_calls_getter = 0
-	var expected_calls_setter = 0
-	var expected_calls_getter = 0
-	var obj = _create_obj_from_type(double(type))
-
-	if name_setter != '':
-		expected_calls_setter = 1
-		stub(obj, name_setter).to_do_nothing()
-		obj.set(name_property, null)
-		amount_calls_setter = gut.get_spy().call_count(obj, str(name_setter))
-
-	if name_getter != '':
-		expected_calls_getter = 1
-		stub(obj, name_getter).to_do_nothing()
-		var __new_property = obj.get(name_property)
-		amount_calls_getter = gut.get_spy().call_count(obj, str(name_getter))
-
-	obj.free()
-
-	# assert
-
-	if amount_calls_setter == expected_calls_setter and amount_calls_getter == expected_calls_getter:
-		_pass(str("setget for %s is correctly configured." % _str(name_property)))
-	else:
-		if amount_calls_setter < expected_calls_setter:
-			message += " The setter was not called."
-		elif amount_calls_setter > expected_calls_setter:
-			message += " The setter was called but should not have been."
-		if amount_calls_getter < expected_calls_getter:
-			message += " The getter was not called."
-		elif amount_calls_getter > expected_calls_getter:
-			message += " The getter was called but should not have been."
-		_fail(str(message))
-
-# ------------------------------------------------------------------------------
-# Wrapper: invokes assert_setget_called but provides a slightly more convenient
-# signature
-# ------------------------------------------------------------------------------
-func assert_setget(
-	instance, name_property,
-	const_or_setter = DEFAULT_SETTER_GETTER, getter="__not_set__"):
-
-	var getter_name = null
-	if(getter != "__not_set__"):
-		getter_name = getter
-
-	var setter_name = null
-	if(typeof(const_or_setter) == TYPE_INT):
-		if(const_or_setter in [SETTER_ONLY, DEFAULT_SETTER_GETTER]):
-			setter_name  = str("set_", name_property)
-
-		if(const_or_setter in [GETTER_ONLY, DEFAULT_SETTER_GETTER]):
-			getter_name = str("get_", name_property)
-	else:
-		setter_name = const_or_setter
-
-	var resource = null
-	if instance.is_class("Resource"):
-		resource = instance
-	else:
-		resource = instance.get_script()
-
-	_assert_setget_called(resource, str(name_property), setter_name, getter_name)
-
-
-# ------------------------------------------------------------------------------
-# Wrapper: asserts if the property exists, the accessor methods exist and the
-# setget keyword is set for accessor methods
-# ------------------------------------------------------------------------------
-func assert_property(instance, name_property, default_value, new_value) -> void:
-	var free_me = []
-	var resource = null
-	var obj = null
-	if instance.is_class("Resource"):
-		resource = instance
-		obj = _create_obj_from_type(resource)
-		free_me.append(obj)
-	else:
-		resource = instance.get_script()
-		obj = instance
-
-	var name_setter = "set_" + str(name_property)
-	var name_getter = "get_" + str(name_property)
-
-	var pre_fail_count = get_fail_count()
-	assert_accessors(obj, str(name_property), default_value, new_value)
-	_assert_setget_called(resource, str(name_property), name_setter, name_getter)
-
-	for entry in free_me:
-		entry.free()
-
-	# assert
-	if get_fail_count() == pre_fail_count:
-		_pass(str("The property is set up as expected."))
-	else:
-		_fail(str("The property is not set up as expected. Examine subtests to see what failed."))
-
-
-# ------------------------------------------------------------------------------
-# Mark the current test as pending.
-# ------------------------------------------------------------------------------
-func pending(text=""):
-	_summary.pending += 1
-	if(gut):
-		_lgr.pending(text)
-		gut._pending(text)
-
-# ------------------------------------------------------------------------------
-# Returns the number of times a signal was emitted.  -1 returned if the object
-# is not being watched.
-# ------------------------------------------------------------------------------
-
-# ------------------------------------------------------------------------------
-# Yield for the time sent in.  The optional message will be printed when
-# Gut detects the yield.  When the time expires the YIELD signal will be
-# emitted.
-# ------------------------------------------------------------------------------
-func yield_for(time, msg=''):
-	return gut.set_yield_time(time, msg)
-
-# ------------------------------------------------------------------------------
-# Yield to a signal or a maximum amount of time, whichever comes first.  When
-# the conditions are met the YIELD signal will be emitted.
-# ------------------------------------------------------------------------------
-func yield_to(obj, signal_name, max_wait, msg=''):
-	watch_signals(obj)
-	gut.set_yield_signal_or_time(obj, signal_name, max_wait, msg)
-
-	return gut
-
-# ------------------------------------------------------------------------------
-# Yield for a number of frames.  The optional message will be printed. when
-# Gut detects a yield.  When the number of frames have elapsed (counted in gut's
-# _process function) the YIELD signal will be emitted.
-# ------------------------------------------------------------------------------
-func yield_frames(frames, msg=''):
-	if(frames <= 0):
-		var text = str('yeild_frames:  frames must be > 0, you passed  ', frames, '.  0 frames waited.')
-		_lgr.error(text)
-		frames = 0
-
-	gut.set_yield_frames(frames, msg)
-	return gut
-
-# ------------------------------------------------------------------------------
-# Ends a test that had a yield in it.  You only need to use this if you do
-# not make assertions after a yield.
-# ------------------------------------------------------------------------------
-func end_test():
-	_lgr.deprecated('end_test is no longer necessary, you can remove it.')
-	#gut.end_yielded_test()
-
-func get_summary():
-	return _summary
-
-func get_fail_count():
-	return _summary.failed
-
-func get_pass_count():
-	return _summary.passed
-
-func get_pending_count():
-	return _summary.pending
-
-func get_assert_count():
-	return _summary.asserts
-
-func clear_signal_watcher():
-	_signal_watcher.clear()
-
-func get_double_strategy():
-	return gut.get_doubler().get_strategy()
-
-func set_double_strategy(double_strategy):
-	gut.get_doubler().set_strategy(double_strategy)
-
-func pause_before_teardown():
-	gut.pause_before_teardown()
-
-# ------------------------------------------------------------------------------
-# Convert the _summary dictionary into text
-# ------------------------------------------------------------------------------
-func get_summary_text():
-	var to_return = get_script().get_path() + "\n"
-	to_return += str('  ', _summary.passed, ' of ', _summary.asserts, ' passed.')
-	if(_summary.pending > 0):
-		to_return += str("\n  ", _summary.pending, ' pending')
-	if(_summary.failed > 0):
-		to_return += str("\n  ", _summary.failed, ' failed.')
-	return to_return
-
-# ------------------------------------------------------------------------------
-# Double a script, inner class, or scene using a path or a loaded script/scene.
-#
-#
-# ------------------------------------------------------------------------------
-
-# ------------------------------------------------------------------------------
-# ------------------------------------------------------------------------------
-func _smart_double(double_info):
-	var override_strat = _utils.nvl(double_info.strategy, gut.get_doubler().get_strategy())
-	var to_return = null
-
-	if(double_info.is_scene()):
-		if(double_info.make_partial):
-			to_return =  gut.get_doubler().partial_double_scene(double_info.path, override_strat)
-		else:
-			to_return =  gut.get_doubler().double_scene(double_info.path, override_strat)
-
-	elif(double_info.is_native()):
-		if(double_info.make_partial):
-			to_return = gut.get_doubler().partial_double_gdnative(double_info.path)
-		else:
-			to_return = gut.get_doubler().double_gdnative(double_info.path)
-
-	elif(double_info.is_script()):
-		if(double_info.subpath == null):
-			if(double_info.make_partial):
-				to_return = gut.get_doubler().partial_double(double_info.path, override_strat)
-			else:
-				to_return = gut.get_doubler().double(double_info.path, override_strat)
-		else:
-			if(double_info.make_partial):
-				to_return = gut.get_doubler().partial_double_inner(double_info.path, double_info.subpath, override_strat)
-			else:
-				to_return = gut.get_doubler().double_inner(double_info.path, double_info.subpath, override_strat)
-	return to_return
-
-# ------------------------------------------------------------------------------
-# ------------------------------------------------------------------------------
-func double(thing, p2=null, p3=null):
-	var double_info = DoubleInfo.new(thing, p2, p3)
-	if(!double_info.is_valid):
-		_lgr.error('double requires a class or path, you passed an instance:  ' + _str(thing))
-		return null
-
-	double_info.make_partial = false
-
-	return _smart_double(double_info)
-
-# ------------------------------------------------------------------------------
-# ------------------------------------------------------------------------------
-func partial_double(thing, p2=null, p3=null):
-	var double_info = DoubleInfo.new(thing, p2, p3)
-	if(!double_info.is_valid):
-		_lgr.error('partial_double requires a class or path, you passed an instance:  ' + _str(thing))
-		return null
-
-	double_info.make_partial = true
-
-	return _smart_double(double_info)
-
-# ------------------------------------------------------------------------------
-# Doubles a Godot singleton
-# ------------------------------------------------------------------------------
-func double_singleton(singleton_name):
-	return null
-	# var to_return = null
-	# if(_validate_singleton_name(singleton_name)):
-	# 	to_return = gut.get_doubler().double_singleton(singleton_name)
-	# return to_return
-
-# ------------------------------------------------------------------------------
-# Partial Doubles a Godot singleton
-# ------------------------------------------------------------------------------
-func partial_double_singleton(singleton_name):
-	return null
-	# var to_return = null
-	# if(_validate_singleton_name(singleton_name)):
-	# 	to_return = gut.get_doubler().partial_double_singleton(singleton_name)
-	# return to_return
-
-# ------------------------------------------------------------------------------
-# Specifically double a scene
-# ------------------------------------------------------------------------------
-func double_scene(path, strategy=null):
-	var override_strat = _utils.nvl(strategy, gut.get_doubler().get_strategy())
-	return gut.get_doubler().double_scene(path, override_strat)
-
-# ------------------------------------------------------------------------------
-# Specifically double a script
-# ------------------------------------------------------------------------------
-func double_script(path, strategy=null):
-	var override_strat = _utils.nvl(strategy, gut.get_doubler().get_strategy())
-	return gut.get_doubler().double(path, override_strat)
-
-# ------------------------------------------------------------------------------
-# Specifically double an Inner class in a a script
-# ------------------------------------------------------------------------------
-func double_inner(path, subpath, strategy=null):
-	var override_strat = _utils.nvl(strategy, gut.get_doubler().get_strategy())
-	return gut.get_doubler().double_inner(path, subpath, override_strat)
-
-
-# ------------------------------------------------------------------------------
-# Add a method that the doubler will ignore.  You can pass this the path to a
-# script or scene or a loaded script or scene.  When running tests, these
-# ignores are cleared after every test.
-# ------------------------------------------------------------------------------
-func ignore_method_when_doubling(thing, method_name):
-	var double_info = DoubleInfo.new(thing)
-	var path = double_info.path
-
-	if(double_info.is_scene()):
-		var inst = thing.instance()
-		if(inst.get_script()):
-			path = inst.get_script().get_path()
-
-	gut.get_doubler().add_ignored_method(path, method_name)
-
-# ------------------------------------------------------------------------------
-# Stub something.
-#
-# Parameters
-# 1: the thing to stub, a file path or a instance or a class
-# 2: either an inner class subpath or the method name
-# 3: the method name if an inner class subpath was specified
-# NOTE:  right now we cannot stub inner classes at the path level so this should
-#        only be called with two parameters.  I did the work though so I'm going
-#        to leave it but not update the wiki.
-# ------------------------------------------------------------------------------
-func stub(thing, p2, p3=null):
-	if(_utils.is_instance(thing) and !_utils.is_double(thing)):
-		_lgr.error(str('You cannot use stub on ', _str(thing), ' because it is not a double.'))
-		return _utils.StubParams.new()
-
-	var method_name = p2
-	var subpath = null
-	if(p3 != null):
-		subpath = p2
-		method_name = p3
-
-	var sp = _utils.StubParams.new(thing, method_name, subpath)
-	gut.get_stubber().add_stub(sp)
-	return sp
-
-# ------------------------------------------------------------------------------
-# convenience wrapper.
-# ------------------------------------------------------------------------------
-func simulate(obj, times, delta):
-	gut.simulate(obj, times, delta)
-
-# ------------------------------------------------------------------------------
-# Replace the node at base_node.get_node(path) with with_this.  All references
-# to the node via $ and get_node(...) will now return with_this.  with_this will
-# get all the groups that the node that was replaced had.
-#
-# The node that was replaced is queued to be freed.
-#
-# TODO see replace_by method, this could simplify the logic here.
-# ------------------------------------------------------------------------------
-func replace_node(base_node, path_or_node, with_this):
-	var path = path_or_node
-
-	if(typeof(path_or_node) != TYPE_STRING):
-		# This will cause an engine error if it fails.  It always returns a
-		# NodePath, even if it fails.  Checking the name count is the only way
-		# I found to check if it found something or not (after it worked I
-		# didn't look any farther).
-		path = base_node.get_path_to(path_or_node)
-		if(path.get_name_count() == 0):
-			_lgr.error('You passed an object that base_node does not have.  Cannot replace node.')
-			return
-
-	if(!base_node.has_node(path)):
-		_lgr.error(str('Could not find node at path [', path, ']'))
-		return
-
-	var to_replace = base_node.get_node(path)
-	var parent = to_replace.get_parent()
-	var replace_name = to_replace.get_name()
-
-	parent.remove_child(to_replace)
-	parent.add_child(with_this)
-	with_this.set_name(replace_name)
-	with_this.set_owner(parent)
-
-	var groups = to_replace.get_groups()
-	for i in range(groups.size()):
-		with_this.add_to_group(groups[i])
-
-	to_replace.queue_free()
-
-
-# ------------------------------------------------------------------------------
-# This method does a somewhat complicated dance with Gut.  It assumes that Gut
-# will clear its parameter handler after it finishes calling a parameterized test
-# enough times.
-# ------------------------------------------------------------------------------
-func use_parameters(params):
-	var ph = gut.get_parameter_handler()
-	if(ph == null):
-		ph = _utils.ParameterHandler.new(params)
-		gut.set_parameter_handler(ph)
-
-	var output = str('(call #', ph.get_call_count() + 1, ') with parameters:  ', ph.get_current_parameters())
-	_lgr.log(output)
-	_lgr.inc_indent()
-	return ph.next_parameters()
-
-# ------------------------------------------------------------------------------
-# Marks whatever is passed in to be freed after the test finishes.  It also
-# returns what is passed in so you can save a line of code.
-#   var thing = autofree(Thing.new())
-# ------------------------------------------------------------------------------
-func autofree(thing):
-	gut.get_autofree().add_free(thing)
-	return thing
-
-# ------------------------------------------------------------------------------
-# Works the same as autofree except queue_free will be called on the object
-# instead.  This also imparts a brief pause after the test finishes so that
-# the queued object has time to free.
-# ------------------------------------------------------------------------------
-func autoqfree(thing):
-	gut.get_autofree().add_queue_free(thing)
-	return thing
-
-# ------------------------------------------------------------------------------
-# The same as autofree but it also adds the object as a child of the test.
-# ------------------------------------------------------------------------------
-func add_child_autofree(node, legible_unique_name = false):
-	gut.get_autofree().add_free(node)
-	# Explicitly calling super here b/c add_child MIGHT change and I don't want
-	# a bug sneaking its way in here.
-	.add_child(node, legible_unique_name)
-	return node
-
-# ------------------------------------------------------------------------------
-# The same as autoqfree but it also adds the object as a child of the test.
-# ------------------------------------------------------------------------------
-func add_child_autoqfree(node, legible_unique_name=false):
-	gut.get_autofree().add_queue_free(node)
-	# Explicitly calling super here b/c add_child MIGHT change and I don't want
-	# a bug sneaking its way in here.
-	.add_child(node, legible_unique_name)
-	return node
-
-# ------------------------------------------------------------------------------
-# Returns true if the test is passing as of the time of this call.  False if not.
-# ------------------------------------------------------------------------------
-func is_passing():
-	if(gut.get_current_test_object() != null and
-		!['before_all', 'after_all'].has(gut.get_current_test_object().name)):
-		return gut.get_current_test_object().passed and \
-			gut.get_current_test_object().assert_count > 0
-	else:
-		_lgr.error('No current test object found.  is_passing must be called inside a test.')
-		return null
-
-# ------------------------------------------------------------------------------
-# Returns true if the test is failing as of the time of this call.  False if not.
-# ------------------------------------------------------------------------------
-func is_failing():
-	if(gut.get_current_test_object() != null and
-		!['before_all', 'after_all'].has(gut.get_current_test_object().name)):
-		return !gut.get_current_test_object().passed
-	else:
-		_lgr.error('No current test object found.  is_failing must be called inside a test.')
-		return null
-
-# ------------------------------------------------------------------------------
-# Marks the test as passing.  Does not override any failing asserts or calls to
-# fail_test.  Same as a passing assert.
-# ------------------------------------------------------------------------------
-func pass_test(text):
-	_pass(text)
-
-# ------------------------------------------------------------------------------
-# Marks the test as failing.  Same as a failing assert.
-# ------------------------------------------------------------------------------
-func fail_test(text):
-	_fail(text)
-
-# ------------------------------------------------------------------------------
-# Peforms a deep compare on both values, a CompareResult instnace is returned.
-# The optional max_differences paramter sets the max_differences to be displayed.
-# ------------------------------------------------------------------------------
-func compare_deep(v1, v2, max_differences=null):
-	var result = _compare.deep(v1, v2)
-	if(max_differences != null):
-		result.max_differences = max_differences
-	return result
-
-# ------------------------------------------------------------------------------
-# Peforms a shallow compare on both values, a CompareResult instnace is returned.
-# The optional max_differences paramter sets the max_differences to be displayed.
-# ------------------------------------------------------------------------------
-func compare_shallow(v1, v2, max_differences=null):
-	var result = _compare.shallow(v1, v2)
-	if(max_differences != null):
-		result.max_differences = max_differences
-	return result
-
-# ------------------------------------------------------------------------------
-# Performs a deep compare and asserts the  values are equal
-# ------------------------------------------------------------------------------
-func assert_eq_deep(v1, v2):
-	var result = compare_deep(v1, v2)
-	if(result.are_equal):
-		_pass(result.get_short_summary())
-	else:
-		_fail(result.summary)
-
-# ------------------------------------------------------------------------------
-# Performs a deep compare and asserts the values are not equal
-# ------------------------------------------------------------------------------
-func assert_ne_deep(v1, v2):
-	var result = compare_deep(v1, v2)
-	if(!result.are_equal):
-		_pass(result.get_short_summary())
-	else:
-		_fail(result.get_short_summary())
-
-# ------------------------------------------------------------------------------
-# Performs a shallow compare and asserts the values are equal
-# ------------------------------------------------------------------------------
-func assert_eq_shallow(v1, v2):
-	var result = compare_shallow(v1, v2)
-	if(result.are_equal):
-		_pass(result.get_short_summary())
-	else:
-		_fail(result.summary)
-
-# ------------------------------------------------------------------------------
-# Performs a shallow compare and asserts the values are not equal
-# ------------------------------------------------------------------------------
-func assert_ne_shallow(v1, v2):
-	var result = compare_shallow(v1, v2)
-	if(!result.are_equal):
-		_pass(result.get_short_summary())
-	else:
-		_fail(result.get_short_summary())
-
-
-# ------------------------------------------------------------------------------
-# Checks the passed in version string (x.x.x) against the engine version to see
-# if the engine version is less than the expected version.  If it is then the
-# test is mareked as passed (for a lack of anything better to do).  The result
-# of the check is returned.
-#
-# Example:
-# if(skip_if_godot_version_lt('3.5.0')):
-# 	return
-# ------------------------------------------------------------------------------
-func skip_if_godot_version_lt(expected):
-	var should_skip = !_utils.is_godot_version_gte(expected)
-	if(should_skip):
-		_pass(str('Skipping ', _utils.godot_version(), ' is less than ', expected))
-	return should_skip
-
-
-# ------------------------------------------------------------------------------
-# Checks if the passed in version matches the engine version.  The passed in
-# version can contain just the major, major.minor or major.minor.path.  If
-# the version is not the same then the test is marked as passed.  The result of
-# the check is returned.
-#
-# Example:
-# if(skip_if_godot_version_ne('3.4')):
-# 	return
-# ------------------------------------------------------------------------------
-func skip_if_godot_version_ne(expected):
-	var should_skip = !_utils.is_godot_version(expected)
-	if(should_skip):
-		_pass(str('Skipping ', _utils.godot_version(), ' is not ', expected))
-	return should_skip
\ No newline at end of file