Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/js/message_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 16 matching lines @@
 // 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.
 
 // Test suite is written using Jasmine -- see http://jasmine.github.io/
 
 goog.setTestOnly();
 
 goog.require('goog.json');
 goog.require('goog.testing.asserts');
-goog.require('goog.userAgent');
 
 // CommonJS-LoadFromFile: google-protobuf jspb
 goog.require('jspb.Message');
 
 // CommonJS-LoadFromFile: test5_pb proto.jspb.exttest.beta
 goog.require('proto.jspb.exttest.beta.floatingStrField');
 
 // CommonJS-LoadFromFile: test3_pb proto.jspb.exttest
 goog.require('proto.jspb.exttest.floatingMsgField');
 
@@ skipping 12 matching lines @@
 goog.require('proto.jspb.test.HasExtensions');
 goog.require('proto.jspb.test.IndirectExtension');
 goog.require('proto.jspb.test.IsExtension');
 goog.require('proto.jspb.test.OptionalFields');
 goog.require('proto.jspb.test.OuterEnum');
 goog.require('proto.jspb.test.OuterMessage.Complex');
 goog.require('proto.jspb.test.Simple1');
 goog.require('proto.jspb.test.Simple2');
 goog.require('proto.jspb.test.SpecialCases');
 goog.require('proto.jspb.test.TestClone');
-goog.require('proto.jspb.test.TestEndsWithBytes');
 goog.require('proto.jspb.test.TestGroup');
 goog.require('proto.jspb.test.TestGroup1');
 goog.require('proto.jspb.test.TestMessageWithOneof');
 goog.require('proto.jspb.test.TestReservedNames');
 goog.require('proto.jspb.test.TestReservedNamesExtension');
-goog.require('proto.jspb.test.Deeply.Nested.Message');
 
 // CommonJS-LoadFromFile: test2_pb proto.jspb.test
 goog.require('proto.jspb.test.ExtensionMessage');
 goog.require('proto.jspb.test.TestExtensionsMessage');
-goog.require('proto.jspb.test.ForeignNestedFieldMessage');
 
 
 
 
 describe('Message test suite', function() {
   it('testEmptyProto', function() {
     var empty1 = new proto.jspb.test.Empty([]);
     var empty2 = new proto.jspb.test.Empty([]);
     assertObjectEquals({}, empty1.toObject());
     assertObjectEquals('Message should not be corrupted:', empty2, empty1);
@@ skipping 118 matching lines @@
       return new proto.jspb.test.DefaultValues(values);
     }
 
     // Test with undefined values,
     // Use push to workaround IE treating undefined array elements as holes.
     response = makeDefault([undefined, undefined, undefined, undefined]);
     assertEquals(defaultString, response.getStringField());
     assertEquals(true, response.getBoolField());
     assertEquals(11, response.getIntField());
     assertEquals(13, response.getEnumField());
-    assertFalse(response.hasStringField());
-    assertFalse(response.hasBoolField());
-    assertFalse(response.hasIntField());
-    assertFalse(response.hasEnumField());
 
     // Test with null values, as would be returned by a JSON serializer.
     response = makeDefault([null, null, null, null]);
     assertEquals(defaultString, response.getStringField());
     assertEquals(true, response.getBoolField());
     assertEquals(11, response.getIntField());
     assertEquals(13, response.getEnumField());
-    assertFalse(response.hasStringField());
-    assertFalse(response.hasBoolField());
-    assertFalse(response.hasIntField());
-    assertFalse(response.hasEnumField());
 
     // Test with false-like values.
     response = makeDefault(['', false, 0, 0]);
     assertEquals('', response.getStringField());
     assertEquals(false, response.getBoolField());
     assertEquals(true, response.getIntField() == 0);
     assertEquals(true, response.getEnumField() == 0);
-    assertTrue(response.hasStringField());
-    assertTrue(response.hasBoolField());
-    assertTrue(response.hasIntField());
-    assertTrue(response.hasEnumField());
 
     // Test that clearing the values reverts them to the default state.
     response = makeDefault(['blah', false, 111, 77]);
     response.clearStringField(); response.clearBoolField();
     response.clearIntField(); response.clearEnumField();
     assertEquals(defaultString, response.getStringField());
     assertEquals(true, response.getBoolField());
     assertEquals(11, response.getIntField());
     assertEquals(13, response.getEnumField());
-    assertFalse(response.hasStringField());
-    assertFalse(response.hasBoolField());
-    assertFalse(response.hasIntField());
-    assertFalse(response.hasEnumField());
 
     // Test that setFoo(null) clears the values.
     response = makeDefault(['blah', false, 111, 77]);
     response.setStringField(null); response.setBoolField(null);
     response.setIntField(undefined); response.setEnumField(undefined);
     assertEquals(defaultString, response.getStringField());
     assertEquals(true, response.getBoolField());
     assertEquals(11, response.getIntField());
     assertEquals(13, response.getEnumField());
-    assertFalse(response.hasStringField());
-    assertFalse(response.hasBoolField());
-    assertFalse(response.hasIntField());
-    assertFalse(response.hasEnumField());
   });
 
-  it('testMessageRegistration', /** @suppress {visibility} */ function() {
+  it('testMessageRegistration', function() {
     // goog.require(SomeResponse) will include its library, which will in
     // turn add SomeResponse to the message registry.
     assertEquals(jspb.Message.registry_['res'], proto.jspb.test.SomeResponse);
   });
 
   it('testClearFields', function() {
+    // We don't set 'proper' defaults, rather, bools, strings,
+    // etc, are cleared to undefined or null and take on the Javascript
+    // meaning for that value. Repeated fields are set to [] when cleared.
     var data = ['str', true, [11], [[22], [33]], ['s1', 's2']];
     var foo = new proto.jspb.test.OptionalFields(data);
     foo.clearAString();
     foo.clearABool();
     foo.clearANestedMessage();
     foo.clearARepeatedMessageList();
     foo.clearARepeatedStringList();
-    assertEquals('', foo.getAString());
-    assertEquals(false, foo.getABool());
+    assertUndefined(foo.getAString());
+    assertUndefined(foo.getABool());
     assertUndefined(foo.getANestedMessage());
-    assertFalse(foo.hasAString());
-    assertFalse(foo.hasABool());
     assertObjectEquals([], foo.getARepeatedMessageList());
     assertObjectEquals([], foo.getARepeatedStringList());
     // NOTE: We want the missing fields in 'expected' to be undefined,
     // but we actually get a sparse array instead. We could use something
     // like [1,undefined,2] to avoid this, except that this is still
     // sparse on IE. No comment...
     var expected = [,,, [], []];
     expected[0] = expected[1] = expected[2] = undefined;
     assertObjectEquals(expected, foo.toArray());
+
+    // Test set(null). We could deprecated this in favor of clear(), but
+    // it's also convenient to have.
+    data = ['str', true, [11], [[22], [33]], ['s1', 's2']];
+    foo = new proto.jspb.test.OptionalFields(data);
+    foo.setAString(null);
+    foo.setABool(null);
+    foo.setANestedMessage(null);
+    foo.setARepeatedMessageList(null);
+    foo.setARepeatedStringList(null);
+    assertNull(foo.getAString());
+    assertNull(foo.getABool());
+    assertNull(foo.getANestedMessage());
+    assertObjectEquals([], foo.getARepeatedMessageList());
+    assertObjectEquals([], foo.getARepeatedStringList());
+    assertObjectEquals([null, null, null, [], []], foo.toArray());
+
+    // Test set(undefined). Again, not something we really need, and not
+    // supported directly by our typing, but it should 'do the right thing'.
+    data = ['str', true, [11], [[22], [33]], ['s1', 's2']];
+    foo = new proto.jspb.test.OptionalFields(data);
+    foo.setAString(undefined);
+    foo.setABool(undefined);
+    foo.setANestedMessage(undefined);
+    foo.setARepeatedMessageList(undefined);
+    foo.setARepeatedStringList(undefined);
+    assertUndefined(foo.getAString());
+    assertUndefined(foo.getABool());
+    assertUndefined(foo.getANestedMessage());
+    assertObjectEquals([], foo.getARepeatedMessageList());
+    assertObjectEquals([], foo.getARepeatedStringList());
+    expected = [,,, [], []];
+    expected[0] = expected[1] = expected[2] = undefined;
+    assertObjectEquals(expected, foo.toArray());
   });
 
-  it('testDifferenceRawObject', /** @suppress {visibility} */ function() {
+  it('testDifferenceRawObject', function() {
     var p1 = new proto.jspb.test.HasExtensions(['hi', 'diff', {}]);
     var p2 = new proto.jspb.test.HasExtensions(['hi', 'what',
                                                {1000: 'unique'}]);
     var diff = /** @type {proto.jspb.test.HasExtensions} */
         (jspb.Message.difference(p1, p2));
-    assertEquals('', diff.getStr1());
+    assertUndefined(diff.getStr1());
     assertEquals('what', diff.getStr2());
-    assertEquals('', diff.getStr3());
+    assertUndefined(diff.getStr3());
     assertEquals('unique', diff.extensionObject_[1000]);
   });
 
   it('testEqualsSimple', function() {
     var s1 = new proto.jspb.test.Simple1(['hi']);
     assertTrue(jspb.Message.equals(s1, new proto.jspb.test.Simple1(['hi'])));
     assertFalse(jspb.Message.equals(s1, new proto.jspb.test.Simple1(['bye'])));
     var s1b = new proto.jspb.test.Simple1(['hi', ['hello']]);
     assertTrue(jspb.Message.equals(s1b,
         new proto.jspb.test.Simple1(['hi', ['hello']])));
@@ skipping 97 matching lines @@
         proto.jspb.test.Simple1.prototype.toObject);
     assertEquals('k', soymap['k'].aString);
     assertArrayEquals(['v'], soymap['k'].aRepeatedStringList);
     var protomap = jspb.Message.toMap([p1, p2],
         proto.jspb.test.Simple1.prototype.getAString);
     assertEquals('k', protomap['k'].getAString());
     assertArrayEquals(['v'], protomap['k'].getARepeatedStringList());
   });
 
   it('testClone', function() {
-    var supportsUint8Array =
-        !goog.userAgent.IE || goog.userAgent.isVersionOrHigher('10');
     var original = new proto.jspb.test.TestClone();
     original.setStr('v1');
     var simple1 = new proto.jspb.test.Simple1(['x1', ['y1', 'z1']]);
     var simple2 = new proto.jspb.test.Simple1(['x2', ['y2', 'z2']]);
     var simple3 = new proto.jspb.test.Simple1(['x3', ['y3', 'z3']]);
     original.setSimple1(simple1);
     original.setSimple2List([simple2, simple3]);
-    var bytes1 = supportsUint8Array ? new Uint8Array([1, 2, 3]) : '123';
-    original.setBytesField(bytes1);
     var extension = new proto.jspb.test.CloneExtension();
     extension.setExt('e1');
     original.setExtension(proto.jspb.test.IsExtension.extField, extension);
-    var clone = original.clone();
+    var clone = original.cloneMessage();
     assertArrayEquals(['v1',, ['x1', ['y1', 'z1']],,
-      [['x2', ['y2', 'z2']], ['x3', ['y3', 'z3']]], bytes1,, { 100: [, 'e1'] }],
+      [['x2', ['y2', 'z2']], ['x3', ['y3', 'z3']]],,, { 100: [, 'e1'] }],
         clone.toArray());
     clone.setStr('v2');
     var simple4 = new proto.jspb.test.Simple1(['a1', ['b1', 'c1']]);
     var simple5 = new proto.jspb.test.Simple1(['a2', ['b2', 'c2']]);
     var simple6 = new proto.jspb.test.Simple1(['a3', ['b3', 'c3']]);
     clone.setSimple1(simple4);
     clone.setSimple2List([simple5, simple6]);
-    if (supportsUint8Array) {
-      clone.getBytesField()[0] = 4;
-      assertObjectEquals(bytes1, original.getBytesField());
-    }
-    var bytes2 = supportsUint8Array ? new Uint8Array([4, 5, 6]) : '456';
-    clone.setBytesField(bytes2);
     var newExtension = new proto.jspb.test.CloneExtension();
     newExtension.setExt('e2');
     clone.setExtension(proto.jspb.test.CloneExtension.extField, newExtension);
     assertArrayEquals(['v2',, ['a1', ['b1', 'c1']],,
-      [['a2', ['b2', 'c2']], ['a3', ['b3', 'c3']]], bytes2,, { 100: [, 'e2'] }],
+      [['a2', ['b2', 'c2']], ['a3', ['b3', 'c3']]],,, { 100: [, 'e2'] }],
         clone.toArray());
     assertArrayEquals(['v1',, ['x1', ['y1', 'z1']],,
-      [['x2', ['y2', 'z2']], ['x3', ['y3', 'z3']]], bytes1,, { 100: [, 'e1'] }],
+      [['x2', ['y2', 'z2']], ['x3', ['y3', 'z3']]],,, { 100: [, 'e1'] }],
         original.toArray());
   });
 
   it('testCopyInto', function() {
-    var supportsUint8Array =
-        !goog.userAgent.IE || goog.userAgent.isVersionOrHigher('10');
     var original = new proto.jspb.test.TestClone();
     original.setStr('v1');
     var dest = new proto.jspb.test.TestClone();
     dest.setStr('override');
     var simple1 = new proto.jspb.test.Simple1(['x1', ['y1', 'z1']]);
     var simple2 = new proto.jspb.test.Simple1(['x2', ['y2', 'z2']]);
     var simple3 = new proto.jspb.test.Simple1(['x3', ['y3', 'z3']]);
     var destSimple1 = new proto.jspb.test.Simple1(['ox1', ['oy1', 'oz1']]);
     var destSimple2 = new proto.jspb.test.Simple1(['ox2', ['oy2', 'oz2']]);
     var destSimple3 = new proto.jspb.test.Simple1(['ox3', ['oy3', 'oz3']]);
     original.setSimple1(simple1);
     original.setSimple2List([simple2, simple3]);
     dest.setSimple1(destSimple1);
     dest.setSimple2List([destSimple2, destSimple3]);
-    var bytes1 = supportsUint8Array ? new Uint8Array([1, 2, 3]) : '123';
-    var bytes2 = supportsUint8Array ? new Uint8Array([4, 5, 6]) : '456';
-    original.setBytesField(bytes1);
-    dest.setBytesField(bytes2);
     var extension = new proto.jspb.test.CloneExtension();
     extension.setExt('e1');
     original.setExtension(proto.jspb.test.CloneExtension.extField, extension);
 
     jspb.Message.copyInto(original, dest);
     assertArrayEquals(original.toArray(), dest.toArray());
     assertEquals('x1', dest.getSimple1().getAString());
     assertEquals('e1',
         dest.getExtension(proto.jspb.test.CloneExtension.extField).getExt());
     dest.getSimple1().setAString('new value');
     assertNotEquals(dest.getSimple1().getAString(),
         original.getSimple1().getAString());
-    if (supportsUint8Array) {
-      dest.getBytesField()[0] = 7;
-      assertObjectEquals(bytes1, original.getBytesField());
-      assertObjectEquals(new Uint8Array([7, 2, 3]), dest.getBytesField());
-    } else {
-      dest.setBytesField('789');
-      assertObjectEquals(bytes1, original.getBytesField());
-      assertObjectEquals('789', dest.getBytesField());
-    }
     dest.getExtension(proto.jspb.test.CloneExtension.extField).
         setExt('new value');
     assertNotEquals(
         dest.getExtension(proto.jspb.test.CloneExtension.extField).getExt(),
         original.getExtension(
             proto.jspb.test.CloneExtension.extField).getExt());
   });
 
   it('testCopyInto_notSameType', function() {
     var a = new proto.jspb.test.TestClone();
@@ skipping 146 matching lines @@
     var msg = new proto.jspb.test.Empty([1, {4: 'hi'}]);
     // The extensionObject is not moved from its original location.
     assertArrayEquals([1, {4: 'hi'}], msg.toArray());
   });
 
   it('testInitialization_forwardCompatible', function() {
     var msg = new proto.jspb.test.Empty([1, 2, 3, {1: 'hi'}]);
     assertArrayEquals([1, 2, 3, {1: 'hi'}], msg.toArray());
   });
 
-  it('testExtendedMessageEnsureObject',
-     /** @suppress {visibility} */ function() {
-       var data =
-           new proto.jspb.test.HasExtensions(['str1', {'a_key': 'an_object'}]);
-       assertEquals('an_object', data.extensionObject_['a_key']);
-     });
+  it('testExtendedMessageEnsureObject', function() {
+    var data = new proto.jspb.test.HasExtensions(['str1',
+        {'a_key': 'an_object'}]);
+    assertEquals('an_object', data.extensionObject_['a_key']);
+  });
 
   it('testToObject_hasExtensionField', function() {
     var data = new proto.jspb.test.HasExtensions(['str1', {100: ['ext1']}]);
     var obj = data.toObject();
     assertEquals('str1', obj.str1);
     assertEquals('ext1', obj.extField.ext1);
   });
 
   it('testGetExtension', function() {
     var data = new proto.jspb.test.HasExtensions(['str1', {100: ['ext1']}]);
@@ skipping 66 matching lines @@
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.RecursiveOneofCase.
             RECURSIVE_ONEOF_NOT_SET,
         message.getRecursiveOneofCase());
   });
 
   it('testInitializeMessageWithSingleValueSetInOneof', function() {
     var message = new proto.jspb.test.TestMessageWithOneof([,, 'x']);
 
     assertEquals('x', message.getPone());
-    assertEquals('', message.getPthree());
+    assertUndefined(message.getPthree());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.PartialOneofCase.PONE,
         message.getPartialOneofCase());
   });
 
   it('testKeepsLastWireValueSetInUnion_multipleValues', function() {
     var message = new proto.jspb.test.TestMessageWithOneof([,, 'x',, 'y']);
 
-    assertEquals('', message.getPone());
+    assertUndefined('x', message.getPone());
     assertEquals('y', message.getPthree());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.PartialOneofCase.PTHREE,
         message.getPartialOneofCase());
   });
 
   it('testSettingOneofFieldClearsOthers', function() {
     var message = new proto.jspb.test.TestMessageWithOneof;
-    assertEquals('', message.getPone());
-    assertEquals('', message.getPthree());
-    assertFalse(message.hasPone());
-    assertFalse(message.hasPthree());
+    assertUndefined(message.getPone());
+    assertUndefined(message.getPthree());
 
     message.setPone('hi');
     assertEquals('hi', message.getPone());
-    assertEquals('', message.getPthree());
-    assertTrue(message.hasPone());
-    assertFalse(message.hasPthree());
+    assertUndefined(message.getPthree());
 
     message.setPthree('bye');
-    assertEquals('', message.getPone());
+    assertUndefined(message.getPone());
     assertEquals('bye', message.getPthree());
-    assertFalse(message.hasPone());
-    assertTrue(message.hasPthree());
   });
 
   it('testSettingOneofFieldDoesNotClearFieldsFromOtherUnions', function() {
     var other = new proto.jspb.test.TestMessageWithOneof;
     var message = new proto.jspb.test.TestMessageWithOneof;
-    assertEquals('', message.getPone());
-    assertEquals('', message.getPthree());
+    assertUndefined(message.getPone());
+    assertUndefined(message.getPthree());
     assertUndefined(message.getRone());
-    assertFalse(message.hasPone());
-    assertFalse(message.hasPthree());
 
     message.setPone('hi');
     message.setRone(other);
     assertEquals('hi', message.getPone());
-    assertEquals('', message.getPthree());
+    assertUndefined(message.getPthree());
     assertEquals(other, message.getRone());
-    assertTrue(message.hasPone());
-    assertFalse(message.hasPthree());
 
     message.setPthree('bye');
-    assertEquals('', message.getPone());
+    assertUndefined(message.getPone());
     assertEquals('bye', message.getPthree());
     assertEquals(other, message.getRone());
-    assertFalse(message.hasPone());
-    assertTrue(message.hasPthree());
   });
 
   it('testUnsetsOneofCaseWhenFieldIsCleared', function() {
     var message = new proto.jspb.test.TestMessageWithOneof;
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.PartialOneofCase.
             PARTIAL_ONEOF_NOT_SET,
         message.getPartialOneofCase());
 
     message.setPone('hi');
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.PartialOneofCase.PONE,
         message.getPartialOneofCase());
 
     message.clearPone();
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.PartialOneofCase.
             PARTIAL_ONEOF_NOT_SET,
         message.getPartialOneofCase());
   });
 
   it('testMessageWithDefaultOneofValues', function() {
     var message = new proto.jspb.test.TestMessageWithOneof;
     assertEquals(1234, message.getAone());
-    assertEquals(0, message.getAtwo());
+    assertUndefined(message.getAtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofACase
             .DEFAULT_ONEOF_A_NOT_SET,
         message.getDefaultOneofACase());
 
     message.setAone(567);
     assertEquals(567, message.getAone());
-    assertEquals(0, message.getAtwo());
+    assertUndefined(message.getAtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofACase.AONE,
         message.getDefaultOneofACase());
 
     message.setAtwo(890);
     assertEquals(1234, message.getAone());
     assertEquals(890, message.getAtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofACase.ATWO,
         message.getDefaultOneofACase());
 
     message.clearAtwo();
     assertEquals(1234, message.getAone());
-    assertEquals(0, message.getAtwo());
+    assertUndefined(message.getAtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofACase
             .DEFAULT_ONEOF_A_NOT_SET,
         message.getDefaultOneofACase());
   });
 
   it('testMessageWithDefaultOneofValues_defaultNotOnFirstField', function() {
     var message = new proto.jspb.test.TestMessageWithOneof;
-    assertEquals(0, message.getBone());
+    assertUndefined(message.getBone());
     assertEquals(1234, message.getBtwo());
-    assertFalse(message.hasBone());
-    assertFalse(message.hasBtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase
             .DEFAULT_ONEOF_B_NOT_SET,
         message.getDefaultOneofBCase());
 
     message.setBone(2);
     assertEquals(2, message.getBone());
     assertEquals(1234, message.getBtwo());
-    assertTrue(message.hasBone());
-    assertFalse(message.hasBtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BONE,
         message.getDefaultOneofBCase());
 
     message.setBtwo(3);
-    assertEquals(0, message.getBone());
-    assertFalse(message.hasBone());
-    assertTrue(message.hasBtwo());
+    assertUndefined(message.getBone());
     assertEquals(3, message.getBtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BTWO,
         message.getDefaultOneofBCase());
 
     message.clearBtwo();
-    assertEquals(0, message.getBone());
-    assertFalse(message.hasBone());
-    assertFalse(message.hasBtwo());
+    assertUndefined(message.getBone());
     assertEquals(1234, message.getBtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase
             .DEFAULT_ONEOF_B_NOT_SET,
         message.getDefaultOneofBCase());
   });
 
   it('testInitializeMessageWithOneofDefaults', function() {
     var message =
         new proto.jspb.test.TestMessageWithOneof(new Array(9).concat(567));
     assertEquals(567, message.getAone());
-    assertEquals(0, message.getAtwo());
+    assertUndefined(message.getAtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofACase.AONE,
         message.getDefaultOneofACase());
 
     message =
         new proto.jspb.test.TestMessageWithOneof(new Array(10).concat(890));
     assertEquals(1234, message.getAone());
     assertEquals(890, message.getAtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.DefaultOneofACase.ATWO,
@@ skipping 15 matching lines @@
         message =
             new proto.jspb.test.TestMessageWithOneof(new Array(11).concat(567));
         assertEquals(567, message.getBone());
         assertEquals(1234, message.getBtwo());
         assertEquals(
             proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BONE,
             message.getDefaultOneofBCase());
 
         message =
             new proto.jspb.test.TestMessageWithOneof(new Array(12).concat(890));
-        assertEquals(0, message.getBone());
+        assertUndefined(message.getBone());
         assertEquals(890, message.getBtwo());
         assertEquals(
             proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BTWO,
             message.getDefaultOneofBCase());
 
         message = new proto.jspb.test.TestMessageWithOneof(
             new Array(11).concat(567, 890));
-        assertEquals(0, message.getBone());
+        assertUndefined(message.getBone());
         assertEquals(890, message.getBtwo());
         assertEquals(
             proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BTWO,
             message.getDefaultOneofBCase());
       });
 
   it('testOneofContainingAnotherMessage', function() {
     var message = new proto.jspb.test.TestMessageWithOneof;
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.RecursiveOneofCase.
             RECURSIVE_ONEOF_NOT_SET,
         message.getRecursiveOneofCase());
 
     var other = new proto.jspb.test.TestMessageWithOneof;
     message.setRone(other);
     assertEquals(other, message.getRone());
-    assertEquals('', message.getRtwo());
+    assertUndefined(message.getRtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.RecursiveOneofCase.RONE,
         message.getRecursiveOneofCase());
 
     message.setRtwo('hi');
     assertUndefined(message.getRone());
     assertEquals('hi', message.getRtwo());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.RecursiveOneofCase.RTWO,
         message.getRecursiveOneofCase());
   });
 
   it('testQueryingOneofCaseEnsuresOnlyOneFieldIsSetInUnderlyingArray',
      function() {
     var message = new proto.jspb.test.TestMessageWithOneof;
     message.setPone('x');
     assertEquals('x', message.getPone());
-    assertEquals('', message.getPthree());
+    assertUndefined(message.getPthree());
     assertEquals(
         proto.jspb.test.TestMessageWithOneof.PartialOneofCase.PONE,
         message.getPartialOneofCase());
 
     var array = message.toArray();
     assertEquals('x', array[2]);
     assertUndefined(array[4]);
     array[4] = 'y';
 
     assertEquals(
@@ skipping 18 matching lines @@
     assertNan(message.getRepeatedFloatFieldList()[0]);
     assertNan(message.getRepeatedFloatFieldList()[1]);
     assertNan(message.getDefaultFloatField());
     assertNan(message.getOptionalDoubleField());
     assertNan(message.getRequiredDoubleField());
     assertNan(message.getRepeatedDoubleFieldList()[0]);
     assertNan(message.getRepeatedDoubleFieldList()[1]);
     assertNan(message.getDefaultDoubleField());
   });
 
-  // Verify that we can successfully use a field referring to a nested message
-  // from a different .proto file.
-  it('testForeignNestedMessage', function() {
-    var msg = new proto.jspb.test.ForeignNestedFieldMessage();
-    var nested = new proto.jspb.test.Deeply.Nested.Message();
-    nested.setCount(5);
-    msg.setDeeplyNestedMessage(nested);
-    assertEquals(5, msg.getDeeplyNestedMessage().getCount());
-
-    // After a serialization-deserialization round trip we should get back the
-    // same data we started with.
-    var serialized = msg.serializeBinary();
-    var deserialized =
-        proto.jspb.test.ForeignNestedFieldMessage.deserializeBinary(serialized);
-    assertEquals(5, deserialized.getDeeplyNestedMessage().getCount());
-  });
-
 });