third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/js/proto3_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 20 matching lines @@
 goog.require('goog.crypt.base64');
 goog.require('goog.testing.asserts');
 
 // CommonJS-LoadFromFile: testbinary_pb proto.jspb.test
 goog.require('proto.jspb.test.ForeignMessage');
 
 // CommonJS-LoadFromFile: proto3_test_pb proto.jspb.test
 goog.require('proto.jspb.test.Proto3Enum');
 goog.require('proto.jspb.test.TestProto3');
 
+// CommonJS-LoadFromFile: google/protobuf/timestamp_pb proto.google.protobuf
+goog.require('proto.google.protobuf.Timestamp');
+
+// CommonJS-LoadFromFile: google/protobuf/struct_pb proto.google.protobuf
+goog.require('proto.google.protobuf.Struct');
+
 
 var BYTES = new Uint8Array([1, 2, 8, 9]);
 var BYTES_B64 = goog.crypt.base64.encodeByteArray(BYTES);
 
 
 /**
  * Helper: compare a bytes field to an expected value
  * @param {Uint8Array|string} arr
  * @param {Uint8Array} expected
  * @return {boolean}
@@ skipping 163 matching lines @@
     assertEquals(msg.getOneofString(), 'asdf');
   });
 
 
   /**
    * Test that oneofs continue to have a notion of field presence.
    */
   it('testOneofs', function() {
     var msg = new proto.jspb.test.TestProto3();
 
-    assertEquals(msg.getOneofUint32(), undefined);
+    assertEquals(msg.getOneofUint32(), 0);
     assertEquals(msg.getOneofForeignMessage(), undefined);
-    assertEquals(msg.getOneofString(), undefined);
-    assertEquals(msg.getOneofBytes(), undefined);
+    assertEquals(msg.getOneofString(), '');
+    assertEquals(msg.getOneofBytes(), '');
+    assertFalse(msg.hasOneofUint32());
+    assertFalse(msg.hasOneofString());
+    assertFalse(msg.hasOneofBytes());
 
     msg.setOneofUint32(42);
     assertEquals(msg.getOneofUint32(), 42);
     assertEquals(msg.getOneofForeignMessage(), undefined);
-    assertEquals(msg.getOneofString(), undefined);
-    assertEquals(msg.getOneofBytes(), undefined);
+    assertEquals(msg.getOneofString(), '');
+    assertEquals(msg.getOneofBytes(), '');
+    assertTrue(msg.hasOneofUint32());
+    assertFalse(msg.hasOneofString());
+    assertFalse(msg.hasOneofBytes());
 
 
     var submsg = new proto.jspb.test.ForeignMessage();
     msg.setOneofForeignMessage(submsg);
-    assertEquals(msg.getOneofUint32(), undefined);
+    assertEquals(msg.getOneofUint32(), 0);
     assertEquals(msg.getOneofForeignMessage(), submsg);
-    assertEquals(msg.getOneofString(), undefined);
-    assertEquals(msg.getOneofBytes(), undefined);
+    assertEquals(msg.getOneofString(), '');
+    assertEquals(msg.getOneofBytes(), '');
+    assertFalse(msg.hasOneofUint32());
+    assertFalse(msg.hasOneofString());
+    assertFalse(msg.hasOneofBytes());
 
     msg.setOneofString('hello');
-    assertEquals(msg.getOneofUint32(), undefined);
+    assertEquals(msg.getOneofUint32(), 0);
     assertEquals(msg.getOneofForeignMessage(), undefined);
     assertEquals(msg.getOneofString(), 'hello');
-    assertEquals(msg.getOneofBytes(), undefined);
+    assertEquals(msg.getOneofBytes(), '');
+    assertFalse(msg.hasOneofUint32());
+    assertTrue(msg.hasOneofString());
+    assertFalse(msg.hasOneofBytes());
 
     msg.setOneofBytes(goog.crypt.base64.encodeString('\u00FF\u00FF'));
-    assertEquals(msg.getOneofUint32(), undefined);
+    assertEquals(msg.getOneofUint32(), 0);
     assertEquals(msg.getOneofForeignMessage(), undefined);
-    assertEquals(msg.getOneofString(), undefined);
+    assertEquals(msg.getOneofString(), '');
     assertEquals(msg.getOneofBytes_asB64(),
         goog.crypt.base64.encodeString('\u00FF\u00FF'));
+    assertFalse(msg.hasOneofUint32());
+    assertFalse(msg.hasOneofString());
+    assertTrue(msg.hasOneofBytes());
   });
 
 
   /**
    * Test that "default"-valued primitive fields are not emitted on the wire.
    */
   it('testNoSerializeDefaults', function() {
     var msg = new proto.jspb.test.TestProto3();
 
     // Set each primitive to a non-default value, then back to its default, to
     // ensure that the serialization is actually checking the value and not just
     // whether it has ever been set.
     msg.setOptionalInt32(42);
     msg.setOptionalInt32(0);
     msg.setOptionalDouble(3.14);
     msg.setOptionalDouble(0.0);
     msg.setOptionalBool(true);
     msg.setOptionalBool(false);
     msg.setOptionalString('hello world');
     msg.setOptionalString('');
     msg.setOptionalBytes(goog.crypt.base64.encodeString('\u00FF\u00FF'));
     msg.setOptionalBytes('');
     msg.setOptionalForeignMessage(new proto.jspb.test.ForeignMessage());
     msg.setOptionalForeignMessage(null);
     msg.setOptionalForeignEnum(proto.jspb.test.Proto3Enum.PROTO3_BAR);
     msg.setOptionalForeignEnum(proto.jspb.test.Proto3Enum.PROTO3_FOO);
     msg.setOneofUint32(32);
-    msg.setOneofUint32(null);
+    msg.clearOneofUint32();
 
 
     var serialized = msg.serializeBinary();
     assertEquals(0, serialized.length);
   });
 
   /**
    * Test that base64 string and Uint8Array are interchangeable in bytes fields.
    */
   it('testBytesFieldsInterop', function() {
@@ skipping 11 matching lines @@
     assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES));
 
     msg = new proto.jspb.test.TestProto3();
     // Set as a Uint8Array and check all the getters work.
     msg.setOptionalBytes(BYTES);
     assertTrue(bytesCompare(msg.getOptionalBytes_asU8(), BYTES));
     assertTrue(bytesCompare(msg.getOptionalBytes_asB64(), BYTES));
     assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES));
 
   });
+
+  it('testTimestampWellKnownType', function() {
+    var msg = new proto.google.protobuf.Timestamp();
+    msg.fromDate(new Date(123456789));
+    assertEquals(123456, msg.getSeconds());
+    assertEquals(789000000, msg.getNanos());
+    var date = msg.toDate();
+    assertEquals(123456789, date.getTime());
+  });
+
+  it('testStructWellKnownType', function() {
+    var jsObj = {
+      abc: "def",
+      number: 12345.678,
+      nullKey: null,
+      boolKey: true,
+      listKey: [1, null, true, false, "abc"],
+      structKey: {foo: "bar", somenum: 123},
+      complicatedKey: [{xyz: {abc: [3, 4, null, false]}}, "zzz"]
+    };
+
+    var struct = proto.google.protobuf.Struct.fromJavaScript(jsObj);
+    var jsObj2 = struct.toJavaScript();
+
+    assertEquals("def", jsObj2.abc);
+    assertEquals(12345.678, jsObj2.number);
+    assertEquals(null, jsObj2.nullKey);
+    assertEquals(true, jsObj2.boolKey);
+    assertEquals("abc", jsObj2.listKey[4]);
+    assertEquals("bar", jsObj2.structKey.foo);
+    assertEquals(4, jsObj2.complicatedKey[0].xyz.abc[1]);
+  });
 });