tape-six 1.5.0 → 1.6.0

package/README.md

@@ -380,6 +380,8 @@ Test output can be controlled by flags. See [Supported flags](https://github.com
 
 The most recent releases:
 
+- 1.6.0 _New features: support for `AssertionError` and 3rd-party assertion libraries based on it like `node:assert` and `chai`, support for `console.assert()`, support for `signal` to cancel asynchronous operations, tests wait for embedded tests, improved reporting of errors, updated dev dependencies._
+- 1.5.1 _Better support for stopping parallel tests, better support for "failed to load" errors._
 - 1.5.0 _Internal refactoring (moved state to reporters), added type identification of values in the DOM and TTY reporters, multiple minor fixes._
 - 1.4.5 _Internal: added flags support for custom test runners._
 - 1.4.4 _Refreshed the lock file._

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tape-six",
-  "version": "1.5.0",
-  "description": "TAP the test harness for the modern JavaScript (ES6).",
+  "version": "1.6.0",
+  "description": "The test harness for the modern JavaScript and TypeScript.",
   "type": "module",
   "main": "index.js",
   "module": "index.js",
@@ -74,14 +74,16 @@
     "importmap": {
       "imports": {
         "tape-six": "../index.js",
-        "tape-six/": "../src/"
+        "tape-six/": "../src/",
+        "chai": "../node_modules/chai/index.js"
       }
     }
   },
   "devDependencies": {
-    "@types/node": "^25.0.10",
-    "playwright": "^1.58.0",
-    "puppeteer": "^24.36.0",
+    "@types/node": "^25.2.0",
+    "chai": "^6.2.2",
+    "playwright": "^1.58.1",
+    "puppeteer": "^24.36.1",
     "typescript": "^5.9.3"
   }
 }

package/src/State.js

@@ -1,10 +1,42 @@
 import {getTimer} from './utils/timer.js';
 
-export class StopTest extends Error {}
-
 export const signature = 'tape6-!@#$%^&*';
 
-export const isStopTest = error => error instanceof StopTest || error[signature] === signature;
+export class StopTest extends Error {
+  constructor(...args) {
+    super(...args);
+
+    if (Error.captureStackTrace) Error.captureStackTrace(this, CustomError);
+
+    this.name = 'StopTest';
+    if (!this.message) this.message = 'Test stopped';
+    this[signature] = signature;
+  }
+}
+
+export const isStopTest = error =>
+  error instanceof StopTest ||
+  (error &&
+    typeof error == 'object' &&
+    error[signature] === signature &&
+    error.name === 'StopTest' &&
+    typeof error.message == 'string');
+
+export const isAssertionError = error =>
+  error &&
+  typeof error == 'object' &&
+  error.name === 'AssertionError' &&
+  typeof error.message == 'string' &&
+  typeof error.operator == 'string';
+
+export const getStackList = error => {
+  const stackList = [];
+  for (const line of error.stack.split('\n')) {
+    const result = /^\s+at\s+(.*)$/.exec(line);
+    if (result) stackList.push(result[1].trimEnd());
+  }
+  return stackList;
+};
 
 const replacer =
   (seen = new Set()) =>
@@ -72,6 +104,20 @@ export class State {
     this.stopTest = false;
     this.timer = timer || parent.timer || getTimer();
     this.startTime = this.time = time || this.timer.now();
+    this.abortController = new AbortController();
+  }
+
+  get signal() {
+    return this.abortController.signal;
+  }
+
+  abort() {
+    if (this.abortController.signal.aborted) return;
+    this.abortController.abort();
+  }
+
+  dispose() {
+    this.abort();
   }
 
   updateParent() {
@@ -94,7 +140,7 @@ export class State {
 
     const isFailed = event.fail && !event.todo && !event.skip;
 
-    if (event.type === 'assert') {
+    if (event.type === 'assert' || event.type === 'assertion-error') {
       ++this.asserts;
       event.skip && ++this.skipped;
       isFailed && ++this.failed;
@@ -107,20 +153,29 @@ export class State {
     if (
       event.type === 'assert' &&
       (event.operator === 'error' || event.operator === 'exception') &&
-      event.data &&
-      event.data.actual &&
-      typeof event.data.actual.stack == 'string'
+      typeof event.data?.actual?.stack == 'string'
     ) {
-      const lines = event.data.actual.stack.split('\n');
-      event.at = lines[Math.min(2, lines.length) - 1].trim().replace(/^at\s+/i, '');
+      event.stackList = getStackList(event.data.actual);
+      event.at = event.stackList[0];
+    }
+
+    if (event.type === 'assertion-error' && typeof event.data?.error?.stack == 'string') {
+      event.stackList = getStackList(event.data.error);
+      event.at = event.stackList[0];
     }
 
-    if (!event.at && event.marker && typeof event.marker.stack == 'string') {
-      const lines = event.marker.stack.split('\n');
-      event.at = lines[Math.min(3, lines.length) - 1].trim().replace(/^at\s+/i, '');
+    if (!event.at && typeof event.marker?.stack == 'string') {
+      event.stackList = getStackList(event.marker);
+      event.at =
+        event.stackList[
+          Math.min(
+            typeof event.markerIndex == 'number' ? event.markerIndex : 1,
+            event.stackList.length
+          )
+        ];
     }
 
-    if (event.type === 'assert' && event.data) {
+    if ((event.type === 'assert' || event.type === 'assertion-error') && event.data) {
       if (typeof event.expected != 'string' && event.data.hasOwnProperty('expected')) {
         event.expected = serialize(event.data.expected);
       }
@@ -129,6 +184,10 @@ export class State {
         event.actual = serialize(event.data.actual);
       }
       if (typeof event.actual == 'string') delete event.data.actual;
+      if (typeof event.error != 'string' && event.data.hasOwnProperty('error')) {
+        event.error = serialize(event.data.error);
+      }
+      if (typeof event.error == 'string') delete event.data.error;
     }
 
     switch (event.type) {

package/src/Tester.js

@@ -15,6 +15,16 @@ export class Tester {
     this.testNumber = testNumber;
     this.reporter = reporter;
     this.timer = reporter.timer || getTimer();
+    this.embeddedTests = [];
+  }
+
+  async dispose() {
+    this.reporter.abort();
+    await Promise.allSettled(this.embeddedTests);
+  }
+
+  get signal() {
+    return this.reporter.signal;
   }
 
   plan(_n) {

package/src/bun/TestWorker.js

@@ -37,16 +37,20 @@ export default class TestWorker extends EventServer {
         name: 'fail to load: ' + (error.message || 'Worker error'),
         test: 0
       });
-      this.report(id, {
-        name: String(error),
-        test: 0,
-        marker: new Error(),
-        operator: 'error',
-        fail: true,
-        data: {
-          actual: error
-        }
-      });
+      try {
+        this.report(id, {
+          name: String(error),
+          test: 0,
+          marker: new Error(),
+          operator: 'error',
+          fail: true,
+          data: {
+            actual: error
+          }
+        });
+      } catch (error) {
+        if (!isStopTest(error)) throw error;
+      }
       this.close(id);
     });
     worker.addEventListener('messageerror', error => {
@@ -55,16 +59,20 @@ export default class TestWorker extends EventServer {
         name: 'fail to load: ' + (error.message || 'Worker error'),
         test: 0
       });
-      this.report(id, {
-        name: String(error),
-        test: 0,
-        marker: new Error(),
-        operator: 'error',
-        fail: true,
-        data: {
-          actual: error
-        }
-      });
+      try {
+        this.report(id, {
+          name: String(error),
+          test: 0,
+          marker: new Error(),
+          operator: 'error',
+          fail: true,
+          data: {
+            actual: error
+          }
+        });
+      } catch (error) {
+        if (!isStopTest(error)) throw error;
+      }
       this.close(id);
     });
     worker.postMessage({

package/src/deno/TestWorker.js

@@ -39,16 +39,20 @@ export default class TestWorker extends EventServer {
         name: 'fail to load: ' + (error.message || 'Worker error'),
         test: 0
       });
-      this.report(id, {
-        name: String(error),
-        test: 0,
-        marker: new Error(),
-        operator: 'error',
-        fail: true,
-        data: {
-          actual: error
-        }
-      });
+      try {
+        this.report(id, {
+          name: String(error),
+          test: 0,
+          marker: new Error(),
+          operator: 'error',
+          fail: true,
+          data: {
+            actual: error
+          }
+        });
+      } catch (error) {
+        if (!isStopTest(error)) throw error;
+      }
       this.close(id);
     });
     worker.postMessage({

package/src/node/TestWorker.js

@@ -39,16 +39,20 @@ export default class TestWorker extends EventServer {
         name: 'fail to load: ' + (error.message || 'Worker error'),
         test: 0
       });
-      this.report(id, {
-        name: String(error),
-        test: 0,
-        marker: new Error(),
-        operator: 'error',
-        fail: true,
-        data: {
-          actual: error
-        }
-      });
+      try {
+        this.report(id, {
+          name: String(error),
+          test: 0,
+          marker: new Error(),
+          operator: 'error',
+          fail: true,
+          data: {
+            actual: error
+          }
+        });
+      } catch (error) {
+        if (!isStopTest(error)) throw error;
+      }
       this.close(id);
     });
     worker.on('messageerror', error => {
@@ -57,16 +61,20 @@ export default class TestWorker extends EventServer {
         name: 'fail to load: ' + (error.message || 'Worker error'),
         test: 0
       });
-      this.report(id, {
-        name: String(error),
-        test: 0,
-        marker: new Error(),
-        operator: 'error',
-        fail: true,
-        data: {
-          actual: error
-        }
-      });
+      try {
+        this.report(id, {
+          name: String(error),
+          test: 0,
+          marker: new Error(),
+          operator: 'error',
+          fail: true,
+          data: {
+            actual: error
+          }
+        });
+      } catch (error) {
+        if (!isStopTest(error)) throw error;
+      }
       this.close(id);
     });
     worker.postMessage({

package/src/reporters/Reporter.js

@@ -9,6 +9,14 @@ export class Reporter {
     this.timer = timer || getTimer();
   }
 
+  get signal() {
+    return this.state?.signal;
+  }
+
+  abort() {
+    this.state?.abort();
+  }
+
   onTest(event) {
     this.state = new State(this.state, {
       name: event.name,
@@ -31,6 +39,7 @@ export class Reporter {
     if (theState) {
       theState.updateParent();
       this.state = theState.parent;
+      theState.dispose();
       --this.depth;
     }
     return theState;
@@ -42,8 +51,7 @@ export class Reporter {
       if (reportingMethod) {
         this[reportingMethod]({type: 'end', test: theState.test, name: theState.name});
       } else {
-        theState.updateParent();
-        this.state = theState.parent;
+        this.onEnd();
       }
       if (theState.test === event.test && theState.name === event.name) break;
     }
@@ -63,11 +71,9 @@ export class Reporter {
     end: 'onEnd',
     terminated: 'onTerminated',
     assert: 'onAssert',
+    'assertion-error': 'onAssertionError',
     comment: 'onComment',
-    'console-log': 'onConsoleLog',
-    'console-info': 'onConsoleInfo',
-    'console-warn': 'onConsoleWarn',
-    'console-error': 'onConsoleError',
+    console: 'onConsole',
     stdout: 'onStdout',
     stderr: 'onStderr',
     bailOut: 'onBailOut'

package/src/reporters/TTYReporter.js

@@ -22,7 +22,8 @@ const consoleDict = {
   log: 'log',
   info: 'inf',
   warn: 'wrn',
-  error: 'err'
+  error: 'err',
+  assert: 'srt'
 };
 
 const getType = value => {
@@ -204,26 +205,24 @@ export class TTYReporter extends Reporter {
         this.onTerminated(event, 'reportInternal');
         break;
       case 'comment':
-        !this.failureOnly && this.out(this.blue(this.italic(event.name || 'empty comment')));
-        break;
-      case 'console-log':
-      case 'console-info':
-      case 'console-warn':
-        if (!this.failureOnly && !this.hideStreams) {
-          const lines = event.name.split(/\r?\n/),
-            type = /\-(\w+)$/.exec(event.type)[1],
-            prefix = this.stdoutPaint(consoleDict[type] + ':') + ' ';
-          for (const line of lines) {
-            this.out(prefix + line);
+        if (!this.failureOnly) {
+          const message = event.name || 'empty comment';
+          for (const line of message.split(/\r?\n/)) {
+            this.out(this.blue(this.italic(line)));
           }
         }
         break;
-      case 'console-error':
-        if (!this.hideStreams) {
-          const lines = event.name.split(/\r?\n/),
-            prefix = this.stderrPaint(consoleDict.error + ':') + ' ';
-          for (const line of lines) {
-            this.out(prefix + line);
+      case 'console':
+        {
+          const method = event.data?.method,
+            isShown = method === 'error' || method === 'assert' || !this.failureOnly;
+          if (isShown && !this.hideStreams) {
+            const lines = event.name.split(/\r?\n/),
+              paint = method === 'error' || method === 'assert' ? 'stderrPaint' : 'stdoutPaint',
+              prefix = this[paint](consoleDict[method] + ':') + ' ';
+            for (const line of lines) {
+              this.out(prefix + line);
+            }
           }
         }
         break;
@@ -257,56 +256,63 @@ export class TTYReporter extends Reporter {
         }
         break;
       case 'assert':
-        const isFailed = event.fail && !event.skip && !event.todo;
-        isFailed ? ++this.failedAsserts : ++this.successfulAsserts;
-        event.skip && ++this.skippedAsserts;
-        event.todo && ++this.todoAsserts;
-        if (!isFailed && this.failureOnly) break;
-        text = event.fail ? '✗' : '✓';
-        if (this.showAssertNumber) {
-          text += ' ' + (this.renumberAsserts ? ++this.assertCounter : event.id);
-        }
-        if (event.skip) {
-          text += ' SKIP';
-        } else if (event.todo) {
-          text += ' ' + this.brightYellow('TODO');
-        }
-        event.name && (text += ' ' + event.name);
-        if (event.skip) {
-          text = this.blue(text);
-        } else {
-          text = isFailed ? this.red(text) : this.green(text);
-        }
-        this.showTime && (text += this.lowWhite(' - ' + formatTime(event.diffTime)));
-        event.fail && event.at && (text += this.lowWhite(' - ' + event.at));
-        if (this.failureOnly) {
-          --this.visibleDepth;
-          this.out(this.brightRed('✗ ' + (this.state?.name || 'anonymous test')));
-          ++this.visibleDepth;
-        }
-        this.out(text);
+      case 'assertion-error':
+        {
+          const isFailed = event.fail && !event.skip && !event.todo,
+            nameLines = event.name ? event.name.split(/\r?\n/g) : [];
+          isFailed ? ++this.failedAsserts : ++this.successfulAsserts;
+          event.skip && ++this.skippedAsserts;
+          event.todo && ++this.todoAsserts;
+          if (!isFailed && this.failureOnly) break;
+          text = event.fail ? '✗' : '✓';
+          if (this.showAssertNumber) {
+            text += ' ' + (this.renumberAsserts ? ++this.assertCounter : event.id);
+          }
+          if (event.skip) {
+            text += ' SKIP';
+          } else if (event.todo) {
+            text += ' ' + this.brightYellow('TODO');
+          }
+          nameLines[0] && (text += ' ' + nameLines[0]);
+          if (event.skip) {
+            text = this.blue(text);
+          } else {
+            text = isFailed ? this.red(text) : this.green(text);
+          }
+          this.showTime && (text += this.lowWhite(' - ' + formatTime(event.diffTime)));
+          event.fail && event.at && (text += this.lowWhite(' - ' + event.at));
+          if (this.failureOnly) {
+            --this.visibleDepth;
+            this.out(this.brightRed('✗ ' + (this.state?.name || 'anonymous test')));
+            ++this.visibleDepth;
+          }
+          this.out(text);
 
-        if (!event.fail || event.skip || !this.showData) break;
+          if (!event.fail || event.skip || !this.showData) break;
 
-        this.out(this.lowWhite('  operator: ') + event.operator);
+          this.out(this.lowWhite('  operator: ') + event.operator);
 
-        const expected = event.expected && JSON.parse(event.expected);
-        if (event.hasOwnProperty('expected')) {
-          this.out(this.lowWhite('  expected: ') + this.formatValue(expected));
-        }
+          if (nameLines.length > 1) {
+            this.out(
+              this.lowWhite(
+                '  message:  |-' + (event.generatedMessage ? ' ' + this.italic('(generated)') : '')
+              )
+            );
+            nameLines.forEach(line => this.out('    ' + line));
+          }
 
-        const actual = event.actual && JSON.parse(event.actual);
-        if (event.hasOwnProperty('actual')) {
-          this.out(this.lowWhite('  actual:   ') + this.formatValue(actual));
-        }
+          const expected = event.expected && JSON.parse(event.expected);
+          if (event.hasOwnProperty('expected')) {
+            this.out(this.lowWhite('  expected: ') + this.formatValue(expected));
+          }
+
+          const actual = event.actual && JSON.parse(event.actual);
+          if (event.hasOwnProperty('actual')) {
+            this.out(this.lowWhite('  actual:   ') + this.formatValue(actual));
+          }
 
-        const stack =
-          actual?.type === 'Error' && typeof actual.stack == 'string'
-            ? actual.stack
-            : event.marker?.stack;
-        if (typeof stack == 'string') {
           this.out(this.lowWhite('  stack: |-'));
-          stack.split('\n').forEach(line => this.out(this.lowWhite('    ' + line)));
+          event.stackList.forEach(line => this.out(this.lowWhite('    at ' + line)));
         }
         break;
     }

package/src/reporters/TapReporter.js

@@ -85,25 +85,54 @@ export class TapReporter extends Reporter {
         break;
       case 'comment':
         this.open();
-        this.write('# ' + event.name);
-        break;
-      case 'console-log':
-      case 'console-info':
-      case 'console-warn':
-        this.open();
-        this.write('# ' + /\-(\w+)$/.exec(event.type)[1] + ': ' + event.name, 'stdout');
+        {
+          const message = event.name || 'empty comment';
+          for (const line of message.split(/\r?\n/)) {
+            this.write('# ' + line);
+          }
+        }
         break;
-      case 'console-error':
+      case 'console':
         this.open();
-        this.write('# error: ' + event.name, 'stderr');
+        switch (event.data?.method) {
+          case 'log':
+            for (const line of event.name.split(/\r?\n/)) {
+              this.write('# log: ' + line, 'stdout');
+            }
+            break;
+          case 'info':
+            for (const line of event.name.split(/\r?\n/)) {
+              this.write('# info: ' + line, 'stdout');
+            }
+            break;
+          case 'warn':
+            for (const line of event.name.split(/\r?\n/)) {
+              this.write('# warn: ' + line, 'stdout');
+            }
+            break;
+          case 'error':
+            for (const line of event.name.split(/\r?\n/)) {
+              this.write('# error: ' + line, 'stderr');
+            }
+            break;
+          case 'assert':
+            for (const line of event.name.split(/\r?\n/)) {
+              this.write('# assert: ' + line, 'stdout');
+            }
+            break;
+        }
         break;
       case 'stdout':
         this.open();
-        this.write('# stdout: ' + event.name, 'stdout');
+        for (const line of event.name.split(/\r?\n/)) {
+          this.write('# stdout: ' + line, 'stdout');
+        }
         break;
       case 'stderr':
         this.open();
-        this.write('# stderr: ' + event.name, 'stderr');
+        for (const line of event.name.split(/\r?\n/)) {
+          this.write('# stderr: ' + line, 'stderr');
+        }
         break;
       case 'bail-out':
         this.open();
@@ -112,55 +141,54 @@ export class TapReporter extends Reporter {
         this.write(text, 'bail-out');
         break;
       case 'assert':
+      case 'assertion-error':
         this.open();
-        text =
-          (event.fail ? 'not ok' : 'ok') +
-          ' ' +
-          (this.renumberAsserts ? ++this.assertCounter : event.id);
-        if (event.skip) {
-          text += ' # SKIP';
-        } else if (event.todo) {
-          text += ' # TODO';
-        }
-        event.name && (text += ' ' + event.name);
-        text += ' # time=' + event.diffTime.toFixed(3) + 'ms';
-        this.write(text, event.fail ? 'failure' : 'success');
-        if (event.fail) {
-          this.write('  ---', 'yaml');
-          if (this.useJson) {
-            this.write('  operator: ' + event.operator, 'yaml');
-            if (event.hasOwnProperty('expected')) {
-              this.write('  expected: ' + formatValue(event.expected), 'yaml');
-            }
-            if (event.hasOwnProperty('actual')) {
-              this.write('  actual:   ' + formatValue(event.actual), 'yaml');
-            }
-            event.at && this.write('  at: ' + event.at, 'yaml');
-          } else {
-            yamlFormatter({operator: event.operator}, formatterOptions).forEach(line =>
-              this.write(line, 'yaml')
-            );
-            yamlFormatter(
-              {
-                expected: event.expected && JSON.parse(event.expected),
-                actual: event.actual && JSON.parse(event.actual)
-              },
-              formatterOptions
-            ).forEach(line => this.write(line, 'yaml'));
-            yamlFormatter({at: event.at}, formatterOptions).forEach(line =>
-              this.write(line, 'yaml')
-            );
+        {
+          const nameLines = event.name ? event.name.split(/\r?\n/g) : [];
+          text =
+            (event.fail ? 'not ok' : 'ok') +
+            ' ' +
+            (this.renumberAsserts ? ++this.assertCounter : event.id);
+          if (event.skip) {
+            text += ' # SKIP';
+          } else if (event.todo) {
+            text += ' # TODO';
           }
-          const actual = event.actual && JSON.parse(event.actual),
-            stack =
-              actual?.type === 'Error' && typeof actual.stack == 'string'
-                ? actual.stack
-                : event.marker.stack;
-          if (typeof stack == 'string') {
+          nameLines[0] && (text += ' ' + nameLines[0]);
+          text += ' # time=' + event.diffTime.toFixed(3) + 'ms';
+          this.write(text, event.fail ? 'failure' : 'success');
+          if (event.fail) {
+            this.write('  ---', 'yaml');
+            if (this.useJson) {
+              this.write('  operator: ' + event.operator, 'yaml');
+              this.write('  message:  ' + formatValue(nameLines), 'yaml');
+              if (event.hasOwnProperty('expected')) {
+                this.write('  expected: ' + formatValue(event.expected), 'yaml');
+              }
+              if (event.hasOwnProperty('actual')) {
+                this.write('  actual:   ' + formatValue(event.actual), 'yaml');
+              }
+              event.at && this.write('  at: ' + event.at, 'yaml');
+            } else {
+              yamlFormatter(
+                {operator: event.operator, message: nameLines},
+                formatterOptions
+              ).forEach(line => this.write(line, 'yaml'));
+              yamlFormatter(
+                {
+                  expected: event.expected && JSON.parse(event.expected),
+                  actual: event.actual && JSON.parse(event.actual)
+                },
+                formatterOptions
+              ).forEach(line => this.write(line, 'yaml'));
+              yamlFormatter({at: event.at}, formatterOptions).forEach(line =>
+                this.write(line, 'yaml')
+              );
+            }
             this.write('  stack: |-', 'yaml');
-            stack.split('\n').forEach(line => this.write('    ' + line, 'yaml'));
+            event.stackList.forEach(line => this.write('    at ' + line, 'yaml'));
+            this.write('  ...', 'yaml');
           }
-          this.write('  ...', 'yaml');
         }
         break;
     }

package/src/test.js

@@ -1,5 +1,5 @@
 import {selectTimer} from './utils/timer.js';
-import {isStopTest} from './State.js';
+import {isAssertionError, isStopTest} from './State.js';
 import getDeferred from './utils/getDeferred.js';
 import timeout from './utils/timeout.js';
 import {formatTime} from './utils/formatters.js';
@@ -25,6 +25,11 @@ export const registerNotifyCallback = callback => {
   }
 };
 
+const testers = [];
+
+export const getTesters = () => testers;
+export const getTester = () => (testers.length ? testers[testers.length - 1] : null);
+
 const processArgs = (name, options, testFn) => {
   // normalize arguments
   if (typeof name == 'function') {
@@ -61,6 +66,11 @@ const processArgs = (name, options, testFn) => {
 
 let isTimerSet = false;
 export const test = async (name, options, testFn) => {
+  const currentTester = getTester();
+  if (currentTester) {
+    return currentTester.test(name, options, testFn);
+  }
+
   options = processArgs(name, options, testFn);
   if (!isTimerSet) {
     await selectTimer();
@@ -93,6 +103,7 @@ export const runTests = async tests => {
       deferred && deferred.resolve(tester.state);
       return;
     }
+    testers.push(tester);
     try {
       tester.reporter.report({
         type: 'test',
@@ -117,6 +128,7 @@ export const runTests = async tests => {
                 test: testNumber,
                 time: tester.timer.now()
               });
+              tester.reporter.abort();
               await result;
             }
           }
@@ -133,6 +145,22 @@ export const runTests = async tests => {
           marker: new Error(),
           time: tester.timer.now()
         });
+      } else if (isAssertionError(error)) {
+        tester.reporter.report({
+          type: 'assertion-error',
+          name: String(error),
+          test: testNumber,
+          marker: new Error(),
+          time: tester.timer.now(),
+          operator: error.operator,
+          generatedMessage: error.generatedMessage,
+          fail: true,
+          data: {
+            actual: error.actual,
+            expected: error.expected,
+            error
+          }
+        });
       } else {
         tester.reporter.report({
           name: 'UNEXPECTED EXCEPTION: ' + String(error),
@@ -155,6 +183,8 @@ export const runTests = async tests => {
           });
       }
     }
+    await tester.dispose();
+    testers.pop();
     tester.reporter.report({
       type: 'end',
       name: options.name,
@@ -168,16 +198,28 @@ export const runTests = async tests => {
 };
 
 test.skip = function skip(name, options, testFn) {
+  const currentTester = getTester();
+  if (currentTester) {
+    return currentTester.skip(name, options, testFn);
+  }
   options = processArgs(name, options, testFn);
   return test({...options, skip: true});
 };
 
 test.todo = function todo(name, options, testFn) {
+  const currentTester = getTester();
+  if (currentTester) {
+    return currentTester.todo(name, options, testFn);
+  }
   options = processArgs(name, options, testFn);
   return test({...options, todo: true});
 };
 
 test.asPromise = function asPromise(name, options, testFn) {
+  const currentTester = getTester();
+  if (currentTester) {
+    return currentTester.asPromise(name, options, testFn);
+  }
   options = processArgs(name, options, testFn);
   if (options.testFn) {
     const testFn = options.testFn;
@@ -200,7 +242,9 @@ Tester.prototype.test = async function test(name, options, testFn) {
   if (this.reporter.state?.skip) {
     this.comment('SKIP test: ' + options.name);
   } else {
-    await runTests([{options}]);
+    const promise = runTests([{options}]);
+    this.embeddedTests.push(promise);
+    return promise;
   }
 };
 
@@ -215,7 +259,9 @@ Tester.prototype.todo = async function todo(name, options, testFn) {
     this.comment('SKIP test: ' + options.name);
     return;
   }
-  await runTests([{options: {...options, todo: true}}]);
+  const promise = runTests([{options: {...options, todo: true}}]);
+  this.embeddedTests.push(promise);
+  return promise;
 };
 
 Tester.prototype.asPromise = async function asPromise(name, options, testFn) {
@@ -231,7 +277,9 @@ Tester.prototype.asPromise = async function asPromise(name, options, testFn) {
         }
       });
   }
-  await runTests([{options}]);
+  const promise = runTests([{options}]);
+  this.embeddedTests.push(promise);
+  return promise;
 };
 
 export default test;

package/src/utils/EventServer.js

@@ -29,9 +29,13 @@ export default class EventServer {
     this.finalized[id] = 1;
     --this.totalTasks;
     if (this.fileQueue.length) {
-      ++this.totalTasks;
-      const nextFile = this.fileQueue.shift();
-      defer(() => this.makeTask(nextFile));
+      if (this.reporter.state?.stopTest) {
+        this.fileQueue = [];
+      } else {
+        ++this.totalTasks;
+        const nextFile = this.fileQueue.shift();
+        defer(() => this.makeTask(nextFile));
+      }
     }
     if (this.passThroughId === id) {
       this.passThroughId = null;
@@ -66,6 +70,7 @@ export default class EventServer {
     }
   }
   createTask(fileName) {
+    if (this.reporter.state?.stopTest) return;
     if (this.totalTasks < this.numberOfTasks) {
       ++this.totalTasks;
       this.makeTask(fileName);

package/src/utils/capture-console.js

@@ -9,11 +9,16 @@ export const captureConsole = () => {
     get(target, property, receiver) {
       const prop = Reflect.get(target, property, receiver);
       if (typeof prop === 'function') {
-        if (consoleVerbs[property] === 1) {
-          const type = 'console-' + property;
+        if (property === 'assert') {
+          return (assertion, ...args) => {
+            if (assertion) return;
+            const reporter = getReporter();
+            reporter.report({type: 'console', name: format(...args), data: {method: property}});
+          };
+        } else if (consoleVerbs[property] === 1) {
           return (...args) => {
             const reporter = getReporter();
-            reporter.report({type, name: format(...args)});
+            reporter.report({type: 'console', name: format(...args), data: {method: property}});
           };
         }
       }

package/web-app/TestWorker.js

@@ -1,4 +1,5 @@
 import EventServer from '../src/utils/EventServer.js';
+import {isStopTest} from '../src/State.js';
 
 export default class TestWorker extends EventServer {
   constructor(reporter, numberOfTasks, options) {
@@ -20,16 +21,20 @@ export default class TestWorker extends EventServer {
           name: 'fail to load: ' + (error.message || 'Worker error'),
           test: 0
         });
-        this.report(id, {
-          name: String(error),
-          test: 0,
-          marker: new Error(),
-          operator: 'error',
-          fail: true,
-          data: {
-            actual: error
-          }
-        });
+        try {
+          this.report(id, {
+            name: String(error),
+            test: 0,
+            marker: new Error(),
+            operator: 'error',
+            fail: true,
+            data: {
+              actual: error
+            }
+          });
+        } catch (error) {
+          if (!isStopTest(error)) throw error;
+        }
       }
       this.close(id);
     };