FUUUUCK FUUUUUUUUUUCK

.gitea/workflows/dev-branch.yaml

@@ -0,0 +1,59 @@
+name: Create tag and build when new code gets to main
+run-name: Create tag and build when new code gets to main
+on:
+  push:
+    branches:
+      - '**'        # matches every branch
+      - '!main'     # except main
+      - '!release/*'  # except release branches
+    tags-ignore:
+      - "**"
+
+env:
+  GAME_NAME: MovementTests
+  ITCHIO_USERNAME: Minimata
+  ITCHIO_GAMEID: MovementTests
+
+jobs:
+  Export:
+    runs-on: ubuntu-latest
+    env:
+      RUNNER_TOOL_CACHE: /toolcache # Runner Tool Cache
+    steps:
+      - name: Install node, xvfb and curl
+        run: |
+          apt update && apt -y install curl nodejs xvfb    
+
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          lfs: false
+          persist-credentials: true
+
+      - name: Checkout LFS
+        run: |
+          git lfs install --local
+          AUTH=$(git config http.${{ gitea.server_url }}/.extraheader)
+          AUTH_FILE=$(git config includeif.gitdir:/workspace/${{ gitea.repository }}/.git.path)
+          git config -f $AUTH_FILE --unset http.${{ gitea.server_url }}/.extraheader
+          git config -f $AUTH_FILE http.${{ gitea.server_url }}/${{ gitea.repository }}.git/info/lfs/objects/batch.extraheader "$AUTH"
+          git lfs pull
+          
+      - name: Run tests
+        uses: godot-gdunit-labs/gdUnit4-action@v1
+        with:
+          godot-version: '4.6.0'
+          godot-net: true
+          godot-force-mono: true
+          dotnet-version: 'net9.0'
+          paths: |
+            res://tests/
+          timeout: 1
+          publish-report: false
+          upload-report: false
+      
+      - name: Upload test report
+        uses: actions/upload-artifact@v3-node20
+        with:
+          name: Test Report
+          path: ${{ github.workspace }}/reports/test-result.html

.gitea/workflows/main.yaml

@@ -35,25 +35,116 @@ jobs:
           PRERELEASE: false
           INITIAL_VERSION: 0.1.0
           DEFAULT_BUMP: patch
+  
+#  Test:
+#    runs-on: ubuntu-latest
+#    env:
+#      RUNNER_TOOL_CACHE: /toolcache # Runner Tool Cache
+#    steps:
+#      - name: Install node, xvfb and curl
+#        run: |
+#          apt update && apt -y install curl nodejs xvfb    
+#
+#      - name: Checkout
+#        uses: actions/checkout@v6
+#        with:
+#          lfs: false
+#          persist-credentials: true
+#
+#      - name: Checkout LFS
+#        run: |
+#          git lfs install --local
+#          AUTH=$(git config http.${{ gitea.server_url }}/.extraheader)
+#          AUTH_FILE=$(git config includeif.gitdir:/workspace/${{ gitea.repository }}/.git.path)
+#          git config -f $AUTH_FILE --unset http.${{ gitea.server_url }}/.extraheader
+#          git config -f $AUTH_FILE http.${{ gitea.server_url }}/${{ gitea.repository }}.git/info/lfs/objects/batch.extraheader "$AUTH"
+#          git lfs pull
+#
+#      - name: Run tests
+#        uses: godot-gdunit-labs/gdUnit4-action@v1
+#        with:
+#          godot-version: '4.6.0'
+#          godot-net: true
+#          godot-force-mono: true
+#          dotnet-version: 'net9.0'
+#          paths: |
+#            res://tests/
+#          timeout: 1
+#          publish-report: false
+#          upload-report: false
+#
+#      - name: Upload test report
+#        uses: actions/upload-artifact@v3-node20
+#        with:
+#          name: Test Report
+#          path: ${{ github.workspace }}/reports/test-result.html
 
   Export:
     runs-on: ubuntu-latest
-    needs: BumpTag
+    env:
+      RUNNER_TOOL_CACHE: /toolcache # Runner Tool Cache
+    needs: 
+      - BumpTag
+#      - Test  # Wait for tests to finish
     container:
-      image: barichello/godot-ci:mono-4.5
+      image: barichello/godot-ci:mono-4.6
 
     steps:
       - name: Install node, curl and zip
         run: |
-          apt update && apt -y install curl zip nodejs          
-      - name: Checkout with LFS
-        uses: https://git.game-dev.space/minimata/checkout-with-lfs.git@main
+          apt update && apt -y install curl zip nodejs         
+
+      - name: Checkout
+        uses: actions/checkout@v3
         with:
-          checkout-version: 3
-            
+          lfs: false
+
+      - name: Checkout LFS
+        run: |
+          UrlBase=$GITHUB_SERVER_URL; \
+          UrlLfsBase=$UrlBase/${{ gitea.repository }}.git/info/lfs/objects; \
+          Auth=`/usr/bin/git config --get --local http.$UrlBase/.extraheader`; \
+          /usr/bin/git config --local http.${UrlLfsBase}/batch.extraheader "$Auth"; \
+          /usr/bin/git config --local http.${UrlLfsBase}/.extraheader ''
+
+          git config --local lfs.transfer.maxretries 1
+
+          /usr/bin/git lfs fetch    origin refs/remotes/origin/${{ gitea.ref_name }}
+          /usr/bin/git lfs checkout
+          /usr/bin/git add .
+          /usr/bin/git reset --hard
+        
+#      - name: Checkout
+#        uses: actions/checkout@v6
+#        with:
+#          lfs: false
+#          persist-credentials: true
+#
+#      - name: Checkout LFS
+#        run: |
+#          git lfs install --local
+#          AUTH=$(git config http.${{ gitea.server_url }}/.extraheader)
+#          AUTH_FILE=$(git config includeif.gitdir:/workspace/${{ gitea.repository }}/.git.path)
+#          git config -f $AUTH_FILE --unset http.${{ gitea.server_url }}/.extraheader
+#          git config -f $AUTH_FILE http.${{ gitea.server_url }}/${{ gitea.repository }}.git/info/lfs/objects/batch.extraheader "$AUTH"
+#          git lfs pull
+      
+      # GDUnit action replacement while waiting for 4.6 support
       - name: Import resources and build solution
         run: |
-          godot --headless --editor --build-solutions --quit --import --path $PWD          
+          godot --headless --editor --build-solutions --quit --import --path $PWD
+      - name: Run tests
+        run: |
+          godot --headless --path "$PWD" -s -d addons/gdUnit4/bin/GdUnitCmdTool.gd -a ./test -rd ./test/reports --ignoreHeadlessMode
+      - name: Upload test report
+        uses: actions/upload-artifact@v3-node20
+        with:
+          name: Test Report
+          path: ${{ github.workspace }}/reports/test-result.html
+          
+      - name: Remove GDUnit addon folder because it breaks the build
+        run: |
+          rm -rf ${{ gitea.workspace }}/addons/gdUnit4 
           
       - name: Build Windows
         run: |
@@ -69,48 +160,3 @@ jobs:
           buildNumber: ${{ needs.BumpTag.outputs.tag_name }}
           gameData: Windows.zip
           buildChannel: windows
-          
-      - name: Build Windows ARM
-        run: |
-          mkdir -v -p build/windowsArm
-          godot --headless --verbose --build-solutions --export-release "Windows ARM" build/windowsArm/${{ env.GAME_NAME }}.exe
-          zip -r WindowsArm.zip build/windowsArm
-      - name: Upload to Itch
-        uses: KikimoraGames/itch-publish@v0.0.3
-        with:
-          butlerApiKey: ${{ secrets.BUTLER_TOKEN }}
-          itchUsername: ${{ env.ITCHIO_USERNAME }}
-          itchGameId: ${{ env.ITCHIO_GAMEID }}
-          buildNumber: ${{ needs.BumpTag.outputs.tag_name }}
-          gameData: WindowsArm.zip
-          buildChannel: windows-arm
-          
-      - name: Linux Build
-        run: |
-          mkdir -v -p build/linux
-          godot --headless --verbose --export-release "Linux/X11" build/linux/${{ env.GAME_NAME }}.x86_64
-          zip -r Linux.zip build/linux
-      - name: Upload to Itch
-        uses: KikimoraGames/itch-publish@v0.0.3
-        with:
-          butlerApiKey: ${{ secrets.BUTLER_TOKEN }}
-          itchUsername: ${{ env.ITCHIO_USERNAME }}
-          itchGameId: ${{ env.ITCHIO_GAMEID }}
-          buildNumber: ${{ needs.BumpTag.outputs.tag_name }}
-          gameData: Linux.zip
-          buildChannel: linux
-          
-      - name: Mac Build
-        run: |
-          mkdir -v -p build/mac
-          godot --headless --verbose --export-release "macOS" build/mac/${{ env.GAME_NAME }}.zip
-          zip -r Mac.zip build/mac     
-      - name: Upload to Itch
-        uses: KikimoraGames/itch-publish@v0.0.3
-        with:
-          butlerApiKey: ${{ secrets.BUTLER_TOKEN }}
-          itchUsername: ${{ env.ITCHIO_USERNAME }}
-          itchGameId: ${{ env.ITCHIO_GAMEID }}
-          buildNumber: ${{ needs.BumpTag.outputs.tag_name }}
-          gameData: Mac.zip
-          buildChannel: mac

.gitea/workflows/release-branch.yaml

@@ -0,0 +1,119 @@
+name: Create tag and build when new code gets to main
+run-name: Create tag and build when new code gets to main
+on:
+  push:
+    branches:
+      - 'release/*'  # only release branches
+    tags-ignore:
+      - "**"
+
+env:
+  GAME_NAME: MovementTests
+  ITCHIO_USERNAME: Minimata
+  ITCHIO_GAMEID: MovementTests
+
+jobs:
+  ReleaseName:
+    runs-on: ubuntu-latest
+    if: ${{ contains(gitea.ref_name, 'release/') }}
+    outputs:
+      release_name: ${{ steps.split.outputs._1 }}
+    steps:
+      - uses: winterjung/split@v2
+        id: split
+        with:
+          msg: ${{ gitea.ref_name }}
+          separator: '/'
+
+  Release:
+    runs-on: ubuntu-latest
+    if: ${{ contains(gitea.ref_name, 'release/') }}
+    needs: ReleaseName
+    env:
+      RUNNER_TOOL_CACHE: /toolcache # Runner Tool Cache
+    container:
+      image: barichello/godot-ci:mono-4.6
+
+    steps:
+      - name: Install node, curl and zip
+        run: |
+          apt update && apt -y install curl zip nodejs         
+
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          lfs: false
+          persist-credentials: true
+
+      - name: Checkout LFS
+        run: |
+          git lfs install --local
+          AUTH=$(git config http.${{ gitea.server_url }}/.extraheader)
+          AUTH_FILE=$(git config includeif.gitdir:/workspace/${{ gitea.repository }}/.git.path)
+          git config -f $AUTH_FILE --unset http.${{ gitea.server_url }}/.extraheader
+          git config -f $AUTH_FILE http.${{ gitea.server_url }}/${{ gitea.repository }}.git/info/lfs/objects/batch.extraheader "$AUTH"
+          git lfs pull
+            
+      - name: Import resources and build solution
+        run: |
+          godot --headless --editor --build-solutions --quit --import --path $PWD          
+          
+      - name: Build Windows
+        run: |
+          mkdir -v -p build/windows
+          godot --headless --verbose --build-solutions --export-release "Windows Desktop" build/windows/${{ env.GAME_NAME }}.exe
+          zip -r Windows.zip build/windows
+      - name: Upload to Itch
+        uses: KikimoraGames/itch-publish@v0.0.3
+        with:
+          butlerApiKey: ${{ secrets.BUTLER_TOKEN }}
+          itchUsername: ${{ env.ITCHIO_USERNAME }}
+          itchGameId: ${{ env.ITCHIO_GAMEID }}
+          buildNumber: ${{ needs.ReleaseName.outputs.release_name }}
+          gameData: Windows.zip
+          buildChannel: windows
+          
+      - name: Build Windows ARM
+        run: |
+          mkdir -v -p build/windowsArm
+          godot --headless --verbose --build-solutions --export-release "Windows ARM" build/windowsArm/${{ env.GAME_NAME }}.exe
+          zip -r WindowsArm.zip build/windowsArm
+      - name: Upload to Itch
+        uses: KikimoraGames/itch-publish@v0.0.3
+        with:
+          butlerApiKey: ${{ secrets.BUTLER_TOKEN }}
+          itchUsername: ${{ env.ITCHIO_USERNAME }}
+          itchGameId: ${{ env.ITCHIO_GAMEID }}
+          buildNumber: ${{ needs.ReleaseName.outputs.release_name }}
+          gameData: WindowsArm.zip
+          buildChannel: windows-arm
+          
+      - name: Linux Build
+        run: |
+          mkdir -v -p build/linux
+          godot --headless --verbose --export-release "Linux/X11" build/linux/${{ env.GAME_NAME }}.x86_64
+          zip -r Linux.zip build/linux
+      - name: Upload to Itch
+        uses: KikimoraGames/itch-publish@v0.0.3
+        with:
+          butlerApiKey: ${{ secrets.BUTLER_TOKEN }}
+          itchUsername: ${{ env.ITCHIO_USERNAME }}
+          itchGameId: ${{ env.ITCHIO_GAMEID }}
+          buildNumber: ${{ needs.ReleaseName.outputs.release_name }}
+          gameData: Linux.zip
+          buildChannel: linux
+          
+      - name: Mac Build
+        run: |
+          mkdir -v -p build/mac
+          godot --headless --verbose --export-release "macOS" build/mac/${{ env.GAME_NAME }}.zip
+          zip -r Mac.zip build/mac     
+      - name: Upload to Itch
+        uses: KikimoraGames/itch-publish@v0.0.3
+        with:
+          butlerApiKey: ${{ secrets.BUTLER_TOKEN }}
+          itchUsername: ${{ env.ITCHIO_USERNAME }}
+          itchGameId: ${{ env.ITCHIO_GAMEID }}
+          buildNumber: ${{ needs.ReleaseName.outputs.release_name }}
+          gameData: Mac.zip
+          buildChannel: mac

.runsettings

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RunSettings>
+    <RunConfiguration>
+        <MaxCpuCount>1</MaxCpuCount>
+        <ResultsDirectory>./TestResults</ResultsDirectory>
+        <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+        <TestSessionTimeout>180000</TestSessionTimeout>
+        <TreatNoTestsAsError>true</TreatNoTestsAsError>
+        <EnvironmentVariables>
+            <GODOT_BIN>d:\development\Godot_v4.5-stable_mono_win64\Godot_v4.5-stable_mono_win64.exe</GODOT_BIN>
+        </EnvironmentVariables>
+    </RunConfiguration>
+
+    <LoggerRunSettings>
+        <Loggers>
+            <Logger friendlyName="console" enabled="True">
+                <Configuration>
+                    <Verbosity>detailed</Verbosity>
+                </Configuration>
+            </Logger>
+            <Logger friendlyName="html" enabled="True">
+                <Configuration>
+                    <LogFileName>test-result.html</LogFileName>
+                </Configuration>
+            </Logger>
+            <Logger friendlyName="trx" enabled="True">
+                <Configuration>
+                    <LogFileName>test-result.trx</LogFileName>
+                </Configuration>
+            </Logger>
+        </Loggers>
+    </LoggerRunSettings>
+
+    <GdUnit4>
+        <!-- Additional Godot runtime parameters. These are passed to the Godot executable when running tests.-->
+        <Parameters>"--verbose"</Parameters>
+  
+        <!-- Controls the display name format of test cases in the test results.
+                 Allowed values:
+                 - SimpleName: Uses only the method name (e.g., "TestMethod")
+                 - FullyQualifiedName: Uses the full path including class and method name (e.g., "MyNamespace.MyClass.TestMethod")
+                 Default: SimpleName -->
+        <DisplayName>FullyQualifiedName</DisplayName>
+  
+        <!-- When set to true, standard output (stdout) from test cases is captured
+                 and included in the test result. This can be useful for debugging. -->
+        <CaptureStdOut>true</CaptureStdOut>
+  
+        <!-- The maximum duration allowed for a Godot project compilation process in milliseconds.
+                         After this timeout period expires, the compilation process is forcefully terminated.
+                         For large or complex Godot projects, you may need to increase this value.
+                         Default: 20000 (20 seconds) -->
+        <CompileProcessTimeout>20000</CompileProcessTimeout>
+    </GdUnit4>
+</RunSettings>

Movement tests.csproj

@@ -1,10 +1,11 @@
-<Project Sdk="Godot.NET.Sdk/4.5.0">
+<Project Sdk="Godot.NET.Sdk/4.6.0">
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <EnableDynamicLoading>true</EnableDynamicLoading>
     <RootNamespace>Movementtests</RootNamespace>
   </PropertyGroup>
   <ItemGroup>
+    <Content Include=".runsettings" />
     <Content Include="export_presets.cfg" />
     <Content Include="menus\assets\git_logo\Git-Logo-2Color.png" />
     <Content Include="menus\assets\git_logo\Git-Logo-2Color.png.import" />
@@ -128,4 +129,14 @@
   <ItemGroup>
     <PackageReference Include="RustyOptions" Version="0.10.1" />
   </ItemGroup>
+  <!-- gdUnit4 package dependencies -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+    <PackageReference Include="gdUnit4.api" Version="5.1.0-rc3" />
+    <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>

Movement tests.csproj.old.1

@@ -0,0 +1,142 @@
+<Project Sdk="Godot.NET.Sdk/4.5.0">
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <EnableDynamicLoading>true</EnableDynamicLoading>
+    <RootNamespace>Movementtests</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <Content Include=".runsettings" />
+    <Content Include="export_presets.cfg" />
+    <Content Include="menus\assets\git_logo\Git-Logo-2Color.png" />
+    <Content Include="menus\assets\git_logo\Git-Logo-2Color.png.import" />
+    <Content Include="menus\assets\git_logo\LICENSE.txt" />
+    <Content Include="menus\assets\godot_engine_logo\LICENSE.txt" />
+    <Content Include="menus\assets\godot_engine_logo\logo_vertical_color_dark.png" />
+    <Content Include="menus\assets\godot_engine_logo\logo_vertical_color_dark.png.import" />
+    <Content Include="menus\assets\icon.png" />
+    <Content Include="menus\assets\icon.png.import" />
+    <Content Include="menus\ATTRIBUTION.md" />
+    <Content Include="menus\resources\themes\expedition.tres" />
+    <Content Include="menus\resources\themes\gravity.tres" />
+    <Content Include="menus\resources\themes\grow.tres" />
+    <Content Include="menus\resources\themes\lab.tres" />
+    <Content Include="menus\resources\themes\lore.tres" />
+    <Content Include="menus\resources\themes\steal_this_theme.tres" />
+    <Content Include="menus\scenes\credits\scrollable_credits.gd" />
+    <Content Include="menus\scenes\credits\scrollable_credits.gd.uid" />
+    <Content Include="menus\scenes\credits\scrollable_credits.tscn" />
+    <Content Include="menus\scenes\credits\scrolling_credits.gd" />
+    <Content Include="menus\scenes\credits\scrolling_credits.gd.uid" />
+    <Content Include="menus\scenes\credits\scrolling_credits.tscn" />
+    <Content Include="menus\scenes\end_credits\end_credits.gd" />
+    <Content Include="menus\scenes\end_credits\end_credits.gd.uid" />
+    <Content Include="menus\scenes\end_credits\end_credits.tscn" />
+    <Content Include="menus\scenes\game_scene\configurable_sub_viewport.gd" />
+    <Content Include="menus\scenes\game_scene\configurable_sub_viewport.gd.uid" />
+    <Content Include="menus\scenes\game_scene\game_ui.tscn" />
+    <Content Include="menus\scenes\game_scene\input_display_label.gd" />
+    <Content Include="menus\scenes\game_scene\input_display_label.gd.uid" />
+    <Content Include="menus\scenes\game_scene\levels\level.gd" />
+    <Content Include="menus\scenes\game_scene\levels\level.gd.uid" />
+    <Content Include="menus\scenes\game_scene\levels\level_1.tscn" />
+    <Content Include="menus\scenes\game_scene\levels\level_2.tscn" />
+    <Content Include="menus\scenes\game_scene\levels\level_3.tscn" />
+    <Content Include="menus\scenes\game_scene\tutorials\tutorial_1.tscn" />
+    <Content Include="menus\scenes\game_scene\tutorials\tutorial_2.tscn" />
+    <Content Include="menus\scenes\game_scene\tutorials\tutorial_3.tscn" />
+    <Content Include="menus\scenes\game_scene\tutorial_manager.gd" />
+    <Content Include="menus\scenes\game_scene\tutorial_manager.gd.uid" />
+    <Content Include="menus\scenes\loading_screen\level_loading_screen.tscn" />
+    <Content Include="menus\scenes\loading_screen\loading_screen.gd" />
+    <Content Include="menus\scenes\loading_screen\loading_screen.gd.uid" />
+    <Content Include="menus\scenes\loading_screen\loading_screen.tscn" />
+    <Content Include="menus\scenes\loading_screen\loading_screen_with_shader_caching.gd" />
+    <Content Include="menus\scenes\loading_screen\loading_screen_with_shader_caching.gd.uid" />
+    <Content Include="menus\scenes\loading_screen\loading_screen_with_shader_caching.tscn" />
+    <Content Include="menus\scenes\menus\level_select_menu\level_select_menu.gd" />
+    <Content Include="menus\scenes\menus\level_select_menu\level_select_menu.gd.uid" />
+    <Content Include="menus\scenes\menus\level_select_menu\level_select_menu.tscn" />
+    <Content Include="menus\scenes\menus\main_menu\main_menu.gd" />
+    <Content Include="menus\scenes\menus\main_menu\main_menu.gd.uid" />
+    <Content Include="menus\scenes\menus\main_menu\main_menu.tscn" />
+    <Content Include="menus\scenes\menus\main_menu\main_menu_with_animations.gd" />
+    <Content Include="menus\scenes\menus\main_menu\main_menu_with_animations.gd.uid" />
+    <Content Include="menus\scenes\menus\main_menu\main_menu_with_animations.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\audio\audio_input_option_control.gd" />
+    <Content Include="menus\scenes\menus\options_menu\audio\audio_input_option_control.gd.uid" />
+    <Content Include="menus\scenes\menus\options_menu\audio\audio_input_option_control.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\audio\audio_options_menu.gd" />
+    <Content Include="menus\scenes\menus\options_menu\audio\audio_options_menu.gd.uid" />
+    <Content Include="menus\scenes\menus\options_menu\audio\audio_options_menu.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\game\game_options_menu.gd" />
+    <Content Include="menus\scenes\menus\options_menu\game\game_options_menu.gd.uid" />
+    <Content Include="menus\scenes\menus\options_menu\game\game_options_menu.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\game\reset_game_control\reset_game_control.gd" />
+    <Content Include="menus\scenes\menus\options_menu\game\reset_game_control\reset_game_control.gd.uid" />
+    <Content Include="menus\scenes\menus\options_menu\game\reset_game_control\reset_game_control.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\input\input_extras_menu.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\input\input_options_menu.gd" />
+    <Content Include="menus\scenes\menus\options_menu\input\input_options_menu.gd.uid" />
+    <Content Include="menus\scenes\menus\options_menu\input\input_options_menu.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\input\input_options_menu_with_mouse_sensitivity.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\master_options_menu.gd" />
+    <Content Include="menus\scenes\menus\options_menu\master_options_menu.gd.uid" />
+    <Content Include="menus\scenes\menus\options_menu\master_options_menu.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\master_options_menu_with_tabs.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\mini_options_menu.gd" />
+    <Content Include="menus\scenes\menus\options_menu\mini_options_menu.gd.uid" />
+    <Content Include="menus\scenes\menus\options_menu\mini_options_menu.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\mini_options_menu_with_reset.gd" />
+    <Content Include="menus\scenes\menus\options_menu\mini_options_menu_with_reset.gd.uid" />
+    <Content Include="menus\scenes\menus\options_menu\mini_options_menu_with_reset.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\video\video_options_menu.gd" />
+    <Content Include="menus\scenes\menus\options_menu\video\video_options_menu.gd.uid" />
+    <Content Include="menus\scenes\menus\options_menu\video\video_options_menu.tscn" />
+    <Content Include="menus\scenes\menus\options_menu\video\video_options_menu_with_extras.tscn" />
+    <Content Include="menus\scenes\opening\opening.gd" />
+    <Content Include="menus\scenes\opening\opening.gd.uid" />
+    <Content Include="menus\scenes\opening\opening.tscn" />
+    <Content Include="menus\scenes\opening\opening_with_logo.tscn" />
+    <Content Include="menus\scenes\overlaid_menus\game_won_menu.gd" />
+    <Content Include="menus\scenes\overlaid_menus\game_won_menu.gd.uid" />
+    <Content Include="menus\scenes\overlaid_menus\game_won_menu.tscn" />
+    <Content Include="menus\scenes\overlaid_menus\level_lost_menu.gd" />
+    <Content Include="menus\scenes\overlaid_menus\level_lost_menu.gd.uid" />
+    <Content Include="menus\scenes\overlaid_menus\level_lost_menu.tscn" />
+    <Content Include="menus\scenes\overlaid_menus\level_won_menu.gd" />
+    <Content Include="menus\scenes\overlaid_menus\level_won_menu.gd.uid" />
+    <Content Include="menus\scenes\overlaid_menus\level_won_menu.tscn" />
+    <Content Include="menus\scenes\overlaid_menus\mini_options_overlaid_menu.tscn" />
+    <Content Include="menus\scenes\overlaid_menus\overlaid_menu.gd" />
+    <Content Include="menus\scenes\overlaid_menus\overlaid_menu.gd.uid" />
+    <Content Include="menus\scenes\overlaid_menus\overlaid_menu.tscn" />
+    <Content Include="menus\scenes\overlaid_menus\overlaid_menu_container.gd" />
+    <Content Include="menus\scenes\overlaid_menus\overlaid_menu_container.gd.uid" />
+    <Content Include="menus\scenes\overlaid_menus\overlaid_menu_container.tscn" />
+    <Content Include="menus\scenes\overlaid_menus\pause_menu.gd" />
+    <Content Include="menus\scenes\overlaid_menus\pause_menu.gd.uid" />
+    <Content Include="menus\scenes\overlaid_menus\pause_menu.tscn" />
+    <Content Include="menus\scripts\game_state.gd" />
+    <Content Include="menus\scripts\game_state.gd.uid" />
+    <Content Include="menus\scripts\level_list_and_state_manager.gd" />
+    <Content Include="menus\scripts\level_list_and_state_manager.gd.uid" />
+    <Content Include="menus\scripts\level_state.gd" />
+    <Content Include="menus\scripts\level_state.gd.uid" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="addons\" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="RustyOptions" Version="0.10.1" />
+  </ItemGroup>
+  <!-- gdUnit4 package dependencies -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0"/>
+    <PackageReference Include="gdUnit4.api" Version="5.1.0-rc3"/>
+    <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>

Movement tests.sln.DotSettings.user

@@ -1,9 +1,12 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AAction_00601_002Ecs_002Fl_003AC_0021_003FUsers_003FMinimata_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F7c0f83388bfc4d2c9d09befcec9dd79bc90908_003Fb8_003F4d300c4d_003FAction_00601_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AAction_00602_002Ecs_002Fl_003AC_0021_003FUsers_003FMinimata_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F7c0f83388bfc4d2c9d09befcec9dd79bc90908_003F87_003Fded27e2d_003FAction_00602_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
-	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ACharacterBody3D_002Ecs_002Fl_003AC_0021_003FUsers_003FMinimata_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FSourcesCache_003Fe56b84c3fa498fb86fc1eba376f62f482127e3fe80415c5fb2acde2bf6d89793_003FCharacterBody3D_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEnemy_005FScriptMethods_002Egenerated_002Ecs_002Fl_003AC_0021_003FUsers_003FMinimata_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FSourcesCache_003F8e71dc81611862c01a2cb998a1f327de14747655_003FEnemy_005FScriptMethods_002Egenerated_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ANode_002Ecs_002Fl_003AC_0021_003FUsers_003FMinimata_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FSourcesCache_003F716d154fef5cbe863cd637bd32beda6e3cec5f12e8fed2dc5b2d8149a0d558ab_003FNode_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ANode_002Ecs_002Fl_003AC_0021_003FUsers_003FMinimata_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FSourcesCache_003Fdf73a4db74df89d59655c5fb6326406f47fbfa9af1fa81518fe0a07c49d34133_003FNode_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ASceneTree_002Ecs_002Fl_003AC_0021_003FUsers_003FMinimata_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FSourcesCache_003F8d6960554e939a669841b1ece03d27df4ab42f92bb80be3767eaec8cdaccf84b_003FSceneTree_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=dd9a7ac6_002Dbb9b_002D4001_002Db145_002D15e6509b7e78/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" IsActive="True" Name="All tests from Solution" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;&#xD;
+  &lt;Solution /&gt;&#xD;
+&lt;/SessionState&gt;</s:String>
+	<s:String x:Key="/Default/Housekeeping/UnitTestingMru/UnitTestRunner/RunConfigurationFilename/@EntryValue">D:\Godot\Projects\movement-tests\.runsettings</s:String>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=floorplane/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

addons/gdUnit4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Mike Schulze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

addons/gdUnit4/bin/GdUnitCmdTool.gd

@@ -0,0 +1,21 @@
+#!/usr/bin/env -S godot -s
+extends SceneTree
+
+
+var _cli_runner: GdUnitTestCIRunner
+
+
+func _initialize() -> void:
+	DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_MINIMIZED)
+	_cli_runner = GdUnitTestCIRunner.new()
+	root.add_child(_cli_runner)
+
+
+# do not use print statements on _finalize it results in random crashes
+func _finalize() -> void:
+	queue_delete(_cli_runner)
+	if OS.is_stdout_verbose():
+		prints("Finallize ..")
+		prints("-Orphan nodes report-----------------------")
+		Window.print_orphan_nodes()
+		prints("Finallize .. done")

addons/gdUnit4/bin/GdUnitCmdTool.gd.uid

@@ -0,0 +1 @@
+uid://i04mdqgjjfsa

addons/gdUnit4/bin/GdUnitCopyLog.gd

@@ -0,0 +1,167 @@
+#!/usr/bin/env -S godot -s
+extends MainLoop
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+# gdlint: disable=max-line-length
+const LOG_FRAME_TEMPLATE = """
+<!DOCTYPE html>
+<html style="display: inline-grid;">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Godot Logging</title>
+	<link rel="stylesheet" href="css/styles.css">
+</head>
+
+<body style="background-color: #eee;">
+	<div class="godot-report-frame"">
+${content}
+	</div>
+</body>
+</html>
+"""
+
+const NO_LOG_MESSAGE = """
+<h3>No logging available!</h3>
+</br>
+<p>In order for logging to take place, you must activate the Activate file logging option in the project settings.</p>
+<p>You can enable the logging under:
+<b>Project Settings</b> > <b>Debug</b> > <b>File Logging</b> > <b>Enable File Logging</b> in the project settings.</p>
+"""
+
+#warning-ignore-all:return_value_discarded
+var _cmd_options := CmdOptions.new([
+		CmdOption.new(
+			"-rd, --report-directory",
+			"-rd <directory>",
+			"Specifies the output directory in which the reports are to be written. The default is res://reports/.",
+			TYPE_STRING,
+			true
+		)
+	])
+
+
+var _report_root_path: String
+var _current_report_path: String
+var _debug_cmd_args := PackedStringArray()
+
+
+func _init() -> void:
+	set_report_directory(GdUnitFileAccess.current_dir() + "reports")
+	set_current_report_path()
+
+
+func _process(_delta: float) -> bool:
+	# check if reports exists
+	if not reports_available():
+		prints("no reports found")
+		return true
+
+	# only process if godot logging is enabled
+	if not GdUnitSettings.is_log_enabled():
+		write_report(NO_LOG_MESSAGE, "")
+		return true
+
+	# parse possible custom report path,
+	var cmd_parser := CmdArgumentParser.new(_cmd_options, "GdUnitCmdTool.gd")
+	# ignore erros and exit quitly
+	if cmd_parser.parse(get_cmdline_args(), true).is_error():
+		return true
+	CmdCommandHandler.new(_cmd_options).register_cb("-rd", set_report_directory)
+
+	var godot_log_file := scan_latest_godot_log()
+	var result := read_log_file_content(godot_log_file)
+	if result.is_error():
+		write_report(result.error_message(), godot_log_file)
+		return true
+	write_report(result.value_as_string(), godot_log_file)
+	return true
+
+
+func set_current_report_path() -> void:
+	# scan for latest report directory
+	var iteration := GdUnitFileAccess.find_last_path_index(
+		_report_root_path, GdUnitConstants.REPORT_DIR_PREFIX
+	)
+	_current_report_path = "%s/%s%d" % [_report_root_path, GdUnitConstants.REPORT_DIR_PREFIX, iteration]
+
+
+func set_report_directory(path: String) -> void:
+	_report_root_path = path
+
+
+func get_log_report_html() -> String:
+	return _current_report_path + "/godot_report_log.html"
+
+
+func reports_available() -> bool:
+	return DirAccess.dir_exists_absolute(_report_root_path)
+
+
+func scan_latest_godot_log() -> String:
+	var path := GdUnitSettings.get_log_path().get_base_dir()
+	var files_sorted := Array()
+	for file in GdUnitFileAccess.scan_dir(path):
+		var file_name := "%s/%s" % [path, file]
+		files_sorted.append(file_name)
+	# sort by name, the name contains the timestamp so we sort at the end by timestamp
+	files_sorted.sort()
+	return files_sorted.back()
+
+
+func read_log_file_content(log_file: String) -> GdUnitResult:
+	var file := FileAccess.open(log_file, FileAccess.READ)
+	if file == null:
+		return GdUnitResult.error(
+			"Can't find log file '%s'. Error: %s"
+			% [log_file, error_string(FileAccess.get_open_error())]
+		)
+	var content := "<pre>" + file.get_as_text()
+	# patch out console format codes
+	for color_index in range(0, 256):
+		var to_replace := "[38;5;%dm" % color_index
+		content = content.replace(to_replace, "")
+	content += "</pre>"
+	content = content\
+		.replace("", "")\
+		.replace(GdUnitCSIMessageWriter.CSI_BOLD, "")\
+		.replace(GdUnitCSIMessageWriter.CSI_ITALIC, "")\
+		.replace(GdUnitCSIMessageWriter.CSI_UNDERLINE, "")
+	return GdUnitResult.success(content)
+
+
+func write_report(content: String, godot_log_file: String) -> GdUnitResult:
+	var file := FileAccess.open(get_log_report_html(), FileAccess.WRITE)
+	if file == null:
+		return GdUnitResult.error(
+			"Can't open to write '%s'. Error: %s"
+			% [get_log_report_html(), error_string(FileAccess.get_open_error())]
+		)
+	var report_html := LOG_FRAME_TEMPLATE.replace("${content}", content)
+	file.store_string(report_html)
+	_update_index_html(godot_log_file)
+	return GdUnitResult.success(file)
+
+
+func _update_index_html(godot_log_file: String) -> void:
+	var index_path := "%s/index.html" % _current_report_path
+	var index_file := FileAccess.open(index_path, FileAccess.READ_WRITE)
+	if index_file == null:
+		push_error(
+			"Can't add log path '%s' to `%s`. Error: %s"
+			% [godot_log_file, index_path, error_string(FileAccess.get_open_error())]
+		)
+		return
+	var content := index_file.get_as_text()\
+		.replace("${log_report}", get_log_report_html())\
+		.replace("${godot_log_file}", godot_log_file)
+	# overide it
+	index_file.seek(0)
+	index_file.store_string(content)
+
+
+func get_cmdline_args() -> PackedStringArray:
+	if _debug_cmd_args.is_empty():
+		return OS.get_cmdline_args()
+	return _debug_cmd_args

addons/gdUnit4/bin/GdUnitCopyLog.gd.uid

@@ -0,0 +1 @@
+uid://lcya8t25hn0j

addons/gdUnit4/plugin.cfg

@@ -0,0 +1,7 @@
+[plugin]
+
+name="gdUnit4"
+description="Unit Testing Framework for Godot Scripts"
+author="Mike Schulze"
+version="6.1.0"
+script="plugin.gd"

addons/gdUnit4/plugin.gd

@@ -0,0 +1,101 @@
+@tool
+extends EditorPlugin
+
+var _gd_inspector: Control
+var _gd_console: Control
+var _filesystem_context_menu: EditorContextMenuPlugin
+var _editor_context_menu: EditorContextMenuPlugin
+var _editor_code_context_menu: EditorContextMenuPlugin
+
+
+func _enter_tree() -> void:
+	var inferred_declaration: int = ProjectSettings.get_setting("debug/gdscript/warnings/inferred_declaration")
+
+	var is_gdunit_excluded_warnings: bool = false
+	if Engine.get_version_info().hex >= 0x40600:
+		var dirctrory_rules: Dictionary = ProjectSettings.get_setting("debug/gdscript/warnings/directory_rules")
+		if dirctrory_rules.has("res://addons/gdUnit4") and dirctrory_rules["res://addons/gdUnit4"] == 0:
+			is_gdunit_excluded_warnings = true
+	else:
+		is_gdunit_excluded_warnings = ProjectSettings.get_setting("debug/gdscript/warnings/exclude_addons")
+	if !is_gdunit_excluded_warnings and inferred_declaration != 0:
+		printerr("GdUnit4: 'inferred_declaration' is set to Warning/Error!")
+		if Engine.get_version_info().hex >= 0x40600:
+			printerr("GdUnit4 is not 'inferred_declaration' save, you have to excluded the addon (debug/gdscript/warnings/directory_rules)")
+		else:
+			printerr("GdUnit4 is not 'inferred_declaration' save, you have to excluded addons (debug/gdscript/warnings/exclude_addons)")
+		printerr("Loading GdUnit4 Plugin failed.")
+		return
+
+	if check_running_in_test_env():
+		@warning_ignore("return_value_discarded")
+		GdUnitCSIMessageWriter.new().prints_warning("It was recognized that GdUnit4 is running in a test environment, therefore the GdUnit4 plugin will not be executed!")
+		return
+
+	if Engine.get_version_info().hex < 0x40500:
+		prints("This GdUnit4 plugin version '%s' requires Godot version '4.5' or higher to run." % GdUnit4Version.current())
+		return
+	GdUnitSettings.setup()
+	# Install the GdUnit Inspector
+	_gd_inspector = (load("res://addons/gdUnit4/src/ui/GdUnitInspector.tscn") as PackedScene).instantiate()
+	_add_context_menus()
+	add_control_to_dock(EditorPlugin.DOCK_SLOT_LEFT_UR, _gd_inspector)
+	# Install the GdUnit Console
+	_gd_console = (load("res://addons/gdUnit4/src/ui/GdUnitConsole.tscn") as PackedScene).instantiate()
+	var control: Control = add_control_to_bottom_panel(_gd_console, "gdUnitConsole")
+	@warning_ignore("unsafe_method_access")
+	await _gd_console.setup_update_notification(control)
+	if GdUnit4CSharpApiLoader.is_api_loaded():
+		prints("GdUnit4Net version '%s' loaded." % GdUnit4CSharpApiLoader.version())
+	else:
+		prints("No GdUnit4Net found.")
+	# Connect to be notified for script changes to be able to discover new tests
+	GdUnitTestDiscoverGuard.instance()
+	@warning_ignore("return_value_discarded")
+	resource_saved.connect(_on_resource_saved)
+	prints("Loading GdUnit4 Plugin success")
+
+
+func _exit_tree() -> void:
+	if check_running_in_test_env():
+		return
+	if is_instance_valid(_gd_inspector):
+		remove_control_from_docks(_gd_inspector)
+		_gd_inspector.free()
+	_remove_context_menus()
+	if is_instance_valid(_gd_console):
+		remove_control_from_bottom_panel(_gd_console)
+		_gd_console.free()
+	var gdUnitTools: GDScript = load("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+	@warning_ignore("unsafe_method_access")
+	gdUnitTools.dispose_all(true)
+	prints("Unload GdUnit4 Plugin success")
+
+
+func check_running_in_test_env() -> bool:
+	var args: PackedStringArray = OS.get_cmdline_args()
+	args.append_array(OS.get_cmdline_user_args())
+	return DisplayServer.get_name() == "headless" or args.has("--selftest") or args.has("--add") or args.has("-a") or args.has("--quit-after") or args.has("--import")
+
+
+func _add_context_menus() -> void:
+	_filesystem_context_menu = preload("res://addons/gdUnit4/src/ui/menu/GdUnitEditorFileSystemContextMenuHandler.gd").new()
+	_editor_context_menu = preload("res://addons/gdUnit4/src/ui/menu/GdUnitScriptEditorContextMenuHandler.gd").new()
+	_editor_code_context_menu = preload("res://addons/gdUnit4/src/ui/menu/GdUnitScriptEditorContextMenuHandler.gd").new()
+	add_context_menu_plugin(EditorContextMenuPlugin.CONTEXT_SLOT_FILESYSTEM, _filesystem_context_menu)
+	add_context_menu_plugin(EditorContextMenuPlugin.CONTEXT_SLOT_SCRIPT_EDITOR, _editor_context_menu)
+	add_context_menu_plugin(EditorContextMenuPlugin.CONTEXT_SLOT_SCRIPT_EDITOR_CODE, _editor_code_context_menu)
+
+
+func _remove_context_menus() -> void:
+	if is_instance_valid(_filesystem_context_menu):
+		remove_context_menu_plugin(_filesystem_context_menu)
+	if is_instance_valid(_editor_context_menu):
+		remove_context_menu_plugin(_editor_context_menu)
+	if is_instance_valid(_editor_code_context_menu):
+		remove_context_menu_plugin(_editor_code_context_menu)
+
+
+func _on_resource_saved(resource: Resource) -> void:
+	if resource is Script:
+		await GdUnitTestDiscoverGuard.instance().discover(resource as Script)

addons/gdUnit4/plugin.gd.uid

@@ -0,0 +1 @@
+uid://8wxua8uw7x7k

addons/gdUnit4/runtest.cmd

@@ -0,0 +1,62 @@
+@echo off
+setlocal enabledelayedexpansion
+
+:: Initialize variables
+set "godot_binary="
+set "filtered_args="
+
+:: Process all arguments
+set "i=0"
+:parse_args
+if "%~1"=="" goto end_parse_args
+
+if "%~1"=="--godot_binary" (
+    set "godot_binary=%~2"
+    shift
+    shift
+) else (
+    set "filtered_args=!filtered_args! %~1"
+    shift
+)
+goto parse_args
+:end_parse_args
+
+:: If --godot_binary wasn't provided, fallback to environment variable
+if "!godot_binary!"=="" (
+    set "godot_binary=%GODOT_BIN%"
+)
+
+:: Check if we have a godot_binary value from any source
+if "!godot_binary!"=="" (
+    echo Godot binary path is not specified.
+    echo Please either:
+    echo   - Set the environment variable: set GODOT_BIN=C:\path\to\godot.exe
+    echo   - Or use the --godot_binary argument: --godot_binary C:\path\to\godot.exe
+    exit /b 1
+)
+
+:: Check if the Godot binary exists
+if not exist "!godot_binary!" (
+    echo Error: The specified Godot binary '!godot_binary!' does not exist.
+    exit /b 1
+)
+
+:: Get Godot version and check if it's a mono build
+for /f "tokens=*" %%i in ('"!godot_binary!" --version') do set GODOT_VERSION=%%i
+echo !GODOT_VERSION! | findstr /I "mono" >nul
+if !errorlevel! equ 0 (
+    echo Godot .NET detected
+    echo Compiling c# classes ... Please Wait
+    dotnet build --debug
+    echo done !errorlevel!
+)
+
+:: Run the tests with the filtered arguments
+"!godot_binary!" --path . -s -d res://addons/gdUnit4/bin/GdUnitCmdTool.gd !filtered_args!
+set exit_code=%ERRORLEVEL%
+echo Run tests ends with %exit_code%
+
+:: Run the copy log command
+"!godot_binary!" --headless --path . --quiet -s res://addons/gdUnit4/bin/GdUnitCopyLog.gd !filtered_args! > nul
+set exit_code2=%ERRORLEVEL%
+exit /b %exit_code%

addons/gdUnit4/runtest.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+# Check for command-line argument
+godot_binary=""
+filtered_args=""
+
+# Process all arguments with a more compatible approach
+while [ $# -gt 0 ]; do
+    if [ "$1" = "--godot_binary" ] && [ $# -gt 1 ]; then
+        # Get the next argument as the value
+        godot_binary="$2"
+        shift 2
+    else
+        # Keep non-godot_binary arguments for passing to Godot
+        filtered_args="$filtered_args $1"
+        shift
+    fi
+done
+
+# If --godot_binary wasn't provided, fallback to environment variable
+if [ -z "$godot_binary" ]; then
+    godot_binary="$GODOT_BIN"
+fi
+
+# Check if we have a godot_binary value from any source
+if [ -z "$godot_binary" ]; then
+    echo "Godot binary path is not specified."
+    echo "Please either:"
+    echo "  - Set the environment variable: export GODOT_BIN=/path/to/godot"
+    echo "  - Or use the --godot_binary argument: --godot_binary /path/to/godot"
+    exit 1
+fi
+
+# Check if the Godot binary exists and is executable
+if [ ! -f "$godot_binary" ]; then
+    echo "Error: The specified Godot binary '$godot_binary' does not exist."
+    exit 1
+fi
+
+if [ ! -x "$godot_binary" ]; then
+    echo "Error: The specified Godot binary '$godot_binary' is not executable."
+    exit 1
+fi
+
+# Get Godot version and check if it's a .NET build
+GODOT_VERSION=$("$godot_binary" --version)
+if echo "$GODOT_VERSION" | grep -i "mono" > /dev/null; then
+    echo "Godot .NET detected"
+    echo "Compiling c# classes ... Please Wait"
+    dotnet build --debug
+    echo "done $?"
+fi
+
+# Run the tests with the filtered arguments
+"$godot_binary" --path . -s -d res://addons/gdUnit4/bin/GdUnitCmdTool.gd $filtered_args
+exit_code=$?
+echo "Run tests ends with $exit_code"
+
+# Run the copy log command
+"$godot_binary" --headless --path . --quiet -s res://addons/gdUnit4/bin/GdUnitCopyLog.gd $filtered_args > /dev/null
+exit_code2=$?
+exit $exit_code

addons/gdUnit4/src/Comparator.gd

@@ -0,0 +1,12 @@
+class_name Comparator
+extends Resource
+
+enum {
+	EQUAL,
+	LESS_THAN,
+	LESS_EQUAL,
+	GREATER_THAN,
+	GREATER_EQUAL,
+	BETWEEN_EQUAL,
+	NOT_BETWEEN_EQUAL,
+}

addons/gdUnit4/src/Comparator.gd.uid

@@ -0,0 +1 @@
+uid://duj13ipuced2q

addons/gdUnit4/src/Fuzzers.gd

@@ -0,0 +1,80 @@
+## Factory class providing convenient static methods to create various fuzzer instances.[br]
+##
+## Fuzzers is a utility class that simplifies the creation of different fuzzer types
+## for testing purposes. It provides static factory methods that create pre-configured
+## fuzzers with sensible defaults, making it easier to set up fuzz testing in your
+## test suites without manually instantiating each fuzzer type.[br]
+##
+## This class acts as a central access point for all fuzzer types, improving code
+## readability and reducing boilerplate in test cases.[br]
+##
+## @tutorial(Fuzzing Testing): https://en.wikipedia.org/wiki/Fuzzing
+class_name Fuzzers
+extends Resource
+
+
+## Generates random strings with length between [param min_length] and
+## [param max_length] (inclusive), using characters from [param charset].
+## See [StringFuzzer] for detailed documentation and examples.
+static func rand_str(min_length: int, max_length: int, charset := StringFuzzer.DEFAULT_CHARSET) -> StringFuzzer:
+	return StringFuzzer.new(min_length, max_length, charset)
+
+
+## Creates a [BoolFuzzer] for generating random boolean values.[br]
+##
+## See [BoolFuzzer] for detailed documentation and examples.
+static func boolean() -> BoolFuzzer:
+	return BoolFuzzer.new()
+
+
+## Creates an [IntFuzzer] for generating random integers within a range.[br]
+##
+## Generates random integers between [param from] and [param to] (inclusive)
+## using [constant IntFuzzer.NORMAL] mode.
+## See [IntFuzzer] for detailed documentation and examples.
+static func rangei(from: int, to: int) -> IntFuzzer:
+	return IntFuzzer.new(from, to)
+
+
+## Creates a [FloatFuzzer] for generating random floats within a range.[br]
+##
+## Generates random float values between [param from] and [param to] (inclusive).
+## See [FloatFuzzer] for detailed documentation and examples.
+static func rangef(from: float, to: float) -> FloatFuzzer:
+	return FloatFuzzer.new(from, to)
+
+
+## Creates a [Vector2Fuzzer] for generating random 2D vectors within a range.[br]
+##
+## Generates random Vector2 values where each component is bounded by
+## [param from] and [param to] (inclusive).
+## See [Vector2Fuzzer] for detailed documentation and examples.
+static func rangev2(from: Vector2, to: Vector2) -> Vector2Fuzzer:
+	return Vector2Fuzzer.new(from, to)
+
+
+## Creates a [Vector3Fuzzer] for generating random 3D vectors within a range.[br]
+##
+## Generates random Vector3 values where each component is bounded by
+## [param from] and [param to] (inclusive).
+## See [Vector3Fuzzer] for detailed documentation and examples.
+static func rangev3(from: Vector3, to: Vector3) -> Vector3Fuzzer:
+	return Vector3Fuzzer.new(from, to)
+
+
+## Creates an [IntFuzzer] that generates only even integers.[br]
+##
+## Generates random even integers between [param from] and [param to] (inclusive)
+## using [constant IntFuzzer.EVEN] mode.
+## See [IntFuzzer] for detailed documentation about even number generation.
+static func eveni(from: int, to: int) -> IntFuzzer:
+	return IntFuzzer.new(from, to, IntFuzzer.EVEN)
+
+
+## Creates an [IntFuzzer] that generates only odd integers.[br]
+##
+## Generates random odd integers between [param from] and [param to] (inclusive)
+## using [constant IntFuzzer.ODD] mode.
+## See [IntFuzzer] for detailed documentation about odd number generation.
+static func oddi(from: int, to: int) -> IntFuzzer:
+	return IntFuzzer.new(from, to, IntFuzzer.ODD)

addons/gdUnit4/src/Fuzzers.gd.uid

@@ -0,0 +1 @@
+uid://wd2ydmpylh1e

addons/gdUnit4/src/GdUnitArrayAssert.gd

@@ -0,0 +1,122 @@
+## An Assertion Tool to verify array values
+@abstract class_name GdUnitArrayAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitArrayAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitArrayAssert
+
+
+## Verifies that the current Array is equal to the given one.
+@abstract func is_equal(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array is equal to the given one, ignoring case considerations.
+@abstract func is_equal_ignoring_case(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array is not equal to the given one.
+@abstract func is_not_equal(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array is not equal to the given one, ignoring case considerations.
+@abstract func is_not_equal_ignoring_case(...expected: Array) -> GdUnitArrayAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitArrayAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array is empty, it has a size of 0.
+@abstract func is_empty() -> GdUnitArrayAssert
+
+
+## Verifies that the current Array is not empty, it has a size of minimum 1.
+@abstract func is_not_empty() -> GdUnitArrayAssert
+
+
+## Verifies that the current Array is the same. [br]
+## Compares the current by object reference equals
+@abstract func is_same(expected: Variant) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array is NOT the same. [br]
+## Compares the current by object reference equals
+@abstract func is_not_same(expected: Variant) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array has a size of given value.
+@abstract func has_size(expectd: int) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array contains the given values, in any order.[br]
+## The values are compared by deep parameter comparision, for object reference compare you have to use [method contains_same]
+@abstract func contains(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array contains exactly only the given values and nothing else, in same order.[br]
+## The values are compared by deep parameter comparision, for object reference compare you have to use [method contains_same_exactly]
+@abstract func contains_exactly(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array contains exactly only the given values and nothing else, in any order.[br]
+## The values are compared by deep parameter comparision, for object reference compare you have to use [method contains_same_exactly_in_any_order]
+@abstract func contains_exactly_in_any_order(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array contains the given values, in any order.[br]
+## The values are compared by object reference, for deep parameter comparision use [method contains]
+@abstract func contains_same(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array contains exactly only the given values and nothing else, in same order.[br]
+## The values are compared by object reference, for deep parameter comparision use [method contains_exactly]
+@abstract func contains_same_exactly(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array contains exactly only the given values and nothing else, in any order.[br]
+## The values are compared by object reference, for deep parameter comparision use [method contains_exactly_in_any_order]
+@abstract func contains_same_exactly_in_any_order(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array do NOT contains the given values, in any order.[br]
+## The values are compared by deep parameter comparision, for object reference compare you have to use [method not_contains_same]
+## [b]Example:[/b]
+## [codeblock]
+## # will succeed
+## assert_array([1, 2, 3, 4, 5]).not_contains(6)
+## # will fail
+## assert_array([1, 2, 3, 4, 5]).not_contains(2, 6)
+## [/codeblock]
+@abstract func not_contains(...expected: Array) -> GdUnitArrayAssert
+
+
+## Verifies that the current Array do NOT contains the given values, in any order.[br]
+## The values are compared by object reference, for deep parameter comparision use [method not_contains]
+## [b]Example:[/b]
+## [codeblock]
+## # will succeed
+## assert_array([1, 2, 3, 4, 5]).not_contains(6)
+## # will fail
+## assert_array([1, 2, 3, 4, 5]).not_contains(2, 6)
+## [/codeblock]
+@abstract func not_contains_same(...expected: Array) -> GdUnitArrayAssert
+
+
+## Extracts all values by given function name and optional arguments into a new ArrayAssert.
+## If the elements not accessible by `func_name` the value is converted to `"n.a"`, expecting null values
+@abstract func extract(func_name: String, ...func_args: Array) -> GdUnitArrayAssert
+
+
+## Extracts all values by given extractor's into a new ArrayAssert.
+## If the elements not extractable than the value is converted to `"n.a"`, expecting null values
+## -- The argument type is Array[GdUnitValueExtractor]
+@abstract func extractv(...extractors: Array) -> GdUnitArrayAssert

addons/gdUnit4/src/GdUnitArrayAssert.gd.uid

@@ -0,0 +1 @@
+uid://bwaeyokx1kgfd

addons/gdUnit4/src/GdUnitAssert.gd

@@ -0,0 +1,47 @@
+## Base interface of all GdUnit asserts
+@abstract class_name GdUnitAssert
+extends RefCounted
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitAssert
+
+
+## Verifies that the current value is equal to expected one.
+@abstract func is_equal(expected: Variant) -> GdUnitAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitAssert
+
+
+## Overrides the default failure message by given custom message.[br]
+## This function allows you to replace the automatically generated failure message with a more specific
+## or user-friendly message that better describes the test failure context.[br]
+## Usage:
+##     [codeblock]
+##		# Override with custom context-specific message
+##		func test_player_inventory():
+##		    assert_that(player.get_item_count("sword"))\
+##		        .override_failure_message("Player should have exactly one sword")\
+##		        .is_equal(1)
+##     [/codeblock]
+@abstract func override_failure_message(message: String) -> GdUnitAssert
+
+
+## Appends a custom message to the failure message.[br]
+## This can be used to add additional information to the generated failure message
+## while keeping the original assertion details for better debugging context.[br]
+## Usage:
+##     [codeblock]
+##		# Add context to existing failure message
+##		func test_player_health():
+##		    assert_that(player.health)\
+##		        .append_failure_message("Player was damaged by: %s" % last_damage_source)\
+##		        .is_greater(0)
+##     [/codeblock]
+@abstract func append_failure_message(message: String) -> GdUnitAssert

addons/gdUnit4/src/GdUnitAssert.gd.uid

@@ -0,0 +1 @@
+uid://qqwrtj2mj3xi

addons/gdUnit4/src/GdUnitAwaiter.gd

@@ -0,0 +1,72 @@
+class_name GdUnitAwaiter
+extends RefCounted
+
+
+# Waits for a specified signal in an interval of 50ms sent from the <source>, and terminates with an error after the specified timeout has elapsed.
+# source: the object from which the signal is emitted
+# signal_name: signal name
+# args: the expected signal arguments as an array
+# timeout: the timeout in ms, default is set to 2000ms
+func await_signal_on(source :Object, signal_name :String, args :Array = [], timeout_millis :int = 2000) -> Variant:
+	# fail fast if the given source instance invalid
+	var assert_that := GdUnitAssertImpl.new(signal_name)
+	var line_number := GdUnitAssertions.get_line_number()
+	if not is_instance_valid(source):
+		@warning_ignore("return_value_discarded")
+		assert_that.report_error(GdAssertMessages.error_await_signal_on_invalid_instance(source, signal_name, args), line_number)
+		return await (Engine.get_main_loop() as SceneTree).process_frame
+	# fail fast if the given source instance invalid
+	if not is_instance_valid(source):
+		@warning_ignore("return_value_discarded")
+		assert_that.report_error(GdAssertMessages.error_await_signal_on_invalid_instance(source, signal_name, args), line_number)
+		return await await_idle_frame()
+	var awaiter := GdUnitSignalAwaiter.new(timeout_millis)
+	var value :Variant = await awaiter.on_signal(source, signal_name, args)
+	if awaiter.is_interrupted():
+		var failure := "await_signal_on(%s, %s) timed out after %sms" % [signal_name, args, timeout_millis]
+		@warning_ignore("return_value_discarded")
+		assert_that.report_error(failure, line_number)
+	return value
+
+
+# Waits for a specified signal sent from the <source> between idle frames and aborts with an error after the specified timeout has elapsed
+# source: the object from which the signal is emitted
+# signal_name: signal name
+# args: the expected signal arguments as an array
+# timeout: the timeout in ms, default is set to 2000ms
+func await_signal_idle_frames(source :Object, signal_name :String, args :Array = [], timeout_millis :int = 2000) -> Variant:
+	var line_number := GdUnitAssertions.get_line_number()
+	# fail fast if the given source instance invalid
+	if not is_instance_valid(source):
+		@warning_ignore("return_value_discarded")
+		GdUnitAssertImpl.new(signal_name)\
+			.report_error(GdAssertMessages.error_await_signal_on_invalid_instance(source, signal_name, args), line_number)
+		return await await_idle_frame()
+	var awaiter := GdUnitSignalAwaiter.new(timeout_millis, true)
+	var value :Variant = await awaiter.on_signal(source, signal_name, args)
+	if awaiter.is_interrupted():
+		var failure := "await_signal_idle_frames(%s, %s) timed out after %sms" % [signal_name, args, timeout_millis]
+		@warning_ignore("return_value_discarded")
+		GdUnitAssertImpl.new(signal_name).report_error(failure, line_number)
+	return value
+
+
+# Waits for for a given amount of milliseconds
+# example:
+#    # waits for 100ms
+#    await GdUnitAwaiter.await_millis(myNode, 100).completed
+# use this waiter and not `await get_tree().create_timer().timeout to prevent errors when a test case is timed out
+func await_millis(milliSec :int) -> void:
+	var timer :Timer = Timer.new()
+	timer.set_name("gdunit_await_millis_timer_%d" % timer.get_instance_id())
+	(Engine.get_main_loop() as SceneTree).root.add_child(timer)
+	timer.add_to_group("GdUnitTimers")
+	timer.set_one_shot(true)
+	timer.start(milliSec / 1000.0)
+	await timer.timeout
+	timer.queue_free()
+
+
+# Waits until the next idle frame
+func await_idle_frame() -> void:
+	await (Engine.get_main_loop() as SceneTree).process_frame

addons/gdUnit4/src/GdUnitAwaiter.gd.uid

@@ -0,0 +1 @@
+uid://fnv7o85xbiiq

addons/gdUnit4/src/GdUnitBoolAssert.gd

@@ -0,0 +1,35 @@
+## An Assertion Tool to verify boolean values
+@abstract class_name GdUnitBoolAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitBoolAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitBoolAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitBoolAssert
+
+
+## Verifies that the current value is not equal to the given one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitBoolAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitBoolAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitBoolAssert
+
+
+## Verifies that the current value is true.
+@abstract func is_true() -> GdUnitBoolAssert
+
+
+## Verifies that the current value is false.
+@abstract func is_false() -> GdUnitBoolAssert

addons/gdUnit4/src/GdUnitBoolAssert.gd.uid

@@ -0,0 +1 @@
+uid://bav21rax06rdf

addons/gdUnit4/src/GdUnitConstants.gd

@@ -0,0 +1,10 @@
+class_name GdUnitConstants
+extends RefCounted
+
+const NO_ARG :Variant = "<--null-->"
+
+const EXPECT_ASSERT_REPORT_FAILURES := "expect_assert_report_failures"
+
+## The maximum number of report history files to store
+const DEFAULT_REPORT_HISTORY_COUNT = 20
+const REPORT_DIR_PREFIX = "report_"

addons/gdUnit4/src/GdUnitConstants.gd.uid

@@ -0,0 +1 @@
+uid://b750alnjl31nv

addons/gdUnit4/src/GdUnitDictionaryAssert.gd

@@ -0,0 +1,79 @@
+## An Assertion Tool to verify dictionary
+@abstract class_name GdUnitDictionaryAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitDictionaryAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary is equal to the given one, ignoring order.
+@abstract func is_equal(expected: Variant) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary is not equal to the given one, ignoring order.
+@abstract func is_not_equal(expected: Variant) -> GdUnitDictionaryAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitDictionaryAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary is empty, it has a size of 0.
+@abstract func is_empty() -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary is not empty, it has a size of minimum 1.
+@abstract func is_not_empty() -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary is the same. [br]
+## Compares the current by object reference equals
+@abstract func is_same(expected: Variant) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary is NOT the same. [br]
+## Compares the current by object reference equals
+@abstract func is_not_same(expected: Variant) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary has a size of given value.
+@abstract func has_size(expected: int) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary contains the given key(s).[br]
+## The keys are compared by deep parameter comparision, for object reference compare you have to use [method contains_same_keys]
+@abstract func contains_keys(...expected: Array) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary contains the given key and value.[br]
+## The key and value are compared by deep parameter comparision, for object reference compare you have to use [method contains_same_key_value]
+@abstract func contains_key_value(key: Variant, value: Variant) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary not contains the given key(s).[br]
+## The keys are compared by deep parameter comparision, for object reference compare you have to use [method not_contains_same_keys]
+@abstract func not_contains_keys(...expected: Array) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary contains the given key(s).[br]
+## The keys are compared by object reference, for deep parameter comparision use [method contains_keys]
+@abstract func contains_same_keys(expected: Array) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary contains the given key and value.[br]
+## The key and value are compared by object reference, for deep parameter comparision use [method contains_key_value]
+@abstract func contains_same_key_value(key: Variant, value: Variant) -> GdUnitDictionaryAssert
+
+
+## Verifies that the current dictionary not contains the given key(s).
+## The keys are compared by object reference, for deep parameter comparision use [method not_contains_keys]
+@abstract func not_contains_same_keys(...expected: Array) -> GdUnitDictionaryAssert

addons/gdUnit4/src/GdUnitDictionaryAssert.gd.uid

@@ -0,0 +1 @@
+uid://cfqx4148ov21q

addons/gdUnit4/src/GdUnitFailureAssert.gd

@@ -0,0 +1,52 @@
+## An assertion tool to verify GDUnit asserts.
+## This assert is for internal use only, to verify that failed asserts work as expected.
+@abstract class_name GdUnitFailureAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitFailureAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitFailureAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitFailureAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitFailureAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitFailureAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitFailureAssert
+
+
+## Verifies if the executed assert was successful
+@abstract func is_success() -> GdUnitFailureAssert
+
+
+## Verifies if the executed assert has failed
+@abstract func is_failed() -> GdUnitFailureAssert
+
+
+## Verifies the failure line is equal to expected one.
+@abstract func has_line(expected: int) -> GdUnitFailureAssert
+
+
+## Verifies the failure message is equal to expected one.
+@abstract func has_message(expected: String) -> GdUnitFailureAssert
+
+
+## Verifies that the failure message starts with the expected message.
+@abstract func starts_with_message(expected: String) -> GdUnitFailureAssert
+
+
+## Verifies that the failure message contains the expected message.
+@abstract func contains_message(expected: String) -> GdUnitFailureAssert

addons/gdUnit4/src/GdUnitFailureAssert.gd.uid

@@ -0,0 +1 @@
+uid://hqhd4a063x3n

addons/gdUnit4/src/GdUnitFileAssert.gd

@@ -0,0 +1,38 @@
+@abstract class_name GdUnitFileAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitFileAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitFileAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitFileAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitFileAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitFileAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitFileAssert
+
+
+@abstract func is_file() -> GdUnitFileAssert
+
+
+@abstract func exists() -> GdUnitFileAssert
+
+
+@abstract func is_script() -> GdUnitFileAssert
+
+
+@abstract func contains_exactly(expected_rows :Array) -> GdUnitFileAssert

addons/gdUnit4/src/GdUnitFileAssert.gd.uid

@@ -0,0 +1 @@
+uid://xsowfqnkhk7j

addons/gdUnit4/src/GdUnitFloatAssert.gd

@@ -0,0 +1,75 @@
+## An Assertion Tool to verify float values
+@abstract class_name GdUnitFloatAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitFloatAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitFloatAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitFloatAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitFloatAssert
+
+
+## Verifies that the current and expected value are approximately equal.
+@abstract func is_equal_approx(expected: float, approx: float) -> GdUnitFloatAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitFloatAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitFloatAssert
+
+
+## Verifies that the current value is less than the given one.
+@abstract func is_less(expected: float) -> GdUnitFloatAssert
+
+
+## Verifies that the current value is less than or equal the given one.
+@abstract func is_less_equal(expected: float) -> GdUnitFloatAssert
+
+
+## Verifies that the current value is greater than the given one.
+@abstract func is_greater(expected: float) -> GdUnitFloatAssert
+
+
+## Verifies that the current value is greater than or equal the given one.
+@abstract func is_greater_equal(expected: float) -> GdUnitFloatAssert
+
+
+## Verifies that the current value is negative.
+@abstract func is_negative() -> GdUnitFloatAssert
+
+
+## Verifies that the current value is not negative.
+@abstract func is_not_negative() -> GdUnitFloatAssert
+
+
+## Verifies that the current value is equal to zero.
+@abstract func is_zero() -> GdUnitFloatAssert
+
+
+## Verifies that the current value is not equal to zero.
+@abstract func is_not_zero() -> GdUnitFloatAssert
+
+
+## Verifies that the current value is in the given set of values.
+@abstract func is_in(expected: Array) -> GdUnitFloatAssert
+
+
+## Verifies that the current value is not in the given set of values.
+@abstract func is_not_in(expected: Array) -> GdUnitFloatAssert
+
+
+## Verifies that the current value is between the given boundaries (inclusive).
+@abstract func is_between(from: float, to: float) -> GdUnitFloatAssert

addons/gdUnit4/src/GdUnitFloatAssert.gd.uid

@@ -0,0 +1 @@
+uid://crdh3ctgqxrqi

addons/gdUnit4/src/GdUnitFuncAssert.gd

@@ -0,0 +1,42 @@
+## An Assertion Tool to verify function callback values
+@abstract class_name GdUnitFuncAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitFuncAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitFuncAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitFuncAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitFuncAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitFuncAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitFuncAssert
+
+
+## Verifies that the current value is true.
+@abstract func is_true() -> GdUnitFuncAssert
+
+
+## Verifies that the current value is false.
+@abstract func is_false() -> GdUnitFuncAssert
+
+
+## Sets the timeout in ms to wait the function returnd the expected value, if the time over a failure is emitted.[br]
+## e.g.[br]
+## do wait until 5s the function `is_state` is returns 10 [br]
+## [code]assert_func(instance, "is_state").wait_until(5000).is_equal(10)[/code]
+@abstract func wait_until(timeout: int) -> GdUnitFuncAssert

addons/gdUnit4/src/GdUnitFuncAssert.gd.uid

@@ -0,0 +1 @@
+uid://bqguqoaa43uev

addons/gdUnit4/src/GdUnitGodotErrorAssert.gd

@@ -0,0 +1,59 @@
+## An assertion tool to verify for Godot runtime errors like assert() and push notifications like push_error().
+@abstract class_name GdUnitGodotErrorAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitGodotErrorAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitGodotErrorAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitGodotErrorAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitGodotErrorAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitGodotErrorAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitGodotErrorAssert
+
+
+## Verifies if the executed code runs without any runtime errors
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_success()
+##     [/codeblock]
+@abstract func is_success() -> GdUnitGodotErrorAssert
+
+
+## Verifies if the executed code runs into a runtime error
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_runtime_error(<expected error message>)
+##     [/codeblock]
+@abstract func is_runtime_error(expected_error: Variant) -> GdUnitGodotErrorAssert
+
+
+## Verifies if the executed code has a push_warning() used
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_push_warning(<expected push warning message>)
+##     [/codeblock]
+@abstract func is_push_warning(expected_warning: Variant) -> GdUnitGodotErrorAssert
+
+
+## Verifies if the executed code has a push_error() used
+## Usage:
+##     [codeblock]
+##		await assert_error(<callable>).is_push_error(<expected push error message>)
+##     [/codeblock]
+@abstract func is_push_error(expected_error: Variant) -> GdUnitGodotErrorAssert

addons/gdUnit4/src/GdUnitGodotErrorAssert.gd.uid

@@ -0,0 +1 @@
+uid://clve38xv30uem

addons/gdUnit4/src/GdUnitIntAssert.gd

@@ -0,0 +1,79 @@
+## An Assertion Tool to verify integer values
+@abstract class_name GdUnitIntAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitIntAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitIntAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitIntAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitIntAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitIntAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitIntAssert
+
+
+## Verifies that the current value is less than the given one.
+@abstract func is_less(expected: int) -> GdUnitIntAssert
+
+
+## Verifies that the current value is less than or equal the given one.
+@abstract func is_less_equal(expected: int) -> GdUnitIntAssert
+
+
+## Verifies that the current value is greater than the given one.
+@abstract func is_greater(expected: int) -> GdUnitIntAssert
+
+
+## Verifies that the current value is greater than or equal the given one.
+@abstract func is_greater_equal(expected: int) -> GdUnitIntAssert
+
+
+## Verifies that the current value is even.
+@abstract func is_even() -> GdUnitIntAssert
+
+
+## Verifies that the current value is odd.
+@abstract func is_odd() -> GdUnitIntAssert
+
+
+## Verifies that the current value is negative.
+@abstract func is_negative() -> GdUnitIntAssert
+
+
+## Verifies that the current value is not negative.
+@abstract func is_not_negative() -> GdUnitIntAssert
+
+
+## Verifies that the current value is equal to zero.
+@abstract func is_zero() -> GdUnitIntAssert
+
+
+## Verifies that the current value is not equal to zero.
+@abstract func is_not_zero() -> GdUnitIntAssert
+
+
+## Verifies that the current value is in the given set of values.
+@abstract func is_in(expected: Array) -> GdUnitIntAssert
+
+
+## Verifies that the current value is not in the given set of values.
+@abstract func is_not_in(expected: Array) -> GdUnitIntAssert
+
+
+## Verifies that the current value is between the given boundaries (inclusive).
+@abstract func is_between(from: int, to: int) -> GdUnitIntAssert

addons/gdUnit4/src/GdUnitIntAssert.gd.uid

@@ -0,0 +1 @@
+uid://chqkkjclq101n

addons/gdUnit4/src/GdUnitObjectAssert.gd

@@ -0,0 +1,51 @@
+## An Assertion Tool to verify Object values
+@abstract class_name GdUnitObjectAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitObjectAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitObjectAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitObjectAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitObjectAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitObjectAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitObjectAssert
+
+
+## Verifies that the current object is the same as the given one.
+@abstract func is_same(expected: Variant) -> GdUnitObjectAssert
+
+
+## Verifies that the current object is not the same as the given one.
+@abstract func is_not_same(expected: Variant) -> GdUnitObjectAssert
+
+
+## Verifies that the current object is an instance of the given type.
+@abstract func is_instanceof(type: Variant) -> GdUnitObjectAssert
+
+
+## Verifies that the current object is not an instance of the given type.
+@abstract func is_not_instanceof(type: Variant) -> GdUnitObjectAssert
+
+
+## Checks whether the current object inherits from the specified type.
+@abstract func is_inheriting(type: Variant) -> GdUnitObjectAssert
+
+
+## Checks whether the current object does NOT inherit from the specified type.
+@abstract func is_not_inheriting(type: Variant) -> GdUnitObjectAssert

addons/gdUnit4/src/GdUnitObjectAssert.gd.uid

@@ -0,0 +1 @@
+uid://b7mk5mihqqr65

addons/gdUnit4/src/GdUnitResultAssert.gd

@@ -0,0 +1,51 @@
+## An Assertion Tool to verify Results
+@abstract class_name GdUnitResultAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitResultAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitResultAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitResultAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitResultAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitResultAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitResultAssert
+
+
+## Verifies that the result is ends up with empty
+@abstract func is_empty() -> GdUnitResultAssert
+
+
+## Verifies that the result is ends up with success
+@abstract func is_success() -> GdUnitResultAssert
+
+
+## Verifies that the result is ends up with warning
+@abstract func is_warning() -> GdUnitResultAssert
+
+
+## Verifies that the result is ends up with error
+@abstract func is_error() -> GdUnitResultAssert
+
+
+## Verifies that the result contains the given message
+@abstract func contains_message(expected: String) -> GdUnitResultAssert
+
+
+## Verifies that the result contains the given value
+@abstract func is_value(expected: Variant) -> GdUnitResultAssert

addons/gdUnit4/src/GdUnitResultAssert.gd.uid

@@ -0,0 +1 @@
+uid://cgee6csuvo1ye

addons/gdUnit4/src/GdUnitSceneRunner.gd

@@ -0,0 +1,350 @@
+## The Scene Runner is a tool used for simulating interactions on a scene.
+## With this tool, you can simulate input events such as keyboard or mouse input and/or simulate scene processing over a certain number of frames.
+## This tool is typically used for integration testing a scene.
+@abstract class_name GdUnitSceneRunner
+extends RefCounted
+
+
+## Simulates that an action has been pressed.[br]
+## [member action] : the action e.g. [code]"ui_up"[/code][br]
+## [member event_index] : [url=https://docs.godotengine.org/en/4.4/classes/class_inputeventaction.html#class-inputeventaction-property-event-index]default=-1[/url][br]
+@abstract func simulate_action_pressed(action: String, event_index := -1) -> GdUnitSceneRunner
+
+
+## Simulates that an action is pressed.[br]
+## [member action] : the action e.g. [code]"ui_up"[/code][br]
+## [member event_index] : [url=https://docs.godotengine.org/en/4.4/classes/class_inputeventaction.html#class-inputeventaction-property-event-index]default=-1[/url][br]
+@abstract func simulate_action_press(action: String, event_index := -1) -> GdUnitSceneRunner
+
+
+## Simulates that an action has been released.[br]
+## [member action] : the action e.g. [code]"ui_up"[/code][br]
+## [member event_index] : [url=https://docs.godotengine.org/en/4.4/classes/class_inputeventaction.html#class-inputeventaction-property-event-index]default=-1[/url][br]
+@abstract func simulate_action_release(action: String, event_index := -1) -> GdUnitSceneRunner
+
+
+## Simulates that a key has been pressed.[br]
+## @deprecated: the modifier [b]shift_pressed[/b] and [b]ctrl_pressed[/b] will be removed in v7.0
+## [member key_code] : the key code e.g. [constant KEY_ENTER][br]
+## [codeblock]
+##    func test_key_presssed():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       await runner.simulate_key_pressed(KEY_SPACE)
+## [/codeblock]
+@abstract func simulate_key_pressed(key_code: int, shift_pressed := false, ctrl_pressed := false) -> GdUnitSceneRunner
+
+
+## Simulates that a key is pressing.[br]
+## @deprecated: the modifier [b]shift_pressed[/b] and [b]ctrl_pressed[/b] will be removed in v7.0[br]See `test_key_shift_and_A_presssing` for example using key combinations
+## [member key_code] : the key code e.g. [constant KEY_ENTER][br]
+## [codeblock]
+##    # Do simulate key pressing A
+##    func test_key_A_presssing():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       await runner.simulate_key_press(KEY_A)
+##
+##
+##    # Do simulate keycombination pressing shift+A
+##    func test_key_shift_and_A_presssing():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       runner.simulate_key_press(KEY_SHIFT)
+##       runner.simulate_key_press(KEY_A)
+##       await _runner.await_input_processed()
+## [/codeblock]
+@abstract func simulate_key_press(key_code: int, shift_pressed := false, ctrl_pressed := false) -> GdUnitSceneRunner
+
+
+## Simulates that a key has been released.[br]
+## [member key_code] : the key code e.g. [constant KEY_ENTER][br]
+## [codeblock]
+##    # Do simulate releasing key A
+##    func test_key_A_releasing():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       await runner.simulate_key_release(KEY_A)
+##
+##
+##    # Do simulate keycombination pressing shift+A
+##    func test_key_shift_and_A_releasing(():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       runner.simulate_key_release(KEY_SHIFT)
+##       runner.simulate_key_release(KEY_A)
+##       await _runner.await_input_processed()
+## [/codeblock]
+## @deprecated: the modifier [b]shift_pressed[/b] and [b]ctrl_pressed[/b] will be removed in v7.0[br]See `test_key_shift_and_A_releasing` for example using key combinations
+@abstract func simulate_key_release(key_code: int, shift_pressed := false, ctrl_pressed := false) -> GdUnitSceneRunner
+
+
+## Sets the mouse position to the specified vector, provided in pixels and relative to an origin at the upper left corner of the currently focused Window Manager game window.[br]
+## [member position] : The absolute position in pixels as Vector2
+@abstract func set_mouse_position(position: Vector2) -> GdUnitSceneRunner
+
+
+## Returns the mouse's position in this Viewport using the coordinate system of this Viewport.
+@abstract func get_mouse_position() -> Vector2
+
+
+## Gets the current global mouse position of the current window
+@abstract func get_global_mouse_position() -> Vector2
+
+
+## Simulates a mouse moved to final position.[br]
+## [member position] : The final mouse position
+@abstract func simulate_mouse_move(position: Vector2) -> GdUnitSceneRunner
+
+
+## Simulates a mouse move to the relative coordinates (offset).[br]
+## [color=yellow]You must use [b]await[/b] to wait until the simulated mouse movement is complete.[/color][br]
+## [br]
+## [member relative] : The relative position, indicating the mouse position offset.[br]
+## [member time] : The time to move the mouse by the relative position in seconds (default is 1 second).[br]
+## [member trans_type] : Sets the type of transition used (default is TRANS_LINEAR).[br]
+## [codeblock]
+##    func test_move_mouse():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       await runner.simulate_mouse_move_relative(Vector2(100,100))
+## [/codeblock]
+@abstract func simulate_mouse_move_relative(relative: Vector2, time: float = 1.0, trans_type: Tween.TransitionType = Tween.TRANS_LINEAR) -> GdUnitSceneRunner
+
+
+## Simulates a mouse move to the absolute coordinates.[br]
+## [color=yellow]You must use [b]await[/b] to wait until the simulated mouse movement is complete.[/color][br]
+## [br]
+## [member position] : The final position of the mouse.[br]
+## [member time] : The time to move the mouse to the final position in seconds (default is 1 second).[br]
+## [member trans_type] : Sets the type of transition used (default is TRANS_LINEAR).[br]
+## [codeblock]
+##    func test_move_mouse():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       await runner.simulate_mouse_move_absolute(Vector2(100,100))
+## [/codeblock]
+@abstract func simulate_mouse_move_absolute(position: Vector2, time: float = 1.0, trans_type: Tween.TransitionType = Tween.TRANS_LINEAR) -> GdUnitSceneRunner
+
+
+## Simulates a mouse button pressed.[br]
+## [member button_index] : The mouse button identifier, one of the [enum MouseButton] or button wheel constants.
+## [member double_click] : Set to true to simulate a double-click
+@abstract func simulate_mouse_button_pressed(button_index: MouseButton, double_click := false) -> GdUnitSceneRunner
+
+
+## Simulates a mouse button press (holding)[br]
+## [member button_index] : The mouse button identifier, one of the [enum MouseButton] or button wheel constants.
+## [member double_click] : Set to true to simulate a double-click
+@abstract func simulate_mouse_button_press(button_index: MouseButton, double_click := false) -> GdUnitSceneRunner
+
+
+## Simulates a mouse button released.[br]
+## [member button_index] : The mouse button identifier, one of the [enum MouseButton] or button wheel constants.
+@abstract func simulate_mouse_button_release(button_index: MouseButton) -> GdUnitSceneRunner
+
+
+## Simulates a screen touch is pressed.[br]
+## [member index] : The touch index in the case of a multi-touch event.[br]
+## [member position] : The position to touch the screen.[br]
+## [member double_tap] : If true, the touch's state is a double tab.
+@abstract func simulate_screen_touch_pressed(index: int, position: Vector2, double_tap := false) -> GdUnitSceneRunner
+
+
+## Simulates a screen touch press without releasing it immediately, effectively simulating a "hold" action.[br]
+## [member index] : The touch index in the case of a multi-touch event.[br]
+## [member position] : The position to touch the screen.[br]
+## [member double_tap] : If true, the touch's state is a double tab.
+@abstract func simulate_screen_touch_press(index: int, position: Vector2, double_tap := false) -> GdUnitSceneRunner
+
+
+## Simulates a screen touch is released.[br]
+## [member index] : The touch index in the case of a multi-touch event.[br]
+## [member double_tap] : If true, the touch's state is a double tab.
+@abstract func simulate_screen_touch_release(index: int, double_tap := false) -> GdUnitSceneRunner
+
+
+## Simulates a touch drag and drop event to a relative position.[br]
+## [color=yellow]You must use [b]await[/b] to wait until the simulated drag&drop is complete.[/color][br]
+## [br]
+## [member index] : The touch index in the case of a multi-touch event.[br]
+## [member relative] : The relative position, indicating the drag&drop position offset.[br]
+## [member time] : The time to move to the relative position in seconds (default is 1 second).[br]
+## [member trans_type] : Sets the type of transition used (default is TRANS_LINEAR).[br]
+## [codeblock]
+##    func test_touch_drag_drop():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       # start drag at position 50,50
+##       runner.simulate_screen_touch_drag_begin(1, Vector2(50, 50))
+##       # and drop it at final at 150,50  relative (50,50 + 100,0)
+##       await runner.simulate_screen_touch_drag_relative(1, Vector2(100,0))
+## [/codeblock]
+@abstract func simulate_screen_touch_drag_relative(index: int, relative: Vector2, time: float = 1.0, trans_type: Tween.TransitionType = Tween.TRANS_LINEAR) -> GdUnitSceneRunner
+
+
+## Simulates a touch screen drop to the absolute coordinates (offset).[br]
+## [color=yellow]You must use [b]await[/b] to wait until the simulated drop is complete.[/color][br]
+## [br]
+## [member index] : The touch index in the case of a multi-touch event.[br]
+## [member position] : The final position, indicating the drop position.[br]
+## [member time] : The time to move to the final position in seconds (default is 1 second).[br]
+## [member trans_type] : Sets the type of transition used (default is TRANS_LINEAR).[br]
+## [codeblock]
+##    func test_touch_drag_drop():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       # start drag at position 50,50
+##       runner.simulate_screen_touch_drag_begin(1, Vector2(50, 50))
+##       # and drop it at 100,50
+##       await runner.simulate_screen_touch_drag_absolute(1, Vector2(100,50))
+## [/codeblock]
+@abstract func simulate_screen_touch_drag_absolute(index: int, position: Vector2, time: float = 1.0, trans_type: Tween.TransitionType = Tween.TRANS_LINEAR) -> GdUnitSceneRunner
+
+
+## Simulates a complete drag and drop event from one position to another.[br]
+## This is ideal for testing complex drag-and-drop scenarios that require a specific start and end position.[br]
+## [color=yellow]You must use [b]await[/b] to wait until the simulated drop is complete.[/color][br]
+## [br]
+## [member index] : The touch index in the case of a multi-touch event.[br]
+## [member position] : The drag start position, indicating the drag position.[br]
+## [member drop_position] : The drop position, indicating the drop position.[br]
+## [member time] : The time to move to the final position in seconds (default is 1 second).[br]
+## [member trans_type] : Sets the type of transition used (default is TRANS_LINEAR).[br]
+## [codeblock]
+##    func test_touch_drag_drop():
+##       var runner = scene_runner("res://scenes/simple_scene.tscn")
+##       # start drag at position 50,50 and drop it at 100,50
+##       await runner.simulate_screen_touch_drag_drop(1, Vector2(50, 50), Vector2(100,50))
+## [/codeblock]
+@abstract 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
+
+
+## Simulates a touch screen drag event to given position.[br]
+## [member index] : The touch index in the case of a multi-touch event.[br]
+## [member position] : The drag start position, indicating the drag position.[br]
+@abstract func simulate_screen_touch_drag(index: int, position: Vector2) -> GdUnitSceneRunner
+
+
+## Returns the actual position of the touchscreen drag position by given index.
+## [member index] : The touch index in the case of a multi-touch event.[br]
+@abstract func get_screen_touch_drag_position(index: int) -> Vector2
+
+
+## Sets how fast or slow the scene simulation is processed (clock ticks versus the real).[br]
+## It defaults to 1.0. A value of 2.0 means the game moves twice as fast as real life,
+## whilst a value of 0.5 means the game moves at half the regular speed.
+## [member time_factor] : A float representing the simulation speed.[br]
+## - Default is 1.0, meaning the simulation runs at normal speed.[br]
+## - A value of 2.0 means the simulation runs twice as fast as real time.[br]
+## - A value of 0.5 means the simulation runs at half the regular speed.[br]
+@abstract func set_time_factor(time_factor: float = 1.0) -> GdUnitSceneRunner
+
+
+## Simulates scene processing for a certain number of frames.[br]
+## [member frames] : amount of frames to process[br]
+## [member delta_milli] : the time delta between a frame in milliseconds
+@abstract func simulate_frames(frames: int, delta_milli: int = -1) -> GdUnitSceneRunner
+
+
+## Simulates scene processing until the given signal is emitted by the scene.[br]
+## [member signal_name] : the signal to stop the simulation[br]
+## [member args] : optional signal arguments to be matched for stop[br]
+@abstract func simulate_until_signal(signal_name: String, ...args: Array) -> GdUnitSceneRunner
+
+
+## Simulates scene processing until the given signal is emitted by the given object.[br]
+## [member source] : the object that should emit the signal[br]
+## [member signal_name] : the signal to stop the simulation[br]
+## [member args] : optional signal arguments to be matched for stop
+@abstract func simulate_until_object_signal(source: Object, signal_name: String, ...args: Array) -> GdUnitSceneRunner
+
+
+## Waits for all input events to be processed by flushing any buffered input events
+## and then awaiting a full cycle of both the process and physics frames.[br]
+## [br]
+## This is typically used to ensure that any simulated or queued inputs are fully
+## processed before proceeding with the next steps in the scene.[br]
+## It's essential for reliable input simulation or when synchronizing logic based
+## on inputs.[br]
+##
+## Usage Example:
+## [codeblock]
+## 	await await_input_processed()  # Ensure all inputs are processed before continuing
+## [/codeblock]
+@abstract func await_input_processed() -> void
+
+
+## The await_func function pauses execution until a specified function in the scene returns a value.[br]
+## It returns a [GdUnitFuncAssert], which provides a suite of assertion methods to verify the returned value.[br]
+## [member func_name] : The name of the function to wait for.[br]
+## [member args] : Optional function arguments
+## [br]
+## Usage Example:
+## [codeblock]
+## 	# Waits for 'calculate_score' function and verifies the result is equal to 100.
+## 	await_func("calculate_score").is_equal(100)
+## [/codeblock]
+@abstract func await_func(func_name: String, ...args: Array) -> GdUnitFuncAssert
+
+
+## The await_func_on function extends the functionality of await_func by allowing you to specify a source node within the scene.[br]
+## It waits for a specified function on that node to return a value and returns a [GdUnitFuncAssert] object for assertions.[br]
+## [member source] : The object where implements the function.[br]
+## [member func_name] : The name of the function to wait for.[br]
+## [member args] : optional function arguments
+## [br]
+## Usage Example:
+## [codeblock]
+## 	# Waits for 'calculate_score' function and verifies the result is equal to 100.
+## 	var my_instance := ScoreCalculator.new()
+## 	await_func(my_instance, "calculate_score").is_equal(100)
+## [/codeblock]
+@abstract func await_func_on(source: Object, func_name: String, ...args: Array) -> GdUnitFuncAssert
+
+
+## Waits for the specified signal to be emitted by the scene. If the signal is not emitted within the given timeout, the operation fails.[br]
+## [member signal_name] : The name of the signal to wait for[br]
+## [member args] : The signal arguments as an array[br]
+## [member timeout] : The maximum duration (in milliseconds) to wait for the signal to be emitted before failing
+@abstract func await_signal(signal_name: String, args := [], timeout := 2000 ) -> void
+
+
+## Waits for the specified signal to be emitted by a particular source node. If the signal is not emitted within the given timeout, the operation fails.[br]
+## [member source] : the object from which the signal is emitted[br]
+## [member signal_name] : The name of the signal to wait for[br]
+## [member args] : The signal arguments as an array[br]
+## [member timeout] : tThe maximum duration (in milliseconds) to wait for the signal to be emitted before failing
+@abstract func await_signal_on(source: Object, signal_name: String, args := [], timeout := 2000 ) -> void
+
+
+## Restores the scene window to a windowed mode and brings it to the foreground.[br]
+## This ensures that the scene is visible and active during testing, making it easier to observe and interact with.
+@abstract func move_window_to_foreground() -> GdUnitSceneRunner
+
+
+## Minimizes the scene window to a windowed mode and brings it to the background.[br]
+## This ensures that the scene is hidden during testing.
+@abstract func move_window_to_background() -> GdUnitSceneRunner
+
+
+## Return the current value of the property with the name <name>.[br]
+## [member name] : name of property[br]
+## [member return] : the value of the property
+@abstract func get_property(name: String) -> Variant
+
+
+## Set the  value <value> of the property with the name <name>.[br]
+## [member name] : name of property[br]
+## [member value] : value of property[br]
+## [member return] : true|false depending on valid property name.
+@abstract func set_property(name: String, value: Variant) -> bool
+
+
+## executes the function specified by <name> in the scene and returns the result.[br]
+## [member name] : the name of the function to execute[br]
+## [member args] : optional function arguments[br]
+## [member return] : the function result
+@abstract func invoke(name: String, ...args: Array) -> Variant
+
+
+## Searches for the specified node with the name in the current scene and returns it, otherwise null.[br]
+## [member name] : the name of the node to find[br]
+## [member recursive] : enables/disables seraching recursive[br]
+## [member return] : the node if find otherwise null
+@abstract func find_child(name: String, recursive: bool = true, owned: bool = false) -> Node
+
+
+## Access to current running scene
+@abstract func scene() -> Node

addons/gdUnit4/src/GdUnitSceneRunner.gd.uid

@@ -0,0 +1 @@
+uid://cg867wakih43u

addons/gdUnit4/src/GdUnitSignalAssert.gd

@@ -0,0 +1,158 @@
+## An Assertion Tool to verify for emitted signals until a waiting time
+@abstract class_name GdUnitSignalAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitSignalAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitSignalAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitSignalAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitSignalAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitSignalAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitSignalAssert
+
+
+## Verifies that the specified signal is emitted with the expected arguments.[br]
+##
+## This assertion waits for a signal to be emitted from the object under test and
+## validates that it was emitted with the correct arguments. The function supports
+## both typed signals (Signal type) and string-based signal names for flexibility
+## in different testing scenarios.[br]
+## [br]
+## [b]Parameters:[/b][br]
+## [param signal_name]: The signal to monitor. Can be either:[br]
+##   • A [Signal] reference (recommended for type safety)[br]
+##   • A [String] with the signal name
+## [param signal_args]: Optional expected signal arguments.[br]
+##   When provided, verifies the signal was emitted with exactly these values.[br]
+## [br]
+## [b]Returns:[/b][br]
+## [GdUnitSignalAssert] - Returns self for method chaining.[br]
+## [br]
+## [b]Examples:[/b]
+## [codeblock]
+## signal signal_a(value: int)
+## signal signal_b(name: String, count: int)
+##
+## # Wait for signal emission without checking arguments
+## # Using Signal reference (type-safe)
+## await assert_signal(instance).is_emitted(signal_a)
+## # Using string name (dynamic)
+## await assert_signal(instance).is_emitted("signal_a")
+##
+## # Wait for signal emission with specific argument
+## await assert_signal(instance).is_emitted(signal_a, 10)
+##
+## # Wait for signal with multiple arguments
+## await assert_signal(instance).is_emitted(signal_b, "test", 42)
+##
+## # Wait max 500ms for signal with argument 10
+## await assert_signal(instance).wait_until(500).is_emitted(signal_a, 10)
+## [/codeblock]
+## [br]
+## [b]Note:[/b] This is an async operation - use [code]await[/code] when calling.[br]
+## The assertion fails if the signal is not emitted within the timeout period.
+@abstract func is_emitted(signal_name: Variant, ...signal_args: Array) -> GdUnitSignalAssert
+
+
+## Verifies that the specified signal is NOT emitted with the expected arguments.[br]
+##
+## This assertion waits for a specified time period and validates that a signal
+## was not emitted with the given arguments. Useful for ensuring certain conditions
+## don't trigger unwanted signals or for verifying signal filtering logic.[br]
+## [br]
+## [b]Parameters:[/b][br]
+## [param signal_name]: The signal to monitor. Can be either:[br]
+##   • A [Signal] reference (recommended for type safety)[br]
+##   • A [String] with the signal name
+## [param signal_args]: Optional expected signal arguments.[br]
+##   When provided, verifies the signal was not emitted with these specific values.[br]
+##   If omitted, verifies the signal was not emitted at all.[br]
+## [br]
+## [b]Returns:[/b][br]
+## [GdUnitSignalAssert] - Returns self for method chaining.[br]
+## [br]
+## [b]Examples:[/b]
+## [codeblock]
+## signal signal_a(value: int)
+## signal signal_b(name: String, count: int)
+##
+## # Verify signal is not emitted at all (without checking arguments)
+## await assert_signal(instance).wait_until(500).is_not_emitted(signal_a)
+## await assert_signal(instance).wait_until(500).is_not_emitted("signal_a")
+##
+## # Verify signal is not emitted with specific argument
+## await assert_signal(instance).wait_until(500).is_not_emitted(signal_a, 10)
+##
+## # Verify signal is not emitted with multiple arguments
+## await assert_signal(instance).wait_until(500).is_not_emitted(signal_b, "test", 42)
+##
+## # Can be emitted with different arguments (this passes)
+## instance.emit_signal("signal_a", 20)  # Emits with 20, not 10
+## await assert_signal(instance).wait_until(500).is_not_emitted(signal_a, 10)
+## [/codeblock]
+## [br]
+## [b]Note:[/b] This is an async operation - use [code]await[/code] when calling.[br]
+## The assertion fails if the signal IS emitted with the specified arguments within the timeout period.
+@abstract func is_not_emitted(signal_name: Variant, ...signal_args: Array) -> GdUnitSignalAssert
+
+
+## Verifies that the specified signal exists on the emitter object.[br]
+##
+## This assertion checks if a signal is defined on the object under test,
+## regardless of whether it has been emitted. Useful for validating that
+## objects have the expected signals before testing their emission.[br]
+## [br]
+## [b]Parameters:[/b][br]
+## [param signal_name]: The signal to check. Can be either:[br]
+##   • A [Signal] reference (recommended for type safety)[br]
+##   • A [String] with the signal name
+## [br]
+## [b]Returns:[/b][br]
+## [GdUnitSignalAssert] - Returns self for method chaining.[br]
+## [br]
+## [b]Examples:[/b]
+## [codeblock]
+## signal my_signal(value: int)
+## signal another_signal()
+##
+## # Verify signal exists using Signal reference
+## assert_signal(instance).is_signal_exists(my_signal)
+##
+## # Verify signal exists using string name
+## assert_signal(instance).is_signal_exists("my_signal")
+##
+## # Chain with other assertions
+## assert_signal(instance) \
+##     .is_signal_exists(my_signal) \
+##     .is_emitted(my_signal, 42)
+##
+## [/codeblock]
+## [br]
+## [b]Note:[/b] This only checks signal definition, not emission.[br]
+## The assertion fails if the signal is not defined on the object.
+@abstract func is_signal_exists(signal_name: Variant) -> GdUnitSignalAssert
+
+
+## Sets the assert signal timeout in ms, if the time over a failure is reported.[br]
+## Example:
+## [codeblock]
+## do wait until 5s the instance has emitted the signal `signal_a`[br]
+## assert_signal(instance).wait_until(5000).is_emitted("signal_a")
+## [/codeblock]
+@abstract func wait_until(timeout: int) -> GdUnitSignalAssert

addons/gdUnit4/src/GdUnitSignalAssert.gd.uid

@@ -0,0 +1 @@
+uid://ck4dbwhcpf144

addons/gdUnit4/src/GdUnitStringAssert.gd

@@ -0,0 +1,71 @@
+## An Assertion Tool to verify String values
+@abstract class_name GdUnitStringAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitStringAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitStringAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitStringAssert
+
+
+## Verifies that the current String is equal to the given one, ignoring case considerations.
+@abstract func is_equal_ignoring_case(expected: Variant) -> GdUnitStringAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitStringAssert
+
+
+## Verifies that the current String is not equal to the given one, ignoring case considerations.
+@abstract func is_not_equal_ignoring_case(expected: Variant) -> GdUnitStringAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitStringAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitStringAssert
+
+
+## Verifies that the current String is empty, it has a length of 0.
+@abstract func is_empty() -> GdUnitStringAssert
+
+
+## Verifies that the current String is not empty, it has a length of minimum 1.
+@abstract func is_not_empty() -> GdUnitStringAssert
+
+
+## Verifies that the current String contains the given String.
+@abstract func contains(expected: String) -> GdUnitStringAssert
+
+
+## Verifies that the current String does not contain the given String.
+@abstract func not_contains(expected: String) -> GdUnitStringAssert
+
+
+## Verifies that the current String does not contain the given String, ignoring case considerations.
+@abstract func contains_ignoring_case(expected: String) -> GdUnitStringAssert
+
+
+## Verifies that the current String does not contain the given String, ignoring case considerations.
+@abstract func not_contains_ignoring_case(expected: String) -> GdUnitStringAssert
+
+
+## Verifies that the current String starts with the given prefix.
+@abstract func starts_with(expected: String) -> GdUnitStringAssert
+
+
+## Verifies that the current String ends with the given suffix.
+@abstract func ends_with(expected: String) -> GdUnitStringAssert
+
+
+## Verifies that the current String has the expected length by used comparator.
+@abstract func has_length(length: int, comparator: int = Comparator.EQUAL) -> GdUnitStringAssert

addons/gdUnit4/src/GdUnitStringAssert.gd.uid

@@ -0,0 +1 @@
+uid://b2itt4pwvweqo

addons/gdUnit4/src/GdUnitTestSuite.gd

@@ -0,0 +1,746 @@
+## The main class for all GdUnit test suites[br]
+## This class is the main class to implement your unit tests[br]
+## You have to extend and implement your test cases as described[br]
+## e.g MyTests.gd [br]
+## [codeblock]
+##    extends GdUnitTestSuite
+##    # testcase
+##    func test_case_a():
+##       assert_that("value").is_equal("value")
+## [/codeblock]
+## @tutorial:  https://mikeschulze.github.io/gdUnit4/faq/test-suite/
+
+@icon("res://addons/gdUnit4/src/ui/settings/logo.png")
+class_name GdUnitTestSuite
+extends Node
+
+
+### internal runtime variables that must not be overwritten!!!
+@warning_ignore("unused_private_class_variable")
+var __is_skipped := false
+@warning_ignore("unused_private_class_variable")
+var __skip_reason := "Unknow."
+var __active_test_case: String
+var __awaiter := __gdunit_awaiter()
+
+
+### We now load all used asserts and tool scripts into the cache according to the principle of "lazy loading"
+### in order to noticeably reduce the loading time of the test suite.
+# We go this hard way to increase the loading performance to avoid reparsing all the used scripts
+# for more detailed info -> https://github.com/godotengine/godot/issues/67400
+func __lazy_load(script_path: String) -> GDScript:
+	return GdUnitAssertions.__lazy_load(script_path)
+
+
+func __gdunit_assert() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd")
+
+
+func __gdunit_tools() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+
+func __gdunit_file_access() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/core/GdUnitFileAccess.gd")
+
+
+func __gdunit_awaiter() -> Object:
+	return __lazy_load("res://addons/gdUnit4/src/GdUnitAwaiter.gd").new()
+
+
+func __gdunit_argument_matchers() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/matchers/GdUnitArgumentMatchers.gd")
+
+
+func __gdunit_object_interactions() -> GDScript:
+	return __lazy_load("res://addons/gdUnit4/src/doubler/GdUnitObjectInteractions.gd")
+
+
+## This function is called before a test suite starts[br]
+## You can overwrite to prepare test data or initalizize necessary variables
+func before() -> void:
+	pass
+
+
+## This function is called at least when a test suite is finished[br]
+## You can overwrite to cleanup data created during test running
+func after() -> void:
+	pass
+
+
+## This function is called before a test case starts[br]
+## You can overwrite to prepare test case specific data
+func before_test() -> void:
+	pass
+
+
+## This function is called after the test case is finished[br]
+## You can overwrite to cleanup your test case specific data
+func after_test() -> void:
+	pass
+
+
+func is_failure() -> bool:
+	return Engine.get_meta("GD_TEST_FAILURE") if Engine.has_meta("GD_TEST_FAILURE") else false
+
+
+func set_active_test_case(test_case: String) -> void:
+	__active_test_case = test_case
+
+
+# === Tools ====================================================================
+# Mapps Godot error number to a readable error message. See at ERROR
+# https://docs.godotengine.org/de/stable/classes/class_@globalscope.html#enum-globalscope-error
+func error_as_string(error_number: int) -> String:
+	return error_string(error_number)
+
+
+## A litle helper to auto freeing your created objects after test execution
+func auto_free(obj: Variant) -> Variant:
+	var execution_context := GdUnitThreadManager.get_current_context().get_execution_context()
+
+	assert(execution_context != null, "INTERNAL ERROR: The current execution_context is null! Please report this as bug.")
+	return execution_context.register_auto_free(obj)
+
+
+@warning_ignore("native_method_override")
+func add_child(node: Node, force_readable_name := false, internal := Node.INTERNAL_MODE_DISABLED) -> void:
+	super.add_child(node, force_readable_name, internal)
+	var execution_context := GdUnitThreadManager.get_current_context().get_execution_context()
+	if execution_context != null:
+		execution_context.orphan_monitor_start()
+
+
+## Discard the error message triggered by a timeout (interruption).[br]
+## By default, an interrupted test is reported as an error.[br]
+## This function allows you to change the message to Success when an interrupted error is reported.
+func discard_error_interupted_by_timeout() -> void:
+	@warning_ignore("unsafe_method_access")
+	__gdunit_tools().register_expect_interupted_by_timeout(self, __active_test_case)
+
+
+## Creates a new directory under the temporary directory *user://tmp*[br]
+## Useful for storing data during test execution. [br]
+## The directory is automatically deleted after test suite execution
+func create_temp_dir(relative_path: String) -> String:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_file_access().create_temp_dir(relative_path)
+
+
+## Deletes the temporary base directory[br]
+## Is called automatically after each execution of the test suite
+func clean_temp_dir() -> void:
+	@warning_ignore("unsafe_method_access")
+	__gdunit_file_access().clear_tmp()
+
+
+## Creates a new file under the temporary directory *user://tmp* + <relative_path>[br]
+## with given name <file_name> and given file <mode> (default = File.WRITE)[br]
+## If success the returned File is automatically closed after the execution of the test suite
+func create_temp_file(relative_path: String, file_name: String, mode := FileAccess.WRITE) -> FileAccess:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_file_access().create_temp_file(relative_path, file_name, mode)
+
+
+## Reads a resource by given path <resource_path> into a PackedStringArray.
+func resource_as_array(resource_path: String) -> PackedStringArray:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_file_access().resource_as_array(resource_path)
+
+
+## Reads a resource by given path <resource_path> and returned the content as String.
+func resource_as_string(resource_path: String) -> String:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_file_access().resource_as_string(resource_path)
+
+
+## Reads a resource by given path <resource_path> and return Variand translated by str_to_var
+func resource_as_var(resource_path: String) -> Variant:
+	@warning_ignore("unsafe_method_access", "unsafe_cast")
+	return str_to_var(__gdunit_file_access().resource_as_string(resource_path) as String)
+
+
+## Waits for given signal to be emitted by <source> until a specified timeout to fail[br]
+## source: the object from which the signal is emitted[br]
+## signal_name: signal name[br]
+## args: the expected signal arguments as an array[br]
+## timeout: the timeout in ms, default is set to 2000ms
+func await_signal_on(source: Object, signal_name: String, args: Array = [], timeout: int = 2000) -> Variant:
+	@warning_ignore("unsafe_method_access")
+	return await __awaiter.await_signal_on(source, signal_name, args, timeout)
+
+
+## Waits until the next idle frame
+func await_idle_frame() -> void:
+	@warning_ignore("unsafe_method_access")
+	await __awaiter.await_idle_frame()
+
+
+## Waits for a given amount of milliseconds[br]
+## example:[br]
+## [codeblock]
+##    # waits for 100ms
+##    await await_millis(myNode, 100).completed
+## [/codeblock][br]
+## use this waiter and not `await get_tree().create_timer().timeout to prevent errors when a test case is timed out
+func await_millis(timeout: int) -> void:
+	@warning_ignore("unsafe_method_access")
+	await __awaiter.await_millis(timeout)
+
+
+## Collects detailed information about orphaned nodes for debugging purposes.[br]
+##
+## This function gathers comprehensive details about nodes that remain in memory
+## after test execution (orphans). It provides debugging information to help
+## identify the source of memory leaks in tests. Must be manually called in
+## tests when orphan nodes are detected.[br]
+## [br]
+## [b]When to Use:[/b][br]
+## - When GdUnit4 reports orphan nodes after test execution[br]
+## - For debugging memory leaks in test scenarios[br]
+## - To get detailed information about unreleased nodes[br]
+## [br]
+## [b]Usage Pattern:[/b][br]
+## Add this call at the end of tests that are suspected to create orphans,
+## or when the test runner reports orphan detection.[br]
+## [br]
+## [b]Examples:[/b]
+## [codeblock]
+## func test_scene_management():
+##     # Test code that might create orphan nodes
+##     var scene = preload("res://TestScene.tscn").instantiate()
+##     add_child(scene)
+##
+##     # Do test operations
+##     scene.some_method()
+##
+##     # Clean up (but might miss some nodes)
+##     scene.queue_free()
+##
+##     # Collect orphan details if any are detected
+##     collect_orphan_node_details()
+## [/codeblock]
+## [br]
+## [b]Note:[/b] This is a debugging utility function that should be removed
+## or commented out once orphan issues are resolved.
+func collect_orphan_node_details() -> void:
+	GdUnitThreadManager.get_current_context().get_execution_context().orphan_monitor_collect()
+
+
+## Creates a new scene runner to allow simulate interactions checked a scene.[br]
+## The runner will manage the scene instance and release after the runner is released[br]
+## example:[br]
+## [codeblock]
+##    # creates a runner by using a instanciated scene
+##    var scene = load("res://foo/my_scne.tscn").instantiate()
+##    var runner := scene_runner(scene)
+##
+##    # or simply creates a runner by using the scene resource path
+##    var runner := scene_runner("res://foo/my_scne.tscn")
+## [/codeblock]
+func scene_runner(scene: Variant, verbose := false) -> GdUnitSceneRunner:
+	return auto_free(__lazy_load("res://addons/gdUnit4/src/core/GdUnitSceneRunnerImpl.gd").new(scene, verbose))
+
+
+# === Mocking  & Spy ===========================================================
+
+## do return a default value for primitive types or null
+const RETURN_DEFAULTS = GdUnitMock.RETURN_DEFAULTS
+## do call the real implementation
+const CALL_REAL_FUNC = GdUnitMock.CALL_REAL_FUNC
+## do return a default value for primitive types and a fully mocked value for Object types
+## builds full deep mocked object
+const RETURN_DEEP_STUB = GdUnitMock.RETURN_DEEP_STUB
+
+
+## Creates a mock for given class name
+func mock(clazz: Variant, mock_mode := RETURN_DEFAULTS) -> Variant:
+	@warning_ignore("unsafe_method_access")
+	return __lazy_load("res://addons/gdUnit4/src/mocking/GdUnitMockBuilder.gd").build(clazz, mock_mode)
+
+
+## Creates a spy checked given object instance
+func spy(instance: Variant) -> Variant:
+	@warning_ignore("unsafe_method_access")
+	return __lazy_load("res://addons/gdUnit4/src/spy/GdUnitSpyBuilder.gd").build(instance)
+
+
+## Configures a return value for the specified function and used arguments.[br]
+## [b]Example:
+## 	[codeblock]
+## 		# overrides the return value of myMock.is_selected() to false
+## 		do_return(false).on(myMock).is_selected()
+## 	[/codeblock]
+func do_return(value: Variant) -> GdUnitMock:
+	return GdUnitMock.new(value)
+
+
+## Verifies certain behavior happened at least once or exact number of times
+func verify(obj: Variant, times := 1) -> Variant:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_object_interactions().verify(obj, times)
+
+
+## Verifies no interactions is happen checked this mock or spy
+func verify_no_interactions(obj: Variant) -> GdUnitAssert:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_object_interactions().verify_no_interactions(obj)
+
+
+## Verifies the given mock or spy has any unverified interaction.
+func verify_no_more_interactions(obj: Variant) -> GdUnitAssert:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_object_interactions().verify_no_more_interactions(obj)
+
+
+## Resets the saved function call counters checked a mock or spy
+func reset(obj: Variant) -> void:
+	@warning_ignore("unsafe_method_access")
+	__gdunit_object_interactions().reset(obj)
+
+
+## Starts monitoring the specified source to collect all transmitted signals.[br]
+## The collected signals can then be checked with 'assert_signal'.[br]
+## By default, the specified source is automatically released when the test ends.
+## You can control this behavior by setting auto_free to false if you do not want the source to be automatically freed.[br]
+## Usage:
+##	[codeblock]
+##		var emitter := monitor_signals(MyEmitter.new())
+##		# call the function to send the signal
+##		emitter.do_it()
+##		# verify the signial is emitted
+##		await assert_signal(emitter).is_emitted('my_signal')
+##	[/codeblock]
+func monitor_signals(source: Object, _auto_free := true) -> Object:
+	@warning_ignore("unsafe_method_access")
+	__lazy_load("res://addons/gdUnit4/src/core/thread/GdUnitThreadManager.gd")\
+		.get_current_context()\
+		.get_signal_collector()\
+		.register_emitter(source, true) # force recreate to start with a fresh monitoring
+	return auto_free(source) if _auto_free else source
+
+
+# === Argument matchers ========================================================
+## Argument matcher to match any argument
+func any() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().any()
+
+
+## Argument matcher to match any boolean value
+func any_bool() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_BOOL)
+
+
+## Argument matcher to match any integer value
+func any_int() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_INT)
+
+
+## Argument matcher to match any float value
+func any_float() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_FLOAT)
+
+
+## Argument matcher to match any String value
+func any_string() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_STRING)
+
+
+## Argument matcher to match any Color value
+func any_color() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_COLOR)
+
+
+## Argument matcher to match any Vector typed value
+func any_vector() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_types([
+		TYPE_VECTOR2,
+		TYPE_VECTOR2I,
+		TYPE_VECTOR3,
+		TYPE_VECTOR3I,
+		TYPE_VECTOR4,
+		TYPE_VECTOR4I,
+	])
+
+
+## Argument matcher to match any Vector2 value
+func any_vector2() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR2)
+
+
+## Argument matcher to match any Vector2i value
+func any_vector2i() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR2I)
+
+
+## Argument matcher to match any Vector3 value
+func any_vector3() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR3)
+
+
+## Argument matcher to match any Vector3i value
+func any_vector3i() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR3I)
+
+
+## Argument matcher to match any Vector4 value
+func any_vector4() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR4)
+
+
+## Argument matcher to match any Vector4i value
+func any_vector4i() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_VECTOR4I)
+
+
+## Argument matcher to match any Rect2 value
+func any_rect2() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_RECT2)
+
+
+## Argument matcher to match any Plane value
+func any_plane() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PLANE)
+
+
+## Argument matcher to match any Quaternion value
+func any_quat() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_QUATERNION)
+
+
+## Argument matcher to match any AABB value
+func any_aabb() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_AABB)
+
+
+## Argument matcher to match any Basis value
+func any_basis() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_BASIS)
+
+
+## Argument matcher to match any Transform2D value
+func any_transform_2d() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_TRANSFORM2D)
+
+
+## Argument matcher to match any Transform3D value
+func any_transform_3d() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_TRANSFORM3D)
+
+
+## Argument matcher to match any NodePath value
+func any_node_path() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_NODE_PATH)
+
+
+## Argument matcher to match any RID value
+func any_rid() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_RID)
+
+
+## Argument matcher to match any Object value
+func any_object() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_OBJECT)
+
+
+## Argument matcher to match any Dictionary value
+func any_dictionary() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_DICTIONARY)
+
+
+## Argument matcher to match any Array value
+func any_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_ARRAY)
+
+
+## Argument matcher to match any PackedByteArray value
+func any_packed_byte_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_BYTE_ARRAY)
+
+
+## Argument matcher to match any PackedInt32Array value
+func any_packed_int32_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_INT32_ARRAY)
+
+
+## Argument matcher to match any PackedInt64Array value
+func any_packed_int64_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_INT64_ARRAY)
+
+
+## Argument matcher to match any PackedFloat32Array value
+func any_packed_float32_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_FLOAT32_ARRAY)
+
+
+## Argument matcher to match any PackedFloat64Array value
+func any_packed_float64_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_FLOAT64_ARRAY)
+
+
+## Argument matcher to match any PackedStringArray value
+func any_packed_string_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_STRING_ARRAY)
+
+
+## Argument matcher to match any PackedVector2Array value
+func any_packed_vector2_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_VECTOR2_ARRAY)
+
+
+## Argument matcher to match any PackedVector3Array value
+func any_packed_vector3_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_VECTOR3_ARRAY)
+
+
+## Argument matcher to match any PackedColorArray value
+func any_packed_color_array() -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().by_type(TYPE_PACKED_COLOR_ARRAY)
+
+
+## Argument matcher to match any instance of given class
+func any_class(clazz :Object) -> GdUnitArgumentMatcher:
+	@warning_ignore("unsafe_method_access")
+	return __gdunit_argument_matchers().any_class(clazz)
+
+
+# === value extract utils ======================================================
+## Builds an extractor by given function name and optional arguments
+func extr(func_name: String, args := Array()) -> GdUnitValueExtractor:
+	return __lazy_load("res://addons/gdUnit4/src/extractors/GdUnitFuncValueExtractor.gd").new(func_name, args)
+
+
+## Creates a GdUnitTuple from the provided arguments for use in test assertions.
+## [br]
+## This is the primary helper function for creating tuples in GdUnit4 tests.
+## It provides a convenient way to group multiple expected values when using
+## [method extractv] assertions. The function enforces that tuples must contain
+## at least two values, as single-value extractions don't require tuple grouping.
+## [br]
+## [b]Parameters:[/b] [br]
+## - [code]...args[/code]: Variable number of arguments (minimum 2) to group into a tuple.
+##   Each argument represents a value to be compared in assertions.
+## [br]
+## [b]Returns:[/b] [br]
+## A [GdUnitTuple] containing the provided values, or an empty tuple if fewer than
+## 2 arguments are provided (with an error message).
+## [br]
+## [b]Error Handling:[/b] [br]
+## [codeblock]
+## # This will push an error and return empty tuple
+## var invalid = tuple("single_value")  # Error: requires at least 2 arguments
+## [br]
+## # Correct usage - minimum 2 arguments
+## var valid = tuple("name", "value")
+## var valid_multi = tuple(1, 2, 3, 4, 5)  # Can have many values
+## [/codeblock]
+func tuple(...args: Array) -> GdUnitTuple:
+	if args.size() < 2:
+		push_error("Tuple requires at least two arguments.")
+		return GdUnitTuple.new()
+	return GdUnitTuple.new.callv(args)
+
+
+# === Asserts ==================================================================
+
+## The common assertion tool to verify values.
+## It checks the given value by type to fit to the best assert
+func assert_that(current: Variant) -> GdUnitAssert:
+	match typeof(current):
+		TYPE_BOOL:
+			return assert_bool(current)
+		TYPE_INT:
+			return assert_int(current)
+		TYPE_FLOAT:
+			return assert_float(current)
+		TYPE_STRING:
+			return assert_str(current)
+		TYPE_VECTOR2, TYPE_VECTOR2I, TYPE_VECTOR3, TYPE_VECTOR3I, TYPE_VECTOR4, TYPE_VECTOR4I:
+			return assert_vector(current, false)
+		TYPE_DICTIONARY:
+			return assert_dict(current)
+		TYPE_ARRAY, TYPE_PACKED_BYTE_ARRAY, TYPE_PACKED_INT32_ARRAY, TYPE_PACKED_INT64_ARRAY,\
+		TYPE_PACKED_FLOAT32_ARRAY, TYPE_PACKED_FLOAT64_ARRAY, TYPE_PACKED_STRING_ARRAY,\
+		TYPE_PACKED_VECTOR2_ARRAY, TYPE_PACKED_VECTOR3_ARRAY, TYPE_PACKED_COLOR_ARRAY:
+			return assert_array(current, false)
+		TYPE_OBJECT, TYPE_NIL:
+			return assert_object(current)
+		_:
+			return __gdunit_assert().new(current)
+
+
+## An assertion tool to verify boolean values.
+func assert_bool(current: Variant) -> GdUnitBoolAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitBoolAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify String values.
+func assert_str(current: Variant) -> GdUnitStringAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitStringAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify integer values.
+func assert_int(current: Variant) -> GdUnitIntAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitIntAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify float values.
+func assert_float(current: Variant) -> GdUnitFloatAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFloatAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify Vector values.[br]
+## This assertion supports all vector types.[br]
+## Usage:
+##     [codeblock]
+##		assert_vector(Vector2(1.2, 1.000001)).is_equal(Vector2(1.2, 1.000001))
+##     [/codeblock]
+func assert_vector(current: Variant, type_check := true) -> GdUnitVectorAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitVectorAssertImpl.gd").new(current, type_check)
+
+
+## An assertion tool to verify arrays.
+func assert_array(current: Variant, type_check := true) -> GdUnitArrayAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitArrayAssertImpl.gd").new(current, type_check)
+
+
+## An assertion tool to verify dictionaries.
+func assert_dict(current: Variant) -> GdUnitDictionaryAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitDictionaryAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify FileAccess.
+func assert_file(current: Variant) -> GdUnitFileAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFileAssertImpl.gd").new(current)
+
+
+## An assertion tool to verify Objects.
+func assert_object(current: Variant) -> GdUnitObjectAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitObjectAssertImpl.gd").new(current)
+
+
+func assert_result(current: Variant) -> GdUnitResultAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitResultAssertImpl.gd").new(current)
+
+
+## An assertion tool that waits until a certain time for an expected function return value
+func assert_func(instance: Object, func_name: String, args := Array()) -> GdUnitFuncAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFuncAssertImpl.gd").new(instance, func_name, args)
+
+
+## An assertion tool to verify for emitted signals until a certain time.
+func assert_signal(instance: Object) -> GdUnitSignalAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitSignalAssertImpl.gd").new(instance)
+
+
+## An assertion tool to test for failing assertions.[br]
+## This assert is only designed for internal use to verify failing asserts working as expected.[br]
+## Usage:
+##     [codeblock]
+##		assert_failure(func(): assert_bool(true).is_not_equal(true)) \
+##		    .has_message("Expecting:\n 'true'\n not equal to\n 'true'")
+##     [/codeblock]
+func assert_failure(assertion: Callable) -> GdUnitFailureAssert:
+	@warning_ignore("unsafe_method_access")
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd").new().execute(assertion)
+
+
+## An assertion tool to test for failing assertions.[br]
+## This assert is only designed for internal use to verify failing asserts working as expected.[br]
+## Usage:
+##     [codeblock]
+##		await assert_failure_await(func(): assert_bool(true).is_not_equal(true)) \
+##		    .has_message("Expecting:\n 'true'\n not equal to\n 'true'")
+##     [/codeblock]
+func assert_failure_await(assertion: Callable) -> GdUnitFailureAssert:
+	@warning_ignore("unsafe_method_access")
+	return await __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd").new().execute_and_await(assertion)
+
+
+## An assertion tool to verify Godot errors.[br]
+## You can use to verify certain Godot errors like failing assertions, push_error, push_warn.[br]
+## Usage:
+##     [codeblock]
+##		# tests no error occurred during execution of the code
+##		await assert_error(func (): return 0 )\
+##		    .is_success()
+##
+##		# tests a push_error('test error') occured during execution of the code
+##		await assert_error(func (): push_error('test error') )\
+##		    .is_push_error('test error')
+##     [/codeblock]
+func assert_error(current: Callable) -> GdUnitGodotErrorAssert:
+	return __lazy_load("res://addons/gdUnit4/src/asserts/GdUnitGodotErrorAssertImpl.gd").new(current)
+
+
+## Explicitly fails the current test indicating that the feature is not yet implemented.[br]
+## This function is useful during development when you want to write test cases before implementing the actual functionality.[br]
+## It provides a clear indication that the test failure is expected because the feature is still under development.[br]
+## Usage:
+##     [codeblock]
+##		# Test for a feature that will be implemented later
+##		func test_advanced_ai_behavior():
+##		    assert_not_yet_implemented()
+##
+##     [/codeblock]
+func assert_not_yet_implemented() -> void:
+	@warning_ignore("unsafe_method_access")
+	__gdunit_assert().new(null).do_fail()
+
+
+## Explicitly fails the current test with a custom error message.[br]
+## This function reports an error but does not terminate test execution automatically.[br]
+## You must use 'return' after calling fail() to stop the test since GDScript has no exception support.[br]
+## Useful for complex conditional testing scenarios where standard assertions are insufficient.[br]
+## Usage:
+##     [codeblock]
+##		# Fail test when conditions are not met
+##		if !custom_check(player):
+##		    fail("Player should be alive but has %d health" % player.health)
+##		    return
+##
+##		# Continue with test if conditions pass
+##		assert_that(player.health).is_greater(0)
+##     [/codeblock]
+func fail(message: String) -> void:
+	@warning_ignore("unsafe_method_access")
+	__gdunit_assert().new(null).report_error(message)
+
+
+# --- internal stuff do not override!!!
+func ResourcePath() -> String:
+	return get_script().resource_path

addons/gdUnit4/src/GdUnitTestSuite.gd.uid

@@ -0,0 +1 @@
+uid://bfroomur047su

addons/gdUnit4/src/GdUnitTuple.gd

@@ -0,0 +1,86 @@
+## A tuple implementation for GdUnit4 test assertions and value extraction.
+## @tutorial(GdUnit4 Array Assertions): https://mikeschulze.github.io/gdUnit4/latest/testing/assert-array/#extractv
+## @tutorial(GdUnit4 Testing Framework): https://mikeschulze.github.io/gdUnit4/
+## [br]
+## The GdUnitTuple class is a utility container designed specifically for the GdUnit4
+## testing framework. It enables advanced assertion operations, particularly when
+## extracting and comparing multiple values from complex test results.
+## [br]
+## [b]Primary Use Cases in Testing:[/b] [br]
+## - Extracting multiple properties from test objects with [method extractv]## [br]
+## - Grouping related assertion values for comparison## [br]
+## - Returning multiple values from test helper methods## [br]
+## - Organizing expected vs actual value pairs in assertions## [br]
+## [br]
+## [b]Example Usage in Tests:[/b]
+## [codeblock]
+## func test_player_stats_after_level_up():
+##     var player = Player.new()
+##     player.level_up()
+##
+##     # Extract multiple properties using tuple
+##     assert_array([player]) \
+##         .extractv(extr("name"), extr("level"), extr("hp")) \
+##         .contains(tuple("Hero", 2, 150))
+##
+## func test_enemy_spawn_positions():
+##     var enemies: Array = spawn_enemies(3)
+##
+##     # Verify multiple enemies have correct position data
+##     assert_array(enemies) \
+##         .extractv(extr("position.x"), extr("position.y")) \
+##         .contains_exactly([
+##             tuple(100, 200),
+##             tuple(150, 200),
+##             tuple(200, 200)
+##         ])
+## [/codeblock]
+## [br]
+## [b]Integration with GdUnit4 Assertions:[/b] [br]
+## Tuples work seamlessly with array assertion methods like: [br]
+## - [code]contains()[/code] - Check if extracted values contain specific tuples [br]
+## - [code]contains_exactly()[/code] - Verify exact tuple matches [br]
+## - [code]is_equal()[/code] - Compare tuple equality [br]
+## [br]
+## [b]Note:[/b] This class is part of the GdUnit4 testing framework's internal
+## utilities and is primarily intended for use within test assertions rather
+## than production code.
+class_name GdUnitTuple
+extends RefCounted
+
+var _values: Array = []
+
+
+## Initializes a new GdUnitTuple with test values.
+## [br]
+## Creates a tuple to hold multiple values extracted from test objects
+## or expected values for assertions. Commonly used with the [code]tuple()[/code]
+## helper function in GdUnit4 tests.
+## [br]
+## [b]Parameters:[/b]
+## - [code]...args[/code]: Variable number of values to store.
+func _init(...args: Array) -> void:
+	_values = args
+
+
+## Returns the tuple's values as an array for assertion comparisons.
+## [br]
+## Provides access to the stored test values. Used internally by GdUnit4's
+## assertion system when comparing tuples in test validations.
+## [br]
+## [b]Returns:[/b]
+## An [Array] containing all values stored in the tuple.
+func values() -> Array:
+	return _values
+
+
+## Returns a string representation for test output and debugging.
+## [br]
+## Formats the tuple for display in test results, error messages, and debug logs.
+## This method is automatically called by GdUnit4 when displaying assertion
+## failures involving tuples.
+## [br]
+## [b]Returns:[/b]
+## A [String] in the format "tuple([value1, value2, ...])"
+func _to_string() -> String:
+	return "tuple(%s)" % str(_values)

addons/gdUnit4/src/GdUnitTuple.gd.uid

@@ -0,0 +1 @@
+uid://ckj5nn4gln5bw

addons/gdUnit4/src/GdUnitValueExtractor.gd

@@ -0,0 +1,9 @@
+## This is the base interface for value extraction
+class_name GdUnitValueExtractor
+extends RefCounted
+
+
+## Extracts a value by given implementation
+func extract_value(value :Variant) -> Variant:
+	push_error("Uninplemented func 'extract_value'")
+	return value

addons/gdUnit4/src/GdUnitValueExtractor.gd.uid

@@ -0,0 +1 @@
+uid://cyagv2phlu24d

addons/gdUnit4/src/GdUnitVectorAssert.gd

@@ -0,0 +1,55 @@
+## An Assertion Tool to verify Vector values
+@abstract class_name GdUnitVectorAssert
+extends GdUnitAssert
+
+
+## Verifies that the current value is null.
+@abstract func is_null() -> GdUnitVectorAssert
+
+
+## Verifies that the current value is not null.
+@abstract func is_not_null() -> GdUnitVectorAssert
+
+
+## Verifies that the current value is equal to the given one.
+@abstract func is_equal(expected: Variant) -> GdUnitVectorAssert
+
+
+## Verifies that the current value is not equal to expected one.
+@abstract func is_not_equal(expected: Variant) -> GdUnitVectorAssert
+
+
+## Verifies that the current and expected value are approximately equal.
+@abstract func is_equal_approx(expected: Variant, approx: Variant) -> GdUnitVectorAssert
+
+
+## Overrides the default failure message by given custom message.
+@abstract func override_failure_message(message: String) -> GdUnitVectorAssert
+
+
+## Appends a custom message to the failure message.
+@abstract func append_failure_message(message: String) -> GdUnitVectorAssert
+
+
+## Verifies that the current value is less than the given one.
+@abstract func is_less(expected: Variant) -> GdUnitVectorAssert
+
+
+## Verifies that the current value is less than or equal the given one.
+@abstract func is_less_equal(expected: Variant) -> GdUnitVectorAssert
+
+
+## Verifies that the current value is greater than the given one.
+@abstract func is_greater(expected: Variant) -> GdUnitVectorAssert
+
+
+## Verifies that the current value is greater than or equal the given one.
+@abstract func is_greater_equal(expected: Variant) -> GdUnitVectorAssert
+
+
+## Verifies that the current value is between the given boundaries (inclusive).
+@abstract func is_between(from: Variant, to: Variant) -> GdUnitVectorAssert
+
+
+## Verifies that the current value is not between the given boundaries (inclusive).
+@abstract func is_not_between(from: Variant, to: Variant) -> GdUnitVectorAssert

addons/gdUnit4/src/GdUnitVectorAssert.gd.uid

@@ -0,0 +1 @@
+uid://hrk46nhl8icp

addons/gdUnit4/src/asserts/CallBackValueProvider.gd

@@ -0,0 +1,25 @@
+# a value provider unsing a callback to get `next` value from a certain function
+class_name CallBackValueProvider
+extends ValueProvider
+
+var _cb :Callable
+var _args :Array
+
+
+func _init(instance :Object, func_name :String, args :Array = Array(), force_error := true) -> void:
+	_cb = Callable(instance, func_name);
+	_args = args
+	if force_error and not _cb.is_valid():
+		push_error("Can't find function '%s' checked instance %s" % [func_name, instance])
+
+
+func get_value() -> Variant:
+	if not _cb.is_valid():
+		return null
+	if _args.is_empty():
+		return await _cb.call()
+	return await _cb.callv(_args)
+
+
+func dispose() -> void:
+	_cb = Callable()

addons/gdUnit4/src/asserts/CallBackValueProvider.gd.uid

@@ -0,0 +1 @@
+uid://bymqibokrfyuk

addons/gdUnit4/src/asserts/DefaultValueProvider.gd

@@ -0,0 +1,13 @@
+# default value provider, simple returns the initial value
+class_name DefaultValueProvider
+extends ValueProvider
+
+var _value: Variant
+
+
+func _init(value: Variant) -> void:
+	_value = value
+
+
+func get_value() -> Variant:
+	return _value

addons/gdUnit4/src/asserts/DefaultValueProvider.gd.uid

@@ -0,0 +1 @@
+uid://bxkxeyj2jbth2

addons/gdUnit4/src/asserts/GdAssertMessages.gd

@@ -0,0 +1,752 @@
+class_name GdAssertMessages
+extends Resource
+
+const WARN_COLOR = "#EFF883"
+const ERROR_COLOR = "#CD5C5C"
+const VALUE_COLOR = "#1E90FF"
+const SUB_COLOR :=  Color(1, 0, 0, .15)
+const ADD_COLOR :=  Color(0, 1, 0, .15)
+
+
+# Dictionary of control characters and their readable representations
+const CONTROL_CHARS = {
+	"\n": "<LF>",   # Line Feed
+	"\r": "<CR>",   # Carriage Return
+	"\t": "<TAB>",  # Tab
+	"\b": "<BS>",   # Backspace
+	"\f": "<FF>",   # Form Feed
+	"\v": "<VT>",   # Vertical Tab
+	"\a": "<BEL>",  # Bell
+	"": "<ESC>"   # Escape
+}
+
+
+static func format_dict(value :Variant) -> String:
+	if not value is Dictionary:
+		return str(value)
+
+	var dict_value: Dictionary = value
+	if dict_value.is_empty():
+		return "{ }"
+	var as_rows := var_to_str(value).split("\n")
+	for index in range( 1, as_rows.size()-1):
+		as_rows[index] = "	" + as_rows[index]
+	as_rows[-1] = "  " + as_rows[-1]
+	return "\n".join(as_rows)
+
+
+# improved version of InputEvent as text
+static func input_event_as_text(event :InputEvent) -> String:
+	var text := ""
+	if event is InputEventKey:
+		var key_event := event as InputEventKey
+		text += """
+			InputEventKey : keycode=%s (%s) pressed: %s
+				physical_keycode: %s
+				location: %s
+				echo: %s""" % [
+					key_event.keycode,
+					event.as_text_keycode(),
+					key_event.pressed,
+					key_event.physical_keycode,
+					key_event.location,
+					key_event.echo]
+	else:
+		text += event.as_text()
+	if event is InputEventMouse:
+		var mouse_event := event as InputEventMouse
+		text += """
+				global_position: %s""" % mouse_event.global_position
+	if event is InputEventWithModifiers:
+		var mouse_event := event as InputEventWithModifiers
+		text += """
+				--------
+				mods: %s
+				shift: %s
+				alt: %s
+				control: %s
+				meta: %s
+				command: %s""" % [
+					mouse_event.get_modifiers_mask(),
+					mouse_event.shift_pressed,
+					mouse_event.alt_pressed,
+					mouse_event.ctrl_pressed,
+					mouse_event.meta_pressed,
+					mouse_event.command_or_control_autoremap]
+	return text.dedent()
+
+
+static func _colored_string_div(characters: String) -> String:
+	return colored_array_div(characters.to_utf32_buffer().to_int32_array())
+
+
+static func colored_array_div(characters: PackedInt32Array) -> String:
+	if characters.is_empty():
+		return "<empty>"
+	var result := PackedInt32Array()
+	var index := 0
+	var missing_chars := PackedInt32Array()
+	var additional_chars := PackedInt32Array()
+
+	while index < characters.size():
+		var character := characters[index]
+		match character:
+			GdDiffTool.DIV_ADD:
+				index += 1
+				@warning_ignore("return_value_discarded")
+				additional_chars.append(characters[index])
+			GdDiffTool.DIV_SUB:
+				index += 1
+				@warning_ignore("return_value_discarded")
+				missing_chars.append(characters[index])
+			_:
+				if not missing_chars.is_empty():
+					result.append_array(format_chars(missing_chars, SUB_COLOR))
+					missing_chars = PackedInt32Array()
+				if not additional_chars.is_empty():
+					result.append_array(format_chars(additional_chars, ADD_COLOR))
+					additional_chars = PackedInt32Array()
+				@warning_ignore("return_value_discarded")
+				result.append(character)
+		index += 1
+
+	result.append_array(format_chars(missing_chars, SUB_COLOR))
+	result.append_array(format_chars(additional_chars, ADD_COLOR))
+	return result.to_byte_array().get_string_from_utf32()
+
+
+static func _typed_value(value :Variant) -> String:
+	return GdDefaultValueDecoder.decode(value)
+
+
+static func _warning(error :String) -> String:
+	return "[color=%s]%s[/color]" % [WARN_COLOR, error]
+
+
+static func _error(error :String) -> String:
+	return "[color=%s]%s[/color]" % [ERROR_COLOR, error]
+
+
+static func _nerror(number :Variant) -> String:
+	match typeof(number):
+		TYPE_INT:
+			return "[color=%s]%d[/color]" % [ERROR_COLOR, number]
+		TYPE_FLOAT:
+			return "[color=%s]%f[/color]" % [ERROR_COLOR, number]
+		_:
+			return "[color=%s]%s[/color]" % [ERROR_COLOR, str(number)]
+
+
+static func _colored(value: Variant, color: Color) -> String:
+	return "[color=%s]%s[/color]" % [color.to_html(), value]
+
+
+static func _colored_value(value :Variant) -> String:
+	match typeof(value):
+		TYPE_STRING, TYPE_STRING_NAME:
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _colored_string_div(str(value))]
+		TYPE_INT:
+			return "'[color=%s]%d[/color]'" % [VALUE_COLOR, value]
+		TYPE_FLOAT:
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _typed_value(value)]
+		TYPE_COLOR:
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _typed_value(value)]
+		TYPE_OBJECT:
+			if value == null:
+				return "'[color=%s]<null>[/color]'" % [VALUE_COLOR]
+			if value is InputEvent:
+				var ie: InputEvent = value
+				return "[color=%s]<%s>[/color]" % [VALUE_COLOR, input_event_as_text(ie)]
+			var obj_value: Object = value
+			if obj_value.has_method("_to_string"):
+				return "[color=%s]<%s>[/color]" % [VALUE_COLOR, str(value)]
+			return "[color=%s]<%s>[/color]" % [VALUE_COLOR, obj_value.get_class()]
+		TYPE_DICTIONARY:
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, format_dict(value)]
+		_:
+			if GdArrayTools.is_array_type(value):
+				return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _typed_value(value)]
+			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, value]
+
+
+
+static func _index_report_as_table(index_reports :Array) -> String:
+	var table := "[table=3]$cells[/table]"
+	var header := "[cell][right][b]$text[/b][/right]\t[/cell]"
+	var cell := "[cell][right]$text[/right]\t[/cell]"
+	var cells := header.replace("$text", "Index") + header.replace("$text", "Current") + header.replace("$text", "Expected")
+	for report :Variant in index_reports:
+		var index :String = str(report["index"])
+		var current :String = str(report["current"])
+		var expected :String = str(report["expected"])
+		cells += cell.replace("$text", index) + cell.replace("$text", current) + cell.replace("$text", expected)
+	return table.replace("$cells", cells)
+
+
+
+static func orphan_warning(orphans_count: int) -> String:
+	return """
+		%s: Found %s possible orphan nodes.
+			Add %s to the end of the test to collect details.""".dedent().trim_prefix("\n") % [
+		_warning("WARNING:"),
+		_nerror(orphans_count),
+		_colored_value("collect_orphan_node_details()")
+	]
+
+static func orphan_detected_on_suite_setup(orphans: Array[GdUnitOrphanNodeInfo]) -> String:
+	return """
+		%s Detected %s orphan nodes!
+			[b]Verify your test suite setup.[/b]
+		%s""".dedent().trim_prefix("\n") % [
+		_warning("WARNING:"),
+		_nerror(orphans.size()),
+		_build_orphan_node_stacktrace(orphans)]
+
+
+static func orphan_detected_on_test_setup(orphans: Array[GdUnitOrphanNodeInfo]) -> String:
+	return """
+			%s Detected %s orphan nodes on test setup!
+				[b]Check before_test() and after_test()![/b]
+			%s""".dedent().trim_prefix("\n") % [
+				_warning("WARNING:"),
+				_nerror(orphans.size()),
+				_build_orphan_node_stacktrace(orphans)
+			]
+
+
+static func orphan_detected_on_test(orphans: Array[GdUnitOrphanNodeInfo]) -> String:
+	return """
+		%s Detected %s orphan nodes!
+		%s""".dedent().trim_prefix("\n") % [
+			_warning("WARNING:"),
+			_nerror(orphans.size()),
+			_build_orphan_node_stacktrace(orphans)
+		]
+
+
+static func _build_orphan_node_stacktrace(orphans: Array[GdUnitOrphanNodeInfo]) -> String:
+	var stack_trace := "\n"
+	for orphan in orphans:
+		stack_trace += orphan.as_trace(orphan, true) + "\n"
+	return stack_trace.indent("    ")
+
+
+
+static func fuzzer_interuped(iterations: int, error: String) -> String:
+	return "%s %s %s\n %s" % [
+		_error("Found an error after"),
+		_colored_value(iterations + 1),
+		_error("test iterations"),
+		error]
+
+
+static func test_timeout(timeout :int) -> String:
+	return "%s\n %s" % [_error("Timeout !"), _colored_value("Test timed out after %s" %  LocalTime.elapsed(timeout))]
+
+
+static func test_session_terminated() -> String:
+	return "%s" % _error("Test Session Terminated")
+
+
+# gdlint:disable = mixed-tabs-and-spaces
+static func test_suite_skipped(hint :String, skip_count :int) -> String:
+	return """
+		%s
+		  Skipped %s tests
+		  Reason: %s
+		""".dedent().trim_prefix("\n")\
+		% [_error("The Entire test-suite is skipped!"), _colored_value(skip_count), _colored_value(hint)]
+
+
+static func test_skipped(hint :String) -> String:
+	return """
+		%s
+		  Reason: %s
+		""".dedent().trim_prefix("\n")\
+		% [_error("This test is skipped!"), _colored_value(hint)]
+
+
+static func error_not_implemented() -> String:
+	return _error("Test not implemented!")
+
+
+static func error_is_null(current :Variant) -> String:
+	return "%s %s but was %s" % [_error("Expecting:"), _colored_value(null), _colored_value(current)]
+
+
+static func error_is_not_null() -> String:
+	return "%s %s" % [_error("Expecting: not to be"), _colored_value(null)]
+
+
+static func error_equal(current :Variant, expected :Variant, index_reports :Array = []) -> String:
+	var report := """
+		%s
+		 %s
+		 but was
+		 %s""".dedent().trim_prefix("\n") % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+	if not index_reports.is_empty():
+		report += "\n\n%s\n%s" % [_error("Differences found:"), _index_report_as_table(index_reports)]
+	return report
+
+
+static func error_not_equal(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n not equal to\n %s" % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_not_equal_case_insensetiv(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n not equal to (case insensitiv)\n %s" % [
+			_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_is_empty(current :Variant) -> String:
+	return "%s\n must be empty but was\n %s" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_not_empty() -> String:
+	return "%s\n must not be empty" % [_error("Expecting:")]
+
+
+static func error_is_same(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n to refer to the same object\n %s" % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+@warning_ignore("unused_parameter")
+static func error_not_same(_current :Variant, expected :Variant) -> String:
+	return "%s\n %s" % [_error("Expecting not same:"), _colored_value(expected)]
+
+
+static func error_not_same_error(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n but was\n %s" % [_error("Expecting error message:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_is_instanceof(current: GdUnitResult, expected :GdUnitResult) -> String:
+	return "%s\n %s\n But it was %s" % [_error("Expected instance of:"),\
+		_colored_value(expected.or_else(null)), _colored_value(current.or_else(null))]
+
+
+# -- Boolean Assert specific messages -----------------------------------------------------
+static func error_is_true(current :Variant) -> String:
+	return "%s %s but is %s" % [_error("Expecting:"), _colored_value(true), _colored_value(current)]
+
+
+static func error_is_false(current :Variant) -> String:
+	return "%s %s but is %s" % [_error("Expecting:"), _colored_value(false), _colored_value(current)]
+
+
+# - Integer/Float Assert specific messages -----------------------------------------------------
+
+static func error_is_even(current :Variant) -> String:
+	return "%s\n %s must be even" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_odd(current :Variant) -> String:
+	return "%s\n %s must be odd" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_negative(current :Variant) -> String:
+	return "%s\n %s be negative" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_not_negative(current :Variant) -> String:
+	return "%s\n %s be not negative" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_zero(current :Variant) -> String:
+	return "%s\n equal to 0 but is %s" % [_error("Expecting:"), _colored_value(current)]
+
+
+static func error_is_not_zero() -> String:
+	return "%s\n not equal to 0" % [_error("Expecting:")]
+
+
+static func error_is_wrong_type(current_type :Variant.Type, expected_type :Variant.Type) -> String:
+	return "%s\n Expecting type %s but is %s" % [
+		_error("Unexpected type comparison:"),
+		_colored_value(GdObjects.type_as_string(current_type)),
+		_colored_value(GdObjects.type_as_string(expected_type))]
+
+
+static func error_is_value(operation :int, current :Variant, expected :Variant, expected2 :Variant = null) -> String:
+	match operation:
+		Comparator.EQUAL:
+			return "%s\n %s but was '%s'" % [_error("Expecting:"), _colored_value(expected), _nerror(current)]
+		Comparator.LESS_THAN:
+			return "%s\n %s but was '%s'" % [_error("Expecting to be less than:"), _colored_value(expected), _nerror(current)]
+		Comparator.LESS_EQUAL:
+			return "%s\n %s but was '%s'" % [_error("Expecting to be less than or equal:"), _colored_value(expected), _nerror(current)]
+		Comparator.GREATER_THAN:
+			return "%s\n %s but was '%s'" % [_error("Expecting to be greater than:"), _colored_value(expected), _nerror(current)]
+		Comparator.GREATER_EQUAL:
+			return "%s\n %s but was '%s'" % [_error("Expecting to be greater than or equal:"), _colored_value(expected), _nerror(current)]
+		Comparator.BETWEEN_EQUAL:
+			return "%s\n %s\n in range between\n %s <> %s" % [
+					_error("Expecting:"), _colored_value(current), _colored_value(expected), _colored_value(expected2)]
+		Comparator.NOT_BETWEEN_EQUAL:
+			return "%s\n %s\n not in range between\n %s <> %s" % [
+					_error("Expecting:"), _colored_value(current), _colored_value(expected), _colored_value(expected2)]
+	return "TODO create expected message"
+
+
+static func error_is_in(current :Variant, expected :Array) -> String:
+	return "%s\n %s\n is in\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(str(expected))]
+
+
+static func error_is_not_in(current :Variant, expected :Array) -> String:
+	return "%s\n %s\n is not in\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(str(expected))]
+
+
+# - StringAssert ---------------------------------------------------------------------------------
+static func error_equal_ignoring_case(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n but was\n %s (ignoring case)" % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_contains(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n do contains\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_not_contains(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n not do contain\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_contains_ignoring_case(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n contains\n %s\n (ignoring case)" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_not_contains_ignoring_case(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n not do contains\n %s\n (ignoring case)" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_starts_with(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n to start with\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_ends_with(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n to end with\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]
+
+
+static func error_has_length(current :Variant, expected: int, compare_operator :int) -> String:
+	@warning_ignore("unsafe_method_access")
+	var current_length :Variant = current.length() if current != null else null
+	match compare_operator:
+		Comparator.EQUAL:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size:"), _colored_value(expected), _nerror(current_length), _colored_value(current)]
+		Comparator.LESS_THAN:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size to be less than:"), _colored_value(expected), _nerror(current_length), _colored_value(current)]
+		Comparator.LESS_EQUAL:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size to be less than or equal:"), _colored_value(expected),
+					_nerror(current_length), _colored_value(current)]
+		Comparator.GREATER_THAN:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size to be greater than:"), _colored_value(expected),
+					_nerror(current_length), _colored_value(current)]
+		Comparator.GREATER_EQUAL:
+			return "%s\n %s but was '%s' in\n %s" % [
+					_error("Expecting size to be greater than or equal:"), _colored_value(expected),
+					_nerror(current_length), _colored_value(current)]
+	return "TODO create expected message"
+
+
+# - ArrayAssert specific messgaes ---------------------------------------------------
+
+static func error_arr_contains(current: Variant, expected: Variant, not_expect: Variant, not_found: Variant, by_reference: bool) -> String:
+	var failure_message := "Expecting contains SAME elements:" if by_reference else "Expecting contains elements:"
+	var error := "%s\n %s\n do contains (in any order)\n %s" % [
+					_error(failure_message), _colored_value(current), _colored_value(expected)]
+	if not is_empty(not_expect):
+		error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect)
+	if not is_empty(not_found):
+		var prefix := "but" if is_empty(not_expect) else "and"
+		error += "\n%s could not find elements:\n %s" % [prefix, _colored_value(not_found)]
+	return error
+
+
+static func error_arr_contains_exactly(
+	current: Variant,
+	expected: Variant,
+	not_expect: Variant,
+	not_found: Variant, compare_mode: GdObjects.COMPARE_MODE) -> String:
+	var failure_message := (
+		"Expecting contains exactly elements:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting contains SAME exactly elements:"
+	)
+	if is_empty(not_expect) and is_empty(not_found):
+		var arr_current: Array = current
+		var arr_expected: Array = expected
+		var diff := _find_first_diff(arr_current, arr_expected)
+		return "%s\n %s\n do contains (in same order)\n %s\n but has different order %s"  % [
+					_error(failure_message), _colored_value(current), _colored_value(expected), diff]
+
+	var error := "%s\n %s\n do contains (in same order)\n %s" % [
+					_error(failure_message), _colored_value(current), _colored_value(expected)]
+	if not is_empty(not_expect):
+		error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect)
+	if not is_empty(not_found):
+		var prefix := "but" if is_empty(not_expect) else "and"
+		error += "\n%s could not find elements:\n %s" % [prefix, _colored_value(not_found)]
+	return error
+
+
+static func error_arr_contains_exactly_in_any_order(
+	current: Variant,
+	expected: Variant,
+	not_expect: Variant,
+	not_found: Variant,
+	compare_mode: GdObjects.COMPARE_MODE) -> String:
+
+	var failure_message := (
+		"Expecting contains exactly elements:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting contains SAME exactly elements:"
+	)
+	var error := "%s\n %s\n do contains exactly (in any order)\n %s" % [
+					_error(failure_message), _colored_value(current), _colored_value(expected)]
+	if not is_empty(not_expect):
+		error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect)
+	if not is_empty(not_found):
+		var prefix := "but" if is_empty(not_expect) else "and"
+		error += "\n%s could not find elements:\n %s" % [prefix, _colored_value(not_found)]
+	return error
+
+
+static func error_arr_not_contains(current: Variant, expected: Variant, found: Variant, compare_mode: GdObjects.COMPARE_MODE) -> String:
+	var failure_message := "Expecting:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST else "Expecting SAME:"
+	var error := "%s\n %s\n do not contains\n %s" % [
+					_error(failure_message), _colored_value(current), _colored_value(expected)]
+	if not is_empty(found):
+		error += "\n but found elements:\n %s" % _colored_value(found)
+	return error
+
+
+# - DictionaryAssert specific messages ----------------------------------------------
+static func error_contains_keys(current :Array, expected :Array, keys_not_found :Array, compare_mode :GdObjects.COMPARE_MODE) -> String:
+	var failure := (
+		"Expecting contains keys:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting contains SAME keys:"
+	)
+	return "%s\n %s\n to contains:\n %s\n but can't find key's:\n %s" % [
+			_error(failure), _colored_value(current), _colored_value(expected), _colored_value(keys_not_found)]
+
+
+static func error_not_contains_keys(current :Array, expected :Array, keys_not_found :Array, compare_mode :GdObjects.COMPARE_MODE) -> String:
+	var failure := (
+		"Expecting NOT contains keys:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting NOT contains SAME keys"
+	)
+	return "%s\n %s\n do not contains:\n %s\n but contains key's:\n %s" % [
+			_error(failure), _colored_value(current), _colored_value(expected), _colored_value(keys_not_found)]
+
+
+static func error_contains_key_value(key :Variant, value :Variant, current_value :Variant, compare_mode :GdObjects.COMPARE_MODE) -> String:
+	var failure := (
+		"Expecting contains key and value:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
+		else "Expecting contains SAME key and value:"
+	)
+	return "%s\n %s : %s\n but contains\n %s : %s" % [
+			_error(failure), _colored_value(key), _colored_value(value), _colored_value(key), _colored_value(current_value)]
+
+
+# - ResultAssert specific errors ----------------------------------------------------
+static func error_result_is_empty(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.EMPTY)
+
+
+static func error_result_is_success(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.SUCCESS)
+
+
+static func error_result_is_warning(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.WARN)
+
+
+static func error_result_is_error(current :GdUnitResult) -> String:
+	return _result_error_message(current, GdUnitResult.ERROR)
+
+
+static func error_result_has_message(current :String, expected :String) -> String:
+	return "%s\n %s\n but was\n %s." % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
+
+
+static func error_result_has_message_on_success(expected :String) -> String:
+	return "%s\n %s\n but the GdUnitResult is a success." % [_error("Expecting:"), _colored_value(expected)]
+
+
+static func error_result_is_value(current :Variant, expected :Variant) -> String:
+	return "%s\n %s\n but was\n %s." % [_error("Expecting to contain same value:"), _colored_value(expected), _colored_value(current)]
+
+
+static func _result_error_message(current :GdUnitResult, expected_type :int) -> String:
+	if current == null:
+		return _error("Expecting the result must be a %s but was <null>." % result_type(expected_type))
+	if current.is_success():
+		return _error("Expecting the result must be a %s but was SUCCESS." % result_type(expected_type))
+	var error := "Expecting the result must be a %s but was %s:" % [result_type(expected_type), result_type(current._state)]
+	return "%s\n %s" % [_error(error), _colored_value(result_message(current))]
+
+
+static func error_interrupted(func_name :String, expected :Variant, elapsed :String) -> String:
+	func_name = humanized(func_name)
+	if expected == null:
+		return "%s %s but timed out after %s" % [_error("Expected:"), func_name, elapsed]
+	return "%s %s %s but timed out after %s" % [_error("Expected:"), func_name, _colored_value(expected), elapsed]
+
+
+static func error_wait_signal(signal_name :String, args :Array, elapsed :String) -> String:
+	if args.is_empty():
+		return "%s %s but timed out after %s" % [
+				_error("Expecting emit signal:"), _colored_value(signal_name + "()"), elapsed]
+	return "%s %s but timed out after %s" % [
+			_error("Expecting emit signal:"), _colored_value(signal_name + "(" + str(args) + ")"), elapsed]
+
+
+static func error_signal_emitted(signal_name :String, args :Array, elapsed :String) -> String:
+	if args.is_empty():
+		return "%s %s but is emitted after %s" % [
+				_error("Expecting do not emit signal:"), _colored_value(signal_name + "()"), elapsed]
+	return "%s %s but is emitted after %s" % [
+			_error("Expecting do not emit signal:"), _colored_value(signal_name + "(" + str(args) + ")"), elapsed]
+
+
+static func error_await_signal_on_invalid_instance(source :Variant, signal_name :String, args :Array) -> String:
+	return "%s\n await_signal_on(%s, %s, %s)" % [
+			_error("Invalid source! Can't await on signal:"), _colored_value(source), signal_name, args]
+
+
+static func result_type(type :int) -> String:
+	match type:
+		GdUnitResult.SUCCESS: return "SUCCESS"
+		GdUnitResult.WARN: return "WARNING"
+		GdUnitResult.ERROR: return "ERROR"
+		GdUnitResult.EMPTY: return "EMPTY"
+	return "UNKNOWN"
+
+
+static func result_message(result :GdUnitResult) -> String:
+	match result._state:
+		GdUnitResult.SUCCESS: return ""
+		GdUnitResult.WARN: return result.warn_message()
+		GdUnitResult.ERROR: return result.error_message()
+		GdUnitResult.EMPTY: return ""
+	return "UNKNOWN"
+# -----------------------------------------------------------------------------------
+
+# - Spy|Mock specific errors ----------------------------------------------------
+static func error_no_more_interactions(summary :Dictionary) -> String:
+	var interactions := PackedStringArray()
+	for args :Array in summary.keys():
+		var times :int = summary[args]
+		@warning_ignore("return_value_discarded")
+		interactions.append(_format_arguments(args, times))
+	return "%s\n%s\n%s" % [_error("Expecting no more interactions!"), _error("But found interactions on:"), "\n".join(interactions)]
+
+
+static func error_validate_interactions(current_interactions: Dictionary, expected_interactions: Dictionary) -> String:
+	var collected_interactions := PackedStringArray()
+	for args: Array in current_interactions.keys():
+		var times: int = current_interactions[args]
+		@warning_ignore("return_value_discarded")
+		collected_interactions.append(_format_arguments(args, times))
+
+	var arguments: Array = expected_interactions.keys()[0]
+	var interactions: int = expected_interactions.values()[0]
+	var expected_interaction := _format_arguments(arguments, interactions)
+	return "%s\n%s\n%s\n%s" % [
+			_error("Expecting interaction on:"), expected_interaction, _error("But found interactions on:"), "\n".join(collected_interactions)]
+
+
+static func _format_arguments(args :Array, times :int) -> String:
+	var fname :String = args[0]
+	var fargs := args.slice(1) as Array
+	var typed_args := _to_typed_args(fargs)
+	var fsignature := _colored_value("%s(%s)" % [fname, ", ".join(typed_args)])
+	return "	%s	%d time's" % [fsignature, times]
+
+
+static func _to_typed_args(args :Array) -> PackedStringArray:
+	var typed := PackedStringArray()
+	for arg :Variant in args:
+		@warning_ignore("return_value_discarded")
+		typed.append(_format_arg(arg) + " :" + GdObjects.type_as_string(typeof(arg)))
+	return typed
+
+
+static func _format_arg(arg :Variant) -> String:
+	if arg is InputEvent:
+		var ie: InputEvent = arg
+		return input_event_as_text(ie)
+	return str(arg)
+
+
+static func _find_first_diff(left :Array, right :Array) -> String:
+	for index in left.size():
+		var l :Variant = left[index]
+		var r :Variant = "<no entry>" if index >= right.size() else right[index]
+		if not GdObjects.equals(l, r):
+			return "at position %s\n '%s' vs '%s'" % [_colored_value(index), _typed_value(l), _typed_value(r)]
+	return ""
+
+
+static func error_has_size(current :Variant, expected: int) -> String:
+	@warning_ignore("unsafe_method_access")
+	var current_size :Variant = null if current == null else current.size()
+	return "%s\n %s\n but was\n %s" % [_error("Expecting size:"), _colored_value(expected), _colored_value(current_size)]
+
+
+static func error_contains_exactly(current: Array, expected: Array) -> String:
+	return "%s\n %s\n but was\n %s" % [_error("Expecting exactly equal:"), _colored_value(expected), _colored_value(current)]
+
+
+static func format_chars(characters: PackedInt32Array, type: Color) -> PackedInt32Array:
+	if characters.size() == 0:# or characters[0] == 10:
+		return characters
+
+	# Replace each control character with its readable form
+	var formatted_text := characters.to_byte_array().get_string_from_utf32()
+	for control_char: String in CONTROL_CHARS:
+		var replace_text: String = CONTROL_CHARS[control_char]
+		formatted_text = formatted_text.replace(control_char, replace_text)
+
+	# Handle special ASCII control characters (0x00-0x1F, 0x7F)
+	var ascii_text := ""
+	for i in formatted_text.length():
+		var character := formatted_text[i]
+		var code := character.unicode_at(0)
+		if code < 0x20 and not CONTROL_CHARS.has(character):  # Control characters not handled above
+			ascii_text += "<0x%02X>" % code
+		elif code == 0x7F:  # DEL character
+			ascii_text += "<DEL>"
+		else:
+			ascii_text += character
+
+	var message := "[bgcolor=#%s][color=white]%s[/color][/bgcolor]" % [
+		type.to_html(),
+		ascii_text
+	]
+
+	var result := PackedInt32Array()
+	result.append_array(message.to_utf32_buffer().to_int32_array())
+	return result
+
+
+static func format_invalid(value :String) -> String:
+	return "[bgcolor=#%s][color=with]%s[/color][/bgcolor]" % [SUB_COLOR.to_html(), value]
+
+
+static func humanized(value :String) -> String:
+	return value.replace("_", " ")
+
+
+static func build_failure_message(failure :String, additional_failure_message: String, custom_failure_message: String) -> String:
+	var message := failure if custom_failure_message.is_empty() else custom_failure_message
+	if additional_failure_message.is_empty():
+		return message
+	return """
+		%s
+		[color=LIME_GREEN][b]Additional info:[/b][/color]
+		 %s""".dedent().trim_prefix("\n") % [message, additional_failure_message]
+
+
+static func is_empty(value: Variant) -> bool:
+	var arry_value: Array = value
+	return arry_value != null and arry_value.is_empty()

addons/gdUnit4/src/asserts/GdAssertMessages.gd.uid

@@ -0,0 +1 @@
+uid://c178wdncle4i5

addons/gdUnit4/src/asserts/GdAssertReports.gd

@@ -0,0 +1,54 @@
+class_name GdAssertReports
+extends RefCounted
+
+const LAST_ERROR = "last_assert_error_message"
+const LAST_ERROR_LINE = "last_assert_error_line"
+
+
+static func report_success() -> void:
+	GdUnitSignals.instance().gdunit_set_test_failed.emit(false)
+	GdAssertReports.set_last_error_line_number(-1)
+	Engine.remove_meta(LAST_ERROR)
+
+
+static func report_warning(message :String, line_number :int) -> void:
+	GdUnitSignals.instance().gdunit_set_test_failed.emit(false)
+	send_report(GdUnitReport.new().create(GdUnitReport.WARN, line_number, message))
+
+
+static func report_error(message:String, line_number :int) -> void:
+	GdUnitSignals.instance().gdunit_set_test_failed.emit(true)
+	GdAssertReports.set_last_error_line_number(line_number)
+	Engine.set_meta(LAST_ERROR, message)
+	# if we expect to fail we handle as success test
+	if _do_expect_assert_failing():
+		return
+	send_report(GdUnitReport.new().create(GdUnitReport.FAILURE, line_number, message))
+
+
+static func reset_last_error_line_number() -> void:
+	Engine.remove_meta(LAST_ERROR_LINE)
+
+
+static func set_last_error_line_number(line_number :int) -> void:
+	Engine.set_meta(LAST_ERROR_LINE, line_number)
+
+
+static func get_last_error_line_number() -> int:
+	if Engine.has_meta(LAST_ERROR_LINE):
+		return Engine.get_meta(LAST_ERROR_LINE)
+	return -1
+
+
+static func _do_expect_assert_failing() -> bool:
+	if Engine.has_meta(GdUnitConstants.EXPECT_ASSERT_REPORT_FAILURES):
+		return Engine.get_meta(GdUnitConstants.EXPECT_ASSERT_REPORT_FAILURES)
+	return false
+
+
+static func current_failure() -> String:
+	return Engine.get_meta(LAST_ERROR)
+
+
+static func send_report(report :GdUnitReport) -> void:
+	GdUnitThreadManager.get_current_context().get_execution_context().add_report(report)

addons/gdUnit4/src/asserts/GdAssertReports.gd.uid

@@ -0,0 +1 @@
+uid://5fthlxduiurg

addons/gdUnit4/src/asserts/GdUnitArrayAssertImpl.gd

@@ -0,0 +1,424 @@
+class_name GdUnitArrayAssertImpl
+extends GdUnitArrayAssert
+
+
+var _base: GdUnitAssertImpl
+var _current_value_provider: ValueProvider
+var _type_check: bool
+
+
+func _init(current: Variant, type_check := true) -> void:
+	_type_check = type_check
+	_current_value_provider = DefaultValueProvider.new(current)
+	_base = GdUnitAssertImpl.new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not _validate_value_type(current):
+		@warning_ignore("return_value_discarded")
+		report_error("GdUnitArrayAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event: int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func report_success() -> GdUnitArrayAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_success()
+	return self
+
+
+func report_error(error: String) -> GdUnitArrayAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base.failure_message()
+
+
+func override_failure_message(message: String) -> GdUnitArrayAssert:
+	@warning_ignore("return_value_discarded")
+	_base.override_failure_message(message)
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitArrayAssert:
+	@warning_ignore("return_value_discarded")
+	_base.append_failure_message(message)
+	return self
+
+
+func _validate_value_type(value: Variant) -> bool:
+	return value == null or GdArrayTools.is_array_type(value)
+
+
+func get_current_value() -> Variant:
+	return _current_value_provider.get_value()
+
+
+func max_length(left: Variant, right: Variant) -> int:
+	var ls := str(left).length()
+	var rs := str(right).length()
+	return rs if ls < rs else ls
+
+
+# gdlint: disable=function-name
+func _toPackedStringArray(value: Variant) -> PackedStringArray:
+	if GdArrayTools.is_array_type(value):
+		@warning_ignore("unsafe_cast")
+		return PackedStringArray(value as Array)
+	return PackedStringArray([str(value)])
+
+
+func _array_equals_div(current: Variant, expected: Variant, case_sensitive: bool = false) -> Array:
+	var current_value := _toPackedStringArray(current)
+	var expected_value := _toPackedStringArray(expected)
+	var index_report := Array()
+	for index in current_value.size():
+		var c := current_value[index]
+		if index < expected_value.size():
+			var e := expected_value[index]
+			if not GdObjects.equals(c, e, case_sensitive):
+				var length := max_length(c, e)
+				current_value[index] = GdAssertMessages.format_invalid(c.lpad(length))
+				expected_value[index] = e.lpad(length)
+				index_report.push_back({"index": index, "current": c, "expected": e})
+		else:
+			current_value[index] = GdAssertMessages.format_invalid(c)
+			index_report.push_back({"index": index, "current": c, "expected": "<N/A>"})
+
+	for index in range(current_value.size(), expected_value.size()):
+		var value := expected_value[index]
+		expected_value[index] = GdAssertMessages.format_invalid(value)
+		index_report.push_back({"index": index, "current": "<N/A>", "expected": value})
+	return [current_value, expected_value, index_report]
+
+
+func _array_div(compare_mode: GdObjects.COMPARE_MODE, left: Array[Variant], right: Array[Variant], _same_order := false) -> Array[Variant]:
+	var not_expect := left.duplicate(true)
+	var not_found := right.duplicate(true)
+	for index_c in left.size():
+		var c: Variant = left[index_c]
+		for index_e in right.size():
+			var e: Variant = right[index_e]
+			if GdObjects.equals(c, e, false, compare_mode):
+				GdArrayTools.erase_value(not_expect, e)
+				GdArrayTools.erase_value(not_found, c)
+				break
+	return [not_expect, not_found]
+
+
+func _contains(expected: Array, compare_mode: GdObjects.COMPARE_MODE) -> GdUnitArrayAssert:
+	var by_reference := compare_mode == GdObjects.COMPARE_MODE.OBJECT_REFERENCE
+	var current_value: Variant = get_current_value()
+	var expected_value: Variant = _extract_variadic_value(expected)
+	if not _validate_value_type(expected_value):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected_value))
+
+	if current_value == null:
+		return report_error(GdAssertMessages.error_arr_contains(current_value, expected_value, [], expected_value, by_reference))
+	@warning_ignore("unsafe_cast")
+	var diffs := _array_div(compare_mode, current_value as Array[Variant], expected_value as Array[Variant])
+	#var not_expect := diffs[0] as Array
+	var not_found: Array = diffs[1]
+	if not not_found.is_empty():
+		return report_error(GdAssertMessages.error_arr_contains(current_value, expected_value, [], not_found, by_reference))
+	return report_success()
+
+
+func _contains_exactly(expected: Array, compare_mode: GdObjects.COMPARE_MODE) -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	var expected_value: Variant = _extract_variadic_value(expected)
+	if not _validate_value_type(expected_value):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected_value))
+
+	if current_value == null:
+		return report_error(GdAssertMessages.error_arr_contains_exactly(null, expected_value, [], expected_value, compare_mode))
+	# has same content in same order
+	if _is_equal(current_value, expected_value, false, compare_mode):
+		return report_success()
+	# check has same elements but in different order
+	if _is_equals_sorted(current_value, expected_value, false, compare_mode):
+		return report_error(GdAssertMessages.error_arr_contains_exactly(current_value, expected_value, [], [], compare_mode))
+	# find the difference
+	@warning_ignore("unsafe_cast")
+	var diffs := _array_div(compare_mode,
+		current_value as Array[Variant],
+		expected_value as Array[Variant],
+		GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+	var not_expect: Array[Variant] = diffs[0]
+	var not_found: Array[Variant] = diffs[1]
+	return report_error(GdAssertMessages.error_arr_contains_exactly(current_value, expected_value, not_expect, not_found, compare_mode))
+
+
+func _contains_exactly_in_any_order(expected: Array, compare_mode: GdObjects.COMPARE_MODE) -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	var expected_value: Variant = _extract_variadic_value(expected)
+	if not _validate_value_type(expected_value):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected_value))
+
+	if current_value == null:
+		return report_error(GdAssertMessages.error_arr_contains_exactly_in_any_order(current_value, expected_value, [],
+			expected_value, compare_mode))
+	# find the difference
+	@warning_ignore("unsafe_cast")
+	var diffs := _array_div(compare_mode, current_value as Array[Variant], expected_value as Array[Variant], false)
+	var not_expect: Array[Variant] = diffs[0]
+	var not_found: Array[Variant] = diffs[1]
+	if not_expect.is_empty() and not_found.is_empty():
+		return report_success()
+	return report_error(GdAssertMessages.error_arr_contains_exactly_in_any_order(current_value, expected_value, not_expect,
+		not_found, compare_mode))
+
+
+func _not_contains(expected: Array, compare_mode: GdObjects.COMPARE_MODE) -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	var expected_value: Variant = _extract_variadic_value(expected)
+	if not _validate_value_type(expected_value):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected_value))
+	if current_value == null:
+		return report_error(GdAssertMessages.error_arr_contains_exactly_in_any_order(current_value, expected_value, [],
+			expected_value, compare_mode))
+	@warning_ignore("unsafe_cast")
+	var diffs := _array_div(compare_mode, current_value as Array[Variant], expected_value as Array[Variant])
+	var found: Array[Variant] = diffs[0]
+	@warning_ignore("unsafe_cast")
+	if found.size() == (current_value as Array).size():
+		return report_success()
+	@warning_ignore("unsafe_cast")
+	var diffs2 := _array_div(compare_mode, expected_value as Array[Variant], diffs[1] as Array[Variant])
+	return report_error(GdAssertMessages.error_arr_not_contains(current_value, expected_value, diffs2[0], compare_mode))
+
+
+func is_null() -> GdUnitArrayAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitArrayAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_null()
+	return self
+
+
+func is_equal(...expected: Array) -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	var expected_value: Variant= _extract_variadic_value(expected)
+	if not _validate_value_type(expected_value):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected_value))
+	if current_value == null and expected_value != null:
+		return report_error(GdAssertMessages.error_equal(null, expected_value))
+
+	if not _is_equal(current_value, expected_value):
+		var diff := _array_equals_div(current_value, expected_value)
+		var expected_as_list := GdArrayTools.as_string(diff[0], false)
+		var current_as_list := GdArrayTools.as_string(diff[1], false)
+		var index_report: Array = diff[2]
+		return report_error(GdAssertMessages.error_equal(expected_as_list, current_as_list, index_report))
+	return report_success()
+
+
+# Verifies that the current Array is equal to the given one, ignoring case considerations.
+func is_equal_ignoring_case(...expected: Array) -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	var expected_value: Variant = _extract_variadic_value(expected)
+	if not _validate_value_type(expected_value):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected_value))
+	if current_value == null and expected_value != null:
+		@warning_ignore("unsafe_cast")
+		return report_error(GdAssertMessages.error_equal(null, GdArrayTools.as_string(expected_value)))
+
+	if not _is_equal(current_value, expected_value, true):
+		@warning_ignore("unsafe_cast")
+		var diff := _array_equals_div(current_value, expected_value, true)
+		var expected_as_list := GdArrayTools.as_string(diff[0])
+		var current_as_list := GdArrayTools.as_string(diff[1])
+		var index_report: Array = diff[2]
+		return report_error(GdAssertMessages.error_equal(expected_as_list, current_as_list, index_report))
+	return report_success()
+
+
+func is_not_equal(...expected: Array) -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	var expected_value: Variant = _extract_variadic_value(expected)
+	if not _validate_value_type(expected_value):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected_value))
+
+	if _is_equal(current_value, expected_value):
+		return report_error(GdAssertMessages.error_not_equal(current_value, expected_value))
+	return report_success()
+
+
+func is_not_equal_ignoring_case(...expected: Array) -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	var expected_value: Variant = _extract_variadic_value(expected)
+	if not _validate_value_type(expected_value):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected_value))
+
+	if _is_equal(current_value, expected_value, true):
+		@warning_ignore("unsafe_cast")
+		var c := GdArrayTools.as_string(current_value as Array)
+		@warning_ignore("unsafe_cast")
+		var e := GdArrayTools.as_string(expected_value)
+		return report_error(GdAssertMessages.error_not_equal_case_insensetiv(c, e))
+	return report_success()
+
+
+func is_empty() -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	@warning_ignore("unsafe_cast")
+	if current_value == null or (current_value as Array).size() > 0:
+		return report_error(GdAssertMessages.error_is_empty(current_value))
+	return report_success()
+
+
+func is_not_empty() -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	@warning_ignore("unsafe_cast")
+	if current_value != null and (current_value as Array).size() == 0:
+		return report_error(GdAssertMessages.error_is_not_empty())
+	return report_success()
+
+
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_same(expected: Variant) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current: Variant = get_current_value()
+	if not is_same(current, expected):
+		@warning_ignore("return_value_discarded")
+		report_error(GdAssertMessages.error_is_same(current, expected))
+	return self
+
+
+func is_not_same(expected: Variant) -> GdUnitArrayAssert:
+	if not _validate_value_type(expected):
+		return report_error("ERROR: expected value: <%s>\n is not a Array Type!" % GdObjects.typeof_as_string(expected))
+	var current: Variant = get_current_value()
+	if is_same(current, expected):
+		@warning_ignore("return_value_discarded")
+		report_error(GdAssertMessages.error_not_same(current, expected))
+	return self
+
+
+func has_size(expected: int) -> GdUnitArrayAssert:
+	var current_value: Variant = get_current_value()
+	@warning_ignore("unsafe_cast")
+	if current_value == null or (current_value as Array).size() != expected:
+		return report_error(GdAssertMessages.error_has_size(current_value, expected))
+	return report_success()
+
+
+func contains(...expected: Array) -> GdUnitArrayAssert:
+	return _contains(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_exactly(...expected: Array) -> GdUnitArrayAssert:
+	return _contains_exactly(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_exactly_in_any_order(...expected: Array) -> GdUnitArrayAssert:
+	return _contains_exactly_in_any_order(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_same(...expected: Array) -> GdUnitArrayAssert:
+	return _contains(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func contains_same_exactly(...expected: Array) -> GdUnitArrayAssert:
+	return _contains_exactly(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func contains_same_exactly_in_any_order(...expected: Array) -> GdUnitArrayAssert:
+	return _contains_exactly_in_any_order(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func not_contains(...expected: Array) -> GdUnitArrayAssert:
+	return _not_contains(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func not_contains_same(...expected: Array) -> GdUnitArrayAssert:
+	return _not_contains(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func is_instanceof(expected: Variant) -> GdUnitAssert:
+	@warning_ignore("unsafe_method_access")
+	_base.is_instanceof(expected)
+	return self
+
+
+func extract(func_name: String, ...func_args: Array) -> GdUnitArrayAssert:
+	var extracted_elements := Array()
+	var args: Array = _extract_variadic_value(func_args)
+	var extractor := GdUnitFuncValueExtractor.new(func_name, args)
+	var current: Variant = get_current_value()
+	if current == null:
+		_current_value_provider = DefaultValueProvider.new(null)
+	else:
+		for element: Variant in current:
+			extracted_elements.append(extractor.extract_value(element))
+		_current_value_provider = DefaultValueProvider.new(extracted_elements)
+	return self
+
+
+func extractv(...extractors: Array) -> GdUnitArrayAssert:
+	var extracted_elements := Array()
+	var current: Variant = get_current_value()
+	if current == null:
+		_current_value_provider = DefaultValueProvider.new(null)
+	else:
+		for element: Variant in current:
+			var ev: Array[Variant] = []
+			for index: int in extractors.size():
+				var extractor: GdUnitValueExtractor = extractors[index]
+				ev.append(extractor.extract_value(element))
+			if extractors.size() > 1:
+				extracted_elements.append(GdUnitTuple.new.callv(ev))
+			else:
+				extracted_elements.append(ev[0])
+		_current_value_provider = DefaultValueProvider.new(extracted_elements)
+	return self
+
+
+## Small helper to support the old expected arguments as single array and variadic arguments
+func _extract_variadic_value(values: Variant) -> Variant:
+	@warning_ignore("unsafe_method_access")
+	if values != null and values.size() == 1 and GdArrayTools.is_array_type(values[0]):
+		return values[0]
+	return values
+
+
+@warning_ignore("incompatible_ternary")
+func _is_equal(
+	left: Variant,
+	right: Variant,
+	case_sensitive := false,
+	compare_mode := GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST) -> bool:
+
+	@warning_ignore("unsafe_cast")
+	return GdObjects.equals(
+		(left as Array) if GdArrayTools.is_array_type(left) else left,
+		(right as Array) if GdArrayTools.is_array_type(right) else right,
+		case_sensitive,
+		compare_mode
+	)
+
+
+func _is_equals_sorted(
+	left: Variant,
+	right: Variant,
+	case_sensitive := false,
+	compare_mode := GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST) -> bool:
+
+	@warning_ignore("unsafe_cast")
+	return GdObjects.equals_sorted(
+		left as Array,
+		right as Array,
+		case_sensitive,
+		compare_mode)

addons/gdUnit4/src/asserts/GdUnitArrayAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://381c6r7r5uhp

addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd

@@ -0,0 +1,80 @@
+class_name GdUnitAssertImpl
+extends GdUnitAssert
+
+
+var _current :Variant
+var _current_failure_message :String = ""
+var _custom_failure_message :String = ""
+var _additional_failure_message: String = ""
+
+
+func _init(current :Variant) -> void:
+	_current = current
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	GdAssertReports.reset_last_error_line_number()
+
+
+
+func failure_message() -> String:
+	return _current_failure_message
+
+
+func current_value() -> Variant:
+	return _current
+
+
+func report_success() -> GdUnitAssert:
+	GdAssertReports.report_success()
+	return self
+
+
+func report_error(failure :String, failure_line_number: int = -1) -> GdUnitAssert:
+	var line_number := failure_line_number if failure_line_number != -1 else GdUnitAssertions.get_line_number()
+	GdAssertReports.set_last_error_line_number(line_number)
+	_current_failure_message = GdAssertMessages.build_failure_message(failure, _additional_failure_message, _custom_failure_message)
+	GdAssertReports.report_error(_current_failure_message, line_number)
+	Engine.set_meta("GD_TEST_FAILURE", true)
+	return self
+
+
+func do_fail() -> GdUnitAssert:
+	return report_error(GdAssertMessages.error_not_implemented())
+
+
+func override_failure_message(message: String) -> GdUnitAssert:
+	_custom_failure_message = message
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitAssert:
+	_additional_failure_message = message
+	return self
+
+
+func is_null() -> GdUnitAssert:
+	var current :Variant = current_value()
+	if current != null:
+		return report_error(GdAssertMessages.error_is_null(current))
+	return report_success()
+
+
+func is_not_null() -> GdUnitAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	return report_success()
+
+
+func is_equal(expected: Variant) -> GdUnitAssert:
+	var current: Variant = current_value()
+	if not GdObjects.equals(current, expected):
+		return report_error(GdAssertMessages.error_equal(current, expected))
+	return report_success()
+
+
+func is_not_equal(expected: Variant) -> GdUnitAssert:
+	var current: Variant = current_value()
+	if GdObjects.equals(current, expected):
+		return report_error(GdAssertMessages.error_not_equal(current, expected))
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://8c05oepulju5

addons/gdUnit4/src/asserts/GdUnitAssertions.gd

@@ -0,0 +1,68 @@
+# Preloads all GdUnit assertions
+class_name GdUnitAssertions
+extends RefCounted
+
+
+@warning_ignore("return_value_discarded")
+func _init() -> void:
+	# preload all gdunit assertions to speedup testsuite loading time
+	# gdlint:disable=private-method-call
+	@warning_ignore_start("return_value_discarded")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitBoolAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitStringAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitIntAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFloatAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitVectorAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitArrayAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitDictionaryAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFileAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitObjectAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitResultAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFuncAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitSignalAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd")
+	GdUnitAssertions.__lazy_load("res://addons/gdUnit4/src/asserts/GdUnitGodotErrorAssertImpl.gd")
+	@warning_ignore_restore("return_value_discarded")
+
+
+### We now load all used asserts and tool scripts into the cache according to the principle of "lazy loading"
+### in order to noticeably reduce the loading time of the test suite.
+# We go this hard way to increase the loading performance to avoid reparsing all the used scripts
+# for more detailed info -> https://github.com/godotengine/godot/issues/67400
+# gdlint:disable=function-name
+static func __lazy_load(script_path :String) -> GDScript:
+	return ResourceLoader.load(script_path, "GDScript", ResourceLoader.CACHE_MODE_REUSE)
+
+
+static func validate_value_type(value :Variant, type :Variant.Type) -> bool:
+	return value == null or typeof(value) == type
+
+
+# Scans the current stack trace for the root cause to extract the line number
+static func get_line_number() -> int:
+	var stack_trace := get_stack()
+	if stack_trace == null or stack_trace.is_empty():
+		return -1
+	for index in stack_trace.size():
+		var stack_info :Dictionary = stack_trace[index]
+		var function :String = stack_info.get("function")
+		# we catch helper asserts to skip over to return the correct line number
+		if function.begins_with("assert_"):
+			continue
+		if function.begins_with("test_"):
+			return stack_info.get("line")
+		var source :String = stack_info.get("source")
+		if source.is_empty() \
+			or source.begins_with("user://") \
+			or source.ends_with("GdUnitAssert.gd") \
+			or source.ends_with("GdUnitAssertions.gd") \
+			or source.ends_with("AssertImpl.gd") \
+			or source.ends_with("GdUnitTestSuite.gd") \
+			or source.ends_with("GdUnitSceneRunnerImpl.gd") \
+			or source.ends_with("GdUnitObjectInteractions.gd") \
+			or source.ends_with("GdUnitObjectInteractionsVerifier.gd") \
+			or source.ends_with("GdUnitAwaiter.gd"):
+			continue
+		return stack_info.get("line")
+	return -1

addons/gdUnit4/src/asserts/GdUnitAssertions.gd.uid

@@ -0,0 +1 @@
+uid://crrhhudfmy3ay

addons/gdUnit4/src/asserts/GdUnitBoolAssertImpl.gd

@@ -0,0 +1,87 @@
+extends GdUnitBoolAssert
+
+var _base: GdUnitAssertImpl
+
+
+func _init(current :Variant) -> void:
+	_base = GdUnitAssertImpl.new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_BOOL):
+		@warning_ignore("return_value_discarded")
+		report_error("GdUnitBoolAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitBoolAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitBoolAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base.failure_message()
+
+
+func override_failure_message(message: String) -> GdUnitBoolAssert:
+	@warning_ignore("return_value_discarded")
+	_base.override_failure_message(message)
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitBoolAssert:
+	@warning_ignore("return_value_discarded")
+	_base.append_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitBoolAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitBoolAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected: Variant) -> GdUnitBoolAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected: Variant) -> GdUnitBoolAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_equal(expected)
+	return self
+
+
+func is_true() -> GdUnitBoolAssert:
+	if current_value() != true:
+		return report_error(GdAssertMessages.error_is_true(current_value()))
+	return report_success()
+
+
+func is_false() -> GdUnitBoolAssert:
+	if current_value() == true || current_value() == null:
+		return report_error(GdAssertMessages.error_is_false(current_value()))
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitBoolAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://c310wp8sog1ti

addons/gdUnit4/src/asserts/GdUnitDictionaryAssertImpl.gd

@@ -0,0 +1,207 @@
+extends GdUnitDictionaryAssert
+
+var _base: GdUnitAssertImpl
+
+
+func _init(current :Variant) -> void:
+	_base = GdUnitAssertImpl.new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_DICTIONARY):
+		@warning_ignore("return_value_discarded")
+		report_error("GdUnitDictionaryAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func report_success() -> GdUnitDictionaryAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitDictionaryAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base.failure_message()
+
+
+func override_failure_message(message: String) -> GdUnitDictionaryAssert:
+	@warning_ignore("return_value_discarded")
+	_base.override_failure_message(message)
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitDictionaryAssert:
+	@warning_ignore("return_value_discarded")
+	_base.append_failure_message(message)
+	return self
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func is_null() -> GdUnitDictionaryAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitDictionaryAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected: Variant) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_equal(null, GdAssertMessages.format_dict(expected)))
+	if not GdObjects.equals(current, expected):
+		var c := GdAssertMessages.format_dict(current)
+		var e := GdAssertMessages.format_dict(expected)
+		return report_error(GdAssertMessages.error_equal(c, e))
+	return report_success()
+
+
+func is_not_equal(expected: Variant) -> GdUnitDictionaryAssert:
+	var current: Variant = current_value()
+	if GdObjects.equals(current, expected):
+		return report_error(GdAssertMessages.error_not_equal(current, expected))
+	return report_success()
+
+
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_same(expected :Variant) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_equal(null, GdAssertMessages.format_dict(expected)))
+	if not is_same(current, expected):
+		var c := GdAssertMessages.format_dict(current)
+		var e := GdAssertMessages.format_dict(expected)
+		return report_error(GdAssertMessages.error_is_same(c, e))
+	return report_success()
+
+
+@warning_ignore("unused_parameter", "shadowed_global_identifier")
+func is_not_same(expected :Variant) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if is_same(current, expected):
+		return report_error(GdAssertMessages.error_not_same(current, expected))
+	return report_success()
+
+
+func is_empty() -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current == null or not (current as Dictionary).is_empty():
+		return report_error(GdAssertMessages.error_is_empty(current))
+	return report_success()
+
+
+func is_not_empty() -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current == null or (current as Dictionary).is_empty():
+		return report_error(GdAssertMessages.error_is_not_empty())
+	return report_success()
+
+
+func has_size(expected: int) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	@warning_ignore("unsafe_cast")
+	if (current as Dictionary).size() != expected:
+		return report_error(GdAssertMessages.error_has_size(current, expected))
+	return report_success()
+
+
+func _contains_keys(expected: Array, compare_mode: GdObjects.COMPARE_MODE) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	var expected_value: Array = _extract_variadic_value(expected)
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	# find expected keys
+	@warning_ignore("unsafe_cast")
+	var keys_not_found :Array = expected_value.filter(_filter_by_key.bind((current as Dictionary).keys(), compare_mode))
+	if not keys_not_found.is_empty():
+		@warning_ignore("unsafe_cast")
+		return report_error(GdAssertMessages.error_contains_keys((current as Dictionary).keys() as Array, expected_value,
+			keys_not_found, compare_mode))
+	return report_success()
+
+
+func _contains_key_value(key :Variant, value :Variant, compare_mode :GdObjects.COMPARE_MODE) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	var expected := [key]
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	var dict_current: Dictionary = current
+	var keys_not_found :Array = expected.filter(_filter_by_key.bind(dict_current.keys(), compare_mode))
+	if not keys_not_found.is_empty():
+		return report_error(GdAssertMessages.error_contains_keys(dict_current.keys() as Array, expected, keys_not_found, compare_mode))
+	if not GdObjects.equals(dict_current[key], value, false, compare_mode):
+		return report_error(GdAssertMessages.error_contains_key_value(key, value, dict_current[key], compare_mode))
+	return report_success()
+
+
+func _not_contains_keys(expected: Array, compare_mode: GdObjects.COMPARE_MODE) -> GdUnitDictionaryAssert:
+	var current :Variant = current_value()
+	var expected_value: Array = _extract_variadic_value(expected)
+	if current == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	var dict_current: Dictionary = current
+	var keys_found :Array = dict_current.keys().filter(_filter_by_key.bind(expected_value, compare_mode, true))
+	if not keys_found.is_empty():
+		return report_error(GdAssertMessages.error_not_contains_keys(dict_current.keys() as Array, expected_value, keys_found, compare_mode))
+	return report_success()
+
+
+func contains_keys(...expected: Array) -> GdUnitDictionaryAssert:
+	return _contains_keys(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_key_value(key :Variant, value :Variant) -> GdUnitDictionaryAssert:
+	return _contains_key_value(key, value, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func not_contains_keys(...expected: Array) -> GdUnitDictionaryAssert:
+	return _not_contains_keys(expected, GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST)
+
+
+func contains_same_keys(expected :Array) -> GdUnitDictionaryAssert:
+	return _contains_keys(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func contains_same_key_value(key :Variant, value :Variant) -> GdUnitDictionaryAssert:
+	return _contains_key_value(key, value, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func not_contains_same_keys(...expected: Array) -> GdUnitDictionaryAssert:
+	return _not_contains_keys(expected, GdObjects.COMPARE_MODE.OBJECT_REFERENCE)
+
+
+func _filter_by_key(element :Variant, values :Array, compare_mode :GdObjects.COMPARE_MODE, is_not :bool = false) -> bool:
+	for key :Variant in values:
+		if GdObjects.equals(key, element, false, compare_mode):
+			return is_not
+	return !is_not
+
+
+## Small helper to support the old expected arguments as single array and variadic arguments
+func _extract_variadic_value(values: Variant) -> Variant:
+	@warning_ignore("unsafe_method_access")
+	if values != null and values.size() == 1 and GdArrayTools.is_array_type(values[0]):
+		return values[0]
+	return values

addons/gdUnit4/src/asserts/GdUnitDictionaryAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://diqntuiv0y7pg

addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd

@@ -0,0 +1,136 @@
+extends GdUnitFailureAssert
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+var _is_failed := false
+var _failure_message: String
+var _current_failure_message := ""
+var _custom_failure_message := ""
+var _additional_failure_message := ""
+
+
+func _set_do_expect_fail(enabled :bool = true) -> void:
+	Engine.set_meta(GdUnitConstants.EXPECT_ASSERT_REPORT_FAILURES, enabled)
+
+
+func execute_and_await(assertion :Callable, do_await := true) -> GdUnitFailureAssert:
+	# do not report any failure from the original assertion we want to test
+	_set_do_expect_fail(true)
+	var thread_context := GdUnitThreadManager.get_current_context()
+	thread_context.set_assert(null)
+	@warning_ignore("return_value_discarded")
+	GdUnitSignals.instance().gdunit_set_test_failed.connect(_on_test_failed)
+	# execute the given assertion as callable
+	if do_await:
+		await assertion.call()
+	else:
+		assertion.call()
+	_set_do_expect_fail(false)
+	# get the assert instance from current tread context
+	var current_assert := thread_context.get_assert()
+	if not is_instance_of(current_assert, GdUnitAssert):
+		_is_failed = true
+		_failure_message = "Invalid Callable! It must be a callable of 'GdUnitAssert'"
+		return self
+	@warning_ignore("unsafe_method_access")
+	_failure_message = current_assert.failure_message()
+	return self
+
+
+func execute(assertion :Callable) -> GdUnitFailureAssert:
+	@warning_ignore("return_value_discarded")
+	execute_and_await(assertion, false)
+	return self
+
+
+func _on_test_failed(value :bool) -> void:
+	_is_failed = value
+
+
+func is_equal(_expected: Variant) -> GdUnitFailureAssert:
+	return _report_error("Not implemented")
+
+
+func is_not_equal(_expected: Variant) -> GdUnitFailureAssert:
+	return _report_error("Not implemented")
+
+
+func is_null() -> GdUnitFailureAssert:
+	return _report_error("Not implemented")
+
+
+func is_not_null() -> GdUnitFailureAssert:
+	return _report_error("Not implemented")
+
+
+func override_failure_message(message: String) -> GdUnitFailureAssert:
+	_custom_failure_message = message
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitFailureAssert:
+	_additional_failure_message = message
+	return self
+
+
+func is_success() -> GdUnitFailureAssert:
+	if _is_failed:
+		return _report_error("Expect: assertion ends successfully.")
+	return self
+
+
+func is_failed() -> GdUnitFailureAssert:
+	if not _is_failed:
+		return _report_error("Expect: assertion fails.")
+	return self
+
+
+func has_line(expected :int) -> GdUnitFailureAssert:
+	var current := GdAssertReports.get_last_error_line_number()
+	if current != expected:
+		return _report_error("Expect: to failed on line '%d'\n but was '%d'." % [expected, current])
+	return self
+
+
+func has_message(expected :String) -> GdUnitFailureAssert:
+	@warning_ignore("return_value_discarded")
+	is_failed()
+	var expected_error := GdUnitTools.normalize_text(GdUnitTools.richtext_normalize(expected))
+	var current_error := GdUnitTools.normalize_text(GdUnitTools.richtext_normalize(_failure_message))
+	if current_error != expected_error:
+		var diffs := GdDiffTool.string_diff(current_error, expected_error)
+		var current := GdAssertMessages.colored_array_div(diffs[1])
+		return _report_error(GdAssertMessages.error_not_same_error(current, expected_error))
+	return self
+
+
+func contains_message(expected :String) -> GdUnitFailureAssert:
+	var expected_error := GdUnitTools.normalize_text(expected)
+	var current_error := GdUnitTools.normalize_text(GdUnitTools.richtext_normalize(_failure_message))
+	if not current_error.contains(expected_error):
+		var diffs := GdDiffTool.string_diff(current_error, expected_error)
+		var current := GdAssertMessages.colored_array_div(diffs[1])
+		return _report_error(GdAssertMessages.error_not_same_error(current, expected_error))
+	return self
+
+
+func starts_with_message(expected :String) -> GdUnitFailureAssert:
+	var expected_error := GdUnitTools.normalize_text(expected)
+	var current_error := GdUnitTools.normalize_text(GdUnitTools.richtext_normalize(_failure_message))
+	if current_error.find(expected_error) != 0:
+		var diffs := GdDiffTool.string_diff(current_error, expected_error)
+		var current := GdAssertMessages.colored_array_div(diffs[1])
+		return _report_error(GdAssertMessages.error_not_same_error(current, expected_error))
+	return self
+
+
+func _report_error(error_message :String, failure_line_number: int = -1) -> GdUnitAssert:
+	var line_number := failure_line_number if failure_line_number != -1 else GdUnitAssertions.get_line_number()
+	_current_failure_message = GdAssertMessages.build_failure_message(error_message, _additional_failure_message, _custom_failure_message)
+	GdAssertReports.report_error(_current_failure_message, line_number)
+	return self
+
+
+func _report_success() -> GdUnitFailureAssert:
+	GdAssertReports.report_success()
+	return self

addons/gdUnit4/src/asserts/GdUnitFailureAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://b8htynygoyy0f

addons/gdUnit4/src/asserts/GdUnitFileAssertImpl.gd

@@ -0,0 +1,116 @@
+extends GdUnitFileAssert
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+
+var _base: GdUnitAssertImpl
+
+
+func _init(current :Variant) -> void:
+	_base = GdUnitAssertImpl.new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_STRING):
+		@warning_ignore("return_value_discarded")
+		report_error("GdUnitFileAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> String:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitFileAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitFileAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base.failure_message()
+
+
+func override_failure_message(message: String) -> GdUnitFileAssert:
+	@warning_ignore("return_value_discarded")
+	_base.override_failure_message(message)
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitFileAssert:
+	@warning_ignore("return_value_discarded")
+	_base.append_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitFileAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitFileAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected: Variant) -> GdUnitFileAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected: Variant) -> GdUnitFileAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_equal(expected)
+	return self
+
+
+func is_file() -> GdUnitFileAssert:
+	var current := current_value()
+	if FileAccess.open(current, FileAccess.READ) == null:
+		return report_error("Is not a file '%s', error code %s" % [current, FileAccess.get_open_error()])
+	return report_success()
+
+
+func exists() -> GdUnitFileAssert:
+	var current := current_value()
+	if not FileAccess.file_exists(current):
+		return report_error("The file '%s' not exists" %current)
+	return report_success()
+
+
+func is_script() -> GdUnitFileAssert:
+	var current := current_value()
+	if FileAccess.open(current, FileAccess.READ) == null:
+		return report_error("Can't acces the file '%s'! Error code %s" % [current, FileAccess.get_open_error()])
+
+	var script := load(current)
+	if not script is GDScript:
+		return report_error("The file '%s' is not a GdScript" % current)
+	return report_success()
+
+
+func contains_exactly(expected_rows: Array) -> GdUnitFileAssert:
+	var current := current_value()
+	if FileAccess.open(current, FileAccess.READ) == null:
+		return report_error("Can't acces the file '%s'! Error code %s" % [current, FileAccess.get_open_error()])
+
+	var script: GDScript = load(current)
+	if script is GDScript:
+		var source_code := GdScriptParser.to_unix_format(script.source_code)
+		var rows := Array(source_code.split("\n"))
+		@warning_ignore("return_value_discarded")
+		GdUnitArrayAssertImpl.new(rows).contains_exactly(expected_rows)
+	return self

addons/gdUnit4/src/asserts/GdUnitFileAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://dg0uusgasnr64

addons/gdUnit4/src/asserts/GdUnitFloatAssertImpl.gd

@@ -0,0 +1,159 @@
+extends GdUnitFloatAssert
+
+var _base: GdUnitAssertImpl
+
+
+func _init(current :Variant) -> void:
+	_base = GdUnitAssertImpl.new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_FLOAT):
+		@warning_ignore("return_value_discarded")
+		report_error("GdUnitFloatAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitFloatAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitFloatAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base.failure_message()
+
+
+func override_failure_message(message: String) -> GdUnitFloatAssert:
+	@warning_ignore("return_value_discarded")
+	_base.override_failure_message(message)
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitFloatAssert:
+	@warning_ignore("return_value_discarded")
+	_base.append_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitFloatAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitFloatAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected: Variant) -> GdUnitFloatAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected: Variant) -> GdUnitFloatAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_equal(expected)
+	return self
+
+
+@warning_ignore("shadowed_global_identifier")
+func is_equal_approx(expected :float, approx :float) -> GdUnitFloatAssert:
+	return is_between(expected-approx, expected+approx)
+
+
+func is_less(expected :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current >= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_THAN, current, expected))
+	return report_success()
+
+
+func is_less_equal(expected :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current > expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_EQUAL, current, expected))
+	return report_success()
+
+
+func is_greater(expected :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current <= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_THAN, current, expected))
+	return report_success()
+
+
+func is_greater_equal(expected :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current < expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_EQUAL, current, expected))
+	return report_success()
+
+
+func is_negative() -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current >= 0.0:
+		return report_error(GdAssertMessages.error_is_negative(current))
+	return report_success()
+
+
+func is_not_negative() -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current < 0.0:
+		return report_error(GdAssertMessages.error_is_not_negative(current))
+	return report_success()
+
+
+func is_zero() -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current == null or not is_equal_approx(0.00000000, current as float):
+		return report_error(GdAssertMessages.error_is_zero(current))
+	return report_success()
+
+
+func is_not_zero() -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current == null or is_equal_approx(0.00000000, current as float):
+		return report_error(GdAssertMessages.error_is_not_zero())
+	return report_success()
+
+
+func is_in(expected :Array) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if not expected.has(current):
+		return report_error(GdAssertMessages.error_is_in(current, expected))
+	return report_success()
+
+
+func is_not_in(expected :Array) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if expected.has(current):
+		return report_error(GdAssertMessages.error_is_not_in(current, expected))
+	return report_success()
+
+
+func is_between(from :float, to :float) -> GdUnitFloatAssert:
+	var current :Variant = current_value()
+	if current == null or current < from or current > to:
+		return report_error(GdAssertMessages.error_is_value(Comparator.BETWEEN_EQUAL, current, from, to))
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitFloatAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://fyb32t5gwdxk

addons/gdUnit4/src/asserts/GdUnitFuncAssertImpl.gd

@@ -0,0 +1,177 @@
+extends GdUnitFuncAssert
+
+
+const GdUnitTools := preload("res://addons/gdUnit4/src/core/GdUnitTools.gd")
+const DEFAULT_TIMEOUT := 2000
+
+
+var _current_value_provider :ValueProvider
+var _current_failure_message :String = ""
+var _custom_failure_message :String = ""
+var _additional_failure_message: String = ""
+var _line_number := -1
+var _timeout := DEFAULT_TIMEOUT
+var _interrupted := false
+var _sleep_timer :Timer = null
+
+
+func _init(instance :Object, func_name :String, args := Array()) -> void:
+	_line_number = GdUnitAssertions.get_line_number()
+	GdAssertReports.reset_last_error_line_number()
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	# verify at first the function name exists
+	if not instance.has_method(func_name):
+		@warning_ignore("return_value_discarded")
+		report_error("The function '%s' do not exists checked instance '%s'." % [func_name, instance])
+		_interrupted = true
+	else:
+		_current_value_provider = CallBackValueProvider.new(instance, func_name, args)
+
+
+func _notification(what :int) -> void:
+	if what == NOTIFICATION_PREDELETE:
+		_interrupted = true
+		var main_node :Node = (Engine.get_main_loop() as SceneTree).root
+		if is_instance_valid(_current_value_provider):
+			_current_value_provider.dispose()
+			_current_value_provider = null
+		if is_instance_valid(_sleep_timer):
+			_sleep_timer.set_wait_time(0.0001)
+			_sleep_timer.stop()
+			main_node.remove_child(_sleep_timer)
+			_sleep_timer.free()
+			_sleep_timer = null
+
+
+func report_success() -> GdUnitFuncAssert:
+	GdAssertReports.report_success()
+	return self
+
+
+func report_error(failure :String) -> GdUnitFuncAssert:
+	_current_failure_message = GdAssertMessages.build_failure_message(failure, _additional_failure_message, _custom_failure_message)
+	GdAssertReports.report_error(_current_failure_message, _line_number)
+	return self
+
+
+func failure_message() -> String:
+	return _current_failure_message
+
+
+func override_failure_message(message: String) -> GdUnitFuncAssert:
+	_custom_failure_message = message
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitFuncAssert:
+	_additional_failure_message = message
+	return self
+
+
+func wait_until(timeout := 2000) -> GdUnitFuncAssert:
+	if timeout <= 0:
+		push_warning("Invalid timeout param, alloed timeouts must be grater than 0. Use default timeout instead")
+		_timeout = DEFAULT_TIMEOUT
+	else:
+		_timeout = timeout
+	return self
+
+
+func is_null() -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_null)
+	return self
+
+
+func is_not_null() -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_not_null)
+	return self
+
+
+func is_false() -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_false)
+	return self
+
+
+func is_true() -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_true)
+	return self
+
+
+func is_equal(expected: Variant) -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_equal, expected)
+	return self
+
+
+func is_not_equal(expected: Variant) -> GdUnitFuncAssert:
+	await _validate_callback(cb_is_not_equal, expected)
+	return self
+
+
+# we need actually to define this Callable as functions otherwise we results into leaked scripts here
+# this is actually a Godot bug and needs this kind of workaround
+func cb_is_null(c :Variant, _e :Variant) -> bool: return c == null
+func cb_is_not_null(c :Variant, _e :Variant) -> bool: return c != null
+func cb_is_false(c :Variant, _e :Variant) -> bool: return c == false
+func cb_is_true(c :Variant, _e :Variant) -> bool: return c == true
+func cb_is_equal(c :Variant, e :Variant) -> bool: return GdObjects.equals(c,e)
+func cb_is_not_equal(c :Variant, e :Variant) -> bool: return not GdObjects.equals(c, e)
+
+
+func do_interrupt() -> void:
+	_interrupted = true
+
+
+func _validate_callback(predicate :Callable, expected :Variant = null) -> void:
+	if _interrupted:
+		return
+	GdUnitMemoryObserver.guard_instance(self)
+	var time_scale := Engine.get_time_scale()
+	var timer := Timer.new()
+	timer.set_name("gdunit_funcassert_interrupt_timer_%d" % timer.get_instance_id())
+	var scene_tree := Engine.get_main_loop() as SceneTree
+	scene_tree.root.add_child(timer)
+	timer.add_to_group("GdUnitTimers")
+	@warning_ignore("return_value_discarded")
+	timer.timeout.connect(do_interrupt, CONNECT_DEFERRED)
+	timer.set_one_shot(true)
+	timer.start((_timeout/1000.0)*time_scale)
+	_sleep_timer = Timer.new()
+	_sleep_timer.set_name("gdunit_funcassert_sleep_timer_%d" % _sleep_timer.get_instance_id() )
+	scene_tree.root.add_child(_sleep_timer)
+
+	while true:
+		var current :Variant = await next_current_value()
+		# is interupted or predicate success
+		if _interrupted or predicate.call(current, expected):
+			break
+		if is_instance_valid(_sleep_timer):
+			_sleep_timer.start(0.05)
+			await _sleep_timer.timeout
+
+	_sleep_timer.stop()
+	await scene_tree.process_frame
+	if _interrupted:
+		# https://github.com/godotengine/godot/issues/73052
+		#var predicate_name = predicate.get_method()
+		var predicate_name :String = str(predicate).split('::')[1]
+		@warning_ignore("return_value_discarded")
+		report_error(GdAssertMessages.error_interrupted(
+			predicate_name.strip_edges().trim_prefix("cb_"),
+			expected,
+			LocalTime.elapsed(_timeout)
+			)
+		)
+	else:
+		@warning_ignore("return_value_discarded")
+		report_success()
+	_sleep_timer.free()
+	timer.free()
+	GdUnitMemoryObserver.unguard_instance(self)
+
+
+func next_current_value() -> Variant:
+	@warning_ignore("redundant_await")
+	if is_instance_valid(_current_value_provider):
+		return await _current_value_provider.get_value()
+	return "invalid value"

addons/gdUnit4/src/asserts/GdUnitFuncAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://bd15pn72awek1

addons/gdUnit4/src/asserts/GdUnitGodotErrorAssertImpl.gd

@@ -0,0 +1,152 @@
+extends GdUnitGodotErrorAssert
+
+var _current_failure_message := ""
+var _custom_failure_message := ""
+var _additional_failure_message := ""
+var _callable: Callable
+var _logger := GodotGdErrorMonitor.new()
+
+
+func _init(callable: Callable) -> void:
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	GdAssertReports.reset_last_error_line_number()
+	_callable = callable
+
+
+func _execute() -> Array[ErrorLogEntry]:
+	_logger.start()
+	await _callable.call()
+	_logger.stop()
+	return _logger.log_entries()
+
+
+func failure_message() -> String:
+	return _current_failure_message
+
+
+func _report_success() -> GdUnitAssert:
+	GdAssertReports.report_success()
+	return self
+
+
+func _report_error(error_message: String, failure_line_number: int = -1) -> GdUnitAssert:
+	var line_number := failure_line_number if failure_line_number != -1 else GdUnitAssertions.get_line_number()
+	_current_failure_message = GdAssertMessages.build_failure_message(error_message, _additional_failure_message, _custom_failure_message)
+	GdAssertReports.report_error(_current_failure_message, line_number)
+	return self
+
+
+func _has_log_entry(log_entries: Array[ErrorLogEntry], type: ErrorLogEntry.TYPE, error: Variant) -> bool:
+	for entry in log_entries:
+		if entry._type == type and GdObjects.equals(entry._message, error):
+			return true
+	return false
+
+
+func _to_list(log_entries: Array[ErrorLogEntry]) -> String:
+	if log_entries.is_empty():
+		return "no errors"
+
+	var values := []
+	for entry in log_entries:
+		values.append(entry)
+	return "\n".join(values)
+
+
+func is_null() -> GdUnitGodotErrorAssert:
+	return _report_error("Not implemented")
+
+
+func is_not_null() -> GdUnitGodotErrorAssert:
+	return _report_error("Not implemented")
+
+
+func is_equal(_expected: Variant) -> GdUnitGodotErrorAssert:
+	return _report_error("Not implemented")
+
+
+func is_not_equal(_expected: Variant) -> GdUnitGodotErrorAssert:
+	return _report_error("Not implemented")
+
+
+func override_failure_message(message: String) -> GdUnitGodotErrorAssert:
+	_custom_failure_message = message
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitGodotErrorAssert:
+	_additional_failure_message = message
+	return self
+
+
+func is_success() -> GdUnitGodotErrorAssert:
+	if not _validate_callable():
+		return self
+
+	var log_entries := await _execute()
+	if log_entries.is_empty():
+		return _report_success()
+	return _report_error("""
+		Expecting: no error's are ocured.
+			but found: '%s'
+		""".dedent().trim_prefix("\n") % _to_list(log_entries))
+
+
+func is_runtime_error(expected_error: Variant) -> GdUnitGodotErrorAssert:
+	if not _validate_callable():
+		return self
+
+	var result := GdUnitArgumentMatchers.is_variant_string_matching(expected_error)
+	if result.is_error():
+		return _report_error(result.error_message())
+	var log_entries := await _execute()
+	if _has_log_entry(log_entries, ErrorLogEntry.TYPE.SCRIPT_ERROR, expected_error):
+		return _report_success()
+	return _report_error("""
+		Expecting: a runtime error is triggered.
+			expected: '%s'
+			current: '%s'
+		""".dedent().trim_prefix("\n") % [expected_error, _to_list(log_entries)])
+
+
+func is_push_warning(expected_warning: Variant) -> GdUnitGodotErrorAssert:
+	if not _validate_callable():
+		return self
+
+	var result := GdUnitArgumentMatchers.is_variant_string_matching(expected_warning)
+	if result.is_error():
+		return _report_error(result.error_message())
+	var log_entries := await _execute()
+	if _has_log_entry(log_entries, ErrorLogEntry.TYPE.PUSH_WARNING, expected_warning):
+		return _report_success()
+	return _report_error("""
+		Expecting: push_warning() is called.
+			expected: '%s'
+			current: '%s'
+		""".dedent().trim_prefix("\n") % [expected_warning, _to_list(log_entries)])
+
+
+func is_push_error(expected_error: Variant) -> GdUnitGodotErrorAssert:
+	if not _validate_callable():
+		return self
+
+	var result := GdUnitArgumentMatchers.is_variant_string_matching(expected_error)
+	if result.is_error():
+		return _report_error(result.error_message())
+	var log_entries := await _execute()
+	if _has_log_entry(log_entries, ErrorLogEntry.TYPE.PUSH_ERROR, expected_error):
+		return _report_success()
+	return _report_error("""
+		Expecting: push_error() is called.
+			expected: '%s'
+			current: '%s'
+		""".dedent().trim_prefix("\n") % [expected_error, _to_list(log_entries)])
+
+
+func _validate_callable() -> bool:
+	if _callable == null or not _callable.is_valid():
+		@warning_ignore("return_value_discarded")
+		_report_error("Invalid Callable '%s'" % _callable)
+		return false
+	return true

addons/gdUnit4/src/asserts/GdUnitGodotErrorAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://d3st26kcndm8l

addons/gdUnit4/src/asserts/GdUnitIntAssertImpl.gd

@@ -0,0 +1,166 @@
+extends GdUnitIntAssert
+
+var _base: GdUnitAssertImpl
+
+
+func _init(current :Variant) -> void:
+	_base = GdUnitAssertImpl.new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not GdUnitAssertions.validate_value_type(current, TYPE_INT):
+		@warning_ignore("return_value_discarded")
+		report_error("GdUnitIntAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitIntAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitIntAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base.failure_message()
+
+
+func override_failure_message(message: String) -> GdUnitIntAssert:
+	@warning_ignore("return_value_discarded")
+	_base.override_failure_message(message)
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitIntAssert:
+	@warning_ignore("return_value_discarded")
+	_base.append_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitIntAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitIntAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected: Variant) -> GdUnitIntAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected: Variant) -> GdUnitIntAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_equal(expected)
+	return self
+
+
+func is_less(expected :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current >= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_THAN, current, expected))
+	return report_success()
+
+
+func is_less_equal(expected :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current > expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.LESS_EQUAL, current, expected))
+	return report_success()
+
+
+func is_greater(expected :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current <= expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_THAN, current, expected))
+	return report_success()
+
+
+func is_greater_equal(expected :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current < expected:
+		return report_error(GdAssertMessages.error_is_value(Comparator.GREATER_EQUAL, current, expected))
+	return report_success()
+
+
+func is_even() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current % 2 != 0:
+		return report_error(GdAssertMessages.error_is_even(current))
+	return report_success()
+
+
+func is_odd() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current % 2 == 0:
+		return report_error(GdAssertMessages.error_is_odd(current))
+	return report_success()
+
+
+func is_negative() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current >= 0:
+		return report_error(GdAssertMessages.error_is_negative(current))
+	return report_success()
+
+
+func is_not_negative() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current < 0:
+		return report_error(GdAssertMessages.error_is_not_negative(current))
+	return report_success()
+
+
+func is_zero() -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current != 0:
+		return report_error(GdAssertMessages.error_is_zero(current))
+	return report_success()
+
+
+func is_not_zero() -> GdUnitIntAssert:
+	var current :Variant= current_value()
+	if current == 0:
+		return report_error(GdAssertMessages.error_is_not_zero())
+	return report_success()
+
+
+func is_in(expected :Array) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if not expected.has(current):
+		return report_error(GdAssertMessages.error_is_in(current, expected))
+	return report_success()
+
+
+func is_not_in(expected :Array) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if expected.has(current):
+		return report_error(GdAssertMessages.error_is_not_in(current, expected))
+	return report_success()
+
+
+func is_between(from :int, to :int) -> GdUnitIntAssert:
+	var current :Variant = current_value()
+	if current == null or current < from or current > to:
+		return report_error(GdAssertMessages.error_is_value(Comparator.BETWEEN_EQUAL, current, from, to))
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitIntAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://bcuh7lnvrg7mb

addons/gdUnit4/src/asserts/GdUnitObjectAssertImpl.gd

@@ -0,0 +1,166 @@
+extends GdUnitObjectAssert
+
+var _base: GdUnitAssertImpl
+
+
+func _init(current: Variant) -> void:
+	_base = GdUnitAssertImpl.new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if (current != null
+		and (GdUnitAssertions.validate_value_type(current, TYPE_BOOL)
+		or GdUnitAssertions.validate_value_type(current, TYPE_INT)
+		or GdUnitAssertions.validate_value_type(current, TYPE_FLOAT)
+		or GdUnitAssertions.validate_value_type(current, TYPE_STRING))):
+			@warning_ignore("return_value_discarded")
+			report_error("GdUnitObjectAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event: int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitObjectAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_success()
+	return self
+
+
+func report_error(error: String) -> GdUnitObjectAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base.failure_message()
+
+
+func override_failure_message(message: String) -> GdUnitObjectAssert:
+	@warning_ignore("return_value_discarded")
+	_base.override_failure_message(message)
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitObjectAssert:
+	@warning_ignore("return_value_discarded")
+	_base.append_failure_message(message)
+	return self
+
+
+func is_equal(expected: Variant) -> GdUnitObjectAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_equal(expected)
+	return self
+
+
+func is_not_equal(expected: Variant) -> GdUnitObjectAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_equal(expected)
+	return self
+
+
+func is_null() -> GdUnitObjectAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitObjectAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_null()
+	return self
+
+
+@warning_ignore("shadowed_global_identifier")
+func is_same(expected: Variant) -> GdUnitObjectAssert:
+	var current: Variant = current_value()
+	if not is_same(current, expected):
+		return report_error(GdAssertMessages.error_is_same(current, expected))
+	return report_success()
+
+
+func is_not_same(expected: Variant) -> GdUnitObjectAssert:
+	var current: Variant = current_value()
+	if is_same(current, expected):
+		return report_error(GdAssertMessages.error_not_same(current, expected))
+	return report_success()
+
+
+func is_instanceof(type: Variant) -> GdUnitObjectAssert:
+	var current: Variant = current_value()
+	if current == null or not is_instance_of(current, type):
+		var result_expected := GdObjects.extract_class_name(type)
+		var result_current := GdObjects.extract_class_name(current)
+		return report_error(GdAssertMessages.error_is_instanceof(result_current, result_expected))
+	return report_success()
+
+
+func is_not_instanceof(type: Variant) -> GdUnitObjectAssert:
+	var current: Variant = current_value()
+	if is_instance_of(current, type):
+		var result := GdObjects.extract_class_name(type)
+		if result.is_success():
+			return report_error("Expected not be a instance of <%s>" % str(result.value()))
+
+		push_error("Internal ERROR: %s" % result.error_message())
+		return self
+	return report_success()
+
+
+## Checks whether the current object inherits from the specified type.
+func is_inheriting(type: Variant) -> GdUnitObjectAssert:
+	var current: Variant = current_value()
+	if not is_instance_of(current, TYPE_OBJECT):
+		return report_error("Expected '%s' to inherit from at least Object." % str(current))
+	var result := _inherits(current, type)
+	if result.is_success():
+		return report_success()
+	return report_error(result.error_message())
+
+
+## Checks whether the current object does NOT inherit from the specified type.
+func is_not_inheriting(type: Variant) -> GdUnitObjectAssert:
+	var current: Variant = current_value()
+	if not is_instance_of(current, TYPE_OBJECT):
+		return report_error("Expected '%s' to inherit from at least Object." % str(current))
+	var result := _inherits(current, type)
+	if result.is_success():
+		return report_error("Expected type to not inherit from <%s>" % _extract_class_type(type))
+	return report_success()
+
+
+func _inherits(current: Variant, type: Variant) -> GdUnitResult:
+	var type_as_string := _extract_class_type(type)
+	if type_as_string == "Object":
+		return GdUnitResult.success("")
+
+	var obj: Object = current
+	for p in obj.get_property_list():
+		var clazz_name :String = p["name"]
+		if p["usage"] == PROPERTY_USAGE_CATEGORY and clazz_name == p["hint_string"] and clazz_name == type_as_string:
+			return GdUnitResult.success("")
+	var script: Script = obj.get_script()
+	if script != null:
+		while script != null:
+			var result := GdObjects.extract_class_name(script)
+			if result.is_success() and result.value() == type_as_string:
+				return GdUnitResult.success("")
+			script = script.get_base_script()
+	return GdUnitResult.error("Expected type to inherit from <%s>" % type_as_string)
+
+
+func _extract_class_type(type: Variant) -> String:
+	if type is String:
+		return type
+	var result := GdObjects.extract_class_name(type)
+	if result.is_error():
+		return ""
+	return result.value()

addons/gdUnit4/src/asserts/GdUnitObjectAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://ba515a8xk0ubo

addons/gdUnit4/src/asserts/GdUnitResultAssertImpl.gd

@@ -0,0 +1,128 @@
+extends GdUnitResultAssert
+
+var _base: GdUnitAssertImpl
+
+
+func _init(current :Variant) -> void:
+	_base = GdUnitAssertImpl.new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if not validate_value_type(current):
+		@warning_ignore("return_value_discarded")
+		report_error("GdUnitResultAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func validate_value_type(value :Variant) -> bool:
+	return value == null or value is GdUnitResult
+
+
+func current_value() -> GdUnitResult:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitResultAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitResultAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_error(error)
+	return self
+
+
+func failure_message() -> String:
+	return _base.failure_message()
+
+
+func override_failure_message(message: String) -> GdUnitResultAssert:
+	@warning_ignore("return_value_discarded")
+	_base.override_failure_message(message)
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitResultAssert:
+	@warning_ignore("return_value_discarded")
+	_base.append_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitResultAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitResultAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected: Variant) -> GdUnitResultAssert:
+	return is_value(expected)
+
+
+func is_not_equal(expected: Variant) -> GdUnitResultAssert:
+	var result := current_value()
+	var value :Variant = null if result == null else result.value()
+	if GdObjects.equals(value, expected):
+		return report_error(GdAssertMessages.error_not_equal(value, expected))
+	return report_success()
+
+
+func is_empty() -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null or not result.is_empty():
+		return report_error(GdAssertMessages.error_result_is_empty(result))
+	return report_success()
+
+
+func is_success() -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null or not result.is_success():
+		return report_error(GdAssertMessages.error_result_is_success(result))
+	return report_success()
+
+
+func is_warning() -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null or not result.is_warn():
+		return report_error(GdAssertMessages.error_result_is_warning(result))
+	return report_success()
+
+
+func is_error() -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null or not result.is_error():
+		return report_error(GdAssertMessages.error_result_is_error(result))
+	return report_success()
+
+
+func contains_message(expected :String) -> GdUnitResultAssert:
+	var result := current_value()
+	if result == null:
+		return report_error(GdAssertMessages.error_result_has_message("<null>", expected))
+	if result.is_success():
+		return report_error(GdAssertMessages.error_result_has_message_on_success(expected))
+	if result.is_error() and result.error_message() != expected:
+		return report_error(GdAssertMessages.error_result_has_message(result.error_message(), expected))
+	if result.is_warn() and result.warn_message() != expected:
+		return report_error(GdAssertMessages.error_result_has_message(result.warn_message(), expected))
+	return report_success()
+
+
+func is_value(expected: Variant) -> GdUnitResultAssert:
+	var result := current_value()
+	var value :Variant = null if result == null else result.value()
+	if not GdObjects.equals(value, expected):
+		return report_error(GdAssertMessages.error_result_is_value(value, expected))
+	return report_success()

addons/gdUnit4/src/asserts/GdUnitResultAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://dwl5ooagjg2nc

addons/gdUnit4/src/asserts/GdUnitSignalAssertImpl.gd

@@ -0,0 +1,163 @@
+extends GdUnitSignalAssert
+
+const DEFAULT_TIMEOUT := 2000
+
+var _signal_collector :GdUnitSignalCollector
+var _emitter :Object
+var _current_failure_message :String = ""
+var _custom_failure_message :String = ""
+var _additional_failure_message: String = ""
+var _line_number := -1
+var _timeout := DEFAULT_TIMEOUT
+var _interrupted := false
+
+
+func _init(emitter :Object) -> void:
+	# save the actual assert instance on the current thread context
+	var context := GdUnitThreadManager.get_current_context()
+	context.set_assert(self)
+	_signal_collector = context.get_signal_collector()
+	_line_number = GdUnitAssertions.get_line_number()
+	_emitter =  emitter
+	GdAssertReports.reset_last_error_line_number()
+
+
+func _notification(what :int) -> void:
+	if what == NOTIFICATION_PREDELETE:
+		_interrupted = true
+		if is_instance_valid(_emitter):
+			_signal_collector.unregister_emitter(_emitter)
+		_emitter = null
+
+
+func report_success() -> GdUnitAssert:
+	GdAssertReports.report_success()
+	return self
+
+
+func report_warning(message :String) -> GdUnitAssert:
+	GdAssertReports.report_warning(message, GdUnitAssertions.get_line_number())
+	return self
+
+
+func report_error(failure :String) -> GdUnitAssert:
+	_current_failure_message = GdAssertMessages.build_failure_message(failure, _additional_failure_message, _custom_failure_message)
+	GdAssertReports.report_error(_current_failure_message, _line_number)
+	return self
+
+
+func failure_message() -> String:
+	return _current_failure_message
+
+
+func override_failure_message(message: String) -> GdUnitSignalAssert:
+	_custom_failure_message = message
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitSignalAssert:
+	_additional_failure_message = message
+	return self
+
+
+func wait_until(timeout := 2000) -> GdUnitSignalAssert:
+	if timeout <= 0:
+		@warning_ignore("return_value_discarded")
+		report_warning("Invalid timeout parameter, allowed timeouts must be greater than 0, use default timeout instead!")
+		_timeout = DEFAULT_TIMEOUT
+	else:
+		_timeout = timeout
+	return self
+
+
+func is_null() -> GdUnitSignalAssert:
+	if _emitter != null:
+		return report_error(GdAssertMessages.error_is_null(_emitter))
+	return report_success()
+
+
+func is_not_null() -> GdUnitSignalAssert:
+	if _emitter == null:
+		return report_error(GdAssertMessages.error_is_not_null())
+	return report_success()
+
+
+func is_equal(_expected: Variant) -> GdUnitSignalAssert:
+	return report_error("Not implemented")
+
+
+func is_not_equal(_expected: Variant) -> GdUnitSignalAssert:
+	return report_error("Not implemented")
+
+
+# Verifies the signal exists checked the emitter
+func is_signal_exists(signal_name: Variant) -> GdUnitSignalAssert:
+	if not (signal_name is String or signal_name is Signal):
+		return report_error("Invalid signal_name: expected String or Signal, but is '%s'" % type_string(typeof(signal_name)))
+	signal_name = (signal_name as Signal).get_name() if signal_name is Signal else signal_name
+
+	if not _emitter.has_signal(signal_name):
+		@warning_ignore("return_value_discarded")
+		report_error("The signal '%s' not exists checked object '%s'." % [signal_name, _emitter.get_class()])
+	return self
+
+
+# Verifies that given signal is emitted until waiting time
+func is_emitted(signal_name: Variant, ...signal_args: Array) -> GdUnitSignalAssert:
+	_line_number = GdUnitAssertions.get_line_number()
+	return await _wail_until_signal(
+		signal_name,
+		_wrap_arguments.callv(signal_args),
+		false)
+
+
+# Verifies that given signal is NOT emitted until waiting time
+func is_not_emitted(signal_name: Variant, ...signal_args: Array) -> GdUnitSignalAssert:
+	_line_number = GdUnitAssertions.get_line_number()
+	return await _wail_until_signal(
+		signal_name,
+		_wrap_arguments.callv(signal_args),
+		true)
+
+
+func _wrap_arguments(...args: Array) -> Array:
+	# Check using old syntax
+	if not args.is_empty() and args[0] is Array:
+		return args[0]
+	return args
+
+
+func _wail_until_signal(signal_value: Variant, expected_args: Array, expect_not_emitted: bool) -> GdUnitSignalAssert:
+	if _emitter == null:
+		return report_error("Can't wait for signal checked a NULL object.")
+	if not (signal_value is String or signal_value is Signal):
+		return report_error("Invalid signal_name: expected String or Signal, but is '%s'" % type_string(typeof(signal_value)))
+	var signal_name := (signal_value as Signal).get_name() if signal_value is Signal else signal_value
+	# first verify the signal is defined
+	if not _emitter.has_signal(signal_name):
+		return report_error("Can't wait for non-existion signal '%s' checked object '%s'." % [signal_name,_emitter.get_class()])
+	_signal_collector.register_emitter(_emitter)
+	var time_scale := Engine.get_time_scale()
+	var timer := Timer.new()
+	(Engine.get_main_loop() as SceneTree).root.add_child(timer)
+	timer.add_to_group("GdUnitTimers")
+	timer.set_one_shot(true)
+	@warning_ignore("return_value_discarded")
+	timer.timeout.connect(func on_timeout() -> void: _interrupted = true)
+	timer.start((_timeout/1000.0)*time_scale)
+	var is_signal_emitted := false
+	while not _interrupted and not is_signal_emitted:
+		await (Engine.get_main_loop() as SceneTree).process_frame
+		if is_instance_valid(_emitter):
+			is_signal_emitted = _signal_collector.match(_emitter, signal_name, expected_args)
+			if is_signal_emitted and expect_not_emitted:
+				@warning_ignore("return_value_discarded")
+				report_error(GdAssertMessages.error_signal_emitted(signal_name, expected_args, LocalTime.elapsed(int(_timeout-timer.time_left*1000))))
+
+	if _interrupted and not expect_not_emitted:
+		@warning_ignore("return_value_discarded")
+		report_error(GdAssertMessages.error_wait_signal(signal_name, expected_args, LocalTime.elapsed(_timeout)))
+	timer.free()
+	if is_instance_valid(_emitter):
+		_signal_collector.reset_received_signals(_emitter, signal_name, expected_args)
+	return self

addons/gdUnit4/src/asserts/GdUnitSignalAssertImpl.gd.uid

@@ -0,0 +1 @@
+uid://c3ytdhnam8ba7

addons/gdUnit4/src/asserts/GdUnitStringAssertImpl.gd

@@ -0,0 +1,208 @@
+extends GdUnitStringAssert
+
+var _base: GdUnitAssertImpl
+
+
+func _init(current :Variant) -> void:
+	_base = GdUnitAssertImpl.new(current)
+	# save the actual assert instance on the current thread context
+	GdUnitThreadManager.get_current_context().set_assert(self)
+	if current != null and typeof(current) != TYPE_STRING and typeof(current) != TYPE_STRING_NAME:
+		@warning_ignore("return_value_discarded")
+		report_error("GdUnitStringAssert inital error, unexpected type <%s>" % GdObjects.typeof_as_string(current))
+
+
+func _notification(event :int) -> void:
+	if event == NOTIFICATION_PREDELETE:
+		if _base != null:
+			_base.notification(event)
+			_base = null
+
+
+func failure_message() -> String:
+	return _base.failure_message()
+
+
+func current_value() -> Variant:
+	return _base.current_value()
+
+
+func report_success() -> GdUnitStringAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_success()
+	return self
+
+
+func report_error(error :String) -> GdUnitStringAssert:
+	@warning_ignore("return_value_discarded")
+	_base.report_error(error)
+	return self
+
+
+func override_failure_message(message: String) -> GdUnitStringAssert:
+	@warning_ignore("return_value_discarded")
+	_base.override_failure_message(message)
+	return self
+
+
+func append_failure_message(message: String) -> GdUnitStringAssert:
+	@warning_ignore("return_value_discarded")
+	_base.append_failure_message(message)
+	return self
+
+
+func is_null() -> GdUnitStringAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_null()
+	return self
+
+
+func is_not_null() -> GdUnitStringAssert:
+	@warning_ignore("return_value_discarded")
+	_base.is_not_null()
+	return self
+
+
+func is_equal(expected: Variant) -> GdUnitStringAssert:
+	return _is_equal(expected, false, GdAssertMessages.error_equal)
+
+
+func is_equal_ignoring_case(expected: Variant) -> GdUnitStringAssert:
+	return _is_equal(expected, true, GdAssertMessages.error_equal_ignoring_case)
+
+
+@warning_ignore_start("unsafe_call_argument")
+func _is_equal(expected: Variant, ignore_case: bool, message_cb: Callable) -> GdUnitStringAssert:
+	var current: Variant = current_value()
+	if current == null:
+		return report_error(message_cb.call(current, expected))
+	var cur_value := str(current)
+	if not GdObjects.equals(cur_value, expected, ignore_case):
+		var exp_value := str(expected)
+		if contains_bbcode(cur_value):
+			# mask user bbcode
+			# https://docs.godotengine.org/en/4.5/tutorials/ui/bbcode_in_richtextlabel.html#handling-user-input-safely
+			return report_error(message_cb.call(cur_value.replace("[", "[lb]"), exp_value.replace("[", "[lb]")))
+		var diffs := GdDiffTool.string_diff(cur_value, exp_value)
+		var formatted_current := GdAssertMessages.colored_array_div(diffs[1])
+		return report_error(message_cb.call(formatted_current, exp_value))
+	return report_success()
+@warning_ignore_restore("unsafe_call_argument")
+
+
+func is_not_equal(expected: Variant) -> GdUnitStringAssert:
+	var current: Variant = current_value()
+	if GdObjects.equals(current, expected):
+		return report_error(GdAssertMessages.error_not_equal(current, expected))
+	return report_success()
+
+
+func is_not_equal_ignoring_case(expected :Variant) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if GdObjects.equals(current, expected, true):
+		return report_error(GdAssertMessages.error_not_equal(current, expected))
+	return report_success()
+
+
+func is_empty() -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current == null or not (current as String).is_empty():
+		return report_error(GdAssertMessages.error_is_empty(current))
+	return report_success()
+
+
+func is_not_empty() -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current == null or (current as String).is_empty():
+		return report_error(GdAssertMessages.error_is_not_empty())
+	return report_success()
+
+
+func contains(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current == null or (current as String).find(expected) == -1:
+		return report_error(GdAssertMessages.error_contains(current, expected))
+	return report_success()
+
+
+func not_contains(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current != null and (current as String).find(expected) != -1:
+		return report_error(GdAssertMessages.error_not_contains(current, expected))
+	return report_success()
+
+
+func contains_ignoring_case(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current == null or (current as String).findn(expected) == -1:
+		return report_error(GdAssertMessages.error_contains_ignoring_case(current, expected))
+	return report_success()
+
+
+func not_contains_ignoring_case(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current != null and (current as String).findn(expected) != -1:
+		return report_error(GdAssertMessages.error_not_contains_ignoring_case(current, expected))
+	return report_success()
+
+
+func starts_with(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	@warning_ignore("unsafe_cast")
+	if current == null or (current as String).find(expected) != 0:
+		return report_error(GdAssertMessages.error_starts_with(current, expected))
+	return report_success()
+
+
+func ends_with(expected :String) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_ends_with(current, expected))
+	@warning_ignore("unsafe_cast")
+	var find :int = (current as String).length() - expected.length()
+	@warning_ignore("unsafe_cast")
+	if (current as String).rfind(expected) != find:
+		return report_error(GdAssertMessages.error_ends_with(current, expected))
+	return report_success()
+
+
+# gdlint:disable=max-returns
+func has_length(expected :int, comparator := Comparator.EQUAL) -> GdUnitStringAssert:
+	var current :Variant = current_value()
+	if current == null:
+		return report_error(GdAssertMessages.error_has_length(current, expected, comparator))
+	var str_current: String = current
+	match comparator:
+		Comparator.EQUAL:
+			if str_current.length() != expected:
+				return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
+		Comparator.LESS_THAN:
+			if str_current.length() >= expected:
+				return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
+		Comparator.LESS_EQUAL:
+			if str_current.length() > expected:
+				return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
+		Comparator.GREATER_THAN:
+			if str_current.length() <= expected:
+				return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
+		Comparator.GREATER_EQUAL:
+			if str_current.length() < expected:
+				return report_error(GdAssertMessages.error_has_length(str_current, expected, comparator))
+		_:
+			return report_error("Comparator '%d' not implemented!" % comparator)
+	return report_success()
+
+
+func contains_bbcode(value: String) -> bool:
+	var rtl := RichTextLabel.new()
+	rtl.bbcode_enabled = true
+	rtl.parse_bbcode(value)
+	var has_bbcode := rtl.get_parsed_text() != value
+	rtl.free()
+	return has_bbcode