xunit.ts 1.4.0 → 3.0.0

package/src/Assertions/StringStartsWith.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a string begins with a given substring
@@ -16,12 +16,12 @@ import { AssertionError } from "assert";
  * this.assert.stringStartsWith(needle, haystack);
  */
 export default function StringStartsWith(needle: string, haystack: string | null, message?: string) {
-	if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) === 0) {
+	if (haystack?.startsWith(needle)) {
 		return;
 	}
 
 	throw new AssertionError({
-		message: message || "Expected string containing expression, but string did not contain expression",
+		message: message ?? "Expected string containing expression, but string did not contain expression",
 		expected: needle,
 		actual: haystack
 	});

package/src/Assertions/Throws.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that an expression throws an error/exception
@@ -14,14 +14,14 @@ import { AssertionError } from "assert";
  * @example
  * this.assert.throws(() => expression);
  */
-export default function Throws(expression: () => any, message?: string) {
+export default function Throws(expression: () => unknown, message?: string) {
 	try {
 		expression();
-	} catch (exception) {
+	} catch {
 		return;
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to throw exception, but expression did not throw exception"
+		message: message ?? "Expected expression to throw exception, but expression did not throw exception"
 	});
 }

package/src/Assertions/True.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a given expression evaluates to `true`
@@ -14,13 +14,13 @@ import { AssertionError } from "assert";
  * @example
  * this.assert.true(expression);
  */
-export default function True(expression: any, message?: string) {
+export default function True(expression: unknown, message?: string) {
 	if (expression === true) {
 		return;
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be true, but expression is not true",
+		message: message ?? "Expected expression to be true, but expression is not true",
 		expected: true,
 		actual: expression
 	});

package/src/Assertions/Undefined.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a given value is equal to `undefined`
@@ -14,13 +14,13 @@ import { AssertionError } from "assert";
  * @example
  * this.assert.undefined(expression);
  */
-export default function Undefined(expression: any, message?: string) {
+export default function Undefined(expression: unknown, message?: string) {
 	if (expression === undefined) {
 		return;
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be undefined, but expression is not undefined",
+		message: message ?? "Expected expression to be undefined, but expression is not undefined",
 		expected: undefined,
 		actual: expression
 	});

package/src/Assertions/index.ts

@@ -1,36 +1,27 @@
-import is_true from "./True";
-import is_false from "./False";
-
-import is_undefined from "./Undefined";
+import contains from "./Contains";
+import count from "./Count";
 import is_defined from "./Defined";
-
-import is_null from "./Null";
-import not_null from "./NotNull";
-
-import equal from "./Equal";
-import not_equal from "./NotEqual";
-
+import not_contains from "./DoesNotContain";
+import does_not_throw from "./DoesNotThrow";
 import empty from "./Empty";
+import equal from "./Equal";
+import is_false from "./False";
+import instance_of from "./InstanceOf";
 import not_empty from "./NotEmpty";
-
-import count from "./Count";
-
-import contains from "./Contains";
-import not_contains from "./DoesNotContain";
-
+import not_equal from "./NotEqual";
+import not_null from "./NotNull";
+import is_null from "./Null";
 import string_contains from "./StringContains";
 import string_not_contains from "./StringDoesNotContain";
-
-import string_starts from "./StringStartsWith";
+import string_not_ends from "./StringDoesNotEndWith";
+import string_not_matches from "./StringDoesNotMatch";
 import string_not_starts from "./StringDoesNotStartWith";
-
 import string_ends from "./StringEndsWith";
-import string_not_ends from "./StringDoesNotEndWith";
-
-import instance_of from "./InstanceOf";
-
+import string_matches from "./StringMatches";
+import string_starts from "./StringStartsWith";
 import throws from "./Throws";
-import does_not_throw from "./DoesNotThrow";
+import is_true from "./True";
+import is_undefined from "./Undefined";
 
 export default new class AssertionLibrary {
 	true = is_true;
@@ -62,6 +53,9 @@ export default new class AssertionLibrary {
 	stringEndsWith = string_ends;
 	stringDoesNotEndWith = string_not_ends;
 
+	stringMatches = string_matches;
+	stringDoesNotMatch = string_not_matches;
+
 	instanceOf = instance_of;
 
 	throws = throws;

package/src/CLI.ts

@@ -1,10 +1,12 @@
-import Usage from "command-line-usage";
-import JUnitReporter from "./Reporters/JUnitReporter";
-import Process from "process";
+import Process from "node:process";
+
 import Args from "command-line-args";
+import Usage from "command-line-usage";
 import SafeRegex from "lodash.escaperegexp";
-import Runner from "./Runners/Runner";
+
+import JUnitReporter from "./Reporters/JUnitReporter";
 import SonarReporter from "./Reporters/SonarReporter";
+import Runner from "./Runners/Runner";
 
 export default class CLI {
 	private static readonly options: Usage.OptionDefinition[] = [
@@ -97,13 +99,15 @@ export default class CLI {
 		const runner = this.runnerFactory(args);
 
 		try {
-			const filters = args.filter ?? [];
-			const results = await runner.runAll(args.dir, filters.map(SafeRegex));
+			const argFilter = args.filter as string[] | undefined;
+			const filters: string[] = argFilter ?? [];
+			const regexFilters = filters.map((f: string) => new RegExp(SafeRegex(f)));
+			const results = await runner.runAll(args.dir as string, regexFilters);
 			return Runner.allTestsPassed(results);
 		} catch (error) {
 			if (error instanceof Error) {
 				this.process.stderr.write(`An unhandled ${error.name} occurred: ${error.message}\n`);
-				this.process.stderr.write(error.stack?.toString() || "(no call stack)\n");
+				this.process.stderr.write(error.stack?.toString() ?? "(no call stack)\n");
 			}
 			return false;
 		}

package/src/Factory.ts

@@ -1,15 +1,17 @@
+import fs from "node:fs/promises";
+
 import Args from "command-line-args";
-import ConsoleReporter from "./Reporters/ConsoleReporter";
+
 import FileSystem from "./IO/FileSystem";
-import JUnitReporter from "./Reporters/JUnitReporter";
 import Output from "./IO/Output";
+import ConsoleReporter from "./Reporters/ConsoleReporter";
+import JUnitReporter from "./Reporters/JUnitReporter";
 import ResultReporter from "./Reporters/ResultReporter";
+import SonarReporter from "./Reporters/SonarReporter";
 import Runner from "./Runners/Runner";
 import TestRunner from "./Runners/TestRunner";
 import TestSuiteLoader from "./Runners/TestSuiteLoader";
 import TestSuiteRunner from "./Runners/TestSuiteRunner";
-import fs from "fs/promises";
-import SonarReporter from "./Reporters/SonarReporter";
 
 export default class Factory {
 	static readonly file_system = new FileSystem(fs);
@@ -23,11 +25,11 @@ export default class Factory {
 		return new Runner(loader, test_suite_runner, reporters);
 	}
 
-	static Reporters(args: Args.CommandLineOptions): ReadonlyArray<ResultReporter> {
+	static Reporters(args: Args.CommandLineOptions): readonly ResultReporter[] {
 		return [
-			!args.quiet ? new ConsoleReporter(new Output(process.stdout)) : null,
-			args.junit !== undefined ? new JUnitReporter(Factory.file_system, args.junit ?? JUnitReporter.defaultFileName) : null,
-			args.sonar !== undefined ? new SonarReporter(Factory.file_system, args.sonar ?? SonarReporter.defaultFileName) : null
-		].filter(r => r !== null) as ResultReporter[];
+			args.quiet ? null : new ConsoleReporter(new Output(process.stdout)),
+			args.junit === undefined ? null : new JUnitReporter(Factory.file_system, args.junit as string | undefined ?? JUnitReporter.defaultFileName),
+			args.sonar === undefined ? null : new SonarReporter(Factory.file_system, args.sonar as string | undefined ?? SonarReporter.defaultFileName)
+		].filter(r => r !== null);
 	}
 }

package/src/Framework/Test.ts

@@ -1,6 +1,6 @@
-import TestSuite from "./TestSuite";
 import TestInfo from "./TestInfo";
 import TestName from "./TestName";
+import TestSuite from "./TestSuite";
 
 /**
  * Annotates a test method within a {@link TestSuite}
@@ -18,6 +18,6 @@ import TestName from "./TestName";
  */
 export default function Test(test_name?: string) {
 	return function (suite: TestSuite, method_name: string, info: TestInfo) {
-		suite.addTest(test_name || TestName.toSentenceCase(method_name), info);
+		suite.addTest(test_name ?? TestName.toSentenceCase(method_name), info);
 	};
 }

package/src/Framework/TestInfo.ts

@@ -1,2 +1,8 @@
-type TestInfo = TypedPropertyDescriptor<() => Promise<void>>;
+type AsyncTest = () => Promise<void>;
+type SyncTest = () => void;
+
+export type AsyncTestInfo = TypedPropertyDescriptor<AsyncTest>;
+export type SyncTestInfo = TypedPropertyDescriptor<SyncTest>;
+
+type TestInfo = AsyncTestInfo | SyncTestInfo;
 export default TestInfo;

package/src/Framework/TestName.ts

@@ -1,8 +1,8 @@
 export default class TestName {
 	static toSentenceCase(test_name: string) {
 		const result = test_name
-			.replace(/_([A-Z])/gi, (substring: string, match: string) => match.toUpperCase())
-			.replace(/([A-Z])/g, " $1")
+			.replaceAll(/_([A-Z])/gi, (substring: string, match: string) => match.toUpperCase())
+			.replaceAll(/([A-Z])/g, " $1")
 			.trim();
 		return result.charAt(0).toUpperCase() + result.slice(1);
 	}

package/src/Framework/TestSuite.ts

@@ -1,5 +1,5 @@
-import TestInfo from "./TestInfo";
 import AssertionLibrary from "../Assertions";
+import TestInfo from "./TestInfo";
 
 /**
  * Defines a container of tests
@@ -13,12 +13,10 @@ import AssertionLibrary from "../Assertions";
 export default abstract class TestSuite {
 	assert = AssertionLibrary;
 
-	private tests: Record<string, TestInfo> = {};
+	private tests?: Record<string, TestInfo> = {};
 
 	addTest(name: string, info: TestInfo) {
-		if (this.tests === undefined || this.tests === null) {
-			this.tests = {};
-		}
+		this.tests ??= {};
 		this.tests[name] = info;
 	}
 
@@ -33,11 +31,18 @@ export default abstract class TestSuite {
 	}
 
 	filteredTests(filters: RegExp[]) {
+		const tests = this.tests;
+		if (tests === undefined)
+			return {};
+
+		const keys = Object.keys(tests)
+			.filter(k => filters.map(f => f.test(`${this.constructor.name}.${tests[k].value?.name}`)).some(Boolean));
+
 		const filtered: Record<string, TestInfo> = {};
-		const keys = Object.keys(this.tests).filter(k => filters.map(f => f.test(`${this.constructor.name}.${this.tests[k].value?.name}`)).filter(m => m).length > 0);
 		keys.forEach(k => {
-			filtered[k] = this.tests[k];
+			filtered[k] = tests[k];
 		});
+
 		return filtered;
 	}
 }

package/src/IO/FileSystem.ts

@@ -1,14 +1,16 @@
-import fs_promises from "fs/promises";
-import path from "path";
+import fs_promises from "node:fs/promises";
+import path from "node:path";
 
 export default class FileSystem {
 
 	constructor(private readonly fs: typeof fs_promises) {
 	}
 
+	private static readonly matchExtension: RegExp = new RegExp(/\.(\w+)$/);
+
 	static extension(file: string) {
-		const match = file.match(/\.(\w+)$/);
-		return match !== undefined && match !== null && match.length > 1
+		const match = this.matchExtension.exec(file);
+		return match && match.length > 1
 			? match[1]
 			: "";
 	}
@@ -25,7 +27,7 @@ export default class FileSystem {
 					: [ item_path ]);
 			}
 			return files;
-		} catch (e) {
+		} catch {
 			return [];
 		}
 	}

package/src/IO/Output.ts

@@ -1,4 +1,4 @@
-import { WriteStream } from "tty";
+import { WriteStream } from "node:tty";
 
 export default class Output {
 

package/src/Reporters/ConsoleReporter.ts

@@ -1,11 +1,14 @@
-import ResultReporter from "./ResultReporter";
-import TestSuite from "../Framework/TestSuite";
-import Output from "../IO/Output";
-import TestName from "../Framework/TestName";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { AssertionError } from "node:assert";
+
 import colors from "colors";
-import { AssertionError } from "assert";
-import TestSuiteResults from "../Framework/TestSuiteResults";
+
 import { ResultType } from "../Framework/ResultType";
+import TestName from "../Framework/TestName";
+import TestSuite from "../Framework/TestSuite";
+import TestSuiteResults from "../Framework/TestSuiteResults";
+import Output from "../IO/Output";
+import ResultReporter from "./ResultReporter";
 
 export default class ConsoleReporter implements ResultReporter {
 
@@ -42,11 +45,10 @@ export default class ConsoleReporter implements ResultReporter {
 	testErrored(suite: TestSuite, test_name: string, error: Error, duration: number): void {
 		this.out.write(` (${Math.round(duration)} ms)`);
 		this.out.overwrite(`  ${colors.red("✘")}\n`);
-		this.out.writeLine(`  ${error.stack}`);
+		this.out.writeLine(`  ${error.stack ?? ""}`);
 		this.out.writeLine();
 	}
 
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	testIncomplete(suite: TestSuite, test_name: string): void {
 		this.out.overwrite(`  ${colors.yellow("?")}\n`);
 	}
@@ -61,16 +63,16 @@ export default class ConsoleReporter implements ResultReporter {
 		this.out.writeLine();
 	}
 
-	runCompleted(suites: Record<string, TestSuiteResults>): void {
+	async runCompleted(suites: Record<string, TestSuiteResults>): Promise<void> {
 		const results = Object.values(suites);
 		if (!results.length) {
 			this.out.writeLine("No tests found!");
-			return;
+			return Promise.resolve();
 		}
 
 		const sum = (result_type?: ResultType) => results
-			.map((suite_result) => result_type !== undefined ? suite_result.count(result_type) : suite_result.total())
-			.reduce((acc, current) => acc + current);
+			.map((suite_result) => result_type === undefined ? suite_result.total() : suite_result.count(result_type))
+			.reduce((acc, current) => acc + current, 0);
 
 		const result = (result_type?: ResultType, color: (string: string) => string = colors.white) => {
 			const count = sum(result_type).toString();

package/src/Reporters/FileReporter.ts

@@ -1,11 +1,13 @@
-import ResultReporter from "./ResultReporter";
-import TestSuiteResults from "../Framework/TestSuiteResults";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { AssertionError } from "node:assert";
+
 import TestSuite from "../Framework/TestSuite";
-import { AssertionError } from "assert";
+import TestSuiteResults from "../Framework/TestSuiteResults";
 import FileSystem from "../IO/FileSystem";
+import ResultReporter from "./ResultReporter";
 
 export default abstract class FileReporter implements ResultReporter {
-	/* eslint-disable @typescript-eslint/no-unused-vars */
+
 	constructor(protected readonly file_system: FileSystem, protected readonly path: string) {
 	}
 
@@ -41,5 +43,5 @@ export default abstract class FileReporter implements ResultReporter {
 		return;
 	}
 
-	abstract runCompleted(results: Record<string, TestSuiteResults>): void;
+	abstract runCompleted(results: Record<string, TestSuiteResults>): Promise<void>;
 }

package/src/Reporters/JUnitReporter.ts

@@ -1,8 +1,9 @@
-import TestSuiteResults from "../Framework/TestSuiteResults";
 import xml from "xml";
-import TestName from "../Framework/TestName";
+
 import { ResultType } from "../Framework/ResultType";
+import TestName from "../Framework/TestName";
 import TestResult from "../Framework/TestResult";
+import TestSuiteResults from "../Framework/TestSuiteResults";
 import XMLReporter from "./XMLReporter";
 
 export default class JUnitReporter extends XMLReporter {

package/src/Reporters/ResultReporter.ts

@@ -1,5 +1,6 @@
+import { AssertionError } from "node:assert";
+
 import TestSuite from "../Framework/TestSuite";
-import { AssertionError } from "assert";
 import TestSuiteResults from "../Framework/TestSuiteResults";
 
 export default interface ResultReporter {
@@ -19,5 +20,5 @@ export default interface ResultReporter {
 
 	suiteCompleted(suite: TestSuite, results: TestSuiteResults): void;
 
-	runCompleted(results: Record<string, TestSuiteResults>): void;
-}
+	runCompleted(results: Record<string, TestSuiteResults>): Promise<void>;
+};

package/src/Reporters/SonarReporter.ts

@@ -1,9 +1,11 @@
-import TestSuiteResults from "../Framework/TestSuiteResults";
+import path from "node:path";
+
 import xml from "xml";
+
 import { ResultType } from "../Framework/ResultType";
 import TestResult from "../Framework/TestResult";
+import TestSuiteResults from "../Framework/TestSuiteResults";
 import XMLReporter from "./XMLReporter";
-import path from "path";
 
 export default class SonarReporter extends XMLReporter {
 	static readonly defaultFileName: string = "sonar.xml";

package/src/Reporters/XMLReporter.ts

@@ -1,5 +1,5 @@
-import FileReporter from "./FileReporter";
-import TestSuiteResults from "../Framework/TestSuiteResults";
+import TestSuiteResults from "../Framework/TestSuiteResults";
+import FileReporter from "./FileReporter";
 
 export default abstract class XMLReporter extends FileReporter {
 	async runCompleted(results: Record<string, TestSuiteResults>): Promise<void> {

package/src/Runners/Runner.ts

@@ -1,12 +1,12 @@
+import { ResultType } from "../Framework/ResultType";
+import TestSuiteResults from "../Framework/TestSuiteResults";
+import ResultReporter from "../Reporters/ResultReporter";
 import TestSuiteLoader from "./TestSuiteLoader";
 import TestSuiteRunner from "./TestSuiteRunner";
-import ResultReporter from "../Reporters/ResultReporter";
-import TestSuiteResults from "../Framework/TestSuiteResults";
-import { ResultType } from "../Framework/ResultType";
 
 export default class Runner {
 
-	constructor(private readonly loader: TestSuiteLoader, private readonly runner: TestSuiteRunner, private readonly reporters: ReadonlyArray<ResultReporter>) {
+	constructor(private readonly loader: TestSuiteLoader, private readonly runner: TestSuiteRunner, private readonly reporters: readonly ResultReporter[]) {
 	}
 
 	static allTestsPassed(results: Record<string, TestSuiteResults>): boolean {
@@ -16,7 +16,7 @@ export default class Runner {
 	}
 
 	async runAll(dir: string, filters: RegExp[]): Promise<Record<string, TestSuiteResults>> {
-		await Promise.all(this.reporters.map(r => r.runStarted()));
+		this.reporters.map(r => r.runStarted());
 		const results: Record<string, TestSuiteResults> = {};
 		const suites = await this.loader.loadTestSuites(dir, filters);
 		for (const file of Object.keys(suites)) {

package/src/Runners/TestRunner.ts

@@ -1,13 +1,14 @@
-import TestInfo from "../Framework/TestInfo";
-import TestSuite from "../Framework/TestSuite";
+import { AssertionError } from "node:assert";
+
 import { ResultType } from "../Framework/ResultType";
-import ResultReporter from "../Reporters/ResultReporter";
+import TestInfo, { AsyncTestInfo, SyncTestInfo } from "../Framework/TestInfo";
 import TestResult from "../Framework/TestResult";
-import { AssertionError } from "assert";
+import TestSuite from "../Framework/TestSuite";
+import ResultReporter from "../Reporters/ResultReporter";
 
 export default class TestRunner {
 
-	constructor(private readonly reporters: ReadonlyArray<ResultReporter>) {
+	constructor(private readonly reporters: readonly ResultReporter[]) {
 	}
 
 	private static msSince(start: [ number, number ]) {
@@ -15,29 +16,36 @@ export default class TestRunner {
 		return duration[0] * 1_000 + duration[1] / 1_000_000;
 	}
 
+	private static isSyncTest = (test?: TestInfo): test is SyncTestInfo|undefined => test !== undefined;
+	private static isAsyncTest = (test?: TestInfo): test is AsyncTestInfo|undefined => test !== undefined;
+
 	async runTest(name: string, info: TestInfo, suite: TestSuite): Promise<TestResult> {
-		await Promise.all(this.reporters.map(r => r.testStarted(suite, name)));
+		this.reporters.map(r => r.testStarted(suite, name));
 		if (info.value === undefined) {
-			await Promise.all(this.reporters.map(r => r.testIncomplete(suite, name)));
+			this.reporters.map(r => r.testIncomplete(suite, name));
 			return new TestResult(ResultType.Incomplete, 0);
 		}
 
 		const start = process.hrtime();
 		try {
-			await info.value.call(suite);
+			if (TestRunner.isAsyncTest(info))
+				await info.value.call(suite);
+			else if (TestRunner.isSyncTest(info))
+				info.value.call(suite);
+
 			const duration = TestRunner.msSince(start);
-			await Promise.all(this.reporters.map(r => r.testPassed(suite, name, duration)));
+			this.reporters.map(r => r.testPassed(suite, name, duration));
 			return new TestResult(ResultType.Passed, duration);
 
 		} catch (error) {
 			const duration = TestRunner.msSince(start);
 			const typedError = error as Error;
 			if (typedError instanceof AssertionError) {
-				await Promise.all(this.reporters.map(r => r.testFailed(suite, name, typedError, duration)));
+				this.reporters.map(r => r.testFailed(suite, name, typedError, duration));
 				return new TestResult(ResultType.Failed, duration, typedError);
 			}
 
-			await Promise.all(this.reporters.map(r => r.testErrored(suite, name, typedError, duration)));
+			this.reporters.map(r => r.testErrored(suite, name, typedError, duration));
 			return new TestResult(ResultType.Error, duration, typedError);
 		}
 	}

package/src/Runners/TestSuiteLoader.ts

@@ -1,6 +1,7 @@
+import path from "node:path";
+
 import TestSuite from "../Framework/TestSuite";
 import FileSystem from "../IO/FileSystem";
-import path from "path";
 
 export default class TestSuiteLoader {
 	constructor(private readonly file_system: FileSystem) {
@@ -8,17 +9,23 @@ export default class TestSuiteLoader {
 
 	static async loadTestSuite(file: string, filters: RegExp[]) {
 		const module_path = TestSuiteLoader.getModulePath(__dirname, file);
-		const test_class = await import(module_path);
-		if (!(test_class.default?.prototype instanceof TestSuite)) {
+		const test_class = await import(module_path) as { default?: new () => TestSuite };
+		const constructor = test_class.default;
+		if (!constructor) {
+			return null;
+		}
+
+		const prototype = constructor.prototype as TestSuite;
+		if (!(prototype instanceof TestSuite)) {
 			return null;
 		}
 
-		const tests = test_class.default?.prototype.getTests(filters);
+		const tests = prototype.getTests(filters);
 		if (tests === undefined || Object.keys(tests).length === 0) {
 			return null;
 		}
 
-		const suite: TestSuite = new test_class.default();
+		const suite = new constructor();
 		suite.setTests(tests);
 		return suite;
 	}
@@ -35,7 +42,7 @@ export default class TestSuiteLoader {
 	}
 
 	static isFromNodeModules(dir: string) {
-		return dir.indexOf("node_modules") !== -1;
+		return dir.includes("node_modules");
 	}
 
 	async loadTestSuites(dir: string, filters: RegExp[]): Promise<Record<string, TestSuite>> {
@@ -46,7 +53,7 @@ export default class TestSuiteLoader {
 
 		for (const file of files) {
 			const suite = await TestSuiteLoader.loadTestSuite(file, filters);
-			if (suite !== undefined && suite !== null) {
+			if (suite !== null) {
 				suites[file] = suite;
 			}
 		}