env/protobuf/js/experimental/runtime/bytestring_test.js

goog.module('proto.im.integration.ByteStringFieldsTest');
goog.setTestOnly();

const ByteString = goog.require('protobuf.ByteString');
const {arrayBufferSlice} = goog.require('protobuf.binary.typedArrays');

const /** !ArrayBuffer */ TEST_BYTES = new Uint8Array([1, 2, 3, 4]).buffer;
const /** !ByteString */ TEST_STRING = ByteString.fromArrayBuffer(TEST_BYTES);
const /** !ArrayBuffer */ PREFIXED_TEST_BYTES =
    new Uint8Array([0, 1, 2, 3, 4]).buffer;
const /** string */ HALLO_IN_BASE64 = 'aGFsbG8=';
const /** string */ HALLO_IN_BASE64_WITH_SPACES = 'a G F s b G 8=';
const /** !ArrayBufferView */ BYTES_WITH_HALLO = new Uint8Array([
  'h'.charCodeAt(0),
  'a'.charCodeAt(0),
  'l'.charCodeAt(0),
  'l'.charCodeAt(0),
  'o'.charCodeAt(0),
]);

describe('ByteString does', () => {
  it('create bytestring from buffer', () => {
    const byteString =
        ByteString.fromArrayBuffer(arrayBufferSlice(TEST_BYTES, 0));
    expect(byteString.toArrayBuffer()).toEqual(TEST_BYTES);
    expect(byteString.toUint8ArrayUnsafe()).toEqual(new Uint8Array(TEST_BYTES));
  });

  it('create bytestring from ArrayBufferView', () => {
    const byteString =
        ByteString.fromArrayBufferView(new Uint8Array(TEST_BYTES));
    expect(byteString.toArrayBuffer()).toEqual(TEST_BYTES);
    expect(byteString.toUint8ArrayUnsafe()).toEqual(new Uint8Array(TEST_BYTES));
  });

  it('create bytestring from subarray', () => {
    const byteString = ByteString.fromArrayBufferView(
        new Uint8Array(TEST_BYTES, /* offset */ 1, /* length */ 2));
    const expected = new Uint8Array([2, 3]);
    expect(new Uint8Array(byteString.toArrayBuffer())).toEqual(expected);
    expect(byteString.toUint8ArrayUnsafe()).toEqual(expected);
  });

  it('create bytestring from Uint8Array (unsafe)', () => {
    const array = new Uint8Array(TEST_BYTES);
    const byteString = ByteString.fromUint8ArrayUnsafe(array);
    expect(byteString.toArrayBuffer()).toEqual(array.buffer);
    expect(byteString.toUint8ArrayUnsafe()).toBe(array);
  });

  it('create bytestring from base64 string', () => {
    const byteString = ByteString.fromBase64String(HALLO_IN_BASE64);
    expect(byteString.toBase64String()).toEqual(HALLO_IN_BASE64);
    expect(byteString.toArrayBuffer()).toEqual(BYTES_WITH_HALLO.buffer);
    expect(byteString.toUint8ArrayUnsafe()).toEqual(BYTES_WITH_HALLO);
  });

  it('preserve immutability if underlying buffer changes: from buffer', () => {
    const buffer = new ArrayBuffer(4);
    const array = new Uint8Array(buffer);
    array[0] = 1;
    array[1] = 2;
    array[2] = 3;
    array[3] = 4;

    const byteString = ByteString.fromArrayBuffer(buffer);
    const otherBuffer = byteString.toArrayBuffer();

    expect(otherBuffer).not.toBe(buffer);
    expect(new Uint8Array(otherBuffer)).toEqual(array);

    // modify the original buffer
    array[0] = 5;
    // Are we still returning the original bytes?
    expect(new Uint8Array(byteString.toArrayBuffer())).toEqual(new Uint8Array([
      1, 2, 3, 4
    ]));
  });

  it('preserve immutability if underlying buffer changes: from ArrayBufferView',
     () => {
       const buffer = new ArrayBuffer(4);
       const array = new Uint8Array(buffer);
       array[0] = 1;
       array[1] = 2;
       array[2] = 3;
       array[3] = 4;

       const byteString = ByteString.fromArrayBufferView(array);
       const otherBuffer = byteString.toArrayBuffer();

       expect(otherBuffer).not.toBe(buffer);
       expect(new Uint8Array(otherBuffer)).toEqual(array);

       // modify the original buffer
       array[0] = 5;
       // Are we still returning the original bytes?
       expect(new Uint8Array(byteString.toArrayBuffer()))
           .toEqual(new Uint8Array([1, 2, 3, 4]));
     });

  it('mutate if underlying buffer changes: from Uint8Array (unsafe)', () => {
    const buffer = new ArrayBuffer(4);
    const array = new Uint8Array(buffer);
    array[0] = 1;
    array[1] = 2;
    array[2] = 3;
    array[3] = 4;

    const byteString = ByteString.fromUint8ArrayUnsafe(array);
    const otherBuffer = byteString.toArrayBuffer();

    expect(otherBuffer).not.toBe(buffer);
    expect(new Uint8Array(otherBuffer)).toEqual(array);

    // modify the original buffer
    array[0] = 5;
    // We are no longer returning the original bytes
    expect(new Uint8Array(byteString.toArrayBuffer())).toEqual(new Uint8Array([
      5, 2, 3, 4
    ]));
  });

  it('preserve immutability for returned buffers: toArrayBuffer', () => {
    const byteString = ByteString.fromArrayBufferView(new Uint8Array(4));
    const buffer1 = byteString.toArrayBuffer();
    const buffer2 = byteString.toArrayBuffer();

    expect(buffer1).toEqual(buffer2);

    const array1 = new Uint8Array(buffer1);
    array1[0] = 1;

    expect(buffer1).not.toEqual(buffer2);
  });

  it('does not preserve immutability for returned buffers: toUint8ArrayUnsafe',
     () => {
       const byteString = ByteString.fromUint8ArrayUnsafe(new Uint8Array(4));
       const array1 = byteString.toUint8ArrayUnsafe();
       const array2 = byteString.toUint8ArrayUnsafe();

       expect(array1).toEqual(array2);
       array1[0] = 1;

       expect(array1).toEqual(array2);
     });

  it('throws when created with null ArrayBufferView', () => {
    expect(
        () => ByteString.fromArrayBufferView(
            /** @type {!ArrayBufferView} */ (/** @type{*} */ (null))))
        .toThrow();
  });

  it('throws when created with null buffer', () => {
    expect(
        () => ByteString.fromBase64String(
            /** @type {string} */ (/** @type{*} */ (null))))
        .toThrow();
  });

  it('convert base64 to ArrayBuffer', () => {
    const other = ByteString.fromBase64String(HALLO_IN_BASE64);
    expect(BYTES_WITH_HALLO).toEqual(new Uint8Array(other.toArrayBuffer()));
  });

  it('convert base64 with spaces to ArrayBuffer', () => {
    const other = ByteString.fromBase64String(HALLO_IN_BASE64_WITH_SPACES);
    expect(new Uint8Array(other.toArrayBuffer())).toEqual(BYTES_WITH_HALLO);
  });

  it('convert bytes to base64', () => {
    const other = ByteString.fromArrayBufferView(BYTES_WITH_HALLO);
    expect(HALLO_IN_BASE64).toEqual(other.toBase64String());
  });

  it('equal empty bytetring', () => {
    const empty = ByteString.fromArrayBuffer(new ArrayBuffer(0));
    expect(ByteString.EMPTY.equals(empty)).toEqual(true);
  });

  it('equal empty bytestring constructed from ArrayBufferView', () => {
    const empty = ByteString.fromArrayBufferView(new Uint8Array(0));
    expect(ByteString.EMPTY.equals(empty)).toEqual(true);
  });

  it('equal empty bytestring constructed from Uint8Array (unsafe)', () => {
    const empty = ByteString.fromUint8ArrayUnsafe(new Uint8Array(0));
    expect(ByteString.EMPTY.equals(empty)).toEqual(true);
  });

  it('equal empty bytestring constructed from base64', () => {
    const empty = ByteString.fromBase64String('');
    expect(ByteString.EMPTY.equals(empty)).toEqual(true);
  });

  it('equal other instance', () => {
    const other = ByteString.fromArrayBuffer(arrayBufferSlice(TEST_BYTES, 0));
    expect(TEST_STRING.equals(other)).toEqual(true);
  });

  it('not equal different instance', () => {
    const other =
        ByteString.fromArrayBuffer(new Uint8Array([1, 2, 3, 4, 5]).buffer);
    expect(TEST_STRING.equals(other)).toEqual(false);
  });

  it('equal other instance constructed from ArrayBufferView', () => {
    const other =
        ByteString.fromArrayBufferView(new Uint8Array(PREFIXED_TEST_BYTES, 1));
    expect(TEST_STRING.equals(other)).toEqual(true);
  });

  it('not equal different instance constructed from ArrayBufferView', () => {
    const other =
        ByteString.fromArrayBufferView(new Uint8Array([1, 2, 3, 4, 5]));
    expect(TEST_STRING.equals(other)).toEqual(false);
  });

  it('equal other instance constructed from Uint8Array (unsafe)', () => {
    const other =
        ByteString.fromUint8ArrayUnsafe(new Uint8Array(PREFIXED_TEST_BYTES, 1));
    expect(TEST_STRING.equals(other)).toEqual(true);
  });

  it('not equal different instance constructed from Uint8Array (unsafe)',
     () => {
       const other =
           ByteString.fromUint8ArrayUnsafe(new Uint8Array([1, 2, 3, 4, 5]));
       expect(TEST_STRING.equals(other)).toEqual(false);
     });

  it('have same hashcode for empty bytes', () => {
    const empty = ByteString.fromArrayBuffer(new ArrayBuffer(0));
    expect(ByteString.EMPTY.hashCode()).toEqual(empty.hashCode());
  });

  it('have same hashcode for test bytes', () => {
    const other = ByteString.fromArrayBuffer(arrayBufferSlice(TEST_BYTES, 0));
    expect(TEST_STRING.hashCode()).toEqual(other.hashCode());
  });

  it('have same hashcode for test bytes', () => {
    const other = ByteString.fromArrayBufferView(
        new Uint8Array(arrayBufferSlice(TEST_BYTES, 0)));
    expect(TEST_STRING.hashCode()).toEqual(other.hashCode());
  });

  it('have same hashcode for different instance constructed with base64',
     () => {
       const other = ByteString.fromBase64String(HALLO_IN_BASE64);
       expect(ByteString.fromArrayBufferView(BYTES_WITH_HALLO).hashCode())
           .toEqual(other.hashCode());
     });

  it('preserves the length of a Uint8Array', () => {
    const original = new Uint8Array([105, 183, 51, 251, 253, 118, 247]);
    const afterByteString = new Uint8Array(
        ByteString.fromArrayBufferView(original).toArrayBuffer());
    expect(afterByteString).toEqual(original);
  });

  it('preserves the length of a base64 value', () => {
    const expected = new Uint8Array([105, 183, 51, 251, 253, 118, 247]);
    const afterByteString = new Uint8Array(
        ByteString.fromBase64String('abcz+/129w').toArrayBuffer());
    expect(afterByteString).toEqual(expected);
  });

  it('preserves the length of a base64 value with padding', () => {
    const expected = new Uint8Array([105, 183, 51, 251, 253, 118, 247]);
    const afterByteString = new Uint8Array(
        ByteString.fromBase64String('abcz+/129w==').toArrayBuffer());
    expect(afterByteString).toEqual(expected);
  });
});