diff options
Diffstat (limited to 'addons/gut/gut.gd')
| -rw-r--r-- | addons/gut/gut.gd | 1676 |
1 files changed, 1676 insertions, 0 deletions
diff --git a/addons/gut/gut.gd b/addons/gut/gut.gd new file mode 100644 index 0000000..bc00f76 --- /dev/null +++ b/addons/gut/gut.gd @@ -0,0 +1,1676 @@ +# ############################################################################## +#(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 the readme at https://github.com/bitwes/Gut/blob/master/README.md for usage details. +# You should also check out the github wiki at: https://github.com/bitwes/Gut/wiki +# ############################################################################## +extends Control + +# -- Settings -- +var _select_script = '' +var _tests_like = '' +var _inner_class_name = '' +var _should_maximize = false setget set_should_maximize, get_should_maximize +var _log_level = 1 setget set_log_level, get_log_level +var _disable_strict_datatype_checks = false setget disable_strict_datatype_checks, is_strict_datatype_checks_disabled +var _test_prefix = 'test_' +var _file_prefix = 'test_' +var _file_extension = '.gd' +var _inner_class_prefix = 'Test' +var _temp_directory = 'user://gut_temp_directory' +var _export_path = '' setget set_export_path, get_export_path +var _include_subdirectories = false setget set_include_subdirectories, get_include_subdirectories +var _double_strategy = 1 setget set_double_strategy, get_double_strategy +var _pre_run_script = '' setget set_pre_run_script, get_pre_run_script +var _post_run_script = '' setget set_post_run_script, get_post_run_script +var _color_output = false setget set_color_output, get_color_output +var _junit_xml_file = '' setget set_junit_xml_file, get_junit_xml_file +var _junit_xml_timestamp = false setget set_junit_xml_timestamp, get_junit_xml_timestamp +var _add_children_to = self setget set_add_children_to, get_add_children_to +# -- End Settings -- + + +# ########################### +# Other Vars +# ########################### +const LOG_LEVEL_FAIL_ONLY = 0 +const LOG_LEVEL_TEST_AND_FAILURES = 1 +const LOG_LEVEL_ALL_ASSERTS = 2 +const WAITING_MESSAGE = '/# waiting #/' +const PAUSE_MESSAGE = '/# Pausing. Press continue button...#/' +const COMPLETED = 'completed' + +var _utils = load('res://addons/gut/utils.gd').get_instance() +var _lgr = _utils.get_logger() +var _strutils = _utils.Strutils.new() +# Used to prevent multiple messages for deprecated setup/teardown messages +var _deprecated_tracker = _utils.ThingCounter.new() + +# The instance that is created from _pre_run_script. Accessible from +# get_pre_run_script_instance. +var _pre_run_script_instance = null +var _post_run_script_instance = null # This is not used except in tests. + + +var _script_name = null +var _test_collector = _utils.TestCollector.new() + +# The instanced scripts. This is populated as the scripts are run. +var _test_script_objects = [] + +var _waiting = false +var _done = false +var _is_running = false + +var _current_test = null +var _log_text = "" + +var _pause_before_teardown = false +# when true _pause_before_teardown will be ignored. useful +# when batch processing and you don't want to watch. +var _ignore_pause_before_teardown = false +var _wait_timer = Timer.new() + +var _yield_between = { + should = false, + timer = Timer.new(), + after_x_tests = 5, + tests_since_last_yield = 0 +} + +var _was_yield_method_called = false +# used when yielding to gut instead of some other +# signal. Start with set_yield_time() +var _yield_timer = Timer.new() +var _yield_frames = 0 + +var _unit_test_name = '' +var _new_summary = null + +var _yielding_to = { + obj = null, + signal_name = '' +} + +var _stubber = _utils.Stubber.new() +var _doubler = _utils.Doubler.new() +var _spy = _utils.Spy.new() +var _gui = null +var _orphan_counter = _utils.OrphanCounter.new() +var _autofree = _utils.AutoFree.new() + +# This is populated by test.gd each time a paramterized test is encountered +# for the first time. +var _parameter_handler = null + +# Used to cancel importing scripts if an error has occurred in the setup. This +# prevents tests from being run if they were exported and ensures that the +# error displayed is seen since importing generates a lot of text. +var _cancel_import = false + +# Used for proper assert tracking and printing during before_all +var _before_all_test_obj = load('res://addons/gut/test_collector.gd').Test.new() +# Used for proper assert tracking and printing during after_all +var _after_all_test_obj = load('res://addons/gut/test_collector.gd').Test.new() + +const SIGNAL_TESTS_FINISHED = 'tests_finished' +const SIGNAL_STOP_YIELD_BEFORE_TEARDOWN = 'stop_yield_before_teardown' + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +var _should_print_versions = true # used to cut down on output in tests. + + +func _init(): + _before_all_test_obj.name = 'before_all' + _after_all_test_obj.name = 'after_all' + # When running tests for GUT itself, _utils has been setup to always return + # a new logger so this does not set the gut instance on the base logger + # when creating test instances of GUT. + _lgr.set_gut(self) + + add_user_signal(SIGNAL_TESTS_FINISHED) + add_user_signal('test_finished') + add_user_signal(SIGNAL_STOP_YIELD_BEFORE_TEARDOWN) + add_user_signal('timeout') + + _doubler.set_output_dir(_temp_directory) + _doubler.set_stubber(_stubber) + _doubler.set_spy(_spy) + _doubler.set_gut(self) + + # TODO remove these, universal logger should fix this. + _doubler.set_logger(_lgr) + _spy.set_logger(_lgr) + _stubber.set_logger(_lgr) + _test_collector.set_logger(_lgr) + + _gui = load('res://addons/gut/GutScene.tscn').instance() + + +func _physics_process(delta): + if(_yield_frames > 0): + _yield_frames -= 1 + + if(_yield_frames <= 0): + emit_signal('timeout') + +# ------------------------------------------------------------------------------ +# Initialize controls +# ------------------------------------------------------------------------------ +func _ready(): + if(!_utils.is_version_ok()): + _print_versions() + push_error(_utils.get_bad_version_text()) + print('Error: ', _utils.get_bad_version_text()) + get_tree().quit() + return + + if(_should_print_versions): + _lgr.info(str('using [', OS.get_user_data_dir(), '] for temporary output.')) + + set_process_input(true) + + add_child(_wait_timer) + _wait_timer.set_wait_time(1) + _wait_timer.set_one_shot(true) + + add_child(_yield_between.timer) + _wait_timer.set_one_shot(true) + + add_child(_yield_timer) + _yield_timer.set_one_shot(true) + _yield_timer.connect('timeout', self, '_yielding_callback') + + _setup_gui() + + if(_select_script != null): + select_script(_select_script) + + if(_tests_like != null): + set_unit_test_name(_tests_like) + + if(_should_maximize): + # GUI checks for is_in_tree will not pass yet. + call_deferred('maximize') + + # hide the panel that IS gut so that only the GUI is seen + self.self_modulate = Color(1,1,1,0) + show() + _print_versions() + +# ------------------------------------------------------------------------------ +# Runs right before free is called. Can't override `free`. +# ------------------------------------------------------------------------------ +func _notification(what): + if(what == NOTIFICATION_PREDELETE): + for test_script in _test_script_objects: + if(is_instance_valid(test_script)): + test_script.free() + + _test_script_objects = [] + + if(is_instance_valid(_gui)): + _gui.free() + +func _print_versions(send_all = true): + if(!_should_print_versions): + return + + var info = _utils.get_version_text() + + if(send_all): + p(info) + else: + var printer = _lgr.get_printer('gui') + printer.send(info + "\n") + + +# ############################################################################## +# +# GUI Events and setup +# +# ############################################################################## +func _setup_gui(): + # This is how we get the size of the control to translate to the gui when + # the scene is run. This is also another reason why the min_rect_size + # must match between both gut and the gui. + _gui.rect_size = self.rect_size + add_child(_gui) + _gui.set_anchor(MARGIN_RIGHT, ANCHOR_END) + _gui.set_anchor(MARGIN_BOTTOM, ANCHOR_END) + _gui.connect('run_single_script', self, '_on_run_one') + _gui.connect('run_script', self, '_on_new_gui_run_script') + _gui.connect('end_pause', self, '_on_new_gui_end_pause') + _gui.connect('ignore_pause', self, '_on_new_gui_ignore_pause') + _gui.connect('log_level_changed', self, '_on_log_level_changed') + var _foo = connect('tests_finished', _gui, 'end_run') + +func _add_scripts_to_gui(): + var scripts = [] + for i in range(_test_collector.scripts.size()): + var s = _test_collector.scripts[i] + var txt = '' + if(s.has_inner_class()): + txt = str(' - ', s.inner_class_name, ' (', s.tests.size(), ')') + else: + txt = str(s.get_full_name(), ' (', s.tests.size(), ')') + scripts.append(txt) + _gui.set_scripts(scripts) + +func _on_run_one(index): + clear_text() + var indexes = [index] + if(!_test_collector.scripts[index].has_inner_class()): + indexes = _get_indexes_matching_path(_test_collector.scripts[index].path) + _test_the_scripts(indexes) + +func _on_new_gui_run_script(index): + var indexes = [] + clear_text() + for i in range(index, _test_collector.scripts.size()): + indexes.append(i) + _test_the_scripts(indexes) + +func _on_new_gui_end_pause(): + _pause_before_teardown = false + emit_signal(SIGNAL_STOP_YIELD_BEFORE_TEARDOWN) + +func _on_new_gui_ignore_pause(should): + _ignore_pause_before_teardown = should + +func _on_log_level_changed(value): + set_log_level(value) + +##################### +# +# Events +# +##################### + +# ------------------------------------------------------------------------------ +# Timeout for the built in timer. emits the timeout signal. Start timer +# with set_yield_time() +# +# signal_watcher._on_watched_signal supports up to 9 additional arguments. +# This is the most number of parameters GUT supports on signals. The comment +# on _on_watched_signal explains reasoning. +# ------------------------------------------------------------------------------ +func _yielding_callback(from_obj=false, + __arg1=null, __arg2=null, __arg3=null, + __arg4=null, __arg5=null, __arg6=null, + __arg7=null, __arg8=null, __arg9=null): + _lgr.end_yield() + if(_yielding_to.obj): + _yielding_to.obj.call_deferred( + "disconnect", + _yielding_to.signal_name, self, + '_yielding_callback') + _yielding_to.obj = null + _yielding_to.signal_name = '' + + if(from_obj): + # we must yield for a little longer after the signal is emitted so that + # the signal can propagate to other objects. This was discovered trying + # to assert that obj/signal_name was emitted. Without this extra delay + # the yield returns and processing finishes before the rest of the + # objects can get the signal. This works b/c the timer will timeout + # and come back into this method but from_obj will be false. + _yield_timer.set_wait_time(.1) + _yield_timer.start() + else: + emit_signal('timeout') + +# ------------------------------------------------------------------------------ +# completed signal for GDScriptFucntionState returned from a test script that +# has yielded +# ------------------------------------------------------------------------------ +func _on_test_script_yield_completed(): + _waiting = false + +##################### +# +# Private +# +##################### +func _log_test_children_warning(test_script): + if(!_lgr.is_type_enabled(_lgr.types.orphan)): + return + + var kids = test_script.get_children() + if(kids.size() > 0): + var msg = '' + if(_log_level == 2): + msg = "Test script still has children when all tests finisehd.\n" + for i in range(kids.size()): + msg += str(" ", _strutils.type2str(kids[i]), "\n") + msg += "You can use autofree, autoqfree, add_child_autofree, or add_child_autoqfree to automatically free objects." + else: + msg = str("Test script has ", kids.size(), " unfreed children. Increase log level for more details.") + + + _lgr.warn(msg) + +# ------------------------------------------------------------------------------ +# Convert the _summary dictionary into text +# ------------------------------------------------------------------------------ +func _print_summary(): + _lgr.log("\n\n*** Run Summary ***", _lgr.fmts.yellow) + + _new_summary.log_summary_text(_lgr) + + var logger_text = '' + if(_lgr.get_errors().size() > 0): + logger_text += str("\n* ", _lgr.get_errors().size(), ' Errors.') + if(_lgr.get_warnings().size() > 0): + logger_text += str("\n* ", _lgr.get_warnings().size(), ' Warnings.') + if(_lgr.get_deprecated().size() > 0): + logger_text += str("\n* ", _lgr.get_deprecated().size(), ' Deprecated calls.') + if(logger_text != ''): + logger_text = "\nWarnings/Errors:" + logger_text + "\n\n" + _lgr.log(logger_text) + + if(_new_summary.get_totals().tests > 0): + var fmt = _lgr.fmts.green + var msg = str(_new_summary.get_totals().passing_tests) + ' passed ' + str(_new_summary.get_totals().failing_tests) + ' failed. ' + \ + str("Tests finished in ", _gui.elapsed_time_as_str()) + if(_new_summary.get_totals().failing > 0): + fmt = _lgr.fmts.red + elif(_new_summary.get_totals().pending > 0): + fmt = _lgr.fmts.yellow + + _lgr.log(msg, fmt) + else: + _lgr.log('No tests ran', _lgr.fmts.red) + + +func _validate_hook_script(path): + var result = { + valid = true, + instance = null + } + + # empty path is valid but will have a null instance + if(path == ''): + return result + + var f = File.new() + if(f.file_exists(path)): + var inst = load(path).new() + if(inst and inst is _utils.HookScript): + result.instance = inst + result.valid = true + else: + result.valid = false + _lgr.error('The hook script [' + path + '] does not extend GutHookScript') + else: + result.valid = false + _lgr.error('The hook script [' + path + '] does not exist.') + + return result + + +# ------------------------------------------------------------------------------ +# Runs a hook script. Script must exist, and must extend +# res://addons/gut/hook_script.gd +# ------------------------------------------------------------------------------ +func _run_hook_script(inst): + if(inst != null): + inst.gut = self + inst.run() + return inst + +# ------------------------------------------------------------------------------ +# Initialize variables for each run of a single test script. +# ------------------------------------------------------------------------------ +func _init_run(): + var valid = true + _test_collector.set_test_class_prefix(_inner_class_prefix) + _test_script_objects = [] + _new_summary = _utils.Summary.new() + + _log_text = "" + + _current_test = null + + _is_running = true + + _yield_between.tests_since_last_yield = 0 + + var pre_hook_result = _validate_hook_script(_pre_run_script) + _pre_run_script_instance = pre_hook_result.instance + var post_hook_result = _validate_hook_script(_post_run_script) + _post_run_script_instance = post_hook_result.instance + + valid = pre_hook_result.valid and post_hook_result.valid + + return valid + + +# ------------------------------------------------------------------------------ +# Print out run information and close out the run. +# ------------------------------------------------------------------------------ +func _end_run(): + _gui.end_run() + _print_summary() + p("\n") + + # Do not count any of the _test_script_objects since these will be released + # when GUT is released. + _orphan_counter._counters.total += _test_script_objects.size() + if(_orphan_counter.get_counter('total') > 0 and _lgr.is_type_enabled('orphan')): + _orphan_counter.print_orphans('total', _lgr) + p("Note: This count does not include GUT objects that will be freed upon exit.") + p(" It also does not include any orphans created by global scripts") + p(" loaded before tests were ran.") + p(str("Total orphans = ", _orphan_counter.orphan_count())) + + if(!_utils.is_null_or_empty(_select_script)): + p('Ran Scripts matching "' + _select_script + '"') + if(!_utils.is_null_or_empty(_unit_test_name)): + p('Ran Tests matching "' + _unit_test_name + '"') + if(!_utils.is_null_or_empty(_inner_class_name)): + p('Ran Inner Classes matching "' + _inner_class_name + '"') + + # For some reason the text edit control isn't scrolling to the bottom after + # the summary is printed. As a workaround, yield for a short time and + # then move the cursor. I found this workaround through trial and error. + _yield_between.timer.set_wait_time(0.1) + _yield_between.timer.start() + yield(_yield_between.timer, 'timeout') + _gui.scroll_to_bottom() + + _is_running = false + update() + _run_hook_script(_post_run_script_instance) + _export_results() + emit_signal(SIGNAL_TESTS_FINISHED) + + if _utils.should_display_latest_version: + p("") + p(str("GUT version ",_utils.latest_version," is now available.")) + + _gui.set_title("Finished.") + _gui.compact_mode(false) + + +# ------------------------------------------------------------------------------ +# Add additional export types here. +# ------------------------------------------------------------------------------ +func _export_results(): + if(_junit_xml_file != ''): + _export_junit_xml() + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _export_junit_xml(): + var exporter = _utils.JunitXmlExport.new() + var output_file = _junit_xml_file + + if(_junit_xml_timestamp): + var ext = "." + output_file.get_extension() + output_file = output_file.replace(ext, str("_", OS.get_unix_time(), ext)) + + var f_result = exporter.write_file(self, output_file) + if(f_result == OK): + p(str("Results saved to ", output_file)) + + + +# ------------------------------------------------------------------------------ +# Checks the passed in thing to see if it is a "function state" object that gets +# returned when a function yields. +# ------------------------------------------------------------------------------ +func _is_function_state(script_result): + return script_result != null and \ + typeof(script_result) == TYPE_OBJECT and \ + script_result is GDScriptFunctionState and \ + script_result.is_valid() + +# ------------------------------------------------------------------------------ +# Print out the heading for a new script +# ------------------------------------------------------------------------------ +func _print_script_heading(script): + if(_does_class_name_match(_inner_class_name, script.inner_class_name)): + var fmt = _lgr.fmts.underline + var divider = '-----------------------------------------' + + var text = '' + if(script.inner_class_name == null): + text = script.path + else: + text = script.path + '.' + script.inner_class_name + _lgr.log("\n\n" + text, fmt) + + +# ------------------------------------------------------------------------------ +# Just gets more logic out of _test_the_scripts. Decides if we should yield after +# this test based on flags and counters. +# ------------------------------------------------------------------------------ +func _should_yield_now(): + var should = _yield_between.should and \ + _yield_between.tests_since_last_yield == _yield_between.after_x_tests + if(should): + _yield_between.tests_since_last_yield = 0 + else: + _yield_between.tests_since_last_yield += 1 + return should + +# ------------------------------------------------------------------------------ +# Yes if the class name is null or the script's class name includes class_name +# ------------------------------------------------------------------------------ +func _does_class_name_match(the_class_name, script_class_name): + return (the_class_name == null or the_class_name == '') or (script_class_name != null and script_class_name.findn(the_class_name) != -1) + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _setup_script(test_script): + test_script.gut = self + test_script.set_logger(_lgr) + _add_children_to.add_child(test_script) + _test_script_objects.append(test_script) + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _do_yield_between(frames=2): + _yield_frames = frames + return self + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _wait_for_done(result): + var iter_counter = 0 + var print_after = 3 + + # callback method sets waiting to false. + result.connect(COMPLETED, self, '_on_test_script_yield_completed') + if(!_was_yield_method_called): + _lgr.log('-- Yield detected, waiting --', _lgr.fmts.yellow) + + _was_yield_method_called = false + _waiting = true + _wait_timer.set_wait_time(0.4) + + var dots = '' + while(_waiting): + iter_counter += 1 + _lgr.yield_text('waiting' + dots) + _wait_timer.start() + yield(_wait_timer, 'timeout') + dots += '.' + if(dots.length() > 5): + dots = '' + + _lgr.end_yield() + +# ------------------------------------------------------------------------------ +# returns self so it can be integrated into the yield call. +# ------------------------------------------------------------------------------ +func _wait_for_continue_button(): + p(PAUSE_MESSAGE, 0) + _waiting = true + return self + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _call_deprecated_script_method(script, method, alt): + if(script.has_method(method)): + var txt = str(script, '-', method) + if(!_deprecated_tracker.has(txt)): + # Removing the deprecated line. I think it's still too early to + # start bothering people with this. Left everything here though + # because I don't want to remember how I did this last time. + _lgr.deprecated(str('The method ', method, ' has been deprecated, use ', alt, ' instead.')) + _deprecated_tracker.add(txt) + script.call(method) + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _get_indexes_matching_script_name(name): + var indexes = [] # empty runs all + for i in range(_test_collector.scripts.size()): + if(_test_collector.scripts[i].get_filename().find(name) != -1): + indexes.append(i) + return indexes + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _get_indexes_matching_path(path): + var indexes = [] + for i in range(_test_collector.scripts.size()): + if(_test_collector.scripts[i].path == path): + indexes.append(i) + return indexes + +# ------------------------------------------------------------------------------ +# Execute all calls of a parameterized test. +# ------------------------------------------------------------------------------ +func _run_parameterized_test(test_script, test_name): + var script_result = _run_test(test_script, test_name) + if(_current_test.assert_count == 0 and !_current_test.pending): + _lgr.warn('Test did not assert') + + if(_is_function_state(script_result)): + # _run_tests does _wait_for_done so just wait on it to complete + yield(script_result, COMPLETED) + + if(_parameter_handler == null): + _lgr.error(str('Parameterized test ', _current_test.name, ' did not call use_parameters for the default value of the parameter.')) + _fail(str('Parameterized test ', _current_test.name, ' did not call use_parameters for the default value of the parameter.')) + else: + while(!_parameter_handler.is_done()): + var cur_assert_count = _current_test.assert_count + script_result = _run_test(test_script, test_name) + if(_is_function_state(script_result)): + # _run_tests does _wait_for_done so just wait on it to complete + yield(script_result, COMPLETED) + + if(_current_test.assert_count == cur_assert_count and !_current_test.pending): + _lgr.warn('Test did not assert') + + + _parameter_handler = null + + +# ------------------------------------------------------------------------------ +# Runs a single test given a test.gd instance and the name of the test to run. +# ------------------------------------------------------------------------------ +func _run_test(script_inst, test_name): + _lgr.log_test_name() + _lgr.set_indent_level(1) + _orphan_counter.add_counter('test') + var script_result = null + + _call_deprecated_script_method(script_inst, 'setup', 'before_each') + var before_each_result = script_inst.before_each() + if(_is_function_state(before_each_result)): + yield(_wait_for_done(before_each_result), COMPLETED) + + # When the script yields it will return a GDScriptFunctionState object + script_result = script_inst.call(test_name) + var test_summary = _new_summary.add_test(test_name) + + # Cannot detect future yields since we never tell the method to resume. If + # there was some way to tell the method to resume we could use what comes + # back from that to detect additional yields. I don't think this is + # possible since we only know what the yield was for except when yield_for + # and yield_to are used. + if(_is_function_state(script_result)): + yield(_wait_for_done(script_result), COMPLETED) + + # if the test called pause_before_teardown then yield until + # the continue button is pressed. + if(_pause_before_teardown and !_ignore_pause_before_teardown): + _gui.pause() + yield(_wait_for_continue_button(), SIGNAL_STOP_YIELD_BEFORE_TEARDOWN) + + script_inst.clear_signal_watcher() + + # call each post-each-test method until teardown is removed. + _call_deprecated_script_method(script_inst, 'teardown', 'after_each') + var after_each_result = script_inst.after_each() + if(_is_function_state(after_each_result)): + yield(_wait_for_done(after_each_result), COMPLETED) + + # Free up everything in the _autofree. Yield for a bit if we + # have anything with a queue_free so that they have time to + # free and are not found by the orphan counter. + var aqf_count = _autofree.get_queue_free_count() + _autofree.free_all() + if(aqf_count > 0): + yield(_do_yield_between(), 'timeout') + + test_summary.orphans = _orphan_counter.get_counter('test') + if(_log_level > 0): + _orphan_counter.print_orphans('test', _lgr) + + _doubler.get_ignored_methods().clear() + +# ------------------------------------------------------------------------------ +# Calls after_all on the passed in test script and takes care of settings so all +# logger output appears indented and with a proper heading +# +# Calls both pre-all-tests methods until prerun_setup is removed +# ------------------------------------------------------------------------------ +func _call_before_all(test_script): + _current_test = _before_all_test_obj + _current_test.has_printed_name = false + _lgr.inc_indent() + + # Next 3 lines can be removed when prerun_setup removed. + _current_test.name = 'prerun_setup' + _call_deprecated_script_method(test_script, 'prerun_setup', 'before_all') + _current_test.name = 'before_all' + + var result = test_script.before_all() + if(_is_function_state(result)): + yield(_wait_for_done(result), COMPLETED) + + _lgr.dec_indent() + _current_test = null + +# ------------------------------------------------------------------------------ +# Calls after_all on the passed in test script and takes care of settings so all +# logger output appears indented and with a proper heading +# +# Calls both post-all-tests methods until postrun_teardown is removed. +# ------------------------------------------------------------------------------ +func _call_after_all(test_script): + _current_test = _after_all_test_obj + _current_test.has_printed_name = false + _lgr.inc_indent() + + # Next 3 lines can be removed when postrun_teardown removed. + _current_test.name = 'postrun_teardown' + _call_deprecated_script_method(test_script, 'postrun_teardown', 'after_all') + _current_test.name = 'after_all' + + var result = test_script.after_all() + if(_is_function_state(result)): + yield(_wait_for_done(result), COMPLETED) + + + _lgr.dec_indent() + _current_test = null + +# ------------------------------------------------------------------------------ +# Run all tests in a script. This is the core logic for running tests. +# ------------------------------------------------------------------------------ +func _test_the_scripts(indexes=[]): + _orphan_counter.add_counter('total') + + _print_versions(false) + var is_valid = _init_run() + if(!is_valid): + _lgr.error('Something went wrong and the run was aborted.') + return + + _run_hook_script(_pre_run_script_instance) + if(_pre_run_script_instance!= null and _pre_run_script_instance.should_abort()): + _lgr.error('pre-run abort') + emit_signal(SIGNAL_TESTS_FINISHED) + return + + _gui.run_mode() + + var indexes_to_run = [] + if(indexes.size()==0): + for i in range(_test_collector.scripts.size()): + indexes_to_run.append(i) + else: + indexes_to_run = indexes + + _gui.set_progress_script_max(indexes_to_run.size()) # New way + _gui.set_progress_script_value(0) + + if(_doubler.get_strategy() == _utils.DOUBLE_STRATEGY.FULL): + _lgr.info("Using Double Strategy FULL as default strategy. Keep an eye out for weirdness, this is still experimental.") + + # loop through scripts + for test_indexes in range(indexes_to_run.size()): + var the_script = _test_collector.scripts[indexes_to_run[test_indexes]] + _orphan_counter.add_counter('script') + + if(the_script.tests.size() > 0): + _gui.set_script_path(the_script.get_full_name()) + _lgr.set_indent_level(0) + _print_script_heading(the_script) + _new_summary.add_script(the_script.get_full_name()) + + var test_script = the_script.get_new() + var script_result = null + _setup_script(test_script) + _doubler.set_strategy(_double_strategy) + + # yield between test scripts so things paint + if(_yield_between.should): + yield(_do_yield_between(), 'timeout') + + # !!! + # Hack so there isn't another indent to this monster of a method. if + # inner class is set and we do not have a match then empty the tests + # for the current test. + # !!! + if(!_does_class_name_match(_inner_class_name, the_script.inner_class_name)): + the_script.tests = [] + else: + var before_all_result = _call_before_all(test_script) + if(_is_function_state(before_all_result)): + # _call_before_all calls _wait for done, just wait for that to finish + yield(before_all_result, COMPLETED) + + + _gui.set_progress_test_max(the_script.tests.size()) # New way + + # Each test in the script + for i in range(the_script.tests.size()): + _stubber.clear() + _spy.clear() + _doubler.clear_output_directory() + _current_test = the_script.tests[i] + script_result = null + + if((_unit_test_name != '' and _current_test.name.find(_unit_test_name) > -1) or + (_unit_test_name == '')): + + # yield so things paint + if(_should_yield_now()): + yield(_do_yield_between(), 'timeout') + + if(_current_test.arg_count > 1): + _lgr.error(str('Parameterized test ', _current_test.name, + ' has too many parameters: ', _current_test.arg_count, '.')) + elif(_current_test.arg_count == 1): + script_result = _run_parameterized_test(test_script, _current_test.name) + else: + script_result = _run_test(test_script, _current_test.name) + + if(_is_function_state(script_result)): + # _run_test calls _wait for done, just wait for that to finish + yield(script_result, COMPLETED) + + if(_current_test.assert_count == 0 and !_current_test.pending): + _lgr.warn('Test did not assert') + _current_test.has_printed_name = false + _gui.set_progress_test_value(i + 1) + emit_signal('test_finished') + + + _current_test = null + _lgr.dec_indent() + _orphan_counter.print_orphans('script', _lgr) + + if(_does_class_name_match(_inner_class_name, the_script.inner_class_name)): + var after_all_result = _call_after_all(test_script) + if(_is_function_state(after_all_result)): + # _call_after_all calls _wait for done, just wait for that to finish + yield(after_all_result, COMPLETED) + + + _log_test_children_warning(test_script) + # This might end up being very resource intensive if the scripts + # don't clean up after themselves. Might have to consolidate output + # into some other structure and kill the script objects with + # test_script.free() instead of remove child. + _add_children_to.remove_child(test_script) + + _lgr.set_indent_level(0) + if(test_script.get_assert_count() > 0): + var script_sum = str(test_script.get_pass_count(), '/', test_script.get_assert_count(), ' passed.') + _lgr.log(script_sum, _lgr.fmts.bold) + + _gui.set_progress_script_value(test_indexes + 1) # new way + # END TEST SCRIPT LOOP + + _lgr.set_indent_level(0) + _end_run() + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _pass(text=''): + _gui.add_passing() # increments counters + if(_current_test): + _current_test.assert_count += 1 + _new_summary.add_pass(_current_test.name, text) + else: + if(_new_summary != null): # b/c of tests. + _new_summary.add_pass('script level', text) + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _fail(text=''): + _gui.add_failing() # increments counters + if(_current_test != null): + var line_text = ' at line ' + str(_extract_line_number(_current_test)) + p(line_text, LOG_LEVEL_FAIL_ONLY) + # format for summary + line_text = "\n " + line_text + var call_count_text = '' + if(_parameter_handler != null): + call_count_text = str('(call #', _parameter_handler.get_call_count(), ') ') + _new_summary.add_fail(_current_test.name, call_count_text + text + line_text) + _current_test.passed = false + _current_test.assert_count += 1 + else: + if(_new_summary != null): # b/c of tests. + _new_summary.add_fail('script level', text) + + +# ------------------------------------------------------------------------------ +# Extracts the line number from curren stacktrace by matching the test case name +# ------------------------------------------------------------------------------ +func _extract_line_number(current_test): + var line_number = -1 + # if stack trace available than extraxt the test case line number + var stackTrace = get_stack() + if(stackTrace!=null): + for index in stackTrace.size(): + var line = stackTrace[index] + var function = line.get("function") + if function == current_test.name: + line_number = line.get("line") + return line_number + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func _pending(text=''): + if(_current_test): + _current_test.pending = true + _new_summary.add_pending(_current_test.name, text) + + +# ------------------------------------------------------------------------------ +# Gets all the files in a directory and all subdirectories if get_include_subdirectories +# is true. The files returned are all sorted by name. +# ------------------------------------------------------------------------------ +func _get_files(path, prefix, suffix): + var files = [] + var directories = [] + # ignore addons/gut per issue 294 + if(path == 'res://addons/gut'): + return []; + + var d = Directory.new() + d.open(path) + # true parameter tells list_dir_begin not to include "." and ".." directories. + d.list_dir_begin(true) + + # Traversing a directory is kinda odd. You have to start the process of listing + # the contents of a directory with list_dir_begin then use get_next until it + # returns an empty string. Then I guess you should end it. + var fs_item = d.get_next() + var full_path = '' + while(fs_item != ''): + full_path = path.plus_file(fs_item) + + #file_exists returns fasle for directories + if(d.file_exists(full_path)): + if(fs_item.begins_with(prefix) and fs_item.ends_with(suffix)): + files.append(full_path) + elif(get_include_subdirectories() and d.dir_exists(full_path)): + directories.append(full_path) + + fs_item = d.get_next() + d.list_dir_end() + + for dir in range(directories.size()): + var dir_files = _get_files(directories[dir], prefix, suffix) + for i in range(dir_files.size()): + files.append(dir_files[i]) + + files.sort() + return files + + +######################### +# +# public +# +######################### + +# ------------------------------------------------------------------------------ +# Conditionally prints the text to the console/results variable based on the +# current log level and what level is passed in. Whenever currently in a test, +# the text will be indented under the test. It can be further indented if +# desired. +# +# The first time output is generated when in a test, the test name will be +# printed. +# +# NOT_USED_ANYMORE was indent level. This was deprecated in 7.0.0. +# ------------------------------------------------------------------------------ +func p(text, level=0, NOT_USED_ANYMORE=-123): + if(NOT_USED_ANYMORE != -123): + _lgr.deprecated('gut.p no longer supports the optional 3rd parameter for indent_level parameter.') + var str_text = str(text) + + if(level <= _utils.nvl(_log_level, 0)): + _lgr.log(str_text) + +################ +# +# RUN TESTS/ADD SCRIPTS +# +################ +func get_minimum_size(): + return Vector2(810, 380) + + +# ------------------------------------------------------------------------------ +# Runs all the scripts that were added using add_script +# ------------------------------------------------------------------------------ +func test_scripts(run_rest=false): + clear_text() + + if(_script_name != null and _script_name != ''): + var indexes = _get_indexes_matching_script_name(_script_name) + if(indexes == []): + _lgr.error('Could not find script matching ' + _script_name) + else: + _test_the_scripts(indexes) + else: + _test_the_scripts([]) + +# alias +func run_tests(run_rest=false): + test_scripts(run_rest) + + +# ------------------------------------------------------------------------------ +# Runs a single script passed in. +# ------------------------------------------------------------------------------ +func test_script(script): + _test_collector.set_test_class_prefix(_inner_class_prefix) + _test_collector.clear() + _test_collector.add_script(script) + _test_the_scripts() + + +# ------------------------------------------------------------------------------ +# Adds a script to be run when test_scripts called. +# ------------------------------------------------------------------------------ +func add_script(script): + if(!Engine.is_editor_hint()): + _test_collector.set_test_class_prefix(_inner_class_prefix) + _test_collector.add_script(script) + _add_scripts_to_gui() + + +# ------------------------------------------------------------------------------ +# Add all scripts in the specified directory that start with the prefix and end +# with the suffix. Does not look in sub directories. Can be called multiple +# times. +# ------------------------------------------------------------------------------ +func add_directory(path, prefix=_file_prefix, suffix=_file_extension): + # check for '' b/c the calls to addin the exported directories 1-6 will pass + # '' if the field has not been populated. This will cause res:// to be + # processed which will include all files if include_subdirectories is true. + if(path == '' or path == null): + return + + var d = Directory.new() + if(!d.dir_exists(path)): + _lgr.error(str('The path [', path, '] does not exist.')) + OS.exit_code = 1 + else: + var files = _get_files(path, prefix, suffix) + for i in range(files.size()): + add_script(files[i]) + + +# ------------------------------------------------------------------------------ +# This will try to find a script in the list of scripts to test that contains +# the specified script name. It does not have to be a full match. It will +# select the first matching occurrence so that this script will run when run_tests +# is called. Works the same as the select_this_one option of add_script. +# +# returns whether it found a match or not +# ------------------------------------------------------------------------------ +func select_script(script_name): + _script_name = script_name + _select_script = script_name + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func export_tests(path=_export_path): + if(path == null): + _lgr.error('You must pass a path or set the export_path before calling export_tests') + else: + var result = _test_collector.export_tests(path) + if(result): + p(_test_collector.to_s()) + p("Exported to " + path) + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func import_tests(path=_export_path): + if(!_utils.file_exists(path)): + _lgr.error(str('Cannot import tests: the path [', path, '] does not exist.')) + else: + _test_collector.clear() + var result = _test_collector.import_tests(path) + if(result): + p(_test_collector.to_s()) + p("Imported from " + path) + _add_scripts_to_gui() + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func import_tests_if_none_found(): + if(!_cancel_import and _test_collector.scripts.size() == 0): + import_tests() + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func export_if_tests_found(): + if(_test_collector.scripts.size() > 0): + export_tests() + +################ +# +# MISC +# +################ + + +# ------------------------------------------------------------------------------ +# Maximize test runner window to fit the viewport. +# ------------------------------------------------------------------------------ +func set_should_maximize(should): + _should_maximize = should + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_should_maximize(): + return _should_maximize + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func maximize(): + _gui.maximize() + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func disable_strict_datatype_checks(should): + _disable_strict_datatype_checks = should + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func is_strict_datatype_checks_disabled(): + return _disable_strict_datatype_checks + +# ------------------------------------------------------------------------------ +# Pauses the test and waits for you to press a confirmation button. Useful when +# you want to watch a test play out onscreen or inspect results. +# ------------------------------------------------------------------------------ +func end_yielded_test(): + _lgr.deprecated('end_yielded_test is no longer necessary, you can remove it.') + +# ------------------------------------------------------------------------------ +# Clears the text of the text box. This resets all counters. +# ------------------------------------------------------------------------------ +func clear_text(): + _gui.clear_text() + update() + +# ------------------------------------------------------------------------------ +# Get the number of tests that were ran +# ------------------------------------------------------------------------------ +func get_test_count(): + return _new_summary.get_totals().tests + +# ------------------------------------------------------------------------------ +# Get the number of assertions that were made +# ------------------------------------------------------------------------------ +func get_assert_count(): + var t = _new_summary.get_totals() + return t.passing + t.failing + +# ------------------------------------------------------------------------------ +# Get the number of assertions that passed +# ------------------------------------------------------------------------------ +func get_pass_count(): + return _new_summary.get_totals().passing + +# ------------------------------------------------------------------------------ +# Get the number of assertions that failed +# ------------------------------------------------------------------------------ +func get_fail_count(): + return _new_summary.get_totals().failing + +# ------------------------------------------------------------------------------ +# Get the number of tests flagged as pending +# ------------------------------------------------------------------------------ +func get_pending_count(): + return _new_summary.get_totals().pending + +# ------------------------------------------------------------------------------ +# Get the results of all tests ran as text. This string is the same as is +# displayed in the text box, and similar to what is printed to the console. +# ------------------------------------------------------------------------------ +func get_result_text(): + return _log_text + +# ------------------------------------------------------------------------------ +# Set the log level. Use one of the various LOG_LEVEL_* constants. +# ------------------------------------------------------------------------------ +func set_log_level(level): + _log_level = max(level, 0) + + # Level 0 settings + _lgr.set_less_test_names(level == 0) + # Explicitly always enabled + _lgr.set_type_enabled(_lgr.types.normal, true) + _lgr.set_type_enabled(_lgr.types.error, true) + _lgr.set_type_enabled(_lgr.types.pending, true) + + # Level 1 types + _lgr.set_type_enabled(_lgr.types.warn, level > 0) + _lgr.set_type_enabled(_lgr.types.deprecated, level > 0) + + # Level 2 types + _lgr.set_type_enabled(_lgr.types.passed, level > 1) + _lgr.set_type_enabled(_lgr.types.info, level > 1) + _lgr.set_type_enabled(_lgr.types.debug, level > 1) + + if(!Engine.is_editor_hint()): + _gui.set_log_level(level) + +# ------------------------------------------------------------------------------ +# Get the current log level. +# ------------------------------------------------------------------------------ +func get_log_level(): + return _log_level + +# ------------------------------------------------------------------------------ +# Call this method to make the test pause before teardown so that you can inspect +# anything that you have rendered to the screen. +# ------------------------------------------------------------------------------ +func pause_before_teardown(): + _pause_before_teardown = true; + +# ------------------------------------------------------------------------------ +# For batch processing purposes, you may want to ignore any calls to +# pause_before_teardown that you forgot to remove. +# ------------------------------------------------------------------------------ +func set_ignore_pause_before_teardown(should_ignore): + _ignore_pause_before_teardown = should_ignore + _gui.set_ignore_pause(should_ignore) + +func get_ignore_pause_before_teardown(): + return _ignore_pause_before_teardown + +# ------------------------------------------------------------------------------ +# Set to true so that painting of the screen will occur between tests. Allows you +# to see the output as tests occur. Especially useful with long running tests that +# make it appear as though it has humg. +# +# NOTE: not compatible with 1.0 so this is disabled by default. This will +# change in future releases. +# ------------------------------------------------------------------------------ +func set_yield_between_tests(should): + _yield_between.should = should + +func get_yield_between_tests(): + return _yield_between.should + +# ------------------------------------------------------------------------------ +# Call _process or _fixed_process, if they exist, on obj and all it's children +# and their children and so and so forth. Delta will be passed through to all +# the _process or _fixed_process methods. +# ------------------------------------------------------------------------------ +func simulate(obj, times, delta): + for _i in range(times): + if(obj.has_method("_process")): + obj._process(delta) + if(obj.has_method("_physics_process")): + obj._physics_process(delta) + + for kid in obj.get_children(): + simulate(kid, 1, delta) + +# ------------------------------------------------------------------------------ +# Starts an internal timer with a timeout of the passed in time. A 'timeout' +# signal will be sent when the timer ends. Returns itself so that it can be +# used in a call to yield...cutting down on lines of code. +# +# Example, yield to the Gut object for 10 seconds: +# yield(gut.set_yield_time(10), 'timeout') +# ------------------------------------------------------------------------------ +func set_yield_time(time, text=''): + _yield_timer.set_wait_time(time) + _yield_timer.start() + var msg = '-- Yielding (' + str(time) + 's)' + if(text == ''): + msg += ' --' + else: + msg += ': ' + text + ' --' + _lgr.log(msg, _lgr.fmts.yellow) + _was_yield_method_called = true + return self + +# ------------------------------------------------------------------------------ +# Sets a counter that is decremented each time _process is called. When the +# counter reaches 0 the 'timeout' signal is emitted. +# +# This actually results in waiting N+1 frames since that appears to be what is +# required for _process in test.gd scripts to count N frames. +# ------------------------------------------------------------------------------ +func set_yield_frames(frames, text=''): + var msg = '-- Yielding (' + str(frames) + ' frames)' + if(text == ''): + msg += ' --' + else: + msg += ': ' + text + ' --' + _lgr.log(msg, _lgr.fmts.yellow) + + _was_yield_method_called = true + _yield_frames = max(frames + 1, 1) + return self + +# ------------------------------------------------------------------------------ +# This method handles yielding to a signal from an object or a maximum +# number of seconds, whichever comes first. +# ------------------------------------------------------------------------------ +func set_yield_signal_or_time(obj, signal_name, max_wait, text=''): + obj.connect(signal_name, self, '_yielding_callback', [true]) + _yielding_to.obj = obj + _yielding_to.signal_name = signal_name + + _yield_timer.set_wait_time(max_wait) + _yield_timer.start() + _was_yield_method_called = true + _lgr.log(str('-- Yielding to signal "', signal_name, '" or for ', max_wait, ' seconds -- ', text), _lgr.fmts.yellow) + return self + +# ------------------------------------------------------------------------------ +# get the specific unit test that should be run +# ------------------------------------------------------------------------------ +func get_unit_test_name(): + return _unit_test_name + +# ------------------------------------------------------------------------------ +# set the specific unit test that should be run. +# ------------------------------------------------------------------------------ +func set_unit_test_name(test_name): + _unit_test_name = test_name + +# ------------------------------------------------------------------------------ +# Creates an empty file at the specified path +# ------------------------------------------------------------------------------ +func file_touch(path): + var f = File.new() + f.open(path, f.WRITE) + f.close() + +# ------------------------------------------------------------------------------ +# deletes the file at the specified path +# ------------------------------------------------------------------------------ +func file_delete(path): + var d = Directory.new() + var result = d.open(path.get_base_dir()) + if(result == OK): + d.remove(path) + +# ------------------------------------------------------------------------------ +# Checks to see if the passed in file has any data in it. +# ------------------------------------------------------------------------------ +func is_file_empty(path): + var f = File.new() + f.open(path, f.READ) + var empty = f.get_len() == 0 + f.close() + return empty + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_file_as_text(path): + return _utils.get_file_as_text(path) + +# ------------------------------------------------------------------------------ +# deletes all files in a given directory +# ------------------------------------------------------------------------------ +func directory_delete_files(path): + var d = Directory.new() + var result = d.open(path) + + # SHORTCIRCUIT + if(result != OK): + return + + # Traversing a directory is kinda odd. You have to start the process of listing + # the contents of a directory with list_dir_begin then use get_next until it + # returns an empty string. Then I guess you should end it. + d.list_dir_begin() + var thing = d.get_next() # could be a dir or a file or something else maybe? + var full_path = '' + while(thing != ''): + full_path = path + "/" + thing + #file_exists returns fasle for directories + if(d.file_exists(full_path)): + d.remove(full_path) + thing = d.get_next() + d.list_dir_end() + +# ------------------------------------------------------------------------------ +# Returns the instantiated script object that is currently being run. +# ------------------------------------------------------------------------------ +func get_current_script_object(): + var to_return = null + if(_test_script_objects.size() > 0): + to_return = _test_script_objects[-1] + return to_return + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_current_test_object(): + return _current_test + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_stubber(): + return _stubber + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_doubler(): + return _doubler + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_spy(): + return _spy + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_temp_directory(): + return _temp_directory + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_temp_directory(temp_directory): + _temp_directory = temp_directory + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_inner_class_name(): + return _inner_class_name + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_inner_class_name(inner_class_name): + _inner_class_name = inner_class_name + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_summary(): + return _new_summary + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_double_strategy(): + return _double_strategy + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_double_strategy(double_strategy): + _double_strategy = double_strategy + _doubler.set_strategy(double_strategy) + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_include_subdirectories(): + return _include_subdirectories + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_logger(): + return _lgr + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_logger(logger): + _lgr = logger + _lgr.set_gut(self) + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_include_subdirectories(include_subdirectories): + _include_subdirectories = include_subdirectories + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_test_collector(): + return _test_collector + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_export_path(): + return _export_path + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_export_path(export_path): + _export_path = export_path + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_version(): + return _utils.version + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_pre_run_script(): + return _pre_run_script + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_pre_run_script(pre_run_script): + _pre_run_script = pre_run_script + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_post_run_script(): + return _post_run_script + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_post_run_script(post_run_script): + _post_run_script = post_run_script + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_pre_run_script_instance(): + return _pre_run_script_instance + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_post_run_script_instance(): + return _post_run_script_instance + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_color_output(): + return _color_output + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_color_output(color_output): + _color_output = color_output + _lgr.disable_formatting(!color_output) + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_parameter_handler(): + return _parameter_handler + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_parameter_handler(parameter_handler): + _parameter_handler = parameter_handler + _parameter_handler.set_logger(_lgr) + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_gui(): + return _gui + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_orphan_counter(): + return _orphan_counter + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func show_orphans(should): + _lgr.set_type_enabled(_lgr.types.orphan, should) + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_autofree(): + return _autofree + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_junit_xml_file(): + return _junit_xml_file + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_junit_xml_file(junit_xml_file): + _junit_xml_file = junit_xml_file + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_junit_xml_timestamp(): + return _junit_xml_timestamp + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_junit_xml_timestamp(junit_xml_timestamp): + _junit_xml_timestamp = junit_xml_timestamp + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func get_add_children_to(): + return _add_children_to + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +func set_add_children_to(add_children_to): + _add_children_to = add_children_to |