commit: b98b400ab7874bc2ae7eb9dce0e0580fcaeba176
parent 48cb1951146d12eba4652559f3b2db0f752bff09
Author: Haelwenn (lanodan) Monnier <contact@hacktivis.me>
Date:   Sun, 21 Sep 2025 06:44:32 +0200
Create tape context instead of overwriting node:test
Fixes running tape-lite on NodeJS v22.13.1
Diffstat:
| M | index.js | 269 | +++++++++++++++++++++++++++++++++++++++++-------------------------------------- | 
1 file changed, 140 insertions(+), 129 deletions(-)
diff --git a/index.js b/index.js
@@ -3,152 +3,161 @@
 
 'use strict';
 
-const test = require('node:test');
+const test   = require('node:test');
+const assert = require('node:assert/strict');
 
 function notOk(value, msg) { return assert.ok(!value, msg); };
 
+// TODO: Handle message
+function _error(err, msg) { return assert.ifError(err); };
+
 var onFailure = [];
 
-// test([name], [opts], cb)
-module.exports = function(name, opts, cb) {
-	function setup_cb(t)
-	{
-		const assert = require('node:assert/strict');
-
-		// t.plan(n)
-		t.plan = (n) => console.log("t.plan called with:", n);
-
-		// t.end(err)
-		t.end = (err) => console.log("t.end called with:", err);
-
-		// t.teardown(cb) → after([fn][, options])
-		t.teardown = test.after;
-
-		// t.fail(msg)
-		t.fail = assert.fail;
-
-		// t.pass(msg) → context.skip([message])
-		// technically not the same thing but close enough
-		t.pass = t.skip;
-
-		// t.timeoutAfter(ms)
-
-		// t.skip(msg) → context.skip([message])
-
-		// t.ok(value, msg) → assert.ok(value[, message])
-		// Aliases: t.true(), t.assert()
-		t.ok     = assert.ok;
-		t.true   = t.ok;
-		t.assert = t.ok;
-
-		// t.notOk(value, msg) → assert.ok(!value[, message])
-		// Aliases: t.false(), t.notok()
-		t.notOk = notOk;
-		t.false = t.notOk;
-		t.notok = t.notOk;
-
-		// t.error(err, msg) → assert.ifError(value)
-		// Aliases: t.ifError(), t.ifErr(), t.iferror()
-		t.error = (err, msg) => assert.ifError(err);
-		t.ifError             = t.error;
-		t.ifErr               = t.error;
-		t.iferror             = t.error;
-
-		// t.equal(actual, expected, msg) → assert.equal(actual, expected[, message])
-		// Aliases: t.equals(), t.isEqual(), t.strictEqual(), t.strictEquals(), t.is()
-		t.equal        = assert.strictEqual;
-		t.equals       = t.equal;
-		t.isEqual      = t.equal;
-		t.strictEqual  = t.equal;
-		t.strictEquals = t.equal;
-		t.is           = t.equal;
-
-		// t.notEqual(actual, expected, msg) → assert.notStrictEqual(actual, expected[, message])
-		// Aliases: t.notEquals(), t.isNotEqual(), t.doesNotEqual(), t.isInequal(), t.notStrictEqual(), t.notStrictEquals(), t.isNot(), t.not()
-		t.notEqual        = assert.notStrictEqual;
-		t.notEquals       = t.notEqual;
-		t.doesNotEqual    = t.notEqual;
-		t.isInequal       = t.notEqual;
-		t.notStrictEqual  = t.notEqual;
-		t.notStrictEquals = t.notEqual;
-		t.isNot           = t.notEqual;
-		t.not             = t.notEqual;
-
-		// t.looseEqual(actual, expected, msg) → assert.Equal(actual, expected[, message])
-		// Aliases: t.looseEquals()
-		t.looseEqual  = assert.Equal;
-		t.looseEquals = t.looseEqual;
-
-		// t.notLooseEqual(actual, expected, msg) → assert.notEqual(actual, expected[, message])
-		// Aliases: t.notLooseEquals()
-		t.notLooseEqual  = assert.notEqual;
-		t.notLooseEquals = t.notLooseEqual;
-
-		// t.deepEqual(actual, expected, msg) → assert.deepStrictEqual(actual, expected[, message])
-		// Aliases: t.deepEquals(), t.isEquivalent(), t.same()
-		t.deepEqual    = assert.deepStrictEqual;
-		t.deepEquals   = t.deepEqual;
-		t.isEquivalent = t.deepEqual;
-		t.same         = t.deepEqual;
-
-		// t.notDeepEqual(actual, expected, msg) → assert.notDeepStrictEqual(actual, expected[, message])
-		// Aliases: t.notDeepEquals, t.notEquivalent(), t.notDeeply(), t.notSame(), t.isNotDeepEqual(), t.isNotDeeply(), t.isNotEquivalent(), t.isInequivalent()
-		t.notDeepEqual    = assert.notDeepStrictEqual;
-		t.notDeepEquals   = t.notDeepEqual;
-		t.notEquivalent   = t.notDeepEqual;
-		t.notDeeply       = t.notDeepEqual;
-		t.notSame         = t.notDeepEqual;
-		t.isNotDeepEqual  = t.notDeepEqual;
-		t.isNotDeeply     = t.notDeepEqual;
-		t.isNotEquivalent = t.notDeepEqual;
-		t.isInequivalent  = t.notDeepEqual;
-
-		// t.deepLooseEqual(actual, expected, msg) → assert.deepEqual(actual, expected[, message])
-		t.deepLooseEqual = assert.deepEqual;
-
-		// t.notDeepLooseEqual(actual, expected, msg) → assert.notDeepEqual(actual, expected[, message])
-		// Aliases: t.notLooseEqual(), t.notLooseEquals()
-		t.notDeepLooseEqual = assert.notDeepEqual;
-		t.notLooseEqual     = t.notDeepLooseEqual;
-		t.notLooseEquals    = t.notDeepLooseEqual;
-
-		// t.throws(fn, expected, msg) → assert.throws(fn[, error][, message])
-		t.throws = assert.throws;
-
-		// t.doesNotThrow(fn, expected, msg)
-
-		// t.test(name, [opts], cb)
-
-		// t.comment(message)
-		t.comment = (msg) => console.log("t.comment called with:", msg);
-
-		// t.match(string, regexp, message) → assert.match(string, regexp[, message])
-		t.match = assert.match;
-
-		// t.doesNotMatch(string, regexp, message) → assert.doesNotMatch(string, regexp[, message])
-		t.doesNotMatch = assert.doesNotMatch;
-
-		// npm:tap compatibility
-		t.strictSame = t.same;
-	};
+var tape_t = {
+	// t.plan(n)
+	"plan" : (n) => console.log("t.plan called with:", n),
+
+	// t.end(err)
+	"end" : (err) => console.log("t.end called with:", err),
+
+	// t.teardown(cb) → after([fn][, options])
+	"teardown" : test.after,
+
+	// t.fail(msg)
+	"fail" : assert.fail,
+
+	// t.ok(value, msg) → assert.ok(value[, message])
+	// Aliases: t.true(), t.assert()
+	"ok": assert.ok,
+	"true": assert.ok,
+	"assert": assert.ok,
+
+	// t.notOk(value, msg) → assert.ok(!value[, message])
+	// Aliases: t.false(), t.notok()
+	"notOk": notOk,
+	"false": notOk,
+	"notok": notOk,
+
+	// t.error(err, msg) → assert.ifError(value)
+	// Aliases: t.ifError(), t.ifErr(), t.iferror()
+	"error": _error,
+	"ifError": _error,
+	"ifErr": _error,
+	"iferror": _error,
+
+	// t.equal(actual, expected, msg) → assert.equal(actual, expected[, message])
+	// Aliases: t.equals(), t.isEqual(), t.strictEqual(), t.strictEquals(), t.is()
+	"equal": assert.strictEqual,
+	"equals": assert.strictEqual,
+	"isEqual": assert.strictEqual,
+	"strictEqual": assert.strictEqual,
+	"strictEquals": assert.strictEqual,
+	"is": assert.strictEqual,
+
+	// t.notEqual(actual, expected, msg) → assert.notStrictEqual(actual, expected[, message])
+	// Aliases: t.notEquals(), t.isNotEqual(), t.doesNotEqual(), t.isInequal(), t.notStrictEqual(), t.notStrictEquals(), t.isNot(), t.not()
+	"notEqual": assert.notStrictEqual,
+	"notEquals": assert.notStrictEqual,
+	"doesNotEqual": assert.notStrictEqual,
+	"isInequal": assert.notStrictEqual,
+	"notStrictEqual": assert.notStrictEqual,
+	"notStrictEquals": assert.notStrictEqual,
+	"isNot": assert.notStrictEqual,
+	"not": assert.notStrictEqual,
+
+	// t.looseEqual(actual, expected, msg) → assert.Equal(actual, expected[, message])
+	// Aliases: t.looseEquals()
+	looseEqual: assert.Equal,
+	looseEquals: assert.Equal,
+
+	// t.notLooseEqual(actual, expected, msg) → assert.notEqual(actual, expected[, message])
+	// Aliases: t.notLooseEquals()
+	notLooseEqual: assert.notEqual,
+	notLooseEquals: assert.notEqual,
+
+	// t.deepEqual(actual, expected, msg) → assert.deepStrictEqual(actual, expected[, message])
+	// Aliases: t.deepEquals(), t.isEquivalent(), t.same()
+	deepEqual: assert.deepStrictEqual,
+	deepEquals: assert.deepStrictEqual,
+	isEquivalent: assert.deepStrictEqual,
+	same: assert.deepStrictEqual,
+
+	// t.notDeepEqual(actual, expected, msg) → assert.notDeepStrictEqual(actual, expected[, message])
+	// Aliases: t.notDeepEquals, t.notEquivalent(), t.notDeeply(), t.notSame(), t.isNotDeepEqual(), t.isNotDeeply(), t.isNotEquivalent(), t.isInequivalent()
+	notDeepEqual: assert.notDeepStrictEqual,
+	notDeepEquals: assert.notDeepStrictEqual,
+	notEquivalent: assert.notDeepStrictEqual,
+	notDeeply: assert.notDeepStrictEqual,
+	notSame: assert.notDeepStrictEqual,
+	isNotDeepEqual: assert.notDeepStrictEqual,
+	isNotDeeply: assert.notDeepStrictEqual,
+	isNotEquivalent: assert.notDeepStrictEqual,
+	isInequivalent: assert.notDeepStrictEqual,
+
+	// t.deepLooseEqual(actual, expected, msg) → assert.deepEqual(actual, expected[, message])
+	deepLooseEqual: assert.deepEqual,
+
+	// t.notDeepLooseEqual(actual, expected, msg) → assert.notDeepEqual(actual, expected[, message])
+	// Aliases: t.notLooseEqual(), t.notLooseEquals()
+	notDeepLooseEqual: assert.notDeepEqual,
+	notLooseEqual: assert.notDeepEqual,
+	notLooseEquals: assert.notDeepEqual,
+
+	// t.comment(message)
+	comment: (msg) => console.log("t.comment called with:", msg),
+
+	// t.match(string, regexp, message) → assert.match(string, regexp[, message])
+	"match" : assert.match,
+
+	// t.doesNotMatch(string, regexp, message) → assert.doesNotMatch(string, regexp[, message])
+	doesNotMatch: assert.doesNotMatch,
+
+	// npm:tap compatibility
+	strictSame: assert.deepStrictEqual,
+
+	// clang-format off
+	// t.throws(fn, expected, msg) → assert.throws(fn[, error][, message])
+	"throws": assert.throws,
+	// clang-format on
+
+	// t.doesNotThrow(fn, expected, msg)
+};
+
+function setup_context(node_t)
+{
+	var t = tape_t;
+	// t.pass(msg) → context.skip([message])
+	// technically not the same thing but close enough
+	//"pass": t.skip,
+	t.pass = node_t.skip;
+
+	// t.skip(msg) → context.skip([message])
+	t.pass = node_t.skip;
 
+	// t.timeoutAfter(ms)
+
+	return t;
+};
+
+// test([name], [opts], cb)
+tape_t.test = function(name, opts, cb) {
 	switch(arguments.length)
 	{
 	case 1:
-		test((t) => {
-			setup_cb(t);
+		test((node_t) => {
+			var t = setup_context(node_t);
 			arguments[0](t)
 		});
 		break;
 	case 2:
-		test(arguments[0], (t) => {
-			setup_cb(t);
+		test(arguments[0], (node_t) => {
+			var t = setup_context(node_t);
 			arguments[1](t)
 		});
 		break;
 	case 3:
-		test(arguments[0], arguments[1], (t) => {
-			setup_cb(t);
+		test(arguments[0], arguments[1], (node_t) => {
+			var t = setup_context(node_t);
 			arguments[2](t)
 		});
 		break;
@@ -157,6 +166,8 @@ module.exports = function(name, opts, cb) {
 	}
 };
 
+module.exports = tape_t.test;
+
 // test.skip([name], [opts], cb)
 
 // test.onFinish(fn)