Update third_party/protobuf to protobuf-v3.0.0-beta-3

third_party/protobuf/js/binary/utils_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 179 matching lines @@
     result = jspb.utils.hash64ArrayToDecimalStrings([
       toHashString(0xFFFFFFFF, 0xFFFFFFFF),
       toHashString(0x00000000, 0x80000000),
       toHashString(0xacd05f15, 0x01b69b4b)], false);
     assertEquals(3, result.length);
     assertEquals('18446744073709551615', result[0]);
     assertEquals('9223372036854775808', result[1]);
     assertEquals('123456789123456789', result[2]);
   });
 
+  /*
+   * Going from decimal strings to hash strings should be lossless.
+   */
+  it('testDecimalToHashConversion', function() {
+    var result;
+    var convert = jspb.utils.decimalStringToHash64;
+
+    result = convert('0');
+    assertEquals(String.fromCharCode.apply(null,
+      [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]), result);
+
+    result = convert('-1');
+    assertEquals(String.fromCharCode.apply(null,
+      [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]), result);
+
+    result = convert('18446744073709551615');
+    assertEquals(String.fromCharCode.apply(null,
+      [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]), result);
+
+    result = convert('9223372036854775808');
+    assertEquals(String.fromCharCode.apply(null,
+      [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80]), result);
+
+    result = convert('-9223372036854775808');
+    assertEquals(String.fromCharCode.apply(null,
+      [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80]), result);
+
+    result = convert('123456789123456789');
+    assertEquals(String.fromCharCode.apply(null,
+      [0x15, 0x5F, 0xD0, 0xAC, 0x4B, 0x9B, 0xB6, 0x01]), result);
+
+    result = convert('-123456789123456789');
+    assertEquals(String.fromCharCode.apply(null,
+      [0xEB, 0xA0, 0x2F, 0x53, 0xB4, 0x64, 0x49, 0xFE]), result);
+  });
 
   /**
    * Going from hash strings to hex strings should be lossless.
    */
   it('testHashToHexConversion', function() {
     var result;
     var convert = jspb.utils.hash64ToHexString;
 
     result = convert(toHashString(0x00000000, 0x00000000));
     assertEquals('0x0000000000000000', result);
@@ skipping 93 matching lines @@
    * Tests conversion from 32-bit floating point numbers to split64 numbers.
    */
   it('testFloat32ToSplit64', function() {
     var f32_eps = jspb.BinaryConstants.FLOAT32_EPS;
     var f32_min = jspb.BinaryConstants.FLOAT32_MIN;
     var f32_max = jspb.BinaryConstants.FLOAT32_MAX;
 
     // NaN.
     jspb.utils.splitFloat32(NaN);
     if (!isNaN(jspb.utils.joinFloat32(jspb.utils.split64Low,
-                                         jspb.utils.split64High))) {
+                                      jspb.utils.split64High))) {
       throw 'fail!';
     }
 
     /**
      * @param {number} x
      * @param {number=} opt_bits
      */
     function test(x, opt_bits) {
       jspb.utils.splitFloat32(x);
       if (goog.isDef(opt_bits)) {
         if (opt_bits != jspb.utils.split64Low) throw 'fail!';
       }
       if (truncate(x) != jspb.utils.joinFloat32(jspb.utils.split64Low,
-                                                   jspb.utils.split64High)) {
+          jspb.utils.split64High)) {
         throw 'fail!';
       }
     }
 
     // Positive and negative infinity.
     test(Infinity, 0x7f800000);
     test(-Infinity, 0xff800000);
 
     // Positive and negative zero.
     test(0, 0x00000000);
@@ skipping 31 matching lines @@
    * Tests conversion from 64-bit floating point numbers to split64 numbers.
    */
   it('testFloat64ToSplit64', function() {
     var f64_eps = jspb.BinaryConstants.FLOAT64_EPS;
     var f64_min = jspb.BinaryConstants.FLOAT64_MIN;
     var f64_max = jspb.BinaryConstants.FLOAT64_MAX;
 
     // NaN.
     jspb.utils.splitFloat64(NaN);
     if (!isNaN(jspb.utils.joinFloat64(jspb.utils.split64Low,
-                                         jspb.utils.split64High))) {
+        jspb.utils.split64High))) {
       throw 'fail!';
     }
 
     /**
      * @param {number} x
      * @param {number=} opt_highBits
      * @param {number=} opt_lowBits
      */
     function test(x, opt_highBits, opt_lowBits) {
       jspb.utils.splitFloat64(x);
       if (goog.isDef(opt_highBits)) {
         if (opt_highBits != jspb.utils.split64High) throw 'fail!';
       }
       if (goog.isDef(opt_lowBits)) {
         if (opt_lowBits != jspb.utils.split64Low) throw 'fail!';
       }
       if (x != jspb.utils.joinFloat64(jspb.utils.split64Low,
-                                         jspb.utils.split64High)) {
+          jspb.utils.split64High)) {
         throw 'fail!';
       }
     }
 
     // Positive and negative infinity.
     test(Infinity, 0x7ff00000, 0x00000000);
     test(-Infinity, 0xfff00000, 0x00000000);
 
     // Positive and negative zero.
     test(0, 0x00000000, 0x00000000);
@@ skipping 24 matching lines @@
       test(cursor);
       cursor *= 1.1;
     }
   });
 
 
   /**
    * Tests counting packed varints.
    */
   it('testCountVarints', function() {
-    var writer = new jspb.BinaryWriter();
-
-    var count = 0;
+    var values = [];
     for (var i = 1; i < 1000000000; i *= 1.1) {
-      writer.rawWriteVarint(Math.floor(i));
-      count++;
+      values.push(Math.floor(i));
     }
 
+    var writer = new jspb.BinaryWriter();
+    writer.writePackedUint64(1, values);
+
     var buffer = new Uint8Array(writer.getResultBuffer());
-    assertEquals(count, jspb.utils.countVarints(buffer, 0, buffer.length));
+
+    // We should have two more varints than we started with - one for the field
+    // tag, one for the packed length.
+    assertEquals(values.length + 2,
+                 jspb.utils.countVarints(buffer, 0, buffer.length));
   });
 
 
   /**
    * Tests counting matching varint fields.
    */
   it('testCountVarintFields', function() {
     var writer = new jspb.BinaryWriter();
 
     var count = 0;
@@ skipping 156 matching lines @@
     assertEquals(sourceBytes, convert(sourceBytes));
 
     // Converting Array.<numbers> into Uint8Arrays should work.
     check(convert(sourceData));
 
     // Converting ArrayBuffers into Uint8Arrays should work.
     check(convert(sourceBuffer));
 
     // Converting base64-encoded strings into Uint8Arrays should work.
     check(convert(sourceBase64));
-
-    // Converting binary-data strings into Uint8Arrays should work.
-    check(convert(sourceString, /* opt_stringIsRawBytes = */ true));
   });
 });