// 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 reader. * * 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('goog.testing.asserts'); goog.require('jspb.BinaryConstants'); goog.require('jspb.BinaryDecoder'); goog.require('jspb.BinaryReader'); goog.require('jspb.BinaryWriter'); describe('binaryReaderTest', function() { /** * Tests the reader instance cache. */ it('testInstanceCaches', /** @suppress {visibility} */ function() { var writer = new jspb.BinaryWriter(); var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); writer.writeMessage(1, dummyMessage, goog.nullFunction); writer.writeMessage(2, dummyMessage, goog.nullFunction); var buffer = writer.getResultBuffer(); // Empty the instance caches. jspb.BinaryReader.instanceCache_ = []; // Allocating and then freeing three decoders should leave us with three in // the cache. var decoder1 = jspb.BinaryDecoder.alloc(); var decoder2 = jspb.BinaryDecoder.alloc(); var decoder3 = jspb.BinaryDecoder.alloc(); decoder1.free(); decoder2.free(); decoder3.free(); assertEquals(3, jspb.BinaryDecoder.instanceCache_.length); assertEquals(0, jspb.BinaryReader.instanceCache_.length); // Allocating and then freeing a reader should remove one decoder from its // cache, but it should stay stuck to the reader afterwards since we can't // have a reader without a decoder. jspb.BinaryReader.alloc().free(); assertEquals(2, jspb.BinaryDecoder.instanceCache_.length); assertEquals(1, jspb.BinaryReader.instanceCache_.length); // Allocating a reader should remove a reader from the cache. var reader = jspb.BinaryReader.alloc(buffer); assertEquals(2, jspb.BinaryDecoder.instanceCache_.length); assertEquals(0, jspb.BinaryReader.instanceCache_.length); // Processing the message reuses the current reader. reader.nextField(); assertEquals(1, reader.getFieldNumber()); reader.readMessage(dummyMessage, function() { assertEquals(0, jspb.BinaryReader.instanceCache_.length); }); reader.nextField(); assertEquals(2, reader.getFieldNumber()); reader.readMessage(dummyMessage, function() { assertEquals(0, jspb.BinaryReader.instanceCache_.length); }); assertEquals(false, reader.nextField()); assertEquals(2, jspb.BinaryDecoder.instanceCache_.length); assertEquals(0, jspb.BinaryReader.instanceCache_.length); // Freeing the reader should put it back into the cache. reader.free(); assertEquals(2, jspb.BinaryDecoder.instanceCache_.length); assertEquals(1, jspb.BinaryReader.instanceCache_.length); }); /** * @param {number} x * @return {number} */ function truncate(x) { var temp = new Float32Array(1); temp[0] = x; return temp[0]; } /** * Verifies that misuse of the reader class triggers assertions. */ it('testReadErrors', /** @suppress {checkTypes|visibility} */ function() { // Calling readMessage on a non-delimited field should trigger an // assertion. var reader = jspb.BinaryReader.alloc([8, 1]); var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); reader.nextField(); assertThrows(function() { reader.readMessage(dummyMessage, goog.nullFunction); }); // Reading past the end of the stream should trigger an assertion. reader = jspb.BinaryReader.alloc([9, 1]); reader.nextField(); assertThrows(function() {reader.readFixed64()}); // Reading past the end of a submessage should trigger an assertion. reader = jspb.BinaryReader.alloc([10, 4, 13, 1, 1, 1]); reader.nextField(); reader.readMessage(dummyMessage, function() { reader.nextField(); assertThrows(function() {reader.readFixed32()}); }); // Skipping an invalid field should trigger an assertion. reader = jspb.BinaryReader.alloc([12, 1]); reader.nextWireType_ = 1000; assertThrows(function() {reader.skipField()}); // Reading fields with the wrong wire type should assert. reader = jspb.BinaryReader.alloc([9, 0, 0, 0, 0, 0, 0, 0, 0]); reader.nextField(); assertThrows(function() {reader.readInt32()}); assertThrows(function() {reader.readInt32String()}); assertThrows(function() {reader.readInt64()}); assertThrows(function() {reader.readInt64String()}); assertThrows(function() {reader.readUint32()}); assertThrows(function() {reader.readUint32String()}); assertThrows(function() {reader.readUint64()}); assertThrows(function() {reader.readUint64String()}); assertThrows(function() {reader.readSint32()}); assertThrows(function() {reader.readBool()}); assertThrows(function() {reader.readEnum()}); reader = jspb.BinaryReader.alloc([8, 1]); reader.nextField(); assertThrows(function() {reader.readFixed32()}); assertThrows(function() {reader.readFixed64()}); assertThrows(function() {reader.readSfixed32()}); assertThrows(function() {reader.readSfixed64()}); assertThrows(function() {reader.readFloat()}); assertThrows(function() {reader.readDouble()}); assertThrows(function() {reader.readString()}); assertThrows(function() {reader.readBytes()}); }); /** * Tests encoding and decoding of unsigned field types. * @param {Function} readField * @param {Function} writeField * @param {number} epsilon * @param {number} upperLimit * @param {Function} filter * @private * @suppress {missingProperties} */ var doTestUnsignedField_ = function(readField, writeField, epsilon, upperLimit, filter) { assertNotNull(readField); assertNotNull(writeField); var writer = new jspb.BinaryWriter(); // Encode zero and limits. writeField.call(writer, 1, filter(0)); writeField.call(writer, 2, filter(epsilon)); writeField.call(writer, 3, filter(upperLimit)); // Encode positive values. for (var cursor = epsilon; cursor < upperLimit; cursor *= 1.1) { writeField.call(writer, 4, filter(cursor)); } var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); // Check zero and limits. reader.nextField(); assertEquals(1, reader.getFieldNumber()); assertEquals(filter(0), readField.call(reader)); reader.nextField(); assertEquals(2, reader.getFieldNumber()); assertEquals(filter(epsilon), readField.call(reader)); reader.nextField(); assertEquals(3, reader.getFieldNumber()); assertEquals(filter(upperLimit), readField.call(reader)); // Check positive values. for (var cursor = epsilon; cursor < upperLimit; cursor *= 1.1) { reader.nextField(); if (4 != reader.getFieldNumber()) throw 'fail!'; if (filter(cursor) != readField.call(reader)) throw 'fail!'; } }; /** * Tests encoding and decoding of signed field types. * @param {Function} readField * @param {Function} writeField * @param {number} epsilon * @param {number} lowerLimit * @param {number} upperLimit * @param {Function} filter * @private * @suppress {missingProperties} */ var doTestSignedField_ = function(readField, writeField, epsilon, lowerLimit, upperLimit, filter) { var writer = new jspb.BinaryWriter(); // Encode zero and limits. writeField.call(writer, 1, filter(lowerLimit)); writeField.call(writer, 2, filter(-epsilon)); writeField.call(writer, 3, filter(0)); writeField.call(writer, 4, filter(epsilon)); writeField.call(writer, 5, filter(upperLimit)); var inputValues = []; // Encode negative values. for (var cursor = lowerLimit; cursor < -epsilon; cursor /= 1.1) { var val = filter(cursor); writeField.call(writer, 6, val); inputValues.push({ fieldNumber: 6, value: val }); } // Encode positive values. for (var cursor = epsilon; cursor < upperLimit; cursor *= 1.1) { var val = filter(cursor); writeField.call(writer, 7, val); inputValues.push({ fieldNumber: 7, value: val }); } var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); // Check zero and limits. reader.nextField(); assertEquals(1, reader.getFieldNumber()); assertEquals(filter(lowerLimit), readField.call(reader)); reader.nextField(); assertEquals(2, reader.getFieldNumber()); assertEquals(filter(-epsilon), readField.call(reader)); reader.nextField(); assertEquals(3, reader.getFieldNumber()); assertEquals(filter(0), readField.call(reader)); reader.nextField(); assertEquals(4, reader.getFieldNumber()); assertEquals(filter(epsilon), readField.call(reader)); reader.nextField(); assertEquals(5, reader.getFieldNumber()); assertEquals(filter(upperLimit), readField.call(reader)); for (var i = 0; i < inputValues.length; i++) { var expected = inputValues[i]; reader.nextField(); assertEquals(expected.fieldNumber, reader.getFieldNumber()); assertEquals(expected.value, readField.call(reader)); } }; /** * Tests fields that use varint encoding. */ it('testVarintFields', function() { assertNotUndefined(jspb.BinaryReader.prototype.readUint32); assertNotUndefined(jspb.BinaryWriter.prototype.writeUint32); assertNotUndefined(jspb.BinaryReader.prototype.readUint64); assertNotUndefined(jspb.BinaryWriter.prototype.writeUint64); assertNotUndefined(jspb.BinaryReader.prototype.readBool); assertNotUndefined(jspb.BinaryWriter.prototype.writeBool); doTestUnsignedField_( jspb.BinaryReader.prototype.readUint32, jspb.BinaryWriter.prototype.writeUint32, 1, Math.pow(2, 32) - 1, Math.round); doTestUnsignedField_( jspb.BinaryReader.prototype.readUint64, jspb.BinaryWriter.prototype.writeUint64, 1, Math.pow(2, 64) - 1025, Math.round); doTestSignedField_( jspb.BinaryReader.prototype.readInt32, jspb.BinaryWriter.prototype.writeInt32, 1, -Math.pow(2, 31), Math.pow(2, 31) - 1, Math.round); doTestSignedField_( jspb.BinaryReader.prototype.readInt64, jspb.BinaryWriter.prototype.writeInt64, 1, -Math.pow(2, 63), Math.pow(2, 63) - 513, Math.round); doTestSignedField_( jspb.BinaryReader.prototype.readEnum, jspb.BinaryWriter.prototype.writeEnum, 1, -Math.pow(2, 31), Math.pow(2, 31) - 1, Math.round); doTestUnsignedField_( jspb.BinaryReader.prototype.readBool, jspb.BinaryWriter.prototype.writeBool, 1, 1, function(x) { return !!x; }); }); /** * Tests reading a field from hexadecimal string (format: '08 BE EF'). * @param {Function} readField * @param {number} expected * @param {string} hexString */ function doTestHexStringVarint_(readField, expected, hexString) { var bytesCount = (hexString.length + 1) / 3; var bytes = new Uint8Array(bytesCount); for (var i = 0; i < bytesCount; i++) { bytes[i] = parseInt(hexString.substring(i * 3, i * 3 + 2), 16); } var reader = jspb.BinaryReader.alloc(bytes); reader.nextField(); assertEquals(expected, readField.call(reader)); } /** * Tests non-canonical redundant varint decoding. */ it('testRedundantVarintFields', function() { assertNotNull(jspb.BinaryReader.prototype.readUint32); assertNotNull(jspb.BinaryReader.prototype.readUint64); assertNotNull(jspb.BinaryReader.prototype.readSint32); assertNotNull(jspb.BinaryReader.prototype.readSint64); // uint32 and sint32 take no more than 5 bytes // 08 - field prefix (type = 0 means varint) doTestHexStringVarint_( jspb.BinaryReader.prototype.readUint32, 12, '08 8C 80 80 80 00'); // 11 stands for -6 in zigzag encoding doTestHexStringVarint_( jspb.BinaryReader.prototype.readSint32, -6, '08 8B 80 80 80 00'); // uint64 and sint64 take no more than 10 bytes // 08 - field prefix (type = 0 means varint) doTestHexStringVarint_( jspb.BinaryReader.prototype.readUint64, 12, '08 8C 80 80 80 80 80 80 80 80 00'); // 11 stands for -6 in zigzag encoding doTestHexStringVarint_( jspb.BinaryReader.prototype.readSint64, -6, '08 8B 80 80 80 80 80 80 80 80 00'); }); /** * Tests reading 64-bit integers as split values. */ it('handles split 64 fields', function() { var writer = new jspb.BinaryWriter(); writer.writeInt64String(1, '4294967296'); writer.writeSfixed64String(2, '4294967298'); var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); function rejoin(lowBits, highBits) { return highBits * 2 ** 32 + (lowBits >>> 0); } reader.nextField(); expect(reader.getFieldNumber()).toEqual(1); expect(reader.readSplitVarint64(rejoin)).toEqual(0x100000000); reader.nextField(); expect(reader.getFieldNumber()).toEqual(2); expect(reader.readSplitFixed64(rejoin)).toEqual(0x100000002); }); /** * Tests 64-bit fields that are handled as strings. */ it('testStringInt64Fields', function() { var writer = new jspb.BinaryWriter(); var testSignedData = [ '2730538252207801776', '-2688470994844604560', '3398529779486536359', '3568577411627971000', '272477188847484900', '-6649058714086158188', '-7695254765712060806', '-4525541438037104029', '-4993706538836508568', '4990160321893729138' ]; var testUnsignedData = [ '7822732630241694882', '6753602971916687352', '2399935075244442116', '8724292567325338867', '16948784802625696584', '4136275908516066934', '3575388346793700364', '5167142028379259461', '1557573948689737699', '17100725280812548567' ]; for (var i = 0; i < testSignedData.length; i++) { writer.writeInt64String(2 * i + 1, testSignedData[i]); writer.writeUint64String(2 * i + 2, testUnsignedData[i]); } var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); for (var i = 0; i < testSignedData.length; i++) { reader.nextField(); assertEquals(2 * i + 1, reader.getFieldNumber()); assertEquals(testSignedData[i], reader.readInt64String()); reader.nextField(); assertEquals(2 * i + 2, reader.getFieldNumber()); assertEquals(testUnsignedData[i], reader.readUint64String()); } }); /** * Tests fields that use zigzag encoding. */ it('testZigzagFields', function() { doTestSignedField_( jspb.BinaryReader.prototype.readSint32, jspb.BinaryWriter.prototype.writeSint32, 1, -Math.pow(2, 31), Math.pow(2, 31) - 1, Math.round); doTestSignedField_( jspb.BinaryReader.prototype.readSint64, jspb.BinaryWriter.prototype.writeSint64, 1, -Math.pow(2, 63), Math.pow(2, 63) - 513, Math.round); }); /** * Tests fields that use fixed-length encoding. */ it('testFixedFields', function() { doTestUnsignedField_( jspb.BinaryReader.prototype.readFixed32, jspb.BinaryWriter.prototype.writeFixed32, 1, Math.pow(2, 32) - 1, Math.round); doTestUnsignedField_( jspb.BinaryReader.prototype.readFixed64, jspb.BinaryWriter.prototype.writeFixed64, 1, Math.pow(2, 64) - 1025, Math.round); doTestSignedField_( jspb.BinaryReader.prototype.readSfixed32, jspb.BinaryWriter.prototype.writeSfixed32, 1, -Math.pow(2, 31), Math.pow(2, 31) - 1, Math.round); doTestSignedField_( jspb.BinaryReader.prototype.readSfixed64, jspb.BinaryWriter.prototype.writeSfixed64, 1, -Math.pow(2, 63), Math.pow(2, 63) - 513, Math.round); }); /** * Tests floating point fields. */ it('testFloatFields', function() { doTestSignedField_( jspb.BinaryReader.prototype.readFloat, jspb.BinaryWriter.prototype.writeFloat, jspb.BinaryConstants.FLOAT32_MIN, -jspb.BinaryConstants.FLOAT32_MAX, jspb.BinaryConstants.FLOAT32_MAX, truncate); doTestSignedField_( jspb.BinaryReader.prototype.readDouble, jspb.BinaryWriter.prototype.writeDouble, jspb.BinaryConstants.FLOAT64_EPS * 10, -jspb.BinaryConstants.FLOAT64_MIN, jspb.BinaryConstants.FLOAT64_MIN, function(x) { return x; }); }); /** * Tests length-delimited string fields. */ it('testStringFields', function() { var s1 = 'The quick brown fox jumps over the lazy dog.'; var s2 = '人人生而自由，在尊嚴和權利上一律平等。'; var writer = new jspb.BinaryWriter(); writer.writeString(1, s1); writer.writeString(2, s2); var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); reader.nextField(); assertEquals(1, reader.getFieldNumber()); assertEquals(s1, reader.readString()); reader.nextField(); assertEquals(2, reader.getFieldNumber()); assertEquals(s2, reader.readString()); }); /** * Tests length-delimited byte fields. */ it('testByteFields', function() { var message = []; var lowerLimit = 1; var upperLimit = 256; var scale = 1.1; var writer = new jspb.BinaryWriter(); for (var cursor = lowerLimit; cursor < upperLimit; cursor *= 1.1) { var len = Math.round(cursor); var bytes = []; for (var i = 0; i < len; i++) bytes.push(i % 256); writer.writeBytes(len, bytes); } var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); for (var cursor = lowerLimit; reader.nextField(); cursor *= 1.1) { var len = Math.round(cursor); if (len != reader.getFieldNumber()) throw 'fail!'; var bytes = reader.readBytes(); if (len != bytes.length) throw 'fail!'; for (var i = 0; i < bytes.length; i++) { if (i % 256 != bytes[i]) throw 'fail!'; } } }); /** * Tests nested messages. */ it('testNesting', function() { var writer = new jspb.BinaryWriter(); var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); writer.writeInt32(1, 100); // Add one message with 3 int fields. writer.writeMessage(2, dummyMessage, function() { writer.writeInt32(3, 300); writer.writeInt32(4, 400); writer.writeInt32(5, 500); }); // Add one empty message. writer.writeMessage(6, dummyMessage, goog.nullFunction); writer.writeInt32(7, 700); var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); // Validate outermost message. reader.nextField(); assertEquals(1, reader.getFieldNumber()); assertEquals(100, reader.readInt32()); reader.nextField(); assertEquals(2, reader.getFieldNumber()); reader.readMessage(dummyMessage, function() { // Validate embedded message 1. reader.nextField(); assertEquals(3, reader.getFieldNumber()); assertEquals(300, reader.readInt32()); reader.nextField(); assertEquals(4, reader.getFieldNumber()); assertEquals(400, reader.readInt32()); reader.nextField(); assertEquals(5, reader.getFieldNumber()); assertEquals(500, reader.readInt32()); assertEquals(false, reader.nextField()); }); reader.nextField(); assertEquals(6, reader.getFieldNumber()); reader.readMessage(dummyMessage, function() { // Validate embedded message 2. assertEquals(false, reader.nextField()); }); reader.nextField(); assertEquals(7, reader.getFieldNumber()); assertEquals(700, reader.readInt32()); assertEquals(false, reader.nextField()); }); /** * Tests skipping fields of each type by interleaving them with sentinel * values and skipping everything that's not a sentinel. */ it('testSkipField', function() { var writer = new jspb.BinaryWriter(); var sentinel = 123456789; // Write varint fields of different sizes. writer.writeInt32(1, sentinel); writer.writeInt32(1, 1); writer.writeInt32(1, 1000); writer.writeInt32(1, 1000000); writer.writeInt32(1, 1000000000); // Write fixed 64-bit encoded fields. writer.writeInt32(2, sentinel); writer.writeDouble(2, 1); writer.writeFixed64(2, 1); writer.writeSfixed64(2, 1); // Write fixed 32-bit encoded fields. writer.writeInt32(3, sentinel); writer.writeFloat(3, 1); writer.writeFixed32(3, 1); writer.writeSfixed32(3, 1); // Write delimited fields. writer.writeInt32(4, sentinel); writer.writeBytes(4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); writer.writeString(4, 'The quick brown fox jumps over the lazy dog'); // Write a group with a nested group inside. writer.writeInt32(5, sentinel); var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); writer.writeGroup(5, dummyMessage, function() { // Previously the skipGroup implementation was wrong, which only consume // the decoder by nextField. This case is for making the previous // implementation failed in skipGroup by an early end group tag. // The reason is 44 = 5 * 8 + 4, this will be translated in to a field // with number 5 and with type 4 (end group) writer.writeInt64(44, 44); // This will make previous implementation failed by invalid tag (7). writer.writeInt64(42, 47); writer.writeInt64(42, 42); // This is for making the previous implementation failed by an invalid // varint. The bytes have at least 9 consecutive minus byte, which will // fail in this.nextField for previous implementation. writer.writeBytes(43, [255, 255, 255, 255, 255, 255, 255, 255, 255, 255]); writer.writeGroup(6, dummyMessage, function() { writer.writeInt64(84, 42); writer.writeInt64(84, 44); writer.writeBytes( 43, [255, 255, 255, 255, 255, 255, 255, 255, 255, 255]); }); }); // Write final sentinel. writer.writeInt32(6, sentinel); var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); function skip(field, count) { for (var i = 0; i < count; i++) { reader.nextField(); if (field != reader.getFieldNumber()) throw 'fail!'; reader.skipField(); } } reader.nextField(); assertEquals(1, reader.getFieldNumber()); assertEquals(sentinel, reader.readInt32()); skip(1, 4); reader.nextField(); assertEquals(2, reader.getFieldNumber()); assertEquals(sentinel, reader.readInt32()); skip(2, 3); reader.nextField(); assertEquals(3, reader.getFieldNumber()); assertEquals(sentinel, reader.readInt32()); skip(3, 3); reader.nextField(); assertEquals(4, reader.getFieldNumber()); assertEquals(sentinel, reader.readInt32()); skip(4, 2); reader.nextField(); assertEquals(5, reader.getFieldNumber()); assertEquals(sentinel, reader.readInt32()); skip(5, 1); reader.nextField(); assertEquals(6, reader.getFieldNumber()); assertEquals(sentinel, reader.readInt32()); }); /** * Tests packed fields. */ it('testPackedFields', function() { var writer = new jspb.BinaryWriter(); var sentinel = 123456789; var unsignedData = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; var signedData = [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]; var floatData = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10]; var doubleData = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10]; var boolData = [true, false, true, true, false, false, true, false]; for (var i = 0; i < floatData.length; i++) { floatData[i] = truncate(floatData[i]); } writer.writeInt32(1, sentinel); writer.writePackedInt32(2, signedData); writer.writePackedInt64(2, signedData); writer.writePackedUint32(2, unsignedData); writer.writePackedUint64(2, unsignedData); writer.writePackedSint32(2, signedData); writer.writePackedSint64(2, signedData); writer.writePackedFixed32(2, unsignedData); writer.writePackedFixed64(2, unsignedData); writer.writePackedSfixed32(2, signedData); writer.writePackedSfixed64(2, signedData); writer.writePackedFloat(2, floatData); writer.writePackedDouble(2, doubleData); writer.writePackedBool(2, boolData); writer.writePackedEnum(2, unsignedData); writer.writeInt32(3, sentinel); var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); reader.nextField(); assertEquals(sentinel, reader.readInt32()); reader.nextField(); assertElementsEquals(reader.readPackedInt32(), signedData); reader.nextField(); assertElementsEquals(reader.readPackedInt64(), signedData); reader.nextField(); assertElementsEquals(reader.readPackedUint32(), unsignedData); reader.nextField(); assertElementsEquals(reader.readPackedUint64(), unsignedData); reader.nextField(); assertElementsEquals(reader.readPackedSint32(), signedData); reader.nextField(); assertElementsEquals(reader.readPackedSint64(), signedData); reader.nextField(); assertElementsEquals(reader.readPackedFixed32(), unsignedData); reader.nextField(); assertElementsEquals(reader.readPackedFixed64(), unsignedData); reader.nextField(); assertElementsEquals(reader.readPackedSfixed32(), signedData); reader.nextField(); assertElementsEquals(reader.readPackedSfixed64(), signedData); reader.nextField(); assertElementsEquals(reader.readPackedFloat(), floatData); reader.nextField(); assertElementsEquals(reader.readPackedDouble(), doubleData); reader.nextField(); assertElementsEquals(reader.readPackedBool(), boolData); reader.nextField(); assertElementsEquals(reader.readPackedEnum(), unsignedData); reader.nextField(); assertEquals(sentinel, reader.readInt32()); }); /** * Byte blobs inside nested messages should always have their byte offset set * relative to the start of the outermost blob, not the start of their parent * blob. */ it('testNestedBlobs', function() { // Create a proto consisting of two nested messages, with the inner one // containing a blob of bytes. var fieldTag = (1 << 3) | jspb.BinaryConstants.WireType.DELIMITED; var blob = [1, 2, 3, 4, 5]; var writer = new jspb.BinaryWriter(); var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); writer.writeMessage(1, dummyMessage, function() { writer.writeMessage(1, dummyMessage, function() { writer.writeBytes(1, blob); }); }); // Peel off the outer two message layers. Each layer should have two bytes // of overhead, one for the field tag and one for the length of the inner // blob. var decoder1 = new jspb.BinaryDecoder(writer.getResultBuffer()); assertEquals(fieldTag, decoder1.readUnsignedVarint32()); assertEquals(blob.length + 4, decoder1.readUnsignedVarint32()); var decoder2 = new jspb.BinaryDecoder(decoder1.readBytes(blob.length + 4)); assertEquals(fieldTag, decoder2.readUnsignedVarint32()); assertEquals(blob.length + 2, decoder2.readUnsignedVarint32()); assertEquals(fieldTag, decoder2.readUnsignedVarint32()); assertEquals(blob.length, decoder2.readUnsignedVarint32()); var bytes = decoder2.readBytes(blob.length); assertElementsEquals(bytes, blob); }); /** * Tests read callbacks. */ it('testReadCallbacks', function() { var writer = new jspb.BinaryWriter(); var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); // Add an int, a submessage, and another int. writer.writeInt32(1, 100); writer.writeMessage(2, dummyMessage, function() { writer.writeInt32(3, 300); writer.writeInt32(4, 400); writer.writeInt32(5, 500); }); writer.writeInt32(7, 700); // Create the reader and register a custom read callback. var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); /** * @param {!jspb.BinaryReader} reader * @return {*} */ function readCallback(reader) { reader.nextField(); assertEquals(3, reader.getFieldNumber()); assertEquals(300, reader.readInt32()); reader.nextField(); assertEquals(4, reader.getFieldNumber()); assertEquals(400, reader.readInt32()); reader.nextField(); assertEquals(5, reader.getFieldNumber()); assertEquals(500, reader.readInt32()); assertEquals(false, reader.nextField()); }; reader.registerReadCallback('readCallback', readCallback); // Read the container message. reader.nextField(); assertEquals(1, reader.getFieldNumber()); assertEquals(100, reader.readInt32()); reader.nextField(); assertEquals(2, reader.getFieldNumber()); reader.readMessage(dummyMessage, function() { // Decode the embedded message using the registered callback. reader.runReadCallback('readCallback'); }); reader.nextField(); assertEquals(7, reader.getFieldNumber()); assertEquals(700, reader.readInt32()); assertEquals(false, reader.nextField()); }); });