test: restore 197 hand-weakened vendored tests to verbatim v26.3.0 (+0 new tests, 197 restored)

test/js/node/test/parallel/test-als-defaultvalue.js

@@ -1,18 +1,21 @@
-"use strict";
+// Flags: --async-context-frame
+'use strict';
 
-require("../common");
+require('../common');
 
-const { AsyncLocalStorage } = require("async_hooks");
+const {
+  AsyncLocalStorage,
+} = require('async_hooks');
 
-const assert = require("assert");
+const assert = require('assert');
 
 // ============================================================================
 // The defaultValue option
 const als1 = new AsyncLocalStorage();
 assert.strictEqual(als1.getStore(), undefined);
 
-const als2 = new AsyncLocalStorage({ defaultValue: "default" });
-assert.strictEqual(als2.getStore(), "default");
+const als2 = new AsyncLocalStorage({ defaultValue: 'default' });
+assert.strictEqual(als2.getStore(), 'default');
 
 const als3 = new AsyncLocalStorage({ defaultValue: 42 });
 assert.strictEqual(als3.getStore(), 42);
@@ -21,14 +24,14 @@ const als4 = new AsyncLocalStorage({ defaultValue: null });
 assert.strictEqual(als4.getStore(), null);
 
 assert.throws(() => new AsyncLocalStorage(null), {
-  code: "ERR_INVALID_ARG_TYPE",
+  code: 'ERR_INVALID_ARG_TYPE',
 });
 
 // ============================================================================
 // The name option
 
-const als5 = new AsyncLocalStorage({ name: "test" });
-assert.strictEqual(als5.name, "test");
+const als5 = new AsyncLocalStorage({ name: 'test' });
+assert.strictEqual(als5.name, 'test');
 
 const als6 = new AsyncLocalStorage();
-assert.strictEqual(als6.name, "");
+assert.strictEqual(als6.name, '');

test/js/node/test/parallel/test-assert-async.js

@@ -85,7 +85,7 @@ const invalidThenableFunc = () => {
 }
 
 {
-  const handler = (err) => {
+  const handler = common.mustCallAtLeast((err) => {
     assert(err instanceof assert.AssertionError,
            `${err.name} is not instance of AssertionError`);
     assert.strictEqual(err.code, 'ERR_ASSERTION');
@@ -94,7 +94,7 @@ const invalidThenableFunc = () => {
     assert.strictEqual(err.operator, 'rejects');
     assert.ok(!err.stack.includes('at Function.rejects'));
     return true;
-  };
+  });
 
   let promise = assert.rejects(async () => {}, common.mustNotCall());
   promises.push(assert.rejects(promise, common.mustCall(handler)));
@@ -132,14 +132,14 @@ promises.push(assert.rejects(
 ));
 
 {
-  const handler = (generated, actual, err) => {
+  const handler = common.mustCallAtLeast((generated, actual, err) => {
     assert.strictEqual(err.generatedMessage, generated);
     assert.strictEqual(err.code, 'ERR_ASSERTION');
     assert.strictEqual(err.actual, actual);
     assert.strictEqual(err.operator, 'rejects');
     assert.match(err.stack, /rejects/);
     return true;
-  };
+  });
   const err = new Error();
   promises.push(assert.rejects(
     assert.rejects(Promise.reject(null), { code: 'FOO' }),
@@ -192,14 +192,14 @@ promises.push(assert.rejects(
     })
   );
 
-  const handler1 = (err) => {
+  const handler1 = common.mustCallAtLeast((err) => {
     assert(err instanceof assert.AssertionError,
            `${err.name} is not instance of AssertionError`);
     assert.strictEqual(err.code, 'ERR_ASSERTION');
     assert.strictEqual(err.message, 'Failed');
     return true;
-  };
-  const handler2 = (err) => {
+  });
+  const handler2 = common.mustCallAtLeast((err) => {
     assert(err instanceof assert.AssertionError,
            `${err.name} is not instance of AssertionError`);
     assert.strictEqual(err.code, 'ERR_ASSERTION');
@@ -209,7 +209,7 @@ promises.push(assert.rejects(
     assert.ok(err.stack);
     assert.ok(!err.stack.includes('at Function.doesNotReject'));
     return true;
-  };
+  });
 
   const rejectingFn = async () => assert.fail();
 

test/js/node/test/parallel/test-assert-checktag.js

@@ -1,5 +1,5 @@
 'use strict';
-const { hasCrypto } = require('../common');
+const { hasCrypto, hasLocalStorage } = require('../common');
 const { test } = require('node:test');
 const assert = require('assert');
 
@@ -12,7 +12,7 @@ const assert = require('assert');
 if (process.stdout.isTTY)
   process.env.NODE_DISABLE_COLORS = '1';
 
-test('', { skip: !hasCrypto }, () => {
+test({ skip: !hasCrypto || !hasLocalStorage }, () => {
   // See https://github.com/nodejs/node/issues/10258
   {
     const date = new Date('2016');

test/js/node/test/parallel/test-assert-deep-with-error.js

@@ -3,6 +3,13 @@ require('../common');
 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';
+}
+
 const defaultStartMessage = 'Expected values to be strictly deep-equal:\n' +
   '+ actual - expected\n' +
   '\n';

test/js/node/test/parallel/test-assert-typedarray-deepequal.js

@@ -20,6 +20,7 @@ suite('equalArrayPairs', () => {
     [new Int8Array(1e5), new Int8Array(1e5)],
     [new Int16Array(1e5), new Int16Array(1e5)],
     [new Int32Array(1e5), new Int32Array(1e5)],
+    [new Float16Array(1e5), new Float16Array(1e5)],
     [new Float32Array(1e5), new Float32Array(1e5)],
     [new Float64Array(1e5), new Float64Array(1e5)],
     [new Float32Array([+0.0]), new Float32Array([+0.0])],
@@ -34,13 +35,19 @@ suite('equalArrayPairs', () => {
     test('', () => {
       // eslint-disable-next-line no-restricted-properties
       assert.deepEqual(arrayPair[0], arrayPair[1]);
+      // eslint-disable-next-line no-restricted-properties
+      assert.deepEqual(arrayPair[1], arrayPair[0]);
       assert.deepStrictEqual(arrayPair[0], arrayPair[1]);
+      assert.deepStrictEqual(arrayPair[1], arrayPair[0]);
+      assert.partialDeepStrictEqual(arrayPair[0], arrayPair[1]);
+      assert.partialDeepStrictEqual(arrayPair[1], arrayPair[0]);
     });
   }
 });
 
 suite('looseEqualArrayPairs', () => {
   const looseEqualArrayPairs = [
+    [new Float16Array([+0.0]), new Float16Array([-0.0])],
     [new Float32Array([+0.0]), new Float32Array([-0.0])],
     [new Float64Array([+0.0]), new Float64Array([-0.0])],
   ];
@@ -49,10 +56,24 @@ suite('looseEqualArrayPairs', () => {
     test('', () => {
       // eslint-disable-next-line no-restricted-properties
       assert.deepEqual(arrayPair[0], arrayPair[1]);
+      // eslint-disable-next-line no-restricted-properties
+      assert.deepEqual(arrayPair[1], arrayPair[0]);
       assert.throws(
         makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
         assert.AssertionError
       );
+      assert.throws(
+        makeBlock(assert.deepStrictEqual, arrayPair[1], arrayPair[0]),
+        assert.AssertionError
+      );
+      assert.throws(
+        makeBlock(assert.partialDeepStrictEqual, arrayPair[0], arrayPair[1]),
+        assert.AssertionError
+      );
+      assert.throws(
+        makeBlock(assert.partialDeepStrictEqual, arrayPair[1], arrayPair[0]),
+        assert.AssertionError
+      );
     });
   }
 });
@@ -63,24 +84,26 @@ suite('notEqualArrayPairs', () => {
     [new Int16Array(256), new Uint16Array(256)],
     [new Int16Array([256]), new Uint16Array([256])],
     [new Float64Array([+0.0]), new Float32Array([-0.0])],
-    [new Uint8Array(2), new Uint8Array(3)],
+    [new Uint8Array(2), new Uint8Array(3), 'unequal length'],
     [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])],
     [new Uint8ClampedArray([300, 2, 3]), new Uint8Array([300, 2, 3])],
     [new Uint16Array([2]), new Uint16Array([3])],
     [new Uint16Array([0]), new Uint16Array([256])],
     [new Int16Array([0]), new Uint16Array([256])],
     [new Int16Array([-256]), new Uint16Array([0xff00])], // same bits
     [new Int32Array([-256]), new Uint32Array([0xffffff00])], // ditto
+    [new Float16Array([0.1]), new Float16Array([0.0])],
+    [new Float16Array([0.1]), new Float16Array([0.1, 0.2]), 'unequal length'],
     [new Float32Array([0.1]), new Float32Array([0.0])],
-    [new Float32Array([0.1]), new Float32Array([0.1, 0.2])],
+    [new Float32Array([0.1]), new Float32Array([0.1, 0.2]), 'unequal length'],
     [new Float64Array([0.1]), new Float64Array([0.0])],
     [new Uint8Array([1, 2, 3]).buffer, new Uint8Array([4, 5, 6]).buffer],
     [
       new Uint8Array(new SharedArrayBuffer(3)).fill(1).buffer,
       new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer,
     ],
-    [new ArrayBuffer(2), new ArrayBuffer(3)],
-    [new SharedArrayBuffer(2), new SharedArrayBuffer(3)],
+    [new ArrayBuffer(2), new ArrayBuffer(3), 'unequal length'],
+    [new SharedArrayBuffer(2), new SharedArrayBuffer(3), 'unequal length'],
     [new ArrayBuffer(2), new SharedArrayBuffer(3)],
     [
       new Uint8Array(new ArrayBuffer(3)).fill(1).buffer,
@@ -97,14 +120,31 @@ suite('notEqualArrayPairs', () => {
         makeBlock(assert.deepEqual, arrayPair[0], arrayPair[1]),
         assert.AssertionError
       );
+      assert.throws(
+        // eslint-disable-next-line no-restricted-properties
+        makeBlock(assert.deepEqual, arrayPair[1], arrayPair[0]),
+        assert.AssertionError
+      );
       assert.throws(
         makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
         assert.AssertionError
       );
+      assert.throws(
+        makeBlock(assert.deepStrictEqual, arrayPair[1], arrayPair[0]),
+        assert.AssertionError
+      );
       assert.throws(
         makeBlock(assert.partialDeepStrictEqual, arrayPair[0], arrayPair[1]),
         assert.AssertionError
       );
+      if (arrayPair[2]) {
+        assert.partialDeepStrictEqual(arrayPair[1], arrayPair[0]);
+      } else {
+        assert.throws(
+          makeBlock(assert.partialDeepStrictEqual, arrayPair[1], arrayPair[0]),
+          assert.AssertionError
+        );
+      }
     });
   }
 });

test/js/node/test/parallel/test-async-hooks-recursive-stack-runInAsyncScope.js

@@ -1,20 +1,20 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const async_hooks = require('async_hooks');
 
 // This test verifies that the async ID stack can grow indefinitely.
 
 function recurse(n) {
   const a = new async_hooks.AsyncResource('foobar');
-  a.runInAsyncScope(() => {
+  a.runInAsyncScope(common.mustCall(() => {
     assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
     assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
     if (n >= 0)
       recurse(n - 1);
     assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
     assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
-  });
+  }));
 }
 
 recurse(1000);

test/js/node/test/parallel/test-async-local-storage-contexts.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const vm = require('vm');
 const { AsyncLocalStorage } = require('async_hooks');
@@ -26,10 +26,10 @@ vm.runInContext(`
 
 const storage = new AsyncLocalStorage();
 async function test() {
-  return storage.run({ test: 'main context' }, async () => {
+  return storage.run({ test: 'main context' }, common.mustCall(async () => {
     assert.strictEqual(storage.getStore().test, 'main context');
     await 42;
     assert.strictEqual(storage.getStore().test, 'main context');
-  });
+  }));
 }
 test();

test/js/node/test/parallel/test-async-local-storage-snapshot.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const common = require('../common');
-const { strictEqual } = require('assert');
+const assert = require('assert');
 const { AsyncLocalStorage } = require('async_hooks');
 
 const asyncLocalStorage = new AsyncLocalStorage();
@@ -13,4 +13,4 @@ const result =
       return asyncLocalStorage.getStore();
     });
   }));
-strictEqual(result, 123);
+assert.strictEqual(result, 123);

test/js/node/test/parallel/test-blocklist-clone.js

@@ -6,24 +6,21 @@ const {
   BlockList,
 } = require('net');
 
-const {
-  ok,
-  notStrictEqual,
-} = require('assert');
+const assert = require('assert');
 
 const blocklist = new BlockList();
 blocklist.addAddress('123.123.123.123');
 
 const mc = new MessageChannel();
 
 mc.port1.onmessage = common.mustCall(({ data }) => {
-  notStrictEqual(data, blocklist);
-  ok(data.check('123.123.123.123'));
-  ok(!data.check('123.123.123.124'));
+  assert.notStrictEqual(data, blocklist);
+  assert.ok(data.check('123.123.123.123'));
+  assert.ok(!data.check('123.123.123.124'));
 
   data.addAddress('123.123.123.124');
-  ok(blocklist.check('123.123.123.124'));
-  ok(data.check('123.123.123.124'));
+  assert.ok(blocklist.check('123.123.123.124'));
+  assert.ok(data.check('123.123.123.124'));
 
   mc.port1.close();
 });