fast-json-stringify 6.0.0 → 6.1.0

package/test/anyof.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
 process.env.TZ = 'UTC'
@@ -23,11 +23,11 @@ test('object with multiple types field', (t) => {
   }
   const stringify = build(schema)
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     str: 'string'
   }), '{"str":"string"}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     str: true
   }), '{"str":true}')
 })
@@ -55,11 +55,11 @@ test('object with field of type object or null', (t) => {
   }
   const stringify = build(schema)
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     prop: null
   }), '{"prop":null}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     prop: {
       str: 'string'
     }
@@ -89,13 +89,13 @@ test('object with field of type object or array', (t) => {
   }
   const stringify = build(schema)
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     prop: {
       str: 'string'
     }
   }), '{"prop":{"str":"string"}}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     prop: ['string']
   }), '{"prop":["string"]}')
 })
@@ -115,7 +115,7 @@ test('object with field of type string and coercion disable ', (t) => {
     }
   }
   const stringify = build(schema)
-  t.throws(() => stringify({ str: 1 }))
+  t.assert.throws(() => stringify({ str: 1 }))
 })
 
 test('object with field of type string and coercion enable ', (t) => {
@@ -143,7 +143,7 @@ test('object with field of type string and coercion enable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.equal(value, '{"str":"1"}')
+  t.assert.equal(value, '{"str":"1"}')
 })
 
 test('object with field with type union of multiple objects', (t) => {
@@ -177,9 +177,9 @@ test('object with field with type union of multiple objects', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ anyOfSchema: { baz: 5 } }), '{"anyOfSchema":{"baz":5}}')
+  t.assert.equal(stringify({ anyOfSchema: { baz: 5 } }), '{"anyOfSchema":{"baz":5}}')
 
-  t.equal(stringify({ anyOfSchema: { bar: 'foo' } }), '{"anyOfSchema":{"bar":"foo"}}')
+  t.assert.equal(stringify({ anyOfSchema: { bar: 'foo' } }), '{"anyOfSchema":{"bar":"foo"}}')
 })
 
 test('null value in schema', (t) => {
@@ -219,10 +219,10 @@ test('symbol value in schema', (t) => {
   }
 
   const stringify = build(schema)
-  t.equal(stringify({ value: 'foo' }), '{"value":"foo"}')
-  t.equal(stringify({ value: 'bar' }), '{"value":"bar"}')
-  t.equal(stringify({ value: 'baz' }), '{"value":"baz"}')
-  t.throws(() => stringify({ value: 'qux' }))
+  t.assert.equal(stringify({ value: 'foo' }), '{"value":"foo"}')
+  t.assert.equal(stringify({ value: 'bar' }), '{"value":"bar"}')
+  t.assert.equal(stringify({ value: 'baz' }), '{"value":"baz"}')
+  t.assert.throws(() => stringify({ value: 'qux' }))
 })
 
 test('anyOf and $ref together', (t) => {
@@ -251,9 +251,9 @@ test('anyOf and $ref together', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}')
+  t.assert.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}')
 
-  t.equal(stringify({ cs: true }), '{"cs":true}')
+  t.assert.equal(stringify({ cs: true }), '{"cs":true}')
 })
 
 test('anyOf and $ref: 2 levels are fine', (t) => {
@@ -289,7 +289,7 @@ test('anyOf and $ref: 2 levels are fine', (t) => {
 
   const stringify = build(schema)
   const value = stringify({ cs: 3 })
-  t.equal(value, '{"cs":3}')
+  t.assert.equal(value, '{"cs":3}')
 })
 
 test('anyOf and $ref: multiple levels should throw at build.', (t) => {
@@ -328,9 +328,9 @@ test('anyOf and $ref: multiple levels should throw at build.', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ cs: 3 }), '{"cs":3}')
-  t.equal(stringify({ cs: true }), '{"cs":true}')
-  t.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
+  t.assert.equal(stringify({ cs: 3 }), '{"cs":3}')
+  t.assert.equal(stringify({ cs: true }), '{"cs":true}')
+  t.assert.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
 })
 
 test('anyOf and $ref - multiple external $ref', (t) => {
@@ -383,10 +383,8 @@ test('anyOf and $ref - multiple external $ref', (t) => {
   const stringify = build(schema, { schema: externalSchema })
   const output = stringify(object)
 
-  JSON.parse(output)
-  t.pass()
-
-  t.equal(output, '{"obj":{"prop":{"prop2":"test"}}}')
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"obj":{"prop":{"prop2":"test"}}}')
 })
 
 test('anyOf looks for all of the array items', (t) => {
@@ -421,7 +419,7 @@ test('anyOf looks for all of the array items', (t) => {
   const stringify = build(schema)
 
   const value = stringify([{ savedId: 'great' }, { error: 'oops' }])
-  t.equal(value, '[{"savedId":"great"},{"error":"oops"}]')
+  t.assert.equal(value, '[{"savedId":"great"},{"error":"oops"}]')
 })
 
 test('anyOf with enum with more than 100 entries', (t) => {
@@ -443,7 +441,7 @@ test('anyOf with enum with more than 100 entries', (t) => {
   const stringify = build(schema)
 
   const value = stringify(['EUR', 'USD', null])
-  t.equal(value, '["EUR","USD",null]')
+  t.assert.equal(value, '["EUR","USD",null]')
 })
 
 test('anyOf object with field date-time of type string with format or null', (t) => {
@@ -465,7 +463,7 @@ test('anyOf object with field date-time of type string with format or null', (t)
 
   const withOneOfStringify = build(withOneOfSchema)
 
-  t.equal(withOneOfStringify({
+  t.assert.equal(withOneOfStringify({
     prop: toStringify
   }), `{"prop":"${toStringify.toISOString()}"}`)
 })
@@ -495,7 +493,7 @@ test('anyOf object with nested field date-time of type string with format or nul
     prop: { nestedProp: new Date() }
   }
 
-  t.equal(withOneOfStringify(data), JSON.stringify(data))
+  t.assert.equal(withOneOfStringify(data), JSON.stringify(data))
 })
 
 test('anyOf object with nested field date of type string with format or null', (t) => {
@@ -523,7 +521,7 @@ test('anyOf object with nested field date of type string with format or null', (
     prop: { nestedProp: new Date(1674263005800) }
   }
 
-  t.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"2023-01-21"}}')
+  t.assert.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"2023-01-21"}}')
 })
 
 test('anyOf object with nested field time of type string with format or null', (t) => {
@@ -550,7 +548,7 @@ test('anyOf object with nested field time of type string with format or null', (
   const data = {
     prop: { nestedProp: new Date(1674263005800) }
   }
-  t.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"01:03:25"}}')
+  t.assert.equal(withOneOfStringify(data), '{"prop":{"nestedProp":"01:03:25"}}')
 })
 
 test('anyOf object with field date of type string with format or null', (t) => {
@@ -571,7 +569,7 @@ test('anyOf object with field date of type string with format or null', (t) => {
   }
 
   const withOneOfStringify = build(withOneOfSchema)
-  t.equal(withOneOfStringify({
+  t.assert.equal(withOneOfStringify({
     prop: toStringify
   }), '{"prop":"2011-01-01"}')
 })
@@ -594,7 +592,7 @@ test('anyOf object with invalid field date of type string with format or null',
   }
 
   const withOneOfStringify = build(withOneOfSchema)
-  t.throws(() => withOneOfStringify({ prop: toStringify }))
+  t.assert.throws(() => withOneOfStringify({ prop: toStringify }))
 })
 
 test('anyOf with a nested external schema', (t) => {
@@ -614,7 +612,7 @@ test('anyOf with a nested external schema', (t) => {
   const schema = { anyOf: [{ $ref: 'external' }] }
 
   const stringify = build(schema, { schema: externalSchemas })
-  t.equal(stringify('foo'), '"foo"')
+  t.assert.equal(stringify('foo'), '"foo"')
 })
 
 test('object with ref and validated properties', (t) => {
@@ -642,7 +640,7 @@ test('object with ref and validated properties', (t) => {
   }
 
   const stringify = build(schema, { schema: externalSchemas })
-  t.equal(stringify({ id: 1, reference: 'hi' }), '{"id":1,"reference":"hi"}')
+  t.assert.equal(stringify({ id: 1, reference: 'hi' }), '{"id":1,"reference":"hi"}')
 })
 
 test('anyOf required props', (t) => {
@@ -659,9 +657,9 @@ test('anyOf required props', (t) => {
     anyOf: [{ required: ['prop2'] }, { required: ['prop3'] }]
   }
   const stringify = build(schema)
-  t.equal(stringify({ prop1: 'test', prop2: 'test2' }), '{"prop1":"test","prop2":"test2"}')
-  t.equal(stringify({ prop1: 'test', prop3: 'test3' }), '{"prop1":"test","prop3":"test3"}')
-  t.equal(stringify({ prop1: 'test', prop2: 'test2', prop3: 'test3' }), '{"prop1":"test","prop2":"test2","prop3":"test3"}')
+  t.assert.equal(stringify({ prop1: 'test', prop2: 'test2' }), '{"prop1":"test","prop2":"test2"}')
+  t.assert.equal(stringify({ prop1: 'test', prop3: 'test3' }), '{"prop1":"test","prop3":"test3"}')
+  t.assert.equal(stringify({ prop1: 'test', prop2: 'test2', prop3: 'test3' }), '{"prop1":"test","prop2":"test2","prop3":"test3"}')
 })
 
 test('anyOf required props', (t) => {
@@ -686,9 +684,9 @@ test('anyOf required props', (t) => {
     ]
   }
   const stringify = build(schema)
-  t.equal(stringify({ prop1: 'test1' }), '{"prop1":"test1"}')
-  t.equal(stringify({ prop2: 'test2' }), '{"prop2":"test2"}')
-  t.equal(stringify({ prop1: 'test1', prop2: 'test2' }), '{"prop1":"test1","prop2":"test2"}')
+  t.assert.equal(stringify({ prop1: 'test1' }), '{"prop1":"test1"}')
+  t.assert.equal(stringify({ prop2: 'test2' }), '{"prop2":"test2"}')
+  t.assert.equal(stringify({ prop1: 'test1', prop2: 'test2' }), '{"prop1":"test1","prop2":"test2"}')
 })
 
 test('recursive nested anyOfs', (t) => {
@@ -706,7 +704,7 @@ test('recursive nested anyOfs', (t) => {
 
   const data = { foo: {} }
   const stringify = build(schema)
-  t.equal(stringify(data), JSON.stringify(data))
+  t.assert.equal(stringify(data), JSON.stringify(data))
 })
 
 test('recursive nested anyOfs', (t) => {
@@ -724,7 +722,7 @@ test('recursive nested anyOfs', (t) => {
 
   const data = { foo: {} }
   const stringify = build(schema)
-  t.equal(stringify(data), JSON.stringify(data))
+  t.assert.equal(stringify(data), JSON.stringify(data))
 })
 
 test('external recursive anyOfs', (t) => {
@@ -763,7 +761,7 @@ test('external recursive anyOfs', (t) => {
     }
   }
   const stringify = build(schema, { schema: { externalSchema } })
-  t.equal(stringify(data), '{"a":{"bar":"42","foo":{}},"b":{"bar":"42","foo":{}}}')
+  t.assert.equal(stringify(data), '{"a":{"bar":"42","foo":{}},"b":{"bar":"42","foo":{}}}')
 })
 
 test('should build merged schemas twice', (t) => {
@@ -784,11 +782,11 @@ test('should build merged schemas twice', (t) => {
 
   {
     const stringify = build(schema)
-    t.equal(stringify({ enums: 'FOO' }), '{"enums":"FOO"}')
+    t.assert.equal(stringify({ enums: 'FOO' }), '{"enums":"FOO"}')
   }
 
   {
     const stringify = build(schema)
-    t.equal(stringify({ enums: 'BAR' }), '{"enums":"BAR"}')
+    t.assert.equal(stringify({ enums: 'BAR' }), '{"enums":"BAR"}')
   }
 })

package/test/array.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const validator = require('is-my-json-valid')
 const build = require('..')
 const Ajv = require('ajv')
@@ -8,7 +8,7 @@ const Ajv = require('ajv')
 test('error on invalid largeArrayMechanism', (t) => {
   t.plan(1)
 
-  t.throws(() => build({
+  t.assert.throws(() => build({
     title: 'large array of null values with default mechanism',
     type: 'object',
     properties: {
@@ -31,9 +31,9 @@ function buildTest (schema, toStringify, options) {
     const stringify = build(schema, options)
     const output = stringify(toStringify)
 
-    t.same(JSON.parse(output), JSON.parse(JSON.stringify(toStringify)))
-    t.equal(output, JSON.stringify(toStringify))
-    t.ok(validate(JSON.parse(output)), 'valid schema')
+    t.assert.deepStrictEqual(JSON.parse(output), JSON.parse(JSON.stringify(toStringify)))
+    t.assert.equal(output, JSON.stringify(toStringify))
+    t.assert.ok(validate(JSON.parse(output)), 'valid schema')
   })
 }
 
@@ -216,7 +216,7 @@ test('invalid items throw', (t) => {
     }
   }
   const stringify = build(schema)
-  t.throws(() => stringify({ args: ['invalid'] }))
+  t.assert.throws(() => stringify({ args: ['invalid'] }))
 })
 
 buildTest({
@@ -258,7 +258,7 @@ test('array items is a list of schema and additionalItems is true, just the desc
     ]
   })
 
-  t.equal(result, '{"foo":["foo","bar",1]}')
+  t.assert.equal(result, '{"foo":["foo","bar",1]}')
 })
 
 test('array items is a list of schema and additionalItems is true, just the described item is validated', (t) => {
@@ -287,7 +287,7 @@ test('array items is a list of schema and additionalItems is true, just the desc
     foo: ['foo']
   })
 
-  t.equal(result, '{"foo":["foo"]}')
+  t.assert.equal(result, '{"foo":["foo"]}')
 })
 
 test('array items is a list of schema and additionalItems is false /1', (t) => {
@@ -307,7 +307,7 @@ test('array items is a list of schema and additionalItems is false /1', (t) => {
   }
 
   const stringify = build(schema)
-  t.throws(() => stringify({ foo: ['foo', 'bar'] }), new Error('Item at 1 does not match schema definition.'))
+  t.assert.throws(() => stringify({ foo: ['foo', 'bar'] }), new Error('Item at 1 does not match schema definition.'))
 })
 
 test('array items is a list of schema and additionalItems is false /2', (t) => {
@@ -329,9 +329,9 @@ test('array items is a list of schema and additionalItems is false /2', (t) => {
 
   const stringify = build(schema)
 
-  t.throws(() => stringify({ foo: [1, 'bar'] }), new Error('Item at 0 does not match schema definition.'))
-  t.throws(() => stringify({ foo: ['foo', 1] }), new Error('Item at 1 does not match schema definition.'))
-  t.throws(() => stringify({ foo: ['foo', 'bar', 'baz'] }), new Error('Item at 2 does not match schema definition.'))
+  t.assert.throws(() => stringify({ foo: [1, 'bar'] }), new Error('Item at 0 does not match schema definition.'))
+  t.assert.throws(() => stringify({ foo: ['foo', 1] }), new Error('Item at 1 does not match schema definition.'))
+  t.assert.throws(() => stringify({ foo: ['foo', 'bar', 'baz'] }), new Error('Item at 2 does not match schema definition.'))
 })
 
 test('array items is a schema and additionalItems is false', (t) => {
@@ -354,8 +354,8 @@ test('array items is a schema and additionalItems is false', (t) => {
   const ajv = new Ajv({ allErrors: true, strict: false })
 
   const validate = ajv.compile(schema)
-  t.same(stringify({ foo: ['foo', 'bar'] }), '{"foo":["foo","bar"]}')
-  t.equal(validate({ foo: ['foo', 'bar'] }), true)
+  t.assert.equal(stringify({ foo: ['foo', 'bar'] }), '{"foo":["foo","bar"]}')
+  t.assert.equal(validate({ foo: ['foo', 'bar'] }), true)
 })
 
 // https://github.com/fastify/fast-json-stringify/issues/279
@@ -402,7 +402,7 @@ test('object array with anyOf and symbol', (t) => {
     { name: 'name-0', option: 'Foo' },
     { name: 'name-1', option: 'Bar' }
   ])
-  t.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
+  t.assert.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
 })
 
 test('different arrays with same item schemas', (t) => {
@@ -427,7 +427,7 @@ test('different arrays with same item schemas', (t) => {
   const stringify = build(schema)
   const data = { array1: ['bar'], array2: ['foo', 'bar'] }
 
-  t.equal(stringify(data), '{"array1":["bar"],"array2":["foo","bar"]}')
+  t.assert.equal(stringify(data), '{"array1":["bar"],"array2":["foo","bar"]}')
 })
 
 const largeArray = new Array(2e4).fill({ a: 'test', b: 1 })
@@ -557,7 +557,7 @@ buildTest({
 test('error on invalid value for largeArraySize /1', (t) => {
   t.plan(1)
 
-  t.throws(() => build({
+  t.assert.throws(() => build({
     title: 'large array of null values with default mechanism',
     type: 'object',
     properties: {
@@ -574,7 +574,7 @@ test('error on invalid value for largeArraySize /1', (t) => {
 test('error on invalid value for largeArraySize /2', (t) => {
   t.plan(1)
 
-  t.throws(() => build({
+  t.assert.throws(() => build({
     title: 'large array of null values with default mechanism',
     type: 'object',
     properties: {
@@ -591,7 +591,7 @@ test('error on invalid value for largeArraySize /2', (t) => {
 test('error on invalid value for largeArraySize /3', (t) => {
   t.plan(1)
 
-  t.throws(() => build({
+  t.assert.throws(() => build({
     title: 'large array of null values with default mechanism',
     type: 'object',
     properties: {

package/test/asNumber.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 
 test('asNumber should convert BigInt', (t) => {
   t.plan(1)
@@ -9,5 +9,5 @@ test('asNumber should convert BigInt', (t) => {
 
   const number = serializer.asNumber(11753021440n)
 
-  t.equal(number, '11753021440')
+  t.assert.equal(number, '11753021440')
 })

package/test/basic.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const validator = require('is-my-json-valid')
 const build = require('..')
 
@@ -12,9 +12,9 @@ function buildTest (schema, toStringify) {
     const stringify = build(schema)
     const output = stringify(toStringify)
 
-    t.same(JSON.parse(output), toStringify)
-    t.equal(output, JSON.stringify(toStringify))
-    t.ok(validate(JSON.parse(output)), 'valid schema')
+    t.assert.deepStrictEqual(JSON.parse(output), toStringify)
+    t.assert.equal(output, JSON.stringify(toStringify))
+    t.assert.ok(validate(JSON.parse(output)), 'valid schema')
   })
 }
 
@@ -281,41 +281,34 @@ test('throw an error or coerce numbers and integers that are not numbers', (t) =
     }
   })
 
-  try {
+  t.assert.throws(() => {
     stringify({ age: 'hello  ', distance: 'long' })
-    t.fail('should throw an error')
-  } catch (err) {
-    t.ok(err)
-  }
+  }, { message: 'The value "hello  " cannot be converted to a number.' })
 
   const result = stringify({
     age: '42',
     distance: true
   })
 
-  t.same(JSON.parse(result), { age: 42, distance: 1 })
-  t.end()
+  t.assert.deepStrictEqual(JSON.parse(result), { age: 42, distance: 1 })
 })
 
 test('Should throw on invalid schema', t => {
   t.plan(1)
-  try {
+  t.assert.throws(() => {
     build({
       type: 'Dinosaur',
       properties: {
         claws: { type: 'sharp' }
       }
     })
-    t.fail('should be an invalid schema')
-  } catch (err) {
-    t.ok(err)
-  }
+  }, { message: 'schema is invalid: data/properties/claws/type must be equal to one of the allowed values' })
 })
 
 test('additionalProperties - throw on unknown type', (t) => {
   t.plan(1)
 
-  try {
+  t.assert.throws(() => {
     build({
       title: 'check array coerce',
       type: 'object',
@@ -325,15 +318,13 @@ test('additionalProperties - throw on unknown type', (t) => {
       }
     })
     t.fail('should be an invalid schema')
-  } catch (err) {
-    t.ok(err)
-  }
+  }, { message: 'schema is invalid: data/additionalProperties/type must be equal to one of the allowed values' })
 })
 
 test('patternProperties - throw on unknown type', (t) => {
   t.plan(1)
 
-  try {
+  t.assert.throws(() => {
     build({
       title: 'check array coerce',
       type: 'object',
@@ -344,10 +335,7 @@ test('patternProperties - throw on unknown type', (t) => {
         }
       }
     })
-    t.fail('should be an invalid schema')
-  } catch (err) {
-    t.ok(err)
-  }
+  }, { message: 'schema is invalid: data/patternProperties/foo/type must be equal to one of the allowed values' })
 })
 
 test('render a double quote as JSON /1', (t) => {
@@ -362,8 +350,8 @@ test('render a double quote as JSON /1', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, JSON.stringify(toStringify))
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, JSON.stringify(toStringify))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('render a double quote as JSON /2', (t) => {
@@ -378,8 +366,8 @@ test('render a double quote as JSON /2', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, JSON.stringify(toStringify))
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, JSON.stringify(toStringify))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('render a long string', (t) => {
@@ -394,8 +382,8 @@ test('render a long string', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, JSON.stringify(toStringify))
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, JSON.stringify(toStringify))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('returns JSON.stringify if schema type is boolean', t => {
@@ -408,5 +396,5 @@ test('returns JSON.stringify if schema type is boolean', t => {
 
   const array = [1, true, 'test']
   const stringify = build(schema)
-  t.equal(stringify(array), JSON.stringify(array))
+  t.assert.equal(stringify(array), JSON.stringify(array))
 })

package/test/bigint.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
+
 const build = require('..')
 
 test('render a bigint as JSON', (t) => {
@@ -15,7 +15,7 @@ test('render a bigint as JSON', (t) => {
   const stringify = build(schema)
   const output = stringify(1615n)
 
-  t.equal(output, '1615')
+  t.assert.equal(output, '1615')
 })
 
 test('render an object with a bigint as JSON', (t) => {
@@ -36,7 +36,7 @@ test('render an object with a bigint as JSON', (t) => {
     id: 1615n
   })
 
-  t.equal(output, '{"id":1615}')
+  t.assert.equal(output, '{"id":1615}')
 })
 
 test('render an array with a bigint as JSON', (t) => {
@@ -53,7 +53,7 @@ test('render an array with a bigint as JSON', (t) => {
   const stringify = build(schema)
   const output = stringify([1615n])
 
-  t.equal(output, '[1615]')
+  t.assert.equal(output, '[1615]')
 })
 
 test('render an object with an additionalProperty of type bigint as JSON', (t) => {
@@ -72,5 +72,5 @@ test('render an object with an additionalProperty of type bigint as JSON', (t) =
     num: 1615n
   })
 
-  t.equal(output, '{"num":1615}')
+  t.assert.equal(output, '{"num":1615}')
 })

package/test/clean-cache.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('Should clean the cache', (t) => {
@@ -11,9 +11,10 @@ test('Should clean the cache', (t) => {
     type: 'string'
   }
 
-  build(schema)
-  build(schema)
-  t.pass()
+  t.assert.doesNotThrow(() => {
+    build(schema)
+    build(schema)
+  })
 })
 
 test('Should clean the cache with external schemas', (t) => {
@@ -39,7 +40,8 @@ test('Should clean the cache with external schemas', (t) => {
     }
   }
 
-  build(schema)
-  build(schema)
-  t.pass()
+  t.assert.doesNotThrow(() => {
+    build(schema)
+    build(schema)
+  })
 })