Use Node test runner

Author: wooorm

.github/workflows/main.yml

@@ -17,5 +17,5 @@ jobs:
     strategy:
       matrix:
         node:
-          - lts/fermium
+          - lts/gallium
           - node

package.json

@@ -36,12 +36,11 @@
     "stringify-entities": "^4.0.0"
   },
   "devDependencies": {
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.0",
     "c8": "^7.0.0",
     "prettier": "^2.0.0",
     "remark-cli": "^11.0.0",
     "remark-preset-wooorm": "^9.0.0",
-    "tape": "^5.0.0",
     "type-coverage": "^2.0.0",
     "typescript": "^4.0.0",
     "unist-builder": "^3.0.0",

test/attribute.js

@@ -1,210 +1,203 @@
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {x} from 'xastscript'
 import {u} from 'unist-builder'
 import {toXml} from '../index.js'
 
-test('`element` attributes', (t) => {
-  t.deepEqual(
+test('`element` attributes', async (t) => {
+  assert.deepEqual(
     toXml(u('element', {name: 'y'}, [])),
     '<y></y>',
     'should ignore missing attributes'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toXml(u('element', {name: 'y', attributes: {a: null}}, [])),
     '<y></y>',
     'should ignore attributes set to `null`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toXml(u('element', {name: 'y', attributes: {a: undefined}}, [])),
     '<y></y>',
     'should ignore attributes set to `undefined`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error runtime.
     toXml(u('element', {name: 'y', attributes: {a: Number.NaN}}, [])),
     '<y a="NaN"></y>',
     'should include attributes set to `NaN`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error runtime.
     toXml(u('element', {name: 'y', attributes: {a: true}}, [])),
     '<y a="true"></y>',
     'should include attributes set to `true`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toXml(u('element', {name: 'y', attributes: {a: 'b'}}, [])),
     '<y a="b"></y>',
     'should include attributes set to a string'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error runtime.
     toXml(u('element', {name: 'y', attributes: {a: ['b', 'c']}}, [])),
     '<y a="b,c"></y>',
     'should include attributes set to an array'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error runtime.
     toXml(u('element', {name: 'y', attributes: {a: 1}}, [])),
     '<y a="1"></y>',
     'should include attributes set to a number'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error runtime.
     toXml(u('element', {name: 'y', attributes: {a: 0}}, [])),
     '<y a="0"></y>',
     'should include attributes set to `0`'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error runtime.
     toXml(u('element', {name: 'y', attributes: {a: {toString}}}, [])),
     '<y a="yup"></y>',
     'should stringify unknowns set to objects'
   )
 
-  t.end()
-
-  t.test('quote', (st) => {
-    st.deepEqual(
+  await t.test('quote', () => {
+    assert.deepEqual(
       toXml(x('y', {a: 'b'})),
       '<y a="b"></y>',
       'should quote attribute values with double quotes by default'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: 'b'}), {quote: "'"}),
       "<y a='b'></y>",
       'should quote attribute values with single quotes if `quote: "\'"`'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: 'b'}), {quote: '"'}),
       '<y a="b"></y>',
       "should quote attribute values with double quotes if `quote: '\"'`"
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: "'b'"}), {quote: "'"}),
       "<y a='&#x27;b&#x27;'></y>",
       'should quote attribute values with single quotes if `quote: "\'"` even if they occur in value'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: '"b"'}), {quote: '"'}),
       '<y a="&#x22;b&#x22;"></y>',
       "should quote attribute values with double quotes if `quote: '\"'` even if they occur in value"
     )
 
-    st.throws(
+    assert.throws(
       () => {
         // @ts-expect-error runtime.
         toXml(x('y'), {quote: '`'})
       },
       /Invalid quote ```, expected `'` or `"`/,
       'should throw on invalid quotes'
     )
-
-    st.end()
   })
 
-  t.test('quoteSmart', (st) => {
-    st.deepEqual(
+  await t.test('quoteSmart', () => {
+    assert.deepEqual(
       toXml(x('y', {a: 'b'}), {quoteSmart: true}),
       '<y a="b"></y>',
       'should quote attribute values with primary quotes by default (`"`)'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: 'b'}), {quote: "'", quoteSmart: true}),
       "<y a='b'></y>",
       "should quote attribute values with primary quotes by default (`'`)"
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: "'b'"}), {quoteSmart: true}),
       '<y a="\'b\'"></y>',
       'should quote attribute values with primary quotes if the alternative occurs'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: "'\"b'"}), {quoteSmart: true}),
       '<y a="\'&#x22;b\'"></y>',
       'should quote attribute values with primary quotes if they occur less than the alternative'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: '"b\''}), {quoteSmart: true}),
       '<y a="&#x22;b\'"></y>',
       'should quote attribute values with primary quotes if they occur as much as alternatives (#1)'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: '"\'b\'"'}), {quoteSmart: true}),
       '<y a="&#x22;\'b\'&#x22;"></y>',
       'should quote attribute values with primary quotes if they occur as much as alternatives (#2)'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: '"b"'}), {quoteSmart: true}),
       '<y a=\'"b"\'></y>',
       'should quote attribute values with alternative quotes if the primary occurs'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: '"\'b"'}), {quoteSmart: true}),
       '<y a=\'"&#x27;b"\'></y>',
       'should quote attribute values with alternative quotes if they occur less than the primary'
     )
-
-    st.end()
   })
 
-  t.test('entities in attributes', (st) => {
-    st.deepEqual(
+  await t.test('entities in attributes', () => {
+    assert.deepEqual(
       toXml(x('y', {'3<5': 'a'})),
       '<y 3&#x3C;5="a"></y>',
       'should encode entities in attribute names'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {'a\0b': 'c'})),
       '<y ab="c"></y>',
       'should strip illegal characters in attribute names'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: '3<5'})),
       '<y a="3&#x3C;5"></y>',
       'should encode entities in attribute values'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: 'b\0c'})),
       '<y a="bc"></y>',
       'should strip illegal characters in attribute values'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {'3=5': 'a'})),
       '<y 3&#x3D;5="a"></y>',
       'should encode `=` in attribute names'
     )
 
-    st.deepEqual(
+    assert.deepEqual(
       toXml(x('y', {a: '3=5'})),
       '<y a="3=5"></y>',
       'should not encode `=` in attribute values'
     )
-
-    st.end()
   })
 })
 

test/cdata.js

@@ -1,19 +1,18 @@
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {u} from 'unist-builder'
 import {toXml} from '../index.js'
 
-test('`cdata`', (t) => {
-  t.deepEqual(
+test('`cdata`', () => {
+  assert.deepEqual(
     toXml(u('cdata', '3 < 5 & 8 > 13')),
     '<![CDATA[3 < 5 & 8 > 13]]>',
     'should not encode `cdata`s'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toXml(u('cdata', '3 ]]> 5')),
     '<![CDATA[3 ]]&#x3E; 5]]>',
     'should encode cdata otherwise closing `cdata`s'
   )
-
-  t.end()
 })

test/comment.js

@@ -1,26 +1,25 @@
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {u} from 'unist-builder'
 import {toXml} from '../index.js'
 
-test('`comment`', (t) => {
-  t.deepEqual(
+test('`comment`', () => {
+  assert.deepEqual(
     toXml(u('comment', 'alpha')),
     '<!--alpha-->',
     'should serialize `comment`s'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     toXml(u('comment', 'AT&T')),
     '<!--AT&T-->',
     'should not encode `comment`s (#1)'
   )
 
   // No way to get around this.
-  t.deepEqual(
+  assert.deepEqual(
     toXml(u('comment', '-->')),
     '<!--&#x2D;&#x2D;>-->',
     'should not encode `comment`s (#2)'
   )
-
-  t.end()
 })

test/core.js

@@ -1,9 +1,10 @@
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {u} from 'unist-builder'
 import {toXml} from '../index.js'
 
-test('toXml()', (t) => {
-  t.throws(
+test('toXml()', () => {
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       toXml(true)
@@ -12,14 +13,12 @@ test('toXml()', (t) => {
     'should throw on non-nodes'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       // @ts-expect-error runtime.
       toXml(u('foo', []))
     },
     /Cannot compile unknown node `foo`/,
     'should throw on unknown nodes'
   )
-
-  t.end()
 })