7808 lines
283 KiB
JavaScript
7808 lines
283 KiB
JavaScript
/**
|
|
* @fileoverview Tests for repeated methods in kernel.js.
|
|
*/
|
|
goog.module('protobuf.runtime.KernelTest');
|
|
|
|
goog.setTestOnly();
|
|
|
|
const ByteString = goog.require('protobuf.ByteString');
|
|
const Int64 = goog.require('protobuf.Int64');
|
|
const InternalMessage = goog.require('protobuf.binary.InternalMessage');
|
|
const Kernel = goog.require('protobuf.runtime.Kernel');
|
|
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('Kernel for repeated boolean does', () => {
|
|
it('return empty array for the empty input', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
expectEqualToArray(accessor.getRepeatedBoolIterable(1), []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
expect(accessor.getRepeatedBoolSize(1)).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const bytes = createArrayBuffer(0x08, 0x01, 0x08, 0x00);
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(bytes);
|
|
expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
});
|
|
|
|
it('return for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(bytes);
|
|
expectEqualToArray(accessor.getRepeatedBoolIterable(1), [true, false]);
|
|
});
|
|
|
|
it('return for adding single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(bytes);
|
|
expect(accessor.getRepeatedBoolSize(1)).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked bool value with other wire types', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedDoubleSize(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedDoubleElement(1, 1, value1);
|
|
const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedDoubleIterable(1, [value1]);
|
|
const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedDoubleIterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedDoubleIterable(1);
|
|
const list2 = accessor.getRepeatedDoubleIterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedDoubleElement(1, 1, value1);
|
|
const list = accessor.getRepeatedDoubleIterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedDoubleIterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedDoubleIterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedDoubleSize(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked double value with other wire types', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedFixed32Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedFixed32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedFixed32Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedFixed32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedFixed32Iterable(1);
|
|
const list2 = accessor.getRepeatedFixed32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedFixed32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedFixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedFixed32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedFixed32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedFixed32Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked fixed32 value with other wire types', () => {
|
|
const accessor =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedFixed64Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedFixed64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedFixed64Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedFixed64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedFixed64Iterable(1);
|
|
const list2 = accessor.getRepeatedFixed64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedFixed64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedFixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedFixed64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedFixed64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedFixed64Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked fixed64 value with other wire types', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedFloatIterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedFloatSize(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedFloatIterable(1);
|
|
|
|
expectEqualToArray(list, [value1Float, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedFloatIterable(1);
|
|
const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedFloatElement(1, 1, value1);
|
|
const list = accessor.getRepeatedFloatIterable(1);
|
|
|
|
expectEqualToArray(list, [value1Float, value1Float]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedFloatIterable(1, [value1]);
|
|
const list = accessor.getRepeatedFloatIterable(1);
|
|
|
|
expectEqualToArray(list, [value1Float]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedFloatIterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedFloatIterable(1);
|
|
|
|
expectEqualToArray(list, [value1Float, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedFloatIterable(1);
|
|
const list2 = accessor.getRepeatedFloatIterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedFloatElement(1, 1, value1);
|
|
const list = accessor.getRepeatedFloatIterable(1);
|
|
|
|
expectEqualToArray(list, [value1Float, value1Float]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedFloatIterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedFloatIterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedFloatSize(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked float value with other wire types', () => {
|
|
const accessor =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 =
|
|
Kernel.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 =
|
|
Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedInt32Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedInt32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedInt32Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedInt32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedInt32Iterable(1);
|
|
const list2 = accessor.getRepeatedInt32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedInt32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedInt32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedInt32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedInt32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedInt32Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked int32 value with other wire types', () => {
|
|
const accessor =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedInt64Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedInt64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedInt64Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedInt64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedInt64Iterable(1);
|
|
const list2 = accessor.getRepeatedInt64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedInt64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedInt64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedInt64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedInt64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedInt64Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked int64 value with other wire types', () => {
|
|
const accessor =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedSfixed32Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedSfixed32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedSfixed32Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedSfixed32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedSfixed32Iterable(1);
|
|
const list2 = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedSfixed32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedSfixed32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedSfixed32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedSfixed32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedSfixed32Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked sfixed32 value with other wire types', () => {
|
|
const accessor =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 =
|
|
Kernel.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 =
|
|
Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedSfixed64Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedSfixed64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedSfixed64Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedSfixed64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedSfixed64Iterable(1);
|
|
const list2 = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedSfixed64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedSfixed64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedSfixed64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedSfixed64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedSfixed64Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked sfixed64 value with other wire types', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedSint32Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedSint32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedSint32Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedSint32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedSint32Iterable(1);
|
|
const list2 = accessor.getRepeatedSint32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedSint32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedSint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedSint32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedSint32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedSint32Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked sint32 value with other wire types', () => {
|
|
const accessor =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedSint64Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedSint64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedSint64Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedSint64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedSint64Iterable(1);
|
|
const list2 = accessor.getRepeatedSint64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedSint64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedSint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedSint64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedSint64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedSint64Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked sint64 value with other wire types', () => {
|
|
const accessor =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedUint32Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedUint32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedUint32Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedUint32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedUint32Iterable(1);
|
|
const list2 = accessor.getRepeatedUint32Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedUint32Element(1, 1, value1);
|
|
const list = accessor.getRepeatedUint32Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedUint32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedUint32Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedUint32Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked uint32 value with other wire types', () => {
|
|
const accessor =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedUint64Size(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return unpacked values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for unpacked values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
accessor.setUnpackedUint64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set unpacked values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedUint64Iterable(1, [value1]);
|
|
const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single unpacked value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setUnpackedUint64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(unpackedValue1Value2);
|
|
});
|
|
|
|
it('return packed values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for packed values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(packedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedUint64Iterable(1);
|
|
const list2 = accessor.getRepeatedUint64Iterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
accessor.setPackedUint64Element(1, 1, value1);
|
|
const list = accessor.getRepeatedUint64Iterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set packed values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.addPackedUint64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('encode for setting single packed value', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
accessor.setPackedUint64Iterable(1, [value1, value2]);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(packedValue1Value2);
|
|
});
|
|
|
|
it('return combined values from the input', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(unpackedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedUint64Size(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting unpacked uint64 value with other wire types', () => {
|
|
const accessor =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedBytesIterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedBytesSize(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(repeatedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedBytesIterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(repeatedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedBytesIterable(1);
|
|
const list2 = accessor.getRepeatedBytesIterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(repeatedValue1Value2);
|
|
|
|
accessor.setRepeatedBytesElement(1, 1, value1);
|
|
const list = accessor.getRepeatedBytesIterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setRepeatedBytesIterable(1, [value1]);
|
|
const list = accessor.getRepeatedBytesIterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single value', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.addRepeatedBytesElement(1, value1);
|
|
accessor.addRepeatedBytesElement(1, value2);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(repeatedValue1Value2);
|
|
});
|
|
|
|
it('encode for adding values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(repeatedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedBytesSize(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting bytes value with other wire types', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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('Kernel 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 = Kernel.createEmpty();
|
|
|
|
const list = accessor.getRepeatedStringIterable(1);
|
|
|
|
expectEqualToArray(list, []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.createEmpty();
|
|
|
|
const size = accessor.getRepeatedStringSize(1);
|
|
|
|
expect(size).toEqual(0);
|
|
});
|
|
|
|
it('return values from the input', () => {
|
|
const accessor = Kernel.fromArrayBuffer(repeatedValue1Value2);
|
|
|
|
const list = accessor.getRepeatedStringIterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value2]);
|
|
});
|
|
|
|
it('ensure not the same instance returned for values', () => {
|
|
const accessor = Kernel.fromArrayBuffer(repeatedValue1Value2);
|
|
|
|
const list1 = accessor.getRepeatedStringIterable(1);
|
|
const list2 = accessor.getRepeatedStringIterable(1);
|
|
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('add single value', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(repeatedValue1Value2);
|
|
|
|
accessor.setRepeatedStringElement(1, 1, value1);
|
|
const list = accessor.getRepeatedStringIterable(1);
|
|
|
|
expectEqualToArray(list, [value1, value1]);
|
|
});
|
|
|
|
it('set values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.setRepeatedStringIterable(1, [value1]);
|
|
const list = accessor.getRepeatedStringIterable(1);
|
|
|
|
expectEqualToArray(list, [value1]);
|
|
});
|
|
|
|
it('encode for adding single value', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
|
|
accessor.addRepeatedStringElement(1, value1);
|
|
accessor.addRepeatedStringElement(1, value2);
|
|
const serialized = accessor.serialize();
|
|
|
|
expect(serialized).toEqual(repeatedValue1Value2);
|
|
});
|
|
|
|
it('encode for adding values', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(repeatedValue1Value2);
|
|
|
|
const size = accessor.getRepeatedStringSize(1);
|
|
|
|
expect(size).toEqual(2);
|
|
});
|
|
|
|
it('fail when getting string value with other wire types', () => {
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 = Kernel.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('Kernel for repeated message does', () => {
|
|
it('return empty array for the empty input', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
expectEqualToArray(
|
|
accessor.getRepeatedMessageIterable(1, TestMessage.instanceCreator),
|
|
[]);
|
|
});
|
|
|
|
it('return empty accessor array for the empty input', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
expectEqualToArray(accessor.getRepeatedMessageAccessorIterable(1), []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.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 = Kernel.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(Kernel.fromArrayBuffer(bytes1));
|
|
const msg2 = new TestMessage(Kernel.fromArrayBuffer(bytes2));
|
|
|
|
const bytes =
|
|
createArrayBuffer(0x0A, 0x02, 0x08, 0x01, 0x0A, 0x02, 0x08, 0x00);
|
|
const accessor = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.fromArrayBuffer(bytes);
|
|
expect(accessor.serialize()).toEqual(bytes);
|
|
});
|
|
|
|
it('add a single value', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
const msg2 = new TestMessage(Kernel.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 = Kernel.createEmpty();
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
const msg2 = new TestMessage(Kernel.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 = Kernel.fromArrayBuffer(bytes);
|
|
const subbytes = createArrayBuffer(0x08, 0x01);
|
|
const submsg = new TestMessage(Kernel.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 = Kernel.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 = Kernel.createEmpty();
|
|
const subbytes = createArrayBuffer(0x08, 0x01);
|
|
const submsg = new TestMessage(Kernel.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 = Kernel.createEmpty();
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
const msg2 = new TestMessage(Kernel.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 = Kernel.createEmpty();
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
const msg2 = new TestMessage(Kernel.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 = Kernel.fromArrayBuffer(bytes);
|
|
const subbytes = createArrayBuffer(0x08, 0x01);
|
|
const submsg = new TestMessage(Kernel.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 = Kernel.createEmpty();
|
|
const subbytes = createArrayBuffer(0x08, 0x01);
|
|
const submsg = new TestMessage(Kernel.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 = Kernel.createEmpty();
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
const msg2 = new TestMessage(Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 = Kernel.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 =
|
|
Kernel.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 =
|
|
Kernel.fromArrayBuffer(createArrayBuffer(0x0A, 0x02, 0x08, 0x00));
|
|
const msg1 =
|
|
accessor.getRepeatedMessageElement(1, TestMessage.instanceCreator, 0);
|
|
const bytes2 = createArrayBuffer(0x08, 0x01);
|
|
const msg2 = new TestMessage(Kernel.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]);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('Kernel for repeated groups does', () => {
|
|
it('return empty array for the empty input', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
expectEqualToArray(
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator), []);
|
|
});
|
|
|
|
it('ensure not the same instance returned for the empty input', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const list1 =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
const list2 =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('return size for the empty input', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
expect(accessor.getRepeatedGroupSize(1, TestMessage.instanceCreator))
|
|
.toEqual(0);
|
|
});
|
|
|
|
it('return values from the input', () => {
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const bytes2 = createArrayBuffer(0x08, 0x02);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const msg2 = new TestMessage(Kernel.fromArrayBuffer(bytes2));
|
|
|
|
const bytes =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x02, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
expectEqualToMessageArray(
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator),
|
|
[msg1, msg2]);
|
|
});
|
|
|
|
it('ensure not the same array instance returned', () => {
|
|
const bytes =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x02, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
const list1 =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
const list2 =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
expect(list1).not.toBe(list2);
|
|
});
|
|
|
|
it('ensure the same array element returned for get iterable', () => {
|
|
const bytes =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x02, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
const list1 =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
const list2 = accessor.getRepeatedGroupIterable(
|
|
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(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x02, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
const [accessor1, accessor2] =
|
|
[...accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator)];
|
|
expect(accessor1.getInt32WithDefault(1)).toEqual(1);
|
|
expect(accessor2.getInt32WithDefault(1)).toEqual(2);
|
|
});
|
|
|
|
it('return accessors from the input when pivot is set', () => {
|
|
const bytes =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x02, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
const [accessor1, accessor2] = [...accessor.getRepeatedGroupIterable(
|
|
1, TestMessage.instanceCreator, /* pivot= */ 0)];
|
|
expect(accessor1.getInt32WithDefault(1)).toEqual(1);
|
|
expect(accessor2.getInt32WithDefault(1)).toEqual(2);
|
|
});
|
|
|
|
it('return the repeated field element from the input', () => {
|
|
const bytes =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x02, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
const msg1 = accessor.getRepeatedGroupElement(
|
|
/* fieldNumber= */ 1, TestMessage.instanceCreator,
|
|
/* index= */ 0);
|
|
const msg2 = accessor.getRepeatedGroupElement(
|
|
/* fieldNumber= */ 1, TestMessage.instanceCreator,
|
|
/* index= */ 1, /* pivot= */ 0);
|
|
expect(msg1.getInt32WithDefault(
|
|
/* fieldNumber= */ 1, /* default= */ 0))
|
|
.toEqual(1);
|
|
expect(msg2.getInt32WithDefault(
|
|
/* fieldNumber= */ 1, /* default= */ 0))
|
|
.toEqual(2);
|
|
});
|
|
|
|
it('ensure the same array element returned', () => {
|
|
const bytes =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x02, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
const msg1 = accessor.getRepeatedGroupElement(
|
|
/* fieldNumber= */ 1, TestMessage.instanceCreator,
|
|
/* index= */ 0);
|
|
const msg2 = accessor.getRepeatedGroupElement(
|
|
/* fieldNumber= */ 1, TestMessage.instanceCreator,
|
|
/* index= */ 0);
|
|
expect(msg1).toBe(msg2);
|
|
});
|
|
|
|
it('return the size from the input', () => {
|
|
const bytes =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x02, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
expect(accessor.getRepeatedGroupSize(1, TestMessage.instanceCreator))
|
|
.toEqual(2);
|
|
});
|
|
|
|
it('encode repeated message from the input', () => {
|
|
const bytes =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x02, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
expect(accessor.serialize()).toEqual(bytes);
|
|
});
|
|
|
|
it('add a single value', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const bytes2 = createArrayBuffer(0x08, 0x02);
|
|
const msg2 = new TestMessage(Kernel.fromArrayBuffer(bytes2));
|
|
|
|
accessor.addRepeatedGroupElement(1, msg1, TestMessage.instanceCreator);
|
|
accessor.addRepeatedGroupElement(1, msg2, TestMessage.instanceCreator);
|
|
const result =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
|
|
expect(Array.from(result)).toEqual([msg1, msg2]);
|
|
});
|
|
|
|
it('add values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const bytes2 = createArrayBuffer(0x08, 0x02);
|
|
const msg2 = new TestMessage(Kernel.fromArrayBuffer(bytes2));
|
|
|
|
accessor.addRepeatedGroupIterable(1, [msg1], TestMessage.instanceCreator);
|
|
accessor.addRepeatedGroupIterable(1, [msg2], TestMessage.instanceCreator);
|
|
const result =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
|
|
expect(Array.from(result)).toEqual([msg1, msg2]);
|
|
});
|
|
|
|
it('set a single value', () => {
|
|
const bytes = createArrayBuffer(0x0B, 0x08, 0x01, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
const subbytes = createArrayBuffer(0x08, 0x01);
|
|
const submsg = new TestMessage(Kernel.fromArrayBuffer(subbytes));
|
|
|
|
accessor.setRepeatedGroupElement(
|
|
/* fieldNumber= */ 1, submsg, TestMessage.instanceCreator,
|
|
/* index= */ 0);
|
|
const result =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
|
|
expect(Array.from(result)).toEqual([submsg]);
|
|
});
|
|
|
|
it('write submessage changes made via getRepeatedGroupElement', () => {
|
|
const bytes = createArrayBuffer(0x0B, 0x08, 0x05, 0x0C);
|
|
const expected = createArrayBuffer(0x0B, 0x08, 0x00, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
const submsg = accessor.getRepeatedGroupElement(
|
|
/* 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 = Kernel.createEmpty();
|
|
const subbytes = createArrayBuffer(0x08, 0x01);
|
|
const submsg = new TestMessage(Kernel.fromArrayBuffer(subbytes));
|
|
|
|
accessor.setRepeatedGroupIterable(1, [submsg]);
|
|
const result =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
|
|
expect(Array.from(result)).toEqual([submsg]);
|
|
});
|
|
|
|
it('encode for adding single value', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
const msg2 = new TestMessage(Kernel.fromArrayBuffer(bytes2));
|
|
const expected =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x00, 0x0C);
|
|
|
|
accessor.addRepeatedGroupElement(1, msg1, TestMessage.instanceCreator);
|
|
accessor.addRepeatedGroupElement(1, msg2, TestMessage.instanceCreator);
|
|
const result = accessor.serialize();
|
|
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it('encode for adding values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const bytes1 = createArrayBuffer(0x08, 0x01);
|
|
const msg1 = new TestMessage(Kernel.fromArrayBuffer(bytes1));
|
|
const bytes2 = createArrayBuffer(0x08, 0x00);
|
|
const msg2 = new TestMessage(Kernel.fromArrayBuffer(bytes2));
|
|
const expected =
|
|
createArrayBuffer(0x0B, 0x08, 0x01, 0x0C, 0x0B, 0x08, 0x00, 0x0C);
|
|
|
|
accessor.addRepeatedGroupIterable(
|
|
1, [msg1, msg2], TestMessage.instanceCreator);
|
|
const result = accessor.serialize();
|
|
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it('encode for setting single value', () => {
|
|
const bytes = createArrayBuffer(0x0B, 0x08, 0x00, 0x0C);
|
|
const accessor = Kernel.fromArrayBuffer(bytes);
|
|
const subbytes = createArrayBuffer(0x08, 0x01);
|
|
const submsg = new TestMessage(Kernel.fromArrayBuffer(subbytes));
|
|
const expected = createArrayBuffer(0x0B, 0x08, 0x01, 0x0C);
|
|
|
|
accessor.setRepeatedGroupElement(
|
|
/* fieldNumber= */ 1, submsg, TestMessage.instanceCreator,
|
|
/* index= */ 0);
|
|
const result = accessor.serialize();
|
|
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it('encode for setting values', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const subbytes = createArrayBuffer(0x08, 0x01);
|
|
const submsg = new TestMessage(Kernel.fromArrayBuffer(subbytes));
|
|
const expected = createArrayBuffer(0x0B, 0x08, 0x01, 0x0C);
|
|
|
|
accessor.setRepeatedGroupIterable(1, [submsg]);
|
|
const result = accessor.serialize();
|
|
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it('fail when getting groups value with other wire types', () => {
|
|
const accessor = Kernel.fromArrayBuffer(createArrayBuffer(
|
|
0x09, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
|
|
|
|
if (CHECK_CRITICAL_STATE) {
|
|
expect(() => {
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
}).toThrow();
|
|
}
|
|
});
|
|
|
|
it('fail when adding group values with wrong type value', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const fakeValue = /** @type {!TestMessage} */ (/** @type {*} */ (null));
|
|
if (CHECK_CRITICAL_STATE) {
|
|
expect(
|
|
() => accessor.addRepeatedGroupIterable(
|
|
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.addRepeatedGroupIterable(
|
|
1, [fakeValue], TestMessage.instanceCreator);
|
|
const list =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
expect(Array.from(list)).toEqual([null]);
|
|
}
|
|
});
|
|
|
|
it('fail when adding single group value with wrong type value', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const fakeValue = /** @type {!TestMessage} */ (/** @type {*} */ (null));
|
|
if (CHECK_CRITICAL_STATE) {
|
|
expect(
|
|
() => accessor.addRepeatedGroupElement(
|
|
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.addRepeatedGroupElement(
|
|
1, fakeValue, TestMessage.instanceCreator);
|
|
const list =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
expect(Array.from(list)).toEqual([null]);
|
|
}
|
|
});
|
|
|
|
it('fail when setting message values with wrong type value', () => {
|
|
const accessor = Kernel.createEmpty();
|
|
const fakeValue = /** @type {!TestMessage} */ (/** @type {*} */ (null));
|
|
if (CHECK_CRITICAL_STATE) {
|
|
expect(() => accessor.setRepeatedGroupIterable(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.setRepeatedGroupIterable(1, [fakeValue]);
|
|
const list =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
expect(Array.from(list)).toEqual([null]);
|
|
}
|
|
});
|
|
|
|
it('fail when setting single value with wrong type value', () => {
|
|
const accessor =
|
|
Kernel.fromArrayBuffer(createArrayBuffer(0x0B, 0x08, 0x00, 0x0C));
|
|
const fakeValue = /** @type {!TestMessage} */ (/** @type {*} */ (null));
|
|
if (CHECK_CRITICAL_STATE) {
|
|
expect(
|
|
() => accessor.setRepeatedGroupElement(
|
|
/* 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.setRepeatedGroupElement(
|
|
/* fieldNumber= */ 1, fakeValue, TestMessage.instanceCreator,
|
|
/* index= */ 0);
|
|
const list =
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator);
|
|
expect(Array.from(list).length).toEqual(1);
|
|
}
|
|
});
|
|
|
|
it('fail when setting single value with out-of-bound index', () => {
|
|
const accessor =
|
|
Kernel.fromArrayBuffer(createArrayBuffer(0x0B, 0x08, 0x00, 0x0C));
|
|
const msg1 =
|
|
accessor.getRepeatedGroupElement(1, TestMessage.instanceCreator, 0);
|
|
const bytes2 = createArrayBuffer(0x08, 0x01);
|
|
const msg2 = new TestMessage(Kernel.fromArrayBuffer(bytes2));
|
|
if (CHECK_CRITICAL_STATE) {
|
|
expect(
|
|
() => accessor.setRepeatedGroupElement(
|
|
/* 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.setRepeatedGroupElement(
|
|
/* fieldNumber= */ 1, msg2, TestMessage.instanceCreator,
|
|
/* index= */ 1);
|
|
expectEqualToArray(
|
|
accessor.getRepeatedGroupIterable(1, TestMessage.instanceCreator),
|
|
[msg1, msg2]);
|
|
}
|
|
});
|
|
});
|