Update deps and remove jest

.eslintrc.json

@@ -9,24 +9,6 @@
 	"parserOptions": {
 		"ecmaVersion": 2022
 	},
-	"overrides": [
-		{
-			"files": [
-				"**/*.test.js"
-			],
-			"env": {
-				"jest": true
-			},
-			"plugins": ["jest"],
-			"rules": {
-				"jest/no-disabled-tests": "warn",
-				"jest/no-focused-tests": "error",
-				"jest/no-identical-title": "error",
-				"jest/prefer-to-have-length": "warn",
-				"jest/valid-expect": "error"
-			}
-		}
-	],
 	"env": {
 		"node": true,
 		"es6": true

.github/workflows/eslint.yml

@@ -0,0 +1,36 @@
+name: ESLint
+defaults:
+  run:
+    shell: bash
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  eslint:
+    name: ESLint
+    runs-on: ubuntu-20.04
+
+    steps:
+
+      - name: Fetch Repository
+        uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+
+      - name: Install Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.12.1
+          cache: 'npm'
+
+      - name: Install Modules
+        run: npm ci
+
+      - name: Run ESLint
+        run: npm run eslint

.github/workflows/test.yml

@@ -12,29 +12,6 @@ on:
       - master
 
 jobs:
-  eslint:
-    name: ESLint
-    runs-on: ubuntu-20.04
-
-    steps:
-
-      - name: Fetch Repository
-        uses: actions/checkout@v3
-        with:
-          persist-credentials: false
-
-      - name: Install Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18.12.1
-          cache: 'npm'
-
-      - name: Install Modules
-        run: npm ci
-
-      - name: Run ESLint
-        run: npm run eslint
-
   unit-tests:
     name: Unit Tests
     strategy:

.gitignore

@@ -6,5 +6,4 @@
 .DS_Store
 node_modules/
 test-addon/build/
-doc/jest/
 *.log

conf/jest.json

@@ -1,20 +0,0 @@
-{
-    "rootDir": "../",
-    "moduleFileExtensions": [
-        "js",
-        "node"
-    ],
-    "testMatch": [
-        "<rootDir>/**/*.test.js"
-    ],
-    "coverageDirectory": "doc/jest",
-    "coverageReporters": [
-        "lcov"
-    ],
-    "collectCoverageFrom": [
-        "**/*.js",
-        "!**/*.test.js",
-        "!index.js",
-        "!utils.js"
-    ]
-}

include/index.test.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const tools = require('.');
 
 
@@ -9,30 +12,30 @@ describe('AT / include', () => {
 	stringMethods.forEach((name) => {
 		describe(`#${name}()`, () => {
 			it('is a function', () => {
-				expect(typeof tools[name]).toBe('function');
+				assert.strictEqual(typeof tools[name], 'function');
 			});
 			
 			it('returns an object', () => {
-				expect(typeof tools[name]()).toBe('string');
+				assert.strictEqual(typeof tools[name](), 'string');
 			});
 		});
 	});
 	
 	describe('#getPaths()', () => {
 		it('is a function', () => {
-			expect(typeof tools.getPaths).toBe('function');
+			assert.strictEqual(typeof tools.getPaths, 'function');
 		});
 		
 		it('returns an object', () => {
-			expect(typeof tools.getPaths(__dirname)).toBe('object');
+			assert.strictEqual(typeof tools.getPaths(__dirname), 'object');
 		});
 		
 		it('has "include" string', () => {
-			expect(typeof tools.getPaths(__dirname).include).toBe('string');
+			assert.strictEqual(typeof tools.getPaths(__dirname).include, 'string');
 		});
 		
 		it('has "bin" string', () => {
-			expect(typeof tools.getPaths(__dirname).include).toBe('string');
+			assert.strictEqual(typeof tools.getPaths(__dirname).include, 'string');
 		});
 	});
 });

package.json

@@ -1,7 +1,7 @@
 {
 	"author": "Luis Blanco <luisblanco1337@gmail.com>",
 	"name": "addon-tools-raub",
-	"version": "7.2.1",
+	"version": "7.3.0",
 	"description": "Helpers for Node.js addons and dependency packages",
 	"license": "MIT",
 	"main": "index.js",
@@ -34,9 +34,8 @@
 	},
 	"scripts": {
 		"eslint": "eslint .",
-		"test": "jest --coverage=false --watch --config=conf/jest.json",
+		"test": "node --test --watch",
-		"test-ci": "jest --ci --runInBand --coverage=false --forceExit --detectOpenHandles --config=conf/jest.json",
+		"test-ci": "node --test",
-		"test-coverage": "rm -rf doc/jest && jest --coverage --silent --config=conf/jest.json",
 		"build-test": "cd test-addon && node-gyp rebuild -j max --silent && cd .."
 	},
 	"repository": {
@@ -44,17 +43,15 @@
 		"url": "https://github.com/node-3d/addon-tools-raub.git"
 	},
 	"peerDependencies": {
-		"node-addon-api": "^6.1.0"
+		"node-addon-api": "^7.0.0"
 	},
 	"peerDependenciesMeta": {
 		"node-addon-api": { "optional": true }
 	},
 	"devDependencies": {
-		"eslint-plugin-jest": "^27.2.1",
 		"eslint-plugin-node": "^11.1.0",
-		"eslint": "^8.40.0",
+		"eslint": "^8.51.0",
-		"jest": "^29.5.0",
+		"node-addon-api": "^7.0.0",
-		"node-addon-api": "^6.1.0",
+		"typescript": "^5.2.2"
-		"typescript": "^5.0.4"
 	}
 }

test-addon/hpp-arg-array-str.test.js

@@ -1,42 +1,45 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const arrayArgMsg = 'Argument 0 must be of type `Array`';
+const arrayArgLetMsg = { message: 'Argument 0 must be of type `Array` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / LET_ARRAY_ARG', () => {
+describe('AT / HPP / LET_ARRAY_ARG', () => {
 	it('exports letArrayStrArg', () => {
-		expect(typeof test.letArrayStrArg).toBe('function');
+		assert.strictEqual(typeof test.letArrayStrArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letArrayStrArg('1')).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg('1'), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letArrayStrArg(1)).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg(1), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letArrayStrArg(true)).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg(true), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.letArrayStrArg(test.retExt())).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg(test.retExt()), arrayArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letArrayStrArg({})).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg({}), arrayArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(Array.isArray(test.letArrayStrArg())).toBe(true);
+		assert.ok(Array.isArray(test.letArrayStrArg()));
 	});
 	it('accepts undefined', () => {
-		expect(Array.isArray(test.letArrayStrArg(undefined))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayStrArg(undefined)));
 	});
 	it('accepts null', () => {
-		expect(Array.isArray(test.letArrayStrArg(null))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayStrArg(null)));
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.letArrayStrArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayStrArg([])));
 	});
 	it('returns same array', () => {
-		expect(test.letArrayStrArg(['a', 'b'])).toEqual(['a', 'b']);
+		assert.deepStrictEqual(test.letArrayStrArg(['a', 'b']),['a', 'b']);
 	});
 });

test-addon/hpp-arg-array.test.js

@@ -1,105 +1,109 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const arrayArgMsg = 'Argument 0 must be of type `Array`';
+const arrayArgMsg = { message: 'Argument 0 must be of type `Array`' };
+const arrayArgLetMsg = { message: 'Argument 0 must be of type `Array` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_ARRAY_ARG', () => {
+describe('AT / HPP / REQ_ARRAY_ARG', () => {
 	it('exports reqArrayArg', () => {
-		expect(typeof test.reqArrayArg).toBe('function');
+		assert.strictEqual(typeof test.reqArrayArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqArrayArg()).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(), arrayArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqArrayArg(undefined)).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(undefined), arrayArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqArrayArg(null)).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(null), arrayArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqArrayArg('1')).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg('1'), arrayArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqArrayArg(1)).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(1), arrayArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqArrayArg(true)).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(true), arrayArgMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.reqArrayArg(test.retExt())).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(test.retExt()), arrayArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqArrayArg({})).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg({}), arrayArgMsg);
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.reqArrayArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.reqArrayArg([])));
 	});
 });
 
 describe('addon-tools.hpp: LET_ARRAY_ARG', () => {
 	it('exports letArrayArg', () => {
-		expect(typeof test.letArrayArg).toBe('function');
+		assert.strictEqual(typeof test.letArrayArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letArrayArg('1')).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg('1'), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letArrayArg(1)).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg(1), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letArrayArg(true)).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg(true), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.letArrayArg(test.retExt())).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg(test.retExt()), arrayArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letArrayArg({})).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg({}), arrayArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(Array.isArray(test.letArrayArg())).toBe(true);
+		assert.ok(Array.isArray(test.letArrayArg()));
 	});
 	it('accepts undefined', () => {
-		expect(Array.isArray(test.letArrayArg(undefined))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayArg(undefined)));
 	});
 	it('accepts null', () => {
-		expect(Array.isArray(test.letArrayArg(null))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayArg(null)));
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.letArrayArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayArg([])));
 	});
 });
 
 describe('addon-tools.hpp: USE_ARRAY_ARG', () => {
 	it('exports useArrayArg', () => {
-		expect(typeof test.useArrayArg).toBe('function');
+		assert.strictEqual(typeof test.useArrayArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useArrayArg('1')).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg('1'), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useArrayArg(1)).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg(1), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useArrayArg(true)).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg(true), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.useArrayArg(test.retExt())).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg(test.retExt()), arrayArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useArrayArg({})).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg({}), arrayArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(Array.isArray(test.useArrayArg())).toBe(true);
+		assert.ok(Array.isArray(test.useArrayArg()));
 	});
 	it('accepts undefined', () => {
-		expect(Array.isArray(test.useArrayArg(undefined))).toBe(true);
+		assert.ok(Array.isArray(test.useArrayArg(undefined)));
 	});
 	it('accepts null', () => {
-		expect(Array.isArray(test.useArrayArg(null))).toBe(true);
+		assert.ok(Array.isArray(test.useArrayArg(null)));
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.useArrayArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.useArrayArg([])));
 	});
 });

test-addon/hpp-arg-bool.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const boolArgMsg = 'Argument 0 must be of type `Bool`';
+const boolArgMsg = { message: 'Argument 0 must be of type `Bool`' };
+const boolArgLetMsg = { message: 'Argument 0 must be of type `Bool` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_BOOL_ARG', () => {
+describe('AT / HPP / REQ_BOOL_ARG', () => {
 	it('exports reqBoolArg', () => {
-		expect(typeof test.reqBoolArg).toBe('function');
+		assert.strictEqual(typeof test.reqBoolArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqBoolArg()).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg(), boolArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqBoolArg(undefined)).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg(undefined), boolArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqBoolArg(null)).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg(null), boolArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqBoolArg('1')).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg('1'), boolArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqBoolArg(1)).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg(1), boolArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqBoolArg({})).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg({}), boolArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqBoolArg([])).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg([]), boolArgMsg);
 	});
 	it('accepts a boolean', () => {
-		expect(test.reqBoolArg(true)).toEqual(true);
+		assert.ok(test.reqBoolArg(true));
 	});
 });
 
 describe('addon-tools.hpp: LET_BOOL_ARG', () => {
 	it('exports letBoolArg', () => {
-		expect(typeof test.letBoolArg).toBe('function');
+		assert.strictEqual(typeof test.letBoolArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letBoolArg('1')).toThrow(boolArgMsg);
+		assert.throws(() => test.letBoolArg('1'), boolArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letBoolArg(1)).toThrow(boolArgMsg);
+		assert.throws(() => test.letBoolArg(1), boolArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letBoolArg({})).toThrow(boolArgMsg);
+		assert.throws(() => test.letBoolArg({}), boolArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letBoolArg([])).toThrow(boolArgMsg);
+		assert.throws(() => test.letBoolArg([]), boolArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letBoolArg()).toEqual(false);
+		assert.strictEqual(test.letBoolArg(), false);
 	});
 	it('accepts undefined', () => {
-		expect(test.letBoolArg(undefined)).toEqual(false);
+		assert.strictEqual(test.letBoolArg(undefined), false);
 	});
 	it('accepts null', () => {
-		expect(test.letBoolArg(null)).toEqual(false);
+		assert.strictEqual(test.letBoolArg(null), false);
 	});
 	it('accepts a boolean', () => {
-		expect(test.letBoolArg(true)).toEqual(true);
+		assert.ok(test.letBoolArg(true));
 	});
 });
 
 describe('addon-tools.hpp: USE_BOOL_ARG', () => {
 	it('exports useBoolArg', () => {
-		expect(typeof test.useBoolArg).toBe('function');
+		assert.strictEqual(typeof test.useBoolArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useBoolArg('1')).toThrow(boolArgMsg);
+		assert.throws(() => test.useBoolArg('1'), boolArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useBoolArg(1)).toThrow(boolArgMsg);
+		assert.throws(() => test.useBoolArg(1), boolArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useBoolArg({})).toThrow(boolArgMsg);
+		assert.throws(() => test.useBoolArg({}), boolArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useBoolArg([])).toThrow(boolArgMsg);
+		assert.throws(() => test.useBoolArg([]), boolArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useBoolArg()).toEqual(true);
+		assert.ok(test.useBoolArg());
 	});
 	it('accepts undefined', () => {
-		expect(test.useBoolArg(undefined)).toEqual(true);
+		assert.ok(test.useBoolArg(undefined));
 	});
 	it('accepts null', () => {
-		expect(test.useBoolArg(null)).toEqual(true);
+		assert.ok(test.useBoolArg(null));
 	});
 	it('accepts a boolean', () => {
-		expect(test.useBoolArg(true)).toEqual(true);
+		assert.ok(test.useBoolArg(true));
 	});
 });

test-addon/hpp-arg-double.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const numArgMsg = 'Argument 0 must be of type `Number`';
+const numArgMsg = { message: 'Argument 0 must be of type `Number`' };
+const numArgLetMsg = { message: 'Argument 0 must be of type `Number` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_DOUBLE_ARG', () => {
+describe('AT / HPP / REQ_DOUBLE_ARG', () => {
 	it('exports reqDoubleArg', () => {
-		expect(typeof test.reqDoubleArg).toBe('function');
+		assert.strictEqual(typeof test.reqDoubleArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqDoubleArg()).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg(), numArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqDoubleArg(undefined)).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg(undefined), numArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqDoubleArg(null)).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg(null), numArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqDoubleArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg('1'), numArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqDoubleArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg(true), numArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqDoubleArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg({}), numArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqDoubleArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg([]), numArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqDoubleArg(55)).toEqual(55);
+		assert.strictEqual(test.reqDoubleArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_DOUBLE_ARG', () => {
 	it('exports letDoubleArg', () => {
-		expect(typeof test.letDoubleArg).toBe('function');
+		assert.strictEqual(typeof test.letDoubleArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letDoubleArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.letDoubleArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letDoubleArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.letDoubleArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letDoubleArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.letDoubleArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letDoubleArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.letDoubleArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letDoubleArg()).toEqual(0);
+		assert.strictEqual(test.letDoubleArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letDoubleArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letDoubleArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letDoubleArg(null)).toEqual(0);
+		assert.strictEqual(test.letDoubleArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letDoubleArg(55)).toEqual(55);
+		assert.strictEqual(test.letDoubleArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_DOUBLE_ARG', () => {
 	it('exports useDoubleArg', () => {
-		expect(typeof test.useDoubleArg).toBe('function');
+		assert.strictEqual(typeof test.useDoubleArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useDoubleArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.useDoubleArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useDoubleArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.useDoubleArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useDoubleArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.useDoubleArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useDoubleArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.useDoubleArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useDoubleArg()).toEqual(10);
+		assert.strictEqual(test.useDoubleArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useDoubleArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useDoubleArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useDoubleArg(null)).toEqual(10);
+		assert.strictEqual(test.useDoubleArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useDoubleArg(55)).toEqual(55);
+		assert.strictEqual(test.useDoubleArg(55), 55);
 	});
 });

test-addon/hpp-arg-ext.test.js

@@ -1,105 +1,109 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const extArgMsg = 'Argument 0 must be of type `Pointer`';
+const extArgMsg = { message: 'Argument 0 must be of type `Pointer`' };
+const extArgLetMsg = { message: 'Argument 0 must be of type `Pointer` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_EXT_ARG', () => {
+describe('AT / HPP / REQ_EXT_ARG', () => {
 	it('exports reqExtArg', () => {
-		expect(typeof test.reqExtArg).toBe('function');
+		assert.strictEqual(typeof test.reqExtArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqExtArg()).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(), extArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqExtArg(undefined)).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(undefined), extArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqExtArg(null)).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(null), extArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqExtArg('1')).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg('1'), extArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqExtArg(1)).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(1), extArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqExtArg(true)).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(true), extArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqExtArg({})).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg({}), extArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqExtArg([])).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg([]), extArgMsg);
 	});
 	it('accepts a pointer', () => {
-		expect(typeof test.reqExtArg(test.retExt())).toBe('object');
+		assert.strictEqual(typeof test.reqExtArg(test.retExt()), 'object');
 	});
 });
 
 describe('addon-tools.hpp: LET_EXT_ARG', () => {
 	it('exports letExtArg', () => {
-		expect(typeof test.letExtArg).toBe('function');
+		assert.strictEqual(typeof test.letExtArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letExtArg('1')).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg('1'), extArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letExtArg(1)).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg(1), extArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letExtArg(true)).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg(true), extArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letExtArg({})).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg({}), extArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letExtArg([])).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg([]), extArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(typeof test.letExtArg()).toBe('object');
+		assert.strictEqual(typeof test.letExtArg(), 'object');
 	});
 	it('accepts undefined', () => {
-		expect(typeof test.letExtArg(undefined)).toBe('object');
+		assert.strictEqual(typeof test.letExtArg(undefined), 'object');
 	});
 	it('accepts null', () => {
-		expect(typeof test.letExtArg(null)).toBe('object');
+		assert.strictEqual(typeof test.letExtArg(null), 'object');
 	});
 	it('accepts a pointer', () => {
-		expect(typeof test.reqExtArg(test.retExt())).toBe('object');
+		assert.strictEqual(typeof test.reqExtArg(test.retExt()), 'object');
 	});
 });
 
 describe('addon-tools.hpp: USE_EXT_ARG', () => {
 	it('exports useExtArg', () => {
-		expect(typeof test.useExtArg).toBe('function');
+		assert.strictEqual(typeof test.useExtArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useExtArg('1')).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg('1'), extArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useExtArg(1)).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg(1), extArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useExtArg(true)).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg(true), extArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useExtArg({})).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg({}), extArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useExtArg([])).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg([]), extArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(typeof test.useExtArg()).toBe('object');
+		assert.strictEqual(typeof test.useExtArg(), 'object');
 	});
 	it('accepts undefined', () => {
-		expect(typeof test.useExtArg(undefined)).toBe('object');
+		assert.strictEqual(typeof test.useExtArg(undefined), 'object');
 	});
 	it('accepts null', () => {
-		expect(typeof test.useExtArg(null)).toBe('object');
+		assert.strictEqual(typeof test.useExtArg(null), 'object');
 	});
 	it('accepts a number', () => {
-		expect(typeof test.useExtArg(test.retExt())).toBe('object');
+		assert.strictEqual(typeof test.useExtArg(test.retExt()), 'object');
 	});
 });

test-addon/hpp-arg-float.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const numArgMsg = 'Argument 0 must be of type `Number`';
+const numArgMsg = { message: 'Argument 0 must be of type `Number`' };
+const numArgLetMsg = { message: 'Argument 0 must be of type `Number` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_FLOAT_ARG', () => {
+describe('AT / HPP / REQ_FLOAT_ARG', () => {
 	it('exports reqFloatArg', () => {
-		expect(typeof test.reqFloatArg).toBe('function');
+		assert.strictEqual(typeof test.reqFloatArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqFloatArg()).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg(), numArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqFloatArg(undefined)).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg(undefined), numArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqFloatArg(null)).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg(null), numArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqFloatArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg('1'), numArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqFloatArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg(true), numArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqFloatArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg({}), numArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqFloatArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg([]), numArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqFloatArg(55)).toEqual(55);
+		assert.strictEqual(test.reqFloatArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_FLOAT_ARG', () => {
 	it('exports letFloatArg', () => {
-		expect(typeof test.letFloatArg).toBe('function');
+		assert.strictEqual(typeof test.letFloatArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letFloatArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.letFloatArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letFloatArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.letFloatArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letFloatArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.letFloatArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letFloatArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.letFloatArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letFloatArg()).toEqual(0);
+		assert.strictEqual(test.letFloatArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letFloatArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letFloatArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letFloatArg(null)).toEqual(0);
+		assert.strictEqual(test.letFloatArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letFloatArg(55)).toEqual(55);
+		assert.strictEqual(test.letFloatArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_FLOAT_ARG', () => {
 	it('exports useFloatArg', () => {
-		expect(typeof test.useFloatArg).toBe('function');
+		assert.strictEqual(typeof test.useFloatArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useFloatArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.useFloatArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useFloatArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.useFloatArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useFloatArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.useFloatArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useFloatArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.useFloatArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useFloatArg()).toEqual(10);
+		assert.strictEqual(test.useFloatArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useFloatArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useFloatArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useFloatArg(null)).toEqual(10);
+		assert.strictEqual(test.useFloatArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useFloatArg(55)).toEqual(55);
+		assert.strictEqual(test.useFloatArg(55), 55);
 	});
 });

test-addon/hpp-arg-int.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const intArgMsg = 'Argument 0 must be of type `Int32`';
+const intArgMsg = { message: 'Argument 0 must be of type `Int32`' };
+const intArgLetMsg = { message: 'Argument 0 must be of type `Int32` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_INT_ARG, REQ_INT32_ARG', () => {
+describe('AT / HPP / REQ_INT_ARG, REQ_INT32_ARG', () => {
 	it('exports reqIntArg', () => {
-		expect(typeof test.reqIntArg).toBe('function');
+		assert.strictEqual(typeof test.reqIntArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqIntArg()).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg(), intArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqIntArg(undefined)).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg(undefined), intArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqIntArg(null)).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg(null), intArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqIntArg('1')).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg('1'), intArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqIntArg(true)).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg(true), intArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqIntArg({})).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg({}), intArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqIntArg([])).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg([]), intArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqIntArg(55)).toEqual(55);
+		assert.strictEqual(test.reqIntArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_INT_ARG / LET_INT32_ARG', () => {
 	it('exports letIntArg', () => {
-		expect(typeof test.letIntArg).toBe('function');
+		assert.strictEqual(typeof test.letIntArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letIntArg('1')).toThrow(intArgMsg);
+		assert.throws(() => test.letIntArg('1'), intArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letIntArg(true)).toThrow(intArgMsg);
+		assert.throws(() => test.letIntArg(true), intArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letIntArg({})).toThrow(intArgMsg);
+		assert.throws(() => test.letIntArg({}), intArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letIntArg([])).toThrow(intArgMsg);
+		assert.throws(() => test.letIntArg([]), intArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letIntArg()).toEqual(0);
+		assert.strictEqual(test.letIntArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letIntArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letIntArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letIntArg(null)).toEqual(0);
+		assert.strictEqual(test.letIntArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letIntArg(55)).toEqual(55);
+		assert.strictEqual(test.letIntArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_INT_ARG / USE_INT32_ARG', () => {
 	it('exports useIntArg', () => {
-		expect(typeof test.useIntArg).toBe('function');
+		assert.strictEqual(typeof test.useIntArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useIntArg('1')).toThrow(intArgMsg);
+		assert.throws(() => test.useIntArg('1'), intArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useIntArg(true)).toThrow(intArgMsg);
+		assert.throws(() => test.useIntArg(true), intArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useIntArg({})).toThrow(intArgMsg);
+		assert.throws(() => test.useIntArg({}), intArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useIntArg([])).toThrow(intArgMsg);
+		assert.throws(() => test.useIntArg([]), intArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useIntArg()).toEqual(10);
+		assert.strictEqual(test.useIntArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useIntArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useIntArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useIntArg(null)).toEqual(10);
+		assert.strictEqual(test.useIntArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useIntArg(55)).toEqual(55);
+		assert.strictEqual(test.useIntArg(55), 55);
 	});
 });

test-addon/hpp-arg-obj.test.js

@@ -1,105 +1,109 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const objArgMsg = 'Argument 0 must be of type `Object`';
+const objArgMsg = { message: 'Argument 0 must be of type `Object`' };
+const objArgLetMsg = { message: 'Argument 0 must be of type `Object` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_OBJ_ARG', () => {
+describe('AT / HPP / REQ_OBJ_ARG', () => {
 	it('exports reqObjArg', () => {
-		expect(typeof test.reqObjArg).toBe('function');
+		assert.strictEqual(typeof test.reqObjArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqObjArg()).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(), objArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqObjArg(undefined)).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(undefined), objArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqObjArg(null)).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(null), objArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqObjArg('1')).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg('1'), objArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqObjArg(1)).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(1), objArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqObjArg(true)).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(true), objArgMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.reqObjArg(test.retExt())).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(test.retExt()), objArgMsg);
 	});
 	it('accepts an object', () => {
-		expect(typeof test.reqObjArg({})).toBe('object');
+		assert.strictEqual(typeof test.reqObjArg({}), 'object');
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.reqObjArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.reqObjArg([])));
 	});
 });
 
 describe('addon-tools.hpp: LET_OBJ_ARG', () => {
 	it('exports letObjArg', () => {
-		expect(typeof test.letObjArg).toBe('function');
+		assert.strictEqual(typeof test.letObjArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letObjArg('1')).toThrow(objArgMsg);
+		assert.throws(() => test.letObjArg('1'), objArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letObjArg(1)).toThrow(objArgMsg);
+		assert.throws(() => test.letObjArg(1), objArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letObjArg(true)).toThrow(objArgMsg);
+		assert.throws(() => test.letObjArg(true), objArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.letObjArg(test.retExt())).toThrow(objArgMsg);
+		assert.throws(() => test.letObjArg(test.retExt()), objArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(typeof test.letObjArg()).toBe('object');
+		assert.strictEqual(typeof test.letObjArg(), 'object');
 	});
 	it('accepts undefined', () => {
-		expect(typeof test.letObjArg(undefined)).toBe('object');
+		assert.strictEqual(typeof test.letObjArg(undefined), 'object');
 	});
 	it('accepts null', () => {
-		expect(typeof test.letObjArg(null)).toBe('object');
+		assert.strictEqual(typeof test.letObjArg(null), 'object');
 	});
 	it('accepts an object', () => {
-		expect(typeof test.letObjArg({})).toBe('object');
+		assert.strictEqual(typeof test.letObjArg({}), 'object');
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.letObjArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.letObjArg([])));
 	});
 });
 
 describe('addon-tools.hpp: USE_OBJ_ARG', () => {
 	it('exports useObjArg', () => {
-		expect(typeof test.useObjArg).toBe('function');
+		assert.strictEqual(typeof test.useObjArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useObjArg('1')).toThrow(objArgMsg);
+		assert.throws(() => test.useObjArg('1'), objArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useObjArg(1)).toThrow(objArgMsg);
+		assert.throws(() => test.useObjArg(1), objArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useObjArg(true)).toThrow(objArgMsg);
+		assert.throws(() => test.useObjArg(true), objArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.useObjArg(test.retExt())).toThrow(objArgMsg);
+		assert.throws(() => test.useObjArg(test.retExt()), objArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(typeof test.useObjArg()).toBe('object');
+		assert.strictEqual(typeof test.useObjArg(), 'object');
 	});
 	it('accepts undefined', () => {
-		expect(typeof test.useObjArg(undefined)).toBe('object');
+		assert.strictEqual(typeof test.useObjArg(undefined), 'object');
 	});
 	it('accepts null', () => {
-		expect(typeof test.useObjArg(null)).toBe('object');
+		assert.strictEqual(typeof test.useObjArg(null), 'object');
 	});
 	it('accepts an object', () => {
-		expect(typeof test.useObjArg({})).toBe('object');
+		assert.strictEqual(typeof test.useObjArg({}), 'object');
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.useObjArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.useObjArg([])));
 	});
 });

test-addon/hpp-arg-offs.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const numArgMsg = 'Argument 0 must be of type `Number`';
+const numArgMsg = { message: 'Argument 0 must be of type `Number`' };
+const numArgLetMsg = { message: 'Argument 0 must be of type `Number` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_OFFS_ARG', () => {
+describe('AT / HPP / REQ_OFFS_ARG', () => {
 	it('exports reqOffsArg', () => {
-		expect(typeof test.reqOffsArg).toBe('function');
+		assert.strictEqual(typeof test.reqOffsArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqOffsArg()).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg(), numArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqOffsArg(undefined)).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg(undefined), numArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqOffsArg(null)).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg(null), numArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqOffsArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg('1'), numArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqOffsArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg(true), numArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqOffsArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg({}), numArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqOffsArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg([]), numArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqOffsArg(55)).toEqual(55);
+		assert.strictEqual(test.reqOffsArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_OFFS_ARG', () => {
 	it('exports letOffsArg', () => {
-		expect(typeof test.letOffsArg).toBe('function');
+		assert.strictEqual(typeof test.letOffsArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letOffsArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.letOffsArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letOffsArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.letOffsArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letOffsArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.letOffsArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letOffsArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.letOffsArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letOffsArg()).toEqual(0);
+		assert.strictEqual(test.letOffsArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letOffsArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letOffsArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letOffsArg(null)).toEqual(0);
+		assert.strictEqual(test.letOffsArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letOffsArg(55)).toEqual(55);
+		assert.strictEqual(test.letOffsArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_OFFS_ARG', () => {
 	it('exports useOffsArg', () => {
-		expect(typeof test.useOffsArg).toBe('function');
+		assert.strictEqual(typeof test.useOffsArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useOffsArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.useOffsArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useOffsArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.useOffsArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useOffsArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.useOffsArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useOffsArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.useOffsArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useOffsArg()).toEqual(10);
+		assert.strictEqual(test.useOffsArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useOffsArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useOffsArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useOffsArg(null)).toEqual(10);
+		assert.strictEqual(test.useOffsArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useOffsArg(55)).toEqual(55);
+		assert.strictEqual(test.useOffsArg(55), 55);
 	});
 });

test-addon/hpp-arg-str.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const strArgMsg = 'Argument 0 must be of type `String`';
+const strArgMsg = { message: 'Argument 0 must be of type `String`' };
+const strArgLetMsg = { message: 'Argument 0 must be of type `String` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_STR_ARG', () => {
+describe('AT / HPP / REQ_STR_ARG', () => {
 	it('exports reqStrArg', () => {
-		expect(typeof test.reqStrArg).toBe('function');
+		assert.strictEqual(typeof test.reqStrArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqStrArg()).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(), strArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqStrArg(undefined)).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(undefined), strArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqStrArg(null)).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(null), strArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqStrArg(1)).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(1), strArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqStrArg(true)).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(true), strArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqStrArg({})).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg({}), strArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqStrArg([])).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg([]), strArgMsg);
 	});
 	it('accepts a string', () => {
-		expect(test.reqStrArg('1abc')).toEqual('1abc');
+		assert.strictEqual(test.reqStrArg('1abc'), '1abc');
 	});
 });
 
 describe('addon-tools.hpp: LET_STR_ARG', () => {
 	it('exports letStrArg', () => {
-		expect(typeof test.letStrArg).toBe('function');
+		assert.strictEqual(typeof test.letStrArg, 'function');
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letStrArg(1)).toThrow(strArgMsg);
+		assert.throws(() => test.letStrArg(1), strArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letStrArg(true)).toThrow(strArgMsg);
+		assert.throws(() => test.letStrArg(true), strArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letStrArg({})).toThrow(strArgMsg);
+		assert.throws(() => test.letStrArg({}), strArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letStrArg([])).toThrow(strArgMsg);
+		assert.throws(() => test.letStrArg([]), strArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letStrArg()).toEqual('');
+		assert.strictEqual(test.letStrArg(), '');
 	});
 	it('accepts undefined', () => {
-		expect(test.letStrArg(undefined)).toEqual('');
+		assert.strictEqual(test.letStrArg(undefined), '');
 	});
 	it('accepts null', () => {
-		expect(test.letStrArg(null)).toEqual('');
+		assert.strictEqual(test.letStrArg(null), '');
 	});
 	it('accepts a string', () => {
-		expect(test.letStrArg('1abc')).toEqual('1abc');
+		assert.strictEqual(test.letStrArg('1abc'), '1abc');
 	});
 });
 
 describe('addon-tools.hpp: USE_STR_ARG', () => {
 	it('exports useStrArg', () => {
-		expect(typeof test.useStrArg).toBe('function');
+		assert.strictEqual(typeof test.useStrArg, 'function');
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useStrArg(1)).toThrow(strArgMsg);
+		assert.throws(() => test.useStrArg(1), strArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useStrArg(true)).toThrow(strArgMsg);
+		assert.throws(() => test.useStrArg(true), strArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useStrArg({})).toThrow(strArgMsg);
+		assert.throws(() => test.useStrArg({}), strArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useStrArg([])).toThrow(strArgMsg);
+		assert.throws(() => test.useStrArg([]), strArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useStrArg()).toEqual('default');
+		assert.strictEqual(test.useStrArg(), 'default');
 	});
 	it('accepts undefined', () => {
-		expect(test.useStrArg(undefined)).toEqual('default');
+		assert.strictEqual(test.useStrArg(undefined), 'default');
 	});
 	it('accepts null', () => {
-		expect(test.useStrArg(null)).toEqual('default');
+		assert.strictEqual(test.useStrArg(null), 'default');
 	});
 	it('accepts a string', () => {
-		expect(test.useStrArg('1abc')).toEqual('1abc');
+		assert.strictEqual(test.useStrArg('1abc'), '1abc');
 	});
 });

test-addon/hpp-arg-uint.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const uintArgMsg = 'Argument 0 must be of type `Uint32`';
+const uintArgMsg = { message: 'Argument 0 must be of type `Uint32`' };
+const uintArgLetMsg = { message: 'Argument 0 must be of type `Uint32` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_UINT_ARG, REQ_UINT32_ARG', () => {
+describe('AT / HPP / REQ_UINT_ARG, REQ_UINT32_ARG', () => {
 	it('exports reqUintArg', () => {
-		expect(typeof test.reqUintArg).toBe('function');
+		assert.strictEqual(typeof test.reqUintArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqUintArg()).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg(), uintArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqUintArg(undefined)).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg(undefined), uintArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqUintArg(null)).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg(null), uintArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqUintArg('1')).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg('1'), uintArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqUintArg(true)).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg(true), uintArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqUintArg({})).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg({}), uintArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqUintArg([])).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg([]), uintArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqUintArg(55)).toEqual(55);
+		assert.strictEqual(test.reqUintArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_UINT_ARG / LET_UINT32_ARG', () => {
 	it('exports letUintArg', () => {
-		expect(typeof test.letUintArg).toBe('function');
+		assert.strictEqual(typeof test.letUintArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letUintArg('1')).toThrow(uintArgMsg);
+		assert.throws(() => test.letUintArg('1'), uintArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letUintArg(true)).toThrow(uintArgMsg);
+		assert.throws(() => test.letUintArg(true), uintArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letUintArg({})).toThrow(uintArgMsg);
+		assert.throws(() => test.letUintArg({}), uintArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letUintArg([])).toThrow(uintArgMsg);
+		assert.throws(() => test.letUintArg([]), uintArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letUintArg()).toEqual(0);
+		assert.strictEqual(test.letUintArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letUintArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letUintArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letUintArg(null)).toEqual(0);
+		assert.strictEqual(test.letUintArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letUintArg(55)).toEqual(55);
+		assert.strictEqual(test.letUintArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_UINT_ARG / USE_UINT32_ARG', () => {
 	it('exports useUintArg', () => {
-		expect(typeof test.useUintArg).toBe('function');
+		assert.strictEqual(typeof test.useUintArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useUintArg('1')).toThrow(uintArgMsg);
+		assert.throws(() => test.useUintArg('1'), uintArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useUintArg(true)).toThrow(uintArgMsg);
+		assert.throws(() => test.useUintArg(true), uintArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useUintArg({})).toThrow(uintArgMsg);
+		assert.throws(() => test.useUintArg({}), uintArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useUintArg([])).toThrow(uintArgMsg);
+		assert.throws(() => test.useUintArg([]), uintArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useUintArg()).toEqual(10);
+		assert.strictEqual(test.useUintArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useUintArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useUintArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useUintArg(null)).toEqual(10);
+		assert.strictEqual(test.useUintArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useUintArg(55)).toEqual(55);
+		assert.strictEqual(test.useUintArg(55), 55);
 	});
 });

test-addon/hpp-arg.test.js

@@ -1,205 +1,211 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-describe('AT / addon-tools.hpp / Function arguments', () => {
+describe('AT / HPP / Function arguments', () => {
+	
+	const arg3Msg = { message: 'Expected at least 3 arguments' };
+	
 	describe('REQ_ARGS', () => {
 		it('exports reqArgs3', () => {
-			expect(typeof test.reqArgs3).toBe('function');
+			assert.strictEqual(typeof test.reqArgs3, 'function');
 		});
 		it('throws if no args passed', () => {
-			expect(() => test.reqArgs3()).toThrow('Expected at least 3 arguments');
+			assert.throws(() => test.reqArgs3(), arg3Msg);
 		});
 		it('throws if 1 arg passed', () => {
-			expect(() => test.reqArgs3(1)).toThrow('Expected at least 3 arguments');
+			assert.throws(() => test.reqArgs3(1), arg3Msg);
 		});
 		it('returns true if 3 args passed', () => {
-			expect(test.reqArgs3(1, 2, 3)).toEqual(true);
+			assert.ok(test.reqArgs3(1, 2, 3));
 		});
 		it('returns true if 5 args passed', () => {
-			expect(test.reqArgs3(1, 2, 3, 4, 5)).toEqual(true);
+			assert.ok(test.reqArgs3(1, 2, 3, 4, 5));
 		});
 	});
 	
 	describe('IS_ARG_EMPTY', () => {
 		it('exports isArg0Empty', () => {
-			expect(typeof test.isArg0Empty).toBe('function');
+			assert.strictEqual(typeof test.isArg0Empty, 'function');
 		});
 		it('returns true for absent arg', () => {
-			expect(test.isArg0Empty()).toEqual(true);
+			assert.ok(test.isArg0Empty());
 		});
 		it('returns true for undefined arg', () => {
-			expect(test.isArg0Empty(undefined)).toEqual(true);
+			assert.ok(test.isArg0Empty(undefined));
 		});
 		it('returns true for null arg', () => {
-			expect(test.isArg0Empty(null)).toEqual(true);
+			assert.ok(test.isArg0Empty(null));
 		});
 		it('returns false for non-empty value', () => {
-			expect(test.isArg0Empty(1)).toEqual(false);
+			assert.strictEqual(test.isArg0Empty(1), false);
 		});
 	});
 	
 	// ------------------------------ FUN_ARG
 	
-	const funArgMsg = 'Argument 0 must be of type `Function`';
+	const funArgMsg = { message: 'Argument 0 must be of type `Function`' };
 	
 	describe('REQ_FUN_ARG', () => {
 		it('exports reqFunArg', () => {
-			expect(typeof test.reqFunArg).toBe('function');
+			assert.strictEqual(typeof test.reqFunArg, 'function');
 		});
 		it('throws if arg was not passed', () => {
-			expect(() => test.reqFunArg()).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(), funArgMsg);
 		});
 		it('throws if arg was passed undefined', () => {
-			expect(() => test.reqFunArg(undefined)).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(undefined), funArgMsg);
 		});
 		it('throws if arg was passed null', () => {
-			expect(() => test.reqFunArg(null)).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(null), funArgMsg);
 		});
 		it('throws if arg was passed a string', () => {
-			expect(() => test.reqFunArg('1')).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg('1'), funArgMsg);
 		});
 		it('throws if arg was passed a number', () => {
-			expect(() => test.reqFunArg(1)).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(1), funArgMsg);
 		});
 		it('throws if arg was passed a boolean', () => {
-			expect(() => test.reqFunArg(true)).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(true), funArgMsg);
 		});
 		it('throws if arg was passed a pointer', () => {
-			expect(() => test.reqFunArg(test.retExt())).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(test.retExt()), funArgMsg);
 		});
 		it('throws if arg was passed an object', () => {
-			expect(() => test.reqFunArg({})).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg({}), funArgMsg);
 		});
 		it('throws if arg was passed an array', () => {
-			expect(() => test.reqFunArg([])).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg([]), funArgMsg);
 		});
 		it('accepts a function', () => {
-			expect(typeof test.reqFunArg(() => {})).toBe('function');
+			assert.strictEqual(typeof test.reqFunArg(() => {}), 'function');
 		});
 	});
 	
 	// ------------------------------ ARRV_ARG
 	
-	const arrvArgMsg = 'Argument 0 must be of type `ArrayBuffer`';
+	const arrvArgMsg = { message: 'Argument 0 must be of type `ArrayBuffer`' };
 	
 	describe('REQ_ARRV_ARG', () => {
 		it('exports reqArrvArg', () => {
-			expect(typeof test.reqArrvArg).toBe('function');
+			assert.strictEqual(typeof test.reqArrvArg, 'function');
 		});
 		it('throws if arg was not passed', () => {
-			expect(() => test.reqArrvArg()).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(), arrvArgMsg);
 		});
 		it('throws if arg was passed undefined', () => {
-			expect(() => test.reqArrvArg(undefined)).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(undefined), arrvArgMsg);
 		});
 		it('throws if arg was passed null', () => {
-			expect(() => test.reqArrvArg(null)).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(null), arrvArgMsg);
 		});
 		it('throws if arg was passed a string', () => {
-			expect(() => test.reqArrvArg('1')).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg('1'), arrvArgMsg);
 		});
 		it('throws if arg was passed a number', () => {
-			expect(() => test.reqArrvArg(1)).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(1), arrvArgMsg);
 		});
 		it('throws if arg was passed a boolean', () => {
-			expect(() => test.reqArrvArg(true)).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(true), arrvArgMsg);
 		});
 		it('throws if arg was passed a pointer', () => {
-			expect(() => test.reqArrvArg(test.retExt())).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(test.retExt()), arrvArgMsg);
 		});
 		it('throws if arg was passed an object', () => {
-			expect(() => test.reqArrvArg({})).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg({}), arrvArgMsg);
 		});
 		it('throws if arg was passed an array', () => {
-			expect(() => test.reqArrvArg([])).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg([]), arrvArgMsg);
 		});
 		it('accepts an array buffer', () => {
 			const { buffer } = new Uint8Array([1, 2, 3]);
-			expect(test.reqArrvArg(buffer)).toEqual(buffer);
+			assert.strictEqual(test.reqArrvArg(buffer), buffer);
 		});
 	});
 	
 	// ------------------------------ BUF_ARG
 	
-	const bufArgMsg = 'Argument 0 must be of type `Buffer`';
+	const bufArgMsg = { message: 'Argument 0 must be of type `Buffer`' };
 	
 	describe('REQ_BUF_ARG', () => {
 		it('exports reqBufArg', () => {
-			expect(typeof test.reqBufArg).toBe('function');
+			assert.strictEqual(typeof test.reqBufArg, 'function');
 		});
 		it('throws if arg was not passed', () => {
-			expect(() => test.reqBufArg()).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(), bufArgMsg);
 		});
 		it('throws if arg was passed undefined', () => {
-			expect(() => test.reqBufArg(undefined)).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(undefined), bufArgMsg);
 		});
 		it('throws if arg was passed null', () => {
-			expect(() => test.reqBufArg(null)).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(null), bufArgMsg);
 		});
 		it('throws if arg was passed a string', () => {
-			expect(() => test.reqBufArg('1')).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg('1'), bufArgMsg);
 		});
 		it('throws if arg was passed a number', () => {
-			expect(() => test.reqBufArg(1)).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(1), bufArgMsg);
 		});
 		it('throws if arg was passed a boolean', () => {
-			expect(() => test.reqBufArg(true)).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(true), bufArgMsg);
 		});
 		it('throws if arg was passed a pointer', () => {
-			expect(() => test.reqBufArg(test.retExt())).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(test.retExt()), bufArgMsg);
 		});
 		it('throws if arg was passed an object', () => {
-			expect(() => test.reqBufArg({})).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg({}), bufArgMsg);
 		});
 		it('throws if arg was passed an array', () => {
-			expect(() => test.reqBufArg([])).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg([]), bufArgMsg);
 		});
 		it('accepts a buffer', () => {
 			const buffer = Buffer.from([1, 2, 3]);
-			expect(test.reqBufArg(buffer)).toEqual(buffer);
+			assert.strictEqual(test.reqBufArg(buffer), buffer);
 		});
 	});
 	
 	// ------------------------------ TYPED_ARRAY_ARG
 	
-	const typedArgMsg = 'Argument 0 must be of type `TypedArray`';
+	const typedArgMsg = { message: 'Argument 0 must be of type `TypedArray`' };
 	
 	describe('REQ_TYPED_ARRAY_ARG', () => {
 		it('exports reqTypedArg', () => {
-			expect(typeof test.reqTypedArg).toBe('function');
+			assert.strictEqual(typeof test.reqTypedArg, 'function');
 		});
 		it('throws if arg was not passed', () => {
-			expect(() => test.reqTypedArg()).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(), typedArgMsg);
 		});
 		it('throws if arg was passed undefined', () => {
-			expect(() => test.reqTypedArg(undefined)).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(undefined), typedArgMsg);
 		});
 		it('throws if arg was passed null', () => {
-			expect(() => test.reqTypedArg(null)).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(null), typedArgMsg);
 		});
 		it('throws if arg was passed a string', () => {
-			expect(() => test.reqTypedArg('1')).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg('1'), typedArgMsg);
 		});
 		it('throws if arg was passed a number', () => {
-			expect(() => test.reqTypedArg(1)).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(1), typedArgMsg);
 		});
 		it('throws if arg was passed a boolean', () => {
-			expect(() => test.reqTypedArg(true)).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(true), typedArgMsg);
 		});
 		it('throws if arg was passed a pointer', () => {
-			expect(() => test.reqTypedArg(test.retExt())).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(test.retExt()), typedArgMsg);
 		});
 		it('throws if arg was passed an object', () => {
-			expect(() => test.reqTypedArg({})).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg({}), typedArgMsg);
 		});
 		it('throws if arg was passed an array', () => {
-			expect(() => test.reqTypedArg([])).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg([]), typedArgMsg);
 		});
 		it('accepts a typed array', () => {
 			const typed = new Uint8Array([1, 2, 3]);
-			expect(test.reqTypedArg(typed)).toEqual(typed);
+			assert.strictEqual(test.reqTypedArg(typed), typed);
 		});
 	});
 });

utils/utils.test.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const utils = require('.');
 
 
@@ -13,7 +16,7 @@ describe('AT / utils', () => {
 	
 	methods.forEach((name) => {
 		it(`exports the "${name}" function`, () => {
-			expect(typeof utils[name]).toBe('function');
+			assert.strictEqual(typeof utils[name], 'function');
 		});
 	});
 });