@everyonesoftware/common 6.0.0 → 7.0.0

package/outputs/{chunk-CHBOMCYM.js → chunk-VF6FBNAU.js}

@@ -1,9 +1,16 @@
 import {
+  ANSIStyles,
+  AsyncResult,
   CurrentProcess,
+  IndentedCharacterWriteStream,
+  Iterable,
   List,
+  Map,
   NodeJSCharacterWriteStream,
+  NotFoundError,
   PreCondition,
   PromiseAsyncResult,
+  Stack,
   ToStringFunctions,
   __export,
   andList,
@@ -12,11 +19,10 @@ import {
   isBoolean,
   isFunction,
   isJavascriptIterable,
-  isPromise,
   isString,
   isUndefinedOrNull,
   join
-} from "./chunk-5Z677JON.js";
+} from "./chunk-MMAX3IZF.js";
 
 // tests/test.ts
 var Test = class _Test {
@@ -94,16 +100,23 @@ var Test = class _Test {
     test2.assertNotSame(value, void 0);
   }
   /**
-   * Assert that the provided value is false.
+   * Assert that the provided collection is not undefined, not null, and not empty.
    * @param value The value to check.
    */
-  assertFalse(value) {
-    _Test.assertFalse(this, value);
+  assertNotEmpty(value) {
+    _Test.assertNotEmpty(this, value);
+  }
+  static assertNotEmpty(test2, value) {
+    test2.assertNotUndefinedAndNotNull(value);
+    test2.assertTrue(Iterable.any(value).await());
   }
   /**
    * Assert that the provided value is false.
    * @param value The value to check.
    */
+  assertFalse(value) {
+    _Test.assertFalse(this, value);
+  }
   static assertFalse(test2, value) {
     PreCondition.assertNotUndefinedAndNotNull(test2, "test");
     test2.assertSame(value, false);
@@ -183,6 +196,9 @@ var AssertTest = class _AssertTest {
   assertNotUndefinedAndNotNull(value) {
     Test.assertNotUndefinedAndNotNull(this, value);
   }
+  assertNotEmpty(value) {
+    Test.assertNotEmpty(this, value);
+  }
   assertSame(left, right) {
     assert.strictEqual(left, right);
   }
@@ -321,22 +337,19 @@ var BasicTestSkip = class _BasicTestSkip {
 
 // tests/failedTest.ts
 var FailedTest = class _FailedTest {
-  fullTestNameParts;
+  testAction;
   error;
-  constructor(fullTestNameParts, error) {
-    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestName");
+  constructor(testAction, error) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
     PreCondition.assertNotUndefinedAndNotNull(error, "error");
-    this.fullTestNameParts = fullTestNameParts;
+    this.testAction = testAction;
     this.error = error;
   }
-  static create(fullTestNameParts, error) {
-    return new _FailedTest(fullTestNameParts, error);
-  }
-  getFullTestNameParts() {
-    return this.fullTestNameParts;
+  static create(testAction, error) {
+    return new _FailedTest(testAction, error);
   }
-  getFullTestName() {
-    return join(" ", this.fullTestNameParts);
+  getTestAction() {
+    return this.testAction;
   }
   getError() {
     return this.error;
@@ -349,24 +362,21 @@ var FailedTest = class _FailedTest {
 // tests/skippedTest.ts
 var SkippedTest = class _SkippedTest {
   skip;
-  fullTestNameParts;
-  constructor(skip, fullTestNameParts) {
+  testAction;
+  constructor(skip, testAction) {
     PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
-    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
     this.skip = skip;
-    this.fullTestNameParts = fullTestNameParts;
+    this.testAction = testAction;
   }
-  static create(skip, fullTestNameParts) {
-    return new _SkippedTest(skip, fullTestNameParts);
+  static create(skip, testAction) {
+    return new _SkippedTest(skip, testAction);
   }
   getSkipMessage() {
     return this.skip.getMessage();
   }
-  getFullTestNameParts() {
-    return this.fullTestNameParts;
-  }
-  getFullTestName() {
-    return join(" ", this.fullTestNameParts);
+  getTestAction() {
+    return this.testAction;
   }
 };
 
@@ -374,18 +384,21 @@ var SkippedTest = class _SkippedTest {
 var TestAction = class _TestAction {
   parent;
   name;
+  type;
   skip;
   action;
-  constructor(parent, name, skip, action) {
+  constructor(parent, name, type, skip, action) {
     PreCondition.assertNotUndefinedAndNotNull(name, "name");
+    PreCondition.assertNotEmpty(type, "type");
     PreCondition.assertNotUndefinedAndNotNull(action, "action");
     this.parent = parent;
     this.name = name;
+    this.type = type;
     this.skip = skip;
     this.action = action;
   }
-  static create(parent, name, skip, action) {
-    return new _TestAction(parent, name, skip, action);
+  static create(parent, name, type, skip, action) {
+    return new _TestAction(parent, name, type, skip, action);
   }
   getParent() {
     return this.parent;
@@ -404,6 +417,9 @@ var TestAction = class _TestAction {
   getFullName() {
     return join(" ", this.getFullNameParts());
   }
+  getType() {
+    return this.type;
+  }
   getSkip() {
     return this.skip || this.parent?.getSkip();
   }
@@ -487,113 +503,237 @@ var TestRunner = class _TestRunner {
   static skip(_runner, shouldSkip, message) {
     return TestSkip.create(shouldSkip, message);
   }
-  static runTestAction(runner, name, skip, testAction) {
-    if (getParameterCount(testAction) === 0) {
-      runner.testGroup(name, skip, testAction);
-    } else {
-      runner.test(name, skip, testAction);
-    }
+};
+
+// tests/ConsoleTestRunnerUI.ts
+var ConsoleTestRunnerUI = class {
+  writeStream;
+  styles;
+  constructor() {
+    this.styles = Map.create();
   }
-  testFile(fileName, skipOrTestAction, testAction) {
-    _TestRunner.testFile(this, fileName, skipOrTestAction, testAction);
+  static flat() {
+    return FlatConsoleTestRunnerUI.create();
   }
-  /**
-   * Create a test group that will test the provided file.
-   * @param runner The {@link TestRunner} that will run the tests.
-   * @param fileName The name of the file that is being tested.
-   * @param testAction The action that will run the tests.
-   */
-  static testFile(runner, fileName, skipOrTestAction, testAction) {
-    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
-    PreCondition.assertNotUndefinedAndNotNull(fileName, "fileName");
-    PreCondition.assertNotEmpty(fileName, "fileName");
-    let skip;
-    if (isFunction(skipOrTestAction)) {
-      PreCondition.assertUndefined(testAction, "testAction");
-      skip = void 0;
-      testAction = skipOrTestAction;
-    } else {
-      skip = skipOrTestAction;
-    }
-    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
-    _TestRunner.runTestAction(runner, fileName, skip, testAction);
+  static tree() {
+    return TreeConsoleTestRunnerUI.create();
   }
-  testType(typeNameOrType, skipOrTestAction, testAction) {
-    _TestRunner.testType(this, typeNameOrType, skipOrTestAction, testAction);
+  setWriteStream(writeStream) {
+    PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
+    this.writeStream = IndentedCharacterWriteStream.create(writeStream);
+    return this;
   }
-  /**
-   * Create a test group that will test the provided type.
-   * @param runner The {@link TestRunner} that will run the tests.
-   * @param type The {@link Type} or name of the type that is being tested.
-   * @param testAction The action that will run the tests.
-   */
-  static testType(runner, typeNameOrType, skipOrTestAction, testAction) {
-    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
-    PreCondition.assertNotUndefinedAndNotNull(typeNameOrType, "typeNameOrType");
-    let typeName;
-    if (isString(typeNameOrType)) {
-      typeName = typeNameOrType;
-    } else {
-      typeName = getName(typeNameOrType);
-    }
-    PreCondition.assertNotEmpty(typeName, "typeName");
-    let skip;
-    if (isFunction(skipOrTestAction)) {
-      PreCondition.assertUndefined(testAction, "testAction");
-      skip = void 0;
-      testAction = skipOrTestAction;
-    } else {
-      skip = skipOrTestAction;
+  setStyle(style, styleFunction) {
+    PreCondition.assertNotEmpty(style, "style");
+    PreCondition.assertNotUndefinedAndNotNull(styleFunction, "styleFunction");
+    this.styles.set(style, styleFunction);
+    return this;
+  }
+  setStyles(styles) {
+    PreCondition.assertNotUndefinedAndNotNull(styles, "styles");
+    for (const entry of Object.entries(styles)) {
+      this.setStyle(entry[0], entry[1]);
     }
+    return this;
+  }
+  applyStyle(style, text) {
+    PreCondition.assertNotEmpty(style, "style");
+    PreCondition.assertNotUndefinedAndNotNull(text, "text");
+    const styleFunction = this.styles.get(style).catch(NotFoundError, () => {
+      return (text2) => text2;
+    }).await();
+    return styleFunction(text);
+  }
+  addIndentation() {
+    this.writeStream?.addIndentation();
+  }
+  removeIndentation() {
+    this.writeStream?.removeIndentation();
+  }
+  indent(action) {
+    return this.writeStream?.indent(action) ?? AsyncResult.value(0);
+  }
+  writeString(text) {
+    return this.writeStream?.writeString(text) ?? AsyncResult.value(0);
+  }
+  writeLine(text) {
+    return this.writeStream?.writeLine(text) ?? AsyncResult.value(0);
+  }
+  writeTestActionName(testAction) {
+    return this.writeString(this.applyStyle(testAction.getType(), testAction.getName()));
+  }
+  writeFullTestActionName(testAction) {
+    return AsyncResult.create(async () => {
+      let result = 0;
+      const testActionStack = Stack.create();
+      let currentTestAction = testAction;
+      while (currentTestAction) {
+        testActionStack.add(currentTestAction);
+        currentTestAction = currentTestAction.getParent();
+      }
+      while (await testActionStack.any()) {
+        currentTestAction = await testActionStack.remove();
+        if (currentTestAction.getParent()) {
+          result += await this.writeString(" ");
+        }
+        result += await this.writeTestActionName(currentTestAction);
+      }
+      return result;
+    });
+  }
+  beforeTestGroup(testGroup) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
+    return AsyncResult.empty();
+  }
+  afterTestGroup(testGroup) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
+    return AsyncResult.empty();
+  }
+  beforeTest(testAction) {
+    return AsyncResult.empty();
+  }
+  afterPassedTest(testAction) {
+    return AsyncResult.create(async () => {
+      await this.writeLine(` - ${this.applyStyle("passed", "Passed")}`);
+    });
+  }
+  afterSkippedTest(testAction, skip) {
     PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
-    _TestRunner.runTestAction(runner, typeName, skip, testAction);
+    PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
+    return AsyncResult.create(async () => {
+      await this.writeLine(` - ${this.applyStyle("skipped", "Skipped")}`);
+    });
   }
-  testFunction(functionSignature, skipOrTestAction, testAction) {
-    _TestRunner.testFunction(this, functionSignature, skipOrTestAction, testAction);
+  afterFailedTest(currentTestAction, error) {
+    PreCondition.assertNotUndefinedAndNotNull(currentTestAction, "currentTestAction");
+    PreCondition.assertNotUndefinedAndNotNull(error, "error");
+    return AsyncResult.create(async () => {
+      await this.writeLine(` - ${this.applyStyle("failed", "Failed")}`);
+    });
   }
-  /**
-   * Create a test group that will test the provided function.
-   * @param runner The {@link TestRunner} that will run the tests.
-   * @param functionSignature The signature of the function that is being tested.
-   * @param testAction The action that will run the tests.
-   */
-  static testFunction(runner, functionSignature, skipOrTestAction, testAction) {
-    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
-    PreCondition.assertNotEmpty(functionSignature, "functionSignature");
-    let skip;
-    if (isFunction(skipOrTestAction)) {
-      PreCondition.assertUndefined(testAction, "testAction");
-      skip = void 0;
-      testAction = skipOrTestAction;
-    } else {
-      skip = skipOrTestAction;
-    }
+  writeSummary(passedTestCount, skippedTests, failedTests) {
+    PreCondition.assertGreaterThanOrEqualTo(passedTestCount, 0, "passedTestCount");
+    PreCondition.assertNotUndefinedAndNotNull(skippedTests, "skippedTests");
+    PreCondition.assertNotUndefinedAndNotNull(failedTests, "failedTests");
+    return AsyncResult.create(async () => {
+      await this.writeLine();
+      if (await skippedTests.any()) {
+        await this.writeLine(`${this.applyStyle("skipped", "Skipped Tests")}:`);
+        let counter = 0;
+        for (const skippedTest of skippedTests) {
+          await this.writeString(`${++counter}) `);
+          await this.writeFullTestActionName(skippedTest.getTestAction());
+          await this.writeLine();
+          const skipMessage = skippedTest.getSkipMessage();
+          if (skipMessage) {
+            await this.indent(() => this.writeLine(skipMessage));
+          }
+        }
+        await this.writeLine();
+      }
+      if (await failedTests.any()) {
+        await this.writeLine(`${this.applyStyle("failed", "Failed Tests")}:`);
+        let counter = 0;
+        for (const failedTest of failedTests) {
+          await this.writeString(`${++counter}) `);
+          await this.writeFullTestActionName(failedTest.getTestAction());
+          await this.writeLine();
+          await this.indent(() => this.writeLine(failedTest.getErrorMessage()));
+          await this.writeLine();
+        }
+      }
+      if (passedTestCount > 0) {
+        await this.writeLine(`${this.applyStyle("passed", "Passed")}:  ${passedTestCount}`);
+      }
+      if (await skippedTests.any()) {
+        await this.writeLine(`${this.applyStyle("skipped", "Skipped")}: ${skippedTests.getCount().await()}`);
+      }
+      if (await failedTests.any()) {
+        await this.writeLine(`${this.applyStyle("failed", "Failed")}:  ${failedTests.getCount().await()}`);
+      }
+    });
+  }
+};
+var FlatConsoleTestRunnerUI = class _FlatConsoleTestRunnerUI extends ConsoleTestRunnerUI {
+  constructor() {
+    super();
+  }
+  static create() {
+    return new _FlatConsoleTestRunnerUI();
+  }
+  beforeTest(testAction) {
+    return AsyncResult.create(async () => {
+      await this.writeFullTestActionName(testAction);
+    });
+  }
+};
+var TreeConsoleTestRunnerUI = class _TreeConsoleTestRunnerUI extends ConsoleTestRunnerUI {
+  testActions;
+  testActionWrittenDepth;
+  constructor() {
+    super();
+    this.testActions = List.create();
+    this.testActionWrittenDepth = 0;
+  }
+  static create() {
+    return new _TreeConsoleTestRunnerUI();
+  }
+  beforeTestGroup(testGroup) {
+    return AsyncResult.create(() => {
+      this.testActions.add(testGroup);
+    });
+  }
+  afterTestGroup(testGroup) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
+    PreCondition.assertTrue(this.testActions.any().await(), "this.testActions.any().await()");
+    return AsyncResult.create(() => {
+      this.testActions.removeLast().await();
+      const testActionCount = this.testActions.getCount().await();
+      if (this.testActionWrittenDepth > testActionCount) {
+        this.testActionWrittenDepth--;
+        this.removeIndentation();
+      }
+    });
+  }
+  beforeTest(testAction) {
     PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
-    _TestRunner.runTestAction(runner, functionSignature, skip, testAction);
+    return AsyncResult.create(async () => {
+      const testActionCount = this.testActions.getCount().await();
+      while (this.testActionWrittenDepth < testActionCount) {
+        const testGroup = this.testActions.get(this.testActionWrittenDepth).await();
+        await this.writeTestActionName(testGroup);
+        await this.writeLine();
+        this.addIndentation();
+        this.testActionWrittenDepth++;
+      }
+      await this.writeTestActionName(testAction);
+    });
   }
 };
 
 // tests/consoleTestRunner.ts
-var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
+var ConsoleTestRunner = class _ConsoleTestRunner {
   writeStream;
-  pendingActions;
-  pendingActionsInsertIndex;
+  testActions;
+  testActionInsertIndex;
   currentTestAction;
   currentTest;
   passedTestCount;
   skippedTests;
   testFailures;
-  constructor() {
-    super();
-    this.writeStream = NodeJSCharacterWriteStream.create(process.stdout);
-    this.pendingActions = List.create();
-    this.pendingActionsInsertIndex = 0;
+  ui;
+  constructor(ui) {
+    this.writeStream = IndentedCharacterWriteStream.create(NodeJSCharacterWriteStream.create(process.stdout));
+    this.testActions = List.create();
+    this.testActionInsertIndex = 0;
     this.passedTestCount = 0;
     this.skippedTests = List.create();
     this.testFailures = List.create();
+    this.ui = ui || ConsoleTestRunnerUI.tree();
+    this.ui.setWriteStream(this.writeStream);
   }
-  static create() {
-    return new _ConsoleTestRunner();
+  static create(ui) {
+    return new _ConsoleTestRunner(ui);
   }
   static run(testFunctionOrTestFunctions) {
     let testFunction;
@@ -614,7 +754,15 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
       };
     }
     return CurrentProcess.run(async (currentProcess) => {
-      const runner = _ConsoleTestRunner.create().setWriteStream(currentProcess.getOutputWriteStream());
+      const runner = _ConsoleTestRunner.create().setWriteStream(currentProcess.getOutputWriteStream()).setStyles({
+        file: (t) => ANSIStyles.blue(t),
+        function: (t) => ANSIStyles.blue(t),
+        type: (t) => ANSIStyles.blue(t),
+        group: (t) => ANSIStyles.blue(t),
+        passed: (t) => ANSIStyles.green(`\u2713 ${t}`),
+        skipped: (t) => ANSIStyles.yellow(`\u25CC ${t}`),
+        failed: (t) => ANSIStyles.red(`\u2717 ${t}`)
+      });
       await testFunction(runner);
       await runner.runAsync();
       await runner.printSummary();
@@ -622,21 +770,39 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
   }
   setWriteStream(writeStream) {
     PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
-    this.writeStream = writeStream;
+    this.writeStream = IndentedCharacterWriteStream.create(writeStream);
+    this.ui.setWriteStream(this.writeStream);
+    return this;
+  }
+  setStyle(style, styleFunction) {
+    this.ui.setStyle(style, styleFunction);
+    return this;
+  }
+  setStyles(styles) {
+    this.ui.setStyles(styles);
     return this;
   }
   /**
    * Get the number of {@link TestAction}s that have yet to be executed.
    */
-  getPendingTestActionsCount() {
-    return this.pendingActions.getCount().await();
+  getTestActionCount() {
+    return this.testActions.getCount().await();
   }
   /**
-   * Get the index in the pending-{@link TestAction} stack that new {@link TestAction}s will be
+   * Get the index in the {@link TestAction} list that new {@link TestAction}s will be
    * inserted at.
    */
-  getPendingTestActionsInsertIndex() {
-    return this.pendingActionsInsertIndex;
+  getTestActionInsertIndex() {
+    return this.testActionInsertIndex;
+  }
+  resetTestActionInsertIndex() {
+    this.testActionInsertIndex = 0;
+  }
+  insertTestAction(testActionName, testActionType, skip, action) {
+    const parentTestAction = this.getCurrentTestAction();
+    const testAction = TestAction.create(parentTestAction, testActionName, testActionType, skip, action);
+    this.testActions.insert(this.testActionInsertIndex, testAction);
+    this.testActionInsertIndex++;
   }
   /**
    * Get the number of tests that have been skipped.
@@ -670,37 +836,103 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
     return this.currentTest;
   }
   assertNoCurrentTest() {
-    if (this.currentTest !== void 0) {
+    if (this.currentTest) {
       this.currentTest.fail("Can't start a new test group or a new test while running a test.");
     }
   }
-  beforeTest(fullTestNameParts) {
-    return PromiseAsyncResult.create(async () => {
-      await this.writeStream.writeString(join(" ", fullTestNameParts));
-    });
+  beforeTestGroup(testAction) {
+    return this.ui.beforeTestGroup(testAction);
+  }
+  afterTestGroup(testAction) {
+    return this.ui.afterTestGroup(testAction);
+  }
+  beforeTest(testAction) {
+    return this.ui.beforeTest(testAction);
   }
-  afterPassedTest() {
-    return PromiseAsyncResult.create(async () => {
-      await this.writeStream.writeLine(" - Passed");
+  afterPassedTest(testAction) {
+    return AsyncResult.create(async () => {
+      await this.ui.afterPassedTest(testAction);
       this.passedTestCount++;
     });
   }
-  afterSkippedTest(fullTestNameParts, skip) {
-    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
-    PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
-    return PromiseAsyncResult.create(async () => {
-      this.skippedTests.add(SkippedTest.create(skip, fullTestNameParts));
-      await this.writeStream.writeLine(" - Skipped");
+  afterSkippedTest(testAction, skip) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    return AsyncResult.create(async () => {
+      await this.ui.afterSkippedTest(testAction, skip);
+      this.skippedTests.add(SkippedTest.create(skip, testAction));
     });
   }
-  afterFailedTest(fullTestNameParts, error) {
-    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
+  afterFailedTest(testAction, error) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
     PreCondition.assertNotUndefinedAndNotNull(error, "error");
-    return PromiseAsyncResult.create(async () => {
-      this.testFailures.add(FailedTest.create(fullTestNameParts, error));
-      await this.writeStream.writeLine(" - Failed");
+    return AsyncResult.create(async () => {
+      await this.ui.afterFailedTest(testAction, error);
+      this.testFailures.add(FailedTest.create(testAction, error));
     });
   }
+  andList(values) {
+    return TestRunner.andList(this, values);
+  }
+  toString(value) {
+    return TestRunner.toString(this, value);
+  }
+  skip(messageOrShouldSkip, message) {
+    let shouldSkip;
+    if (!isBoolean(messageOrShouldSkip)) {
+      shouldSkip = true;
+      message = messageOrShouldSkip;
+    } else {
+      shouldSkip = messageOrShouldSkip;
+    }
+    return TestRunner.skip(this, shouldSkip, message);
+  }
+  testFile(fileName, skipOrTestAction, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(fileName, "fileName");
+    PreCondition.assertNotEmpty(fileName, "fileName");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.testGroupOrTest(fileName, "file", skip, testAction);
+  }
+  testType(typeNameOrType, skipOrTestAction, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(typeNameOrType, "typeNameOrType");
+    let typeName;
+    if (isString(typeNameOrType)) {
+      typeName = typeNameOrType;
+    } else {
+      typeName = getName(typeNameOrType);
+    }
+    PreCondition.assertNotEmpty(typeName, "typeName");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.testGroupOrTest(typeName, "type", skip, testAction);
+  }
+  testFunction(functionSignature, skipOrTestAction, testAction) {
+    PreCondition.assertNotEmpty(functionSignature, "functionSignature");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.testGroupOrTest(functionSignature, "function", skip, testAction);
+  }
   testGroup(testGroupName, skipOrTestAction, testAction) {
     PreCondition.assertNotUndefinedAndNotNull(testGroupName, "testGroupName");
     PreCondition.assertNotEmpty(testGroupName, "testGroupName");
@@ -713,27 +945,7 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
       skip = skipOrTestAction;
     }
     PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
-    this.assertNoCurrentTest();
-    this.pendingActions.insert(
-      this.pendingActionsInsertIndex,
-      TestAction.create(
-        this.getCurrentTestAction(),
-        testGroupName,
-        skip,
-        async () => {
-          const previousTestActionInsertIndex = this.pendingActionsInsertIndex;
-          this.pendingActionsInsertIndex = this.pendingActions.getCount().await();
-          const currentTestAction = this.getCurrentTestAction();
-          try {
-            await testAction();
-          } catch (error) {
-            await this.afterFailedTest(currentTestAction.getFullNameParts(), error);
-          } finally {
-            this.pendingActionsInsertIndex = previousTestActionInsertIndex;
-          }
-        }
-      )
-    );
+    this.innerTestGroup(testGroupName, "group", skip, testAction);
   }
   test(testName, skipOrTestAction, testAction) {
     PreCondition.assertNotUndefinedAndNotNull(testName, "testName");
@@ -747,85 +959,90 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
       skip = skipOrTestAction;
     }
     PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.innerTest(testName, "test", skip, testAction);
+  }
+  innerTestGroup(testGroupName, type, skip, testGroupAction) {
+    PreCondition.assertNotEmpty(testGroupName, "testGroupName");
+    PreCondition.assertNotUndefinedAndNotNull(testGroupAction, "testGroupAction");
     this.assertNoCurrentTest();
-    this.pendingActions.insert(
-      this.pendingActionsInsertIndex,
-      TestAction.create(
-        this.getCurrentTestAction(),
-        testName,
-        skip,
-        async () => {
-          const currentTestAction = this.getCurrentTestAction();
-          try {
-            await this.beforeTest(currentTestAction.getFullNameParts());
-            if (currentTestAction.shouldSkip()) {
-              await this.afterSkippedTest(currentTestAction.getFullNameParts(), currentTestAction.getSkip());
-            } else {
-              this.currentTest = AssertTest.create(testName);
-              try {
-                await testAction(this.currentTest);
-                await this.afterPassedTest();
-              } finally {
-                this.currentTest = void 0;
-              }
+    this.insertTestAction(
+      testGroupName,
+      type,
+      skip,
+      () => this.beforeTestGroup(this.getCurrentTestAction())
+    );
+    this.insertTestAction(
+      testGroupName,
+      type,
+      skip,
+      async () => {
+        this.resetTestActionInsertIndex();
+        try {
+          await testGroupAction();
+        } catch (error) {
+          const currentTestGroupAction = this.getCurrentTestAction();
+          await this.afterFailedTest(currentTestGroupAction, error);
+        }
+      }
+    );
+    this.insertTestAction(
+      testGroupName,
+      type,
+      skip,
+      () => this.afterTestGroup(this.getCurrentTestAction())
+    );
+  }
+  innerTest(testName, testType, skip, testAction) {
+    PreCondition.assertNotEmpty(testName, "testName");
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.assertNoCurrentTest();
+    this.insertTestAction(
+      testName,
+      testType,
+      skip,
+      async () => {
+        const currentTestAction = this.getCurrentTestAction();
+        try {
+          await this.beforeTest(currentTestAction);
+          const skip2 = currentTestAction.getSkip();
+          if (skip2?.getShouldSkip()) {
+            await this.afterSkippedTest(currentTestAction, skip2);
+          } else {
+            this.currentTest = AssertTest.create(testName);
+            try {
+              await testAction(this.currentTest);
+            } finally {
+              this.currentTest = void 0;
             }
-          } catch (error) {
-            await this.afterFailedTest(currentTestAction.getFullNameParts(), error);
+            await this.afterPassedTest(currentTestAction);
           }
+        } catch (error) {
+          await this.afterFailedTest(currentTestAction, error);
         }
-      )
+      }
     );
   }
+  testGroupOrTest(name, type, skip, testAction) {
+    if (getParameterCount(testAction) === 0) {
+      this.innerTestGroup(name, type, skip, testAction);
+    } else {
+      this.innerTest(name, type, skip, testAction);
+    }
+  }
   async runAsync() {
-    while (this.pendingActions.any().await()) {
-      this.currentTestAction = this.pendingActions.removeLast().await();
+    while (this.testActions.any().await()) {
+      this.resetTestActionInsertIndex();
+      this.currentTestAction = this.testActions.removeFirst().await();
       try {
-        const result = this.currentTestAction.runAsync();
-        if (isPromise(result)) {
-          await result;
-        }
+        await this.currentTestAction.runAsync();
       } finally {
         this.currentTestAction = void 0;
       }
     }
+    this.resetTestActionInsertIndex();
   }
   printSummary() {
-    return PromiseAsyncResult.create(async () => {
-      await this.writeStream.writeLine();
-      const skippedTests = this.getSkippedTests();
-      if (await skippedTests.any()) {
-        await this.writeStream.writeLine(`Skipped Tests:`);
-        let counter = 0;
-        for (const skippedTest of skippedTests) {
-          await this.writeStream.writeLine(`${++counter}) ${skippedTest.getFullTestName()}`);
-          const skipMessage = skippedTest.getSkipMessage();
-          if (skipMessage) {
-            await this.writeStream.writeLine(`  ${skipMessage}`);
-          }
-        }
-        await this.writeStream.writeLine();
-      }
-      const failedTests = this.getFailedTests();
-      if (await failedTests.any()) {
-        await this.writeStream.writeLine("Failed Tests:");
-        let counter = 0;
-        for (const failedTest of failedTests) {
-          await this.writeStream.writeLine(`${++counter}) ${failedTest.getFullTestName()}`);
-          await this.writeStream.writeLine(`  ${failedTest.getErrorMessage()}`);
-          await this.writeStream.writeLine();
-        }
-      }
-      const passedTestCount = this.getPassedTestCount();
-      if (passedTestCount > 0) {
-        await this.writeStream.writeLine(`Passed:  ${passedTestCount}`);
-      }
-      if (await skippedTests.any()) {
-        await this.writeStream.writeLine(`Skipped: ${skippedTests.getCount().await()}`);
-      }
-      if (await failedTests.any()) {
-        await this.writeStream.writeLine(`Failed:  ${failedTests.getCount().await()}`);
-      }
-    });
+    return this.ui.writeSummary(this.passedTestCount, this.getSkippedTests(), this.getFailedTests());
   }
 };
 
@@ -842,4 +1059,4 @@ export {
   TestRunner,
   ConsoleTestRunner
 };
-//# sourceMappingURL=chunk-CHBOMCYM.js.map
+//# sourceMappingURL=chunk-VF6FBNAU.js.map