iw6-mod/deps/protobuf/js/experimental/runtime/bytestring_test.js
2024-02-27 01:34:37 -05:00

278 lines
9.8 KiB
JavaScript

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);
});
});