test: update test-assert-typedarray-deepequal to use node:test

jasnell · targos · commit d7ac3262dea4 · 2024-10-02T07:57:45.000+02:00
PR-URL: #54585 Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com> Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
diff --git a/test/parallel/test-assert-typedarray-deepequal.js b/test/parallel/test-assert-typedarray-deepequal.js
@@ -2,6 +2,7 @@
 
 require('../common');
 const assert = require('assert');
+const { test, suite } = require('node:test');
 
 function makeBlock(f) {
 const args = Array.prototype.slice.call(arguments, 1);
@@ -10,82 +11,94 @@ function makeBlock(f) {
 };
 }
 
-const equalArrayPairs = [
- [new Uint8Array(1e5), new Uint8Array(1e5)],
- [new Uint16Array(1e5), new Uint16Array(1e5)],
- [new Uint32Array(1e5), new Uint32Array(1e5)],
- [new Uint8ClampedArray(1e5), new Uint8ClampedArray(1e5)],
- [new Int8Array(1e5), new Int8Array(1e5)],
- [new Int16Array(1e5), new Int16Array(1e5)],
- [new Int32Array(1e5), new Int32Array(1e5)],
- [new Float32Array(1e5), new Float32Array(1e5)],
- [new Float64Array(1e5), new Float64Array(1e5)],
- [new Float32Array([+0.0]), new Float32Array([+0.0])],
- [new Uint8Array([1, 2, 3, 4]).subarray(1), new Uint8Array([2, 3, 4])],
- [new Uint16Array([1, 2, 3, 4]).subarray(1), new Uint16Array([2, 3, 4])],
- [new Uint32Array([1, 2, 3, 4]).subarray(1, 3), new Uint32Array([2, 3])],
- [new ArrayBuffer(3), new ArrayBuffer(3)],
- [new SharedArrayBuffer(3), new SharedArrayBuffer(3)],
-];
+suite('equalArrayPairs', () => {
+ const equalArrayPairs = [
+ [new Uint8Array(1e5), new Uint8Array(1e5)],
+ [new Uint16Array(1e5), new Uint16Array(1e5)],
+ [new Uint32Array(1e5), new Uint32Array(1e5)],
+ [new Uint8ClampedArray(1e5), new Uint8ClampedArray(1e5)],
+ [new Int8Array(1e5), new Int8Array(1e5)],
+ [new Int16Array(1e5), new Int16Array(1e5)],
+ [new Int32Array(1e5), new Int32Array(1e5)],
+ [new Float32Array(1e5), new Float32Array(1e5)],
+ [new Float64Array(1e5), new Float64Array(1e5)],
+ [new Float32Array([+0.0]), new Float32Array([+0.0])],
+ [new Uint8Array([1, 2, 3, 4]).subarray(1), new Uint8Array([2, 3, 4])],
+ [new Uint16Array([1, 2, 3, 4]).subarray(1), new Uint16Array([2, 3, 4])],
+ [new Uint32Array([1, 2, 3, 4]).subarray(1, 3), new Uint32Array([2, 3])],
+ [new ArrayBuffer(3), new ArrayBuffer(3)],
+ [new SharedArrayBuffer(3), new SharedArrayBuffer(3)],
+ ];
 
-const looseEqualArrayPairs = [
- [new Float32Array([+0.0]), new Float32Array([-0.0])],
- [new Float64Array([+0.0]), new Float64Array([-0.0])],
-];
+ for (const arrayPair of equalArrayPairs) {
+ test('', () => {
+ // eslint-disable-next-line no-restricted-properties
+ assert.deepEqual(arrayPair[0], arrayPair[1]);
+ assert.deepStrictEqual(arrayPair[0], arrayPair[1]);
+ });
+ }
+});
 
-const notEqualArrayPairs = [
- [new ArrayBuffer(3), new SharedArrayBuffer(3)],
- [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([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 Float32Array([0.1]), new Float32Array([0.0])],
- [new Float32Array([0.1]), new Float32Array([0.1, 0.2])],
- [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 SharedArrayBuffer(3)],
- [
- new Uint8Array(new ArrayBuffer(3)).fill(1).buffer,
- new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer,
- ],
-];
+suite('looseEqualArrayPairs', () => {
+ const looseEqualArrayPairs = [
+ [new Float32Array([+0.0]), new Float32Array([-0.0])],
+ [new Float64Array([+0.0]), new Float64Array([-0.0])],
+ ];
 
-for (const arrayPair of equalArrayPairs) {
- // eslint-disable-next-line no-restricted-properties
- assert.deepEqual(arrayPair[0], arrayPair[1]);
- assert.deepStrictEqual(arrayPair[0], arrayPair[1]);
-}
+ for (const arrayPair of looseEqualArrayPairs) {
+ test('', () => {
+ // eslint-disable-next-line no-restricted-properties
+ assert.deepEqual(arrayPair[0], arrayPair[1]);
+ assert.throws(
+ makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
+ assert.AssertionError
+ );
+ });
+ }
+});
 
-for (const arrayPair of looseEqualArrayPairs) {
- // eslint-disable-next-line no-restricted-properties
- assert.deepEqual(arrayPair[0], arrayPair[1]);
- assert.throws(
- makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
- assert.AssertionError
- );
-}
+suite('notEqualArrayPairs', () => {
+ const notEqualArrayPairs = [
+ [new ArrayBuffer(3), new SharedArrayBuffer(3)],
+ [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([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 Float32Array([0.1]), new Float32Array([0.0])],
+ [new Float32Array([0.1]), new Float32Array([0.1, 0.2])],
+ [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 SharedArrayBuffer(3)],
+ [
+ new Uint8Array(new ArrayBuffer(3)).fill(1).buffer,
+ new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer,
+ ],
+ ];
 
-for (const arrayPair of notEqualArrayPairs) {
- assert.throws(
- // eslint-disable-next-line no-restricted-properties
- makeBlock(assert.deepEqual, arrayPair[0], arrayPair[1]),
- assert.AssertionError
- );
- assert.throws(
- makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
- assert.AssertionError
- );
-}
+ for (const arrayPair of notEqualArrayPairs) {
+ test('', () => {
+ assert.throws(
+ // eslint-disable-next-line no-restricted-properties
+ makeBlock(assert.deepEqual, arrayPair[0], arrayPair[1]),
+ assert.AssertionError
+ );
+ assert.throws(
+ makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
+ assert.AssertionError
+ );
+ });
+ }
+});

-Original file line number
+Diff line change
 require('../common');
 constassert=require('assert');
 +const{ test, suite }=require('node:test');
 functionmakeBlock(f){
 constargs=Array.prototype.slice.call(arguments,1);
 };
+}
 -constequalArrayPairs=[
 -[newUint8Array(1e5),newUint8Array(1e5)],
 -[newUint16Array(1e5),newUint16Array(1e5)],
 -[newUint32Array(1e5),newUint32Array(1e5)],
 -[newUint8ClampedArray(1e5),newUint8ClampedArray(1e5)],
 -[newInt8Array(1e5),newInt8Array(1e5)],
 -[newInt16Array(1e5),newInt16Array(1e5)],
 -[newInt32Array(1e5),newInt32Array(1e5)],
 -[newFloat32Array(1e5),newFloat32Array(1e5)],
 -[newFloat64Array(1e5),newFloat64Array(1e5)],
 -[newFloat32Array([+0.0]),newFloat32Array([+0.0])],
 -[newUint8Array([1,2,3,4]).subarray(1),newUint8Array([2,3,4])],
 -[newUint16Array([1,2,3,4]).subarray(1),newUint16Array([2,3,4])],
 -[newUint32Array([1,2,3,4]).subarray(1,3),newUint32Array([2,3])],
 -[newArrayBuffer(3),newArrayBuffer(3)],
 -[newSharedArrayBuffer(3),newSharedArrayBuffer(3)],
 -];
 +suite('equalArrayPairs',()=>{
 +constequalArrayPairs=[
 +[newUint8Array(1e5),newUint8Array(1e5)],
 +[newUint16Array(1e5),newUint16Array(1e5)],
 +[newUint32Array(1e5),newUint32Array(1e5)],
 +[newUint8ClampedArray(1e5),newUint8ClampedArray(1e5)],
 +[newInt8Array(1e5),newInt8Array(1e5)],
 +[newInt16Array(1e5),newInt16Array(1e5)],
 +[newInt32Array(1e5),newInt32Array(1e5)],
 +[newFloat32Array(1e5),newFloat32Array(1e5)],
 +[newFloat64Array(1e5),newFloat64Array(1e5)],
 +[newFloat32Array([+0.0]),newFloat32Array([+0.0])],
 +[newUint8Array([1,2,3,4]).subarray(1),newUint8Array([2,3,4])],
 +[newUint16Array([1,2,3,4]).subarray(1),newUint16Array([2,3,4])],
 +[newUint32Array([1,2,3,4]).subarray(1,3),newUint32Array([2,3])],
 +[newArrayBuffer(3),newArrayBuffer(3)],
 +[newSharedArrayBuffer(3),newSharedArrayBuffer(3)],
 +];
 -constlooseEqualArrayPairs=[
 -[newFloat32Array([+0.0]),newFloat32Array([-0.0])],
 -[newFloat64Array([+0.0]),newFloat64Array([-0.0])],
 -];
 +for(constarrayPairofequalArrayPairs){
 +test('',()=>{
 +// eslint-disable-next-line no-restricted-properties
 +assert.deepEqual(arrayPair[0],arrayPair[1]);
 +assert.deepStrictEqual(arrayPair[0],arrayPair[1]);
 +});
 +}
 +});
 -constnotEqualArrayPairs=[
 -[newArrayBuffer(3),newSharedArrayBuffer(3)],
 -[newInt16Array(256),newUint16Array(256)],
 -[newInt16Array([256]),newUint16Array([256])],
 -[newFloat64Array([+0.0]),newFloat32Array([-0.0])],
 -[newUint8Array(2),newUint8Array(3)],
 -[newUint8Array([1,2,3]),newUint8Array([4,5,6])],
 -[newUint8ClampedArray([300,2,3]),newUint8Array([300,2,3])],
 -[newUint16Array([2]),newUint16Array([3])],
 -[newUint16Array([0]),newUint16Array([256])],
 -[newInt16Array([0]),newUint16Array([256])],
 -[newInt16Array([-256]),newUint16Array([0xff00])],// same bits
 -[newInt32Array([-256]),newUint32Array([0xffffff00])],// ditto
 -[newFloat32Array([0.1]),newFloat32Array([0.0])],
 -[newFloat32Array([0.1]),newFloat32Array([0.1,0.2])],
 -[newFloat64Array([0.1]),newFloat64Array([0.0])],
 -[newUint8Array([1,2,3]).buffer,newUint8Array([4,5,6]).buffer],
 -[
 -newUint8Array(newSharedArrayBuffer(3)).fill(1).buffer,
 -newUint8Array(newSharedArrayBuffer(3)).fill(2).buffer,
 -],
 -[newArrayBuffer(2),newArrayBuffer(3)],
 -[newSharedArrayBuffer(2),newSharedArrayBuffer(3)],
 -[newArrayBuffer(2),newSharedArrayBuffer(3)],
 -[
 -newUint8Array(newArrayBuffer(3)).fill(1).buffer,
 -newUint8Array(newSharedArrayBuffer(3)).fill(2).buffer,
 -],
 -];
 +suite('looseEqualArrayPairs',()=>{
 +constlooseEqualArrayPairs=[
 +[newFloat32Array([+0.0]),newFloat32Array([-0.0])],
 +[newFloat64Array([+0.0]),newFloat64Array([-0.0])],
 +];
 -for(constarrayPairofequalArrayPairs){
 -// eslint-disable-next-line no-restricted-properties
 -assert.deepEqual(arrayPair[0],arrayPair[1]);
 -assert.deepStrictEqual(arrayPair[0],arrayPair[1]);
 -}
 +for(constarrayPairoflooseEqualArrayPairs){
 +test('',()=>{
 +// eslint-disable-next-line no-restricted-properties
 +assert.deepEqual(arrayPair[0],arrayPair[1]);
 +assert.throws(
 +makeBlock(assert.deepStrictEqual,arrayPair[0],arrayPair[1]),
 +assert.AssertionError
 +);
 +});
 +}
 +});
 -for(constarrayPairoflooseEqualArrayPairs){
 -// eslint-disable-next-line no-restricted-properties
 -assert.deepEqual(arrayPair[0],arrayPair[1]);
 -assert.throws(
 -makeBlock(assert.deepStrictEqual,arrayPair[0],arrayPair[1]),
 -assert.AssertionError
 -);
 -}
 +suite('notEqualArrayPairs',()=>{
 +constnotEqualArrayPairs=[
 +[newArrayBuffer(3),newSharedArrayBuffer(3)],
 +[newInt16Array(256),newUint16Array(256)],
 +[newInt16Array([256]),newUint16Array([256])],
 +[newFloat64Array([+0.0]),newFloat32Array([-0.0])],
 +[newUint8Array(2),newUint8Array(3)],
 +[newUint8Array([1,2,3]),newUint8Array([4,5,6])],
 +[newUint8ClampedArray([300,2,3]),newUint8Array([300,2,3])],
 +[newUint16Array([2]),newUint16Array([3])],
 +[newUint16Array([0]),newUint16Array([256])],
 +[newInt16Array([0]),newUint16Array([256])],
 +[newInt16Array([-256]),newUint16Array([0xff00])],// same bits
 +[newInt32Array([-256]),newUint32Array([0xffffff00])],// ditto
 +[newFloat32Array([0.1]),newFloat32Array([0.0])],
 +[newFloat32Array([0.1]),newFloat32Array([0.1,0.2])],
 +[newFloat64Array([0.1]),newFloat64Array([0.0])],
 +[newUint8Array([1,2,3]).buffer,newUint8Array([4,5,6]).buffer],
 +[
 +newUint8Array(newSharedArrayBuffer(3)).fill(1).buffer,
 +newUint8Array(newSharedArrayBuffer(3)).fill(2).buffer,
 +],
 +[newArrayBuffer(2),newArrayBuffer(3)],
 +[newSharedArrayBuffer(2),newSharedArrayBuffer(3)],
 +[newArrayBuffer(2),newSharedArrayBuffer(3)],
 +[
 +newUint8Array(newArrayBuffer(3)).fill(1).buffer,
 +newUint8Array(newSharedArrayBuffer(3)).fill(2).buffer,
 +],
 +];
 -for(constarrayPairofnotEqualArrayPairs){
 -assert.throws(
 -// eslint-disable-next-line no-restricted-properties
 -makeBlock(assert.deepEqual,arrayPair[0],arrayPair[1]),
 -assert.AssertionError
 -);
 -assert.throws(
 -makeBlock(assert.deepStrictEqual,arrayPair[0],arrayPair[1]),
 -assert.AssertionError
 -);
 -}
 +for(constarrayPairofnotEqualArrayPairs){
 +test('',()=>{
 +assert.throws(
 +// eslint-disable-next-line no-restricted-properties
 +makeBlock(assert.deepEqual,arrayPair[0],arrayPair[1]),
 +assert.AssertionError
 +);
 +assert.throws(
 +makeBlock(assert.deepStrictEqual,arrayPair[0],arrayPair[1]),
 +assert.AssertionError
 +);
 +});
 +}
 +});