GDScript test suite now has tests that fail until confirmed at end

Necessary because some operations cause Godot errors, which cause immediate return from the
`test_*` GDScript function. However, the runner cannot differentiate that from a legitimate
return at the end, as the only difference is a printed error message (which isn't accessible
programmatically).

As a result, a new pattern with mark_test_pending() + mark_test_succeeded() is introduced.
If the former method is called without the latter, the test is considered failed.

Author: Bromeon

itest/godot/InheritTests.gd

@@ -7,6 +7,13 @@ extends ArrayTest
 
 var test_suite: TestSuite = TestSuite.new()
 
+# Override public state management methods of TestSuite, since this is treated as a suite by the runner.
+func reset_state():
+	test_suite.reset_state()
+
+func is_test_failed() -> bool:
+	return test_suite.is_test_failed()
+
 # In order to reproduce the behavior discovered in https://github.com/godot-rust/gdext/issues/138
 # we must inherit a Godot Node. Because of this we can't just inherit TesSuite like the rest of the tests.
 func assert_that(what: bool, message: String = "") -> bool:

itest/godot/TestRunner.gd

@@ -87,11 +87,11 @@ func _ready():
 
 
 class GDScriptTestCase:
-	var suite: Object
+	var suite: RefCounted # not always TestSuite, e.g. InheritTests.
 	var method_name: String
 	var suite_name: String
 
-	func _init(suite: Object, method_name: String):
+	func _init(suite: RefCounted, method_name: String):
 		self.suite = suite
 		self.method_name = method_name
 		self.suite_name = _suite_name(suite)
@@ -100,17 +100,17 @@ class GDScriptTestCase:
 		push_error("run unimplemented")
 		return false
 
-	static func _suite_name(suite: Object) -> String:
+	static func _suite_name(suite: RefCounted) -> String:
 		var script: GDScript = suite.get_script()
 		return str(script.resource_path.get_file().get_basename(), ".gd")
 
 # Standard test case used for whenever something can be tested by just running a GDScript function.
 class GDScriptExecutableTestCase extends GDScriptTestCase:
 	func run():
 		# This is a no-op if the suite doesn't have this property.
-		suite.set("_assertion_failed", false)
+		suite.reset_state()
 		var result = suite.call(method_name)
-		var ok: bool = (result == true or result == null) and not suite.get("_assertion_failed")
+		var ok: bool = (result == true or result == null) and not suite.is_test_failed()
 		return ok
 
 # Hardcoded test case used for special cases where the standard testing API is not sufficient.

itest/godot/TestSuite.gd

@@ -7,6 +7,20 @@ class_name TestSuite
 extends RefCounted
 
 var _assertion_failed: bool = false
+var _pending: bool = false
+
+# -----------------------------------------------------------------------------------------------------------------------------------------------
+# Public API, called by the test runner.
+
+func reset_state():
+	_assertion_failed = false
+	_pending = false
+
+func is_test_failed() -> bool:
+	return _assertion_failed
+
+# -----------------------------------------------------------------------------------------------------------------------------------------------
+# Protected API, called by individual test .gd files.
 
 func print_newline():
 	printerr()
@@ -45,6 +59,29 @@ func assert_eq(actual, expected, message: String = "") -> bool:
 	# Note: stacktrace cannot be printed, because not connected to a debugging server (editor).
 	return false
 
+## Pre-emptively mark this test as "failed unless confirmed success". Use mark_test_succeeded() to rollback if test actually succeeds.
+##
+## For situations where statements coming after this will abort the test function without reliable ways to detect.
+func mark_test_pending():
+	if _pending:
+		push_error("Test is already pending.")
+		_assertion_failed = true
+		return
+
+	_pending = true
+	_assertion_failed = true
+	#print("Test will fail unless rolled back: ", message)
+
+## Roll back the failure assumption if the test actually succeeded.
+func mark_test_succeeded():
+	if not _pending:
+		push_error("Cannot mark test as succeeded, test was not marked as pending.")
+		_assertion_failed = true
+		return
+
+	_pending = false
+	_assertion_failed = false
+
 # Disable error message printing from godot. 
 #
 # Error messages are always re-enabled by the rust test runner after a test has been run.

itest/godot/input/GenFfiTests.template.gd

@@ -12,6 +12,7 @@ extends TestSuite
 
 #(
 func test_varcall_IDENT():
+	mark_test_pending()
 	var ffi = GenFfi.new()
 
 	var from_rust: Variant = ffi.return_IDENT()
@@ -24,6 +25,7 @@ func test_varcall_IDENT():
 	var mirrored: Variant = ffi.mirror_IDENT(from_gdscript)
 	assert_eq(mirrored, from_gdscript, "mirrored == from_gdscript")
 	_check_callconv("mirror_IDENT", "varcall")
+	mark_test_succeeded()
 #)
 
 # Godot currently does not support calling static methods via reflection, which is why we use an instance for the return_static_IDENT() call.
@@ -32,6 +34,7 @@ func test_varcall_IDENT():
 # so Godot cannot use ptrcalls anyway.
 #(
 func test_varcall_static_IDENT():
+	mark_test_pending()
 	var instance = GenFfi.new() # workaround
 	var from_rust: Variant = instance.return_static_IDENT()
 	_check_callconv("return_static_IDENT", "varcall")
@@ -43,10 +46,12 @@ func test_varcall_static_IDENT():
 	var mirrored: Variant = GenFfi.mirror_static_IDENT(from_gdscript)
 	assert_eq(mirrored, from_gdscript, "mirrored_static == from_gdscript")
 	_check_callconv("mirror_static_IDENT", "varcall")
+	mark_test_succeeded()
 #)
 
 #(
 func test_ptrcall_IDENT():
+	mark_test_pending()
 	var ffi := GenFfi.new()
 
 	var from_rust: TYPE = ffi.return_IDENT()
@@ -59,10 +64,12 @@ func test_ptrcall_IDENT():
 	var mirrored: TYPE = ffi.mirror_IDENT(from_gdscript)
 	assert_eq(mirrored, from_gdscript, "mirrored == from_gdscript")
 	_check_callconv("mirror_IDENT", "ptrcall")
+	mark_test_succeeded()
 #)
 
 #(
 func test_ptrcall_static_IDENT():
+	mark_test_pending()
 	var from_rust: TYPE = GenFfi.return_static_IDENT()
 	_check_callconv("return_static_IDENT", "ptrcall")
 
@@ -73,6 +80,7 @@ func test_ptrcall_static_IDENT():
 	var mirrored: TYPE = GenFfi.mirror_static_IDENT(from_gdscript)
 	assert_eq(mirrored, from_gdscript, "mirrored_static == from_gdscript")
 	_check_callconv("mirror_static_IDENT", "ptrcall")
+	mark_test_succeeded()
 #)
 
 func _check_callconv(function: String, expected: String) -> void: