gdharness 1.3.9 → 1.3.11

package/build/godot/tests/listed.gd

@@ -10,11 +10,21 @@ extends SceneTree
 ## its own and reaches gdUnit4 through the project's global classes. Besides the file of suites it
 ## finds each case by its id in a dictionary ([GdhIndexedSession]), can compile the suites together
 ## before gdUnit4 loads them ([constant TOGETHER]), can turn off the reports the caller does
-## not read ([constant REPORTS_OFF]), and writes the errors each suite declares it expects
-## ([constant EXPECTED_OUT]).
+## not read ([constant REPORTS_OFF]), and writes the errors and warnings each suite declares it
+## prints ([constant EXPECTED_OUT]).
 
 const LISTED: String = "--suites-in"
 const SKIPPING: String = "--skipping-in"
+## The file of the parameterised cases dealt by their rows, one a line and tab-separated:
+## `res://suite.gd:test_case`, then `only` and the rows this engine runs, or `besides` and the rows
+## it leaves to the others, for the engine that takes every row dealt nowhere else. Apart from
+## [constant SKIPPING], since gdUnit4 reads `suite:case:row` there as the case and leaves out every
+## row of it.
+const ROWS: String = "--rows-in"
+## Printed before each row an engine leaves out, as `res://suite.gd > test_case:row`, -1 for a case
+## that is not parameterised. gdUnit4 prints nothing for a case it skips, and the caller needs every
+## row an engine found to tell one that no engine ran.
+const LEFT_OUT: String = "gdharness left out"
 ## The flags turning off a report, with the gdUnit4 hook that writes it. A gate reads what a run
 ## prints, and each report finds every case it hears of in the session to write them all out as the
 ## run ends; project_test reads the JUnit one and turns off only the HTML one.
@@ -27,11 +37,15 @@ const REPORTS_OFF: Dictionary[String, String] = {
 ## does not compile named. project_test does not: its answer is about the scripts its run reached,
 ## and the compile names every broken script of the game, then once more as the one script it made.
 const TOGETHER: String = "--compile-together"
-## The file to write the errors every suite declares it expects into, as JSON keyed by suite path and
-## then case name.
-const EXPECTED_OUT: String = "--expected-errors-out"
-## The constant a suite declares its expected errors in: case name to the exact texts it prints.
-const EXPECTED: String = "GDHARNESS_EXPECTED_ERRORS"
+## The file to write what every suite declares it prints into, as JSON: each key of
+## [constant EXPECTED] holding the declarations keyed by suite path and then case name.
+const EXPECTED_OUT: String = "--expected-out"
+## The constants a suite declares what it prints on purpose in, case name to the exact texts: its
+## engine errors, and its engine warnings.
+const EXPECTED: Dictionary[String, String] = {
+	"errors": "GDHARNESS_EXPECTED_ERRORS",
+	"warnings": "GDHARNESS_EXPECTED_WARNINGS",
+}
 ## The tool name gdUnit4 reads its options after.
 const TOOL: String = "GdUnitCmdTool.gd"
 ## How long a windowless engine sleeps after each frame. The engine's own default is the
@@ -50,10 +64,23 @@ class GdhRunner:
 	extends GdUnitTestCIRunner
 
 	var own_path: String = ""
+	## The cases dealt by their rows, by `res://suite.gd:test_case`.
+	var row_shares: Dictionary[String, GdhRowShare] = {}
 
 	func get_cmdline_args() -> PackedStringArray:
 		return options_of(OS.get_cmdline_args(), own_path)
 
+	## gdUnit4 asks this of every case it finds, a parameterised case once a row, each row carrying
+	## its index.
+	func is_skipped(test: GdUnitTestCase) -> bool:
+		if super(test):
+			return true
+		var share: GdhRowShare = row_shares.get("%s:%s" % [test.suite_resource_path, test.test_name], null)
+		if share == null or not share.leaves_out(test.attribute_index):
+			return false
+		print("%s %s > %s:%d" % [LEFT_OUT, test.suite_resource_path, test.test_name, test.attribute_index])
+		return true
+
 	## The session gdUnit4 has just made, swapped for a [GdhIndexedSession] of the same cases as it
 	## is announced: everything that reads the session, the hooks, the cases and the console printing
 	## every case, is handed it after this.
@@ -83,6 +110,19 @@ class GdhRunner:
 		return forward.to_lower() if OS.get_name() == "Windows" else forward
 
 
+## The rows of one parameterised case an engine runs: those named, or every row but those.
+class GdhRowShare:
+	extends RefCounted
+
+	var only: bool = true
+	var rows: PackedInt32Array = []
+
+	## Whether the engine leaves out [param row], which is -1 for a case that is not parameterised
+	## and so runs only in the engine taking the rows besides.
+	func leaves_out(row: int) -> bool:
+		return rows.has(row) != only
+
+
 ## gdUnit4's session finding a case by its id in a dictionary, where its own walks every case of the
 ## session, `GdUnitTestSession.find_test_by_id`: the console asks it twice a case and each report
 ## twice more, so a run's time in it grew with the square of its cases (17.9 s of processor time
@@ -128,6 +168,7 @@ func _initialize() -> void:
 	_runner.own_path = get_script().resource_path
 	_runner.add_test_suites(suites)
 	_runner.skip_test_suites(listed(asked, SKIPPING))
+	_runner.row_shares = row_shares_of(listed(asked, ROWS))
 	root.add_child(_runner)
 
 
@@ -209,6 +250,22 @@ static func listed(args: PackedStringArray, flag: String) -> PackedStringArray:
 	return named
 
 
+## The row shares [param lines] of a [constant ROWS] file give, by case.
+static func row_shares_of(lines: PackedStringArray) -> Dictionary[String, GdhRowShare]:
+	var shares: Dictionary[String, GdhRowShare] = {}
+	for line: String in lines:
+		var parts: PackedStringArray = line.split("\t")
+		if parts.size() < 2:
+			continue
+		var share: GdhRowShare = GdhRowShare.new()
+		share.only = parts[1] == "only"
+		for row: String in parts.slice(2):
+			if row.is_valid_int():
+				var _added: bool = share.rows.append(row.to_int())
+		shares[parts[0]] = share
+	return shares
+
+
 ## The argument after [param flag] in [param args], or "" when there is none.
 static func argument_after(args: PackedStringArray, flag: String) -> String:
 	var at: int = args.find(flag)
@@ -217,18 +274,18 @@ static func argument_after(args: PackedStringArray, flag: String) -> String:
 	return args[at + 1]
 
 
-## The errors each of [param suites] declares it expects, by suite path and then case name, read off
-## the compiled suite's constants so a declaration is whatever the engine made of it. A directory
+## What each of [param suites] declares in [param constant], by suite path and then case name, read
+## off the compiled suite's constants so a declaration is whatever the engine made of it. A directory
 ## listed is walked for its scripts, as gdUnit4 walks it for suites. Only a script whose source names
 ## the constant is loaded: gdUnit4 stops on a suite that does not load only when its own load is the
 ## one that fails, so a broken suite loaded here first let the rest of its directory run.
-static func expected_by_suite(suites: PackedStringArray) -> Dictionary:
+static func expected_by_suite(suites: PackedStringArray, constant: String) -> Dictionary:
 	var expected: Dictionary = {}
 	for path: String in scripts_in(suites):
-		if not FileAccess.file_exists(path) or not FileAccess.get_file_as_string(path).contains(EXPECTED):
+		if not FileAccess.file_exists(path) or not FileAccess.get_file_as_string(path).contains(constant):
 			continue
 		var suite: Script = load(path)
-		var declared: Variant = suite.get_script_constant_map().get(EXPECTED)
+		var declared: Variant = suite.get_script_constant_map().get(constant)
 		if declared is Dictionary:
 			expected[path] = declared
 	return expected
@@ -259,5 +316,8 @@ static func write_expected(path: String, suites: PackedStringArray) -> void:
 	if file == null:
 		push_error("Could not write the expected errors to %s: %s" % [path, FileAccess.get_open_error()])
 		return
-	var _stored: bool = file.store_string(JSON.stringify(expected_by_suite(suites)))
+	var expected: Dictionary = {}
+	for kind: String in EXPECTED:
+		expected[kind] = expected_by_suite(suites, EXPECTED[kind])
+	var _stored: bool = file.store_string(JSON.stringify(expected))
 	file.close()