third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/js/binary/reader_test.js

 // 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.
@@ skipping 34 matching lines @@
 goog.require('jspb.BinaryConstants');
 goog.require('jspb.BinaryDecoder');
 goog.require('jspb.BinaryReader');
 goog.require('jspb.BinaryWriter');
 
 
 
 describe('binaryReaderTest', function() {
   /**
    * Tests the reader instance cache.
-   * @suppress {visibility}
    */
-  it('testInstanceCaches', function() {
+  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_ = [];
 
@@ skipping 56 matching lines @@
    */
   function truncate(x) {
     var temp = new Float32Array(1);
     temp[0] = x;
     return temp[0];
   }
 
 
   /**
    * Verifies that misuse of the reader class triggers assertions.
-   * @suppress {checkTypes|visibility}
    */
-  it('testReadErrors', function() {
+  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.
@@ skipping 46 matching lines @@
   /**
    * 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}
    */
-  function doTestUnsignedField_(readField,
+  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));
@@ skipping 31 matching lines @@
    * 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}
    */
-  function doTestSignedField_(readField,
+  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));
 
@@ skipping 48 matching lines @@
       assertEquals(expected.fieldNumber, reader.getFieldNumber());
       assertEquals(expected.value, readField.call(reader));
     }
   };
 
 
   /**
    * Tests fields that use varint encoding.
    */
   it('testVarintFields', function() {
-    assertNotNull(jspb.BinaryReader.prototype.readUint32);
-    assertNotNull(jspb.BinaryReader.prototype.writeUint32);
-    assertNotNull(jspb.BinaryReader.prototype.readUint64);
-    assertNotNull(jspb.BinaryReader.prototype.writeUint64);
-    assertNotNull(jspb.BinaryReader.prototype.readBool);
-    assertNotNull(jspb.BinaryReader.prototype.writeBool);
+    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);
 
@@ skipping 13 matching lines @@
         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 64-bit fields that are handled as strings.
    */
   it('testStringInt64Fields', function() {
     var writer = new jspb.BinaryWriter();
 
     var testSignedData = [
       '2730538252207801776',
       '-2688470994844604560',
       '3398529779486536359',
       '3568577411627971000',
@@ skipping 491 matching lines @@
       reader.runReadCallback('readCallback');
     });
 
     reader.nextField();
     assertEquals(7, reader.getFieldNumber());
     assertEquals(700, reader.readInt32());
 
     assertEquals(false, reader.nextField());
   });
 });