feat: b64byteLength()

Author: waitingsong

src/lib/index.ts

@@ -11,6 +11,7 @@ import {
   NodeDecode,
   NodeEncode,
 } from './nodejs'
+import { getLens, _byteLength } from './to_buffer'
 
 
 export function b64encode(
@@ -46,3 +47,16 @@ export function b64fromBuffer(buffer: ArrayBuffer | Uint8Array): string {
     : browserFromBuffer(buffer)
   return ret
 }
+
+
+/**
+ * Calculate buffer.byteLength from base64
+ *
+ * base64 is 4/3 + up to two characters of the original data
+ */
+export function b64byteLength(base64: string): number {
+  const lens = getLens(base64)
+  const validLen = lens[0]
+  const placeHoldersLen = lens[1]
+  return _byteLength(validLen, placeHoldersLen)
+}

test/20_big.test.ts

@@ -0,0 +1,47 @@
+/// <reference types="mocha" />
+
+import {
+  basename,
+  join,
+} from '@waiting/shared-core'
+import * as assert from 'power-assert'
+import rewire = require('rewire')
+import { TextDecoder, TextEncoder } from 'util'
+
+import { b64byteLength, b64encode } from '../src'
+import { fromUint8Array } from '../src/lib/from_buffer'
+import { toUint8Array } from '../src/lib/to_buffer'
+
+import { input1, input2, input3 } from './config'
+import { equal } from './helper'
+
+
+const filename = basename(__filename)
+
+
+describe(filename, () => {
+  describe('Should fromUint8Array() works with big input', () => {
+    it('test1', () => {
+      const big = new Uint8Array(128 * 1024 * 1024)
+
+      for (let i = 0, length = big.length; i < length; ++i) {
+        big[i] = i % 256
+      }
+      const b64 = fromUint8Array(big)
+      const u8arr = toUint8Array(b64)
+
+      assert(equal(u8arr, big))
+      assert(b64byteLength(b64) === u8arr.length)
+    })
+
+    it('test2', () => {
+      const str = input1.concat(input2, input3).join('').repeat(500_000)
+      const len = (str.length / 1024 / 1024).toFixed(2)
+      const ret1 = b64encode(str, TextEncoder)
+      const ret2 = Buffer.from(str.toString()).toString('base64')
+
+      console.info(`test2: string length ${len} MB`)
+      assert(ret1 === ret2, `input: "${str.toString()}"`)
+    })
+  })
+})

test/20_to_buffer.test.ts

@@ -0,0 +1,33 @@
+/// <reference types="mocha" />
+
+import {
+  basename,
+  join,
+} from '@waiting/shared-core'
+import * as assert from 'power-assert'
+import rewire = require('rewire')
+
+import { b64byteLength } from '../src'
+import { toUint8Array } from '../src/lib/to_buffer'
+
+import { input8 } from './config'
+import { equal } from './helper'
+
+
+const filename = basename(__filename)
+const mods = rewire('../src/lib/from_buffer')
+
+describe(filename, () => {
+  it('Should toUint8Array() works', () => {
+    input8.forEach(row => {
+      const input = row[1]
+      const actual = toUint8Array(input)
+      const expected = Uint8Array.from(row[0])
+
+      assert(equal(actual, expected), 'Ensure that ' + input + ' deserialise to ' + expected)
+      const byteLength = b64byteLength(input)
+      assert(byteLength === expected.length, 'Ensure that ' + input + ' has byte lentgh of ' + expected.length)
+    })
+  })
+
+})

test_browser/10_encoding.test.ts

@@ -0,0 +1,38 @@
+/// <reference types="mocha" />
+
+// tslint:disable-next-line
+import * as assert from 'power-assert'
+
+import {
+  b64decode,
+  b64encode,
+} from '../src/index'
+
+
+const filename = '10_encoding.test.ts'
+
+describe(filename, () => {
+  const fnName = 'b64decode'
+
+  describe(`Should ${fnName}() works`, () => {
+    it('with various encoding', () => {
+      ['A', '1', 'ascii0123'].forEach(str => {
+        const input = str.toString()
+        const base64 = b64encode(str)
+
+        const s1 = b64decode(base64, 'utf-8')
+        assert(s1 === input, `input: "${input}" expect:"${s1}"`)
+
+        const s2 = b64decode(base64, 'gbk')
+        assert(s2 === input, `input: "${input}" expect:"${s2}"`)
+
+        const s3 = b64decode(base64, 'gb18030')
+        assert(s3 === input, `input: "${input}" expect:"${s3}"`)
+
+        const s4 = b64decode(base64, 'iso-8859-2')
+        assert(s4 === input, `input: "${input}" expect:"${s4}"`)
+      })
+    })
+  })
+
+})

test_browser/20_big.test.ts

@@ -0,0 +1,39 @@
+/// <reference types="mocha" />
+
+import * as assert from 'power-assert'
+
+import { b64decode, b64encode, b64ByteLength } from '../src'
+import { fromUint8Array } from '../src/lib/from_buffer'
+import { toUint8Array } from '../src/lib/to_buffer'
+
+import { input1, input2 } from './config'
+import { equal } from './helper'
+
+
+const filename = '20_big.test.ts'
+
+describe(filename, () => {
+  describe('Should fromUint8Array() works with big input', () => {
+    it('test1', () => {
+      const big = new Uint8Array(128 * 1024 * 1024)
+
+      for (let i = 0, length = big.length; i < length; ++i) {
+        big[i] = i % 256
+      }
+      const b64 = fromUint8Array(big)
+      const u8arr = toUint8Array(b64)
+      assert(equal(u8arr, big))
+      assert(b64ByteLength(b64) === u8arr.length)
+    })
+
+    it('test2', () => {
+      const str = input1.concat(input2).join('').repeat(300_000)
+      const len = (str.length / 1024 / 1024).toFixed(2)
+      const ret1 = b64encode(str)
+      const ret2 = b64decode(ret1)
+
+      console.info(`test2: string length ${len} MB`)
+      assert(ret2 === str)
+    })
+  })
+})

test_browser/20_to_buffer.test.ts

@@ -0,0 +1,27 @@
+/// <reference types="mocha" />
+
+import * as assert from 'power-assert'
+
+import { b64ByteLength } from '../src'
+import { toUint8Array } from '../src/lib/to_buffer'
+
+import { input8 } from './config'
+import { equal } from './helper'
+
+
+const filename = '20_to_buffer.test.ts'
+
+describe(filename, () => {
+  it('Should toUint8Array() works', () => {
+    input8.forEach(row => {
+      const input = row[1]
+      const actual = toUint8Array(input)
+      const expected = Uint8Array.from(row[0])
+
+      assert(equal(actual, expected), 'Ensure that ' + input + ' deserialise to ' + expected)
+      const byteLength = b64ByteLength(input)
+      assert(byteLength === expected.length, 'Ensure that ' + input + ' has byte lentgh of ' + expected.length)
+    })
+  })
+
+})