test: compare single-byte against WHATWG non-normative indexes.json

Author: ChALkeR

fallback/single-byte.js

@@ -13,7 +13,7 @@ export const assertEncoding = (encoding) => {
 
 const r = 0xff_fd
 
-function getEncoding(encoding) {
+export function getEncoding(encoding) {
   assertEncoding(encoding)
   if (encoding === xUserDefined) return Array.from({ length: 128 }, (_, i) => 0xf7_80 + i)
   if (encoding === iso8i) encoding = 'iso-8859-8'

tests/encoding/fixtures/indexes.cjs

@@ -0,0 +1,15 @@
+const raw = require('./indexes.json')
+
+const {
+  big5,
+  'euc-kr': eucKr,
+  gb18030,
+  jis0208,
+  jis0212,
+  'gb18030-ranges': gb18030ranges,
+  'iso-2022-jp-katakana': katakana,
+  ...singleByte
+} = raw
+const multiByte = { big5, 'euc-kr': eucKr, gb18030, jis0208, jis0212 }
+
+module.exports = { raw, gb18030ranges, katakana, multiByte, singleByte }

tests/single-byte.test.js

@@ -2,8 +2,9 @@ import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { test, describe } from 'node:test'
 import { createSinglebyteDecoder, createSinglebyteEncoder } from '@exodus/bytes/single-byte.js'
-import { encodingDecoder } from '../fallback/single-byte.js'
+import { encodingDecoder, getEncoding } from '../fallback/single-byte.js'
 import encodingsObject from '../fallback/single-byte.encodings.js'
+import { singleByte } from './encoding/fixtures/indexes.cjs'
 
 const encodings = Object.keys(encodingsObject)
 const nonWhatwg = new Set(['iso-8859-1', 'iso-8859-9', 'iso-8859-11'])
@@ -214,6 +215,42 @@ describe('single-byte encodings index: WHATWG', () => {
   }
 })
 
+describe('single-byte encodings index: WHATWG non-normative indexes.json', () => {
+  for (const [encoding, data] of Object.entries(singleByte)) {
+    test(encoding, (t) => {
+      t.assert.ok(Object.hasOwn(encodingsObject, encoding))
+      const high = getEncoding(encoding)
+      while (high.length < 128) high.push(128 + high.length)
+      t.assert.deepStrictEqual(
+        high,
+        data.map((x) => (x === null ? 65_533 : x))
+      )
+      const decoder = createSinglebyteDecoder(encoding)
+      const decoderLoose = createSinglebyteDecoder(encoding, true)
+      const encoder = createSinglebyteEncoder(encoding)
+
+      t.assert.strictEqual(data.length, 128)
+      for (let i = 0; i < data.length; i++) {
+        const byte = i + 128
+        t.assert.notEqual(data[i], 0)
+        t.assert.notEqual(data[i], 0xff_fd)
+        const str = data[i] === null ? null : String.fromCodePoint(data[i])
+
+        if (str) {
+          t.assert.ok(data[i] > 0)
+          t.assert.ok(data[i] <= 0xff_ff)
+          t.assert.strictEqual(decoder(Uint8Array.of(byte)), str)
+          t.assert.strictEqual(decoderLoose(Uint8Array.of(byte)), str)
+          t.assert.deepStrictEqual(encoder(str), Uint8Array.of(byte))
+        } else {
+          t.assert.throws(() => decoder(Uint8Array.of(byte)))
+          t.assert.strictEqual(decoderLoose(Uint8Array.of(byte)), '\uFFFD')
+        }
+      }
+    })
+  }
+})
+
 // https://encoding.spec.whatwg.org/#x-user-defined-decoder
 describe('x-user-defined', () => {
   const encoding = 'x-user-defined'