From a6c5d2a73963011e9dd44f9235e98b500a174e94 Mon Sep 17 00:00:00 2001
From: ganon <ganonballgame@gmail.com>
Date: Sun, 13 Apr 2025 01:25:15 -0400
Subject: [PATCH] poc run C# tests

---
 .gutconfig.json                               |   3 +-
 Gut.csproj                                    |   8 +
 Gut.sln                                       |  19 ++
 addons/gut/CSharpScriptInspector.cs           |  68 ++++++++
 addons/gut/GutRunner.cs                       |  67 ++++++++
 addons/gut/GutTest.cs                         | 162 ++++++++++++++++++
 addons/gut/gut.gd                             |  16 +-
 addons/gut/test_collector.gd                  |   8 +-
 addons/gut/utils.gd                           |   1 -
 project.godot                                 |   7 +-
 .../panel_demo_scripts/test_totals_testing.gd |   1 -
 test/samples/cs/TestCSharp.cs                 |  22 +++
 test/samples/test_readme_examples.gd          |   2 -
 13 files changed, 374 insertions(+), 10 deletions(-)
 create mode 100644 Gut.csproj
 create mode 100644 Gut.sln
 create mode 100644 addons/gut/CSharpScriptInspector.cs
 create mode 100644 addons/gut/GutRunner.cs
 create mode 100644 addons/gut/GutTest.cs
 create mode 100644 test/samples/cs/TestCSharp.cs

diff --git a/.gutconfig.json b/.gutconfig.json
index 6b682b9a..e1455cbb 100644
--- a/.gutconfig.json
+++ b/.gutconfig.json
@@ -3,8 +3,7 @@
 
   "include_subdirs": true,
   "dirs": [
-    "res://test/unit/",
-    "res://test/integration/"
+    "res://test/samples/cs/"
   ],
   "should_exit": true,
   "log_level": 3,
diff --git a/Gut.csproj b/Gut.csproj
new file mode 100644
index 00000000..53cc1f18
--- /dev/null
+++ b/Gut.csproj
@@ -0,0 +1,8 @@
+<Project Sdk="Godot.NET.Sdk/4.3.0">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework Condition=" '$(GodotTargetPlatform)' == 'android' ">net7.0</TargetFramework>
+    <TargetFramework Condition=" '$(GodotTargetPlatform)' == 'ios' ">net8.0</TargetFramework>
+    <EnableDynamicLoading>true</EnableDynamicLoading>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/Gut.sln b/Gut.sln
new file mode 100644
index 00000000..a6b04736
--- /dev/null
+++ b/Gut.sln
@@ -0,0 +1,19 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Gut", "Gut.csproj", "{AED1B5D9-B5A4-4898-9EE6-55B809D51881}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+	Debug|Any CPU = Debug|Any CPU
+	ExportDebug|Any CPU = ExportDebug|Any CPU
+	ExportRelease|Any CPU = ExportRelease|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{AED1B5D9-B5A4-4898-9EE6-55B809D51881}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{AED1B5D9-B5A4-4898-9EE6-55B809D51881}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{AED1B5D9-B5A4-4898-9EE6-55B809D51881}.ExportDebug|Any CPU.ActiveCfg = ExportDebug|Any CPU
+		{AED1B5D9-B5A4-4898-9EE6-55B809D51881}.ExportDebug|Any CPU.Build.0 = ExportDebug|Any CPU
+		{AED1B5D9-B5A4-4898-9EE6-55B809D51881}.ExportRelease|Any CPU.ActiveCfg = ExportRelease|Any CPU
+		{AED1B5D9-B5A4-4898-9EE6-55B809D51881}.ExportRelease|Any CPU.Build.0 = ExportRelease|Any CPU
+	EndGlobalSection
+EndGlobal
diff --git a/addons/gut/CSharpScriptInspector.cs b/addons/gut/CSharpScriptInspector.cs
new file mode 100644
index 00000000..f1c5943a
--- /dev/null
+++ b/addons/gut/CSharpScriptInspector.cs
@@ -0,0 +1,68 @@
+using Godot;
+using System;
+using System.Reflection;
+
+// namespace GutCSharp
+// {
+	/// <summary>
+	/// Utility class to handle inspection of C# scripts for the GUT testing framework.
+	/// This provides reflection-based methods that help GUT understand C# class inheritance.
+	/// </summary>
+	public partial class CSharpScriptInspector : RefCounted
+	{
+		/// <summary>
+		/// Checks if a C# type inherits from GutTest
+		/// </summary>
+		/// <param name="type">The Type to check</param>
+		/// <returns>True if the type inherits from GutTest</returns>
+		private bool TypeInheritsFromGutTest(Type type)
+		{
+			if (type == null)
+				return false;
+				
+			// If this is the GutTest class itself (base case for successful inheritance)
+			if (type.FullName == "GutCSharp.GutTest")
+			{
+				GD.Print("FULL NAME: ", type.FullName);
+				return true;
+			}
+				
+			// Check the base type
+			return TypeInheritsFromGutTest(type.BaseType);
+		}
+		
+		/// <summary>
+		/// Determines if a CSharpScript inherits from GutTest
+		/// </summary>
+		/// <param name="script">The CSharpScript to check</param>
+		/// <returns>True if the script inherits from GutTest</returns>
+		public bool InheritsFromTest(CSharpScript script)
+		{
+
+			if (script == null)
+				return false;
+			Variant instance = script.New();
+			var tryCast = instance.As<GutTest>();
+			
+			return tryCast != null;
+		}
+		
+		/// <summary>
+		/// Determines if an object instance inherits from GutTest
+		/// </summary>
+		/// <param name="instance">The object instance to check</param>
+		/// <returns>True if the object inherits from GutTest</returns>
+		public bool InheritsFromTest(object instance)
+		{
+
+            GD.Print("here");
+
+
+			if (instance == null)
+				return false;
+
+				
+			return TypeInheritsFromGutTest(instance.GetType());
+		}
+	}
+// } 
diff --git a/addons/gut/GutRunner.cs b/addons/gut/GutRunner.cs
new file mode 100644
index 00000000..eaae9759
--- /dev/null
+++ b/addons/gut/GutRunner.cs
@@ -0,0 +1,67 @@
+using Godot;
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+
+namespace GutCSharp
+{
+	public partial class GutCSharpRunner : RefCounted
+	{
+		private Node _gut;
+
+		public GutCSharpRunner(Node gut)
+		{
+			_gut = gut;
+		}
+
+		public void RunTests(string scriptPath)
+		{
+			// Load the C# script/class
+			var script = GD.Load<CSharpScript>(scriptPath);
+			if (script == null) return;
+			
+			var instance = script.New().As<GutTest>();
+			if (instance == null) return;
+			
+			instance.gut = _gut;
+			
+			// Get all methods from the instance
+			Type type = instance.GetType();
+			MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+			
+			// Filter for test methods (prefixed with "Test")
+			List<MethodInfo> testMethods = new List<MethodInfo>();
+			foreach (var method in methods)
+			{
+				if (method.Name.StartsWith("Test") && method.GetParameters().Length == 0)
+				{
+					testMethods.Add(method);
+				}
+			}
+			
+			// Run lifecycle and test methods
+			try
+			{
+				instance.BeforeAll();
+				
+				foreach (var testMethod in testMethods)
+				{
+					string testName = testMethod.Name;
+					_gut.Call("_pre_run_test", testName);
+					
+					instance.BeforeEach();
+					testMethod.Invoke(instance, null);
+					instance.AfterEach();
+					
+					_gut.Call("_post_run_test");
+				}
+				
+				instance.AfterAll();
+			}
+			catch (Exception e)
+			{
+				_gut.Call("_fail", "Error in test: " + e.Message);
+			}
+		}
+	}
+}
diff --git a/addons/gut/GutTest.cs b/addons/gut/GutTest.cs
new file mode 100644
index 00000000..4768f9ee
--- /dev/null
+++ b/addons/gut/GutTest.cs
@@ -0,0 +1,162 @@
+using Godot;
+using System;
+using System.Reflection;
+
+// namespace GutCSharp
+// {
+	public partial class GutTest : Godot.Node
+	{
+		// Public property that proxies to _gdGutTest
+		public Node gut
+		{
+			get
+			{
+				if (_gdGutTest != null)
+				{
+					return (Node)_gdGutTest.Get("gut");
+				}
+				return null;
+			}
+			set
+			{
+				if (_gdGutTest != null)
+				{
+					_gdGutTest.Set("gut", value);
+				}
+			}
+		}
+		
+		// Reference to GDScript GutTest instance that will handle the actual implementation
+		private Node _gdGutTest;
+		
+		// Flag to track if ready was called
+		public bool _was_ready_called
+		{
+			get
+			{
+				if (_gdGutTest != null)
+				{
+					return (bool)_gdGutTest.Get("_was_ready_called");
+				}
+				return false;
+			}
+		}
+		
+		// Constructor - creates the GDScript GutTest instance
+		public GutTest()
+		{
+			// Load the GDScript GutTest scene/script
+			var gdTestScript = GD.Load<Script>("res://addons/gut/test.gd");
+			_gdGutTest = new Node();
+			_gdGutTest.SetScript(gdTestScript);
+		}
+		
+		// Override _Ready to setup the GDScript instance
+		public override void _Ready()
+		{
+			base._Ready();
+			// Add the GDScript instance as a child so it gets properly initialized
+			AddChild(_gdGutTest);
+		}
+
+		// Lifecycle methods - these are virtual and meant to be overridden
+		public virtual void BeforeAll() { }
+		public void before_all() {
+			BeforeAll();
+		}
+
+		public virtual void AfterAll() { }
+		public void after_all() {
+			AfterAll();
+		}
+
+		public virtual void BeforeEach() { }
+		public void before_each() {
+			BeforeEach();
+		}
+
+		public virtual void AfterEach() { }
+		public void after_each() {
+			AfterEach();
+			// Call GDScript implementation
+			if (_gdGutTest != null)
+			{
+				_gdGutTest.Call("after_each");
+			}
+		}
+
+		// Assertion methods - proxied to GDScript implementation when possible
+		public void AssertEq(object a, object b, string text = "")
+		{
+			// Using direct implementation instead of proxying due to type conversion issues
+			if (a.Equals(b))
+				gut.Call("_pass", $"Expecting {a} to equal {b}. {text}");
+			else
+				gut.Call("_fail", $"Expecting {a} to equal {b}. {text}");
+		}
+
+		public void AssertNe(object a, object b, string text = "")
+		{
+			// Using direct implementation instead of proxying due to type conversion issues
+			if (!a.Equals(b))
+				gut.Call("_pass", $"Expecting {a} to not equal {b}. {text}");
+			else
+				gut.Call("_fail", $"Expecting {a} to not equal {b}. {text}");
+		}
+
+		// Virtual method that can be overridden
+		public virtual bool should_skip_script() {
+			return false;
+		}
+
+		// Proxy methods to GDScript implementation
+		public void set_logger(RefCounted logger) {
+			if (_gdGutTest != null)
+			{
+				_gdGutTest.Call("set_logger", logger);
+			}
+		}
+
+		public Variant get_assert_count() {
+			if (_gdGutTest != null)
+			{
+				return _gdGutTest.Call("get_assert_count");
+			}
+			return 0;
+		}
+
+		public void _do_ready_stuff() {
+			if (_gdGutTest != null)
+			{
+				_gdGutTest.Call("_do_ready_stuff");
+			}
+		}
+
+		public void clear_signal_watcher() {
+			if (_gdGutTest != null)
+			{
+				_gdGutTest.Call("clear_signal_watcher");
+			}
+		}
+		
+		// Additional methods to proxy common GutTest functionality
+		
+		// Example of how to add more assertion methods:
+		public void AssertTrue(bool condition, string text = "")
+		{
+			if (condition)
+				gut.Call("_pass", $"Expecting true. {text}");
+			else
+				gut.Call("_fail", $"Expecting true. {text}");
+		}
+		
+		public void AssertFalse(bool condition, string text = "")
+		{
+			if (!condition)
+				gut.Call("_pass", $"Expecting false. {text}");
+			else
+				gut.Call("_fail", $"Expecting false. {text}");
+		}
+
+	}
+//}
diff --git a/addons/gut/gut.gd b/addons/gut/gut.gd
index 92025ce2..138e3492 100644
--- a/addons/gut/gut.gd
+++ b/addons/gut/gut.gd
@@ -740,6 +740,16 @@ func _test_the_scripts(indexes=[]):
 		_setup_script(test_script, coll_script)
 		_doubler.set_strategy(_double_strategy)
 
+		# Skip based on indexes if needed
+		if(indexes != [] and !indexes.has(test_indexes)):
+			continue
+			
+		# C# specific handling
+		# if test_script.resource_path.ends_with(".cs"):
+		# 	var runner = load("res://addons/gut/GutCSharpRunner.cs").new(self)
+		# 	runner.RunTests(test_script.path)
+		# 	continue
+
 		# ----
 		# SHORTCIRCUIT
 		# skip_script logic
@@ -924,7 +934,9 @@ func _get_files(path, prefix, suffix):
 		# MUST use FileAccess since d.file_exists returns false for exported
 		# projects
 		if(FileAccess.file_exists(full_path)):
-			if(fs_item.begins_with(prefix) and fs_item.ends_with(suffix)):
+			# Add support for C# files
+			if((fs_item.begins_with(prefix) and fs_item.ends_with(suffix)) or 
+			   (fs_item.begins_with("Test") and fs_item.ends_with(".cs"))):
 				files.append(full_path)
 		# MUST use DirAccess, d.dir_exists is false for exported projects.
 		elif(include_subdirectories and DirAccess.dir_exists_absolute(full_path)):
@@ -1026,6 +1038,7 @@ func add_directory(path, prefix=_file_prefix, suffix=".gd"):
 	# check for '' b/c the calls to addin the exported directories 1-6 will pass
 	# '' if the field has not been populated.  This will cause res:// to be
 	# processed which will include all files if include_subdirectories is true.
+	print('path: ', path)
 	if(path == '' or path == null):
 		return
 
@@ -1034,6 +1047,7 @@ func add_directory(path, prefix=_file_prefix, suffix=".gd"):
 		_lgr.error(str('The path [', path, '] does not exist.'))
 	else:
 		var files = _get_files(path, prefix, suffix)
+		print(files)
 		for i in range(files.size()):
 			if(_script_name == null or _script_name == '' or \
 					(_script_name != null and files[i].findn(_script_name) != -1)):
diff --git a/addons/gut/test_collector.gd b/addons/gut/test_collector.gd
index b0047585..bdadd173 100644
--- a/addons/gut/test_collector.gd
+++ b/addons/gut/test_collector.gd
@@ -19,11 +19,16 @@ var scripts = []
 
 
 func _does_inherit_from_test(thing):
+
+	if (thing.get_class() == 'CSharpScript'):
+		var cs_inspector = load('res://addons/gut/CSharpScriptInspector.cs').new()
+		var ret = cs_inspector.InheritsFromTest(thing)
+
 	var base_script = thing.get_base_script()
 	var to_return = false
 	if(base_script != null):
 		var base_path = base_script.get_path()
-		if(base_path == 'res://addons/gut/test.gd'):
+		if(base_path == 'res://addons/gut/test.gd' or base_path == 'res://addons/gut/GutTest.cs'):
 			to_return = true
 		else:
 			to_return = _does_inherit_from_test(base_script)
@@ -100,6 +105,7 @@ func _parse_script(test_script):
 # Public
 # -----------------
 func add_script(path):
+	print('script path: ', path)
 	# SHORTCIRCUIT
 	if(has_script(path)):
 		return []
diff --git a/addons/gut/utils.gd b/addons/gut/utils.gd
index 0f4d93c9..7fd618ee 100644
--- a/addons/gut/utils.gd
+++ b/addons/gut/utils.gd
@@ -591,4 +591,3 @@ static func get_display_size():
 # THE SOFTWARE.
 #
 # ##############################################################################
-
diff --git a/project.godot b/project.godot
index 7197e088..23282bdc 100644
--- a/project.godot
+++ b/project.godot
@@ -12,7 +12,7 @@ config_version=5
 
 config/name="Gut"
 run/main_scene="res://scenes/main.tscn"
-config/features=PackedStringArray("4.3")
+config/features=PackedStringArray("4.3", "C#")
 config/icon="res://icon.png"
 
 [autoload]
@@ -21,7 +21,6 @@ global="*res://scripts/global.gd"
 
 [debug]
 
-gdscript/warnings/exclude_addons=false
 gdscript/warnings/redundant_await=0
 
 [display]
@@ -29,6 +28,10 @@ gdscript/warnings/redundant_await=0
 window/stretch/mode="canvas_items"
 window/dpi/allow_hidpi=false
 
+[dotnet]
+
+project/assembly_name="Gut"
+
 [editor_plugins]
 
 disabled=PackedStringArray("res://addons/gut/plugin.cfg")
diff --git a/test/panel_demo_scripts/test_totals_testing.gd b/test/panel_demo_scripts/test_totals_testing.gd
index b13eb5b4..ca94dbb2 100644
--- a/test/panel_demo_scripts/test_totals_testing.gd
+++ b/test/panel_demo_scripts/test_totals_testing.gd
@@ -60,4 +60,3 @@ func test_fail_with_orphans():
 
 func test_no_assert_and_orphans():
 	var n1 = Node2D.new()
-
diff --git a/test/samples/cs/TestCSharp.cs b/test/samples/cs/TestCSharp.cs
new file mode 100644
index 00000000..0bfdbbcd
--- /dev/null
+++ b/test/samples/cs/TestCSharp.cs
@@ -0,0 +1,22 @@
+using Godot;
+using System;
+// using GutCSharp;
+
+public partial class TestCSharp : GutTest
+{
+    public void TestOne()
+    {
+        // This should pass
+        // AssertEq("five", "five", "Values should be equal");
+    }
+    
+    public void TestTwo()
+    {
+        // This should fail (like your sample)
+        // AssertNe("five", "five", "This should fail");
+    }
+
+    public void test_three() {
+        AssertEq(1, 1, "This should pass");
+    }
+}
diff --git a/test/samples/test_readme_examples.gd b/test/samples/test_readme_examples.gd
index 41bbdcb3..0ab9a40d 100644
--- a/test/samples/test_readme_examples.gd
+++ b/test/samples/test_readme_examples.gd
@@ -768,5 +768,3 @@ func test_assert_setget():
 
 	# assert_setget(HealthBar, 'label') # FAIL => setter or getter has to be specified
 	# assert_setget(HealthBar, 'label', true) # FAIL => setter does not exist
-
-