Changing assert to become a class

test/fixtures/errors/error_exit.snapshot

@@ -1,13 +1,13 @@
 Exiting with code=1
 node:assert:*
-  throw new AssertionError(obj);
-  ^
+    throw new AssertionError(obj);
+    ^
 
 AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
 
 1 !== 2
 
-    at Object.<anonymous> (*error_exit.js:*:*) {
+    at new AssertionError (node:internal*assert*assertion_error:*:*) {
   generatedMessage: true,
   code: 'ERR_ASSERTION',
   actual: 1,

test/fixtures/errors/if-error-has-good-stack.snapshot

@@ -1,12 +1,12 @@
 node:assert:*
-    throw newErr;
-    ^
+      throw newErr;
+      ^
 
 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
+    at new AssertionError (node:internal*assert*assertion_error:*:*)
+    at Assert.ifError (node:assert:*:*)
     at z (*if-error-has-good-stack.js:*:*)
     at y (*if-error-has-good-stack.js:*:*)
-    at x (*if-error-has-good-stack.js:*:*)
-    at Object.<anonymous> (*if-error-has-good-stack.js:*:*)
     at c (*if-error-has-good-stack.js:*:*)
     at b (*if-error-has-good-stack.js:*:*)
     at a (*if-error-has-good-stack.js:*:*)

test/fixtures/test-runner/output/describe_it.snapshot

@@ -154,6 +154,9 @@ not ok 14 - async assertion fail
     *
     *
     *
+    *
+    *
+    *
   ...
 # Subtest: resolve pass
 ok 15 - resolve pass

test/fixtures/test-runner/output/dot_reporter.snapshot

@@ -61,6 +61,9 @@ Failed tests:
       *
       *
       *
+      *
+      *
+      *
       * {
     generatedMessage: true,
     code: 'ERR_ASSERTION',

test/fixtures/test-runner/output/junit_reporter.snapshot

@@ -119,6 +119,9 @@ true !== false
       *
       *
       *
+      *
+      *
+      *
       * {
     generatedMessage: true,
     code: 'ERR_ASSERTION',

test/fixtures/test-runner/output/output.snapshot

@@ -157,6 +157,9 @@ not ok 13 - async assertion fail
     *
     *
     *
+    *
+    *
+    *
   ...
 # Subtest: resolve pass
 ok 14 - resolve pass

test/fixtures/test-runner/output/output_cli.snapshot

@@ -157,6 +157,9 @@ not ok 13 - async assertion fail
     *
     *
     *
+    *
+    *
+    *
   ...
 # Subtest: resolve pass
 ok 14 - resolve pass

test/fixtures/test-runner/output/source_mapped_locations.snapshot

@@ -22,6 +22,9 @@ not ok 1 - fails
     *
     *
     *
+    *
+    *
+    *
   ...
 1..1
 # tests 1

test/fixtures/test-runner/output/spec_reporter.snapshot

@@ -166,6 +166,9 @@
       *
       *
       *
+      *
+      *
+      *
       * {
     generatedMessage: true,
     code: 'ERR_ASSERTION',

test/fixtures/test-runner/output/spec_reporter_cli.snapshot

@@ -169,6 +169,9 @@
       *
       *
       *
+      *
+      *
+      *
       * {
     generatedMessage: true,
     code: 'ERR_ASSERTION',

test/parallel/test-assert-class.js

@@ -0,0 +1,106 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { Assert } = require('assert');
+const { test } = require('node:test');
+
+// Disable colored output to prevent color codes from breaking assertion
+// message comparisons. This should only be an issue when process.stdout
+// is a TTY.
+if (process.stdout.isTTY) {
+  process.env.NODE_DISABLE_COLORS = '1';
+}
+
+test('Assert class basic instance', () => {
+  const assertInstance = new Assert();
+
+  assertInstance.ok(assert.AssertionError.prototype instanceof Error,
+                    'assert.AssertionError instanceof Error');
+  assertInstance.ok(true);
+  assertInstance.throws(
+    () => { assertInstance.fail(); },
+    {
+      code: 'ERR_ASSERTION',
+      name: 'AssertionError',
+      message: 'Failed',
+      operator: 'fail',
+      actual: undefined,
+      expected: undefined,
+      generatedMessage: true,
+      stack: /Failed/
+    }
+  );
+  assertInstance.equal(undefined, undefined);
+  assertInstance.notEqual(true, false);
+  assertInstance.throws(
+    () => assertInstance.deepEqual(/a/),
+    { code: 'ERR_MISSING_ARGS' }
+  );
+  assertInstance.throws(
+    () => assertInstance.notDeepEqual('test'),
+    { code: 'ERR_MISSING_ARGS' }
+  );
+  assertInstance.notStrictEqual(2, '2');
+  assertInstance.throws(() => assertInstance.strictEqual(2, '2'),
+                        assertInstance.AssertionError, 'strictEqual(2, \'2\')');
+  assertInstance.throws(
+    () => {
+      assertInstance.partialDeepStrictEqual({ a: true }, { a: false }, 'custom message');
+    },
+    {
+      code: 'ERR_ASSERTION',
+      name: 'AssertionError',
+      message: 'custom message\n+ actual - expected\n\n  {\n+   a: true\n-   a: false\n  }\n'
+    }
+  );
+  assertInstance.throws(
+    () => assertInstance.match(/abc/, 'string'),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: 'The "regexp" argument must be an instance of RegExp. ' +
+              "Received type string ('string')"
+    }
+  );
+  assertInstance.throws(
+    () => assertInstance.doesNotMatch(/abc/, 'string'),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: 'The "regexp" argument must be an instance of RegExp. ' +
+              "Received type string ('string')"
+    }
+  );
+
+  /* eslint-disable no-restricted-syntax */
+  {
+    function thrower(errorConstructor) {
+      throw new errorConstructor({});
+    }
+
+    let threw = false;
+    try {
+      assertInstance.doesNotThrow(() => thrower(TypeError), assertInstance.AssertionError);
+    } catch (e) {
+      threw = true;
+      assertInstance.ok(e instanceof TypeError);
+    }
+    assertInstance.ok(threw, 'assertInstance.doesNotThrow with an explicit error is eating extra errors');
+  }
+  {
+    let threw = false;
+    const rangeError = new RangeError('my range');
+
+    try {
+      assertInstance.doesNotThrow(() => {
+        throw new TypeError('wrong type');
+      }, TypeError, rangeError);
+    } catch (e) {
+      threw = true;
+      assertInstance.ok(e.message.includes(rangeError.message));
+      assertInstance.ok(e instanceof assertInstance.AssertionError);
+      assertInstance.ok(!e.stack.includes('doesNotThrow'), e);
+    }
+    assertInstance.ok(threw);
+  }
+  /* eslint-enable no-restricted-syntax */
+});

test/parallel/test-fs-promises.js

@@ -58,7 +58,7 @@ assert.strictEqual(
       code: 'ENOENT',
       name: 'Error',
       message: /^ENOENT: no such file or directory, access/,
-      stack: /at async ok\.rejects/
+      stack: /at async Assert\.rejects/
     }
   ).then(common.mustCall());
 

test/parallel/test-runner-assert.js

@@ -7,6 +7,8 @@ test('expected methods are on t.assert', (t) => {
   const uncopiedKeys = [
     'AssertionError',
     'strict',
+    'Assert',
+    'options',
   ];
   const assertKeys = Object.keys(assert).filter((key) => !uncopiedKeys.includes(key));
   const expectedKeys = ['snapshot', 'fileSnapshot'].concat(assertKeys).sort();