third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/js/binary/decoder_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 129 matching lines @@
   }
 
   // Encoding values outside the valid range should assert.
   assertThrows(function() {writeValue.call(encoder, lowerLimit * 1.1);});
   assertThrows(function() {writeValue.call(encoder, upperLimit * 1.1);});
 }
 
 describe('binaryDecoderTest', function() {
   /**
    * Tests the decoder instance cache.
-   * @suppress {visibility}
    */
-  it('testInstanceCache', function() {
+  it('testInstanceCache', /** @suppress {visibility} */ function() {
     // Empty the instance caches.
     jspb.BinaryDecoder.instanceCache_ = [];
 
     // Allocating and then freeing a decoder should put it in the instance
     // cache.
     jspb.BinaryDecoder.alloc().free();
 
     assertEquals(1, jspb.BinaryDecoder.instanceCache_.length);
 
     // Allocating and then freeing three decoders should leave us with three in
@@ skipping 40 matching lines @@
     assertEquals(hashA, decoder.readVarintHash64());
     assertEquals(hashB, decoder.readVarintHash64());
     assertEquals(hashC, decoder.readVarintHash64());
     assertEquals(hashD, decoder.readVarintHash64());
 
     assertEquals(hashA, decoder.readFixedHash64());
     assertEquals(hashB, decoder.readFixedHash64());
     assertEquals(hashC, decoder.readFixedHash64());
     assertEquals(hashD, decoder.readFixedHash64());
   });
+  
+  /**
+   * Test encoding and decoding utf-8.
+   */
+   it('testUtf8', function() {
+    var encoder = new jspb.BinaryEncoder();
 
+    var ascii = "ASCII should work in 3, 2, 1..."
+    var utf8_two_bytes = "©";
+    var utf8_three_bytes = "❄";
+    var utf8_four_bytes = "😁";
+    
+    encoder.writeString(ascii);
+    encoder.writeString(utf8_two_bytes);
+    encoder.writeString(utf8_three_bytes);
+    encoder.writeString(utf8_four_bytes);
+    
+    var decoder = jspb.BinaryDecoder.alloc(encoder.end());
+    
+    assertEquals(ascii, decoder.readString(ascii.length));
+    assertEquals(utf8_two_bytes, decoder.readString(utf8_two_bytes.length));
+    assertEquals(utf8_three_bytes, decoder.readString(utf8_three_bytes.length));
+    assertEquals(utf8_four_bytes, decoder.readString(utf8_four_bytes.length));
+   });
 
   /**
    * Verifies that misuse of the decoder class triggers assertions.
    * @suppress {checkTypes|visibility}
    */
   it('testDecodeErrors', function() {
     // Reading a value past the end of the stream should trigger an assertion.
     var decoder = jspb.BinaryDecoder.alloc([0, 1, 2]);
     assertThrows(function() {decoder.readUint64()});
 
@@ skipping 102 matching lines @@
 
     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; });
   });
 });