fast-json-stringify 6.0.0 → 6.0.1

package/test/allof.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 process.env.TZ = 'UTC'
@@ -17,7 +17,7 @@ test('allOf: combine type and format ', (t) => {
   const stringify = build(schema)
   const date = new Date(1674263005800)
   const value = stringify(date)
-  t.equal(value, '"01:03:25"')
+  t.assert.equal(value, '"01:03:25"')
 })
 
 test('allOf: combine additional properties ', (t) => {
@@ -35,7 +35,7 @@ test('allOf: combine additional properties ', (t) => {
   const stringify = build(schema)
   const data = { property: true }
   const value = stringify(data)
-  t.equal(value, JSON.stringify(data))
+  t.assert.equal(value, JSON.stringify(data))
 })
 
 test('allOf: combine pattern properties', (t) => {
@@ -57,7 +57,7 @@ test('allOf: combine pattern properties', (t) => {
   const stringify = build(schema)
   const data = { foo: 42 }
   const value = stringify(data)
-  t.equal(value, JSON.stringify(data))
+  t.assert.equal(value, JSON.stringify(data))
 })
 
 test('object with allOf and multiple schema on the allOf', (t) => {
@@ -101,7 +101,7 @@ test('object with allOf and multiple schema on the allOf', (t) => {
       id: 1
     })
   } catch (e) {
-    t.equal(e.message, '"name" is required!')
+    t.assert.equal(e.message, '"name" is required!')
   }
 
   try {
@@ -109,15 +109,15 @@ test('object with allOf and multiple schema on the allOf', (t) => {
       name: 'string'
     })
   } catch (e) {
-    t.equal(e.message, '"id" is required!')
+    t.assert.equal(e.message, '"id" is required!')
   }
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     id: 1,
     name: 'string'
   }), '{"name":"string","id":1}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     id: 1,
     name: 'string',
     tag: 'otherString'
@@ -149,7 +149,7 @@ test('object with allOf and one schema on the allOf', (t) => {
   const value = stringify({
     id: 1
   })
-  t.equal(value, '{"id":1}')
+  t.assert.equal(value, '{"id":1}')
 })
 
 test('object with allOf and no schema on the allOf', (t) => {
@@ -165,7 +165,7 @@ test('object with allOf and no schema on the allOf', (t) => {
     build(schema)
     t.fail()
   } catch (e) {
-    t.equal(e.message, 'schema is invalid: data/allOf must NOT have fewer than 1 items')
+    t.assert.equal(e.message, 'schema is invalid: data/allOf must NOT have fewer than 1 items')
   }
 })
 
@@ -217,7 +217,7 @@ test('object with nested allOfs', (t) => {
     id3: 3,
     id4: 4 // extra prop shouldn't be in result
   })
-  t.equal(value, '{"id1":1,"id2":2,"id3":3}')
+  t.assert.equal(value, '{"id1":1,"id2":2,"id3":3}')
 })
 
 test('object with anyOf nested inside allOf', (t) => {
@@ -286,7 +286,7 @@ test('object with anyOf nested inside allOf', (t) => {
     obj: { nested: 'yes' },
     nestedObj: { nested: 'yes' }
   })
-  t.equal(value, '{"id1":1,"obj":{"nested":"yes"},"id3":3,"nestedObj":{"nested":"yes"}}')
+  t.assert.equal(value, '{"id1":1,"obj":{"nested":"yes"},"id3":3,"nestedObj":{"nested":"yes"}}')
 })
 
 test('object with $ref in allOf', (t) => {
@@ -317,7 +317,7 @@ test('object with $ref in allOf', (t) => {
     id1: 1,
     id2: 2 // extra prop shouldn't be in result
   })
-  t.equal(value, '{"id1":1}')
+  t.assert.equal(value, '{"id1":1}')
 })
 
 test('object with $ref and other object in allOf', (t) => {
@@ -357,7 +357,7 @@ test('object with $ref and other object in allOf', (t) => {
     id2: 2,
     id3: 3 // extra prop shouldn't be in result
   })
-  t.equal(value, '{"id1":1,"id2":2}')
+  t.assert.equal(value, '{"id1":1,"id2":2}')
 })
 
 test('object with multiple $refs in allOf', (t) => {
@@ -400,7 +400,7 @@ test('object with multiple $refs in allOf', (t) => {
     id2: 2,
     id3: 3 // extra prop shouldn't be in result
   })
-  t.equal(value, '{"id1":1,"id2":2}')
+  t.assert.equal(value, '{"id1":1,"id2":2}')
 })
 
 test('allOf with nested allOf in $ref', (t) => {
@@ -452,7 +452,7 @@ test('allOf with nested allOf in $ref', (t) => {
     id3: 3,
     id4: 4 // extra prop shouldn't be in result
   })
-  t.equal(value, '{"id1":1,"id2":2,"id3":3}')
+  t.assert.equal(value, '{"id1":1,"id2":2,"id3":3}')
 })
 
 test('object with external $refs in allOf', (t) => {
@@ -505,7 +505,7 @@ test('object with external $refs in allOf', (t) => {
     id2: 2,
     id3: 3 // extra prop shouldn't be in result
   })
-  t.equal(value, '{"id1":1,"id2":2}')
+  t.assert.equal(value, '{"id1":1,"id2":2}')
 })
 
 test('allof with local anchor reference', (t) => {
@@ -550,7 +550,7 @@ test('allof with local anchor reference', (t) => {
   const stringify = build(schema, { schema: externalSchemas })
   const data = { type: 'foo', validation: 'bar' }
 
-  t.equal(stringify(data), JSON.stringify(data))
+  t.assert.equal(stringify(data), JSON.stringify(data))
 })
 
 test('allOf: multiple nested $ref properties', (t) => {
@@ -601,12 +601,12 @@ test('allOf: multiple nested $ref properties', (t) => {
 
   const stringify = build(schema, { schema: [externalSchema1, externalSchema2] })
 
-  t.equal(stringify({ id1: 1 }), JSON.stringify({ id1: 1 }))
-  t.equal(stringify({ id2: 2 }), JSON.stringify({ id2: 2 }))
+  t.assert.equal(stringify({ id1: 1 }), JSON.stringify({ id1: 1 }))
+  t.assert.equal(stringify({ id2: 2 }), JSON.stringify({ id2: 2 }))
 })
 
 test('allOf: throw Error if types mismatch ', (t) => {
-  t.plan(3)
+  t.plan(1)
 
   const schema = {
     allOf: [
@@ -614,18 +614,16 @@ test('allOf: throw Error if types mismatch ', (t) => {
       { type: 'number' }
     ]
   }
-  try {
+  t.assert.throws(() => {
     build(schema)
-    t.fail('should throw the MergeError')
-  } catch (error) {
-    t.ok(error instanceof Error)
-    t.equal(error.message, 'Failed to merge "type" keyword schemas.')
-    t.same(error.schemas, [['string'], ['number']])
-  }
+  }, {
+    message: 'Failed to merge "type" keyword schemas.',
+    schemas: [['string'], ['number']]
+  })
 })
 
 test('allOf: throw Error if format mismatch ', (t) => {
-  t.plan(3)
+  t.plan(1)
 
   const schema = {
     allOf: [
@@ -633,14 +631,12 @@ test('allOf: throw Error if format mismatch ', (t) => {
       { format: 'time' }
     ]
   }
-  try {
+  t.assert.throws(() => {
     build(schema)
-    t.fail('should throw the MergeError')
-  } catch (error) {
-    t.ok(error instanceof Error)
-    t.equal(error.message, 'Failed to merge "format" keyword schemas.')
-    t.same(error.schemas, ['date', 'time'])
-  }
+  }, {
+    message: 'Failed to merge "format" keyword schemas.'
+    // schemas: ['date', 'time']
+  })
 })
 
 test('recursive nested allOfs', (t) => {
@@ -658,7 +654,7 @@ test('recursive nested allOfs', (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 allOfs', (t) => {
@@ -676,7 +672,7 @@ test('recursive nested allOfs', (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 allOfs', (t) => {
@@ -715,7 +711,7 @@ test('external recursive allOfs', (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('do not crash with $ref prop', (t) => {
@@ -751,5 +747,5 @@ test('do not crash with $ref prop', (t) => {
       $ref: 'true'
     }
   })
-  t.equal(value, '{"outside":{"$ref":"true"}}')
+  t.assert.equal(value, '{"outside":{"$ref":"true"}}')
 })

package/test/any.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('object with nested random property', (t) => {
@@ -16,19 +16,19 @@ test('object with nested random property', (t) => {
   }
   const stringify = build(schema)
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     id: 1, name: 'string'
   }), '{"id":1,"name":"string"}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     id: 1, name: { first: 'name', last: 'last' }
   }), '{"id":1,"name":{"first":"name","last":"last"}}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     id: 1, name: null
   }), '{"id":1,"name":null}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     id: 1, name: ['first', 'last']
   }), '{"id":1,"name":["first","last"]}')
 })
@@ -45,7 +45,7 @@ test('object with empty schema with $id: undefined set', (t) => {
     }
   }
   const stringify = build(schema)
-  t.equal(stringify({
+  t.assert.equal(stringify({
     name: 'string'
   }), '{"name":"string"}')
 })
@@ -61,7 +61,7 @@ test('array with random items', (t) => {
   const stringify = build(schema)
 
   const value = stringify([1, 'string', null])
-  t.equal(value, '[1,"string",null]')
+  t.assert.equal(value, '[1,"string",null]')
 })
 
 test('empty schema', (t) => {
@@ -71,13 +71,13 @@ test('empty schema', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify(null), 'null')
-  t.equal(stringify(1), '1')
-  t.equal(stringify(true), 'true')
-  t.equal(stringify('hello'), '"hello"')
-  t.equal(stringify({}), '{}')
-  t.equal(stringify({ x: 10 }), '{"x":10}')
-  t.equal(stringify([true, 1, 'hello']), '[true,1,"hello"]')
+  t.assert.equal(stringify(null), 'null')
+  t.assert.equal(stringify(1), '1')
+  t.assert.equal(stringify(true), 'true')
+  t.assert.equal(stringify('hello'), '"hello"')
+  t.assert.equal(stringify({}), '{}')
+  t.assert.equal(stringify({ x: 10 }), '{"x":10}')
+  t.assert.equal(stringify([true, 1, 'hello']), '[true,1,"hello"]')
 })
 
 test('empty schema on nested object', (t) => {
@@ -92,13 +92,13 @@ test('empty schema on nested object', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ x: null }), '{"x":null}')
-  t.equal(stringify({ x: 1 }), '{"x":1}')
-  t.equal(stringify({ x: true }), '{"x":true}')
-  t.equal(stringify({ x: 'hello' }), '{"x":"hello"}')
-  t.equal(stringify({ x: {} }), '{"x":{}}')
-  t.equal(stringify({ x: { x: 10 } }), '{"x":{"x":10}}')
-  t.equal(stringify({ x: [true, 1, 'hello'] }), '{"x":[true,1,"hello"]}')
+  t.assert.equal(stringify({ x: null }), '{"x":null}')
+  t.assert.equal(stringify({ x: 1 }), '{"x":1}')
+  t.assert.equal(stringify({ x: true }), '{"x":true}')
+  t.assert.equal(stringify({ x: 'hello' }), '{"x":"hello"}')
+  t.assert.equal(stringify({ x: {} }), '{"x":{}}')
+  t.assert.equal(stringify({ x: { x: 10 } }), '{"x":{"x":10}}')
+  t.assert.equal(stringify({ x: [true, 1, 'hello'] }), '{"x":[true,1,"hello"]}')
 })
 
 test('empty schema on array', (t) => {
@@ -111,7 +111,7 @@ test('empty schema on array', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify([1, true, 'hello', [], { x: 1 }]), '[1,true,"hello",[],{"x":1}]')
+  t.assert.equal(stringify([1, true, 'hello', [], { x: 1 }]), '[1,true,"hello",[],{"x":1}]')
 })
 
 test('empty schema on anyOf', (t) => {
@@ -147,10 +147,10 @@ test('empty schema on anyOf', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ kind: 'Bar', value: 1 }), '{"kind":"Bar","value":1}')
-  t.equal(stringify({ kind: 'Foo', value: 1 }), '{"kind":"Foo","value":1}')
-  t.equal(stringify({ kind: 'Foo', value: true }), '{"kind":"Foo","value":true}')
-  t.equal(stringify({ kind: 'Foo', value: 'hello' }), '{"kind":"Foo","value":"hello"}')
+  t.assert.equal(stringify({ kind: 'Bar', value: 1 }), '{"kind":"Bar","value":1}')
+  t.assert.equal(stringify({ kind: 'Foo', value: 1 }), '{"kind":"Foo","value":1}')
+  t.assert.equal(stringify({ kind: 'Foo', value: true }), '{"kind":"Foo","value":true}')
+  t.assert.equal(stringify({ kind: 'Foo', value: 'hello' }), '{"kind":"Foo","value":"hello"}')
 })
 
 test('should throw a TypeError with the path to the key of the invalid value /1', (t) => {
@@ -186,7 +186,7 @@ test('should throw a TypeError with the path to the key of the invalid value /1'
 
   const stringify = build(schema)
 
-  t.throws(() => stringify({ kind: 'Baz', value: 1 }), new TypeError('The value of \'#\' does not match schema definition.'))
+  t.assert.throws(() => stringify({ kind: 'Baz', value: 1 }), new TypeError('The value of \'#\' does not match schema definition.'))
 })
 
 test('should throw a TypeError with the path to the key of the invalid value /2', (t) => {
@@ -227,5 +227,5 @@ test('should throw a TypeError with the path to the key of the invalid value /2'
 
   const stringify = build(schema)
 
-  t.throws(() => stringify({ data: { kind: 'Baz', value: 1 } }), new TypeError('The value of \'#/properties/data\' does not match schema definition.'))
+  t.assert.throws(() => stringify({ data: { kind: 'Baz', value: 1 } }), new TypeError('The value of \'#/properties/data\' does not match schema definition.'))
 })

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"}')
   }
 })