GdUnit4

https://godot-gdunit-labs.github.io/gdUnit4/latest
Admin
GdUnit4 is an embedded unit testing framework for Godot 4.x, designed for testing GDScript, C#...
Tokens:87,858
Snippets:1,015
Trust Score:8.3
Update:4 months ago
Show doc for...
Tokens:
Raw
### C# Signal Monitoring Example

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/signals

Demonstrates starting signal monitoring on emitter objects in C#, verifying initial monitoring status, and asserting non-emitted signals with a timeout.

```csharp
using System.Threading.Tasks;

using GdUnit4.Asserts;
using GdUnit4.Core.Signals;

using static Assertions;

[TestSuite]
public partial class SignalAssertTest
{
    public sealed partial class MyEmitter : Godot.Node {

        [Godot.Signal]
        public delegate void SignalAEventHandler();

        [Godot.Signal]
        public delegate void SignalBEventHandler(string value);

        public void DoEmitSignalA() => EmitSignal(SignalName.SignalA);

        public void DoEmitSignalB() => EmitSignal(SignalName.SignalB, "foo");
    }

    [TestCase(Timeout = 1000)]
    public async Task MonitorOnSignal()
    {
        var emitterA = AutoFree(new MyEmitter())!;
        var emitterB = AutoFree(new MyEmitter())!;

        // verify initial the emitters are not monitored
        AssertThat(GodotSignalCollector.Instance.IsSignalCollecting(emitterA, MyEmitter.SignalName.SignalA)).IsFalse();
        AssertThat(GodotSignalCollector.Instance.IsSignalCollecting(emitterA, MyEmitter.SignalName.SignalB)).IsFalse();
        AssertThat(GodotSignalCollector.Instance.IsSignalCollecting(emitterB, MyEmitter.SignalName.SignalA)).IsFalse();
        AssertThat(GodotSignalCollector.Instance.IsSignalCollecting(emitterB, MyEmitter.SignalName.SignalB)).IsFalse();

        // start monitoring on the emitter A
        AssertSignal(emitterA).StartMonitoring();
        // verify the emitters are now monitored
        AssertThat(GodotSignalCollector.Instance.IsSignalCollecting(emitterA, MyEmitter.SignalName.SignalA)).IsTrue();
        AssertThat(GodotSignalCollector.Instance.IsSignalCollecting(emitterA, MyEmitter.SignalName.SignalB)).IsTrue();
        AssertThat(GodotSignalCollector.Instance.IsSignalCollecting(emitterB, MyEmitter.SignalName.SignalA)).IsFalse();
        AssertThat(GodotSignalCollector.Instance.IsSignalCollecting(emitterB, MyEmitter.SignalName.SignalB)).IsFalse();

        // verify the signals are not emitted initial
        await AssertSignal(emitterA).IsNotEmitted(MyEmitter.SignalName.SignalA).WithTimeout(50);

```

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

### List Installed .NET SDKs

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/csharp_project_setup/csharp-setup

Verify that you have .NET 8 or .NET 9 SDKs installed on your system. This command lists all installed SDK versions.

```bash
dotnet --list-sdks
8.0.201 [C:\Program Files\dotnet\sdk]
9.0.100 [C:\Program Files\dotnet\sdk]


```

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

### GdScript Test Suite Setup and Teardown

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/test-case

Demonstrates how to define setup (before_test) and teardown (after_test) hooks within a GdUnit test suite.

```gdscript
extends GdUnitTestSuite

func before_test():
    # Setup test data here

func after_test():
    # Cleanup test data here

func test_string_to_lower() -> void:
   assert_str("AbcD".to_lower()).is_equal("abcd")

```

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

### String starts with prefix - C#

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-string

Verifies that the current string starts with the given prefix. This is useful for checking the beginning of a string.

```C#
AssertThat("This is a String").StartsWith("This is");

// this assertion fails
AssertThat("This is a String").StartsWith("a String");
```

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

### GdScript Database Test Hook Example

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/hooks

A GdScript example demonstrating a database test hook. It sets up a test database during startup and cleans it up during shutdown.

```gdscript
class_name DatabaseTestHook
extends GdUnitTestSessionHook

var db_connection

func _init():
    super("DatabaseTestHook", "Manages test database lifecycle")

func startup(session: GdUnitTestSession) -> GdUnitResult:
    session.send_message("Creating test database: %s" % test_db_name)
    
    # Connect to database server
    db_connection = DatabaseManager.connect_to_server({
        "host": "localhost",
        "port": 5432,
        "user": "test_user",
        "password": "test_password"
    })
    
    if not db_connection:
        return GdUnitResult.error("Failed to connect to database server")
    
    # Create test database
    if not db_connection.create_database("test_db_name"):
        return GdUnitResult.error("Failed to create test database")
    
    
    session.send_message("Test database ready")
    return GdUnitResult.success()

func shutdown(session: GdUnitTestSession) -> GdUnitResult:
    session.send_message("Cleaning up test database")
    
    if db_connection:
        # Drop test database
        db_connection.drop_database("test_db_name")
        db_connection.disconnect()
        
    session.send_message("Database cleanup completed")
    return GdUnitResult.success()


```

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

### String starts with prefix

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-string

Verifies that the current string starts with the given prefix. This is useful for checking the beginning of a string.

```GdScript
assert_str("This is a String").starts_with("This is")

# this assertion fails
assert_str("This is a String").starts_with("a String")
```

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

### C# Test Case Setup Hook

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/hooks

Use the `[BeforeTest]` attribute to designate a method that will execute before each test case, ensuring necessary setup is performed.

```csharp
[TestSuite]
public class ExampleTest
{
    private Godot.Node _testInstance;

    [BeforeTest]
    public void SetupTest()
    {
        // Each test gets a fresh instance
        _testInstance = AutoFree(new Godot.Node());
        _testInstance.Name = "TestNode";
    }
}

```

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

### Example of using create_temp_dir() to save game data in GdScript

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/tools

This GdScript example demonstrates creating a temporary directory using create_temp_dir(), saving JSON data to a file within that directory, and asserting the file's existence.

```GdScript
func test_save_game_data():
    # create a temporay directory to store test data
    var temp_dir := create_temp_dir("examples/game/save")
    var file_to_save := temp_dir + "/save_game.dat"
    
    var data = {
        'user': "Hoschi",
        'level': 42
    }
    var file := File.new()
    file.open(file_to_save, File.WRITE)
    file.store_line(JSON.print(data))
    file.close()
    
        # the data is saved at "user://tmp/examples/game/save/save_game.dat"
    assert_bool(file.file_exists(file_to_save)).is_true()

```

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

### Example Test File Paths

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/first_steps/settings

Illustrates the typical relationship between source files and their corresponding test files within a project structure.

```text
  res://project/src/folder_a/folder_b/my_class.gd
  res://project/test/folder_a/folder_b/my_class_test.gd

```

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

### C# AssertThat Examples

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-that

Examples demonstrating the usage of AssertThat in C# for string equality and numeric comparison. The auto-typing feature selects the correct assertion.

```csharp
AssertThat("This is a test message").is_equal("This is a test message");
AssertThat(23).IsGreater(20);

```

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

### GdScript extended example of auto_free() usage

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/tools

An extended GdScript test suite example demonstrating the usage of auto_free() across different scopes (suite setup, test case setup, test) and showing object lifetime management.

```GdScript
extends GdUnitTestSuite

var _obj_a;
var _obj_b;
var _obj_c;

# Scope test suite setup
func before():
    _obj_a = auto_free(Node.new())
    print_obj_usage("before")

# Scope test case setup
func before_test():
    _obj_b = auto_free(Node.new())
    print_obj_usage("before_test")

# Scope test
func test():
    _obj_c = auto_free(Node.new())
    # _obj_a still lives here
    # _obj_b still lives here
    # _obj_b still lives here
    print_obj_usage("test")

# Scope test case setup
func after_test():
    # _obj_a still lives here
    # _obj_b still lives here
    # _obj_c is freed
    print_obj_usage("after_test")
    
# Scope test suite setup
func after():
    # _obj_a still lives here
    # _obj_b is auto freed
    # _obj_c is freed
    print_obj_usage("after")

func _notification(what):
    if what == NOTIFICATION_PATH_CHANGED:
        print_header()
    else:
        print_obj_usage(GdObjects.notification_as_string(what))

func print_header() :
    prints("|%16s | %16s | %16s | %16s |" % ["", "_obj_a", "_obj_b", "_obj_c"])
    prints("----------------------------------------------------------------------------")

func print_obj_usage(name :String) :
    prints("|%16s | %16s | %16s | %16s |" % [name, _obj_a, _obj_b, _obj_c])

```

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

### Complete GdUnit4 C# Project Configuration

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/csharp_project_setup/csharp-setup

An example of a complete .csproj file demonstrating the necessary configurations for GdUnit4 C# testing, including target framework and dependencies.

```xml
 <Project Sdk="Godot.NET.Sdk/4.5">
   <PropertyGroup>
     <TargetFramework>net9.0</TargetFramework>
     <LangVersion>13.0</LangVersion>
     <!--Force nullable warnings, you can disable if you want-->
     <Nullable>enable</Nullable>
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
     <!--Disable warning of invalid/incompatible GodotSharp version-->
     <NoWarn>NU1605</NoWarn>
   </PropertyGroup>
      
   <!-- gdUnit4 package dependencies --> 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0"/>
     <PackageReference Include="gdUnit4.api" Version="5.1.0-rc1"/>
     <PackageReference Include="gdUnit4.test.adapter" Version="3.0.0"/>
     <PackageReference Include="gdUnit4.analyzers" Version="1.0.0">
       <PrivateAssets>none</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
   </ItemGroup>
 </Project>


```

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

### Run Tests Using Specific Configuration

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/cmd

Load a specific test configuration file and run the configured tests. Use this to manage different test setups.

```bash
./addons/gdUnit4/runtest.sh -conf <test_config.cfg>
```

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

### GdScript Resource Cleanup Example

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/hooks

Demonstrates using `before_test` to open a file and `after_test` to close it, ensuring resources are managed correctly. Timers are shown with `auto_free` for automatic cleanup.

```gdscript
func before_test():
    _file = FileAccess.open("test.txt", FileAccess.WRITE)
    _timer = auto_free(Timer.new())
    
func after_test():
    if _file:
        _file.close()
    # Timer is auto-freed

```

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

### scene

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing//scene_runner/accessors

Gets access to the current running scene.

```APIDOC
## scene

### Description
Gets access to the current running scene.

### GdScript Signature
```gdscript
func scene() -> SceneTree:
```

### C# Signature
```csharp
public SceneTree Scene { get; }
```

### Returns
* (SceneTree) - The current running scene.

### GdScript Example
```gdscript
var runner := scene_runner("res://test_scene.tscn")
var current_scene: SceneTree = runner.scene()
```

### C# Example
```csharp
ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn");
SceneTree currentScene = runner.Scene;
```
```

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

### GdScript AssertThat Examples

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-that

Examples demonstrating the usage of AssertThat in GdScript for string equality and numeric comparison. Type-specific asserts are preferred for clarity.

```gdscript
assert_that("This is a test message").is_equal("This is a test message")
assert_that(23).is_greater(20)

```

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

### Run Tests Using Specific Configuration (Unix/Linux)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/cmd

Load a specific test configuration file and run the configured tests on Unix/Linux systems. Use this to manage different test setups.

```bash
./addons/gdUnit4/runtest -conf <test_config.cfg>
```

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

### Example Class Definition

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/mock

Defines a simple GDScript class 'TestClass' that extends Node and has a 'message' method returning a string.

```gdscript
class_name TestClass
extends Node

    func message() -> String:
        return "a message"

```

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

### C# AwaitMethod Example

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/functions

Waits for a function to return a value and asserts it equals 'black' within a 5000ms timeout.

```csharp
ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn");

// Waits until the function `color_cycle()` returns black or fails after an timeout of 5s
await runner.AwaitMethod<bool>("color_cycle").IsEqual("black").WithTimeout(5000);

```

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

### Custom Fuzzer Implementation Example

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/fuzzing

An example of a custom fuzzer implementation that extends the base `Fuzzer` class. This fuzzer provides a random value from a predefined set of prime numbers.

```GdScript
# A simple test fuzzer where a random value of a hard coded set of values is provided
class TestFuzzer extends Fuzzer:
    var _data := [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

    func next_value():
        return _data[randi_range(0, _data.size())]

```

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

### Mocking Node Methods and Arguments

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/mock

Provides an example of mocking methods on a Node instance, including overriding 'get_child_count' to return a specific number and 'get_child' to return mocked instances of Camera and Area based on the argument index.

```gdscript
# Create a mock from class `Node`
var mocked_node := mock(Node) as Node

# It returns 0 by default
mocked_node.get_child_count()
# Override function `get_child_count` to return 10
do_return(10).on(mocked_node).get_child_count()
# The next call of `get_child_count` will now return 10
mocked_node.get_child_count()

# It returns 'null' by default
var node = mocked_node.get_child(0)
assert_object(node).is_null()

# Override function `get_child` to return a mocked 'Camera' for child index 0
do_return(mock(Camera)).on(mocked_node).get_child(0)
# And a mocked 'Area' for child index 1
do_return(mock(Area)).on(mocked_node).get_child(1)

# It now returns the Camera node at index 0
var node0 = mocked_node.get_child(0)
assert_object(node0).is_instanceof(Camera)
# And the Area node at index 1
var node1 = mocked_node.get_child(1)
assert_object(node1).is_instanceof(Area)

```

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

### Scene

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing//scene_runner/accessors

Gets access to the current loaded and managed scene by the SceneRunner.

```APIDOC
## Scene

### Description
Gets access to the current loaded and managed scene by the SceneRunner. The scene remains available for testing and interaction until the runner is disposed or the scene is explicitly freed.

### Method
Node? Scene()

### Response
#### Success Response
- **Node?** - The node representing the current running scene, or null when the SceneRunner is disposed or the scene has been freed.

### Request Example
```gdscript
ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn");
var currentScene = runner.Scene();
```
```

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

### GdScript Signal Monitoring Example

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/signals

Demonstrates monitoring signals from two emitter objects, asserting initial non-emission, emitting signals, and verifying their emission. It also shows asserting non-emission on a separate emitter.

```gdscript
extends GdUnitTestSuite

class MyEmitter extends Node:

    signal my_signal_a
    signal my_signal_b(value :String)

    func do_emit_a() -> void:
        my_signal_a.emit()

    func do_emit_b() -> void:
        my_signal_b.emit("foo")


func test_monitor_signals() -> void:
    # start monitoring on the emitter to collect all emitted signals
    # use typed variables to enable Signal reference syntax (since v6.1)
    var emitter_a: MyEmitter = monitor_signals(MyEmitter.new())
    var emitter_b: MyEmitter = monitor_signals(MyEmitter.new())

    # verify the signals are not emitted initial
    await assert_signal(emitter_a).wait_until(50).is_not_emitted(emitter_a.my_signal_a)
    await assert_signal(emitter_a).wait_until(50).is_not_emitted(emitter_a.my_signal_b)
    await assert_signal(emitter_b).wait_until(50).is_not_emitted(emitter_b.my_signal_a)
    await assert_signal(emitter_b).wait_until(50).is_not_emitted(emitter_b.my_signal_b)

    # emit signal `my_signal_a` on emitter_a
    emitter_a.do_emit_a()
    await assert_signal(emitter_a).is_emitted(emitter_a.my_signal_a)

    # emit signal `my_signal_b` on emitter_a (variadic args since v6.1)
    emitter_a.do_emit_b()
    await assert_signal(emitter_a).is_emitted(emitter_a.my_signal_b, "foo")
    # verify emitter_b still has nothing emitted
    await assert_signal(emitter_b).wait_until(50).is_not_emitted(emitter_b.my_signal_a)
    await assert_signal(emitter_b).wait_until(50).is_not_emitted(emitter_b.my_signal_b)

    # now verify emitter b
    emitter_b.do_emit_a()
    await assert_signal(emitter_b).wait_until(50).is_emitted(emitter_b.my_signal_a)


```

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

### Use a Spy to Track Function Calls

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/spy

This example demonstrates how to spy on a custom class instance and verify that its 'message' function was called exactly once.

```gdscript
class_name TestClass
extends Node

    func message() -> String:
        return "a message"

func test_spy():
    var instance = auto_free(TestClass.new())

    # Build a spy on the instance
    var spy = spy(instance)

    # Call function `message` on the spy to track the interaction
    spy.message()

    # Verify the function 'message' is called one times
    verify(spy, 1).message()
```

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

### Example C# Object for Extraction

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-array

Defines a sample C# class 'TestObj' with properties that can be accessed via extractors.

```csharp
// example object for extraction
class TestObj : Godot.Reference
{
    string _name;
    object _value;
    object _x;

    public TestObj(string name, object value, object x = null)
    {
        _name = name;
        _value = value;
        _x = x;
    }

    public string GetName() => _name;
    public object GetValue() => _value;
    public object GetX() => _x;
}
```

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

### Assert Integer Is Zero

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is exactly zero. Examples are shown for GdScript and C#.

```GdScript
# this assertion succeeds
assert_int(0).is_zero()

# this assertion fail because the value is not zero
assert_int(1).is_zero()
```

```C#
// this assertion succeeds
AssertThat(0).IsZero();

// this assertion fail because the value is not zero
AssertThat(1).IsZero();
```

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

### GdScript Test Case Setup Hook

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/hooks

Implement the `before_test()` function within your TestSuite to initialize data or resources required before each individual test case begins.

```gdscript
class_name GdUnitExampleTest
extends GdUnitTestSuite

var _test_instance :Node

func before_test():
    # Each test gets a fresh instance
    _test_instance = auto_free(Node.new())
    _test_instance.name = "TestNode"

```

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

### GdScript await_func Example

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/functions

Waits for a function in the scene to return a value and asserts it equals 'black' within 5000ms.

```gdscript
var runner := scene_runner("res://test_scene.tscn")

# Waits until the function `color_cycle()` returns black or fails after an timeout of 5s
await runner.await_func("color_cycle").wait_until(5000).is_equal("black")

```

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

### GdScript await_func_on Example

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/functions

Waits for a function on a specific source node to return a value and asserts it is false within 100ms.

```gdscript
var runner := scene_runner("res://test_scene.tscn")
# grab the colorRect instance from the scene
var box1: ColorRect = runner.get_property("_box1")

# call function `start_color_cycle` how is emit the signal 
box1.start_color_cycle()

# Waits until the function `has_parent()` on source `door` returns false or fails after an timeout of 100ms
await runner.await_func_on(box1, "panel_color_change", [box1, Color.RED]).wait_until(100).is_false()

```

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

### Verifying Signal Emission with Argument Matchers

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/argument_matchers

Use `any_int()` and `any_string()` to assert that a signal is emitted with specific argument types. This example shows how to wait for a signal with any integer argument or a string name and an integer ID.

```gdscript
# Waits until 'test_signal_counted' is emitted with any integer argument (variadic syntax since v6.1)
await assert_signal(signal_emitter).is_emitted("test_signal_counted", any_int())
# Waits until 'item_added' is emitted with any String name and exactly item_id=42
await assert_signal(signal_emitter).is_emitted("item_added", any_string(), 42)
```

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

### Using rangei Fuzzer

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/fuzzing

Example of using the `rangei` fuzzer to generate random integers within a specified range and asserting the result. This snippet also shows how to set a custom number of iterations.

```GdScript
func test_fuzzer_inject_value(fuzzer := Fuzzers.rangei(-23, 22), _fuzzer_iterations := 100)
    assert_int(fuzzer.next_value()).is_between(-23, 22)
  
  
# using multiple fuzzers in test are allowed
func test_fuzzer_inject_value(fuzzer_a := Fuzzers.rangei(-23, 22), fuzzer_b := Fuzzers.rangei(0, 42), _fuzzer_iterations := 100):
    assert_int(fuzzer_a.next_value()).is_between(-23, 22)
    assert_int(fuzzer_b.next_value()).is_between(-23, 22)

```

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

### Assert Integer Less Than or Equal To

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is less than or equal to a specified value. Examples are shown for GdScript and C#.

```GdScript
assert_int(23).is_less_equal(22)
```

```GdScript
// this assertion succeeds
assert_int(23).is_less_equal(42);
assert_int(23).is_less_equal(23);

// this assertion fails because 23 is not less than or equal to 22
assert_int(23).is_less_equal(22);
```

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

### Simulate Scene Processing Over Frames (GdScript)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/sceneRunner

Example of using the simulate_frames function in GdScript to process a scene over a specified number of frames at normal speed. Ensure the scene runner is initialized first.

```GdScript
var runner := scene_runner("res://test_scene.tscn")

# Simulate scene processing over 60 frames at normal speed
await runner.simulate_frames(60)
```

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

### C# Vector Not Equal Assertion Examples

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-vector

Examples of successful and failing vector not equal assertions in C#. The assertion fails if the vectors are equal.

```csharp
// this assertion succeeds
AssertThat(Vector2.One).IsNotEqual(new Vector2(1.2f, 1.000001f));

// should fail because is equal
AssertThat(Vector2.One).IsNotEqual(Vector2.One);
```

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

### GdScript Vector Not Equal Assertion Examples

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-vector

Examples of successful and failing vector not equal assertions in GdScript. The assertion fails if the vectors are identical.

```gdscript
# this assertion succeeds
assert_vector(Vector2(1.1, 1.2)).is_not_equal(Vector2(1.1, 1.3))

# this assertion fails because both vectors are equal
assert_vector(Vector2(1.1, 1.2)).is_not_equal(Vector2(1.1, 1.2))
```

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

### Error Handling in Hook Startup

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/hooks

Demonstrates proper error handling within a hook's startup method. It checks for initialization and configuration success, returning specific error results if failures occur.

```GdScript
func startup(session: GdUnitTestSession) -> GdUnitResult:
    if not initialize_resources():
        return GdUnitResult.error("Failed to initialize resources: %s" % get_last_error())
    
    if not validate_configuration():
        return GdUnitResult.error("Invalid configuration: missing required settings")
    
    session.send_message("All systems initialized successfully")
    return GdUnitResult.success()

```

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

### Run Tests Using Latest Configuration (Unix/Linux)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/cmd

Load the latest GdUnitRunner.cfg configuration and run the configured tests on Unix/Linux systems. This is convenient for repeating the last test session.

```bash
./addons/gdUnit4/runtest -conf
```

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

### C# Vector Equality Assertion Examples

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-vector

Examples of successful and failing vector equality assertions in C#. The assertion fails if the vectors are not exactly equal.

```csharp
// this assertion succeeds
AssertThat(Vector2.One).IsEqual(Vector2.One);

// should fail because is NOT equal
AssertThat(Vector2.One).IsEqual(new Vector2(1.2f, 1.000001f));
```

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

### Simulate Enter Key Release (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/keys

Simulates the Enter key being released. Use `await runner.AwaitInputProcessed()` to ensure completion.

```csharp
ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn");

// Simulate the enter key is released
runner.SimulateKeyRelease(KeyList.Enter);
await runner.AwaitInputProcessed();
```

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

### GdScript Vector Equality Assertion Examples

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-vector

Examples demonstrating successful and failing vector equality assertions in GdScript. The assertion fails if any component of the vector is not equal.

```gdscript
# this assertion succeeds
assert_vector(Vector2(1.1, 1.2)).is_equal(Vector2(1.1, 1.2))

# this assertion fails because part y of the vector 1.2 are not equal to 1.3
assert_vector(Vector2(1.1, 1.2)).is_equal(Vector2(1.1, 1.3))
```

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

### Run Tests Using Latest Configuration

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/cmd

Load the latest GdUnitRunner.cfg configuration and run the configured tests. This is convenient for repeating the last test session.

```bash
./addons/gdUnit4/runtest.sh -conf
```

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

### GdScript Vector Less Than Assertion Examples

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-vector

Examples demonstrating successful vector less than assertions in GdScript. The assertion checks if the current vector is component-wise less than the expected vector.

```gdscript
# this assertion succeeds
assert_vector(Vector2.ZERO.is_less(Vector2.ONE)
assert_vector(Vector2(1.1, 1.2)).is_less(Vector2(1.1, 1.3))
```

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

### GdUnit Command Line Tool Help

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/cmd

Displays the help message for the GdUnit command-line tool, outlining available commands and options.

```bash
----------------------------------------------------------------------------------------------
 GdUnit4 Commandline Tool

 Usage:
        runtest -a <directory|path of testsiute>
        runtest -a <directory> -i <path of testsuite|testsuite_name|testsuite_name:test_name>

-- Options ---------------------------------------------------------------------------------------

  [-help]                                 Shows this help message.

  [--help-advanced]                       Shows advanced options.

  [-a, --add]                             Adds the given test suite or directory to the execution pipeline.
     -a <directory|path of testsuite>

  [-i, --ignore]                          Adds the given test suite or test case to the ignore list.
     -i <testsuite_name|testsuite_name:test-name>

  [-c, --continue]                        By default GdUnit will abort on first test failure to be fail fast, instead of stop after first failure you can use this option to run the complete test set.

  [-conf, --config]                       Run all tests by given test configuration. Default is 'GdUnitRunner.cfg'
     -conf [testconfiguration.cfg]


```

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

### C# Vector Approximate Equality Assertion Examples

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-vector

Examples of successful and failing approximate equality assertions in C#. The assertion checks if the vector components are within the specified approximation range.

```csharp
// this assertion succeeds
AssertVec2(Vector2.One).IsEqualApprox(Vector2.One, new Vector2(0.004f, 0.004f));

// should fail because is NOT equal approximated
AssertVec2(new Vector2(1.005f, 1f)).IsEqualApprox(Vector2.One, new Vector2(0.004f, 0.004f));
```

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

### GdScript Vector Approximate Equality Assertion Examples

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-vector

Examples of successful and failing approximate equality assertions in GdScript. The assertion checks if the vector components are within the specified approximation range.

```gdscript
# this assertion succeeds
assert_vector(Vector2(0.996, 0.996)).is_equal_approx(Vector2.ONE, Vector2(0.004, 0.004))

# this will fail because the vector is out of approximated range
assert_vector(Vector2(1.005, 1)).is_equal_approx(Vector2.ONE, Vector2(0.004, 0.004))
```

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

### Simulate Complete Drag and Drop (GdScript)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/touchscreen

Simulates a complete drag and drop event from a start position to an end position. Ideal for testing complex drag-and-drop scenarios with defined start and end points.

```GdScript
func simulate_screen_touch_drag_drop(index: int, position: Vector2, drop_position: Vector2, time: float = 1.0, trans_type: Tween.TransitionType = Tween.TRANS_LINEAR) -> GdUnitSceneRunner:


```

```GdScript
var runner := scene_runner("res://test_scene.tscn")

# Simulates a full drag and drop from position 50, 50 to 100, 50
await runner.simulate_screen_touch_drag_drop(0, Vector2(50, 50), Vector2(100,50))
```

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

### Load Scene with Scene Runner (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/sceneRunner

Loads a scene to be tested using the Scene Runner in C#. This is the initial step to begin scene simulation.

```C#
ISceneRunner runner = ISceneRunner.Load("res://my_scene.tscn");
```

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

### Mocking by Class Name or Resource Path

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/mock

Shows how to create mocked instances of a class using either its 'class_name' or its full resource path if 'class_name' is not defined.

```gdscript
# Example class
class_name TestClass
extends Node
    ...

```

```gdscript
# Create a mocked instance of the class 'TestClass'
var mock := mock(TestClass)
# Or create it by using the full resource path if no `class_name` is defined
var mock := mock("res://project_name/src/TestClass.gd")

```

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

### Get Mouse Position (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/mouse

Retrieves the current mouse cursor position within the viewport.

```csharp
ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn");

// gets the current mouse position
var mousePosition = runner.GetMousePosition();
```

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

### Simulate Enter Key Release (GdScript)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/keys

Simulates the Enter key being released. Use `await runner.await_input_processed()` to ensure completion.

```gdscript
var runner := scene_runner("res://test_scene.tscn")

# Simulate the enter key is released
runner.simulate_key_release(KEY_ENTER)
await runner.await_input_processed()
```

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

### Simulate Enter Key Press (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/keys

Simulates the Enter key being pressed. Use `await runner.AwaitInputProcessed()` to ensure completion.

```csharp
ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn");

// Simulate the enter key is pressed
runner.SimulateKeyPress(KeyList.Enter);
await runner.AwaitInputProcessed();
```

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

### Get Mouse Position (GdScript)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/mouse

Retrieves the current mouse cursor position within the viewport.

```gdscript
var runner := scene_runner("res://test_scene.tscn")

# gets the current mouse position
var mouse_position := runner.get_mouse_position()
```

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

### Assert Integer Is Not Zero

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is not equal to zero. Examples are shown for GdScript and C#.

```GdScript
# this assertion succeeds
assert_int(1).is_not_zero()

# this assertion fail because the value is zero
assert_int(0).is_not_zero()
```

```C#
// this assertion succeeds
AssertThat(1).IsNotZero();

// this assertion fail because the value is zero
AssertThat(0).IsNotZero();
```

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

### Assert Integer Is Negative

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is a negative number. Examples are shown for GdScript and C#.

```GdScript
# this assertion succeeds
assert_int(-13).is_negative()

# this assertion fail because the value '13' is positive
assert_int(13).is_negative()
```

```C#
// this assertion succeeds
AssertThat(-13).IsNegative();

// this assertion fail because the value '13' is positive
AssertThat(13).IsNegative();
```

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

### Verify Resource is a File

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-file

Use `is_file()` to check if a resource exists and is readable as a file. It fails if the path points to a directory or a non-existent resource.

```GdScript
func assert_file(<current>).is_file() -> GdUnitFileAssert
```

```GdScript
# this assertion succeeds if the file exists and can be opened
assert_file("res://test.gd").is_file()

# this assertion fails if the file doesn't exist or can't be opened
assert_file("res://nonexistent.gd").is_file()
assert_file("res://some_directory/").is_file()
```

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

### Assert Integer Is Odd

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is an odd number. Examples are shown for GdScript and C#.

```GdScript
# this assertion succeeds
assert_int(13).is_odd()

# this assertion fail because the value '12' is even
assert_int(12).is_odd()
```

```C#
// this assertion succeeds
AssertThat(13).IsOdd();

// this assertion fail because the value '12' is even
AssertThat(12).IsOdd();
```

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

### Assert Integer Is Even

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is an even number. Examples are shown for GdScript and C#.

```GdScript
# this assertion succeeds
assert_int(12).is_even()

# this assertion fail because the value '13' is not even
assert_int(13).is_even()
```

```C#
// this assertion succeeds
AssertThat(12).IsEven();

// this assertion fail because the value '13' is not even
AssertThat(13).IsEven();
```

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

### Simulate Ctrl+Alt+C Key Release (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/keys

Simulates the Ctrl+Alt+C key combination being released. Use `await runner.AwaitInputProcessed()` to ensure completion.

```csharp
// Simulates multi key combination ctrl+alt+C is released
runner.SimulateKeyRelease(KeyList.Ctrl);
runner.SimulateKeyRelease(KeyList.Alt);
runner.SimulateKeyRelease(KeyList.C);
await runner.AwaitInputProcessed();
```

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

### Simulate Action Pressed (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/actions

Simulates a full action press-and-release interaction. Use await runner.AwaitInputProcessed() to ensure the simulation is complete.

```csharp
ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn");

// Simulate the UP key is pressed by using the input action "ui_up"
runner.SimulateActionPressed("ui_up");
await runner.AwaitInputProcessed();
```

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

### Get Current Scene Instance (GdScript)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing//scene_runner/accessors

Retrieves the root node of the currently loaded and managed scene.

```gdscript
## Returns the scene instance that is currently loaded and managed by this SceneRunner.
## [member return] : The node representing the current running scene
func scene() -> Node:

```

Here is an example of how to use scene():
```
var runner := scene_runner("res://test_scene.tscn")

# Gets access to the scene instance
var my_scene := runner.scene()

```
```

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

### Simulate Ctrl+C Key Release (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/keys

Simulates the Ctrl+C key combination being released. Use `await runner.AwaitInputProcessed()` to ensure completion.

```csharp
// Simulates key combination ctrl+C is releasedrunner.SimulateKeyRelease(KeyList.Ctrl);
runner.SimulateKeyRelease(KeyList.C);
await runner.AwaitInputProcessed();
```

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

### Simulate Action Release (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/actions

Completes a key interaction by releasing the action. Use await runner.AwaitInputProcessed() to ensure the simulation is complete.

```csharp
/// <summary>
/// Simulates that an action has been released.
/// </summary>
/// <param name="action">The name of the action, e.g., "ui_up".</param>
/// <returns>The SceneRunner instance.</returns>
ISceneRunner SimulateActionRelease(string action);
```

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

### Assert Integer Is In Set

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is present within a given set of values. This example is for GdScript.

```GdScript
func assert_int(<current>).is_in(<expected> :Array) -> GdUnitIntAssert
```

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

### Initialize Scene Runner (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/touchscreen

Initializes the scene runner in C# for simulating touchscreen events. This is a prerequisite for using any of the simulation methods.

```C#
ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn");
```

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

### Verify Resource Exists

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-file

Use `exists()` to confirm that a resource is present in the file system. This assertion fails if the specified path does not exist.

```GdScript
func assert_file(<current>).exists() -> GdUnitFileAssert
```

```GdScript
# this assertion succeeds if the file exists
assert_file("res://test.gd").exists()

# this assertion fails if the file doesn't exist
assert_file("res://nonexistent.gd").exists()
```

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

### Assert Integer Greater Than

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is strictly greater than a specified value. Examples are shown for GdScript and C#.

```GdScript
assert_int(23).is_greater(20)
assert_int(23).is_greater(22)

// this assertion fails because 23 is not greater than 23
assert_int(23).is_greater(23)
```

```C#
// this assertion succeeds
AssertThat(23).IsGreater(20);
AssertThat(23).IsGreater(22);

// this assertion fails because 23 is not greater than 23
AssertThat(23).IsGreater(23);
```

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

### Simulate Full Key Press-and-Release (GdScript)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/keys

Use simulate_key_pressed to simulate a complete key press and release action. Ensure input events are processed by awaiting runner.await_input_processed().

```gdscript
func simulate_key_pressed(key_code: int, shift := false, control := false) -> GdUnitSceneRunner:


```

```gdscript
var runner := scene_runner("res://test_scene.tscn")

# Simulate the enter key is pressed
runner.simulate_key_pressed(KEY_ENTER)
await runner.await_input_processed()

# Simulates key combination ctrl+C is pressedrunner.simulate_key_press(KEY_CTRL)
runner.simulate_key_pressed(KEY_C)
await runner.await_input_processed()

```

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

### Simulate Ctrl+Alt+C Key Release (GdScript)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/keys

Simulates the Ctrl+Alt+C key combination being released. Use `await runner.await_input_processed()` to ensure completion.

```gdscript
# Simulates multi key combination ctrl+alt+C is released
runner.simulate_key_release(KEY_CTRL)
runner.simulate_key_release(KEY_ALT)
runner.simulate_key_release(KEY_C)
await runner.await_input_processed()
```

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

### Simulate Ctrl+C Key Release (GdScript)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/keys

Simulates the Ctrl+C key combination being released. Use `await runner.await_input_processed()` to ensure completion.

```gdscript
# Simulates key combination ctrl+C is releasedrunner.simulate_key_release(KEY_CTRL)
runner.simulate_key_release(KEY_C)
await runner.await_input_processed()
```

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

### Assert Integer Is Not Negative

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is not a negative number (i.e., zero or positive). Examples are shown for GdScript and C#.

```GdScript
# this assertion succeeds
assert_int(13).is_not_negative()

# this assertion fail because the value '-13' is negative
assert_int(-13).is_not_negative()
```

```C#
// this assertion succeeds
AssertThat(13).IsNotNegative();

// this assertion fail because the value '-13' is negative
AssertThat(-13).IsNotNegative();
```

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

### Assert Integer Greater Than or Equal To

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/assert-integer

Use this to verify if an integer is greater than or equal to a specified value. Examples are shown for GdScript and C#.

```GdScript
assert_int(23).is_greater_equal(20)
assert_int(23).is_greater_equal(23)

# this assertion fails because 23 is not greater than 23
assert_int(23).is_greater_equal(24)
```

```C#
AssertThat(23).IsGreaterEqual(20)
AssertThat(23).IsGreaterEqual(23)

// this assertion fails because 23 is not greater than 23
AssertThat(23).IsGreaterEqual(24)
```

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

### Simulate Action Pressed (GdScript)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/actions

Simulates a full action press-and-release interaction. Use await runner.await_input_processed() to ensure the simulation is complete.

```gdscript
var runner := scene_runner("res://test_scene.tscn")

# Simulate the UP key is pressed by using the input action "ui_up"
runner.simulate_action_pressed("ui_up")
await runner.await_input_processed()
```

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

### Basic Spy Interaction and Verification

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/spy

This snippet demonstrates the basic usage of spies to record and verify function calls. It shows how to spy on a node, call its methods, and then verify those calls.

```gdscript
var spyed_node = spy(Node.new())
spyed_node.is_a_parent_of(null)
spyed_node.set_process(false)

verify(spyed_node).is_a_parent_of(null)
verify(spyed_node).set_process(false)
```

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

### Get Scene Access in GdScript

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing//scene_runner/accessors

Provides access to the current running scene object. Use when direct scene manipulation is needed.

```gdscript
# Gets access to the current running scene
var scene = runner.scene
```

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

### Complete First Test using Resource Path

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/first_steps/getting-started

Completes the 'test_full_name' test by loading the 'TestPerson' script using its resource path and asserting the expected full name.

```gdscript
func test_full_name() -> void:
   var person = load("res://first_steps/test_person.gd").new("King", "Arthur")
   assert_str(person.full_name()).is_equal("King Arthur")

```

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

### Simulate Frames and Test Scene Behavior (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/sceneRunner

Tests scene behavior by simulating frames, invoking functions, and asserting property changes. Requires the scene runner to be initialized and the scene node to be accessible.

```C#
[TestCase]
public async Task simulate_frame() {
    // Create the scene runner for scene `test_scene.tscn`
    ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn"); 
    
    // Get access to the loaded scene node
    var my_scene = runner.Scene();

    // Get access to scene property '_box1'
    ColorRect box1 = runner.GetProperty("_box1");
    // Verify it is initially set to white
    AssertObject(box1.color).IsEqual(Color.WHITE);
    
    // Start the color cycle by invoking the function 'start_color_cycle' and await 10 frames being processed
    runner.Invoke("start_color_cycle")        
    await runner.SimulateFrames(10);

    // After 10 frames, the color should have changed to black
    AssertObject(box1.color).IsEqual(Color.BLACK);
}
```

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

### Simulate Ctrl+Alt+C Key Press (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/scene_runner/keys

Simulates the Ctrl+Alt+C key combination being pressed. Use `await runner.AwaitInputProcessed()` to ensure completion.

```csharp
// Simulates multi key combination ctrl+alt+C is pressed
runner.SimulateKeyPress(KeyList.Ctrl);
runner.SimulateKeyPress(KeyList.Alt);
runner.SimulateKeyPress(KeyList.C);
await runner.AwaitInputProcessed();
```

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

### Get Scene Access in C#

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing//scene_runner/accessors

Provides access to the current running scene object. Use when direct scene manipulation is needed in C#.

```csharp
// Gets access to the current running scene
var scene = runner.Scene;
```

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

### Get Property Value in GdScript

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing//scene_runner/accessors

Retrieves the current value of a specified property from the scene. Use when you need to inspect a node's state.

```gdscript
var runner := scene_runner("res://test_scene.tscn")

# Returns the current property `_door_color` from the scene
var color: ColorRect = runner.get_property("_door_color")
```

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

### Load and Simulate Frames (C#)

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/advanced_testing/sceneRunner

Loads a scene and simulates its processing for a given number of frames. The default deltaPeerFrame is used if not specified.

```C#
ISceneRunner runner = ISceneRunner.Load("res://test_scene.tscn");

// Simulate scene processing over 60 frames at normal speed
await runner.SimulateFrames(60);

// Simulate scene processing over 60 frames with a delay of 100ms between each frame
await runner.SimulateFrames(60, 100);
```

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

### GdScript TestSuite with Hooks

Source: https://godot-gdunit-labs.github.io/gdUnit4/latest/testing/test-suite

Defines a GdUnit TestSuite in GdScript with suite-level setup and teardown hooks, and two test cases for string case conversion.

```GdScript
extends GdUnitTestSuite

func before() -> void:
    # Setup suite-level shared resources, expensive setup

func after() -> void:
    # Cleanup suite-level shared resources, expensive setup

func test_string_to_lower() -> void:
   assert_str("AbcD".to_lower()).is_equal("abcd")
   
func test_string_to_upper() -> void:
   assert_str("AbcD".to_upper()).is_equal("ABCD")   
   

```
Tokens:
Raw