test: ensure any Uint8Array is accepted in base64/base32

Author: ChALkeR

base32.d.ts

@@ -47,7 +47,7 @@ export interface FromBase32Options {
  * @param options - Encoding options
  * @returns The base32 encoded string
  */
-export function toBase32(arr: Uint8ArrayBuffer, options?: ToBase32Options): string;
+export function toBase32(arr: Uint8Array, options?: ToBase32Options): string;
 
 /**
  * Encode a `Uint8Array` to a base32hex string (RFC 4648)
@@ -56,7 +56,7 @@ export function toBase32(arr: Uint8ArrayBuffer, options?: ToBase32Options): stri
  * @param options - Encoding options (padding defaults to false)
  * @returns The base32hex encoded string
  */
-export function toBase32hex(arr: Uint8ArrayBuffer, options?: ToBase32Options): string;
+export function toBase32hex(arr: Uint8Array, options?: ToBase32Options): string;
 
 /**
  * Decode a base32 string to bytes

base64.d.ts

@@ -48,7 +48,7 @@ export interface FromBase64Options {
  * @param options - Encoding options
  * @returns The base64 encoded string
  */
-export function toBase64(arr: Uint8ArrayBuffer, options?: ToBase64Options): string;
+export function toBase64(arr: Uint8Array, options?: ToBase64Options): string;
 
 /**
  * Encode a `Uint8Array` to a base64url string (RFC 4648)
@@ -57,7 +57,7 @@ export function toBase64(arr: Uint8ArrayBuffer, options?: ToBase64Options): stri
  * @param options - Encoding options (padding defaults to false)
  * @returns The base64url encoded string
  */
-export function toBase64url(arr: Uint8ArrayBuffer, options?: ToBase64Options): string;
+export function toBase64url(arr: Uint8Array, options?: ToBase64Options): string;
 
 /**
  * Decode a base64 string to bytes

tests/base32.test.js

@@ -3,6 +3,8 @@ import { describe, test } from 'node:test'
 import base32js from 'base32.js'
 import hiBase32 from 'hi-base32'
 
+const SharedArrayBuffer = globalThis.SharedArrayBuffer ?? ArrayBuffer
+
 const raw = [new Uint8Array(), new Uint8Array([0]), new Uint8Array([1]), new Uint8Array([255])]
 for (let i = 0; i < 50; i++) {
   const size = Math.floor(Math.random() * 100)
@@ -19,7 +21,9 @@ const pool = raw.map((uint8) => {
   if (base32padded !== hiBase32.encode(uint8)) throw new Error('Unexpected mismatch with hiBase32')
   const base32hexPadded = pad(base32hex)
   const hex = buffer.toString('hex')
-  return { uint8, buffer, hex, base32, base32padded, base32hex, base32hexPadded }
+  const shared = new Uint8Array(new SharedArrayBuffer(buffer.length))
+  shared.set(uint8)
+  return { uint8, shared, buffer, hex, base32, base32padded, base32hex, base32hexPadded }
 })
 
 describe('toBase32', () => {
@@ -34,20 +38,22 @@ describe('toBase32', () => {
   })
 
   test('base32', (t) => {
-    for (const { uint8, buffer, base32, base32padded } of pool) {
-      t.assert.strictEqual(toBase32(uint8), base32)
-      t.assert.strictEqual(toBase32(buffer), base32)
-      t.assert.strictEqual(toBase32(uint8, { padding: false }), base32)
-      t.assert.strictEqual(toBase32(uint8, { padding: true }), base32padded)
+    for (const { uint8, shared, buffer, base32, base32padded } of pool) {
+      for (const arg of [uint8, shared, buffer]) {
+        t.assert.strictEqual(toBase32(arg), base32)
+        t.assert.strictEqual(toBase32(arg, { padding: false }), base32)
+        t.assert.strictEqual(toBase32(arg, { padding: true }), base32padded)
+      }
     }
   })
 
   test('base32hex', (t) => {
-    for (const { uint8, buffer, base32hex, base32hexPadded } of pool) {
-      t.assert.strictEqual(toBase32hex(uint8), base32hex)
-      t.assert.strictEqual(toBase32hex(buffer), base32hex)
-      t.assert.strictEqual(toBase32hex(uint8, { padding: false }), base32hex)
-      t.assert.strictEqual(toBase32hex(uint8, { padding: true }), base32hexPadded)
+    for (const { uint8, shared, buffer, base32hex, base32hexPadded } of pool) {
+      for (const arg of [uint8, shared, buffer]) {
+        t.assert.strictEqual(toBase32hex(arg), base32hex)
+        t.assert.strictEqual(toBase32hex(arg, { padding: false }), base32hex)
+        t.assert.strictEqual(toBase32hex(arg, { padding: true }), base32hexPadded)
+      }
     }
   })
 })

tests/base64.test.js

@@ -2,6 +2,8 @@ import { toBase64, toBase64url, fromBase64, fromBase64url } from '@exodus/bytes/
 import * as js from '../fallback/base64.js'
 import { describe, test } from 'node:test'
 
+const SharedArrayBuffer = globalThis.SharedArrayBuffer ?? ArrayBuffer
+
 const raw = [new Uint8Array(), new Uint8Array([0]), new Uint8Array([1]), new Uint8Array([255])]
 for (let i = 0; i < 50; i++) {
   const size = Math.floor(Math.random() * 100)
@@ -21,7 +23,9 @@ const pool = raw.map((uint8) => {
 
   if (base64url !== base64urlFallback) throw new Error('Unexpected base64url mismatch with Buffer')
   const hex = buffer.toString('hex')
-  return { uint8, buffer, hex, base64, base64nopad, base64url, base64urlPadded }
+  const shared = new Uint8Array(new SharedArrayBuffer(buffer.length))
+  shared.set(uint8)
+  return { uint8, shared, buffer, hex, base64, base64nopad, base64url, base64urlPadded }
 })
 
 describe('toBase64', () => {
@@ -36,32 +40,26 @@ describe('toBase64', () => {
   })
 
   test('base64', (t) => {
-    for (const { uint8, buffer, base64, base64nopad } of pool) {
-      t.assert.strictEqual(toBase64(uint8), base64)
-      t.assert.strictEqual(toBase64(uint8, { padding: true }), base64)
-      t.assert.strictEqual(toBase64(uint8, { padding: false }), base64nopad)
-      t.assert.strictEqual(js.toBase64(uint8, false, false), base64nopad)
-      t.assert.strictEqual(js.toBase64(uint8, false, true), base64)
-      t.assert.strictEqual(toBase64(buffer), base64)
-      t.assert.strictEqual(toBase64(buffer, { padding: true }), base64)
-      t.assert.strictEqual(toBase64(buffer, { padding: false }), base64nopad)
-      t.assert.strictEqual(js.toBase64(buffer, false, false), base64nopad)
-      t.assert.strictEqual(js.toBase64(buffer, false, true), base64)
+    for (const { uint8, shared, buffer, base64, base64nopad } of pool) {
+      for (const arg of [uint8, shared, buffer]) {
+        t.assert.strictEqual(toBase64(arg), base64)
+        t.assert.strictEqual(toBase64(arg, { padding: true }), base64)
+        t.assert.strictEqual(toBase64(arg, { padding: false }), base64nopad)
+        t.assert.strictEqual(js.toBase64(arg, false, false), base64nopad)
+        t.assert.strictEqual(js.toBase64(arg, false, true), base64)
+      }
     }
   })
 
   test('base64url', (t) => {
-    for (const { uint8, buffer, base64url, base64urlPadded } of pool) {
-      t.assert.strictEqual(toBase64url(uint8), base64url)
-      t.assert.strictEqual(toBase64url(uint8, { padding: false }), base64url)
-      t.assert.strictEqual(toBase64url(uint8, { padding: true }), base64urlPadded)
-      t.assert.strictEqual(js.toBase64(uint8, true, false), base64url)
-      t.assert.strictEqual(js.toBase64(uint8, true, true), base64urlPadded)
-      t.assert.strictEqual(toBase64url(buffer), base64url)
-      t.assert.strictEqual(toBase64url(buffer, { padding: false }), base64url)
-      t.assert.strictEqual(toBase64url(buffer, { padding: true }), base64urlPadded)
-      t.assert.strictEqual(js.toBase64(buffer, true, false), base64url)
-      t.assert.strictEqual(js.toBase64(buffer, true, true), base64urlPadded)
+    for (const { uint8, shared, buffer, base64url, base64urlPadded } of pool) {
+      for (const arg of [uint8, shared, buffer]) {
+        t.assert.strictEqual(toBase64url(arg), base64url)
+        t.assert.strictEqual(toBase64url(arg, { padding: false }), base64url)
+        t.assert.strictEqual(toBase64url(arg, { padding: true }), base64urlPadded)
+        t.assert.strictEqual(js.toBase64(arg, true, false), base64url)
+        t.assert.strictEqual(js.toBase64(arg, true, true), base64urlPadded)
+      }
     }
   })
 })