src/third_party/protobuf/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java

   1 // Protocol Buffers - Google's data interchange format
   2 // Copyright 2008 Google Inc.  All rights reserved.
   3 // http://code.google.com/p/protobuf/
   4 //
   5 // Redistribution and use in source and binary forms, with or without
   6 // modification, are permitted provided that the following conditions are
   7 // met:
   8 //
   9 //     * Redistributions of source code must retain the above copyright
  10 // notice, this list of conditions and the following disclaimer.
  11 //     * Redistributions in binary form must reproduce the above
  12 // copyright notice, this list of conditions and the following disclaimer
  13 // in the documentation and/or other materials provided with the
  14 // distribution.
  15 //     * Neither the name of Google Inc. nor the names of its
  16 // contributors may be used to endorse or promote products derived from
  17 // this software without specific prior written permission.
  18 //
  19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30
  31 package com.google.protobuf;
  32
  33 import com.google.protobuf.Descriptors.Descriptor;
  34 import com.google.protobuf.Descriptors.FieldDescriptor;
  35 import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
  36 import com.google.protobuf.test.UnittestImport;
  37 import protobuf_unittest.EnumWithNoOuter;
  38 import protobuf_unittest.MessageWithNoOuter;
  39 import protobuf_unittest.MultipleFilesTestProto;
  40 import protobuf_unittest.NestedExtension.MyNestedExtension;
  41 import protobuf_unittest.NestedExtensionLite.MyNestedExtensionLite;
  42 import protobuf_unittest.NonNestedExtension;
  43 import protobuf_unittest.NonNestedExtension.MessageToBeExtended;
  44 import protobuf_unittest.NonNestedExtension.MyNonNestedExtension;
  45 import protobuf_unittest.NonNestedExtensionLite;
  46 import protobuf_unittest.NonNestedExtensionLite.MessageLiteToBeExtended;
  47 import protobuf_unittest.NonNestedExtensionLite.MyNonNestedExtensionLite;
  48 import protobuf_unittest.ServiceWithNoOuter;
  49 import protobuf_unittest.UnittestOptimizeFor.TestOptimizedForSize;
  50 import protobuf_unittest.UnittestOptimizeFor.TestOptionalOptimizedForSize;
  51 import protobuf_unittest.UnittestOptimizeFor.TestRequiredOptimizedForSize;
  52 import protobuf_unittest.UnittestProto;
  53 import protobuf_unittest.UnittestProto.ForeignEnum;
  54 import protobuf_unittest.UnittestProto.ForeignMessage;
  55 import protobuf_unittest.UnittestProto.ForeignMessageOrBuilder;
  56 import protobuf_unittest.UnittestProto.TestAllExtensions;
  57 import protobuf_unittest.UnittestProto.TestAllTypes;
  58 import protobuf_unittest.UnittestProto.TestAllTypes.NestedMessage;
  59 import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder;
  60 import protobuf_unittest.UnittestProto.TestExtremeDefaultValues;
  61 import protobuf_unittest.UnittestProto.TestPackedTypes;
  62 import protobuf_unittest.UnittestProto.TestUnpackedTypes;
  63
  64 import junit.framework.TestCase;
  65
  66 import java.io.ByteArrayInputStream;
  67 import java.io.ByteArrayOutputStream;
  68 import java.io.ObjectInputStream;
  69 import java.io.ObjectOutputStream;
  70 import java.util.Arrays;
  71 import java.util.Collections;
  72 import java.util.List;
  73
  74 /**
  75  * Unit test for generated messages and generated code.  See also
  76  * {@link MessageTest}, which tests some generated message functionality.
  77  *
  78  * @author kenton@google.com Kenton Varda
  79  */
  80 public class GeneratedMessageTest extends TestCase {
  81   TestUtil.ReflectionTester reflectionTester =
  82     new TestUtil.ReflectionTester(TestAllTypes.getDescriptor(), null);
  83
  84   public void testDefaultInstance() throws Exception {
  85     assertSame(TestAllTypes.getDefaultInstance(),
  86                TestAllTypes.getDefaultInstance().getDefaultInstanceForType());
  87     assertSame(TestAllTypes.getDefaultInstance(),
  88                TestAllTypes.newBuilder().getDefaultInstanceForType());
  89   }
  90
  91   public void testMessageOrBuilder() throws Exception {
  92     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  93     TestUtil.setAllFields(builder);
  94     TestAllTypes message = builder.build();
  95     TestUtil.assertAllFieldsSet(message);
  96   }
  97
  98   public void testUsingBuilderMultipleTimes() throws Exception {
  99     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 100     // primitive field scalar and repeated
 101     builder.setOptionalSfixed64(100);
 102     builder.addRepeatedInt32(100);
 103     // enum field scalar and repeated
 104     builder.setOptionalImportEnum(UnittestImport.ImportEnum.IMPORT_BAR);
 105     builder.addRepeatedImportEnum(UnittestImport.ImportEnum.IMPORT_BAR);
 106     // proto field scalar and repeated
 107     builder.setOptionalForeignMessage(ForeignMessage.newBuilder().setC(1));
 108     builder.addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(1));
 109
 110     TestAllTypes value1 = builder.build();
 111
 112     assertEquals(100, value1.getOptionalSfixed64());
 113     assertEquals(100, value1.getRepeatedInt32(0));
 114     assertEquals(UnittestImport.ImportEnum.IMPORT_BAR,
 115         value1.getOptionalImportEnum());
 116     assertEquals(UnittestImport.ImportEnum.IMPORT_BAR,
 117         value1.getRepeatedImportEnum(0));
 118     assertEquals(1, value1.getOptionalForeignMessage().getC());
 119     assertEquals(1, value1.getRepeatedForeignMessage(0).getC());
 120
 121     // Make sure that builder didn't update previously created values
 122     builder.setOptionalSfixed64(200);
 123     builder.setRepeatedInt32(0, 200);
 124     builder.setOptionalImportEnum(UnittestImport.ImportEnum.IMPORT_FOO);
 125     builder.setRepeatedImportEnum(0, UnittestImport.ImportEnum.IMPORT_FOO);
 126     builder.setOptionalForeignMessage(ForeignMessage.newBuilder().setC(2));
 127     builder.setRepeatedForeignMessage(0, ForeignMessage.newBuilder().setC(2));
 128
 129     TestAllTypes value2 = builder.build();
 130
 131     // Make sure value1 didn't change.
 132     assertEquals(100, value1.getOptionalSfixed64());
 133     assertEquals(100, value1.getRepeatedInt32(0));
 134     assertEquals(UnittestImport.ImportEnum.IMPORT_BAR,
 135         value1.getOptionalImportEnum());
 136     assertEquals(UnittestImport.ImportEnum.IMPORT_BAR,
 137         value1.getRepeatedImportEnum(0));
 138     assertEquals(1, value1.getOptionalForeignMessage().getC());
 139     assertEquals(1, value1.getRepeatedForeignMessage(0).getC());
 140
 141     // Make sure value2 is correct
 142     assertEquals(200, value2.getOptionalSfixed64());
 143     assertEquals(200, value2.getRepeatedInt32(0));
 144     assertEquals(UnittestImport.ImportEnum.IMPORT_FOO,
 145         value2.getOptionalImportEnum());
 146     assertEquals(UnittestImport.ImportEnum.IMPORT_FOO,
 147         value2.getRepeatedImportEnum(0));
 148     assertEquals(2, value2.getOptionalForeignMessage().getC());
 149     assertEquals(2, value2.getRepeatedForeignMessage(0).getC());
 150   }
 151
 152   public void testProtosShareRepeatedArraysIfDidntChange() throws Exception {
 153     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 154     builder.addRepeatedInt32(100);
 155     builder.addRepeatedImportEnum(UnittestImport.ImportEnum.IMPORT_BAR);
 156     builder.addRepeatedForeignMessage(ForeignMessage.getDefaultInstance());
 157
 158     TestAllTypes value1 = builder.build();
 159     TestAllTypes value2 = value1.toBuilder().build();
 160
 161     assertSame(value1.getRepeatedInt32List(), value2.getRepeatedInt32List());
 162     assertSame(value1.getRepeatedImportEnumList(),
 163         value2.getRepeatedImportEnumList());
 164     assertSame(value1.getRepeatedForeignMessageList(),
 165         value2.getRepeatedForeignMessageList());
 166   }
 167
 168   public void testRepeatedArraysAreImmutable() throws Exception {
 169     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 170     builder.addRepeatedInt32(100);
 171     builder.addRepeatedImportEnum(UnittestImport.ImportEnum.IMPORT_BAR);
 172     builder.addRepeatedForeignMessage(ForeignMessage.getDefaultInstance());
 173     assertIsUnmodifiable(builder.getRepeatedInt32List());
 174     assertIsUnmodifiable(builder.getRepeatedImportEnumList());
 175     assertIsUnmodifiable(builder.getRepeatedForeignMessageList());
 176     assertIsUnmodifiable(builder.getRepeatedFloatList());
 177
 178
 179     TestAllTypes value = builder.build();
 180     assertIsUnmodifiable(value.getRepeatedInt32List());
 181     assertIsUnmodifiable(value.getRepeatedImportEnumList());
 182     assertIsUnmodifiable(value.getRepeatedForeignMessageList());
 183     assertIsUnmodifiable(value.getRepeatedFloatList());
 184   }
 185
 186   public void testParsedMessagesAreImmutable() throws Exception {
 187     TestAllTypes value = TestAllTypes.PARSER.parseFrom(
 188         TestUtil.getAllSet().toByteString());
 189     assertIsUnmodifiable(value.getRepeatedInt32List());
 190     assertIsUnmodifiable(value.getRepeatedInt64List());
 191     assertIsUnmodifiable(value.getRepeatedUint32List());
 192     assertIsUnmodifiable(value.getRepeatedUint64List());
 193     assertIsUnmodifiable(value.getRepeatedSint32List());
 194     assertIsUnmodifiable(value.getRepeatedSint64List());
 195     assertIsUnmodifiable(value.getRepeatedFixed32List());
 196     assertIsUnmodifiable(value.getRepeatedFixed64List());
 197     assertIsUnmodifiable(value.getRepeatedSfixed32List());
 198     assertIsUnmodifiable(value.getRepeatedSfixed64List());
 199     assertIsUnmodifiable(value.getRepeatedFloatList());
 200     assertIsUnmodifiable(value.getRepeatedDoubleList());
 201     assertIsUnmodifiable(value.getRepeatedBoolList());
 202     assertIsUnmodifiable(value.getRepeatedStringList());
 203     assertIsUnmodifiable(value.getRepeatedBytesList());
 204     assertIsUnmodifiable(value.getRepeatedGroupList());
 205     assertIsUnmodifiable(value.getRepeatedNestedMessageList());
 206     assertIsUnmodifiable(value.getRepeatedForeignMessageList());
 207     assertIsUnmodifiable(value.getRepeatedImportMessageList());
 208     assertIsUnmodifiable(value.getRepeatedNestedEnumList());
 209     assertIsUnmodifiable(value.getRepeatedForeignEnumList());
 210     assertIsUnmodifiable(value.getRepeatedImportEnumList());
 211   }
 212
 213   private void assertIsUnmodifiable(List<?> list) {
 214     if (list == Collections.emptyList()) {
 215       // OKAY -- Need to check this b/c EmptyList allows you to call clear.
 216     } else {
 217       try {
 218         list.clear();
 219         fail("List wasn't immutable");
 220       } catch (UnsupportedOperationException e) {
 221         // good
 222       }
 223     }
 224   }
 225
 226   public void testSettersRejectNull() throws Exception {
 227     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 228     try {
 229       builder.setOptionalString(null);
 230       fail("Exception was not thrown");
 231     } catch (NullPointerException e) {
 232       // We expect this exception.
 233     }
 234     try {
 235       builder.setOptionalBytes(null);
 236       fail("Exception was not thrown");
 237     } catch (NullPointerException e) {
 238       // We expect this exception.
 239     }
 240     try {
 241       builder.setOptionalNestedMessage((TestAllTypes.NestedMessage) null);
 242       fail("Exception was not thrown");
 243     } catch (NullPointerException e) {
 244       // We expect this exception.
 245     }
 246     try {
 247       builder.setOptionalNestedMessage(
 248           (TestAllTypes.NestedMessage.Builder) null);
 249       fail("Exception was not thrown");
 250     } catch (NullPointerException e) {
 251       // We expect this exception.
 252     }
 253     try {
 254       builder.setOptionalNestedEnum(null);
 255       fail("Exception was not thrown");
 256     } catch (NullPointerException e) {
 257       // We expect this exception.
 258     }
 259     try {
 260       builder.addRepeatedString(null);
 261       fail("Exception was not thrown");
 262     } catch (NullPointerException e) {
 263       // We expect this exception.
 264     }
 265     try {
 266       builder.addRepeatedBytes(null);
 267       fail("Exception was not thrown");
 268     } catch (NullPointerException e) {
 269       // We expect this exception.
 270     }
 271     try {
 272       builder.addRepeatedNestedMessage((TestAllTypes.NestedMessage) null);
 273       fail("Exception was not thrown");
 274     } catch (NullPointerException e) {
 275       // We expect this exception.
 276     }
 277     try {
 278       builder.addRepeatedNestedMessage(
 279           (TestAllTypes.NestedMessage.Builder) null);
 280       fail("Exception was not thrown");
 281     } catch (NullPointerException e) {
 282       // We expect this exception.
 283     }
 284     try {
 285       builder.addRepeatedNestedEnum(null);
 286       fail("Exception was not thrown");
 287     } catch (NullPointerException e) {
 288       // We expect this exception.
 289     }
 290   }
 291
 292   public void testRepeatedSetters() throws Exception {
 293     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 294     TestUtil.setAllFields(builder);
 295     TestUtil.modifyRepeatedFields(builder);
 296     TestAllTypes message = builder.build();
 297     TestUtil.assertRepeatedFieldsModified(message);
 298   }
 299
 300   public void testRepeatedSettersRejectNull() throws Exception {
 301     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 302
 303     builder.addRepeatedString("one");
 304     builder.addRepeatedString("two");
 305     try {
 306       builder.setRepeatedString(1, null);
 307       fail("Exception was not thrown");
 308     } catch (NullPointerException e) {
 309       // We expect this exception.
 310     }
 311
 312     builder.addRepeatedBytes(TestUtil.toBytes("one"));
 313     builder.addRepeatedBytes(TestUtil.toBytes("two"));
 314     try {
 315       builder.setRepeatedBytes(1, null);
 316       fail("Exception was not thrown");
 317     } catch (NullPointerException e) {
 318       // We expect this exception.
 319     }
 320
 321     builder.addRepeatedNestedMessage(
 322       TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
 323     builder.addRepeatedNestedMessage(
 324       TestAllTypes.NestedMessage.newBuilder().setBb(456).build());
 325     try {
 326       builder.setRepeatedNestedMessage(1, (TestAllTypes.NestedMessage) null);
 327       fail("Exception was not thrown");
 328     } catch (NullPointerException e) {
 329       // We expect this exception.
 330     }
 331     try {
 332       builder.setRepeatedNestedMessage(
 333           1, (TestAllTypes.NestedMessage.Builder) null);
 334       fail("Exception was not thrown");
 335     } catch (NullPointerException e) {
 336       // We expect this exception.
 337     }
 338
 339     builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.FOO);
 340     builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR);
 341     try {
 342       builder.setRepeatedNestedEnum(1, null);
 343       fail("Exception was not thrown");
 344     } catch (NullPointerException e) {
 345       // We expect this exception.
 346     }
 347   }
 348
 349   public void testRepeatedAppend() throws Exception {
 350     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 351
 352     builder.addAllRepeatedInt32(Arrays.asList(1, 2, 3, 4));
 353     builder.addAllRepeatedForeignEnum(Arrays.asList(ForeignEnum.FOREIGN_BAZ));
 354
 355     ForeignMessage foreignMessage =
 356         ForeignMessage.newBuilder().setC(12).build();
 357     builder.addAllRepeatedForeignMessage(Arrays.asList(foreignMessage));
 358
 359     TestAllTypes message = builder.build();
 360     assertEquals(message.getRepeatedInt32List(), Arrays.asList(1, 2, 3, 4));
 361     assertEquals(message.getRepeatedForeignEnumList(),
 362         Arrays.asList(ForeignEnum.FOREIGN_BAZ));
 363     assertEquals(1, message.getRepeatedForeignMessageCount());
 364     assertEquals(12, message.getRepeatedForeignMessage(0).getC());
 365   }
 366
 367   public void testRepeatedAppendRejectsNull() throws Exception {
 368     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 369
 370     ForeignMessage foreignMessage =
 371         ForeignMessage.newBuilder().setC(12).build();
 372     try {
 373       builder.addAllRepeatedForeignMessage(
 374           Arrays.asList(foreignMessage, (ForeignMessage) null));
 375       fail("Exception was not thrown");
 376     } catch (NullPointerException e) {
 377       // We expect this exception.
 378     }
 379
 380     try {
 381       builder.addAllRepeatedForeignEnum(
 382           Arrays.asList(ForeignEnum.FOREIGN_BAZ, null));
 383       fail("Exception was not thrown");
 384     } catch (NullPointerException e) {
 385       // We expect this exception.
 386     }
 387
 388     try {
 389       builder.addAllRepeatedString(Arrays.asList("one", null));
 390       fail("Exception was not thrown");
 391     } catch (NullPointerException e) {
 392       // We expect this exception.
 393     }
 394
 395     try {
 396       builder.addAllRepeatedBytes(Arrays.asList(TestUtil.toBytes("one"), null));
 397       fail("Exception was not thrown");
 398     } catch (NullPointerException e) {
 399       // We expect this exception.
 400     }
 401   }
 402
 403   public void testSettingForeignMessageUsingBuilder() throws Exception {
 404     TestAllTypes message = TestAllTypes.newBuilder()
 405         // Pass builder for foreign message instance.
 406         .setOptionalForeignMessage(ForeignMessage.newBuilder().setC(123))
 407         .build();
 408     TestAllTypes expectedMessage = TestAllTypes.newBuilder()
 409         // Create expected version passing foreign message instance explicitly.
 410         .setOptionalForeignMessage(
 411             ForeignMessage.newBuilder().setC(123).build())
 412         .build();
 413     // TODO(ngd): Upgrade to using real #equals method once implemented
 414     assertEquals(expectedMessage.toString(), message.toString());
 415   }
 416
 417   public void testSettingRepeatedForeignMessageUsingBuilder() throws Exception {
 418     TestAllTypes message = TestAllTypes.newBuilder()
 419         // Pass builder for foreign message instance.
 420         .addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(456))
 421         .build();
 422     TestAllTypes expectedMessage = TestAllTypes.newBuilder()
 423         // Create expected version passing foreign message instance explicitly.
 424         .addRepeatedForeignMessage(
 425             ForeignMessage.newBuilder().setC(456).build())
 426         .build();
 427     assertEquals(expectedMessage.toString(), message.toString());
 428   }
 429
 430   public void testDefaults() throws Exception {
 431     TestUtil.assertClear(TestAllTypes.getDefaultInstance());
 432     TestUtil.assertClear(TestAllTypes.newBuilder().build());
 433
 434     TestExtremeDefaultValues message =
 435         TestExtremeDefaultValues.getDefaultInstance();
 436     assertEquals("\u1234", message.getUtf8String());
 437     assertEquals(Double.POSITIVE_INFINITY, message.getInfDouble());
 438     assertEquals(Double.NEGATIVE_INFINITY, message.getNegInfDouble());
 439     assertTrue(Double.isNaN(message.getNanDouble()));
 440     assertEquals(Float.POSITIVE_INFINITY, message.getInfFloat());
 441     assertEquals(Float.NEGATIVE_INFINITY, message.getNegInfFloat());
 442     assertTrue(Float.isNaN(message.getNanFloat()));
 443     assertEquals("? ? ?? ?? ??? ??/ ??-", message.getCppTrigraph());
 444   }
 445
 446   public void testClear() throws Exception {
 447     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 448     TestUtil.assertClear(builder);
 449     TestUtil.setAllFields(builder);
 450     builder.clear();
 451     TestUtil.assertClear(builder);
 452   }
 453
 454   public void testReflectionGetters() throws Exception {
 455     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 456     TestUtil.setAllFields(builder);
 457     reflectionTester.assertAllFieldsSetViaReflection(builder);
 458
 459     TestAllTypes message = builder.build();
 460     reflectionTester.assertAllFieldsSetViaReflection(message);
 461   }
 462
 463   public void testReflectionSetters() throws Exception {
 464     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 465     reflectionTester.setAllFieldsViaReflection(builder);
 466     TestUtil.assertAllFieldsSet(builder);
 467
 468     TestAllTypes message = builder.build();
 469     TestUtil.assertAllFieldsSet(message);
 470   }
 471
 472   public void testReflectionSettersRejectNull() throws Exception {
 473     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 474     reflectionTester.assertReflectionSettersRejectNull(builder);
 475   }
 476
 477   public void testReflectionRepeatedSetters() throws Exception {
 478     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 479     reflectionTester.setAllFieldsViaReflection(builder);
 480     reflectionTester.modifyRepeatedFieldsViaReflection(builder);
 481     TestUtil.assertRepeatedFieldsModified(builder);
 482
 483     TestAllTypes message = builder.build();
 484     TestUtil.assertRepeatedFieldsModified(message);
 485   }
 486
 487   public void testReflectionRepeatedSettersRejectNull() throws Exception {
 488     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 489     reflectionTester.assertReflectionRepeatedSettersRejectNull(builder);
 490   }
 491
 492   public void testReflectionDefaults() throws Exception {
 493     reflectionTester.assertClearViaReflection(
 494       TestAllTypes.getDefaultInstance());
 495     reflectionTester.assertClearViaReflection(
 496       TestAllTypes.newBuilder().build());
 497   }
 498
 499   public void testEnumInterface() throws Exception {
 500     assertTrue(TestAllTypes.getDefaultInstance().getDefaultNestedEnum()
 501         instanceof ProtocolMessageEnum);
 502   }
 503
 504   public void testEnumMap() throws Exception {
 505     Internal.EnumLiteMap<ForeignEnum> map = ForeignEnum.internalGetValueMap();
 506
 507     for (ForeignEnum value : ForeignEnum.values()) {
 508       assertEquals(value, map.findValueByNumber(value.getNumber()));
 509     }
 510
 511     assertTrue(map.findValueByNumber(12345) == null);
 512   }
 513
 514   public void testParsePackedToUnpacked() throws Exception {
 515     TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder();
 516     TestUnpackedTypes message =
 517       builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build();
 518     TestUtil.assertUnpackedFieldsSet(message);
 519   }
 520
 521   public void testParseUnpackedToPacked() throws Exception {
 522     TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
 523     TestPackedTypes message =
 524       builder.mergeFrom(TestUtil.getUnpackedSet().toByteString()).build();
 525     TestUtil.assertPackedFieldsSet(message);
 526   }
 527
 528   // =================================================================
 529   // Extensions.
 530
 531   TestUtil.ReflectionTester extensionsReflectionTester =
 532     new TestUtil.ReflectionTester(TestAllExtensions.getDescriptor(),
 533                                   TestUtil.getExtensionRegistry());
 534
 535   public void testExtensionMessageOrBuilder() throws Exception {
 536     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
 537     TestUtil.setAllExtensions(builder);
 538     TestAllExtensions message = builder.build();
 539     TestUtil.assertAllExtensionsSet(message);
 540   }
 541
 542   public void testExtensionRepeatedSetters() throws Exception {
 543     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
 544     TestUtil.setAllExtensions(builder);
 545     TestUtil.modifyRepeatedExtensions(builder);
 546     TestAllExtensions message = builder.build();
 547     TestUtil.assertRepeatedExtensionsModified(message);
 548   }
 549
 550   public void testExtensionDefaults() throws Exception {
 551     TestUtil.assertExtensionsClear(TestAllExtensions.getDefaultInstance());
 552     TestUtil.assertExtensionsClear(TestAllExtensions.newBuilder().build());
 553   }
 554
 555   public void testExtensionReflectionGetters() throws Exception {
 556     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
 557     TestUtil.setAllExtensions(builder);
 558     extensionsReflectionTester.assertAllFieldsSetViaReflection(builder);
 559
 560     TestAllExtensions message = builder.build();
 561     extensionsReflectionTester.assertAllFieldsSetViaReflection(message);
 562   }
 563
 564   public void testExtensionReflectionSetters() throws Exception {
 565     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
 566     extensionsReflectionTester.setAllFieldsViaReflection(builder);
 567     TestUtil.assertAllExtensionsSet(builder);
 568
 569     TestAllExtensions message = builder.build();
 570     TestUtil.assertAllExtensionsSet(message);
 571   }
 572
 573   public void testExtensionReflectionSettersRejectNull() throws Exception {
 574     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
 575     extensionsReflectionTester.assertReflectionSettersRejectNull(builder);
 576   }
 577
 578   public void testExtensionReflectionRepeatedSetters() throws Exception {
 579     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
 580     extensionsReflectionTester.setAllFieldsViaReflection(builder);
 581     extensionsReflectionTester.modifyRepeatedFieldsViaReflection(builder);
 582     TestUtil.assertRepeatedExtensionsModified(builder);
 583
 584     TestAllExtensions message = builder.build();
 585     TestUtil.assertRepeatedExtensionsModified(message);
 586   }
 587
 588   public void testExtensionReflectionRepeatedSettersRejectNull()
 589       throws Exception {
 590     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
 591     extensionsReflectionTester.assertReflectionRepeatedSettersRejectNull(
 592         builder);
 593   }
 594
 595   public void testExtensionReflectionDefaults() throws Exception {
 596     extensionsReflectionTester.assertClearViaReflection(
 597       TestAllExtensions.getDefaultInstance());
 598     extensionsReflectionTester.assertClearViaReflection(
 599       TestAllExtensions.newBuilder().build());
 600   }
 601
 602   public void testClearExtension() throws Exception {
 603     // clearExtension() is not actually used in TestUtil, so try it manually.
 604     assertFalse(
 605       TestAllExtensions.newBuilder()
 606         .setExtension(UnittestProto.optionalInt32Extension, 1)
 607         .clearExtension(UnittestProto.optionalInt32Extension)
 608         .hasExtension(UnittestProto.optionalInt32Extension));
 609     assertEquals(0,
 610       TestAllExtensions.newBuilder()
 611         .addExtension(UnittestProto.repeatedInt32Extension, 1)
 612         .clearExtension(UnittestProto.repeatedInt32Extension)
 613         .getExtensionCount(UnittestProto.repeatedInt32Extension));
 614   }
 615
 616   public void testExtensionCopy() throws Exception {
 617     TestAllExtensions original = TestUtil.getAllExtensionsSet();
 618     TestAllExtensions copy = TestAllExtensions.newBuilder(original).build();
 619     TestUtil.assertAllExtensionsSet(copy);
 620   }
 621
 622   public void testExtensionMergeFrom() throws Exception {
 623     TestAllExtensions original =
 624       TestAllExtensions.newBuilder()
 625         .setExtension(UnittestProto.optionalInt32Extension, 1).build();
 626     TestAllExtensions merged =
 627         TestAllExtensions.newBuilder().mergeFrom(original).build();
 628     assertTrue(merged.hasExtension(UnittestProto.optionalInt32Extension));
 629     assertEquals(
 630         1, (int) merged.getExtension(UnittestProto.optionalInt32Extension));
 631   }
 632
 633   // =================================================================
 634   // Lite Extensions.
 635
 636   // We test lite extensions directly because they have a separate
 637   // implementation from full extensions.  In contrast, we do not test
 638   // lite fields directly since they are implemented exactly the same as
 639   // regular fields.
 640
 641   public void testLiteExtensionMessageOrBuilder() throws Exception {
 642     TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
 643     TestUtil.setAllExtensions(builder);
 644     TestUtil.assertAllExtensionsSet(builder);
 645
 646     TestAllExtensionsLite message = builder.build();
 647     TestUtil.assertAllExtensionsSet(message);
 648   }
 649
 650   public void testLiteExtensionRepeatedSetters() throws Exception {
 651     TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
 652     TestUtil.setAllExtensions(builder);
 653     TestUtil.modifyRepeatedExtensions(builder);
 654     TestUtil.assertRepeatedExtensionsModified(builder);
 655
 656     TestAllExtensionsLite message = builder.build();
 657     TestUtil.assertRepeatedExtensionsModified(message);
 658   }
 659
 660   public void testLiteExtensionDefaults() throws Exception {
 661     TestUtil.assertExtensionsClear(TestAllExtensionsLite.getDefaultInstance());
 662     TestUtil.assertExtensionsClear(TestAllExtensionsLite.newBuilder().build());
 663   }
 664
 665   public void testClearLiteExtension() throws Exception {
 666     // clearExtension() is not actually used in TestUtil, so try it manually.
 667     assertFalse(
 668       TestAllExtensionsLite.newBuilder()
 669         .setExtension(UnittestLite.optionalInt32ExtensionLite, 1)
 670         .clearExtension(UnittestLite.optionalInt32ExtensionLite)
 671         .hasExtension(UnittestLite.optionalInt32ExtensionLite));
 672     assertEquals(0,
 673       TestAllExtensionsLite.newBuilder()
 674         .addExtension(UnittestLite.repeatedInt32ExtensionLite, 1)
 675         .clearExtension(UnittestLite.repeatedInt32ExtensionLite)
 676         .getExtensionCount(UnittestLite.repeatedInt32ExtensionLite));
 677   }
 678
 679   public void testLiteExtensionCopy() throws Exception {
 680     TestAllExtensionsLite original = TestUtil.getAllLiteExtensionsSet();
 681     TestAllExtensionsLite copy =
 682         TestAllExtensionsLite.newBuilder(original).build();
 683     TestUtil.assertAllExtensionsSet(copy);
 684   }
 685
 686   public void testLiteExtensionMergeFrom() throws Exception {
 687     TestAllExtensionsLite original =
 688       TestAllExtensionsLite.newBuilder()
 689         .setExtension(UnittestLite.optionalInt32ExtensionLite, 1).build();
 690     TestAllExtensionsLite merged =
 691         TestAllExtensionsLite.newBuilder().mergeFrom(original).build();
 692     assertTrue(merged.hasExtension(UnittestLite.optionalInt32ExtensionLite));
 693     assertEquals(
 694         1, (int) merged.getExtension(UnittestLite.optionalInt32ExtensionLite));
 695   }
 696
 697   // =================================================================
 698   // multiple_files_test
 699
 700   public void testMultipleFilesOption() throws Exception {
 701     // We mostly just want to check that things compile.
 702     MessageWithNoOuter message =
 703       MessageWithNoOuter.newBuilder()
 704         .setNested(MessageWithNoOuter.NestedMessage.newBuilder().setI(1))
 705         .addForeign(TestAllTypes.newBuilder().setOptionalInt32(1))
 706         .setNestedEnum(MessageWithNoOuter.NestedEnum.BAZ)
 707         .setForeignEnum(EnumWithNoOuter.BAR)
 708         .build();
 709     assertEquals(message, MessageWithNoOuter.parseFrom(message.toByteString()));
 710
 711     assertEquals(MultipleFilesTestProto.getDescriptor(),
 712                  MessageWithNoOuter.getDescriptor().getFile());
 713
 714     Descriptors.FieldDescriptor field =
 715       MessageWithNoOuter.getDescriptor().findFieldByName("foreign_enum");
 716     assertEquals(EnumWithNoOuter.BAR.getValueDescriptor(),
 717                  message.getField(field));
 718
 719     assertEquals(MultipleFilesTestProto.getDescriptor(),
 720                  ServiceWithNoOuter.getDescriptor().getFile());
 721
 722     assertFalse(
 723       TestAllExtensions.getDefaultInstance().hasExtension(
 724         MultipleFilesTestProto.extensionWithOuter));
 725   }
 726
 727   public void testOptionalFieldWithRequiredSubfieldsOptimizedForSize()
 728     throws Exception {
 729     TestOptionalOptimizedForSize message =
 730         TestOptionalOptimizedForSize.getDefaultInstance();
 731     assertTrue(message.isInitialized());
 732
 733     message = TestOptionalOptimizedForSize.newBuilder().setO(
 734         TestRequiredOptimizedForSize.newBuilder().buildPartial()
 735         ).buildPartial();
 736     assertFalse(message.isInitialized());
 737
 738     message = TestOptionalOptimizedForSize.newBuilder().setO(
 739         TestRequiredOptimizedForSize.newBuilder().setX(5).buildPartial()
 740         ).buildPartial();
 741     assertTrue(message.isInitialized());
 742   }
 743
 744   public void testUninitializedExtensionInOptimizedForSize()
 745       throws Exception {
 746     TestOptimizedForSize.Builder builder = TestOptimizedForSize.newBuilder();
 747     builder.setExtension(TestOptimizedForSize.testExtension2,
 748         TestRequiredOptimizedForSize.newBuilder().buildPartial());
 749     assertFalse(builder.isInitialized());
 750     assertFalse(builder.buildPartial().isInitialized());
 751
 752     builder = TestOptimizedForSize.newBuilder();
 753     builder.setExtension(TestOptimizedForSize.testExtension2,
 754         TestRequiredOptimizedForSize.newBuilder().setX(10).buildPartial());
 755     assertTrue(builder.isInitialized());
 756     assertTrue(builder.buildPartial().isInitialized());
 757   }
 758
 759   public void testToBuilder() throws Exception {
 760     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 761     TestUtil.setAllFields(builder);
 762     TestAllTypes message = builder.build();
 763     TestUtil.assertAllFieldsSet(message);
 764     TestUtil.assertAllFieldsSet(message.toBuilder().build());
 765   }
 766
 767   public void testFieldConstantValues() throws Exception {
 768     assertEquals(TestAllTypes.NestedMessage.BB_FIELD_NUMBER, 1);
 769     assertEquals(TestAllTypes.OPTIONAL_INT32_FIELD_NUMBER, 1);
 770     assertEquals(TestAllTypes.OPTIONALGROUP_FIELD_NUMBER, 16);
 771     assertEquals(TestAllTypes.OPTIONAL_NESTED_MESSAGE_FIELD_NUMBER, 18);
 772     assertEquals(TestAllTypes.OPTIONAL_NESTED_ENUM_FIELD_NUMBER, 21);
 773     assertEquals(TestAllTypes.REPEATED_INT32_FIELD_NUMBER, 31);
 774     assertEquals(TestAllTypes.REPEATEDGROUP_FIELD_NUMBER, 46);
 775     assertEquals(TestAllTypes.REPEATED_NESTED_MESSAGE_FIELD_NUMBER, 48);
 776     assertEquals(TestAllTypes.REPEATED_NESTED_ENUM_FIELD_NUMBER, 51);
 777   }
 778
 779   public void testExtensionConstantValues() throws Exception {
 780     assertEquals(UnittestProto.TestRequired.SINGLE_FIELD_NUMBER, 1000);
 781     assertEquals(UnittestProto.TestRequired.MULTI_FIELD_NUMBER, 1001);
 782     assertEquals(UnittestProto.OPTIONAL_INT32_EXTENSION_FIELD_NUMBER, 1);
 783     assertEquals(UnittestProto.OPTIONALGROUP_EXTENSION_FIELD_NUMBER, 16);
 784     assertEquals(
 785       UnittestProto.OPTIONAL_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 18);
 786     assertEquals(UnittestProto.OPTIONAL_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 21);
 787     assertEquals(UnittestProto.REPEATED_INT32_EXTENSION_FIELD_NUMBER, 31);
 788     assertEquals(UnittestProto.REPEATEDGROUP_EXTENSION_FIELD_NUMBER, 46);
 789     assertEquals(
 790       UnittestProto.REPEATED_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 48);
 791     assertEquals(UnittestProto.REPEATED_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 51);
 792   }
 793
 794   public void testRecursiveMessageDefaultInstance() throws Exception {
 795     UnittestProto.TestRecursiveMessage message =
 796         UnittestProto.TestRecursiveMessage.getDefaultInstance();
 797     assertTrue(message != null);
 798     assertTrue(message.getA() != null);
 799     assertTrue(message.getA() == message);
 800   }
 801
 802   public void testSerialize() throws Exception {
 803     ByteArrayOutputStream baos = new ByteArrayOutputStream();
 804     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 805     TestUtil.setAllFields(builder);
 806     TestAllTypes expected = builder.build();
 807     ObjectOutputStream out = new ObjectOutputStream(baos);
 808     try {
 809       out.writeObject(expected);
 810     } finally {
 811       out.close();
 812     }
 813     ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
 814     ObjectInputStream in = new ObjectInputStream(bais);
 815     TestAllTypes actual = (TestAllTypes) in.readObject();
 816     assertEquals(expected, actual);
 817   }
 818
 819   public void testSerializePartial() throws Exception {
 820     ByteArrayOutputStream baos = new ByteArrayOutputStream();
 821     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 822     TestAllTypes expected = builder.buildPartial();
 823     ObjectOutputStream out = new ObjectOutputStream(baos);
 824     try {
 825       out.writeObject(expected);
 826     } finally {
 827       out.close();
 828     }
 829     ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
 830     ObjectInputStream in = new ObjectInputStream(bais);
 831     TestAllTypes actual = (TestAllTypes) in.readObject();
 832     assertEquals(expected, actual);
 833   }
 834
 835   public void testEnumValues() {
 836      assertEquals(
 837          TestAllTypes.NestedEnum.BAR.getNumber(),
 838          TestAllTypes.NestedEnum.BAR_VALUE);
 839     assertEquals(
 840         TestAllTypes.NestedEnum.BAZ.getNumber(),
 841         TestAllTypes.NestedEnum.BAZ_VALUE);
 842     assertEquals(
 843         TestAllTypes.NestedEnum.FOO.getNumber(),
 844         TestAllTypes.NestedEnum.FOO_VALUE);
 845   }
 846
 847   public void testNonNestedExtensionInitialization() {
 848     assertTrue(NonNestedExtension.nonNestedExtension
 849                .getMessageDefaultInstance() instanceof MyNonNestedExtension);
 850     assertEquals("nonNestedExtension",
 851                  NonNestedExtension.nonNestedExtension.getDescriptor().getName());
 852   }
 853
 854   public void testNestedExtensionInitialization() {
 855     assertTrue(MyNestedExtension.recursiveExtension.getMessageDefaultInstance()
 856                instanceof MessageToBeExtended);
 857     assertEquals("recursiveExtension",
 858                  MyNestedExtension.recursiveExtension.getDescriptor().getName());
 859   }
 860
 861   public void testNonNestedExtensionLiteInitialization() {
 862     assertTrue(NonNestedExtensionLite.nonNestedExtensionLite
 863                .getMessageDefaultInstance() instanceof MyNonNestedExtensionLite);
 864   }
 865
 866   public void testNestedExtensionLiteInitialization() {
 867     assertTrue(MyNestedExtensionLite.recursiveExtensionLite
 868                .getMessageDefaultInstance() instanceof MessageLiteToBeExtended);
 869   }
 870
 871   public void testInvalidations() throws Exception {
 872     GeneratedMessage.enableAlwaysUseFieldBuildersForTesting();
 873     TestAllTypes.NestedMessage nestedMessage1 =
 874         TestAllTypes.NestedMessage.newBuilder().build();
 875     TestAllTypes.NestedMessage nestedMessage2 =
 876         TestAllTypes.NestedMessage.newBuilder().build();
 877
 878     // Set all three flavors (enum, primitive, message and singular/repeated)
 879     // and verify no invalidations fired
 880     TestUtil.MockBuilderParent mockParent = new TestUtil.MockBuilderParent();
 881
 882     TestAllTypes.Builder builder = (TestAllTypes.Builder)
 883         ((GeneratedMessage) TestAllTypes.getDefaultInstance()).
 884             newBuilderForType(mockParent);
 885     builder.setOptionalInt32(1);
 886     builder.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAR);
 887     builder.setOptionalNestedMessage(nestedMessage1);
 888     builder.addRepeatedInt32(1);
 889     builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR);
 890     builder.addRepeatedNestedMessage(nestedMessage1);
 891     assertEquals(0, mockParent.getInvalidationCount());
 892
 893     // Now tell it we want changes and make sure it's only fired once
 894     // And do this for each flavor
 895
 896     // primitive single
 897     builder.buildPartial();
 898     builder.setOptionalInt32(2);
 899     builder.setOptionalInt32(3);
 900     assertEquals(1, mockParent.getInvalidationCount());
 901
 902     // enum single
 903     builder.buildPartial();
 904     builder.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAZ);
 905     builder.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAR);
 906     assertEquals(2, mockParent.getInvalidationCount());
 907
 908     // message single
 909     builder.buildPartial();
 910     builder.setOptionalNestedMessage(nestedMessage2);
 911     builder.setOptionalNestedMessage(nestedMessage1);
 912     assertEquals(3, mockParent.getInvalidationCount());
 913
 914     // primitive repeated
 915     builder.buildPartial();
 916     builder.addRepeatedInt32(2);
 917     builder.addRepeatedInt32(3);
 918     assertEquals(4, mockParent.getInvalidationCount());
 919
 920     // enum repeated
 921     builder.buildPartial();
 922     builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ);
 923     builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ);
 924     assertEquals(5, mockParent.getInvalidationCount());
 925
 926     // message repeated
 927     builder.buildPartial();
 928     builder.addRepeatedNestedMessage(nestedMessage2);
 929     builder.addRepeatedNestedMessage(nestedMessage1);
 930     assertEquals(6, mockParent.getInvalidationCount());
 931
 932   }
 933
 934   public void testInvalidations_Extensions() throws Exception {
 935     TestUtil.MockBuilderParent mockParent = new TestUtil.MockBuilderParent();
 936
 937     TestAllExtensions.Builder builder = (TestAllExtensions.Builder)
 938         ((GeneratedMessage) TestAllExtensions.getDefaultInstance()).
 939             newBuilderForType(mockParent);
 940
 941     builder.addExtension(UnittestProto.repeatedInt32Extension, 1);
 942     builder.setExtension(UnittestProto.repeatedInt32Extension, 0, 2);
 943     builder.clearExtension(UnittestProto.repeatedInt32Extension);
 944     assertEquals(0, mockParent.getInvalidationCount());
 945
 946     // Now tell it we want changes and make sure it's only fired once
 947     builder.buildPartial();
 948     builder.addExtension(UnittestProto.repeatedInt32Extension, 2);
 949     builder.addExtension(UnittestProto.repeatedInt32Extension, 3);
 950     assertEquals(1, mockParent.getInvalidationCount());
 951
 952     builder.buildPartial();
 953     builder.setExtension(UnittestProto.repeatedInt32Extension, 0, 4);
 954     builder.setExtension(UnittestProto.repeatedInt32Extension, 1, 5);
 955     assertEquals(2, mockParent.getInvalidationCount());
 956
 957     builder.buildPartial();
 958     builder.clearExtension(UnittestProto.repeatedInt32Extension);
 959     builder.clearExtension(UnittestProto.repeatedInt32Extension);
 960     assertEquals(3, mockParent.getInvalidationCount());
 961   }
 962
 963   public void testBaseMessageOrBuilder() {
 964     // Mostly just makes sure the base interface exists and has some methods.
 965     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 966     TestAllTypes message = builder.buildPartial();
 967     TestAllTypesOrBuilder builderAsInterface = (TestAllTypesOrBuilder) builder;
 968     TestAllTypesOrBuilder messageAsInterface = (TestAllTypesOrBuilder) message;
 969
 970     assertEquals(
 971         messageAsInterface.getDefaultBool(),
 972         messageAsInterface.getDefaultBool());
 973     assertEquals(
 974         messageAsInterface.getOptionalDouble(),
 975         messageAsInterface.getOptionalDouble());
 976   }
 977
 978   public void testMessageOrBuilderGetters() {
 979     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 980
 981     // single fields
 982     assertSame(ForeignMessage.getDefaultInstance(),
 983         builder.getOptionalForeignMessageOrBuilder());
 984     ForeignMessage.Builder subBuilder =
 985         builder.getOptionalForeignMessageBuilder();
 986     assertSame(subBuilder, builder.getOptionalForeignMessageOrBuilder());
 987
 988     // repeated fields
 989     ForeignMessage m0 = ForeignMessage.newBuilder().buildPartial();
 990     ForeignMessage m1 = ForeignMessage.newBuilder().buildPartial();
 991     ForeignMessage m2 = ForeignMessage.newBuilder().buildPartial();
 992     builder.addRepeatedForeignMessage(m0);
 993     builder.addRepeatedForeignMessage(m1);
 994     builder.addRepeatedForeignMessage(m2);
 995     assertSame(m0, builder.getRepeatedForeignMessageOrBuilder(0));
 996     assertSame(m1, builder.getRepeatedForeignMessageOrBuilder(1));
 997     assertSame(m2, builder.getRepeatedForeignMessageOrBuilder(2));
 998     ForeignMessage.Builder b0 = builder.getRepeatedForeignMessageBuilder(0);
 999     ForeignMessage.Builder b1 = builder.getRepeatedForeignMessageBuilder(1);
1000     assertSame(b0, builder.getRepeatedForeignMessageOrBuilder(0));
1001     assertSame(b1, builder.getRepeatedForeignMessageOrBuilder(1));
1002     assertSame(m2, builder.getRepeatedForeignMessageOrBuilder(2));
1003
1004     List<? extends ForeignMessageOrBuilder> messageOrBuilderList =
1005         builder.getRepeatedForeignMessageOrBuilderList();
1006     assertSame(b0, messageOrBuilderList.get(0));
1007     assertSame(b1, messageOrBuilderList.get(1));
1008     assertSame(m2, messageOrBuilderList.get(2));
1009   }
1010
1011   public void testGetFieldBuilder() {
1012     Descriptor descriptor = TestAllTypes.getDescriptor();
1013
1014     FieldDescriptor fieldDescriptor =
1015         descriptor.findFieldByName("optional_nested_message");
1016     FieldDescriptor foreignFieldDescriptor =
1017         descriptor.findFieldByName("optional_foreign_message");
1018     FieldDescriptor importFieldDescriptor =
1019         descriptor.findFieldByName("optional_import_message");
1020
1021     // Mutate the message with new field builder
1022     // Mutate nested message
1023     TestAllTypes.Builder builder1 = TestAllTypes.newBuilder();
1024     Message.Builder fieldBuilder1 = builder1.newBuilderForField(fieldDescriptor)
1025         .mergeFrom((Message) builder1.getField(fieldDescriptor));
1026     FieldDescriptor subFieldDescriptor1 =
1027         fieldBuilder1.getDescriptorForType().findFieldByName("bb");
1028     fieldBuilder1.setField(subFieldDescriptor1, 1);
1029     builder1.setField(fieldDescriptor, fieldBuilder1.build());
1030
1031     // Mutate foreign message
1032     Message.Builder foreignFieldBuilder1 = builder1.newBuilderForField(
1033         foreignFieldDescriptor)
1034         .mergeFrom((Message) builder1.getField(foreignFieldDescriptor));
1035     FieldDescriptor subForeignFieldDescriptor1 =
1036         foreignFieldBuilder1.getDescriptorForType().findFieldByName("c");
1037     foreignFieldBuilder1.setField(subForeignFieldDescriptor1, 2);
1038     builder1.setField(foreignFieldDescriptor, foreignFieldBuilder1.build());
1039
1040     // Mutate import message
1041     Message.Builder importFieldBuilder1 = builder1.newBuilderForField(
1042         importFieldDescriptor)
1043         .mergeFrom((Message) builder1.getField(importFieldDescriptor));
1044     FieldDescriptor subImportFieldDescriptor1 =
1045         importFieldBuilder1.getDescriptorForType().findFieldByName("d");
1046     importFieldBuilder1.setField(subImportFieldDescriptor1, 3);
1047     builder1.setField(importFieldDescriptor, importFieldBuilder1.build());
1048
1049     Message newMessage1 = builder1.build();
1050
1051     // Mutate the message with existing field builder
1052     // Mutate nested message
1053     TestAllTypes.Builder builder2 = TestAllTypes.newBuilder();
1054     Message.Builder fieldBuilder2 = builder2.getFieldBuilder(fieldDescriptor);
1055     FieldDescriptor subFieldDescriptor2 =
1056         fieldBuilder2.getDescriptorForType().findFieldByName("bb");
1057     fieldBuilder2.setField(subFieldDescriptor2, 1);
1058     builder2.setField(fieldDescriptor, fieldBuilder2.build());
1059
1060     // Mutate foreign message
1061     Message.Builder foreignFieldBuilder2 = builder2.newBuilderForField(
1062         foreignFieldDescriptor)
1063         .mergeFrom((Message) builder2.getField(foreignFieldDescriptor));
1064     FieldDescriptor subForeignFieldDescriptor2 =
1065         foreignFieldBuilder2.getDescriptorForType().findFieldByName("c");
1066     foreignFieldBuilder2.setField(subForeignFieldDescriptor2, 2);
1067     builder2.setField(foreignFieldDescriptor, foreignFieldBuilder2.build());
1068
1069     // Mutate import message
1070     Message.Builder importFieldBuilder2 = builder2.newBuilderForField(
1071         importFieldDescriptor)
1072         .mergeFrom((Message) builder2.getField(importFieldDescriptor));
1073     FieldDescriptor subImportFieldDescriptor2 =
1074         importFieldBuilder2.getDescriptorForType().findFieldByName("d");
1075     importFieldBuilder2.setField(subImportFieldDescriptor2, 3);
1076     builder2.setField(importFieldDescriptor, importFieldBuilder2.build());
1077
1078     Message newMessage2 = builder2.build();
1079
1080     // These two messages should be equal.
1081     assertEquals(newMessage1, newMessage2);
1082   }
1083
1084   public void testGetFieldBuilderWithInitializedValue() {
1085     Descriptor descriptor = TestAllTypes.getDescriptor();
1086     FieldDescriptor fieldDescriptor =
1087         descriptor.findFieldByName("optional_nested_message");
1088
1089     // Before setting field, builder is initialized by default value.
1090     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
1091     NestedMessage.Builder fieldBuilder =
1092         (NestedMessage.Builder) builder.getFieldBuilder(fieldDescriptor);
1093     assertEquals(0, fieldBuilder.getBb());
1094
1095     // Setting field value with new field builder instance.
1096     builder = TestAllTypes.newBuilder();
1097     NestedMessage.Builder newFieldBuilder =
1098         builder.getOptionalNestedMessageBuilder();
1099     newFieldBuilder.setBb(2);
1100     // Then get the field builder instance by getFieldBuilder().
1101     fieldBuilder =
1102         (NestedMessage.Builder) builder.getFieldBuilder(fieldDescriptor);
1103     // It should contain new value.
1104     assertEquals(2, fieldBuilder.getBb());
1105     // These two builder should be equal.
1106     assertSame(fieldBuilder, newFieldBuilder);
1107   }
1108
1109   public void testGetFieldBuilderNotSupportedException() {
1110     Descriptor descriptor = TestAllTypes.getDescriptor();
1111     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
1112     try {
1113       builder.getFieldBuilder(descriptor.findFieldByName("optional_int32"));
1114       fail("Exception was not thrown");
1115     } catch (UnsupportedOperationException e) {
1116       // We expect this exception.
1117     }
1118     try {
1119       builder.getFieldBuilder(
1120           descriptor.findFieldByName("optional_nested_enum"));
1121       fail("Exception was not thrown");
1122     } catch (UnsupportedOperationException e) {
1123       // We expect this exception.
1124     }
1125     try {
1126       builder.getFieldBuilder(descriptor.findFieldByName("repeated_int32"));
1127       fail("Exception was not thrown");
1128     } catch (UnsupportedOperationException e) {
1129       // We expect this exception.
1130     }
1131     try {
1132       builder.getFieldBuilder(
1133           descriptor.findFieldByName("repeated_nested_enum"));
1134       fail("Exception was not thrown");
1135     } catch (UnsupportedOperationException e) {
1136       // We expect this exception.
1137     }
1138     try {
1139       builder.getFieldBuilder(
1140           descriptor.findFieldByName("repeated_nested_message"));
1141       fail("Exception was not thrown");
1142     } catch (UnsupportedOperationException e) {
1143       // We expect this exception.
1144     }
1145   }
1146 }