// Protocol Buffers - Google's data interchange format

// Copyright 2008 Google Inc. All rights reserved.

// https://developers.google.com/protocol-buffers/

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

// * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

// * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

/**

* @fileoverview Test cases for jspb's binary protocol buffer decoder.

*

* There are two particular magic numbers that need to be pointed out -

* 2^64-1025 is the largest number representable as both a double and an

* unsigned 64-bit integer, and 2^63-513 is the largest number representable as

* both a double and a signed 64-bit integer.

*

* Test suite is written using Jasmine -- see http://jasmine.github.io/

*

* @author aappleby@google.com (Austin Appleby)

*/

goog.require('jspb.BinaryConstants');

goog.require('jspb.BinaryDecoder');

goog.require('jspb.BinaryEncoder');

goog.require('jspb.utils');

/**

* Tests encoding and decoding of unsigned types.

* @param {Function} readValue

* @param {Function} writeValue

* @param {number} epsilon

* @param {number} upperLimit

* @param {Function} filter

* @suppress {missingProperties|visibility}

*/

function doTestUnsignedValue(

readValue, writeValue, epsilon, upperLimit, filter) {

const encoder = new jspb.BinaryEncoder();

// Encode zero and limits.

writeValue.call(encoder, filter(0));

writeValue.call(encoder, filter(epsilon));

writeValue.call(encoder, filter(upperLimit));

// Encode positive values.

for (let cursor = epsilon; cursor < upperLimit; cursor *= 1.1) {

writeValue.call(encoder, filter(cursor));

}

const decoder = jspb.BinaryDecoder.alloc(encoder.end());

// Check zero and limits.

expect(readValue.call(decoder)).toEqual(filter(0));

expect(readValue.call(decoder)).toEqual(filter(epsilon));

expect(readValue.call(decoder)).toEqual(filter(upperLimit));

// Check positive values.

for (let cursor = epsilon; cursor < upperLimit; cursor *= 1.1) {

if (filter(cursor) != readValue.call(decoder)) throw 'fail!';

}

// Encoding values outside the valid range should assert.

expect(() => {

writeValue.call(encoder, -1);

}).toThrow();

expect(() => {

writeValue.call(encoder, upperLimit * 1.1);

}).toThrow();

}

/**

* Tests encoding and decoding of signed types.

* @param {Function} readValue

* @param {Function} writeValue

* @param {number} epsilon

* @param {number} lowerLimit

* @param {number} upperLimit

* @param {Function} filter

* @suppress {missingProperties}

*/

function doTestSignedValue(

readValue, writeValue, epsilon, lowerLimit, upperLimit, filter) {

const encoder = new jspb.BinaryEncoder();

// Encode zero and limits.

writeValue.call(encoder, filter(lowerLimit));

writeValue.call(encoder, filter(-epsilon));

writeValue.call(encoder, filter(0));

writeValue.call(encoder, filter(epsilon));

writeValue.call(encoder, filter(upperLimit));

const inputValues = [];

// Encode negative values.

for (let cursor = lowerLimit; cursor < -epsilon; cursor /= 1.1) {

let val = filter(cursor);

writeValue.call(encoder, val);

inputValues.push(val);

}

// Encode positive values.

for (let cursor = epsilon; cursor < upperLimit; cursor *= 1.1) {

const val = filter(cursor);

writeValue.call(encoder, val);

inputValues.push(val);

}

const decoder = jspb.BinaryDecoder.alloc(encoder.end());

// Check zero and limits.

expect(readValue.call(decoder)).toEqual(filter(lowerLimit));

expect(readValue.call(decoder)).toEqual(filter(-epsilon));

expect(readValue.call(decoder)).toEqual(filter(0));

expect(readValue.call(decoder)).toEqual(filter(epsilon));

expect(readValue.call(decoder)).toEqual(filter(upperLimit));

// Verify decoded values.

for (let i = 0; i < inputValues.length; i++) {

expect(readValue.call(decoder)).toEqual(inputValues[i]);

}

// Encoding values outside the valid range should assert.

const pastLowerLimit = lowerLimit * 1.1;

const pastUpperLimit = upperLimit * 1.1;

if (pastLowerLimit !== -Infinity) {

expect(() => void writeValue.call(encoder, pastLowerLimit)).toThrow();

}

if (pastUpperLimit !== Infinity) {

expect(() => void writeValue.call(encoder, pastUpperLimit)).toThrow();

}

}

describe('binaryDecoderTest', () => {

/**

* Tests the decoder instance cache.

*/

it('testInstanceCache', /** @suppress {visibility} */ () => {

// Empty the instance caches.

jspb.BinaryDecoder.instanceCache_ = [];

// Allocating and then freeing a decoder should put it in the instance

// cache.

jspb.BinaryDecoder.alloc().free();

expect(jspb.BinaryDecoder.getInstanceCacheLength()).toEqual(1);

// Allocating and then freeing three decoders should leave us with three in

// the cache.

const decoder1 = jspb.BinaryDecoder.alloc();

const decoder2 = jspb.BinaryDecoder.alloc();

const decoder3 = jspb.BinaryDecoder.alloc();

decoder1.free();

decoder2.free();

decoder3.free();

expect(jspb.BinaryDecoder.getInstanceCacheLength()).toEqual(3);

});

describe('varint64', () => {

let /** !jspb.BinaryEncoder */ encoder;

let /** !jspb.BinaryDecoder */ decoder;

const hashA =

String.fromCharCode(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);

const hashB =

String.fromCharCode(0x12, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);

const hashC =

String.fromCharCode(0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21);

const hashD =

String.fromCharCode(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);

beforeEach(() => {

encoder = new jspb.BinaryEncoder();

encoder.writeVarintHash64(hashA);

encoder.writeVarintHash64(hashB);

encoder.writeVarintHash64(hashC);

encoder.writeVarintHash64(hashD);

encoder.writeFixedHash64(hashA);

encoder.writeFixedHash64(hashB);

encoder.writeFixedHash64(hashC);

encoder.writeFixedHash64(hashD);

decoder = jspb.BinaryDecoder.alloc(encoder.end());

});

it('reads 64-bit integers as hash strings', () => {

expect(hashA).toEqual(decoder.readVarintHash64());

expect(hashB).toEqual(decoder.readVarintHash64());

expect(hashC).toEqual(decoder.readVarintHash64());

expect(hashD).toEqual(decoder.readVarintHash64());

expect(hashA).toEqual(decoder.readFixedHash64());

expect(hashB).toEqual(decoder.readFixedHash64());

expect(hashC).toEqual(decoder.readFixedHash64());

expect(hashD).toEqual(decoder.readFixedHash64());

});

it('reads split 64 bit integers', () => {

function hexJoin(bitsLow, bitsHigh) {

return `0x${(bitsHigh >>> 0).toString(16)}:0x${

(bitsLow >>> 0).toString(16)}`;

}

function hexJoinHash(hash64) {

jspb.utils.splitHash64(hash64, true);

return hexJoin(jspb.utils.getSplit64Low(), jspb.utils.getSplit64High());

}

expect(decoder.readSplitVarint64(hexJoin)).toEqual(hexJoinHash(hashA));

expect(decoder.readSplitVarint64(hexJoin)).toEqual(hexJoinHash(hashB));

expect(decoder.readSplitVarint64(hexJoin)).toEqual(hexJoinHash(hashC));

expect(decoder.readSplitVarint64(hexJoin)).toEqual(hexJoinHash(hashD));

expect(decoder.readSplitFixed64(hexJoin)).toEqual(hexJoinHash(hashA));

expect(decoder.readSplitFixed64(hexJoin)).toEqual(hexJoinHash(hashB));

expect(decoder.readSplitFixed64(hexJoin)).toEqual(hexJoinHash(hashC));

expect(decoder.readSplitFixed64(hexJoin)).toEqual(hexJoinHash(hashD));

});

});

describe('sint64', () => {

let /** !jspb.BinaryDecoder */ decoder;

const hashA =

String.fromCharCode(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);

const hashB =

String.fromCharCode(0x12, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);

const hashC =

String.fromCharCode(0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21);

const hashD =

String.fromCharCode(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);

beforeEach(() => {

const encoder = new jspb.BinaryEncoder();

encoder.writeZigzagVarintHash64(hashA);

encoder.writeZigzagVarintHash64(hashB);

encoder.writeZigzagVarintHash64(hashC);

encoder.writeZigzagVarintHash64(hashD);

decoder = jspb.BinaryDecoder.alloc(encoder.end());

});

it('reads 64-bit integers as decimal strings', () => {

const signed = true;

expect(decoder.readZigzagVarint64String())

.toEqual(jspb.utils.hash64ToDecimalString(hashA, signed));

expect(decoder.readZigzagVarint64String())

.toEqual(jspb.utils.hash64ToDecimalString(hashB, signed));

expect(decoder.readZigzagVarint64String())

.toEqual(jspb.utils.hash64ToDecimalString(hashC, signed));

expect(decoder.readZigzagVarint64String())

.toEqual(jspb.utils.hash64ToDecimalString(hashD, signed));

});

it('reads 64-bit integers as hash strings', () => {

expect(decoder.readZigzagVarintHash64()).toEqual(hashA);

expect(decoder.readZigzagVarintHash64()).toEqual(hashB);

expect(decoder.readZigzagVarintHash64()).toEqual(hashC);

expect(decoder.readZigzagVarintHash64()).toEqual(hashD);

});

it('reads split 64 bit zigzag integers', () => {

function hexJoin(bitsLow, bitsHigh) {

return `0x${(bitsHigh >>> 0).toString(16)}:0x${

(bitsLow >>> 0).toString(16)}`;

}

function hexJoinHash(hash64) {

jspb.utils.splitHash64(hash64);

return hexJoin(jspb.utils.getSplit64Low(), jspb.utils.getSplit64High());

}

expect(decoder.readSplitZigzagVarint64(hexJoin))

.toEqual(hexJoinHash(hashA));

expect(decoder.readSplitZigzagVarint64(hexJoin))

.toEqual(hexJoinHash(hashB));

expect(decoder.readSplitZigzagVarint64(hexJoin))

.toEqual(hexJoinHash(hashC));

expect(decoder.readSplitZigzagVarint64(hexJoin))

.toEqual(hexJoinHash(hashD));

});

it('does zigzag encoding properly', () => {

// Test cases directly from the protobuf dev guide.

// https://engdoc.corp.google.com/eng/howto/protocolbuffers/developerguide/encoding.shtml?cl=head#types

const testCases = [

{original: '0', zigzag: '0'},

{original: '-1', zigzag: '1'},

{original: '1', zigzag: '2'},

{original: '-2', zigzag: '3'},

{original: '2147483647', zigzag: '4294967294'},

{original: '-2147483648', zigzag: '4294967295'},

// 64-bit extremes, not in dev guide.

{original: '9223372036854775807', zigzag: '18446744073709551614'},

{original: '-9223372036854775808', zigzag: '18446744073709551615'},

// None of the above catch: bitsLow < 0 && bitsHigh > 0 && bitsHigh <

// 0x1FFFFF. The following used to be broken.

{original: '72000000000', zigzag: '144000000000'},

];

const encoder = new jspb.BinaryEncoder();

testCases.forEach(function(c) {

encoder.writeZigzagVarint64String(c.original);

});

const buffer = encoder.end();

const zigzagDecoder = jspb.BinaryDecoder.alloc(buffer);

const varintDecoder = jspb.BinaryDecoder.alloc(buffer);

testCases.forEach(function(c) {

expect(zigzagDecoder.readZigzagVarint64String()).toEqual(c.original);

expect(varintDecoder.readUnsignedVarint64String()).toEqual(c.zigzag);

});

});

});

/**

* Tests reading and writing large strings

*/

it('testLargeStrings', () => {

const encoder = new jspb.BinaryEncoder();

const len = 150000;

let long_string = '';

for (let i = 0; i < len; i++) {

long_string += 'a';

}

encoder.writeString(long_string);

const decoder = jspb.BinaryDecoder.alloc(encoder.end());

expect(decoder.readString(len)).toEqual(long_string);

});

/**

* Test encoding and decoding utf-8.

*/

it('testUtf8', () => {

const encoder = new jspb.BinaryEncoder();

const ascii = 'ASCII should work in 3, 2, 1...';

const utf8_two_bytes = '©';

const utf8_three_bytes = '❄';

const utf8_four_bytes = '😁';

encoder.writeString(ascii);

encoder.writeString(utf8_two_bytes);

encoder.writeString(utf8_three_bytes);

encoder.writeString(utf8_four_bytes);

const decoder = jspb.BinaryDecoder.alloc(encoder.end());

expect(decoder.readString(ascii.length)).toEqual(ascii);

expect(utf8_two_bytes).toEqual(decoder.readString(utf8_two_bytes.length));

expect(utf8_three_bytes)

.toEqual(decoder.readString(utf8_three_bytes.length));

expect(utf8_four_bytes).toEqual(decoder.readString(utf8_four_bytes.length));

});

/**

* Verifies that passing a non-string to writeString raises an error.

*/

it('testBadString', () => {

const encoder = new jspb.BinaryEncoder();

expect(() => {

encoder.writeString(42)

}).toThrow();

expect(() => {

encoder.writeString(null)

}).toThrow();

});

/**

* Verifies that misuse of the decoder class triggers assertions.

*/

it('testDecodeErrors', () => {

// Reading a value past the end of the stream should trigger an assertion.

const decoder = jspb.BinaryDecoder.alloc([0, 1, 2]);

expect(() => {

decoder.readUint64()

}).toThrow();

// Overlong varints should trigger assertions.

decoder.setBlock(

[255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0]);

expect(() => {

decoder.readUnsignedVarint64()

}).toThrow();

decoder.reset();

expect(() => {

decoder.readSignedVarint64()

}).toThrow();

decoder.reset();

expect(() => {

decoder.readZigzagVarint64()

}).toThrow();

decoder.reset();

expect(() => {

decoder.readUnsignedVarint32()

}).toThrow();

});

/**

* Tests encoding and decoding of unsigned integers.

*/

it('testUnsignedIntegers', () => {

doTestUnsignedValue(

jspb.BinaryDecoder.prototype.readUint8,

jspb.BinaryEncoder.prototype.writeUint8, 1, 0xFF, Math.round);

doTestUnsignedValue(

jspb.BinaryDecoder.prototype.readUint16,

jspb.BinaryEncoder.prototype.writeUint16, 1, 0xFFFF, Math.round);

doTestUnsignedValue(

jspb.BinaryDecoder.prototype.readUint32,

jspb.BinaryEncoder.prototype.writeUint32, 1, 0xFFFFFFFF, Math.round);

doTestUnsignedValue(

jspb.BinaryDecoder.prototype.readUnsignedVarint32,

jspb.BinaryEncoder.prototype.writeUnsignedVarint32, 1, 0xFFFFFFFF,

Math.round);

doTestUnsignedValue(

jspb.BinaryDecoder.prototype.readUint64,

jspb.BinaryEncoder.prototype.writeUint64, 1, Math.pow(2, 64) - 1025,

Math.round);

doTestUnsignedValue(

jspb.BinaryDecoder.prototype.readUnsignedVarint64,

jspb.BinaryEncoder.prototype.writeUnsignedVarint64, 1,

Math.pow(2, 64) - 1025, Math.round);

});

/**

* Tests encoding and decoding of signed integers.

*/

it('testSignedIntegers', () => {

doTestSignedValue(

jspb.BinaryDecoder.prototype.readInt8,

jspb.BinaryEncoder.prototype.writeInt8, 1, -0x80, 0x7F, Math.round);

doTestSignedValue(

jspb.BinaryDecoder.prototype.readInt16,

jspb.BinaryEncoder.prototype.writeInt16, 1, -0x8000, 0x7FFF,

Math.round);

doTestSignedValue(

jspb.BinaryDecoder.prototype.readInt32,

jspb.BinaryEncoder.prototype.writeInt32, 1, -0x80000000, 0x7FFFFFFF,

Math.round);

doTestSignedValue(

jspb.BinaryDecoder.prototype.readSignedVarint32,

jspb.BinaryEncoder.prototype.writeSignedVarint32, 1, -0x80000000,

0x7FFFFFFF, Math.round);

doTestSignedValue(

jspb.BinaryDecoder.prototype.readInt64,

jspb.BinaryEncoder.prototype.writeInt64, 1, -Math.pow(2, 63),

Math.pow(2, 63) - 513, Math.round);

doTestSignedValue(

jspb.BinaryDecoder.prototype.readSignedVarint64,

jspb.BinaryEncoder.prototype.writeSignedVarint64, 1, -Math.pow(2, 63),

Math.pow(2, 63) - 513, Math.round);

});

/**

* Tests encoding and decoding of floats.

*/

it('testFloats', () => {

/**

* @param {number} x

* @return {number}

*/

function truncate(x) {

const temp = new Float32Array(1);

temp[0] = x;

return temp[0];

}

doTestSignedValue(

jspb.BinaryDecoder.prototype.readFloat,

jspb.BinaryEncoder.prototype.writeFloat,

jspb.BinaryConstants.FLOAT32_EPS, -jspb.BinaryConstants.FLOAT32_MAX,

jspb.BinaryConstants.FLOAT32_MAX, truncate);

doTestSignedValue(

jspb.BinaryDecoder.prototype.readDouble,

jspb.BinaryEncoder.prototype.writeDouble,

jspb.BinaryConstants.FLOAT64_EPS * 10,

-jspb.BinaryConstants.FLOAT64_MAX, jspb.BinaryConstants.FLOAT64_MAX,

function(x) {

return x;

});

});

});