GUT

https://gut.readthedocs.io/en/latest/
Admin
GUT (Godot Unit Test) is a utility for writing tests for your Godot Engine game, allowing you to...
Tokens:57,157
Snippets:698
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Implementing a Global Pre-Run Hook

Source: https://gut.readthedocs.io/en/latest/Global-Lifecycle-Hooks.html

Example of a GutHookScript that connects a custom function to the start_test signal to run setup logic before every test.

```gdscript
extends GutHookScript

func run():
    gut.start_test.connect(_on_test_started)

func _on_test_started(test_name):
    # setup logic run before every test in every test script goes here
```

--------------------------------

### GUT CLI List Option Syntax

Source: https://gut.readthedocs.io/en/latest/_sources/Command-Line.md.txt

Examples of how to provide multiple values for list-based options.

```text
-gdir=a,b
-gdir c,d
-gdir e
# results in -gdir equaling [a, b, c, d, e]
```

--------------------------------

### GUT CLI Usage and Configuration

Source: https://gut.readthedocs.io/en/latest/Command-Line.html

Basic command-line usage pattern and examples for specifying list-based options.

```text
The GUT CLI
-----------
The default behavior for GUT is to load options from a res://.gutconfig.json if
it exists.  Any options specified on the command line will take precedence over
options specified in the gutconfig file.  You can specify a different gutconfig
file with the -gconfig option.

To generate a .gutconfig.json file you can use -gprint_gutconfig_sample
To see the effective values of a CLI command and a gutconfig use -gpo

Values for options can be supplied using:
    option=value    # no space around "="
    option value    # a space between option and value w/o =

Options whose values are lists/arrays can be specified multiple times:
	-gdir=a,b
	-gdir c,d
	-gdir e
	# results in -gdir equaling [a, b, c, d, e]

To not use an empty value instead of a default value, specifiy the option with
an immediate "=":
	-gconfig=
```

```text
Usage
-----------
  <path to godot> -s addons/gut/gut_cmdln.gd [opts]
```

--------------------------------

### Vararg method signature example

Source: https://gut.readthedocs.io/en/latest/_sources/Doubles.md.txt

Example of a vararg method signature as encountered by GUT.

```gdscript
Error rpc_id ( int peer_id, StringName method, ... ) vararg
```

--------------------------------

### Example of named_parameters output

Source: https://gut.readthedocs.io/en/latest/class_ref/class_addons_gut_parameter_factory.html

Shows the expected output structure when calling the named_parameters method.

```gdscript
create_named_parameters(['a', 'b'], [[1, 2], ['one', 'two']]) returns
   [{a:1, b:2}, {a:'one', b:'two'}]
```

--------------------------------

### Create a basic test script

Source: https://gut.readthedocs.io/en/latest/Creating-Tests.html

A template for a test script extending GutTest with lifecycle hooks and assertion examples.

```gdscript
extends GutTest
func before_each():
	gut.p("ran setup", 2)

func after_each():
	gut.p("ran teardown", 2)

func before_all():
	gut.p("ran run setup", 2)

func after_all():
	gut.p("ran run teardown", 2)

func test_assert_eq_number_not_equal():
	assert_eq(1, 2, "Should fail.  1 != 2")

func test_assert_eq_number_equal():
	assert_eq('asdf', 'asdf', "Should pass")

func test_assert_true_with_true():
	assert_true(true, "Should pass, true is true")

func test_assert_true_with_false():
	assert_true(false, "Should fail")

func test_something_else():
	assert_true(false, "didn't work")
```

--------------------------------

### Example of a vararg method signature

Source: https://gut.readthedocs.io/en/latest/Stubbing.html

The signature for Node.rpc_id which includes variable arguments.

```gdscript
Variant rpc_id(peer_id: int, method: String, ...) vararg
```

--------------------------------

### Demonstrate Orphan Creation

Source: https://gut.readthedocs.io/en/latest/Memory-Management.html

An example of a test that creates a node without freeing it, resulting in an orphan.

```GDScript
func test_something():
  var my_node = Node.new()
  assert_not_null(my_node)
```

--------------------------------

### Implement lifecycle methods and test cases

Source: https://gut.readthedocs.io/en/latest/Quick-Start.html

Define setup and teardown methods using specific lifecycle hooks and create test methods prefixed with 'test_'.

```GDScript
extends GutTest

func before_all():
	gut.p("Runs once before all tests")

func before_each():
	gut.p("Runs before each test.")

func after_each():
	gut.p("Runs after each test.")

func after_all():
	gut.p("Runs once after all tests")

func test_assert_eq_number_not_equal():
	assert_eq(1, 2, "Should fail.  1 != 2")

func test_assert_eq_number_equal():
	assert_eq('asdf', 'asdf', "Should pass")
```

--------------------------------

### Example of a class with default parameters

Source: https://gut.readthedocs.io/en/latest/Stubbing.html

A sample class where the increment method uses a default parameter value.

```gdscript
# res://foo.gd
var _sum  = 0
func increment(inc_by=1):
  _sum += inc_by

func go_up_one():
  increment()

func get_sum():
  return _sum
```

--------------------------------

### gut.get_pre_run_script_instance()

Source: https://gut.readthedocs.io/en/latest/Hooks.html

Retrieves the instance of the pre-run script, allowing access to global variables or setup state from within the post-run hook.

```APIDOC
## gut.get_pre_run_script_instance()

### Description
Returns the instance of the pre-run script. This is primarily used in the post-run hook to access state or variables initialized before tests were executed.
```

--------------------------------

### Define test method naming

Source: https://gut.readthedocs.io/en/latest/Creating-Tests.html

Test methods must start with the 'test_' prefix and accept no parameters.

```gdscript
func test_this_is_only_a_test():
```

--------------------------------

### Vararg method signature generation

Source: https://gut.readthedocs.io/en/latest/Doubles.html

Example of how GUT generates default null arguments for methods with varargs.

```text
Error rpc_id ( int peer_id, StringName method, ... ) vararg
```

```gdscript
func rpc_id (peer_id, method, arg1=null, arg2=null, arg3=null, arg4=null, arg5=null, arg6=null, arg7=null, arg8=null, arg9=null, arg10=null)
```

--------------------------------

### Usage of wait_until

Source: https://gut.readthedocs.io/en/latest/Awaiting.html

Examples of using wait_until to poll a predicate until it returns true or a timeout occurs.

```GDScript
var everything_is_ok = func():
	return true

# Call everything_is_ok every frame until it returns true or 5 seconds elapses
await wait_until(everything_is_ok, 5)

# Same as above but we get the result to use later and provide a message to
# display when the await starts.
var result = await wait_until(everything_is_ok, 5, 'Show this message')

# Calls everything_is_ok every second until it returns true and asserts
# on the returned value
assert_true(await wait_until(everything_is_ok, 10, 1),
	"Everything should be ok in 10 seconds").
```

--------------------------------

### Common command-line error output

Source: https://gut.readthedocs.io/en/latest/Command-Line.html

Example error message displayed when command-line arguments are malformed, such as missing an equals sign.

```text
ERROR:  No loader found for resource: res://samples3
At:  core\io\resource_loader.cpp:209
ERROR:  Failed loading scene: res://samples3
At:  main\main.cpp:1260
```

--------------------------------

### simulate(obj, times, delta, check_is_processing: bool = false)

Source: https://gut.readthedocs.io/en/latest/Simulate.html

The simulate method calls _process and _physics_process on a tree of objects. It recursively traverses the tree starting from the provided object, executing these methods if they exist.

```APIDOC
## simulate(obj, times, delta, check_is_processing: bool = false)

### Description
Triggers the `_process` and `_physics_process` methods on a tree of objects. This is useful for testing logic that relies on frame-based updates without running the full game loop.

### Parameters
- **obj** (Object) - Required - The base object to start the simulation from.
- **times** (int) - Required - The number of times to call the methods.
- **delta** (float) - Required - The delta value to pass to the `_process` or `_physics_process` methods.
- **check_is_processing** (bool) - Optional - If true, GUT will check `is_processing` and `is_physics_processing` on each object and only call the methods if the object is currently processing.
```

--------------------------------

### Verify file existence with assert_file_exists

Source: https://gut.readthedocs.io/en/latest/class_ref/class_guttest.html

Asserts that a file exists at the provided path. Requires proper setup and teardown of test files.

```GDScript
func before_each():
    gut.file_touch('user://some_test_file')

func after_each():
    gut.file_delete('user://some_test_file')

func test_assert_file_exists():
    # Passing
    assert_file_exists('res://addons/gut/gut.gd')
    assert_file_exists('user://some_test_file')

    # Failing
    assert_file_exists('user://file_does_not.exist')
    assert_file_exists('res://some_dir/another_dir/file_does_not.exist')
```

--------------------------------

### Example of Orphaned Object Warning

Source: https://gut.readthedocs.io/en/latest/Memory-Management.html

Typical console output indicating objects were not freed at the end of a test run.

```text
WARNING: ObjectDB instances leaked at exit (run with --verbose for details).
     at: cleanup (core/object/object.cpp:2490)
ERROR: 24 resources still in use at exit (run with --verbose for details).
   at: clear (core/io/resource.cpp:789)
```

--------------------------------

### Define lifecycle hooks

Source: https://gut.readthedocs.io/en/latest/Creating-Tests.html

Methods for setup and teardown logic executed at different stages of the test lifecycle.

```gdscript
before_each():
after_each():
before_all():
after_all():
```

--------------------------------

### Example of Orphaned Nodes in Test Output

Source: https://gut.readthedocs.io/en/latest/Memory-Management.html

Detailed report format showing specific nodes that were not freed during a test.

```text
* test_this_makes_two_orphans
    2 Orphans
        * test_two_one:<Node#59944994582>
        * test_two_two:<Node#59961771799>
* test_with_a_scene_orphan
    104 Orphans
        * main:<Node2D#60045657884>(main.gd) + 27
        * GutRunner:<Node2D#60565751588>(GutRunner.gd) + 75
```

--------------------------------

### Connect to Gut signals in _post_ready_setup

Source: https://gut.readthedocs.io/en/latest/_sources/Running-On-Devices.md.txt

Connect to Gut signals after the _ready method to ensure the Gut instance is available.

```GDScript
func _post_ready_setup():
	var gut = _gut_control.get_gut()
	gut.start_run.connect(_on_gut_run_start)

	gut.start_script.connect(_on_gut_start_script)
	gut.end_script.connect(_on_gut_end_script)

	gut.start_test.connect(_on_gut_start_test)
	gut.end_test.connect(_on_gut_end_test)

	gut.end_run.connect(_on_gut_run_end)
```

--------------------------------

### get_help()

Source: https://gut.readthedocs.io/en/latest/class_ref/class_addons_gut_cli_optparse.html

Returns the help text for all defined command-line options.

```APIDOC
## String get_help()

### Description
Returns the help text for all defined options.

### Returns
- **String** - The formatted help text.
```

--------------------------------

### Configuring Help Headings

Source: https://gut.readthedocs.io/en/latest/class_ref/class_addons_gut_cli_optparse.html

Organize help output by adding headings between option definitions.

```GDScript
  add("--asdf", 1, "This will have no heading")
  add_heading("foo")
  add("--foo", false, "This will have the foo heading")
  add("--another_foo", 1.5, "This too.")
  add_heading("This is after foo")
  add("--bar", true, "You probably get it by now.")
```

--------------------------------

### print_help()

Source: https://gut.readthedocs.io/en/latest/class_ref/class_addons_gut_cli_optparse.html

Prints the help text for all defined options to the console.

```APIDOC
## void print_help()

### Description
Prints out the help text for all defined options.
```

--------------------------------

### Use wait_seconds in tests

Source: https://gut.readthedocs.io/en/latest/Awaiting.html

Examples of pausing test execution for a specified duration with optional logging.

```GDScript
# wait 2.8 seconds then continue running the test
await wait_seconds(2.8)

# wait .25 seconds, text included in log message
await wait_seconds(.25, "waiting for a short period")
```

--------------------------------

### GUT configuration file format

Source: https://gut.readthedocs.io/en/latest/Command-Line.html

A sample JSON configuration file used to define default GUT execution parameters.

```json
{
  "dirs":["res://test/unit/","res://test/integration/"],
  "double_strategy":"partial",
  "ignore_pause":false,
  "include_subdirs":true,
  "inner_class":"",
  "log_level":3,
  "opacity":100,
  "prefix":"test_",
  "selected":"",
  "should_exit":true,
  "should_maximize":true,
  "suffix":".gd",
  "tests":[],
  "unit_test_name":"",
}
```

--------------------------------

### Double an Engine Singleton

Source: https://gut.readthedocs.io/en/latest/class_ref/class_guttest.html

Demonstrates how to create a pseudo-double of an Engine Singleton and inject it into a class instance.

```gdscript
class_name UsesTime
var t := Time
```

```gdscript
extends GutTest
func test_something():
    var dbl_time = partial_double_singleton(Time).new()
    var inst = UsesTime.new()
    inst.t = dbl_time
```

--------------------------------

### run()

Source: https://gut.readthedocs.io/en/latest/class_ref/class_guthookscript.html

A virtual method that must be implemented by the user. This is the entry point where custom logic is executed by GUT after the script is instantiated.

```APIDOC
## void run()

### Description
Virtual method that will be called by GUT after instantiating this script. This is where you put all of your logic.
```

--------------------------------

### Chaining Input Events

Source: https://gut.readthedocs.io/en/latest/Mocking-Input.html

Demonstrates how to chain multiple input calls to create a sequence that executes immediately.

```GDScript
var player = Player.new()
var sender = InputSender.new(player)

# press a, then b, then release a, then release b
sender.key_down("a").wait(.1)\
    .key_down(KEY_B).wait(.1)\
    .key_up("a").wait(.1)\
    .key_up(KEY_B)
await(sender.idle)
```

--------------------------------

### Generate Engine Errors

Source: https://gut.readthedocs.io/en/latest/Error-Tracking.html

Example functions that trigger Godot engine errors through invalid type assignments or operations.

```gdscript
func divide_recklessly(top, bottom):
	return top / bottom

func assign_a_to_string_and_b_to_int(a, b):
	var string_a : String = a
	var int_b : int = b

func test_demo_engine_type_error():
	assign_a_to_string_and_b_to_int(Object.new(), 'asdf')
	divide_recklessly('some words', Node)
```

--------------------------------

### Create a basic test script

Source: https://gut.readthedocs.io/en/latest/Quick-Start.html

Define a test class by extending GutTest and implementing methods prefixed with 'test_'. Use assertion methods like assert_eq to validate expected outcomes.

```gdscript
extends GutTest

func test_passes():
	# this test will pass because 1 does equal 1
	assert_eq(1, 1)

func test_fails():
	# this test will fail because those strings are not equal
	assert_eq('hello', 'goodbye')
```

--------------------------------

### GUT CLI Usage Pattern

Source: https://gut.readthedocs.io/en/latest/_sources/Command-Line.md.txt

The standard syntax for executing GUT tests via the Godot command line.

```text
<path to godot> -s addons/gut/gut_cmdln.gd [opts]
```

--------------------------------

### Assert String Prefix with assert_string_starts_with

Source: https://gut.readthedocs.io/en/latest/class_ref/class_guttest.html

Verifies that a string begins with a specific substring.

```GDScript
# Passing
assert_string_starts_with('abc 123', 'a')
assert_string_starts_with('abc 123', 'ABC', false)
assert_string_starts_with('abc 123', 'abc 123')

## Failing
assert_string_starts_with('abc 123', 'z')
assert_string_starts_with('abc 123', 'ABC')
assert_string_starts_with('abc 123', 'abc 1234')
```

--------------------------------

### add(op_names, default, desc)

Source: https://gut.readthedocs.io/en/latest/class_ref/class_addons_gut_cli_optparse.html

Registers a new command line option.

```APIDOC
## OptParseOption add(op_names, default, desc: String)

### Description
Adds a command line option. Returns the OptParseOption object on success, or null if a name collision occurs.

### Parameters
- **op_names** (String or Array) - The name or aliases for the option.
- **default** (Variant) - The default value if not provided during parsing.
- **desc** (String) - Human-readable description.
```

--------------------------------

### Static Method Parser Error

Source: https://gut.readthedocs.io/en/latest/Doubles.html

Example of the error message encountered when attempting to double a class containing static methods.

```text
Parser Error: Function signature doesn't match the parent. Parent signature is: 'Variant foo()'.
```

--------------------------------

### Mocking Input for the Global Input Singleton

Source: https://gut.readthedocs.io/en/latest/Mocking-Input.html

Demonstrates using the global Input singleton as a receiver. Requires calling release_all and clear in after_each to reset state and awaiting frames to ensure input processing.

```gdscript
var _sender = InputSender.new(Input)

func after_each():
    _sender.release_all()
    _sender.clear()

func test_shoot():
    var player = Player.new()

    _sender.action_down("shoot").wait_frames(1)
    await(_sender.idle)

    assert_true(player.is_shooting())
```

--------------------------------

### Defining Inner Test Classes in Gut

Source: https://gut.readthedocs.io/en/latest/Inner-Test-Classes.html

An example of a test script containing an inner class that extends GutTest with its own lifecycle methods.

```gdscript
extends GutTest

func before_all():
	gut.p('script:  pre-run')

func before_each():
	gut.p('script:  setup')

func after_each():
	gut.p('script:  teardown')

func after_all():
	gut.p('script:  post-run')

func test_something():
	assert_true(true)

class TestClass1:
	extends GutTest

	func before_all():
		gut.p('TestClass1:  pre-run')

	func before_each():
		gut.p('TestClass1:  setup')

	func after_each():
		gut.p('TestClass1:  teardown')

	func after_all():
		gut.p('TestClass1:  post-run')

	func test_context1_one():
		assert_true(true)

	func test_context1_two():
		pending()
```

--------------------------------

### Retrieve Full Summary Instance

Source: https://gut.readthedocs.io/en/latest/Hooks.html

Access the summary.gd instance containing all data regarding the test run.

```GDScript
# Returns GUT's summary.gd instance holding all the data about the run.
gut.get_summary()
```

--------------------------------

### Run GUT tests from command line

Source: https://gut.readthedocs.io/en/latest/Command-Line.html

Execute the GUT command line script from the project root using Godot's script execution flags.

```bash
godot -d -s --path "$PWD" addons/gut/gut_cmdln.gd
```

--------------------------------

### Retrieve Script Summary Objects

Source: https://gut.readthedocs.io/en/latest/Hooks.html

Get an array of Summary.gd.TestScript objects containing detailed information about each executed script or inner class.

```GDScript
# Returns and array of Summary.gd.TestScript objects that have detailed information
# about each script/inner class that was ran.  See summary.gd for more details.
gut.get_summary().get_scripts()
```

--------------------------------

### Retrieve GUT Summary Instance

Source: https://gut.readthedocs.io/en/latest/_sources/Hooks.md.txt

Access the summary.gd instance containing comprehensive data about the current test run.

```GDScript
gut.get_summary()
```

--------------------------------

### Retrieve Test Totals

Source: https://gut.readthedocs.io/en/latest/Hooks.html

Get a dictionary containing counts for passing, pending, failing tests, total tests, and total scripts.

```GDScript
# This will return a dictionary containing the following counts:
#   passing = 0,
#   pending = 0,
#   failing = 0,
#   tests = 0,
#   scripts = 0
gut.get_summary().get_totals()
```

--------------------------------

### Define property accessors in Godot 4

Source: https://gut.readthedocs.io/en/latest/New-For-Godot-4.html

Use the set and get syntax to define property accessors directly within the variable declaration.

```gdscript
var foo = 10:
    get():
        return foo
    set(val):
        foo = val
```

--------------------------------

### Configure Double Strategy via Command Line

Source: https://gut.readthedocs.io/en/latest/Double-Strategy.html

Use the -gdouble_strategy flag to set the strategy when running tests from the command line.

```bash
-gdouble_strategy='SCRIPT_ONLY'
```

--------------------------------

### Group tests with inner classes

Source: https://gut.readthedocs.io/en/latest/Creating-Tests.html

Use inner classes extending GutTest to organize related tests, ensuring class names start with 'Test'.

```gdscript
extends GutTest

class TestFeatureA:
	extends GutTest

	var Obj = load('res://scripts/object.gd')
	var _obj = null

	func before_each():
		_obj = Obj.new()

	func test_something():
		assert_true(_obj.is_something_cool(), 'Should be cool.')

class TestFeatureB:
	extends GutTest

	var Obj = load('res://scripts/object.gd')
	var _obj = null

	func before_each():
		_obj = Obj.new()

	func test_foobar():
		assert_eq(_obj.foo(), 'bar', 'Foo should return bar')
```

--------------------------------

### Testing with a Partial Double Singleton

Source: https://gut.readthedocs.io/en/latest/Doubling-Singletons.html

Create a partial double of an Engine Singleton and inject it into the target class for testing.

```gdscript
extends GutTest

func test_player_does_something_with_input():
    var dbl_input = partial_double_singleton(Input).new()
    var p = Player.new()
    p.my_local_input_singleton_ref = dbl_input

    stub(dbl_input.is_action_just_pressed)\
        .to_return(true)\
        .when_passed("jump")
    ...
```

--------------------------------

### JUnit XML Test Results Output

Source: https://gut.readthedocs.io/en/latest/Export-Test-Results.html

Example of the XML schema used for exported test results, including test suites, test cases, and failure/skipped status details.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<testsuites name="GutTests" failures="7" tests="17">
      <testsuite name="res://test/resources/exporter_test_files/test_simple_2.gd" tests="3" failures="1" skipped="1">
            <testcase name="test_pass" assertions="1" status="pass" classname="res://test/resources/exporter_test_files/test_simple_2.gd"></testcase>
            <testcase name="test_fail" assertions="1" status="fail" classname="res://test/resources/exporter_test_files/test_simple_2.gd">
                  <failure message="failed">Cannot compare Int[1] to String["two"].
            at line 7</failure>
            </testcase>
            <testcase name="test_pending" assertions="0" status="pending" classname="res://test/resources/exporter_test_files/test_simple_2.gd">
                  <skipped message="pending">this has text</skipped>
            </testcase>
      </testsuite>
      <testsuite name="res://test/resources/exporter_test_files/test_simple.gd" tests="8" failures="4" skipped="2">
            <testcase name="test_pending_with_text" assertions="0" status="pending" classname="res://test/resources/exporter_test_files/test_simple.gd">
                  <skipped message="pending">this has text</skipped>
            </testcase>
            <testcase name="test_parameterized_passing" assertions="4" status="pass" classname="res://test/resources/exporter_test_files/test_simple.gd"></testcase>
            <testcase name="test_parameterized_failing" assertions="2" status="fail" classname="res://test/resources/exporter_test_files/test_simple.gd">
                  <failure message="failed">(call #1) [1] expected to equal [2]:
            at line 25</failure>
            </testcase>
            <testcase name="test_fail_2" assertions="1" status="fail" classname="res://test/resources/exporter_test_files/test_simple.gd">
                  <failure message="failed">Cannot compare String["two"] to Int[2].
            at line 13</failure>
            </testcase>
            <testcase name="test_pending_no_text" assertions="0" status="pending" classname="res://test/resources/exporter_test_files/test_simple.gd">
                  <skipped message="pending"></skipped>
            </testcase>
            <testcase name="test_pass_1" assertions="1" status="pass" classname="res://test/resources/exporter_test_files/test_simple.gd"></testcase>
            <testcase name="test_pass_2" assertions="1" status="pass" classname="res://test/resources/exporter_test_files/test_simple.gd"></testcase>
            <testcase name="test_fail_1" assertions="1" status="fail" classname="res://test/resources/exporter_test_files/test_simple.gd">
                  <failure message="failed">Cannot compare Int[1] to String["two"].
            at line 10</failure>
            </testcase>
      </testsuite>
      <testsuite name="res://test/resources/exporter_test_files/test_with_inner_classes.gd" tests="0" failures="0" skipped="0"></testsuite>
      <testsuite name="res://test/resources/exporter_test_files/test_with_inner_classes.gd.TestClassOne" tests="3" failures="1" skipped="1">
            <testcase name="test_pending_with_text" assertions="0" status="pending" classname="res://test/resources/exporter_test_files/test_with_inner_classes.gd.TestClassOne">
                  <skipped message="pending">this has text</skipped>
            </testcase>
            <testcase name="test_fail_1" assertions="1" status="fail" classname="res://test/resources/exporter_test_files/test_with_inner_classes.gd.TestClassOne">
                  <failure message="failed">Cannot compare Int[1] to String["two"].
            at line 11</failure>
            </testcase>
            <testcase name="test_pass_1" assertions="1" status="pass" classname="res://test/resources/exporter_test_files/test_with_inner_classes.gd.TestClassOne"></testcase>
      </testsuite>
      <testsuite name="res://test/resources/exporter_test_files/test_with_inner_classes.gd.TestClassTwo" tests="3" failures="1" skipped="1">
            <testcase name="test_pending_with_text" assertions="0" status="pending" classname="res://test/resources/exporter_test_files/test_with_inner_classes.gd.TestClassTwo">
                  <skipped message="pending">this has text</skipped>
            </testcase>
            <testcase name="test_fail_1" assertions="1" status="fail" classname="res://test/resources/exporter_test_files/test_with_inner_classes.gd.TestClassTwo">
                  <failure message="failed">Cannot compare Int[1] to String["two"].
            at line 26</failure>
            </testcase>
            <testcase name="test_pass_1" assertions="1" status="pass" classname="res://test/resources/exporter_test_files/test_with_inner_classes.gd.TestClassTwo"></testcase>
      </testsuite>
</testsuites>
```

--------------------------------

### parse(cli_args = null)

Source: https://gut.readthedocs.io/en/latest/class_ref/class_addons_gut_cli_optparse.html

Parses command-line arguments for options defined in the optparse instance.

```APIDOC
## void parse(cli_args = null)

### Description
Parses a string for all options that have been set in this optparse. If `cli_args` is passed as a String, it is parsed; otherwise, arguments passed to the Godot engine at startup are parsed.

### Parameters
- **cli_args** (String) - Optional - The string of arguments to parse. If null, defaults to engine startup arguments.
```

--------------------------------

### action_up

Source: https://gut.readthedocs.io/en/latest/class_ref/class_gutinputfactory.html

Returns an InputEventAction instance for an action release.

```APIDOC
## InputEventAction action_up(which, strength = 1.0)

### Description
Returns an “action up” InputEventAction instance. `which` is the name of the action defined in the Key Map.
```

--------------------------------

### Testing Input with GutTest

Source: https://gut.readthedocs.io/en/latest/Mocking-Input.html

Provides a template for setting up InputSender at the class level and cleaning up state in after_each.

```GDScript
extends GutTest

# When sending events to Input the InputSender instance should be defined at
# the class level so that you can easily clear it between tests in after_each.
var _sender = InputSender.new(Input)

# IMPORTANT:  When using Input as the receiver of events you should always
#             release_all and clear the InputSender so that any
#             actions/keys/buttons that are not released in a test are released
#             before the next test runs.  "down" events will not be sent by
#             Input if the action/button/etc is currently "down".
func after_each():
    _sender.release_all()
    _sender.clear()


# In this test we press and hold the jump button for .1 seconds then wait
# another .3 seconds for the jump to take take place.  We then assert that
# the character has moved up between 4 and 5 pixels.
func test_tapping_jump_jumps_certain_height():
    var player = add_child_autofree(Player.new())

    _sender.action_down("jump").hold_for(.1).wait(.3)
    await(_sender.idle)

    assert_between(player.position.y, 4, 5)


# This is similar to the other test but we hold jump for longer and then
# verify the player jumped higher.
func test_holding_jump_jumps_higher():
    var player = add_child_autofree(Player.new())

    _sender.action_down("jump").hold_for(.75)
    await(_sender.idle)

    assert_between(player.position.y, 7, 8)


# This tests throwing a fireball, like with Ryu or Ken from Street Fighter.
# Note that there is not a hold_for after "forward" and the key_down for
# fierce punch (FP) immediately after.  This means the "forward" motion AND
# FP are pressed in the same frame.
func test_fireball_input():
    var player = add_child_autofree(Player.new())

    _sender.action_down("down").hold_for("2f")\
        .action_down("down_forward").hold_for("2f")\
        .action_down("forward").key_down("FP")
    await(_sender.idle)

    assert_true(player.is_throwing_fireball())


# In this example we are testing that two actions in combination cause the
# player to slide.  Note that there is no release of the actions in this
# test.  This is a good example of why using release_all in after_each makes
# the tests simpler to write and prevents leaking of inputs from one test to
# another.
func test_holding_down_and_jump_does_slide():
    var player = add_child_autofree(Player.new())

    _sender.action_down("down").wait("1f")\
        .action_down("jump").wait("2f")
    await(_sender.idle)

    assert_gt(player.velocity.x, 0)
```

--------------------------------

### Test class using doubled singletons

Source: https://gut.readthedocs.io/en/latest/Doubling-Singletons.html

Unit tests demonstrating how to use partial_double_singleton and double_singleton to stub methods and verify behavior.

```GDScript
extends GutTest

# Fun fact, this test will fail if ran on any Monday.  I wrote this on a
# Wednesday, so it passes.  This is a doozy of a flakey test.  Don't make
# tests
func test_calling_end_returns_elapsed_time_using_msecs():
	var dbl_time = partial_double_singleton(Time).new()
	var inst = UsesTime.new()
	inst.t = dbl_time

	stub(dbl_time.get_ticks_msec).to_return(0)
	inst.start()
	stub(dbl_time.get_ticks_msec).to_return(10)
	assert_eq(inst.end(), 10)


# Illustrate that enums are included in singleton doubles.
func test_on_mondays_elapsed_time_is_longer_because_time_moves_slower_on_mondays():
	var dbl_time = double_singleton(Time).new()
	var inst = UsesTime.new()

	inst.t = dbl_time
	stub(dbl_time.get_date_dict_from_system)\
		.to_return({
			"year": 2025,
			"month": 1,
			"day": 1,
			"weekday": Time.WEEKDAY_MONDAY})

	stub(dbl_time.get_ticks_msec).to_return(0)
	inst.start()
	stub(dbl_time.get_ticks_msec).to_return(10)
	assert_eq(inst.end(), 20)
```

--------------------------------

### Simulate method usage in GUT tests

Source: https://gut.readthedocs.io/en/latest/Simulate.html

Demonstrates how to use gut.simulate to trigger processing methods on objects and their children within a unit test.

```gdscript
# --------------------------------
# res://scripts/my_object.gd
# --------------------------------
extends Node2D
  var a_number = 1

  func _process(delta):
    a_number += 1

# --------------------------------
# res://scripts/another_object.gd
# --------------------------------
extends Node2D
  var another_number = 1

  func _physics_process(delta):
    another_number += 1

# --------------------------------
# res://test/unit/test_my_object.gd
# --------------------------------

# ...

var MyObject = load('res://scripts/my_object.gd')
var AnotherObject = load('res://scripts/another_object')

# ...

# Given that SomeCoolObj has a _process method that increments a_number by 1
# each time _process is called, and that the number starts at 0, this test
# should pass
func test_does_something_each_loop():
  var my_obj = MyObject.new()
  add_child_autofree(my_obj)
  gut.simulate(my_obj, 20, .1)
  assert_eq(my_obj.a_number, 20, 'Since a_number is incremented in _process, it should be 20 now')

# Let us also assume that AnotherObj acts exactly the same way as
# but has SomeCoolObj but has a _physics_process method instead of
# _process.  In that case, this test will pass too since all child objects
# have the _process or _physics_process method called.
func test_does_something_each_loop():
  var my_obj = MyObject.new()
  var other_obj = AnotherObj.new()

  add_child_autofree(my_obj)
  my_obj.add_child(other_obj)

  gut.simulate(my_obj, 20, .1)

  assert_eq(my_obj.a_number, 20, 'Since a_number is incremented in _process, \
                                  it should be 20 now')
  assert_eq(other_obj.another_number, 20, 'Since other_obj is a child of my_obj \
                                           and another_number is incremented in \
                                           _physics_process then it should be 20 now')
```

--------------------------------

### stub(double_instance, method_name)

Source: https://gut.readthedocs.io/en/latest/Stubbing.html

Creates a stub for a specific object instance and method name.

```APIDOC
## stub(double_instance, method_name)

### Description
Creates a stub for the specified object instance and method name. Use `when_passed` to define behavior for specific parameter values.

### Example
```gdscript
var inst = double(MyScript).new()
stub(inst, "some_method").to_return(111)
stub(inst, "some_method").when_passed("a").to_return(999)

assert_eq(inst.some_method("not a"), 111)
assert_eq(inst.some_method("a"), 999)
```
```

--------------------------------

### Execute Gut tests in a deployed game

Source: https://gut.readthedocs.io/en/latest/Running-On-Devices.html

A GDScript implementation for a Node2D scene that initializes GutControl, loads a configuration file, and connects to test lifecycle signals.

```gdscript
# ------------------------------------------------------------------------------
# This is an example of using the GutControl (res://addons/gut/gui/GutContro.tscn)
# to execute tests in a deployed game.
#
# Setup:
# Create a scene.
# Add a GutControl to your scene, name it GutControl.
# Add this script to your scene.
# Run it.
# ------------------------------------------------------------------------------
extends Node2D
@onready var _gut_control = $GutControl

# Holds a reference to the current test script object being run.  Set in
# signal callbacks.
var _current_script_object = null
# Holds the name of the current test being run.  Set in signal callbacks.
var _current_test_name = null


func _ready():
	simple_setup()
	# complex_setup()


func simple_setup():
	# You must load a gut config file to use this control.  Here we are loading
	# the default config file used by the command line.  You can use any config
	# file you have created.  Use the "save as" button in the Settings subpanel
	# to create a config file, or write your own.
	#
	# Some settings may not work.  For example, the exit flags do not have any
	# effect.
	#
	# Settings are not saved, so any changes will be lost. The idea is that you
	# want to deploy the settings and users should not be able to save them.  If
	# you want to save changes, you can call:
	# 	_gut_control.get_config().write_options(path).
	# Note that you cannot to write to res:// on mobile platforms, so you will
	# have to juggle the initial loading from res:// or user:// and save to
	# user://.
	_gut_control.load_config_file('res://.gutconfig.json')

	# That's it.  Just get a reference to the control you added to the scene and
	# give it a config.  The rest of the stuff in this script optional.



func complex_setup():
	# See simple setup
	_gut_control.load_config_file('res://.gutconfig.json')

	# Returns a gut_config.gd instance.
	var config = _gut_control.get_config()

	# Override specific values for the purposes of this scene.  You can see all
	# the options available in the default_options dictionary in gut_config.gd.
	# Changing settings AFTER _ready will not have any effect.
	config.options.should_exit = false
	config.options.should_exit_on_success = false
	config.options.compact_mode = false
	# Note that if you are exporting xml results you may want to set the path to
	# a file in user:// instead of an absolute path.  Your game may not have
	# permissions to save files elsewhere when running on a mobile device.
	config.options.junit_xml_file = 'user://deployed_results.xml'

	# Some actions cannot be done until after _ready has finished in all objects
	_post_ready_setup.call_deferred()




# If you would like to connect to signals provided by gut.gd then you must do
# so after _ready.  This is an example of getting a reference to gut and all
# of the signals it provides.
func _post_ready_setup():
	var gut = _gut_control.get_gut()
	gut.start_run.connect(_on_gut_run_start)

	gut.start_script.connect(_on_gut_start_script)
	gut.end_script.connect(_on_gut_end_script)

	gut.start_test.connect(_on_gut_start_test)
	gut.end_test.connect(_on_gut_end_test)

	gut.end_run.connect(_on_gut_run_end)


# -----------------------
# Events
# -----------------------
func _on_gut_run_start():
	print('Starting tests')


# This signal passes a TestCollector.gd/TestScript instance
func _on_gut_start_script(script_obj):
	print(script_obj.get_full_name(), ' has ', script_obj.tests.size(), ' tests')
	_current_script_object = script_obj


func _on_gut_end_script():
	var pass_count = 0
	for test in _current_script_object.tests:
		if(test.did_pass()):
			pass_count += 1
	print(pass_count, '/', _current_script_object.tests.size(), " passed\n")
	_current_script_object = null


func _on_gut_start_test(test_name):
	_current_test_name = test_name
	print('  ', test_name)


func _on_gut_end_test():
	# get_test_named returns a TestCollector.gd/Test instance for the name
	# passed in.
	var test_object = _current_script_object.get_test_named(_current_test_name)
	var status = "failed"
	if(test_object.did_pass()):
		status = "passed"
	elif(test_object.pending):
		status = "pending"

	print('    ', status)
	_current_test_name = null


func _on_gut_run_end():
	print('Tests Done')


# You can kick of the tests via code if you want.
func _on_run_gut_tests_button_pressed():
	_gut_control.run_tests()
```

--------------------------------

### key_up

Source: https://gut.readthedocs.io/en/latest/class_ref/class_gutinputfactory.html

Returns an InputEventKey event representing a key release.

```APIDOC
## InputEventKey key_up(which)

### Description
Returns an InputEventKey event with `pressed = false`. `which` can be a character or a `KEY_*` constant.
```

--------------------------------

### Configure JUnit XML Export in .gutconfig.json

Source: https://gut.readthedocs.io/en/latest/Export-Test-Results.html

Set the output file path and timestamp toggle within the .gutconfig.json configuration file.

```json
"junit_xml_file":"user://results.xml"
```

```json
"junit_xml_timestamp":false
```

--------------------------------

### Test with a Partial Double

Source: https://gut.readthedocs.io/en/latest/Partial-Doubles.html

Demonstrates creating a partial double, stubbing a method to bypass original logic, and verifying behavior with assertions.

```gdscript
var Foo = load('res://script.gd')

func test_things():
  var partial = partial_double(Foo).new()
  stub(partial, 'set_value').to_do_nothing()
  partial.set_value(20) # stubbed so implementation bypassed.

  # since set_value was stubbed, and get_value was not, and since
  # this is a partial stub, then the original functionality of
  # get_value will be executed and _value is returned.
  assert_eq(partial.get_value(), 10)
  # unstubbed partial methods can be spied on.
  assert_called(partial, 'get_value')
  # stubbed methods can be spied on as well
  assert_called(partial, 'set_value', [20])
```

--------------------------------

### simulate(obj, times, delta, check_is_processing: bool = false)

Source: https://gut.readthedocs.io/en/latest/_sources/Simulate.md.txt

Manually triggers _process and _physics_process methods on an object and its children.

```APIDOC
## simulate(obj, times, delta, check_is_processing: bool = false)

### Description
Calls `_process` and `_physics_process` on a tree of objects. It recursively traverses the tree and executes these methods if they exist on the objects.

### Parameters
- **obj** (Object) - The base object to start simulation from.
- **times** (int) - The number of times to call the methods.
- **delta** (float) - The delta value passed to the methods.
- **check_is_processing** (bool) - Optional. If true, only calls methods if the object is currently processing.
```

--------------------------------

### add_heading(display_text)

Source: https://gut.readthedocs.io/en/latest/class_ref/class_addons_gut_cli_optparse.html

Adds a heading to the help menu output.

```APIDOC
## void add_heading(display_text: String)

### Description
Adds a heading to separate logical groups of options in the help menu.

### Parameters
- **display_text** (String) - The text to display as a heading.
```

--------------------------------

### double_singleton(singleton)

Source: https://gut.readthedocs.io/en/latest/class_ref/class_guttest.html

Creates a pseudo-double of an Engine Singleton.

```APIDOC
## double_singleton(singleton)

### Description
Creates a pseudo-double of an Engine Singleton. These doubles wrap around the singleton, and do not inherit from them. These doubles do not replace the Engine Singleton instance.
```

--------------------------------

### gut.get_summary()

Source: https://gut.readthedocs.io/en/latest/Hooks.html

Retrieves the summary object containing all data regarding the test run.

```APIDOC
## gut.get_summary()

### Description
Returns the summary.gd instance which holds comprehensive data about the test run.
```

--------------------------------

### Doubling built-in objects

Source: https://gut.readthedocs.io/en/latest/Doubles.html

Demonstrates creating doubles and partial doubles for built-in Godot nodes.

```gdscript
var doubled_node2d = double(Node2D).new()
stub(doubled_node2d, 'get_position').to_return(-1)

var partial_doubled_raycast = partial_double(Raycast2D).new()
```

--------------------------------

### Retrieve Signal Parameters

Source: https://gut.readthedocs.io/en/latest/class_ref/class_guttest.html

Demonstrates how to use get_signal_parameters to inspect signal emissions from a watched object.

```GDScript
class SignalObject:
    signal some_signal
    signal other_signal


func test_get_signal_parameters():
    var obj = SignalObject.new()
    watch_signals(obj)
    obj.some_signal.emit(1, 2, 3)
    obj.some_signal.emit('a', 'b', 'c')

    # -- Passing --
    # passes because get_signal_parameters returns the most recent emission
    # by default
    assert_eq(get_signal_parameters(obj, 'some_signal'), ['a', 'b', 'c'])
    assert_eq(get_signal_parameters(obj.some_signal), ['a', 'b', 'c'])

    assert_eq(get_signal_parameters(obj, 'some_signal', 0), [1, 2, 3])
    assert_eq(get_signal_parameters(obj.some_signal, 0), [1, 2, 3])

    # if the signal was not fired null is returned
    assert_null(get_signal_parameters(obj, 'other_signal'))
    # if the signal does not exist or isn't being watched null is returned
    assert_null(get_signal_parameters(obj, 'signal_dne'))

    # -- Failing --
    assert_eq(get_signal_parameters(obj, 'some_signal'), [1, 2, 3])
    assert_eq(get_signal_parameters(obj.some_signal, 0), ['a', 'b', 'c'])
```

--------------------------------

### OptParse Methods

Source: https://gut.readthedocs.io/en/latest/class_ref/class_addons_gut_cli_optparse.html

Methods available for configuring and interacting with the OptParse instance.

```APIDOC
## Methods

### add(op_names, default, desc: String)
Adds a standard option.

### add_heading(display_text: String)
Adds a heading to the help output.

### add_positional(op_name, default, desc: String)
Adds a positional argument.

### add_positional_required(op_name, default, desc: String)
Adds a required positional argument.

### add_required(op_names, default, desc: String)
Adds a required option.

### get_help() -> String
Returns the formatted help string.

### get_missing_required_options() -> Array
Returns a list of required options that were not provided.

### get_value(name: String) -> Variant
Retrieves the value of an option.

### get_value_or_null(name: String) -> Variant
Retrieves the value of an option or null if not set.

### is_option(arg) -> bool
Checks if an argument is an option based on the prefix.

### parse(cli_args = null)
Parses the provided command-line arguments.

### print_help()
Prints the help text to the console.
```

--------------------------------

### Configuration and Debugging

Source: https://gut.readthedocs.io/en/latest/class_ref/class_guttest.html

Methods for configuring test behavior and debugging.

```APIDOC
## Variant get_double_strategy()
Returns the current double strategy.

## void set_double_strategy(double_strategy)
Sets the double strategy for all tests in the script.

## void pause_before_teardown()
Causes Gut to pause before moving to the next test, useful for debugging.
```

--------------------------------

### stub(script, method_name)

Source: https://gut.readthedocs.io/en/latest/_sources/Stubbing.md.txt

Creates a stub for a method on all instances of a specific script.

```APIDOC
## stub(script, method_name)

### Description
Creates a stub for `method_name` on all Doubles of a `script`. This stub acts as a fallback if no instance-specific stub is defined.

### Example
```gdscript
func before_each():
  stub(MyScript, "some_method").to_return(111)

func test_script_level_stubs():
  var uses_script_stub = double(MyScript).new()
  assert_eq(uses_script_stub.some_method("anything"), 111)
```
```

--------------------------------

### is_option(arg)

Source: https://gut.readthedocs.io/en/latest/class_ref/class_addons_gut_cli_optparse.html

Checks if a given argument is a valid option based on the configured prefix.

```APIDOC
## bool is_option(arg)

### Description
Tests if an argument is an existing option. Returns true if the string representation of the argument begins with the configured option_name_prefix.

### Parameters
- **arg** (any) - The argument to test.
```

--------------------------------

### Verify file absence with assert_file_does_not_exist

Source: https://gut.readthedocs.io/en/latest/class_ref/class_guttest.html

Asserts that no file exists at the provided path.

```GDScript
func before_each():
    gut.file_touch('user://some_test_file')

func after_each():
    gut.file_delete('user://some_test_file')

func test_assert_file_does_not_exist():
    # Passing
    assert_file_does_not_exist('user://file_does_not.exist')
    assert_file_does_not_exist('res://some_dir/another_dir/file_does_not.exist')

    # Failing
    assert_file_does_not_exist('res://addons/gut/gut.gd')
```
Tokens:
Raw