|
|
@@ -0,0 +1,7443 @@
|
|
|
+/**
|
|
|
+ * @fileoverview Tests for repeated methods in lazy_accessor.js.
|
|
|
+ */
|
|
|
+goog.module('protobuf.binary.LazyAccessorTest');
|
|
|
+
|
|
|
+goog.setTestOnly();
|
|
|
+
|
|
|
+const ByteString = goog.require('protobuf.ByteString');
|
|
|
+const Int64 = goog.require('protobuf.Int64');
|
|
|
+const InternalMessage = goog.require('protobuf.binary.InternalMessage');
|
|
|
+const LazyAccessor = goog.require('protobuf.binary.LazyAccessor');
|
|
|
+const TestMessage = goog.require('protobuf.testing.binary.TestMessage');
|
|
|
+// Note to the reader:
|
|
|
+// Since the lazy accessor behavior changes with the checking level some of the
|
|
|
+// tests in this file have to know which checking level is enable to make
|
|
|
+// correct assertions.
|
|
|
+const {CHECK_CRITICAL_STATE} = goog.require('protobuf.internal.checks');
|
|
|
+
|
|
|
+/**
|
|
|
+ * @param {...number} bytes
|
|
|
+ * @return {!ArrayBuffer}
|
|
|
+ */
|
|
|
+function createArrayBuffer(...bytes) {
|
|
|
+ return new Uint8Array(bytes).buffer;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * Expects the Iterable instance yield the same values as the expected array.
|
|
|
+ * @param {!Iterable<T>} iterable
|
|
|
+ * @param {!Array<T>} expected
|
|
|
+ * @template T
|
|
|
+ * TODO: Implement this as a custom matcher.
|
|
|
+ */
|
|
|
+function expectEqualToArray(iterable, expected) {
|
|
|
+ const array = Array.from(iterable);
|
|
|
+ expect(array).toEqual(expected);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * Expects the Iterable instance yield qualified values.
|
|
|
+ * @param {!Iterable<T>} iterable
|
|
|
+ * @param {(function(T): boolean)=} verify
|
|
|
+ * @template T
|
|
|
+ */
|
|
|
+function expectQualifiedIterable(iterable, verify) {
|
|
|
+ if (verify) {
|
|
|
+ for (const value of iterable) {
|
|
|
+ expect(verify(value)).toBe(true);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * Expects the Iterable instance yield the same values as the expected array of
|
|
|
+ * messages.
|
|
|
+ * @param {!Iterable<!TestMessage>} iterable
|
|
|
+ * @param {!Array<!TestMessage>} expected
|
|
|
+ * @template T
|
|
|
+ * TODO: Implement this as a custom matcher.
|
|
|
+ */
|
|
|
+function expectEqualToMessageArray(iterable, expected) {
|
|
|
+ const array = Array.from(iterable);
|
|
|
+ expect(array.length).toEqual(expected.length);
|
|
|
+ for (let i = 0; i < array.length; i++) {
|
|
|
+ const value = array[i].getBoolWithDefault(1, false);
|
|
|
+ const expectedValue = expected[i].getBoolWithDefault(1, false);
|
|
|
+ expect(value).toBe(expectedValue);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated boolean does', () => {
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const list1 = accessor.getRepeatedBoolIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedBoolIterable(1);
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ expect(accessor.getRepeatedBoolSize(1)).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const bytes = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const bytes = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const list1 = accessor.getRepeatedBoolIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedBoolIterable(1);
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked multibytes values from the input', () => {
|
|
|
+ const bytes = createArrayBuffer(0x08, 0x80, 0x01, 0x08, 0x80, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ accessor.addUnpackedBoolElement(1, true);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true]);
|
|
|
+ accessor.addUnpackedBoolElement(1, false);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ accessor.addUnpackedBoolIterable(1, [true]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true]);
|
|
|
+ accessor.addUnpackedBoolIterable(1, [false]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return for setting single unpacked value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00, 0x08, 0x01));
|
|
|
+ accessor.setUnpackedBoolElement(1, 0, true);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, true]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ accessor.setUnpackedBoolIterable(1, [true]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true]);
|
|
|
+ accessor.setUnpackedBoolIterable(1, [false]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ accessor.addUnpackedBoolElement(1, true);
|
|
|
+ accessor.addUnpackedBoolElement(1, false);
|
|
|
+ expect(accessor.serialize()).toEqual(bytes);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ accessor.addUnpackedBoolIterable(1, [true, false]);
|
|
|
+ expect(accessor.serialize()).toEqual(bytes);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x02, 0x00, 0x01));
|
|
|
+ const bytes = createArrayBuffer(0x08, 0x01, 0x08, 0x01);
|
|
|
+ accessor.setUnpackedBoolElement(1, 0, true);
|
|
|
+ expect(accessor.serialize()).toEqual(bytes);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ accessor.setUnpackedBoolIterable(1, [true, false]);
|
|
|
+ expect(accessor.serialize()).toEqual(bytes);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const list1 = accessor.getRepeatedBoolIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedBoolIterable(1);
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed multibytes values from the input', () => {
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x04, 0x80, 0x01, 0x80, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ accessor.addPackedBoolElement(1, true);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true]);
|
|
|
+ accessor.addPackedBoolElement(1, false);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ accessor.addPackedBoolIterable(1, [true]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true]);
|
|
|
+ accessor.addPackedBoolIterable(1, [false]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return for setting single packed value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00, 0x08, 0x01));
|
|
|
+ accessor.setPackedBoolElement(1, 0, true);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, true]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ accessor.setPackedBoolIterable(1, [true]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true]);
|
|
|
+ accessor.setPackedBoolIterable(1, [false]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ accessor.addPackedBoolElement(1, true);
|
|
|
+ accessor.addPackedBoolElement(1, false);
|
|
|
+ expect(accessor.serialize()).toEqual(bytes);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ accessor.addPackedBoolIterable(1, [true, false]);
|
|
|
+ expect(accessor.serialize()).toEqual(bytes);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00, 0x08, 0x01));
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x01, 0x01);
|
|
|
+ accessor.setPackedBoolElement(1, 0, true);
|
|
|
+ expect(accessor.serialize()).toEqual(bytes);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ accessor.setPackedBoolIterable(1, [true, false]);
|
|
|
+ expect(accessor.serialize()).toEqual(bytes);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const bytes =
|
|
|
+ createArrayBuffer(0x08, 0x01, 0x0A, 0x02, 0x01, 0x00, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expectEqualToArray(
|
|
|
+ accessor.getRepeatedBoolIterable(1), [true, true, false, false]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const bytes = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expect(accessor.getRepeatedBoolElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toEqual(true);
|
|
|
+ expect(accessor.getRepeatedBoolElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1))
|
|
|
+ .toEqual(false);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const bytes = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expect(accessor.getRepeatedBoolSize(1)).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked bool value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedBoolIterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 0 but found: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked bool values with number value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeBoolean = /** @type {boolean} */ (/** @type {*} */ (2));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedBoolIterable(1, [fakeBoolean]))
|
|
|
+ .toThrowError('Must be a boolean, but got: 2');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedBoolIterable(1, [fakeBoolean]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [fakeBoolean]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked bool value with number value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeBoolean = /** @type {boolean} */ (/** @type {*} */ (2));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedBoolElement(1, fakeBoolean))
|
|
|
+ .toThrowError('Must be a boolean, but got: 2');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedBoolElement(1, fakeBoolean);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [fakeBoolean]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked bool values with number value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeBoolean = /** @type {boolean} */ (/** @type {*} */ (2));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedBoolIterable(1, [fakeBoolean]))
|
|
|
+ .toThrowError('Must be a boolean, but got: 2');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedBoolIterable(1, [fakeBoolean]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [fakeBoolean]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked bool value with number value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ const fakeBoolean = /** @type {boolean} */ (/** @type {*} */ (2));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedBoolElement(1, 0, fakeBoolean))
|
|
|
+ .toThrowError('Must be a boolean, but got: 2');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedBoolElement(1, 0, fakeBoolean);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [fakeBoolean]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed bool values with number value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeBoolean = /** @type {boolean} */ (/** @type {*} */ (2));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedBoolIterable(1, [fakeBoolean]))
|
|
|
+ .toThrowError('Must be a boolean, but got: 2');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedBoolIterable(1, [fakeBoolean]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [fakeBoolean]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed bool value with number value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeBoolean = /** @type {boolean} */ (/** @type {*} */ (2));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedBoolElement(1, fakeBoolean))
|
|
|
+ .toThrowError('Must be a boolean, but got: 2');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedBoolElement(1, fakeBoolean);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [fakeBoolean]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed bool values with number value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeBoolean = /** @type {boolean} */ (/** @type {*} */ (2));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedBoolIterable(1, [fakeBoolean]))
|
|
|
+ .toThrowError('Must be a boolean, but got: 2');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedBoolIterable(1, [fakeBoolean]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [fakeBoolean]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed bool value with number value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ const fakeBoolean = /** @type {boolean} */ (/** @type {*} */ (2));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedBoolElement(1, 0, fakeBoolean))
|
|
|
+ .toThrowError('Must be a boolean, but got: 2');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedBoolElement(1, 0, fakeBoolean);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [fakeBoolean]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedBoolElement(1, 1, true))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedBoolElement(1, 1, true);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [false, true]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedBoolElement(1, 1, true))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedBoolElement(1, 1, true);
|
|
|
+ expectEqualToArray(accessor.getRepeatedBoolIterable(1), [false, true]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedBoolElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedBoolElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated double does', () => {
|
|
|
+ const value1 = 1;
|
|
|
+ const value2 = 0;
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0xF0,
|
|
|
+ 0x3F, // value1
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ );
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0xF0,
|
|
|
+ 0x3F, // value2
|
|
|
+ );
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x10, // tag
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0xF0,
|
|
|
+ 0x3F, // value1
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ );
|
|
|
+ const packedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x10, // tag
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0xF0,
|
|
|
+ 0x3F, // value2
|
|
|
+ );
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedDoubleSize(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedDoubleElement(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+ accessor.addUnpackedDoubleElement(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedDoubleIterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+ accessor.addUnpackedDoubleIterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedDoubleElement(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedDoubleIterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedDoubleElement(1, value1);
|
|
|
+ accessor.addUnpackedDoubleElement(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedDoubleIterable(1, [value1]);
|
|
|
+ accessor.addUnpackedDoubleIterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedDoubleElement(1, 0, value2);
|
|
|
+ accessor.setUnpackedDoubleElement(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedDoubleIterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedDoubleElement(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+ accessor.addPackedDoubleElement(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedDoubleIterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+ accessor.addPackedDoubleIterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedDoubleElement(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedDoubleIterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+ accessor.setPackedDoubleIterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedDoubleElement(1, value1);
|
|
|
+ accessor.addPackedDoubleElement(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedDoubleIterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedDoubleElement(1, 0, value2);
|
|
|
+ accessor.setPackedDoubleElement(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedDoubleIterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0xF0,
|
|
|
+ 0x3F, // value1
|
|
|
+ 0x0A,
|
|
|
+ 0x10, // tag
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0xF0,
|
|
|
+ 0x3F, // value1
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedDoubleElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedDoubleElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedDoubleSize(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked double value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedDoubleIterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 1 but found: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectEqualToArray(
|
|
|
+ accessor.getRepeatedDoubleIterable(1), [2.937446524422997e-306]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked double values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeDouble = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedDoubleIterable(1, [fakeDouble]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedDoubleIterable(1, [fakeDouble]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [fakeDouble]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked double value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeDouble = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedDoubleElement(1, fakeDouble))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedDoubleElement(1, fakeDouble);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [fakeDouble]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked double values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeDouble = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedDoubleIterable(1, [fakeDouble]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedDoubleIterable(1, [fakeDouble]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [fakeDouble]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked double value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeDouble = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedDoubleElement(1, 0, fakeDouble))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedDoubleElement(1, 0, fakeDouble);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [fakeDouble]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed double values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeDouble = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedDoubleIterable(1, [fakeDouble]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedDoubleIterable(1, [fakeDouble]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [fakeDouble]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed double value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeDouble = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedDoubleElement(1, fakeDouble))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedDoubleElement(1, fakeDouble);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [fakeDouble]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed double values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeDouble = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedDoubleIterable(1, [fakeDouble]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedDoubleIterable(1, [fakeDouble]);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [fakeDouble]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed double value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ const fakeDouble = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedDoubleElement(1, 0, fakeDouble))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedDoubleElement(1, 0, fakeDouble);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [fakeDouble]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedDoubleElement(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedDoubleElement(1, 1, 1);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [0, 1]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedDoubleElement(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedDoubleElement(1, 1, 1);
|
|
|
+ expectEqualToArray(accessor.getRepeatedDoubleIterable(1), [0, 1]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedDoubleElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedDoubleElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated fixed32 does', () => {
|
|
|
+ const value1 = 1;
|
|
|
+ const value2 = 0;
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0D, 0x01, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00);
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0D, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x01, 0x00, 0x00, 0x00);
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0A, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
|
|
|
+ const packedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0A, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00);
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedFixed32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFixed32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+ accessor.addUnpackedFixed32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFixed32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+ accessor.addUnpackedFixed32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedFixed32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedFixed32Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFixed32Element(1, value1);
|
|
|
+ accessor.addUnpackedFixed32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFixed32Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedFixed32Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedFixed32Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedFixed32Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedFixed32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFixed32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+ accessor.addPackedFixed32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFixed32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+ accessor.addPackedFixed32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedFixed32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedFixed32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+ accessor.setPackedFixed32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFixed32Element(1, value1);
|
|
|
+ accessor.addPackedFixed32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFixed32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedFixed32Element(1, 0, value2);
|
|
|
+ accessor.setPackedFixed32Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedFixed32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x0D,
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x0A,
|
|
|
+ 0x08, // tag
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ 0x0D,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedFixed32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedFixed32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedFixed32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked fixed32 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x08, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedFixed32Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 5 but found: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFixed32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked fixed32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedFixed32Iterable(1, [fakeFixed32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedFixed32Iterable(1, [fakeFixed32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked fixed32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedFixed32Element(1, fakeFixed32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedFixed32Element(1, fakeFixed32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked fixed32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedFixed32Iterable(1, [fakeFixed32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedFixed32Iterable(1, [fakeFixed32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked fixed32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x08, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeFixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedFixed32Element(1, 0, fakeFixed32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedFixed32Element(1, 0, fakeFixed32);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFixed32Iterable(1),
|
|
|
+ );
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed fixed32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedFixed32Iterable(1, [fakeFixed32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedFixed32Iterable(1, [fakeFixed32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed fixed32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedFixed32Element(1, fakeFixed32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedFixed32Element(1, fakeFixed32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed fixed32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedFixed32Iterable(1, [fakeFixed32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedFixed32Iterable(1, [fakeFixed32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed fixed32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ const fakeFixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedFixed32Element(1, 0, fakeFixed32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedFixed32Element(1, 0, fakeFixed32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0A, 0x04, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedFixed32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedFixed32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFixed32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedFixed32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedFixed32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFixed32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedFixed32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedFixed32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated fixed64 does', () => {
|
|
|
+ const value1 = Int64.fromInt(1);
|
|
|
+ const value2 = Int64.fromInt(0);
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x09,
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ );
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x09,
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ );
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x10, // tag
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ );
|
|
|
+ const packedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x10, // tag
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ );
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedFixed64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFixed64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+ accessor.addUnpackedFixed64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFixed64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+ accessor.addUnpackedFixed64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedFixed64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedFixed64Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFixed64Element(1, value1);
|
|
|
+ accessor.addUnpackedFixed64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFixed64Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedFixed64Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedFixed64Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedFixed64Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedFixed64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFixed64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+ accessor.addPackedFixed64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFixed64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+ accessor.addPackedFixed64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedFixed64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedFixed64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+ accessor.setPackedFixed64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFixed64Element(1, value1);
|
|
|
+ accessor.addPackedFixed64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFixed64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedFixed64Element(1, 0, value2);
|
|
|
+ accessor.setPackedFixed64Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedFixed64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // value1
|
|
|
+ 0x0A, 0x10, // tag
|
|
|
+ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // value1
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // value2
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedFixed64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedFixed64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedFixed64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked fixed64 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedFixed64Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 1 but found: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFixed64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked fixed64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedFixed64Iterable(1, [fakeFixed64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedFixed64Iterable(1, [fakeFixed64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked fixed64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedFixed64Element(1, fakeFixed64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedFixed64Element(1, fakeFixed64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked fixed64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedFixed64Iterable(1, [fakeFixed64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedFixed64Iterable(1, [fakeFixed64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked fixed64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeFixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedFixed64Element(1, 0, fakeFixed64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedFixed64Element(1, 0, fakeFixed64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed fixed64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedFixed64Iterable(1, [fakeFixed64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedFixed64Iterable(1, [fakeFixed64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed fixed64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedFixed64Element(1, fakeFixed64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedFixed64Element(1, fakeFixed64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed fixed64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedFixed64Iterable(1, [fakeFixed64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedFixed64Iterable(1, [fakeFixed64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed fixed64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ const fakeFixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedFixed64Element(1, 0, fakeFixed64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedFixed64Element(1, 0, fakeFixed64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedFixed64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedFixed64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFixed64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedFixed64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedFixed64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFixed64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedFixed64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedFixed64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated float does', () => {
|
|
|
+ const value1 = 1.6;
|
|
|
+ const value1Float = Math.fround(1.6);
|
|
|
+ const value2 = 0;
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0D, 0xCD, 0xCC, 0xCC, 0x3F, 0x0D, 0x00, 0x00, 0x00, 0x00);
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0D, 0x00, 0x00, 0x00, 0x00, 0x0D, 0xCD, 0xCC, 0xCC, 0x3F);
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0A, 0x08, 0xCD, 0xCC, 0xCC, 0x3F, 0x00, 0x00, 0x00, 0x00);
|
|
|
+ const packedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0A, 0x08, 0x00, 0x00, 0x00, 0x00, 0xCD, 0xCC, 0xCC, 0x3F);
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedFloatIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedFloatSize(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1Float, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedFloatIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFloatElement(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedFloatIterable(1);
|
|
|
+ accessor.addUnpackedFloatElement(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1Float]);
|
|
|
+ expectEqualToArray(list2, [value1Float, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFloatIterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedFloatIterable(1);
|
|
|
+ accessor.addUnpackedFloatIterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1Float]);
|
|
|
+ expectEqualToArray(list2, [value1Float, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedFloatElement(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1Float, value1Float]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedFloatIterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1Float]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFloatElement(1, value1);
|
|
|
+ accessor.addUnpackedFloatElement(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedFloatIterable(1, [value1]);
|
|
|
+ accessor.addUnpackedFloatIterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedFloatElement(1, 0, value2);
|
|
|
+ accessor.setUnpackedFloatElement(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedFloatIterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1Float, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedFloatIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFloatElement(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedFloatIterable(1);
|
|
|
+ accessor.addPackedFloatElement(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1Float]);
|
|
|
+ expectEqualToArray(list2, [value1Float, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFloatIterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedFloatIterable(1);
|
|
|
+ accessor.addPackedFloatIterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1Float]);
|
|
|
+ expectEqualToArray(list2, [value1Float, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedFloatElement(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1Float, value1Float]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedFloatIterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedFloatIterable(1);
|
|
|
+ accessor.setPackedFloatIterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1Float]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFloatElement(1, value1);
|
|
|
+ accessor.addPackedFloatElement(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedFloatIterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedFloatElement(1, 0, value2);
|
|
|
+ accessor.setPackedFloatElement(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedFloatIterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x0D,
|
|
|
+ 0xCD,
|
|
|
+ 0xCC,
|
|
|
+ 0xCC,
|
|
|
+ 0x3F, // value1
|
|
|
+ 0x0A,
|
|
|
+ 0x08, // tag
|
|
|
+ 0xCD,
|
|
|
+ 0xCC,
|
|
|
+ 0xCC,
|
|
|
+ 0x3F, // value1
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ 0x0D,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedFloatIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1Float, value1Float, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedFloatElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedFloatElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1Float);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedFloatSize(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked float value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x08, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedFloatIterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 5 but found: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFloatIterable(1),
|
|
|
+ (value) => typeof value === 'number');
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked float values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFloat = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedFloatIterable(1, [fakeFloat]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedFloatIterable(1, [fakeFloat]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFloatIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked float value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFloat = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedFloatElement(1, fakeFloat))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedFloatElement(1, fakeFloat);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFloatIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked float values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFloat = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedFloatIterable(1, [fakeFloat]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedFloatIterable(1, [fakeFloat]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFloatIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked float value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x08, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeFloat = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedFloatElement(1, 0, fakeFloat))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedFloatElement(1, 0, fakeFloat);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFloatIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed float values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFloat = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedFloatIterable(1, [fakeFloat]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedFloatIterable(1, [fakeFloat]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFloatIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed float value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFloat = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedFloatElement(1, fakeFloat))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedFloatElement(1, fakeFloat);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFloatIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed float values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeFloat = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedFloatIterable(1, [fakeFloat]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedFloatIterable(1, [fakeFloat]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFloatIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed float value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ const fakeFloat = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedFloatElement(1, 0, fakeFloat))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedFloatElement(1, 0, fakeFloat);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedFloatIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedFloatElement(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedFloatElement(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFloatIterable(1),
|
|
|
+ (value) => typeof value === 'number');
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedFloatElement(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedFloatElement(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedFloatIterable(1),
|
|
|
+ (value) => typeof value === 'number');
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedFloatElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedFloatElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated int32 does', () => {
|
|
|
+ const value1 = 1;
|
|
|
+ const value2 = 0;
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(0x08, 0x00, 0x08, 0x01);
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ const packedValue2Value1 = createArrayBuffer(0x0A, 0x02, 0x00, 0x01);
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedInt32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedInt32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+ accessor.addUnpackedInt32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedInt32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+ accessor.addUnpackedInt32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedInt32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedInt32Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedInt32Element(1, value1);
|
|
|
+ accessor.addUnpackedInt32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedInt32Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedInt32Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedInt32Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedInt32Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedInt32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedInt32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+ accessor.addPackedInt32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedInt32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+ accessor.addPackedInt32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedInt32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedInt32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+ accessor.setPackedInt32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedInt32Element(1, value1);
|
|
|
+ accessor.addPackedInt32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedInt32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedInt32Element(1, 0, value2);
|
|
|
+ accessor.setPackedInt32Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedInt32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08,
|
|
|
+ 0x01, // unpacked value1
|
|
|
+ 0x0A,
|
|
|
+ 0x02,
|
|
|
+ 0x01,
|
|
|
+ 0x00, // packed value1 and value2
|
|
|
+ 0x08,
|
|
|
+ 0x00, // unpacked value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedInt32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedInt32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedInt32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked int32 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedInt32Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 0 but found: 5');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedInt32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked int32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedInt32Iterable(1, [fakeInt32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedInt32Iterable(1, [fakeInt32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked int32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedInt32Element(1, fakeInt32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedInt32Element(1, fakeInt32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked int32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedInt32Iterable(1, [fakeInt32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedInt32Iterable(1, [fakeInt32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked int32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeInt32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedInt32Element(1, 0, fakeInt32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedInt32Element(1, 0, fakeInt32);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedInt32Iterable(1),
|
|
|
+ );
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed int32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedInt32Iterable(1, [fakeInt32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedInt32Iterable(1, [fakeInt32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed int32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedInt32Element(1, fakeInt32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedInt32Element(1, fakeInt32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed int32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedInt32Iterable(1, [fakeInt32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedInt32Iterable(1, [fakeInt32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed int32 value with null value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ const fakeInt32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedInt32Element(1, 0, fakeInt32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedInt32Element(1, 0, fakeInt32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x01, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedInt32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedInt32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedInt32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedInt32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedInt32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedInt32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedInt32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedInt32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated int64 does', () => {
|
|
|
+ const value1 = Int64.fromInt(1);
|
|
|
+ const value2 = Int64.fromInt(0);
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(0x08, 0x00, 0x08, 0x01);
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ const packedValue2Value1 = createArrayBuffer(0x0A, 0x02, 0x00, 0x01);
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedInt64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedInt64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+ accessor.addUnpackedInt64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedInt64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+ accessor.addUnpackedInt64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedInt64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedInt64Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedInt64Element(1, value1);
|
|
|
+ accessor.addUnpackedInt64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedInt64Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedInt64Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedInt64Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedInt64Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedInt64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedInt64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+ accessor.addPackedInt64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedInt64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+ accessor.addPackedInt64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedInt64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedInt64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+ accessor.setPackedInt64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedInt64Element(1, value1);
|
|
|
+ accessor.addPackedInt64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedInt64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedInt64Element(1, 0, value2);
|
|
|
+ accessor.setPackedInt64Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedInt64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08,
|
|
|
+ 0x01, // unpacked value1
|
|
|
+ 0x0A,
|
|
|
+ 0x02,
|
|
|
+ 0x01,
|
|
|
+ 0x00, // packed value1 and value2
|
|
|
+ 0x08,
|
|
|
+ 0x00, // unpacked value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedInt64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedInt64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedInt64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked int64 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedInt64Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 0 but found: 5');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedInt64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked int64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedInt64Iterable(1, [fakeInt64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedInt64Iterable(1, [fakeInt64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked int64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedInt64Element(1, fakeInt64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedInt64Element(1, fakeInt64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked int64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedInt64Iterable(1, [fakeInt64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedInt64Iterable(1, [fakeInt64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked int64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeInt64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedInt64Element(1, 0, fakeInt64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedInt64Element(1, 0, fakeInt64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed int64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedInt64Iterable(1, [fakeInt64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedInt64Iterable(1, [fakeInt64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed int64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedInt64Element(1, fakeInt64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedInt64Element(1, fakeInt64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed int64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeInt64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedInt64Iterable(1, [fakeInt64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedInt64Iterable(1, [fakeInt64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed int64 value with null value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ const fakeInt64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedInt64Element(1, 0, fakeInt64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedInt64Element(1, 0, fakeInt64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedInt64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x01, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedInt64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedInt64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedInt64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedInt64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedInt64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedInt64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedInt64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedInt64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated sfixed32 does', () => {
|
|
|
+ const value1 = 1;
|
|
|
+ const value2 = 0;
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0D, 0x01, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00);
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0D, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x01, 0x00, 0x00, 0x00);
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0A, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
|
|
|
+ const packedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0A, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00);
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedSfixed32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSfixed32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+ accessor.addUnpackedSfixed32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSfixed32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+ accessor.addUnpackedSfixed32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedSfixed32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedSfixed32Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSfixed32Element(1, value1);
|
|
|
+ accessor.addUnpackedSfixed32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSfixed32Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedSfixed32Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedSfixed32Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedSfixed32Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedSfixed32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSfixed32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+ accessor.addPackedSfixed32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSfixed32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+ accessor.addPackedSfixed32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedSfixed32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedSfixed32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+ accessor.setPackedSfixed32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSfixed32Element(1, value1);
|
|
|
+ accessor.addPackedSfixed32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSfixed32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedSfixed32Element(1, 0, value2);
|
|
|
+ accessor.setPackedSfixed32Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedSfixed32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x0D,
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x0A,
|
|
|
+ 0x08, // tag
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ 0x0D,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedSfixed32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedSfixed32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedSfixed32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked sfixed32 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x08, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedSfixed32Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 5 but found: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSfixed32Iterable(1),
|
|
|
+ (value) => typeof value === 'number');
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked sfixed32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedSfixed32Iterable(1, [fakeSfixed32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedSfixed32Iterable(1, [fakeSfixed32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked sfixed32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedSfixed32Element(1, fakeSfixed32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedSfixed32Element(1, fakeSfixed32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked sfixed32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSfixed32Iterable(1, [fakeSfixed32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSfixed32Iterable(1, [fakeSfixed32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked sfixed32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x08, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeSfixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSfixed32Element(1, 0, fakeSfixed32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSfixed32Element(1, 0, fakeSfixed32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed sfixed32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedSfixed32Iterable(1, [fakeSfixed32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedSfixed32Iterable(1, [fakeSfixed32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed sfixed32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedSfixed32Element(1, fakeSfixed32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedSfixed32Element(1, fakeSfixed32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed sfixed32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSfixed32Iterable(1, [fakeSfixed32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSfixed32Iterable(1, [fakeSfixed32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed sfixed32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ const fakeSfixed32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSfixed32Element(1, 0, fakeSfixed32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSfixed32Element(1, 0, fakeSfixed32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSfixed32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSfixed32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSfixed32Iterable(1),
|
|
|
+ (value) => typeof value === 'number');
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSfixed32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSfixed32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSfixed32Iterable(1),
|
|
|
+ (value) => typeof value === 'number');
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedSfixed32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedSfixed32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated sfixed64 does', () => {
|
|
|
+ const value1 = Int64.fromInt(1);
|
|
|
+ const value2 = Int64.fromInt(0);
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x09,
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ );
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x09,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x09,
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ );
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x10, // tag
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ );
|
|
|
+ const packedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x10, // tag
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value2
|
|
|
+ 0x01,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00,
|
|
|
+ 0x00, // value1
|
|
|
+ );
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedSfixed64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSfixed64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+ accessor.addUnpackedSfixed64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSfixed64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+ accessor.addUnpackedSfixed64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedSfixed64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedSfixed64Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSfixed64Element(1, value1);
|
|
|
+ accessor.addUnpackedSfixed64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSfixed64Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedSfixed64Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedSfixed64Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedSfixed64Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedSfixed64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSfixed64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+ accessor.addPackedSfixed64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSfixed64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+ accessor.addPackedSfixed64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedSfixed64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedSfixed64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+ accessor.setPackedSfixed64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSfixed64Element(1, value1);
|
|
|
+ accessor.addPackedSfixed64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSfixed64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedSfixed64Element(1, 0, value2);
|
|
|
+ accessor.setPackedSfixed64Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedSfixed64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // value1
|
|
|
+ 0x0A, 0x10, // tag
|
|
|
+ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // value1
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // value2
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedSfixed64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedSfixed64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedSfixed64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked sfixed64 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedSfixed64Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 1 but found: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSfixed64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked sfixed64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedSfixed64Iterable(1, [fakeSfixed64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedSfixed64Iterable(1, [fakeSfixed64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked sfixed64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedSfixed64Element(1, fakeSfixed64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedSfixed64Element(1, fakeSfixed64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked sfixed64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSfixed64Iterable(1, [fakeSfixed64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSfixed64Iterable(1, [fakeSfixed64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked sfixed64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeSfixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSfixed64Element(1, 0, fakeSfixed64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSfixed64Element(1, 0, fakeSfixed64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed sfixed64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedSfixed64Iterable(1, [fakeSfixed64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedSfixed64Iterable(1, [fakeSfixed64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed sfixed64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedSfixed64Element(1, fakeSfixed64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedSfixed64Element(1, fakeSfixed64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed sfixed64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSfixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSfixed64Iterable(1, [fakeSfixed64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSfixed64Iterable(1, [fakeSfixed64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed sfixed64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ const fakeSfixed64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSfixed64Element(1, 0, fakeSfixed64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSfixed64Element(1, 0, fakeSfixed64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSfixed64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSfixed64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSfixed64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSfixed64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSfixed64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSfixed64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSfixed64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedSfixed64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedSfixed64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated sint32 does', () => {
|
|
|
+ const value1 = -1;
|
|
|
+ const value2 = 0;
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(0x08, 0x00, 0x08, 0x01);
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ const packedValue2Value1 = createArrayBuffer(0x0A, 0x02, 0x00, 0x01);
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedSint32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSint32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+ accessor.addUnpackedSint32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSint32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+ accessor.addUnpackedSint32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedSint32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedSint32Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSint32Element(1, value1);
|
|
|
+ accessor.addUnpackedSint32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSint32Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedSint32Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedSint32Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedSint32Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedSint32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSint32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+ accessor.addPackedSint32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSint32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+ accessor.addPackedSint32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedSint32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedSint32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+ accessor.setPackedSint32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSint32Element(1, value1);
|
|
|
+ accessor.addPackedSint32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSint32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedSint32Element(1, 0, value2);
|
|
|
+ accessor.setPackedSint32Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedSint32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08,
|
|
|
+ 0x01, // unpacked value1
|
|
|
+ 0x0A,
|
|
|
+ 0x02,
|
|
|
+ 0x01,
|
|
|
+ 0x00, // packed value1 and value2
|
|
|
+ 0x08,
|
|
|
+ 0x00, // unpacked value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedSint32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedSint32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedSint32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked sint32 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedSint32Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 0 but found: 5');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSint32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked sint32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedSint32Iterable(1, [fakeSint32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedSint32Iterable(1, [fakeSint32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked sint32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedSint32Element(1, fakeSint32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedSint32Element(1, fakeSint32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked sint32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSint32Iterable(1, [fakeSint32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSint32Iterable(1, [fakeSint32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked sint32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeSint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSint32Element(1, 0, fakeSint32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSint32Element(1, 0, fakeSint32);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSint32Iterable(1),
|
|
|
+ );
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed sint32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedSint32Iterable(1, [fakeSint32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedSint32Iterable(1, [fakeSint32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed sint32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedSint32Element(1, fakeSint32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedSint32Element(1, fakeSint32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed sint32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSint32Iterable(1, [fakeSint32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSint32Iterable(1, [fakeSint32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed sint32 value with null value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ const fakeSint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSint32Element(1, 0, fakeSint32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSint32Element(1, 0, fakeSint32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x01, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSint32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSint32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSint32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSint32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSint32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSint32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedSint32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedSint32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated sint64 does', () => {
|
|
|
+ const value1 = Int64.fromInt(-1);
|
|
|
+ const value2 = Int64.fromInt(0);
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(0x08, 0x00, 0x08, 0x01);
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ const packedValue2Value1 = createArrayBuffer(0x0A, 0x02, 0x00, 0x01);
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedSint64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSint64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+ accessor.addUnpackedSint64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSint64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+ accessor.addUnpackedSint64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedSint64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedSint64Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSint64Element(1, value1);
|
|
|
+ accessor.addUnpackedSint64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedSint64Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedSint64Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedSint64Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedSint64Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedSint64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSint64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+ accessor.addPackedSint64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSint64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+ accessor.addPackedSint64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedSint64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedSint64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+ accessor.setPackedSint64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSint64Element(1, value1);
|
|
|
+ accessor.addPackedSint64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedSint64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedSint64Element(1, 0, value2);
|
|
|
+ accessor.setPackedSint64Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedSint64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08,
|
|
|
+ 0x01, // unpacked value1
|
|
|
+ 0x0A,
|
|
|
+ 0x02,
|
|
|
+ 0x01,
|
|
|
+ 0x00, // packed value1 and value2
|
|
|
+ 0x08,
|
|
|
+ 0x00, // unpacked value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedSint64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedSint64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedSint64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked sint64 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedSint64Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 0 but found: 5');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSint64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked sint64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedSint64Iterable(1, [fakeSint64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedSint64Iterable(1, [fakeSint64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked sint64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedSint64Element(1, fakeSint64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedSint64Element(1, fakeSint64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked sint64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSint64Iterable(1, [fakeSint64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSint64Iterable(1, [fakeSint64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked sint64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeSint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSint64Element(1, 0, fakeSint64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSint64Element(1, 0, fakeSint64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed sint64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedSint64Iterable(1, [fakeSint64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedSint64Iterable(1, [fakeSint64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed sint64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedSint64Element(1, fakeSint64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedSint64Element(1, fakeSint64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed sint64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeSint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSint64Iterable(1, [fakeSint64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSint64Iterable(1, [fakeSint64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed sint64 value with null value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ const fakeSint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSint64Element(1, 0, fakeSint64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSint64Element(1, 0, fakeSint64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedSint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x01, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedSint64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedSint64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSint64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedSint64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedSint64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedSint64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedSint64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedSint64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated uint32 does', () => {
|
|
|
+ const value1 = 1;
|
|
|
+ const value2 = 0;
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(0x08, 0x00, 0x08, 0x01);
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ const packedValue2Value1 = createArrayBuffer(0x0A, 0x02, 0x00, 0x01);
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedUint32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedUint32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+ accessor.addUnpackedUint32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedUint32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+ accessor.addUnpackedUint32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedUint32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedUint32Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedUint32Element(1, value1);
|
|
|
+ accessor.addUnpackedUint32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedUint32Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedUint32Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedUint32Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedUint32Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedUint32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedUint32Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+ accessor.addPackedUint32Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedUint32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+ accessor.addPackedUint32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedUint32Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedUint32Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+ accessor.setPackedUint32Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedUint32Element(1, value1);
|
|
|
+ accessor.addPackedUint32Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedUint32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedUint32Element(1, 0, value2);
|
|
|
+ accessor.setPackedUint32Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedUint32Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08,
|
|
|
+ 0x01, // unpacked value1
|
|
|
+ 0x0A,
|
|
|
+ 0x02,
|
|
|
+ 0x01,
|
|
|
+ 0x00, // packed value1 and value2
|
|
|
+ 0x08,
|
|
|
+ 0x00, // unpacked value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedUint32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedUint32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedUint32Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked uint32 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedUint32Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 0 but found: 5');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedUint32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked uint32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedUint32Iterable(1, [fakeUint32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedUint32Iterable(1, [fakeUint32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked uint32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedUint32Element(1, fakeUint32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedUint32Element(1, fakeUint32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked uint32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedUint32Iterable(1, [fakeUint32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedUint32Iterable(1, [fakeUint32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked uint32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeUint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedUint32Element(1, 0, fakeUint32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedUint32Element(1, 0, fakeUint32);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedUint32Iterable(1),
|
|
|
+ );
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed uint32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedUint32Iterable(1, [fakeUint32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedUint32Iterable(1, [fakeUint32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed uint32 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedUint32Element(1, fakeUint32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedUint32Element(1, fakeUint32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed uint32 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedUint32Iterable(1, [fakeUint32]))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedUint32Iterable(1, [fakeUint32]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed uint32 value with null value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ const fakeUint32 = /** @type {number} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedUint32Element(1, 0, fakeUint32))
|
|
|
+ .toThrowError('Must be a number, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedUint32Element(1, 0, fakeUint32);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint32Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x01, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedUint32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedUint32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedUint32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedUint32Element(1, 1, 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedUint32Element(1, 1, 1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedUint32Iterable(1),
|
|
|
+ (value) => Number.isInteger(value));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedUint32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedUint32Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated uint64 does', () => {
|
|
|
+ const value1 = Int64.fromInt(1);
|
|
|
+ const value2 = Int64.fromInt(0);
|
|
|
+
|
|
|
+ const unpackedValue1Value2 = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
|
+ const unpackedValue2Value1 = createArrayBuffer(0x08, 0x00, 0x08, 0x01);
|
|
|
+
|
|
|
+ const packedValue1Value2 = createArrayBuffer(0x0A, 0x02, 0x01, 0x00);
|
|
|
+ const packedValue2Value1 = createArrayBuffer(0x0A, 0x02, 0x00, 0x01);
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedUint64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return unpacked values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedUint64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+ accessor.addUnpackedUint64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedUint64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+ accessor.addUnpackedUint64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedUint64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedUint64Iterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedUint64Element(1, value1);
|
|
|
+ accessor.addUnpackedUint64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addUnpackedUint64Iterable(1, [value1]);
|
|
|
+ accessor.addUnpackedUint64Iterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single unpacked value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setUnpackedUint64Element(1, 0, value2);
|
|
|
+ accessor.setUnpackedUint64Element(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting unpacked values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setUnpackedUint64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(unpackedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return packed values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for packed values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(packedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+ const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedUint64Element(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+ accessor.addPackedUint64Element(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedUint64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+ accessor.addPackedUint64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedUint64Element(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedUint64Iterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+ accessor.setPackedUint64Iterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedUint64Element(1, value1);
|
|
|
+ accessor.addPackedUint64Element(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addPackedUint64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single packed value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setPackedUint64Element(1, 0, value2);
|
|
|
+ accessor.setPackedUint64Element(1, 1, value1);
|
|
|
+
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting packed values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setPackedUint64Iterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(packedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return combined values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08,
|
|
|
+ 0x01, // unpacked value1
|
|
|
+ 0x0A,
|
|
|
+ 0x02,
|
|
|
+ 0x01,
|
|
|
+ 0x00, // packed value1 and value2
|
|
|
+ 0x08,
|
|
|
+ 0x00, // unpacked value2
|
|
|
+ ));
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1, value2, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedUint64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedUint64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(unpackedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedUint64Size(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting unpacked uint64 value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedUint64Iterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 0 but found: 5');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedUint64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding unpacked uint64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedUint64Iterable(1, [fakeUint64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedUint64Iterable(1, [fakeUint64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single unpacked uint64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addUnpackedUint64Element(1, fakeUint64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addUnpackedUint64Element(1, fakeUint64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting unpacked uint64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedUint64Iterable(1, [fakeUint64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedUint64Iterable(1, [fakeUint64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked uint64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(
|
|
|
+ createArrayBuffer(0x0D, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeUint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedUint64Element(1, 0, fakeUint64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedUint64Element(1, 0, fakeUint64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding packed uint64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedUint64Iterable(1, [fakeUint64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedUint64Iterable(1, [fakeUint64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single packed uint64 value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addPackedUint64Element(1, fakeUint64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addPackedUint64Element(1, fakeUint64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting packed uint64 values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeUint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedUint64Iterable(1, [fakeUint64]))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedUint64Iterable(1, [fakeUint64]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed uint64 value with null value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ const fakeUint64 = /** @type {!Int64} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedUint64Element(1, 0, fakeUint64))
|
|
|
+ .toThrowError('Must be Int64 instance, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedUint64Element(1, 0, fakeUint64);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedUint64Iterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single unpacked with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x01, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setUnpackedUint64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setUnpackedUint64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedUint64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single packed with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x08, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setPackedUint64Element(1, 1, Int64.fromInt(1)))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setPackedUint64Element(1, 1, Int64.fromInt(1));
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedUint64Iterable(1),
|
|
|
+ (value) => value instanceof Int64);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedUint64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedUint64Element(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated bytes does', () => {
|
|
|
+ const value1 = ByteString.fromArrayBuffer((createArrayBuffer(0x61)));
|
|
|
+ const value2 = ByteString.fromArrayBuffer((createArrayBuffer(0x62)));
|
|
|
+
|
|
|
+ const repeatedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x01,
|
|
|
+ 0x61, // value1
|
|
|
+ 0x0A,
|
|
|
+ 0x01,
|
|
|
+ 0x62, // value2
|
|
|
+ );
|
|
|
+ const repeatedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x01,
|
|
|
+ 0x62, // value2
|
|
|
+ 0x0A,
|
|
|
+ 0x01,
|
|
|
+ 0x61, // value1
|
|
|
+ );
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedBytesIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedBytesIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedBytesIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedBytesSize(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedBytesIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedBytesIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedBytesIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addRepeatedBytesElement(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedBytesIterable(1);
|
|
|
+ accessor.addRepeatedBytesElement(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedBytesIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addRepeatedBytesIterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedBytesIterable(1);
|
|
|
+ accessor.addRepeatedBytesIterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedBytesIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setRepeatedBytesElement(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedBytesIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setRepeatedBytesIterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedBytesIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addRepeatedBytesElement(1, value1);
|
|
|
+ accessor.addRepeatedBytesElement(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(repeatedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addRepeatedBytesIterable(1, [value1]);
|
|
|
+ accessor.addRepeatedBytesIterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(repeatedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setRepeatedBytesElement(1, 0, value2);
|
|
|
+ accessor.setRepeatedBytesElement(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(repeatedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setRepeatedBytesIterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(repeatedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedBytesElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedBytesElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedBytesSize(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting bytes value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedBytesIterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 2 but found: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedBytesIterable(1),
|
|
|
+ (value) => value instanceof ByteString);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding bytes values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeBytes = /** @type {!ByteString} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addRepeatedBytesIterable(1, [fakeBytes]))
|
|
|
+ .toThrowError('Must be a ByteString, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addRepeatedBytesIterable(1, [fakeBytes]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedBytesIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single bytes value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeBytes = /** @type {!ByteString} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addRepeatedBytesElement(1, fakeBytes))
|
|
|
+ .toThrowError('Must be a ByteString, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addRepeatedBytesElement(1, fakeBytes);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedBytesIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting bytes values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeBytes = /** @type {!ByteString} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setRepeatedBytesIterable(1, [fakeBytes]))
|
|
|
+ .toThrowError('Must be a ByteString, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setRepeatedBytesIterable(1, [fakeBytes]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedBytesIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single bytes value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeBytes = /** @type {!ByteString} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setRepeatedBytesElement(1, 0, fakeBytes))
|
|
|
+ .toThrowError('Must be a ByteString, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setRepeatedBytesElement(1, 0, fakeBytes);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedBytesIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x01, 0x61));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setRepeatedBytesElement(1, 1, value1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setRepeatedBytesElement(1, 1, value1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedBytesIterable(1),
|
|
|
+ (value) => value instanceof ByteString);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedBytesElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedBytesElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated string does', () => {
|
|
|
+ const value1 = 'a';
|
|
|
+ const value2 = 'b';
|
|
|
+
|
|
|
+ const repeatedValue1Value2 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x01,
|
|
|
+ 0x61, // value1
|
|
|
+ 0x0A,
|
|
|
+ 0x01,
|
|
|
+ 0x62, // value2
|
|
|
+ );
|
|
|
+ const repeatedValue2Value1 = createArrayBuffer(
|
|
|
+ 0x0A,
|
|
|
+ 0x01,
|
|
|
+ 0x62, // value2
|
|
|
+ 0x0A,
|
|
|
+ 0x01,
|
|
|
+ 0x61, // value1
|
|
|
+ );
|
|
|
+
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedStringIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedStringIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedStringIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedStringSize(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return values from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ const list = accessor.getRepeatedStringIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for values', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ const list1 = accessor.getRepeatedStringIterable(1);
|
|
|
+ const list2 = accessor.getRepeatedStringIterable(1);
|
|
|
+
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add single value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addRepeatedStringElement(1, value1);
|
|
|
+ const list1 = accessor.getRepeatedStringIterable(1);
|
|
|
+ accessor.addRepeatedStringElement(1, value2);
|
|
|
+ const list2 = accessor.getRepeatedStringIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addRepeatedStringIterable(1, [value1]);
|
|
|
+ const list1 = accessor.getRepeatedStringIterable(1);
|
|
|
+ accessor.addRepeatedStringIterable(1, [value2]);
|
|
|
+ const list2 = accessor.getRepeatedStringIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list1, [value1]);
|
|
|
+ expectEqualToArray(list2, [value1, value2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setRepeatedStringElement(1, 1, value1);
|
|
|
+ const list = accessor.getRepeatedStringIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1, value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setRepeatedStringIterable(1, [value1]);
|
|
|
+ const list = accessor.getRepeatedStringIterable(1);
|
|
|
+
|
|
|
+ expectEqualToArray(list, [value1]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addRepeatedStringElement(1, value1);
|
|
|
+ accessor.addRepeatedStringElement(1, value2);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(repeatedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.addRepeatedStringIterable(1, [value1]);
|
|
|
+ accessor.addRepeatedStringIterable(1, [value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(repeatedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ accessor.setRepeatedStringElement(1, 0, value2);
|
|
|
+ accessor.setRepeatedStringElement(1, 1, value1);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(repeatedValue2Value1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+
|
|
|
+ accessor.setRepeatedStringIterable(1, [value1, value2]);
|
|
|
+ const serialized = accessor.serialize();
|
|
|
+
|
|
|
+ expect(serialized).toEqual(repeatedValue1Value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ const result1 = accessor.getRepeatedStringElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ const result2 = accessor.getRepeatedStringElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 1);
|
|
|
+
|
|
|
+ expect(result1).toEqual(value1);
|
|
|
+ expect(result2).toEqual(value2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(repeatedValue1Value2);
|
|
|
+
|
|
|
+ const size = accessor.getRepeatedStringSize(1);
|
|
|
+
|
|
|
+ expect(size).toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting string value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedStringIterable(1);
|
|
|
+ }).toThrowError('Expected wire type: 2 but found: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedStringIterable(1),
|
|
|
+ (value) => typeof value === 'string');
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding string values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeString = /** @type {string} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addRepeatedStringIterable(1, [fakeString]))
|
|
|
+ .toThrowError('Must be string, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addRepeatedStringIterable(1, [fakeString]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedStringIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single string value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeString = /** @type {string} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.addRepeatedStringElement(1, fakeString))
|
|
|
+ .toThrowError('Must be string, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addRepeatedStringElement(1, fakeString);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedStringIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting string values with null value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeString = /** @type {string} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setRepeatedStringIterable(1, [fakeString]))
|
|
|
+ .toThrowError('Must be string, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setRepeatedStringIterable(1, [fakeString]);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedStringIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single string value with null value', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00));
|
|
|
+ const fakeString = /** @type {string} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setRepeatedStringElement(1, 0, fakeString))
|
|
|
+ .toThrowError('Must be string, but got: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setRepeatedStringElement(1, 0, fakeString);
|
|
|
+ expectQualifiedIterable(accessor.getRepeatedStringIterable(1));
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x01, 0x61));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setRepeatedStringElement(1, 1, value1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setRepeatedStringElement(1, 1, value1);
|
|
|
+ expectQualifiedIterable(
|
|
|
+ accessor.getRepeatedStringIterable(1),
|
|
|
+ (value) => typeof value === 'string');
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting element with out-of-range index', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedStringElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0);
|
|
|
+ }).toThrowError('Index out of bounds: index: 0 size: 0');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ expect(accessor.getRepeatedStringElement(
|
|
|
+ /* fieldNumber= */ 1, /* index= */ 0))
|
|
|
+ .toBe(undefined);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
|
|
+
|
|
|
+describe('LazyAccessor for repeated message does', () => {
|
|
|
+ it('return empty array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ expectEqualToArray(
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator),
|
|
|
+ []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return empty accessor array for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ expectEqualToArray(accessor.getRepeatedMessageAccessorIterable(1), []);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same instance returned for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const list1 =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ const list2 =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return size for the empty input', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ expect(accessor.getRepeatedMessageSize(1, TestMessage.instanceCreator))
|
|
|
+ .toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return values from the input', () => {
|
|
|
+ const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
|
+ const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
|
+ const msg1 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes1));
|
|
|
+ const msg2 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes2));
|
|
|
+
|
|
|
+ const bytes =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expectEqualToMessageArray(
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator),
|
|
|
+ [msg1, msg2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure not the same array instance returned', () => {
|
|
|
+ const bytes =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const list1 =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ const list2 =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ expect(list1).not.toBe(list2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure the same array element returned for get iterable', () => {
|
|
|
+ const bytes =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const list1 =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ const list2 = accessor.getRepeatedMessageIterable(
|
|
|
+ 1, TestMessage.instanceCreator, /* pivot= */ 0);
|
|
|
+ const array1 = Array.from(list1);
|
|
|
+ const array2 = Array.from(list2);
|
|
|
+ for (let i = 0; i < array1.length; i++) {
|
|
|
+ expect(array1[i]).toBe(array2[i]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return accessors from the input', () => {
|
|
|
+ const bytes =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const [accessor1, accessor2] =
|
|
|
+ [...accessor.getRepeatedMessageAccessorIterable(1)];
|
|
|
+ expect(accessor1.getInt32WithDefault(1)).toEqual(1);
|
|
|
+ expect(accessor2.getInt32WithDefault(1)).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return accessors from the input when pivot is set', () => {
|
|
|
+ const bytes =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const [accessor1, accessor2] =
|
|
|
+ [...accessor.getRepeatedMessageAccessorIterable(1, /* pivot= */ 0)];
|
|
|
+ expect(accessor1.getInt32WithDefault(1)).toEqual(1);
|
|
|
+ expect(accessor2.getInt32WithDefault(1)).toEqual(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the repeated field element from the input', () => {
|
|
|
+ const bytes =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const msg1 = accessor.getRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 0);
|
|
|
+ const msg2 = accessor.getRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 1, /* pivot= */ 0);
|
|
|
+ expect(msg1.getBoolWithDefault(
|
|
|
+ /* fieldNumber= */ 1, /* default= */ false))
|
|
|
+ .toEqual(true);
|
|
|
+ expect(msg2.getBoolWithDefault(
|
|
|
+ /* fieldNumber= */ 1, /* default= */ false))
|
|
|
+ .toEqual(false);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ensure the same array element returned', () => {
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x08, 0x01);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const msg1 = accessor.getRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 0);
|
|
|
+ const msg2 = accessor.getRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 0);
|
|
|
+ expect(msg1).toBe(msg2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('return the size from the input', () => {
|
|
|
+ const bytes =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expect(accessor.getRepeatedMessageSize(1, TestMessage.instanceCreator))
|
|
|
+ .toEqual(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode repeated message from the input', () => {
|
|
|
+ const bytes =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ expect(accessor.serialize()).toEqual(bytes);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add a single value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
|
+ const msg1 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes1));
|
|
|
+ const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
|
+ const msg2 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes2));
|
|
|
+
|
|
|
+ accessor.addRepeatedMessageElement(1, msg1, TestMessage.instanceCreator);
|
|
|
+ accessor.addRepeatedMessageElement(1, msg2, TestMessage.instanceCreator);
|
|
|
+ const result =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+
|
|
|
+ expect(Array.from(result)).toEqual([msg1, msg2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('add values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
|
+ const msg1 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes1));
|
|
|
+ const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
|
+ const msg2 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes2));
|
|
|
+
|
|
|
+ accessor.addRepeatedMessageIterable(1, [msg1], TestMessage.instanceCreator);
|
|
|
+ accessor.addRepeatedMessageIterable(1, [msg2], TestMessage.instanceCreator);
|
|
|
+ const result =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+
|
|
|
+ expect(Array.from(result)).toEqual([msg1, msg2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set a single value', () => {
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const subbytes = createArrayBuffer(0x08, 0x01);
|
|
|
+ const submsg = new TestMessage(LazyAccessor.fromArrayBuffer(subbytes));
|
|
|
+
|
|
|
+ accessor.setRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, submsg, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 0);
|
|
|
+ const result =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+
|
|
|
+ expect(Array.from(result)).toEqual([submsg]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('write submessage changes made via getRepeatedMessagElement', () => {
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x08, 0x05);
|
|
|
+ const expected = createArrayBuffer(0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const submsg = accessor.getRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 0);
|
|
|
+ expect(submsg.getInt32WithDefault(1, 0)).toEqual(5);
|
|
|
+ submsg.setInt32(1, 0);
|
|
|
+
|
|
|
+ expect(accessor.serialize()).toEqual(expected);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('set values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const subbytes = createArrayBuffer(0x08, 0x01);
|
|
|
+ const submsg = new TestMessage(LazyAccessor.fromArrayBuffer(subbytes));
|
|
|
+
|
|
|
+ accessor.setRepeatedMessageIterable(1, [submsg]);
|
|
|
+ const result =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+
|
|
|
+ expect(Array.from(result)).toEqual([submsg]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding single value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
|
+ const msg1 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes1));
|
|
|
+ const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
|
+ const msg2 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes2));
|
|
|
+ const expected =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+
|
|
|
+ accessor.addRepeatedMessageElement(1, msg1, TestMessage.instanceCreator);
|
|
|
+ accessor.addRepeatedMessageElement(1, msg2, TestMessage.instanceCreator);
|
|
|
+ const result = accessor.serialize();
|
|
|
+
|
|
|
+ expect(result).toEqual(expected);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for adding values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
|
+ const msg1 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes1));
|
|
|
+ const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
|
+ const msg2 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes2));
|
|
|
+ const expected =
|
|
|
+ createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
|
+
|
|
|
+ accessor.addRepeatedMessageIterable(
|
|
|
+ 1, [msg1, msg2], TestMessage.instanceCreator);
|
|
|
+ const result = accessor.serialize();
|
|
|
+
|
|
|
+ expect(result).toEqual(expected);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting single value', () => {
|
|
|
+ const bytes = createArrayBuffer(0x0A, 0x02, 0x08, 0x00);
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(bytes);
|
|
|
+ const subbytes = createArrayBuffer(0x08, 0x01);
|
|
|
+ const submsg = new TestMessage(LazyAccessor.fromArrayBuffer(subbytes));
|
|
|
+ const expected = createArrayBuffer(0x0A, 0x02, 0x08, 0x01);
|
|
|
+
|
|
|
+ accessor.setRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, submsg, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 0);
|
|
|
+ const result = accessor.serialize();
|
|
|
+
|
|
|
+ expect(result).toEqual(expected);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('encode for setting values', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const subbytes = createArrayBuffer(0x08, 0x01);
|
|
|
+ const submsg = new TestMessage(LazyAccessor.fromArrayBuffer(subbytes));
|
|
|
+ const expected = createArrayBuffer(0x0A, 0x02, 0x08, 0x01);
|
|
|
+
|
|
|
+ accessor.setRepeatedMessageIterable(1, [submsg]);
|
|
|
+ const result = accessor.serialize();
|
|
|
+
|
|
|
+ expect(result).toEqual(expected);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('get accessors from set values.', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
|
+ const msg1 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes1));
|
|
|
+ const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
|
+ const msg2 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes2));
|
|
|
+
|
|
|
+ accessor.addRepeatedMessageIterable(
|
|
|
+ 1, [msg1, msg2], TestMessage.instanceCreator);
|
|
|
+
|
|
|
+ const [accessor1, accessor2] =
|
|
|
+ [...accessor.getRepeatedMessageAccessorIterable(1)];
|
|
|
+ expect(accessor1.getInt32WithDefault(1)).toEqual(1);
|
|
|
+ expect(accessor2.getInt32WithDefault(1)).toEqual(0);
|
|
|
+
|
|
|
+ // Retrieved accessors are the exact same accessors as the added messages.
|
|
|
+ expect(accessor1).toBe(
|
|
|
+ (/** @type {!InternalMessage} */ (msg1)).internalGetKernel());
|
|
|
+ expect(accessor2).toBe(
|
|
|
+ (/** @type {!InternalMessage} */ (msg2)).internalGetKernel());
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when getting message value with other wire types', () => {
|
|
|
+ const accessor = LazyAccessor.fromArrayBuffer(createArrayBuffer(
|
|
|
+ 0x09, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => {
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ }).toThrow();
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ const [msg1] =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ expect(msg1.serialize()).toEqual(createArrayBuffer());
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding message values with wrong type value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeValue = /** @type {!TestMessage} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(
|
|
|
+ () => accessor.addRepeatedMessageIterable(
|
|
|
+ 1, [fakeValue], TestMessage.instanceCreator))
|
|
|
+ .toThrowError('Given value is not a message instance: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addRepeatedMessageIterable(
|
|
|
+ 1, [fakeValue], TestMessage.instanceCreator);
|
|
|
+ const list =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ expect(Array.from(list)).toEqual([null]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when adding single message value with wrong type value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeValue = /** @type {!TestMessage} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(
|
|
|
+ () => accessor.addRepeatedMessageElement(
|
|
|
+ 1, fakeValue, TestMessage.instanceCreator))
|
|
|
+ .toThrowError('Given value is not a message instance: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.addRepeatedMessageElement(
|
|
|
+ 1, fakeValue, TestMessage.instanceCreator);
|
|
|
+ const list =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ expect(Array.from(list)).toEqual([null]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting message values with wrong type value', () => {
|
|
|
+ const accessor = LazyAccessor.createEmpty();
|
|
|
+ const fakeValue = /** @type {!TestMessage} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(() => accessor.setRepeatedMessageIterable(1, [fakeValue]))
|
|
|
+ .toThrowError('Given value is not a message instance: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setRepeatedMessageIterable(1, [fakeValue]);
|
|
|
+ const list =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ expect(Array.from(list)).toEqual([null]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single value with wrong type value', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x02, 0x08, 0x00));
|
|
|
+ const fakeValue = /** @type {!TestMessage} */ (/** @type {*} */ (null));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(
|
|
|
+ () => accessor.setRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, fakeValue, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 0))
|
|
|
+ .toThrowError('Given value is not a message instance: null');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, fakeValue, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 0);
|
|
|
+ const list =
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator);
|
|
|
+ expect(Array.from(list).length).toEqual(1);
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ it('fail when setting single value with out-of-bound index', () => {
|
|
|
+ const accessor =
|
|
|
+ LazyAccessor.fromArrayBuffer(createArrayBuffer(0x0A, 0x02, 0x08, 0x00));
|
|
|
+ const msg1 =
|
|
|
+ accessor.getRepeatedMessageElement(1, TestMessage.instanceCreator, 0);
|
|
|
+ const bytes2 = createArrayBuffer(0x08, 0x01);
|
|
|
+ const msg2 = new TestMessage(LazyAccessor.fromArrayBuffer(bytes2));
|
|
|
+ if (CHECK_CRITICAL_STATE) {
|
|
|
+ expect(
|
|
|
+ () => accessor.setRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, msg2, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 1))
|
|
|
+ .toThrowError('Index out of bounds: index: 1 size: 1');
|
|
|
+ } else {
|
|
|
+ // Note in unchecked mode we produce invalid output for invalid inputs.
|
|
|
+ // This test just documents our behavior in those cases.
|
|
|
+ // These values might change at any point and are not considered
|
|
|
+ // what the implementation should be doing here.
|
|
|
+ accessor.setRepeatedMessageElement(
|
|
|
+ /* fieldNumber= */ 1, msg2, TestMessage.instanceCreator,
|
|
|
+ /* index= */ 1);
|
|
|
+ expectEqualToArray(
|
|
|
+ accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator),
|
|
|
+ [msg1, msg2]);
|
|
|
+ }
|
|
|
+ });
|
|
|
+});
|
Protobuf Team