review.tizen.org Git - tools/dynpart-tools.git/blob

   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.test;
  32 import com.google.protobuf.*;
  33
  34 import protobuf_unittest.UnittestProto;
  35
  36 // The static imports are to avoid 100+ char lines.  The following is roughly equivalent to
  37 // import static protobuf_unittest.UnittestProto.*;
  38 import static protobuf_unittest.UnittestProto.defaultInt32Extension;
  39 import static protobuf_unittest.UnittestProto.defaultInt64Extension;
  40 import static protobuf_unittest.UnittestProto.defaultUint32Extension;
  41 import static protobuf_unittest.UnittestProto.defaultUint64Extension;
  42 import static protobuf_unittest.UnittestProto.defaultSint32Extension;
  43 import static protobuf_unittest.UnittestProto.defaultSint64Extension;
  44 import static protobuf_unittest.UnittestProto.defaultFixed32Extension;
  45 import static protobuf_unittest.UnittestProto.defaultFixed64Extension;
  46 import static protobuf_unittest.UnittestProto.defaultSfixed32Extension;
  47 import static protobuf_unittest.UnittestProto.defaultSfixed64Extension;
  48 import static protobuf_unittest.UnittestProto.defaultFloatExtension;
  49 import static protobuf_unittest.UnittestProto.defaultDoubleExtension;
  50 import static protobuf_unittest.UnittestProto.defaultBoolExtension;
  51 import static protobuf_unittest.UnittestProto.defaultStringExtension;
  52 import static protobuf_unittest.UnittestProto.defaultBytesExtension;
  53 import static protobuf_unittest.UnittestProto.defaultNestedEnumExtension;
  54 import static protobuf_unittest.UnittestProto.defaultForeignEnumExtension;
  55 import static protobuf_unittest.UnittestProto.defaultImportEnumExtension;
  56 import static protobuf_unittest.UnittestProto.defaultStringPieceExtension;
  57 import static protobuf_unittest.UnittestProto.defaultCordExtension;
  58
  59 import static protobuf_unittest.UnittestProto.optionalInt32Extension;
  60 import static protobuf_unittest.UnittestProto.optionalInt64Extension;
  61 import static protobuf_unittest.UnittestProto.optionalUint32Extension;
  62 import static protobuf_unittest.UnittestProto.optionalUint64Extension;
  63 import static protobuf_unittest.UnittestProto.optionalSint32Extension;
  64 import static protobuf_unittest.UnittestProto.optionalSint64Extension;
  65 import static protobuf_unittest.UnittestProto.optionalFixed32Extension;
  66 import static protobuf_unittest.UnittestProto.optionalFixed64Extension;
  67 import static protobuf_unittest.UnittestProto.optionalSfixed32Extension;
  68 import static protobuf_unittest.UnittestProto.optionalSfixed64Extension;
  69 import static protobuf_unittest.UnittestProto.optionalFloatExtension;
  70 import static protobuf_unittest.UnittestProto.optionalDoubleExtension;
  71 import static protobuf_unittest.UnittestProto.optionalBoolExtension;
  72 import static protobuf_unittest.UnittestProto.optionalStringExtension;
  73 import static protobuf_unittest.UnittestProto.optionalBytesExtension;
  74 import static protobuf_unittest.UnittestProto.optionalGroupExtension;
  75 import static protobuf_unittest.UnittestProto.optionalCordExtension;
  76 import static protobuf_unittest.UnittestProto.optionalForeignEnumExtension;
  77 import static protobuf_unittest.UnittestProto.optionalForeignMessageExtension;
  78 import static protobuf_unittest.UnittestProto.optionalImportEnumExtension;
  79 import static protobuf_unittest.UnittestProto.optionalImportMessageExtension;
  80 import static protobuf_unittest.UnittestProto.optionalNestedEnumExtension;
  81 import static protobuf_unittest.UnittestProto.optionalNestedMessageExtension;
  82 import static protobuf_unittest.UnittestProto.optionalPublicImportMessageExtension;
  83 import static protobuf_unittest.UnittestProto.optionalLazyMessageExtension;
  84 import static protobuf_unittest.UnittestProto.optionalStringPieceExtension;
  85
  86 import static protobuf_unittest.UnittestProto.repeatedInt32Extension;
  87 import static protobuf_unittest.UnittestProto.repeatedInt64Extension;
  88 import static protobuf_unittest.UnittestProto.repeatedUint32Extension;
  89 import static protobuf_unittest.UnittestProto.repeatedUint64Extension;
  90 import static protobuf_unittest.UnittestProto.repeatedSint32Extension;
  91 import static protobuf_unittest.UnittestProto.repeatedSint64Extension;
  92 import static protobuf_unittest.UnittestProto.repeatedFixed32Extension;
  93 import static protobuf_unittest.UnittestProto.repeatedFixed64Extension;
  94 import static protobuf_unittest.UnittestProto.repeatedSfixed32Extension;
  95 import static protobuf_unittest.UnittestProto.repeatedSfixed64Extension;
  96 import static protobuf_unittest.UnittestProto.repeatedFloatExtension;
  97 import static protobuf_unittest.UnittestProto.repeatedDoubleExtension;
  98 import static protobuf_unittest.UnittestProto.repeatedBoolExtension;
  99 import static protobuf_unittest.UnittestProto.repeatedStringExtension;
 100 import static protobuf_unittest.UnittestProto.repeatedBytesExtension;
 101 import static protobuf_unittest.UnittestProto.repeatedGroupExtension;
 102 import static protobuf_unittest.UnittestProto.repeatedNestedMessageExtension;
 103 import static protobuf_unittest.UnittestProto.repeatedForeignMessageExtension;
 104 import static protobuf_unittest.UnittestProto.repeatedImportMessageExtension;
 105 import static protobuf_unittest.UnittestProto.repeatedLazyMessageExtension;
 106 import static protobuf_unittest.UnittestProto.repeatedNestedEnumExtension;
 107 import static protobuf_unittest.UnittestProto.repeatedForeignEnumExtension;
 108 import static protobuf_unittest.UnittestProto.repeatedImportEnumExtension;
 109 import static protobuf_unittest.UnittestProto.repeatedStringPieceExtension;
 110 import static protobuf_unittest.UnittestProto.repeatedCordExtension;
 111
 112 import static protobuf_unittest.UnittestProto.OptionalGroup_extension;
 113 import static protobuf_unittest.UnittestProto.RepeatedGroup_extension;
 114
 115 import static protobuf_unittest.UnittestProto.packedInt32Extension;
 116 import static protobuf_unittest.UnittestProto.packedInt64Extension;
 117 import static protobuf_unittest.UnittestProto.packedUint32Extension;
 118 import static protobuf_unittest.UnittestProto.packedUint64Extension;
 119 import static protobuf_unittest.UnittestProto.packedSint32Extension;
 120 import static protobuf_unittest.UnittestProto.packedSint64Extension;
 121 import static protobuf_unittest.UnittestProto.packedFixed32Extension;
 122 import static protobuf_unittest.UnittestProto.packedFixed64Extension;
 123 import static protobuf_unittest.UnittestProto.packedSfixed32Extension;
 124 import static protobuf_unittest.UnittestProto.packedSfixed64Extension;
 125 import static protobuf_unittest.UnittestProto.packedFloatExtension;
 126 import static protobuf_unittest.UnittestProto.packedDoubleExtension;
 127 import static protobuf_unittest.UnittestProto.packedBoolExtension;
 128 import static protobuf_unittest.UnittestProto.packedEnumExtension;
 129
 130
 131 import protobuf_unittest.UnittestProto.TestAllExtensions;
 132 import protobuf_unittest.UnittestProto.TestAllExtensionsOrBuilder;
 133 import protobuf_unittest.UnittestProto.TestAllTypes;
 134 import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder;
 135 import protobuf_unittest.UnittestProto.TestPackedExtensions;
 136 import protobuf_unittest.UnittestProto.TestPackedTypes;
 137 import protobuf_unittest.UnittestProto.TestUnpackedTypes;
 138 import protobuf_unittest.UnittestProto.ForeignMessage;
 139 import protobuf_unittest.UnittestProto.ForeignEnum;
 140 import com.google.protobuf.test.UnittestImport.ImportEnum;
 141 import com.google.protobuf.test.UnittestImport.ImportMessage;
 142 import com.google.protobuf.test.UnittestImportPublic.PublicImportMessage;
 143
 144 import junit.framework.Assert;
 145
 146 import java.io.File;
 147 import java.io.IOException;
 148 import java.io.RandomAccessFile;
 149
 150 /**
 151  * Contains methods for setting all fields of {@code TestAllTypes} to
 152  * some values as well as checking that all the fields are set to those values.
 153  * These are useful for testing various protocol message features, e.g.
 154  * set all fields of a message, serialize it, parse it, and check that all
 155  * fields are set.
 156  *
 157  * <p>This code is not to be used outside of {@code com.google.protobuf} and
 158  * subpackages.
 159  *
 160  * @author kenton@google.com Kenton Varda
 161  */
 162 public final class TestUtil {
 163   private TestUtil() {}
 164
 165   /** Helper to convert a String to ByteString. */
 166   static ByteString toBytes(String str) {
 167     try {
 168       return ByteString.copyFrom(str.getBytes("UTF-8"));
 169     } catch(java.io.UnsupportedEncodingException e) {
 170       throw new RuntimeException("UTF-8 not supported.", e);
 171     }
 172   }
 173
 174   /**
 175    * Get a {@code TestAllTypes} with all fields set as they would be by
 176    * {@link #setAllFields(TestAllTypes.Builder)}.
 177    */
 178   public static TestAllTypes getAllSet() {
 179     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 180     setAllFields(builder);
 181     return builder.build();
 182   }
 183
 184   /**
 185    * Get a {@code TestAllTypes.Builder} with all fields set as they would be by
 186    * {@link #setAllFields(TestAllTypes.Builder)}.
 187    */
 188   public static TestAllTypes.Builder getAllSetBuilder() {
 189     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 190     setAllFields(builder);
 191     return builder;
 192   }
 193
 194   /**
 195    * Get a {@code TestAllExtensions} with all fields set as they would be by
 196    * {@link #setAllExtensions(TestAllExtensions.Builder)}.
 197    */
 198   public static TestAllExtensions getAllExtensionsSet() {
 199     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
 200     setAllExtensions(builder);
 201     return builder.build();
 202   }
 203
 204   public static TestPackedTypes getPackedSet() {
 205     TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
 206     setPackedFields(builder);
 207     return builder.build();
 208   }
 209
 210   public static TestUnpackedTypes getUnpackedSet() {
 211     TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder();
 212     setUnpackedFields(builder);
 213     return builder.build();
 214   }
 215
 216   public static TestPackedExtensions getPackedExtensionsSet() {
 217     TestPackedExtensions.Builder builder = TestPackedExtensions.newBuilder();
 218     setPackedExtensions(builder);
 219     return builder.build();
 220   }
 221
 222   /**
 223    * Set every field of {@code message} to the values expected by
 224    * {@code assertAllFieldsSet()}.
 225    */
 226   public static void setAllFields(TestAllTypes.Builder message) {
 227     message.setOptionalInt32   (101);
 228     message.setOptionalInt64   (102);
 229     message.setOptionalUint32  (103);
 230     message.setOptionalUint64  (104);
 231     message.setOptionalSint32  (105);
 232     message.setOptionalSint64  (106);
 233     message.setOptionalFixed32 (107);
 234     message.setOptionalFixed64 (108);
 235     message.setOptionalSfixed32(109);
 236     message.setOptionalSfixed64(110);
 237     message.setOptionalFloat   (111);
 238     message.setOptionalDouble  (112);
 239     message.setOptionalBool    (true);
 240     message.setOptionalString  ("115");
 241     message.setOptionalBytes   (toBytes("116"));
 242
 243     message.setOptionalGroup(
 244       TestAllTypes.OptionalGroup.newBuilder().setA(117).build());
 245     message.setOptionalNestedMessage(
 246       TestAllTypes.NestedMessage.newBuilder().setBb(118).build());
 247     message.setOptionalForeignMessage(
 248       ForeignMessage.newBuilder().setC(119).build());
 249     message.setOptionalImportMessage(
 250       ImportMessage.newBuilder().setD(120).build());
 251     message.setOptionalPublicImportMessage(
 252       PublicImportMessage.newBuilder().setE(126).build());
 253     message.setOptionalLazyMessage(
 254       TestAllTypes.NestedMessage.newBuilder().setBb(127).build());
 255
 256     message.setOptionalNestedEnum (TestAllTypes.NestedEnum.BAZ);
 257     message.setOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ);
 258     message.setOptionalImportEnum (ImportEnum.IMPORT_BAZ);
 259
 260     message.setOptionalStringPiece("124");
 261     message.setOptionalCord("125");
 262
 263     // -----------------------------------------------------------------
 264
 265     message.addRepeatedInt32   (201);
 266     message.addRepeatedInt64   (202);
 267     message.addRepeatedUint32  (203);
 268     message.addRepeatedUint64  (204);
 269     message.addRepeatedSint32  (205);
 270     message.addRepeatedSint64  (206);
 271     message.addRepeatedFixed32 (207);
 272     message.addRepeatedFixed64 (208);
 273     message.addRepeatedSfixed32(209);
 274     message.addRepeatedSfixed64(210);
 275     message.addRepeatedFloat   (211);
 276     message.addRepeatedDouble  (212);
 277     message.addRepeatedBool    (true);
 278     message.addRepeatedString  ("215");
 279     message.addRepeatedBytes   (toBytes("216"));
 280
 281     message.addRepeatedGroup(
 282       TestAllTypes.RepeatedGroup.newBuilder().setA(217).build());
 283     message.addRepeatedNestedMessage(
 284       TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
 285     message.addRepeatedForeignMessage(
 286       ForeignMessage.newBuilder().setC(219).build());
 287     message.addRepeatedImportMessage(
 288       ImportMessage.newBuilder().setD(220).build());
 289     message.addRepeatedLazyMessage(
 290       TestAllTypes.NestedMessage.newBuilder().setBb(227).build());
 291
 292     message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAR);
 293     message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAR);
 294     message.addRepeatedImportEnum (ImportEnum.IMPORT_BAR);
 295
 296     message.addRepeatedStringPiece("224");
 297     message.addRepeatedCord("225");
 298
 299     // Add a second one of each field.
 300     message.addRepeatedInt32   (301);
 301     message.addRepeatedInt64   (302);
 302     message.addRepeatedUint32  (303);
 303     message.addRepeatedUint64  (304);
 304     message.addRepeatedSint32  (305);
 305     message.addRepeatedSint64  (306);
 306     message.addRepeatedFixed32 (307);
 307     message.addRepeatedFixed64 (308);
 308     message.addRepeatedSfixed32(309);
 309     message.addRepeatedSfixed64(310);
 310     message.addRepeatedFloat   (311);
 311     message.addRepeatedDouble  (312);
 312     message.addRepeatedBool    (false);
 313     message.addRepeatedString  ("315");
 314     message.addRepeatedBytes   (toBytes("316"));
 315
 316     message.addRepeatedGroup(
 317       TestAllTypes.RepeatedGroup.newBuilder().setA(317).build());
 318     message.addRepeatedNestedMessage(
 319       TestAllTypes.NestedMessage.newBuilder().setBb(318).build());
 320     message.addRepeatedForeignMessage(
 321       ForeignMessage.newBuilder().setC(319).build());
 322     message.addRepeatedImportMessage(
 323       ImportMessage.newBuilder().setD(320).build());
 324     message.addRepeatedLazyMessage(
 325       TestAllTypes.NestedMessage.newBuilder().setBb(327).build());
 326
 327     message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAZ);
 328     message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAZ);
 329     message.addRepeatedImportEnum (ImportEnum.IMPORT_BAZ);
 330
 331     message.addRepeatedStringPiece("324");
 332     message.addRepeatedCord("325");
 333
 334     // -----------------------------------------------------------------
 335
 336     message.setDefaultInt32   (401);
 337     message.setDefaultInt64   (402);
 338     message.setDefaultUint32  (403);
 339     message.setDefaultUint64  (404);
 340     message.setDefaultSint32  (405);
 341     message.setDefaultSint64  (406);
 342     message.setDefaultFixed32 (407);
 343     message.setDefaultFixed64 (408);
 344     message.setDefaultSfixed32(409);
 345     message.setDefaultSfixed64(410);
 346     message.setDefaultFloat   (411);
 347     message.setDefaultDouble  (412);
 348     message.setDefaultBool    (false);
 349     message.setDefaultString  ("415");
 350     message.setDefaultBytes   (toBytes("416"));
 351
 352     message.setDefaultNestedEnum (TestAllTypes.NestedEnum.FOO);
 353     message.setDefaultForeignEnum(ForeignEnum.FOREIGN_FOO);
 354     message.setDefaultImportEnum (ImportEnum.IMPORT_FOO);
 355
 356     message.setDefaultStringPiece("424");
 357     message.setDefaultCord("425");
 358   }
 359
 360   // -------------------------------------------------------------------
 361
 362   /**
 363    * Modify the repeated fields of {@code message} to contain the values
 364    * expected by {@code assertRepeatedFieldsModified()}.
 365    */
 366   public static void modifyRepeatedFields(TestAllTypes.Builder message) {
 367     message.setRepeatedInt32   (1, 501);
 368     message.setRepeatedInt64   (1, 502);
 369     message.setRepeatedUint32  (1, 503);
 370     message.setRepeatedUint64  (1, 504);
 371     message.setRepeatedSint32  (1, 505);
 372     message.setRepeatedSint64  (1, 506);
 373     message.setRepeatedFixed32 (1, 507);
 374     message.setRepeatedFixed64 (1, 508);
 375     message.setRepeatedSfixed32(1, 509);
 376     message.setRepeatedSfixed64(1, 510);
 377     message.setRepeatedFloat   (1, 511);
 378     message.setRepeatedDouble  (1, 512);
 379     message.setRepeatedBool    (1, true);
 380     message.setRepeatedString  (1, "515");
 381     message.setRepeatedBytes   (1, toBytes("516"));
 382
 383     message.setRepeatedGroup(1,
 384       TestAllTypes.RepeatedGroup.newBuilder().setA(517).build());
 385     message.setRepeatedNestedMessage(1,
 386       TestAllTypes.NestedMessage.newBuilder().setBb(518).build());
 387     message.setRepeatedForeignMessage(1,
 388       ForeignMessage.newBuilder().setC(519).build());
 389     message.setRepeatedImportMessage(1,
 390       ImportMessage.newBuilder().setD(520).build());
 391     message.setRepeatedLazyMessage(1,
 392       TestAllTypes.NestedMessage.newBuilder().setBb(527).build());
 393
 394     message.setRepeatedNestedEnum (1, TestAllTypes.NestedEnum.FOO);
 395     message.setRepeatedForeignEnum(1, ForeignEnum.FOREIGN_FOO);
 396     message.setRepeatedImportEnum (1, ImportEnum.IMPORT_FOO);
 397
 398     message.setRepeatedStringPiece(1, "524");
 399     message.setRepeatedCord(1, "525");
 400   }
 401
 402   // -------------------------------------------------------------------
 403
 404   /**
 405    * Assert (using {@code junit.framework.Assert}} that all fields of
 406    * {@code message} are set to the values assigned by {@code setAllFields}.
 407    */
 408   public static void assertAllFieldsSet(TestAllTypesOrBuilder message) {
 409     Assert.assertTrue(message.hasOptionalInt32   ());
 410     Assert.assertTrue(message.hasOptionalInt64   ());
 411     Assert.assertTrue(message.hasOptionalUint32  ());
 412     Assert.assertTrue(message.hasOptionalUint64  ());
 413     Assert.assertTrue(message.hasOptionalSint32  ());
 414     Assert.assertTrue(message.hasOptionalSint64  ());
 415     Assert.assertTrue(message.hasOptionalFixed32 ());
 416     Assert.assertTrue(message.hasOptionalFixed64 ());
 417     Assert.assertTrue(message.hasOptionalSfixed32());
 418     Assert.assertTrue(message.hasOptionalSfixed64());
 419     Assert.assertTrue(message.hasOptionalFloat   ());
 420     Assert.assertTrue(message.hasOptionalDouble  ());
 421     Assert.assertTrue(message.hasOptionalBool    ());
 422     Assert.assertTrue(message.hasOptionalString  ());
 423     Assert.assertTrue(message.hasOptionalBytes   ());
 424
 425     Assert.assertTrue(message.hasOptionalGroup         ());
 426     Assert.assertTrue(message.hasOptionalNestedMessage ());
 427     Assert.assertTrue(message.hasOptionalForeignMessage());
 428     Assert.assertTrue(message.hasOptionalImportMessage ());
 429
 430     Assert.assertTrue(message.getOptionalGroup         ().hasA());
 431     Assert.assertTrue(message.getOptionalNestedMessage ().hasBb());
 432     Assert.assertTrue(message.getOptionalForeignMessage().hasC());
 433     Assert.assertTrue(message.getOptionalImportMessage ().hasD());
 434
 435     Assert.assertTrue(message.hasOptionalNestedEnum ());
 436     Assert.assertTrue(message.hasOptionalForeignEnum());
 437     Assert.assertTrue(message.hasOptionalImportEnum ());
 438
 439     Assert.assertTrue(message.hasOptionalStringPiece());
 440     Assert.assertTrue(message.hasOptionalCord());
 441
 442     Assert.assertEquals(101  , message.getOptionalInt32   ());
 443     Assert.assertEquals(102  , message.getOptionalInt64   ());
 444     Assert.assertEquals(103  , message.getOptionalUint32  ());
 445     Assert.assertEquals(104  , message.getOptionalUint64  ());
 446     Assert.assertEquals(105  , message.getOptionalSint32  ());
 447     Assert.assertEquals(106  , message.getOptionalSint64  ());
 448     Assert.assertEquals(107  , message.getOptionalFixed32 ());
 449     Assert.assertEquals(108  , message.getOptionalFixed64 ());
 450     Assert.assertEquals(109  , message.getOptionalSfixed32());
 451     Assert.assertEquals(110  , message.getOptionalSfixed64());
 452     Assert.assertEquals(111  , message.getOptionalFloat   (), 0.0);
 453     Assert.assertEquals(112  , message.getOptionalDouble  (), 0.0);
 454     Assert.assertEquals(true , message.getOptionalBool    ());
 455     Assert.assertEquals("115", message.getOptionalString  ());
 456     Assert.assertEquals(toBytes("116"), message.getOptionalBytes());
 457
 458     Assert.assertEquals(117, message.getOptionalGroup              ().getA());
 459     Assert.assertEquals(118, message.getOptionalNestedMessage      ().getBb());
 460     Assert.assertEquals(119, message.getOptionalForeignMessage     ().getC());
 461     Assert.assertEquals(120, message.getOptionalImportMessage      ().getD());
 462     Assert.assertEquals(126, message.getOptionalPublicImportMessage().getE());
 463     Assert.assertEquals(127, message.getOptionalLazyMessage        ().getBb());
 464
 465     Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getOptionalNestedEnum());
 466     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getOptionalForeignEnum());
 467     Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getOptionalImportEnum());
 468
 469     Assert.assertEquals("124", message.getOptionalStringPiece());
 470     Assert.assertEquals("125", message.getOptionalCord());
 471
 472     // -----------------------------------------------------------------
 473
 474     Assert.assertEquals(2, message.getRepeatedInt32Count   ());
 475     Assert.assertEquals(2, message.getRepeatedInt64Count   ());
 476     Assert.assertEquals(2, message.getRepeatedUint32Count  ());
 477     Assert.assertEquals(2, message.getRepeatedUint64Count  ());
 478     Assert.assertEquals(2, message.getRepeatedSint32Count  ());
 479     Assert.assertEquals(2, message.getRepeatedSint64Count  ());
 480     Assert.assertEquals(2, message.getRepeatedFixed32Count ());
 481     Assert.assertEquals(2, message.getRepeatedFixed64Count ());
 482     Assert.assertEquals(2, message.getRepeatedSfixed32Count());
 483     Assert.assertEquals(2, message.getRepeatedSfixed64Count());
 484     Assert.assertEquals(2, message.getRepeatedFloatCount   ());
 485     Assert.assertEquals(2, message.getRepeatedDoubleCount  ());
 486     Assert.assertEquals(2, message.getRepeatedBoolCount    ());
 487     Assert.assertEquals(2, message.getRepeatedStringCount  ());
 488     Assert.assertEquals(2, message.getRepeatedBytesCount   ());
 489
 490     Assert.assertEquals(2, message.getRepeatedGroupCount         ());
 491     Assert.assertEquals(2, message.getRepeatedNestedMessageCount ());
 492     Assert.assertEquals(2, message.getRepeatedForeignMessageCount());
 493     Assert.assertEquals(2, message.getRepeatedImportMessageCount ());
 494     Assert.assertEquals(2, message.getRepeatedLazyMessageCount   ());
 495     Assert.assertEquals(2, message.getRepeatedNestedEnumCount    ());
 496     Assert.assertEquals(2, message.getRepeatedForeignEnumCount   ());
 497     Assert.assertEquals(2, message.getRepeatedImportEnumCount    ());
 498
 499     Assert.assertEquals(2, message.getRepeatedStringPieceCount());
 500     Assert.assertEquals(2, message.getRepeatedCordCount());
 501
 502     Assert.assertEquals(201  , message.getRepeatedInt32   (0));
 503     Assert.assertEquals(202  , message.getRepeatedInt64   (0));
 504     Assert.assertEquals(203  , message.getRepeatedUint32  (0));
 505     Assert.assertEquals(204  , message.getRepeatedUint64  (0));
 506     Assert.assertEquals(205  , message.getRepeatedSint32  (0));
 507     Assert.assertEquals(206  , message.getRepeatedSint64  (0));
 508     Assert.assertEquals(207  , message.getRepeatedFixed32 (0));
 509     Assert.assertEquals(208  , message.getRepeatedFixed64 (0));
 510     Assert.assertEquals(209  , message.getRepeatedSfixed32(0));
 511     Assert.assertEquals(210  , message.getRepeatedSfixed64(0));
 512     Assert.assertEquals(211  , message.getRepeatedFloat   (0), 0.0);
 513     Assert.assertEquals(212  , message.getRepeatedDouble  (0), 0.0);
 514     Assert.assertEquals(true , message.getRepeatedBool    (0));
 515     Assert.assertEquals("215", message.getRepeatedString  (0));
 516     Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0));
 517
 518     Assert.assertEquals(217, message.getRepeatedGroup         (0).getA());
 519     Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb());
 520     Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC());
 521     Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD());
 522     Assert.assertEquals(227, message.getRepeatedLazyMessage   (0).getBb());
 523
 524     Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEnum (0));
 525     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(0));
 526     Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0));
 527
 528     Assert.assertEquals("224", message.getRepeatedStringPiece(0));
 529     Assert.assertEquals("225", message.getRepeatedCord(0));
 530
 531     Assert.assertEquals(301  , message.getRepeatedInt32   (1));
 532     Assert.assertEquals(302  , message.getRepeatedInt64   (1));
 533     Assert.assertEquals(303  , message.getRepeatedUint32  (1));
 534     Assert.assertEquals(304  , message.getRepeatedUint64  (1));
 535     Assert.assertEquals(305  , message.getRepeatedSint32  (1));
 536     Assert.assertEquals(306  , message.getRepeatedSint64  (1));
 537     Assert.assertEquals(307  , message.getRepeatedFixed32 (1));
 538     Assert.assertEquals(308  , message.getRepeatedFixed64 (1));
 539     Assert.assertEquals(309  , message.getRepeatedSfixed32(1));
 540     Assert.assertEquals(310  , message.getRepeatedSfixed64(1));
 541     Assert.assertEquals(311  , message.getRepeatedFloat   (1), 0.0);
 542     Assert.assertEquals(312  , message.getRepeatedDouble  (1), 0.0);
 543     Assert.assertEquals(false, message.getRepeatedBool    (1));
 544     Assert.assertEquals("315", message.getRepeatedString  (1));
 545     Assert.assertEquals(toBytes("316"), message.getRepeatedBytes(1));
 546
 547     Assert.assertEquals(317, message.getRepeatedGroup         (1).getA());
 548     Assert.assertEquals(318, message.getRepeatedNestedMessage (1).getBb());
 549     Assert.assertEquals(319, message.getRepeatedForeignMessage(1).getC());
 550     Assert.assertEquals(320, message.getRepeatedImportMessage (1).getD());
 551     Assert.assertEquals(327, message.getRepeatedLazyMessage   (1).getBb());
 552
 553     Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getRepeatedNestedEnum (1));
 554     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getRepeatedForeignEnum(1));
 555     Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getRepeatedImportEnum(1));
 556
 557     Assert.assertEquals("324", message.getRepeatedStringPiece(1));
 558     Assert.assertEquals("325", message.getRepeatedCord(1));
 559
 560     // -----------------------------------------------------------------
 561
 562     Assert.assertTrue(message.hasDefaultInt32   ());
 563     Assert.assertTrue(message.hasDefaultInt64   ());
 564     Assert.assertTrue(message.hasDefaultUint32  ());
 565     Assert.assertTrue(message.hasDefaultUint64  ());
 566     Assert.assertTrue(message.hasDefaultSint32  ());
 567     Assert.assertTrue(message.hasDefaultSint64  ());
 568     Assert.assertTrue(message.hasDefaultFixed32 ());
 569     Assert.assertTrue(message.hasDefaultFixed64 ());
 570     Assert.assertTrue(message.hasDefaultSfixed32());
 571     Assert.assertTrue(message.hasDefaultSfixed64());
 572     Assert.assertTrue(message.hasDefaultFloat   ());
 573     Assert.assertTrue(message.hasDefaultDouble  ());
 574     Assert.assertTrue(message.hasDefaultBool    ());
 575     Assert.assertTrue(message.hasDefaultString  ());
 576     Assert.assertTrue(message.hasDefaultBytes   ());
 577
 578     Assert.assertTrue(message.hasDefaultNestedEnum ());
 579     Assert.assertTrue(message.hasDefaultForeignEnum());
 580     Assert.assertTrue(message.hasDefaultImportEnum ());
 581
 582     Assert.assertTrue(message.hasDefaultStringPiece());
 583     Assert.assertTrue(message.hasDefaultCord());
 584
 585     Assert.assertEquals(401  , message.getDefaultInt32   ());
 586     Assert.assertEquals(402  , message.getDefaultInt64   ());
 587     Assert.assertEquals(403  , message.getDefaultUint32  ());
 588     Assert.assertEquals(404  , message.getDefaultUint64  ());
 589     Assert.assertEquals(405  , message.getDefaultSint32  ());
 590     Assert.assertEquals(406  , message.getDefaultSint64  ());
 591     Assert.assertEquals(407  , message.getDefaultFixed32 ());
 592     Assert.assertEquals(408  , message.getDefaultFixed64 ());
 593     Assert.assertEquals(409  , message.getDefaultSfixed32());
 594     Assert.assertEquals(410  , message.getDefaultSfixed64());
 595     Assert.assertEquals(411  , message.getDefaultFloat   (), 0.0);
 596     Assert.assertEquals(412  , message.getDefaultDouble  (), 0.0);
 597     Assert.assertEquals(false, message.getDefaultBool    ());
 598     Assert.assertEquals("415", message.getDefaultString  ());
 599     Assert.assertEquals(toBytes("416"), message.getDefaultBytes());
 600
 601     Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getDefaultNestedEnum ());
 602     Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getDefaultForeignEnum());
 603     Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getDefaultImportEnum());
 604
 605     Assert.assertEquals("424", message.getDefaultStringPiece());
 606     Assert.assertEquals("425", message.getDefaultCord());
 607   }
 608
 609   // -------------------------------------------------------------------
 610   /**
 611    * Assert (using {@code junit.framework.Assert}} that all fields of
 612    * {@code message} are cleared, and that getting the fields returns their
 613    * default values.
 614    */
 615   public static void assertClear(TestAllTypesOrBuilder message) {
 616     // hasBlah() should initially be false for all optional fields.
 617     Assert.assertFalse(message.hasOptionalInt32   ());
 618     Assert.assertFalse(message.hasOptionalInt64   ());
 619     Assert.assertFalse(message.hasOptionalUint32  ());
 620     Assert.assertFalse(message.hasOptionalUint64  ());
 621     Assert.assertFalse(message.hasOptionalSint32  ());
 622     Assert.assertFalse(message.hasOptionalSint64  ());
 623     Assert.assertFalse(message.hasOptionalFixed32 ());
 624     Assert.assertFalse(message.hasOptionalFixed64 ());
 625     Assert.assertFalse(message.hasOptionalSfixed32());
 626     Assert.assertFalse(message.hasOptionalSfixed64());
 627     Assert.assertFalse(message.hasOptionalFloat   ());
 628     Assert.assertFalse(message.hasOptionalDouble  ());
 629     Assert.assertFalse(message.hasOptionalBool    ());
 630     Assert.assertFalse(message.hasOptionalString  ());
 631     Assert.assertFalse(message.hasOptionalBytes   ());
 632
 633     Assert.assertFalse(message.hasOptionalGroup         ());
 634     Assert.assertFalse(message.hasOptionalNestedMessage ());
 635     Assert.assertFalse(message.hasOptionalForeignMessage());
 636     Assert.assertFalse(message.hasOptionalImportMessage ());
 637
 638     Assert.assertFalse(message.hasOptionalNestedEnum ());
 639     Assert.assertFalse(message.hasOptionalForeignEnum());
 640     Assert.assertFalse(message.hasOptionalImportEnum ());
 641
 642     Assert.assertFalse(message.hasOptionalStringPiece());
 643     Assert.assertFalse(message.hasOptionalCord());
 644
 645     // Optional fields without defaults are set to zero or something like it.
 646     Assert.assertEquals(0    , message.getOptionalInt32   ());
 647     Assert.assertEquals(0    , message.getOptionalInt64   ());
 648     Assert.assertEquals(0    , message.getOptionalUint32  ());
 649     Assert.assertEquals(0    , message.getOptionalUint64  ());
 650     Assert.assertEquals(0    , message.getOptionalSint32  ());
 651     Assert.assertEquals(0    , message.getOptionalSint64  ());
 652     Assert.assertEquals(0    , message.getOptionalFixed32 ());
 653     Assert.assertEquals(0    , message.getOptionalFixed64 ());
 654     Assert.assertEquals(0    , message.getOptionalSfixed32());
 655     Assert.assertEquals(0    , message.getOptionalSfixed64());
 656     Assert.assertEquals(0    , message.getOptionalFloat   (), 0.0);
 657     Assert.assertEquals(0    , message.getOptionalDouble  (), 0.0);
 658     Assert.assertEquals(false, message.getOptionalBool    ());
 659     Assert.assertEquals(""   , message.getOptionalString  ());
 660     Assert.assertEquals(ByteString.EMPTY, message.getOptionalBytes());
 661
 662     // Embedded messages should also be clear.
 663     Assert.assertFalse(message.getOptionalGroup              ().hasA());
 664     Assert.assertFalse(message.getOptionalNestedMessage      ().hasBb());
 665     Assert.assertFalse(message.getOptionalForeignMessage     ().hasC());
 666     Assert.assertFalse(message.getOptionalImportMessage      ().hasD());
 667     Assert.assertFalse(message.getOptionalPublicImportMessage().hasE());
 668     Assert.assertFalse(message.getOptionalLazyMessage        ().hasBb());
 669
 670     Assert.assertEquals(0, message.getOptionalGroup              ().getA());
 671     Assert.assertEquals(0, message.getOptionalNestedMessage      ().getBb());
 672     Assert.assertEquals(0, message.getOptionalForeignMessage     ().getC());
 673     Assert.assertEquals(0, message.getOptionalImportMessage      ().getD());
 674     Assert.assertEquals(0, message.getOptionalPublicImportMessage().getE());
 675     Assert.assertEquals(0, message.getOptionalLazyMessage        ().getBb());
 676
 677     // Enums without defaults are set to the first value in the enum.
 678     Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getOptionalNestedEnum ());
 679     Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getOptionalForeignEnum());
 680     Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getOptionalImportEnum());
 681
 682     Assert.assertEquals("", message.getOptionalStringPiece());
 683     Assert.assertEquals("", message.getOptionalCord());
 684
 685     // Repeated fields are empty.
 686     Assert.assertEquals(0, message.getRepeatedInt32Count   ());
 687     Assert.assertEquals(0, message.getRepeatedInt64Count   ());
 688     Assert.assertEquals(0, message.getRepeatedUint32Count  ());
 689     Assert.assertEquals(0, message.getRepeatedUint64Count  ());
 690     Assert.assertEquals(0, message.getRepeatedSint32Count  ());
 691     Assert.assertEquals(0, message.getRepeatedSint64Count  ());
 692     Assert.assertEquals(0, message.getRepeatedFixed32Count ());
 693     Assert.assertEquals(0, message.getRepeatedFixed64Count ());
 694     Assert.assertEquals(0, message.getRepeatedSfixed32Count());
 695     Assert.assertEquals(0, message.getRepeatedSfixed64Count());
 696     Assert.assertEquals(0, message.getRepeatedFloatCount   ());
 697     Assert.assertEquals(0, message.getRepeatedDoubleCount  ());
 698     Assert.assertEquals(0, message.getRepeatedBoolCount    ());
 699     Assert.assertEquals(0, message.getRepeatedStringCount  ());
 700     Assert.assertEquals(0, message.getRepeatedBytesCount   ());
 701
 702     Assert.assertEquals(0, message.getRepeatedGroupCount         ());
 703     Assert.assertEquals(0, message.getRepeatedNestedMessageCount ());
 704     Assert.assertEquals(0, message.getRepeatedForeignMessageCount());
 705     Assert.assertEquals(0, message.getRepeatedImportMessageCount ());
 706     Assert.assertEquals(0, message.getRepeatedLazyMessageCount   ());
 707     Assert.assertEquals(0, message.getRepeatedNestedEnumCount    ());
 708     Assert.assertEquals(0, message.getRepeatedForeignEnumCount   ());
 709     Assert.assertEquals(0, message.getRepeatedImportEnumCount    ());
 710
 711     Assert.assertEquals(0, message.getRepeatedStringPieceCount());
 712     Assert.assertEquals(0, message.getRepeatedCordCount());
 713
 714     // hasBlah() should also be false for all default fields.
 715     Assert.assertFalse(message.hasDefaultInt32   ());
 716     Assert.assertFalse(message.hasDefaultInt64   ());
 717     Assert.assertFalse(message.hasDefaultUint32  ());
 718     Assert.assertFalse(message.hasDefaultUint64  ());
 719     Assert.assertFalse(message.hasDefaultSint32  ());
 720     Assert.assertFalse(message.hasDefaultSint64  ());
 721     Assert.assertFalse(message.hasDefaultFixed32 ());
 722     Assert.assertFalse(message.hasDefaultFixed64 ());
 723     Assert.assertFalse(message.hasDefaultSfixed32());
 724     Assert.assertFalse(message.hasDefaultSfixed64());
 725     Assert.assertFalse(message.hasDefaultFloat   ());
 726     Assert.assertFalse(message.hasDefaultDouble  ());
 727     Assert.assertFalse(message.hasDefaultBool    ());
 728     Assert.assertFalse(message.hasDefaultString  ());
 729     Assert.assertFalse(message.hasDefaultBytes   ());
 730
 731     Assert.assertFalse(message.hasDefaultNestedEnum ());
 732     Assert.assertFalse(message.hasDefaultForeignEnum());
 733     Assert.assertFalse(message.hasDefaultImportEnum ());
 734
 735     Assert.assertFalse(message.hasDefaultStringPiece());
 736     Assert.assertFalse(message.hasDefaultCord());
 737
 738     // Fields with defaults have their default values (duh).
 739     Assert.assertEquals( 41    , message.getDefaultInt32   ());
 740     Assert.assertEquals( 42    , message.getDefaultInt64   ());
 741     Assert.assertEquals( 43    , message.getDefaultUint32  ());
 742     Assert.assertEquals( 44    , message.getDefaultUint64  ());
 743     Assert.assertEquals(-45    , message.getDefaultSint32  ());
 744     Assert.assertEquals( 46    , message.getDefaultSint64  ());
 745     Assert.assertEquals( 47    , message.getDefaultFixed32 ());
 746     Assert.assertEquals( 48    , message.getDefaultFixed64 ());
 747     Assert.assertEquals( 49    , message.getDefaultSfixed32());
 748     Assert.assertEquals(-50    , message.getDefaultSfixed64());
 749     Assert.assertEquals( 51.5  , message.getDefaultFloat   (), 0.0);
 750     Assert.assertEquals( 52e3  , message.getDefaultDouble  (), 0.0);
 751     Assert.assertEquals(true   , message.getDefaultBool    ());
 752     Assert.assertEquals("hello", message.getDefaultString  ());
 753     Assert.assertEquals(toBytes("world"), message.getDefaultBytes());
 754
 755     Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getDefaultNestedEnum ());
 756     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getDefaultForeignEnum());
 757     Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getDefaultImportEnum());
 758
 759     Assert.assertEquals("abc", message.getDefaultStringPiece());
 760     Assert.assertEquals("123", message.getDefaultCord());
 761   }
 762
 763   // -------------------------------------------------------------------
 764
 765   /**
 766    * Assert (using {@code junit.framework.Assert}} that all fields of
 767    * {@code message} are set to the values assigned by {@code setAllFields}
 768    * followed by {@code modifyRepeatedFields}.
 769    */
 770   public static void assertRepeatedFieldsModified(
 771       TestAllTypesOrBuilder message) {
 772     // ModifyRepeatedFields only sets the second repeated element of each
 773     // field.  In addition to verifying this, we also verify that the first
 774     // element and size were *not* modified.
 775     Assert.assertEquals(2, message.getRepeatedInt32Count   ());
 776     Assert.assertEquals(2, message.getRepeatedInt64Count   ());
 777     Assert.assertEquals(2, message.getRepeatedUint32Count  ());
 778     Assert.assertEquals(2, message.getRepeatedUint64Count  ());
 779     Assert.assertEquals(2, message.getRepeatedSint32Count  ());
 780     Assert.assertEquals(2, message.getRepeatedSint64Count  ());
 781     Assert.assertEquals(2, message.getRepeatedFixed32Count ());
 782     Assert.assertEquals(2, message.getRepeatedFixed64Count ());
 783     Assert.assertEquals(2, message.getRepeatedSfixed32Count());
 784     Assert.assertEquals(2, message.getRepeatedSfixed64Count());
 785     Assert.assertEquals(2, message.getRepeatedFloatCount   ());
 786     Assert.assertEquals(2, message.getRepeatedDoubleCount  ());
 787     Assert.assertEquals(2, message.getRepeatedBoolCount    ());
 788     Assert.assertEquals(2, message.getRepeatedStringCount  ());
 789     Assert.assertEquals(2, message.getRepeatedBytesCount   ());
 790
 791     Assert.assertEquals(2, message.getRepeatedGroupCount         ());
 792     Assert.assertEquals(2, message.getRepeatedNestedMessageCount ());
 793     Assert.assertEquals(2, message.getRepeatedForeignMessageCount());
 794     Assert.assertEquals(2, message.getRepeatedImportMessageCount ());
 795     Assert.assertEquals(2, message.getRepeatedLazyMessageCount   ());
 796     Assert.assertEquals(2, message.getRepeatedNestedEnumCount    ());
 797     Assert.assertEquals(2, message.getRepeatedForeignEnumCount   ());
 798     Assert.assertEquals(2, message.getRepeatedImportEnumCount    ());
 799
 800     Assert.assertEquals(2, message.getRepeatedStringPieceCount());
 801     Assert.assertEquals(2, message.getRepeatedCordCount());
 802
 803     Assert.assertEquals(201  , message.getRepeatedInt32   (0));
 804     Assert.assertEquals(202L , message.getRepeatedInt64   (0));
 805     Assert.assertEquals(203  , message.getRepeatedUint32  (0));
 806     Assert.assertEquals(204L , message.getRepeatedUint64  (0));
 807     Assert.assertEquals(205  , message.getRepeatedSint32  (0));
 808     Assert.assertEquals(206L , message.getRepeatedSint64  (0));
 809     Assert.assertEquals(207  , message.getRepeatedFixed32 (0));
 810     Assert.assertEquals(208L , message.getRepeatedFixed64 (0));
 811     Assert.assertEquals(209  , message.getRepeatedSfixed32(0));
 812     Assert.assertEquals(210L , message.getRepeatedSfixed64(0));
 813     Assert.assertEquals(211F , message.getRepeatedFloat   (0));
 814     Assert.assertEquals(212D , message.getRepeatedDouble  (0));
 815     Assert.assertEquals(true , message.getRepeatedBool    (0));
 816     Assert.assertEquals("215", message.getRepeatedString  (0));
 817     Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0));
 818
 819     Assert.assertEquals(217, message.getRepeatedGroup         (0).getA());
 820     Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb());
 821     Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC());
 822     Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD());
 823     Assert.assertEquals(227, message.getRepeatedLazyMessage   (0).getBb());
 824
 825     Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEnum (0));
 826     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(0));
 827     Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0));
 828
 829     Assert.assertEquals("224", message.getRepeatedStringPiece(0));
 830     Assert.assertEquals("225", message.getRepeatedCord(0));
 831
 832     // Actually verify the second (modified) elements now.
 833     Assert.assertEquals(501  , message.getRepeatedInt32   (1));
 834     Assert.assertEquals(502L , message.getRepeatedInt64   (1));
 835     Assert.assertEquals(503  , message.getRepeatedUint32  (1));
 836     Assert.assertEquals(504L , message.getRepeatedUint64  (1));
 837     Assert.assertEquals(505  , message.getRepeatedSint32  (1));
 838     Assert.assertEquals(506L , message.getRepeatedSint64  (1));
 839     Assert.assertEquals(507  , message.getRepeatedFixed32 (1));
 840     Assert.assertEquals(508L , message.getRepeatedFixed64 (1));
 841     Assert.assertEquals(509  , message.getRepeatedSfixed32(1));
 842     Assert.assertEquals(510L , message.getRepeatedSfixed64(1));
 843     Assert.assertEquals(511F , message.getRepeatedFloat   (1));
 844     Assert.assertEquals(512D , message.getRepeatedDouble  (1));
 845     Assert.assertEquals(true , message.getRepeatedBool    (1));
 846     Assert.assertEquals("515", message.getRepeatedString  (1));
 847     Assert.assertEquals(toBytes("516"), message.getRepeatedBytes(1));
 848
 849     Assert.assertEquals(517, message.getRepeatedGroup         (1).getA());
 850     Assert.assertEquals(518, message.getRepeatedNestedMessage (1).getBb());
 851     Assert.assertEquals(519, message.getRepeatedForeignMessage(1).getC());
 852     Assert.assertEquals(520, message.getRepeatedImportMessage (1).getD());
 853     Assert.assertEquals(527, message.getRepeatedLazyMessage   (1).getBb());
 854
 855     Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getRepeatedNestedEnum (1));
 856     Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getRepeatedForeignEnum(1));
 857     Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getRepeatedImportEnum(1));
 858
 859     Assert.assertEquals("524", message.getRepeatedStringPiece(1));
 860     Assert.assertEquals("525", message.getRepeatedCord(1));
 861   }
 862
 863   /**
 864    * Set every field of {@code message} to a unique value.
 865    */
 866   public static void setPackedFields(TestPackedTypes.Builder message) {
 867     message.addPackedInt32   (601);
 868     message.addPackedInt64   (602);
 869     message.addPackedUint32  (603);
 870     message.addPackedUint64  (604);
 871     message.addPackedSint32  (605);
 872     message.addPackedSint64  (606);
 873     message.addPackedFixed32 (607);
 874     message.addPackedFixed64 (608);
 875     message.addPackedSfixed32(609);
 876     message.addPackedSfixed64(610);
 877     message.addPackedFloat   (611);
 878     message.addPackedDouble  (612);
 879     message.addPackedBool    (true);
 880     message.addPackedEnum    (ForeignEnum.FOREIGN_BAR);
 881     // Add a second one of each field.
 882     message.addPackedInt32   (701);
 883     message.addPackedInt64   (702);
 884     message.addPackedUint32  (703);
 885     message.addPackedUint64  (704);
 886     message.addPackedSint32  (705);
 887     message.addPackedSint64  (706);
 888     message.addPackedFixed32 (707);
 889     message.addPackedFixed64 (708);
 890     message.addPackedSfixed32(709);
 891     message.addPackedSfixed64(710);
 892     message.addPackedFloat   (711);
 893     message.addPackedDouble  (712);
 894     message.addPackedBool    (false);
 895     message.addPackedEnum    (ForeignEnum.FOREIGN_BAZ);
 896   }
 897
 898   /**
 899    * Set every field of {@code message} to a unique value. Must correspond with
 900    * the values applied by {@code setPackedFields}.
 901    */
 902   public static void setUnpackedFields(TestUnpackedTypes.Builder message) {
 903     message.addUnpackedInt32   (601);
 904     message.addUnpackedInt64   (602);
 905     message.addUnpackedUint32  (603);
 906     message.addUnpackedUint64  (604);
 907     message.addUnpackedSint32  (605);
 908     message.addUnpackedSint64  (606);
 909     message.addUnpackedFixed32 (607);
 910     message.addUnpackedFixed64 (608);
 911     message.addUnpackedSfixed32(609);
 912     message.addUnpackedSfixed64(610);
 913     message.addUnpackedFloat   (611);
 914     message.addUnpackedDouble  (612);
 915     message.addUnpackedBool    (true);
 916     message.addUnpackedEnum    (ForeignEnum.FOREIGN_BAR);
 917     // Add a second one of each field.
 918     message.addUnpackedInt32   (701);
 919     message.addUnpackedInt64   (702);
 920     message.addUnpackedUint32  (703);
 921     message.addUnpackedUint64  (704);
 922     message.addUnpackedSint32  (705);
 923     message.addUnpackedSint64  (706);
 924     message.addUnpackedFixed32 (707);
 925     message.addUnpackedFixed64 (708);
 926     message.addUnpackedSfixed32(709);
 927     message.addUnpackedSfixed64(710);
 928     message.addUnpackedFloat   (711);
 929     message.addUnpackedDouble  (712);
 930     message.addUnpackedBool    (false);
 931     message.addUnpackedEnum    (ForeignEnum.FOREIGN_BAZ);
 932   }
 933
 934   /**
 935    * Assert (using {@code junit.framework.Assert}} that all fields of
 936    * {@code message} are set to the values assigned by {@code setPackedFields}.
 937    */
 938   public static void assertPackedFieldsSet(TestPackedTypes message) {
 939     Assert.assertEquals(2, message.getPackedInt32Count   ());
 940     Assert.assertEquals(2, message.getPackedInt64Count   ());
 941     Assert.assertEquals(2, message.getPackedUint32Count  ());
 942     Assert.assertEquals(2, message.getPackedUint64Count  ());
 943     Assert.assertEquals(2, message.getPackedSint32Count  ());
 944     Assert.assertEquals(2, message.getPackedSint64Count  ());
 945     Assert.assertEquals(2, message.getPackedFixed32Count ());
 946     Assert.assertEquals(2, message.getPackedFixed64Count ());
 947     Assert.assertEquals(2, message.getPackedSfixed32Count());
 948     Assert.assertEquals(2, message.getPackedSfixed64Count());
 949     Assert.assertEquals(2, message.getPackedFloatCount   ());
 950     Assert.assertEquals(2, message.getPackedDoubleCount  ());
 951     Assert.assertEquals(2, message.getPackedBoolCount    ());
 952     Assert.assertEquals(2, message.getPackedEnumCount   ());
 953     Assert.assertEquals(601  , message.getPackedInt32   (0));
 954     Assert.assertEquals(602  , message.getPackedInt64   (0));
 955     Assert.assertEquals(603  , message.getPackedUint32  (0));
 956     Assert.assertEquals(604  , message.getPackedUint64  (0));
 957     Assert.assertEquals(605  , message.getPackedSint32  (0));
 958     Assert.assertEquals(606  , message.getPackedSint64  (0));
 959     Assert.assertEquals(607  , message.getPackedFixed32 (0));
 960     Assert.assertEquals(608  , message.getPackedFixed64 (0));
 961     Assert.assertEquals(609  , message.getPackedSfixed32(0));
 962     Assert.assertEquals(610  , message.getPackedSfixed64(0));
 963     Assert.assertEquals(611  , message.getPackedFloat   (0), 0.0);
 964     Assert.assertEquals(612  , message.getPackedDouble  (0), 0.0);
 965     Assert.assertEquals(true , message.getPackedBool    (0));
 966     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getPackedEnum(0));
 967     Assert.assertEquals(701  , message.getPackedInt32   (1));
 968     Assert.assertEquals(702  , message.getPackedInt64   (1));
 969     Assert.assertEquals(703  , message.getPackedUint32  (1));
 970     Assert.assertEquals(704  , message.getPackedUint64  (1));
 971     Assert.assertEquals(705  , message.getPackedSint32  (1));
 972     Assert.assertEquals(706  , message.getPackedSint64  (1));
 973     Assert.assertEquals(707  , message.getPackedFixed32 (1));
 974     Assert.assertEquals(708  , message.getPackedFixed64 (1));
 975     Assert.assertEquals(709  , message.getPackedSfixed32(1));
 976     Assert.assertEquals(710  , message.getPackedSfixed64(1));
 977     Assert.assertEquals(711  , message.getPackedFloat   (1), 0.0);
 978     Assert.assertEquals(712  , message.getPackedDouble  (1), 0.0);
 979     Assert.assertEquals(false, message.getPackedBool    (1));
 980     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getPackedEnum(1));
 981   }
 982
 983   /**
 984    * Assert (using {@code junit.framework.Assert}} that all fields of
 985    * {@code message} are set to the values assigned by {@code setUnpackedFields}.
 986    */
 987   public static void assertUnpackedFieldsSet(TestUnpackedTypes message) {
 988     Assert.assertEquals(2, message.getUnpackedInt32Count   ());
 989     Assert.assertEquals(2, message.getUnpackedInt64Count   ());
 990     Assert.assertEquals(2, message.getUnpackedUint32Count  ());
 991     Assert.assertEquals(2, message.getUnpackedUint64Count  ());
 992     Assert.assertEquals(2, message.getUnpackedSint32Count  ());
 993     Assert.assertEquals(2, message.getUnpackedSint64Count  ());
 994     Assert.assertEquals(2, message.getUnpackedFixed32Count ());
 995     Assert.assertEquals(2, message.getUnpackedFixed64Count ());
 996     Assert.assertEquals(2, message.getUnpackedSfixed32Count());
 997     Assert.assertEquals(2, message.getUnpackedSfixed64Count());
 998     Assert.assertEquals(2, message.getUnpackedFloatCount   ());
 999     Assert.assertEquals(2, message.getUnpackedDoubleCount  ());
1000     Assert.assertEquals(2, message.getUnpackedBoolCount    ());
1001     Assert.assertEquals(2, message.getUnpackedEnumCount   ());
1002     Assert.assertEquals(601  , message.getUnpackedInt32   (0));
1003     Assert.assertEquals(602  , message.getUnpackedInt64   (0));
1004     Assert.assertEquals(603  , message.getUnpackedUint32  (0));
1005     Assert.assertEquals(604  , message.getUnpackedUint64  (0));
1006     Assert.assertEquals(605  , message.getUnpackedSint32  (0));
1007     Assert.assertEquals(606  , message.getUnpackedSint64  (0));
1008     Assert.assertEquals(607  , message.getUnpackedFixed32 (0));
1009     Assert.assertEquals(608  , message.getUnpackedFixed64 (0));
1010     Assert.assertEquals(609  , message.getUnpackedSfixed32(0));
1011     Assert.assertEquals(610  , message.getUnpackedSfixed64(0));
1012     Assert.assertEquals(611  , message.getUnpackedFloat   (0), 0.0);
1013     Assert.assertEquals(612  , message.getUnpackedDouble  (0), 0.0);
1014     Assert.assertEquals(true , message.getUnpackedBool    (0));
1015     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getUnpackedEnum(0));
1016     Assert.assertEquals(701  , message.getUnpackedInt32   (1));
1017     Assert.assertEquals(702  , message.getUnpackedInt64   (1));
1018     Assert.assertEquals(703  , message.getUnpackedUint32  (1));
1019     Assert.assertEquals(704  , message.getUnpackedUint64  (1));
1020     Assert.assertEquals(705  , message.getUnpackedSint32  (1));
1021     Assert.assertEquals(706  , message.getUnpackedSint64  (1));
1022     Assert.assertEquals(707  , message.getUnpackedFixed32 (1));
1023     Assert.assertEquals(708  , message.getUnpackedFixed64 (1));
1024     Assert.assertEquals(709  , message.getUnpackedSfixed32(1));
1025     Assert.assertEquals(710  , message.getUnpackedSfixed64(1));
1026     Assert.assertEquals(711  , message.getUnpackedFloat   (1), 0.0);
1027     Assert.assertEquals(712  , message.getUnpackedDouble  (1), 0.0);
1028     Assert.assertEquals(false, message.getUnpackedBool    (1));
1029     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getUnpackedEnum(1));
1030   }
1031
1032   // ===================================================================
1033   // Like above, but for extensions
1034
1035   // Java gets confused with things like assertEquals(int, Integer):  it can't
1036   // decide whether to call assertEquals(int, int) or assertEquals(Object,
1037   // Object).  So we define these methods to help it.
1038   private static void assertEqualsExactType(int a, int b) {
1039     Assert.assertEquals(a, b);
1040   }
1041   private static void assertEqualsExactType(long a, long b) {
1042     Assert.assertEquals(a, b);
1043   }
1044   private static void assertEqualsExactType(float a, float b) {
1045     Assert.assertEquals(a, b, 0.0);
1046   }
1047   private static void assertEqualsExactType(double a, double b) {
1048     Assert.assertEquals(a, b, 0.0);
1049   }
1050   private static void assertEqualsExactType(boolean a, boolean b) {
1051     Assert.assertEquals(a, b);
1052   }
1053   private static void assertEqualsExactType(String a, String b) {
1054     Assert.assertEquals(a, b);
1055   }
1056   private static void assertEqualsExactType(ByteString a, ByteString b) {
1057     Assert.assertEquals(a, b);
1058   }
1059   private static void assertEqualsExactType(TestAllTypes.NestedEnum a,
1060                                             TestAllTypes.NestedEnum b) {
1061     Assert.assertEquals(a, b);
1062   }
1063   private static void assertEqualsExactType(ForeignEnum a, ForeignEnum b) {
1064     Assert.assertEquals(a, b);
1065   }
1066   private static void assertEqualsExactType(ImportEnum a, ImportEnum b) {
1067     Assert.assertEquals(a, b);
1068   }
1069   /**
1070    * Get an unmodifiable {@link ExtensionRegistry} containing all the
1071    * extensions of {@code TestAllExtensions}.
1072    */
1073   public static ExtensionRegistry getExtensionRegistry() {
1074     ExtensionRegistry registry = ExtensionRegistry.newInstance();
1075     registerAllExtensions(registry);
1076     return registry.getUnmodifiable();
1077   }
1078
1079
1080   /**
1081    * Register all of {@code TestAllExtensions}'s extensions with the
1082    * given {@link ExtensionRegistry}.
1083    */
1084   public static void registerAllExtensions(ExtensionRegistry registry) {
1085     UnittestProto.registerAllExtensions(registry);
1086   }
1087
1088
1089   /**
1090    * Set every field of {@code message} to the values expected by
1091    * {@code assertAllExtensionsSet()}.
1092    */
1093   public static void setAllExtensions(TestAllExtensions.Builder message) {
1094     message.setExtension(optionalInt32Extension   , 101);
1095     message.setExtension(optionalInt64Extension   , 102L);
1096     message.setExtension(optionalUint32Extension  , 103);
1097     message.setExtension(optionalUint64Extension  , 104L);
1098     message.setExtension(optionalSint32Extension  , 105);
1099     message.setExtension(optionalSint64Extension  , 106L);
1100     message.setExtension(optionalFixed32Extension , 107);
1101     message.setExtension(optionalFixed64Extension , 108L);
1102     message.setExtension(optionalSfixed32Extension, 109);
1103     message.setExtension(optionalSfixed64Extension, 110L);
1104     message.setExtension(optionalFloatExtension   , 111F);
1105     message.setExtension(optionalDoubleExtension  , 112D);
1106     message.setExtension(optionalBoolExtension    , true);
1107     message.setExtension(optionalStringExtension  , "115");
1108     message.setExtension(optionalBytesExtension   , toBytes("116"));
1109
1110     message.setExtension(optionalGroupExtension,
1111       OptionalGroup_extension.newBuilder().setA(117).build());
1112     message.setExtension(optionalNestedMessageExtension,
1113       TestAllTypes.NestedMessage.newBuilder().setBb(118).build());
1114     message.setExtension(optionalForeignMessageExtension,
1115       ForeignMessage.newBuilder().setC(119).build());
1116     message.setExtension(optionalImportMessageExtension,
1117       ImportMessage.newBuilder().setD(120).build());
1118     message.setExtension(optionalPublicImportMessageExtension,
1119       PublicImportMessage.newBuilder().setE(126).build());
1120     message.setExtension(optionalLazyMessageExtension,
1121       TestAllTypes.NestedMessage.newBuilder().setBb(127).build());
1122
1123     message.setExtension(optionalNestedEnumExtension, TestAllTypes.NestedEnum.BAZ);
1124     message.setExtension(optionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ);
1125     message.setExtension(optionalImportEnumExtension, ImportEnum.IMPORT_BAZ);
1126
1127     message.setExtension(optionalStringPieceExtension, "124");
1128     message.setExtension(optionalCordExtension, "125");
1129
1130     // -----------------------------------------------------------------
1131
1132     message.addExtension(repeatedInt32Extension   , 201);
1133     message.addExtension(repeatedInt64Extension   , 202L);
1134     message.addExtension(repeatedUint32Extension  , 203);
1135     message.addExtension(repeatedUint64Extension  , 204L);
1136     message.addExtension(repeatedSint32Extension  , 205);
1137     message.addExtension(repeatedSint64Extension  , 206L);
1138     message.addExtension(repeatedFixed32Extension , 207);
1139     message.addExtension(repeatedFixed64Extension , 208L);
1140     message.addExtension(repeatedSfixed32Extension, 209);
1141     message.addExtension(repeatedSfixed64Extension, 210L);
1142     message.addExtension(repeatedFloatExtension   , 211F);
1143     message.addExtension(repeatedDoubleExtension  , 212D);
1144     message.addExtension(repeatedBoolExtension    , true);
1145     message.addExtension(repeatedStringExtension  , "215");
1146     message.addExtension(repeatedBytesExtension   , toBytes("216"));
1147
1148     message.addExtension(repeatedGroupExtension,
1149       RepeatedGroup_extension.newBuilder().setA(217).build());
1150     message.addExtension(repeatedNestedMessageExtension,
1151       TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
1152     message.addExtension(repeatedForeignMessageExtension,
1153       ForeignMessage.newBuilder().setC(219).build());
1154     message.addExtension(repeatedImportMessageExtension,
1155       ImportMessage.newBuilder().setD(220).build());
1156     message.addExtension(repeatedLazyMessageExtension,
1157       TestAllTypes.NestedMessage.newBuilder().setBb(227).build());
1158
1159     message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAR);
1160     message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAR);
1161     message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAR);
1162
1163     message.addExtension(repeatedStringPieceExtension, "224");
1164     message.addExtension(repeatedCordExtension, "225");
1165
1166     // Add a second one of each field.
1167     message.addExtension(repeatedInt32Extension   , 301);
1168     message.addExtension(repeatedInt64Extension   , 302L);
1169     message.addExtension(repeatedUint32Extension  , 303);
1170     message.addExtension(repeatedUint64Extension  , 304L);
1171     message.addExtension(repeatedSint32Extension  , 305);
1172     message.addExtension(repeatedSint64Extension  , 306L);
1173     message.addExtension(repeatedFixed32Extension , 307);
1174     message.addExtension(repeatedFixed64Extension , 308L);
1175     message.addExtension(repeatedSfixed32Extension, 309);
1176     message.addExtension(repeatedSfixed64Extension, 310L);
1177     message.addExtension(repeatedFloatExtension   , 311F);
1178     message.addExtension(repeatedDoubleExtension  , 312D);
1179     message.addExtension(repeatedBoolExtension    , false);
1180     message.addExtension(repeatedStringExtension  , "315");
1181     message.addExtension(repeatedBytesExtension   , toBytes("316"));
1182
1183     message.addExtension(repeatedGroupExtension,
1184       RepeatedGroup_extension.newBuilder().setA(317).build());
1185     message.addExtension(repeatedNestedMessageExtension,
1186       TestAllTypes.NestedMessage.newBuilder().setBb(318).build());
1187     message.addExtension(repeatedForeignMessageExtension,
1188       ForeignMessage.newBuilder().setC(319).build());
1189     message.addExtension(repeatedImportMessageExtension,
1190       ImportMessage.newBuilder().setD(320).build());
1191     message.addExtension(repeatedLazyMessageExtension,
1192       TestAllTypes.NestedMessage.newBuilder().setBb(327).build());
1193
1194     message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAZ);
1195     message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ);
1196     message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAZ);
1197
1198     message.addExtension(repeatedStringPieceExtension, "324");
1199     message.addExtension(repeatedCordExtension, "325");
1200
1201     // -----------------------------------------------------------------
1202
1203     message.setExtension(defaultInt32Extension   , 401);
1204     message.setExtension(defaultInt64Extension   , 402L);
1205     message.setExtension(defaultUint32Extension  , 403);
1206     message.setExtension(defaultUint64Extension  , 404L);
1207     message.setExtension(defaultSint32Extension  , 405);
1208     message.setExtension(defaultSint64Extension  , 406L);
1209     message.setExtension(defaultFixed32Extension , 407);
1210     message.setExtension(defaultFixed64Extension , 408L);
1211     message.setExtension(defaultSfixed32Extension, 409);
1212     message.setExtension(defaultSfixed64Extension, 410L);
1213     message.setExtension(defaultFloatExtension   , 411F);
1214     message.setExtension(defaultDoubleExtension  , 412D);
1215     message.setExtension(defaultBoolExtension    , false);
1216     message.setExtension(defaultStringExtension  , "415");
1217     message.setExtension(defaultBytesExtension   , toBytes("416"));
1218
1219     message.setExtension(defaultNestedEnumExtension, TestAllTypes.NestedEnum.FOO);
1220     message.setExtension(defaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO);
1221     message.setExtension(defaultImportEnumExtension, ImportEnum.IMPORT_FOO);
1222
1223     message.setExtension(defaultStringPieceExtension, "424");
1224     message.setExtension(defaultCordExtension, "425");
1225   }
1226
1227   // -------------------------------------------------------------------
1228
1229   /**
1230    * Modify the repeated extensions of {@code message} to contain the values
1231    * expected by {@code assertRepeatedExtensionsModified()}.
1232    */
1233   public static void modifyRepeatedExtensions(
1234       TestAllExtensions.Builder message) {
1235     message.setExtension(repeatedInt32Extension   , 1, 501);
1236     message.setExtension(repeatedInt64Extension   , 1, 502L);
1237     message.setExtension(repeatedUint32Extension  , 1, 503);
1238     message.setExtension(repeatedUint64Extension  , 1, 504L);
1239     message.setExtension(repeatedSint32Extension  , 1, 505);
1240     message.setExtension(repeatedSint64Extension  , 1, 506L);
1241     message.setExtension(repeatedFixed32Extension , 1, 507);
1242     message.setExtension(repeatedFixed64Extension , 1, 508L);
1243     message.setExtension(repeatedSfixed32Extension, 1, 509);
1244     message.setExtension(repeatedSfixed64Extension, 1, 510L);
1245     message.setExtension(repeatedFloatExtension   , 1, 511F);
1246     message.setExtension(repeatedDoubleExtension  , 1, 512D);
1247     message.setExtension(repeatedBoolExtension    , 1, true);
1248     message.setExtension(repeatedStringExtension  , 1, "515");
1249     message.setExtension(repeatedBytesExtension   , 1, toBytes("516"));
1250
1251     message.setExtension(repeatedGroupExtension, 1,
1252       RepeatedGroup_extension.newBuilder().setA(517).build());
1253     message.setExtension(repeatedNestedMessageExtension, 1,
1254       TestAllTypes.NestedMessage.newBuilder().setBb(518).build());
1255     message.setExtension(repeatedForeignMessageExtension, 1,
1256       ForeignMessage.newBuilder().setC(519).build());
1257     message.setExtension(repeatedImportMessageExtension, 1,
1258       ImportMessage.newBuilder().setD(520).build());
1259     message.setExtension(repeatedLazyMessageExtension, 1,
1260       TestAllTypes.NestedMessage.newBuilder().setBb(527).build());
1261
1262     message.setExtension(repeatedNestedEnumExtension , 1, TestAllTypes.NestedEnum.FOO);
1263     message.setExtension(repeatedForeignEnumExtension, 1, ForeignEnum.FOREIGN_FOO);
1264     message.setExtension(repeatedImportEnumExtension , 1, ImportEnum.IMPORT_FOO);
1265
1266     message.setExtension(repeatedStringPieceExtension, 1, "524");
1267     message.setExtension(repeatedCordExtension, 1, "525");
1268   }
1269
1270   // -------------------------------------------------------------------
1271
1272   /**
1273    * Assert (using {@code junit.framework.Assert}} that all extensions of
1274    * {@code message} are set to the values assigned by {@code setAllExtensions}.
1275    */
1276   public static void assertAllExtensionsSet(
1277       TestAllExtensionsOrBuilder message) {
1278     Assert.assertTrue(message.hasExtension(optionalInt32Extension   ));
1279     Assert.assertTrue(message.hasExtension(optionalInt64Extension   ));
1280     Assert.assertTrue(message.hasExtension(optionalUint32Extension  ));
1281     Assert.assertTrue(message.hasExtension(optionalUint64Extension  ));
1282     Assert.assertTrue(message.hasExtension(optionalSint32Extension  ));
1283     Assert.assertTrue(message.hasExtension(optionalSint64Extension  ));
1284     Assert.assertTrue(message.hasExtension(optionalFixed32Extension ));
1285     Assert.assertTrue(message.hasExtension(optionalFixed64Extension ));
1286     Assert.assertTrue(message.hasExtension(optionalSfixed32Extension));
1287     Assert.assertTrue(message.hasExtension(optionalSfixed64Extension));
1288     Assert.assertTrue(message.hasExtension(optionalFloatExtension   ));
1289     Assert.assertTrue(message.hasExtension(optionalDoubleExtension  ));
1290     Assert.assertTrue(message.hasExtension(optionalBoolExtension    ));
1291     Assert.assertTrue(message.hasExtension(optionalStringExtension  ));
1292     Assert.assertTrue(message.hasExtension(optionalBytesExtension   ));
1293
1294     Assert.assertTrue(message.hasExtension(optionalGroupExtension         ));
1295     Assert.assertTrue(message.hasExtension(optionalNestedMessageExtension ));
1296     Assert.assertTrue(message.hasExtension(optionalForeignMessageExtension));
1297     Assert.assertTrue(message.hasExtension(optionalImportMessageExtension ));
1298
1299     Assert.assertTrue(message.getExtension(optionalGroupExtension         ).hasA());
1300     Assert.assertTrue(message.getExtension(optionalNestedMessageExtension ).hasBb());
1301     Assert.assertTrue(message.getExtension(optionalForeignMessageExtension).hasC());
1302     Assert.assertTrue(message.getExtension(optionalImportMessageExtension ).hasD());
1303
1304     Assert.assertTrue(message.hasExtension(optionalNestedEnumExtension ));
1305     Assert.assertTrue(message.hasExtension(optionalForeignEnumExtension));
1306     Assert.assertTrue(message.hasExtension(optionalImportEnumExtension ));
1307
1308     Assert.assertTrue(message.hasExtension(optionalStringPieceExtension));
1309     Assert.assertTrue(message.hasExtension(optionalCordExtension));
1310
1311     assertEqualsExactType(101  , message.getExtension(optionalInt32Extension   ));
1312     assertEqualsExactType(102L , message.getExtension(optionalInt64Extension   ));
1313     assertEqualsExactType(103  , message.getExtension(optionalUint32Extension  ));
1314     assertEqualsExactType(104L , message.getExtension(optionalUint64Extension  ));
1315     assertEqualsExactType(105  , message.getExtension(optionalSint32Extension  ));
1316     assertEqualsExactType(106L , message.getExtension(optionalSint64Extension  ));
1317     assertEqualsExactType(107  , message.getExtension(optionalFixed32Extension ));
1318     assertEqualsExactType(108L , message.getExtension(optionalFixed64Extension ));
1319     assertEqualsExactType(109  , message.getExtension(optionalSfixed32Extension));
1320     assertEqualsExactType(110L , message.getExtension(optionalSfixed64Extension));
1321     assertEqualsExactType(111F , message.getExtension(optionalFloatExtension   ));
1322     assertEqualsExactType(112D , message.getExtension(optionalDoubleExtension  ));
1323     assertEqualsExactType(true , message.getExtension(optionalBoolExtension    ));
1324     assertEqualsExactType("115", message.getExtension(optionalStringExtension  ));
1325     assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExtension));
1326
1327     assertEqualsExactType(117, message.getExtension(optionalGroupExtension              ).getA());
1328     assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtension      ).getBb());
1329     assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtension     ).getC());
1330     assertEqualsExactType(120, message.getExtension(optionalImportMessageExtension      ).getD());
1331     assertEqualsExactType(126, message.getExtension(optionalPublicImportMessageExtension).getE());
1332     assertEqualsExactType(127, message.getExtension(optionalLazyMessageExtension        ).getBb());
1333
1334     assertEqualsExactType(TestAllTypes.NestedEnum.BAZ,
1335       message.getExtension(optionalNestedEnumExtension));
1336     assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
1337       message.getExtension(optionalForeignEnumExtension));
1338     assertEqualsExactType(ImportEnum.IMPORT_BAZ,
1339       message.getExtension(optionalImportEnumExtension));
1340
1341     assertEqualsExactType("124", message.getExtension(optionalStringPieceExtension));
1342     assertEqualsExactType("125", message.getExtension(optionalCordExtension));
1343
1344     // -----------------------------------------------------------------
1345
1346     Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension   ));
1347     Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension   ));
1348     Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension  ));
1349     Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension  ));
1350     Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension  ));
1351     Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension  ));
1352     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension ));
1353     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension ));
1354     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension));
1355     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension));
1356     Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension   ));
1357     Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension  ));
1358     Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension    ));
1359     Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension  ));
1360     Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension   ));
1361
1362     Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension         ));
1363     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension ));
1364     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));
1365     Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension ));
1366     Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtension   ));
1367     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension    ));
1368     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension   ));
1369     Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension    ));
1370
1371     Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension));
1372     Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension));
1373
1374     assertEqualsExactType(201  , message.getExtension(repeatedInt32Extension   , 0));
1375     assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension   , 0));
1376     assertEqualsExactType(203  , message.getExtension(repeatedUint32Extension  , 0));
1377     assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension  , 0));
1378     assertEqualsExactType(205  , message.getExtension(repeatedSint32Extension  , 0));
1379     assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension  , 0));
1380     assertEqualsExactType(207  , message.getExtension(repeatedFixed32Extension , 0));
1381     assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension , 0));
1382     assertEqualsExactType(209  , message.getExtension(repeatedSfixed32Extension, 0));
1383     assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension, 0));
1384     assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension   , 0));
1385     assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension  , 0));
1386     assertEqualsExactType(true , message.getExtension(repeatedBoolExtension    , 0));
1387     assertEqualsExactType("215", message.getExtension(repeatedStringExtension  , 0));
1388     assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0));
1389
1390     assertEqualsExactType(217, message.getExtension(repeatedGroupExtension         , 0).getA());
1391     assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb());
1392     assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());
1393     assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD());
1394     assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension   , 0).getBb());
1395
1396     assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
1397       message.getExtension(repeatedNestedEnumExtension, 0));
1398     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
1399       message.getExtension(repeatedForeignEnumExtension, 0));
1400     assertEqualsExactType(ImportEnum.IMPORT_BAR,
1401       message.getExtension(repeatedImportEnumExtension, 0));
1402
1403     assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0));
1404     assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0));
1405
1406     assertEqualsExactType(301  , message.getExtension(repeatedInt32Extension   , 1));
1407     assertEqualsExactType(302L , message.getExtension(repeatedInt64Extension   , 1));
1408     assertEqualsExactType(303  , message.getExtension(repeatedUint32Extension  , 1));
1409     assertEqualsExactType(304L , message.getExtension(repeatedUint64Extension  , 1));
1410     assertEqualsExactType(305  , message.getExtension(repeatedSint32Extension  , 1));
1411     assertEqualsExactType(306L , message.getExtension(repeatedSint64Extension  , 1));
1412     assertEqualsExactType(307  , message.getExtension(repeatedFixed32Extension , 1));
1413     assertEqualsExactType(308L , message.getExtension(repeatedFixed64Extension , 1));
1414     assertEqualsExactType(309  , message.getExtension(repeatedSfixed32Extension, 1));
1415     assertEqualsExactType(310L , message.getExtension(repeatedSfixed64Extension, 1));
1416     assertEqualsExactType(311F , message.getExtension(repeatedFloatExtension   , 1));
1417     assertEqualsExactType(312D , message.getExtension(repeatedDoubleExtension  , 1));
1418     assertEqualsExactType(false, message.getExtension(repeatedBoolExtension    , 1));
1419     assertEqualsExactType("315", message.getExtension(repeatedStringExtension  , 1));
1420     assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExtension, 1));
1421
1422     assertEqualsExactType(317, message.getExtension(repeatedGroupExtension         , 1).getA());
1423     assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtension , 1).getBb());
1424     assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtension, 1).getC());
1425     assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtension , 1).getD());
1426     assertEqualsExactType(327, message.getExtension(repeatedLazyMessageExtension   , 1).getBb());
1427
1428     assertEqualsExactType(TestAllTypes.NestedEnum.BAZ,
1429       message.getExtension(repeatedNestedEnumExtension, 1));
1430     assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
1431       message.getExtension(repeatedForeignEnumExtension, 1));
1432     assertEqualsExactType(ImportEnum.IMPORT_BAZ,
1433       message.getExtension(repeatedImportEnumExtension, 1));
1434
1435     assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtension, 1));
1436     assertEqualsExactType("325", message.getExtension(repeatedCordExtension, 1));
1437
1438     // -----------------------------------------------------------------
1439
1440     Assert.assertTrue(message.hasExtension(defaultInt32Extension   ));
1441     Assert.assertTrue(message.hasExtension(defaultInt64Extension   ));
1442     Assert.assertTrue(message.hasExtension(defaultUint32Extension  ));
1443     Assert.assertTrue(message.hasExtension(defaultUint64Extension  ));
1444     Assert.assertTrue(message.hasExtension(defaultSint32Extension  ));
1445     Assert.assertTrue(message.hasExtension(defaultSint64Extension  ));
1446     Assert.assertTrue(message.hasExtension(defaultFixed32Extension ));
1447     Assert.assertTrue(message.hasExtension(defaultFixed64Extension ));
1448     Assert.assertTrue(message.hasExtension(defaultSfixed32Extension));
1449     Assert.assertTrue(message.hasExtension(defaultSfixed64Extension));
1450     Assert.assertTrue(message.hasExtension(defaultFloatExtension   ));
1451     Assert.assertTrue(message.hasExtension(defaultDoubleExtension  ));
1452     Assert.assertTrue(message.hasExtension(defaultBoolExtension    ));
1453     Assert.assertTrue(message.hasExtension(defaultStringExtension  ));
1454     Assert.assertTrue(message.hasExtension(defaultBytesExtension   ));
1455
1456     Assert.assertTrue(message.hasExtension(defaultNestedEnumExtension ));
1457     Assert.assertTrue(message.hasExtension(defaultForeignEnumExtension));
1458     Assert.assertTrue(message.hasExtension(defaultImportEnumExtension ));
1459
1460     Assert.assertTrue(message.hasExtension(defaultStringPieceExtension));
1461     Assert.assertTrue(message.hasExtension(defaultCordExtension));
1462
1463     assertEqualsExactType(401  , message.getExtension(defaultInt32Extension   ));
1464     assertEqualsExactType(402L , message.getExtension(defaultInt64Extension   ));
1465     assertEqualsExactType(403  , message.getExtension(defaultUint32Extension  ));
1466     assertEqualsExactType(404L , message.getExtension(defaultUint64Extension  ));
1467     assertEqualsExactType(405  , message.getExtension(defaultSint32Extension  ));
1468     assertEqualsExactType(406L , message.getExtension(defaultSint64Extension  ));
1469     assertEqualsExactType(407  , message.getExtension(defaultFixed32Extension ));
1470     assertEqualsExactType(408L , message.getExtension(defaultFixed64Extension ));
1471     assertEqualsExactType(409  , message.getExtension(defaultSfixed32Extension));
1472     assertEqualsExactType(410L , message.getExtension(defaultSfixed64Extension));
1473     assertEqualsExactType(411F , message.getExtension(defaultFloatExtension   ));
1474     assertEqualsExactType(412D , message.getExtension(defaultDoubleExtension  ));
1475     assertEqualsExactType(false, message.getExtension(defaultBoolExtension    ));
1476     assertEqualsExactType("415", message.getExtension(defaultStringExtension  ));
1477     assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExtension));
1478
1479     assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
1480       message.getExtension(defaultNestedEnumExtension ));
1481     assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
1482       message.getExtension(defaultForeignEnumExtension));
1483     assertEqualsExactType(ImportEnum.IMPORT_FOO,
1484       message.getExtension(defaultImportEnumExtension));
1485
1486     assertEqualsExactType("424", message.getExtension(defaultStringPieceExtension));
1487     assertEqualsExactType("425", message.getExtension(defaultCordExtension));
1488   }
1489
1490   // -------------------------------------------------------------------
1491
1492   /**
1493    * Assert (using {@code junit.framework.Assert}} that all extensions of
1494    * {@code message} are cleared, and that getting the extensions returns their
1495    * default values.
1496    */
1497   public static void assertExtensionsClear(TestAllExtensionsOrBuilder message) {
1498     // hasBlah() should initially be false for all optional fields.
1499     Assert.assertFalse(message.hasExtension(optionalInt32Extension   ));
1500     Assert.assertFalse(message.hasExtension(optionalInt64Extension   ));
1501     Assert.assertFalse(message.hasExtension(optionalUint32Extension  ));
1502     Assert.assertFalse(message.hasExtension(optionalUint64Extension  ));
1503     Assert.assertFalse(message.hasExtension(optionalSint32Extension  ));
1504     Assert.assertFalse(message.hasExtension(optionalSint64Extension  ));
1505     Assert.assertFalse(message.hasExtension(optionalFixed32Extension ));
1506     Assert.assertFalse(message.hasExtension(optionalFixed64Extension ));
1507     Assert.assertFalse(message.hasExtension(optionalSfixed32Extension));
1508     Assert.assertFalse(message.hasExtension(optionalSfixed64Extension));
1509     Assert.assertFalse(message.hasExtension(optionalFloatExtension   ));
1510     Assert.assertFalse(message.hasExtension(optionalDoubleExtension  ));
1511     Assert.assertFalse(message.hasExtension(optionalBoolExtension    ));
1512     Assert.assertFalse(message.hasExtension(optionalStringExtension  ));
1513     Assert.assertFalse(message.hasExtension(optionalBytesExtension   ));
1514
1515     Assert.assertFalse(message.hasExtension(optionalGroupExtension         ));
1516     Assert.assertFalse(message.hasExtension(optionalNestedMessageExtension ));
1517     Assert.assertFalse(message.hasExtension(optionalForeignMessageExtension));
1518     Assert.assertFalse(message.hasExtension(optionalImportMessageExtension ));
1519
1520     Assert.assertFalse(message.hasExtension(optionalNestedEnumExtension ));
1521     Assert.assertFalse(message.hasExtension(optionalForeignEnumExtension));
1522     Assert.assertFalse(message.hasExtension(optionalImportEnumExtension ));
1523
1524     Assert.assertFalse(message.hasExtension(optionalStringPieceExtension));
1525     Assert.assertFalse(message.hasExtension(optionalCordExtension));
1526
1527     // Optional fields without defaults are set to zero or something like it.
1528     assertEqualsExactType(0    , message.getExtension(optionalInt32Extension   ));
1529     assertEqualsExactType(0L   , message.getExtension(optionalInt64Extension   ));
1530     assertEqualsExactType(0    , message.getExtension(optionalUint32Extension  ));
1531     assertEqualsExactType(0L   , message.getExtension(optionalUint64Extension  ));
1532     assertEqualsExactType(0    , message.getExtension(optionalSint32Extension  ));
1533     assertEqualsExactType(0L   , message.getExtension(optionalSint64Extension  ));
1534     assertEqualsExactType(0    , message.getExtension(optionalFixed32Extension ));
1535     assertEqualsExactType(0L   , message.getExtension(optionalFixed64Extension ));
1536     assertEqualsExactType(0    , message.getExtension(optionalSfixed32Extension));
1537     assertEqualsExactType(0L   , message.getExtension(optionalSfixed64Extension));
1538     assertEqualsExactType(0F   , message.getExtension(optionalFloatExtension   ));
1539     assertEqualsExactType(0D   , message.getExtension(optionalDoubleExtension  ));
1540     assertEqualsExactType(false, message.getExtension(optionalBoolExtension    ));
1541     assertEqualsExactType(""   , message.getExtension(optionalStringExtension  ));
1542     assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesExtension));
1543
1544     // Embedded messages should also be clear.
1545     Assert.assertFalse(message.getExtension(optionalGroupExtension         ).hasA());
1546     Assert.assertFalse(message.getExtension(optionalNestedMessageExtension ).hasBb());
1547     Assert.assertFalse(message.getExtension(optionalForeignMessageExtension).hasC());
1548     Assert.assertFalse(message.getExtension(optionalImportMessageExtension ).hasD());
1549
1550     assertEqualsExactType(0, message.getExtension(optionalGroupExtension         ).getA());
1551     assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtension ).getBb());
1552     assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtension).getC());
1553     assertEqualsExactType(0, message.getExtension(optionalImportMessageExtension ).getD());
1554
1555     // Enums without defaults are set to the first value in the enum.
1556     assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
1557       message.getExtension(optionalNestedEnumExtension ));
1558     assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
1559       message.getExtension(optionalForeignEnumExtension));
1560     assertEqualsExactType(ImportEnum.IMPORT_FOO,
1561       message.getExtension(optionalImportEnumExtension));
1562
1563     assertEqualsExactType("", message.getExtension(optionalStringPieceExtension));
1564     assertEqualsExactType("", message.getExtension(optionalCordExtension));
1565
1566     // Repeated fields are empty.
1567     Assert.assertEquals(0, message.getExtensionCount(repeatedInt32Extension   ));
1568     Assert.assertEquals(0, message.getExtensionCount(repeatedInt64Extension   ));
1569     Assert.assertEquals(0, message.getExtensionCount(repeatedUint32Extension  ));
1570     Assert.assertEquals(0, message.getExtensionCount(repeatedUint64Extension  ));
1571     Assert.assertEquals(0, message.getExtensionCount(repeatedSint32Extension  ));
1572     Assert.assertEquals(0, message.getExtensionCount(repeatedSint64Extension  ));
1573     Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32Extension ));
1574     Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64Extension ));
1575     Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32Extension));
1576     Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64Extension));
1577     Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtension   ));
1578     Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtension  ));
1579     Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtension    ));
1580     Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtension  ));
1581     Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtension   ));
1582
1583     Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtension         ));
1584     Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtension ));
1585     Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExtension));
1586     Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtension ));
1587     Assert.assertEquals(0, message.getExtensionCount(repeatedLazyMessageExtension   ));
1588     Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtension    ));
1589     Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtension   ));
1590     Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtension    ));
1591
1592     Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtension));
1593     Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtension));
1594
1595     // Repeated fields are empty via getExtension().size().
1596     Assert.assertEquals(0, message.getExtension(repeatedInt32Extension   ).size());
1597     Assert.assertEquals(0, message.getExtension(repeatedInt64Extension   ).size());
1598     Assert.assertEquals(0, message.getExtension(repeatedUint32Extension  ).size());
1599     Assert.assertEquals(0, message.getExtension(repeatedUint64Extension  ).size());
1600     Assert.assertEquals(0, message.getExtension(repeatedSint32Extension  ).size());
1601     Assert.assertEquals(0, message.getExtension(repeatedSint64Extension  ).size());
1602     Assert.assertEquals(0, message.getExtension(repeatedFixed32Extension ).size());
1603     Assert.assertEquals(0, message.getExtension(repeatedFixed64Extension ).size());
1604     Assert.assertEquals(0, message.getExtension(repeatedSfixed32Extension).size());
1605     Assert.assertEquals(0, message.getExtension(repeatedSfixed64Extension).size());
1606     Assert.assertEquals(0, message.getExtension(repeatedFloatExtension   ).size());
1607     Assert.assertEquals(0, message.getExtension(repeatedDoubleExtension  ).size());
1608     Assert.assertEquals(0, message.getExtension(repeatedBoolExtension    ).size());
1609     Assert.assertEquals(0, message.getExtension(repeatedStringExtension  ).size());
1610     Assert.assertEquals(0, message.getExtension(repeatedBytesExtension   ).size());
1611
1612     Assert.assertEquals(0, message.getExtension(repeatedGroupExtension         ).size());
1613     Assert.assertEquals(0, message.getExtension(repeatedNestedMessageExtension ).size());
1614     Assert.assertEquals(0, message.getExtension(repeatedForeignMessageExtension).size());
1615     Assert.assertEquals(0, message.getExtension(repeatedImportMessageExtension ).size());
1616     Assert.assertEquals(0, message.getExtension(repeatedLazyMessageExtension   ).size());
1617     Assert.assertEquals(0, message.getExtension(repeatedNestedEnumExtension    ).size());
1618     Assert.assertEquals(0, message.getExtension(repeatedForeignEnumExtension   ).size());
1619     Assert.assertEquals(0, message.getExtension(repeatedImportEnumExtension    ).size());
1620
1621     Assert.assertEquals(0, message.getExtension(repeatedStringPieceExtension).size());
1622     Assert.assertEquals(0, message.getExtension(repeatedCordExtension).size());
1623
1624     // hasBlah() should also be false for all default fields.
1625     Assert.assertFalse(message.hasExtension(defaultInt32Extension   ));
1626     Assert.assertFalse(message.hasExtension(defaultInt64Extension   ));
1627     Assert.assertFalse(message.hasExtension(defaultUint32Extension  ));
1628     Assert.assertFalse(message.hasExtension(defaultUint64Extension  ));
1629     Assert.assertFalse(message.hasExtension(defaultSint32Extension  ));
1630     Assert.assertFalse(message.hasExtension(defaultSint64Extension  ));
1631     Assert.assertFalse(message.hasExtension(defaultFixed32Extension ));
1632     Assert.assertFalse(message.hasExtension(defaultFixed64Extension ));
1633     Assert.assertFalse(message.hasExtension(defaultSfixed32Extension));
1634     Assert.assertFalse(message.hasExtension(defaultSfixed64Extension));
1635     Assert.assertFalse(message.hasExtension(defaultFloatExtension   ));
1636     Assert.assertFalse(message.hasExtension(defaultDoubleExtension  ));
1637     Assert.assertFalse(message.hasExtension(defaultBoolExtension    ));
1638     Assert.assertFalse(message.hasExtension(defaultStringExtension  ));
1639     Assert.assertFalse(message.hasExtension(defaultBytesExtension   ));
1640
1641     Assert.assertFalse(message.hasExtension(defaultNestedEnumExtension ));
1642     Assert.assertFalse(message.hasExtension(defaultForeignEnumExtension));
1643     Assert.assertFalse(message.hasExtension(defaultImportEnumExtension ));
1644
1645     Assert.assertFalse(message.hasExtension(defaultStringPieceExtension));
1646     Assert.assertFalse(message.hasExtension(defaultCordExtension));
1647
1648     // Fields with defaults have their default values (duh).
1649     assertEqualsExactType( 41    , message.getExtension(defaultInt32Extension   ));
1650     assertEqualsExactType( 42L   , message.getExtension(defaultInt64Extension   ));
1651     assertEqualsExactType( 43    , message.getExtension(defaultUint32Extension  ));
1652     assertEqualsExactType( 44L   , message.getExtension(defaultUint64Extension  ));
1653     assertEqualsExactType(-45    , message.getExtension(defaultSint32Extension  ));
1654     assertEqualsExactType( 46L   , message.getExtension(defaultSint64Extension  ));
1655     assertEqualsExactType( 47    , message.getExtension(defaultFixed32Extension ));
1656     assertEqualsExactType( 48L   , message.getExtension(defaultFixed64Extension ));
1657     assertEqualsExactType( 49    , message.getExtension(defaultSfixed32Extension));
1658     assertEqualsExactType(-50L   , message.getExtension(defaultSfixed64Extension));
1659     assertEqualsExactType( 51.5F , message.getExtension(defaultFloatExtension   ));
1660     assertEqualsExactType( 52e3D , message.getExtension(defaultDoubleExtension  ));
1661     assertEqualsExactType(true   , message.getExtension(defaultBoolExtension    ));
1662     assertEqualsExactType("hello", message.getExtension(defaultStringExtension  ));
1663     assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExtension));
1664
1665     assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
1666       message.getExtension(defaultNestedEnumExtension ));
1667     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
1668       message.getExtension(defaultForeignEnumExtension));
1669     assertEqualsExactType(ImportEnum.IMPORT_BAR,
1670       message.getExtension(defaultImportEnumExtension));
1671
1672     assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtension));
1673     assertEqualsExactType("123", message.getExtension(defaultCordExtension));
1674   }
1675
1676   // -------------------------------------------------------------------
1677
1678   /**
1679    * Assert (using {@code junit.framework.Assert}} that all extensions of
1680    * {@code message} are set to the values assigned by {@code setAllExtensions}
1681    * followed by {@code modifyRepeatedExtensions}.
1682    */
1683   public static void assertRepeatedExtensionsModified(
1684       TestAllExtensionsOrBuilder message) {
1685     // ModifyRepeatedFields only sets the second repeated element of each
1686     // field.  In addition to verifying this, we also verify that the first
1687     // element and size were *not* modified.
1688     Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension   ));
1689     Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension   ));
1690     Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension  ));
1691     Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension  ));
1692     Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension  ));
1693     Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension  ));
1694     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension ));
1695     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension ));
1696     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension));
1697     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension));
1698     Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension   ));
1699     Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension  ));
1700     Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension    ));
1701     Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension  ));
1702     Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension   ));
1703
1704     Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension         ));
1705     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension ));
1706     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));
1707     Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension ));
1708     Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtension   ));
1709     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension    ));
1710     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension   ));
1711     Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension    ));
1712
1713     Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension));
1714     Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension));
1715
1716     assertEqualsExactType(201  , message.getExtension(repeatedInt32Extension   , 0));
1717     assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension   , 0));
1718     assertEqualsExactType(203  , message.getExtension(repeatedUint32Extension  , 0));
1719     assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension  , 0));
1720     assertEqualsExactType(205  , message.getExtension(repeatedSint32Extension  , 0));
1721     assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension  , 0));
1722     assertEqualsExactType(207  , message.getExtension(repeatedFixed32Extension , 0));
1723     assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension , 0));
1724     assertEqualsExactType(209  , message.getExtension(repeatedSfixed32Extension, 0));
1725     assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension, 0));
1726     assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension   , 0));
1727     assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension  , 0));
1728     assertEqualsExactType(true , message.getExtension(repeatedBoolExtension    , 0));
1729     assertEqualsExactType("215", message.getExtension(repeatedStringExtension  , 0));
1730     assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0));
1731
1732     assertEqualsExactType(217, message.getExtension(repeatedGroupExtension         , 0).getA());
1733     assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb());
1734     assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());
1735     assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD());
1736     assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension   , 0).getBb());
1737
1738     assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
1739       message.getExtension(repeatedNestedEnumExtension, 0));
1740     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
1741       message.getExtension(repeatedForeignEnumExtension, 0));
1742     assertEqualsExactType(ImportEnum.IMPORT_BAR,
1743       message.getExtension(repeatedImportEnumExtension, 0));
1744
1745     assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0));
1746     assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0));
1747
1748     // Actually verify the second (modified) elements now.
1749     assertEqualsExactType(501  , message.getExtension(repeatedInt32Extension   , 1));
1750     assertEqualsExactType(502L , message.getExtension(repeatedInt64Extension   , 1));
1751     assertEqualsExactType(503  , message.getExtension(repeatedUint32Extension  , 1));
1752     assertEqualsExactType(504L , message.getExtension(repeatedUint64Extension  , 1));
1753     assertEqualsExactType(505  , message.getExtension(repeatedSint32Extension  , 1));
1754     assertEqualsExactType(506L , message.getExtension(repeatedSint64Extension  , 1));
1755     assertEqualsExactType(507  , message.getExtension(repeatedFixed32Extension , 1));
1756     assertEqualsExactType(508L , message.getExtension(repeatedFixed64Extension , 1));
1757     assertEqualsExactType(509  , message.getExtension(repeatedSfixed32Extension, 1));
1758     assertEqualsExactType(510L , message.getExtension(repeatedSfixed64Extension, 1));
1759     assertEqualsExactType(511F , message.getExtension(repeatedFloatExtension   , 1));
1760     assertEqualsExactType(512D , message.getExtension(repeatedDoubleExtension  , 1));
1761     assertEqualsExactType(true , message.getExtension(repeatedBoolExtension    , 1));
1762     assertEqualsExactType("515", message.getExtension(repeatedStringExtension  , 1));
1763     assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExtension, 1));
1764
1765     assertEqualsExactType(517, message.getExtension(repeatedGroupExtension         , 1).getA());
1766     assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtension , 1).getBb());
1767     assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtension, 1).getC());
1768     assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtension , 1).getD());
1769     assertEqualsExactType(527, message.getExtension(repeatedLazyMessageExtension   , 1).getBb());
1770
1771     assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
1772       message.getExtension(repeatedNestedEnumExtension, 1));
1773     assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
1774       message.getExtension(repeatedForeignEnumExtension, 1));
1775     assertEqualsExactType(ImportEnum.IMPORT_FOO,
1776       message.getExtension(repeatedImportEnumExtension, 1));
1777
1778     assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtension, 1));
1779     assertEqualsExactType("525", message.getExtension(repeatedCordExtension, 1));
1780   }
1781
1782   public static void setPackedExtensions(TestPackedExtensions.Builder message) {
1783     message.addExtension(packedInt32Extension   , 601);
1784     message.addExtension(packedInt64Extension   , 602L);
1785     message.addExtension(packedUint32Extension  , 603);
1786     message.addExtension(packedUint64Extension  , 604L);
1787     message.addExtension(packedSint32Extension  , 605);
1788     message.addExtension(packedSint64Extension  , 606L);
1789     message.addExtension(packedFixed32Extension , 607);
1790     message.addExtension(packedFixed64Extension , 608L);
1791     message.addExtension(packedSfixed32Extension, 609);
1792     message.addExtension(packedSfixed64Extension, 610L);
1793     message.addExtension(packedFloatExtension   , 611F);
1794     message.addExtension(packedDoubleExtension  , 612D);
1795     message.addExtension(packedBoolExtension    , true);
1796     message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAR);
1797     // Add a second one of each field.
1798     message.addExtension(packedInt32Extension   , 701);
1799     message.addExtension(packedInt64Extension   , 702L);
1800     message.addExtension(packedUint32Extension  , 703);
1801     message.addExtension(packedUint64Extension  , 704L);
1802     message.addExtension(packedSint32Extension  , 705);
1803     message.addExtension(packedSint64Extension  , 706L);
1804     message.addExtension(packedFixed32Extension , 707);
1805     message.addExtension(packedFixed64Extension , 708L);
1806     message.addExtension(packedSfixed32Extension, 709);
1807     message.addExtension(packedSfixed64Extension, 710L);
1808     message.addExtension(packedFloatExtension   , 711F);
1809     message.addExtension(packedDoubleExtension  , 712D);
1810     message.addExtension(packedBoolExtension    , false);
1811     message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAZ);
1812   }
1813
1814   public static void assertPackedExtensionsSet(TestPackedExtensions message) {
1815     Assert.assertEquals(2, message.getExtensionCount(packedInt32Extension   ));
1816     Assert.assertEquals(2, message.getExtensionCount(packedInt64Extension   ));
1817     Assert.assertEquals(2, message.getExtensionCount(packedUint32Extension  ));
1818     Assert.assertEquals(2, message.getExtensionCount(packedUint64Extension  ));
1819     Assert.assertEquals(2, message.getExtensionCount(packedSint32Extension  ));
1820     Assert.assertEquals(2, message.getExtensionCount(packedSint64Extension  ));
1821     Assert.assertEquals(2, message.getExtensionCount(packedFixed32Extension ));
1822     Assert.assertEquals(2, message.getExtensionCount(packedFixed64Extension ));
1823     Assert.assertEquals(2, message.getExtensionCount(packedSfixed32Extension));
1824     Assert.assertEquals(2, message.getExtensionCount(packedSfixed64Extension));
1825     Assert.assertEquals(2, message.getExtensionCount(packedFloatExtension   ));
1826     Assert.assertEquals(2, message.getExtensionCount(packedDoubleExtension  ));
1827     Assert.assertEquals(2, message.getExtensionCount(packedBoolExtension    ));
1828     Assert.assertEquals(2, message.getExtensionCount(packedEnumExtension));
1829     assertEqualsExactType(601  , message.getExtension(packedInt32Extension   , 0));
1830     assertEqualsExactType(602L , message.getExtension(packedInt64Extension   , 0));
1831     assertEqualsExactType(603  , message.getExtension(packedUint32Extension  , 0));
1832     assertEqualsExactType(604L , message.getExtension(packedUint64Extension  , 0));
1833     assertEqualsExactType(605  , message.getExtension(packedSint32Extension  , 0));
1834     assertEqualsExactType(606L , message.getExtension(packedSint64Extension  , 0));
1835     assertEqualsExactType(607  , message.getExtension(packedFixed32Extension , 0));
1836     assertEqualsExactType(608L , message.getExtension(packedFixed64Extension , 0));
1837     assertEqualsExactType(609  , message.getExtension(packedSfixed32Extension, 0));
1838     assertEqualsExactType(610L , message.getExtension(packedSfixed64Extension, 0));
1839     assertEqualsExactType(611F , message.getExtension(packedFloatExtension   , 0));
1840     assertEqualsExactType(612D , message.getExtension(packedDoubleExtension  , 0));
1841     assertEqualsExactType(true , message.getExtension(packedBoolExtension    , 0));
1842     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
1843                           message.getExtension(packedEnumExtension, 0));
1844     assertEqualsExactType(701  , message.getExtension(packedInt32Extension   , 1));
1845     assertEqualsExactType(702L , message.getExtension(packedInt64Extension   , 1));
1846     assertEqualsExactType(703  , message.getExtension(packedUint32Extension  , 1));
1847     assertEqualsExactType(704L , message.getExtension(packedUint64Extension  , 1));
1848     assertEqualsExactType(705  , message.getExtension(packedSint32Extension  , 1));
1849     assertEqualsExactType(706L , message.getExtension(packedSint64Extension  , 1));
1850     assertEqualsExactType(707  , message.getExtension(packedFixed32Extension , 1));
1851     assertEqualsExactType(708L , message.getExtension(packedFixed64Extension , 1));
1852     assertEqualsExactType(709  , message.getExtension(packedSfixed32Extension, 1));
1853     assertEqualsExactType(710L , message.getExtension(packedSfixed64Extension, 1));
1854     assertEqualsExactType(711F , message.getExtension(packedFloatExtension   , 1));
1855     assertEqualsExactType(712D , message.getExtension(packedDoubleExtension  , 1));
1856     assertEqualsExactType(false, message.getExtension(packedBoolExtension    , 1));
1857     assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
1858                           message.getExtension(packedEnumExtension, 1));
1859   }
1860
1861   // =================================================================
1862
1863   /**
1864    * Performs the same things that the methods of {@code TestUtil} do, but
1865    * via the reflection interface.  This is its own class because it needs
1866    * to know what descriptor to use.
1867    */
1868   public static class ReflectionTester {
1869     private final Descriptors.Descriptor baseDescriptor;
1870     private final ExtensionRegistry extensionRegistry;
1871
1872     private final Descriptors.FileDescriptor file;
1873     private final Descriptors.FileDescriptor importFile;
1874     private final Descriptors.FileDescriptor publicImportFile;
1875
1876     private final Descriptors.Descriptor optionalGroup;
1877     private final Descriptors.Descriptor repeatedGroup;
1878     private final Descriptors.Descriptor nestedMessage;
1879     private final Descriptors.Descriptor foreignMessage;
1880     private final Descriptors.Descriptor importMessage;
1881     private final Descriptors.Descriptor publicImportMessage;
1882
1883     private final Descriptors.FieldDescriptor groupA;
1884     private final Descriptors.FieldDescriptor repeatedGroupA;
1885     private final Descriptors.FieldDescriptor nestedB;
1886     private final Descriptors.FieldDescriptor foreignC;
1887     private final Descriptors.FieldDescriptor importD;
1888     private final Descriptors.FieldDescriptor importE;
1889
1890     private final Descriptors.EnumDescriptor nestedEnum;
1891     private final Descriptors.EnumDescriptor foreignEnum;
1892     private final Descriptors.EnumDescriptor importEnum;
1893
1894     private final Descriptors.EnumValueDescriptor nestedFoo;
1895     private final Descriptors.EnumValueDescriptor nestedBar;
1896     private final Descriptors.EnumValueDescriptor nestedBaz;
1897     private final Descriptors.EnumValueDescriptor foreignFoo;
1898     private final Descriptors.EnumValueDescriptor foreignBar;
1899     private final Descriptors.EnumValueDescriptor foreignBaz;
1900     private final Descriptors.EnumValueDescriptor importFoo;
1901     private final Descriptors.EnumValueDescriptor importBar;
1902     private final Descriptors.EnumValueDescriptor importBaz;
1903
1904     /**
1905      * Construct a {@code ReflectionTester} that will expect messages using
1906      * the given descriptor.
1907      *
1908      * Normally {@code baseDescriptor} should be a descriptor for the type
1909      * {@code TestAllTypes}, defined in
1910      * {@code google/protobuf/unittest.proto}.  However, if
1911      * {@code extensionRegistry} is non-null, then {@code baseDescriptor} should
1912      * be for {@code TestAllExtensions} instead, and instead of reading and
1913      * writing normal fields, the tester will read and write extensions.
1914      * All of {@code TestAllExtensions}' extensions must be registered in the
1915      * registry.
1916      */
1917     public ReflectionTester(Descriptors.Descriptor baseDescriptor,
1918                             ExtensionRegistry extensionRegistry) {
1919       this.baseDescriptor = baseDescriptor;
1920       this.extensionRegistry = extensionRegistry;
1921
1922       this.file = baseDescriptor.getFile();
1923       Assert.assertEquals(1, file.getDependencies().size());
1924       this.importFile = file.getDependencies().get(0);
1925       this.publicImportFile = importFile.getDependencies().get(0);
1926
1927       Descriptors.Descriptor testAllTypes;
1928       if (baseDescriptor.getName() == "TestAllTypes") {
1929         testAllTypes = baseDescriptor;
1930       } else {
1931         testAllTypes = file.findMessageTypeByName("TestAllTypes");
1932         Assert.assertNotNull(testAllTypes);
1933       }
1934
1935       if (extensionRegistry == null) {
1936         // Use testAllTypes, rather than baseDescriptor, to allow
1937         // initialization using TestPackedTypes descriptors. These objects
1938         // won't be used by the methods for packed fields.
1939         this.optionalGroup =
1940           testAllTypes.findNestedTypeByName("OptionalGroup");
1941         this.repeatedGroup =
1942           testAllTypes.findNestedTypeByName("RepeatedGroup");
1943       } else {
1944         this.optionalGroup =
1945           file.findMessageTypeByName("OptionalGroup_extension");
1946         this.repeatedGroup =
1947           file.findMessageTypeByName("RepeatedGroup_extension");
1948       }
1949       this.nestedMessage = testAllTypes.findNestedTypeByName("NestedMessage");
1950       this.foreignMessage = file.findMessageTypeByName("ForeignMessage");
1951       this.importMessage = importFile.findMessageTypeByName("ImportMessage");
1952       this.publicImportMessage = publicImportFile.findMessageTypeByName(
1953           "PublicImportMessage");
1954
1955       this.nestedEnum = testAllTypes.findEnumTypeByName("NestedEnum");
1956       this.foreignEnum = file.findEnumTypeByName("ForeignEnum");
1957       this.importEnum = importFile.findEnumTypeByName("ImportEnum");
1958
1959       Assert.assertNotNull(optionalGroup );
1960       Assert.assertNotNull(repeatedGroup );
1961       Assert.assertNotNull(nestedMessage );
1962       Assert.assertNotNull(foreignMessage);
1963       Assert.assertNotNull(importMessage );
1964       Assert.assertNotNull(nestedEnum    );
1965       Assert.assertNotNull(foreignEnum   );
1966       Assert.assertNotNull(importEnum    );
1967
1968       this.nestedB  = nestedMessage .findFieldByName("bb");
1969       this.foreignC = foreignMessage.findFieldByName("c");
1970       this.importD  = importMessage .findFieldByName("d");
1971       this.importE  = publicImportMessage.findFieldByName("e");
1972       this.nestedFoo = nestedEnum.findValueByName("FOO");
1973       this.nestedBar = nestedEnum.findValueByName("BAR");
1974       this.nestedBaz = nestedEnum.findValueByName("BAZ");
1975       this.foreignFoo = foreignEnum.findValueByName("FOREIGN_FOO");
1976       this.foreignBar = foreignEnum.findValueByName("FOREIGN_BAR");
1977       this.foreignBaz = foreignEnum.findValueByName("FOREIGN_BAZ");
1978       this.importFoo = importEnum.findValueByName("IMPORT_FOO");
1979       this.importBar = importEnum.findValueByName("IMPORT_BAR");
1980       this.importBaz = importEnum.findValueByName("IMPORT_BAZ");
1981
1982       this.groupA = optionalGroup.findFieldByName("a");
1983       this.repeatedGroupA = repeatedGroup.findFieldByName("a");
1984
1985       Assert.assertNotNull(groupA        );
1986       Assert.assertNotNull(repeatedGroupA);
1987       Assert.assertNotNull(nestedB       );
1988       Assert.assertNotNull(foreignC      );
1989       Assert.assertNotNull(importD       );
1990       Assert.assertNotNull(importE       );
1991       Assert.assertNotNull(nestedFoo     );
1992       Assert.assertNotNull(nestedBar     );
1993       Assert.assertNotNull(nestedBaz     );
1994       Assert.assertNotNull(foreignFoo    );
1995       Assert.assertNotNull(foreignBar    );
1996       Assert.assertNotNull(foreignBaz    );
1997       Assert.assertNotNull(importFoo     );
1998       Assert.assertNotNull(importBar     );
1999       Assert.assertNotNull(importBaz     );
2000     }
2001
2002     /**
2003      * Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes.
2004      */
2005     private Descriptors.FieldDescriptor f(String name) {
2006       Descriptors.FieldDescriptor result;
2007       if (extensionRegistry == null) {
2008         result = baseDescriptor.findFieldByName(name);
2009       } else {
2010         result = file.findExtensionByName(name + "_extension");
2011       }
2012       Assert.assertNotNull(result);
2013       return result;
2014     }
2015
2016     /**
2017      * Calls {@code parent.newBuilderForField()} or uses the
2018      * {@code ExtensionRegistry} to find an appropriate builder, depending
2019      * on what type is being tested.
2020      */
2021     private Message.Builder newBuilderForField(
2022         Message.Builder parent, Descriptors.FieldDescriptor field) {
2023       if (extensionRegistry == null) {
2024         return parent.newBuilderForField(field);
2025       } else {
2026         ExtensionRegistry.ExtensionInfo extension =
2027           extensionRegistry.findExtensionByNumber(field.getContainingType(),
2028                                                   field.getNumber());
2029         Assert.assertNotNull(extension);
2030         Assert.assertNotNull(extension.defaultInstance);
2031         return extension.defaultInstance.newBuilderForType();
2032       }
2033     }
2034
2035     // -------------------------------------------------------------------
2036
2037     /**
2038      * Set every field of {@code message} to the values expected by
2039      * {@code assertAllFieldsSet()}, using the {@link Message.Builder}
2040      * reflection interface.
2041      */
2042     void setAllFieldsViaReflection(Message.Builder message) {
2043       message.setField(f("optional_int32"   ), 101 );
2044       message.setField(f("optional_int64"   ), 102L);
2045       message.setField(f("optional_uint32"  ), 103 );
2046       message.setField(f("optional_uint64"  ), 104L);
2047       message.setField(f("optional_sint32"  ), 105 );
2048       message.setField(f("optional_sint64"  ), 106L);
2049       message.setField(f("optional_fixed32" ), 107 );
2050       message.setField(f("optional_fixed64" ), 108L);
2051       message.setField(f("optional_sfixed32"), 109 );
2052       message.setField(f("optional_sfixed64"), 110L);
2053       message.setField(f("optional_float"   ), 111F);
2054       message.setField(f("optional_double"  ), 112D);
2055       message.setField(f("optional_bool"    ), true);
2056       message.setField(f("optional_string"  ), "115");
2057       message.setField(f("optional_bytes"   ), toBytes("116"));
2058
2059       message.setField(f("optionalgroup"),
2060         newBuilderForField(message, f("optionalgroup"))
2061                .setField(groupA, 117).build());
2062       message.setField(f("optional_nested_message"),
2063         newBuilderForField(message, f("optional_nested_message"))
2064                .setField(nestedB, 118).build());
2065       message.setField(f("optional_foreign_message"),
2066         newBuilderForField(message, f("optional_foreign_message"))
2067                .setField(foreignC, 119).build());
2068       message.setField(f("optional_import_message"),
2069         newBuilderForField(message, f("optional_import_message"))
2070                .setField(importD, 120).build());
2071       message.setField(f("optional_public_import_message"),
2072         newBuilderForField(message, f("optional_public_import_message"))
2073                .setField(importE, 126).build());
2074       message.setField(f("optional_lazy_message"),
2075         newBuilderForField(message, f("optional_lazy_message"))
2076                .setField(nestedB, 127).build());
2077
2078       message.setField(f("optional_nested_enum" ),  nestedBaz);
2079       message.setField(f("optional_foreign_enum"), foreignBaz);
2080       message.setField(f("optional_import_enum" ),  importBaz);
2081
2082       message.setField(f("optional_string_piece" ), "124");
2083       message.setField(f("optional_cord" ), "125");
2084
2085       // -----------------------------------------------------------------
2086
2087       message.addRepeatedField(f("repeated_int32"   ), 201 );
2088       message.addRepeatedField(f("repeated_int64"   ), 202L);
2089       message.addRepeatedField(f("repeated_uint32"  ), 203 );
2090       message.addRepeatedField(f("repeated_uint64"  ), 204L);
2091       message.addRepeatedField(f("repeated_sint32"  ), 205 );
2092       message.addRepeatedField(f("repeated_sint64"  ), 206L);
2093       message.addRepeatedField(f("repeated_fixed32" ), 207 );
2094       message.addRepeatedField(f("repeated_fixed64" ), 208L);
2095       message.addRepeatedField(f("repeated_sfixed32"), 209 );
2096       message.addRepeatedField(f("repeated_sfixed64"), 210L);
2097       message.addRepeatedField(f("repeated_float"   ), 211F);
2098       message.addRepeatedField(f("repeated_double"  ), 212D);
2099       message.addRepeatedField(f("repeated_bool"    ), true);
2100       message.addRepeatedField(f("repeated_string"  ), "215");
2101       message.addRepeatedField(f("repeated_bytes"   ), toBytes("216"));
2102
2103       message.addRepeatedField(f("repeatedgroup"),
2104         newBuilderForField(message, f("repeatedgroup"))
2105                .setField(repeatedGroupA, 217).build());
2106       message.addRepeatedField(f("repeated_nested_message"),
2107         newBuilderForField(message, f("repeated_nested_message"))
2108                .setField(nestedB, 218).build());
2109       message.addRepeatedField(f("repeated_foreign_message"),
2110         newBuilderForField(message, f("repeated_foreign_message"))
2111                .setField(foreignC, 219).build());
2112       message.addRepeatedField(f("repeated_import_message"),
2113         newBuilderForField(message, f("repeated_import_message"))
2114                .setField(importD, 220).build());
2115       message.addRepeatedField(f("repeated_lazy_message"),
2116         newBuilderForField(message, f("repeated_lazy_message"))
2117                .setField(nestedB, 227).build());
2118
2119       message.addRepeatedField(f("repeated_nested_enum" ),  nestedBar);
2120       message.addRepeatedField(f("repeated_foreign_enum"), foreignBar);
2121       message.addRepeatedField(f("repeated_import_enum" ),  importBar);
2122
2123       message.addRepeatedField(f("repeated_string_piece" ), "224");
2124       message.addRepeatedField(f("repeated_cord" ), "225");
2125
2126       // Add a second one of each field.
2127       message.addRepeatedField(f("repeated_int32"   ), 301 );
2128       message.addRepeatedField(f("repeated_int64"   ), 302L);
2129       message.addRepeatedField(f("repeated_uint32"  ), 303 );
2130       message.addRepeatedField(f("repeated_uint64"  ), 304L);
2131       message.addRepeatedField(f("repeated_sint32"  ), 305 );
2132       message.addRepeatedField(f("repeated_sint64"  ), 306L);
2133       message.addRepeatedField(f("repeated_fixed32" ), 307 );
2134       message.addRepeatedField(f("repeated_fixed64" ), 308L);
2135       message.addRepeatedField(f("repeated_sfixed32"), 309 );
2136       message.addRepeatedField(f("repeated_sfixed64"), 310L);
2137       message.addRepeatedField(f("repeated_float"   ), 311F);
2138       message.addRepeatedField(f("repeated_double"  ), 312D);
2139       message.addRepeatedField(f("repeated_bool"    ), false);
2140       message.addRepeatedField(f("repeated_string"  ), "315");
2141       message.addRepeatedField(f("repeated_bytes"   ), toBytes("316"));
2142
2143       message.addRepeatedField(f("repeatedgroup"),
2144         newBuilderForField(message, f("repeatedgroup"))
2145                .setField(repeatedGroupA, 317).build());
2146       message.addRepeatedField(f("repeated_nested_message"),
2147         newBuilderForField(message, f("repeated_nested_message"))
2148                .setField(nestedB, 318).build());
2149       message.addRepeatedField(f("repeated_foreign_message"),
2150         newBuilderForField(message, f("repeated_foreign_message"))
2151                .setField(foreignC, 319).build());
2152       message.addRepeatedField(f("repeated_import_message"),
2153         newBuilderForField(message, f("repeated_import_message"))
2154                .setField(importD, 320).build());
2155       message.addRepeatedField(f("repeated_lazy_message"),
2156         newBuilderForField(message, f("repeated_lazy_message"))
2157                .setField(nestedB, 327).build());
2158
2159       message.addRepeatedField(f("repeated_nested_enum" ),  nestedBaz);
2160       message.addRepeatedField(f("repeated_foreign_enum"), foreignBaz);
2161       message.addRepeatedField(f("repeated_import_enum" ),  importBaz);
2162
2163       message.addRepeatedField(f("repeated_string_piece" ), "324");
2164       message.addRepeatedField(f("repeated_cord" ), "325");
2165
2166       // -----------------------------------------------------------------
2167
2168       message.setField(f("default_int32"   ), 401 );
2169       message.setField(f("default_int64"   ), 402L);
2170       message.setField(f("default_uint32"  ), 403 );
2171       message.setField(f("default_uint64"  ), 404L);
2172       message.setField(f("default_sint32"  ), 405 );
2173       message.setField(f("default_sint64"  ), 406L);
2174       message.setField(f("default_fixed32" ), 407 );
2175       message.setField(f("default_fixed64" ), 408L);
2176       message.setField(f("default_sfixed32"), 409 );
2177       message.setField(f("default_sfixed64"), 410L);
2178       message.setField(f("default_float"   ), 411F);
2179       message.setField(f("default_double"  ), 412D);
2180       message.setField(f("default_bool"    ), false);
2181       message.setField(f("default_string"  ), "415");
2182       message.setField(f("default_bytes"   ), toBytes("416"));
2183
2184       message.setField(f("default_nested_enum" ),  nestedFoo);
2185       message.setField(f("default_foreign_enum"), foreignFoo);
2186       message.setField(f("default_import_enum" ),  importFoo);
2187
2188       message.setField(f("default_string_piece" ), "424");
2189       message.setField(f("default_cord" ), "425");
2190     }
2191
2192     // -------------------------------------------------------------------
2193
2194     /**
2195      * Modify the repeated fields of {@code message} to contain the values
2196      * expected by {@code assertRepeatedFieldsModified()}, using the
2197      * {@link Message.Builder} reflection interface.
2198      */
2199     void modifyRepeatedFieldsViaReflection(Message.Builder message) {
2200       message.setRepeatedField(f("repeated_int32"   ), 1, 501 );
2201       message.setRepeatedField(f("repeated_int64"   ), 1, 502L);
2202       message.setRepeatedField(f("repeated_uint32"  ), 1, 503 );
2203       message.setRepeatedField(f("repeated_uint64"  ), 1, 504L);
2204       message.setRepeatedField(f("repeated_sint32"  ), 1, 505 );
2205       message.setRepeatedField(f("repeated_sint64"  ), 1, 506L);
2206       message.setRepeatedField(f("repeated_fixed32" ), 1, 507 );
2207       message.setRepeatedField(f("repeated_fixed64" ), 1, 508L);
2208       message.setRepeatedField(f("repeated_sfixed32"), 1, 509 );
2209       message.setRepeatedField(f("repeated_sfixed64"), 1, 510L);
2210       message.setRepeatedField(f("repeated_float"   ), 1, 511F);
2211       message.setRepeatedField(f("repeated_double"  ), 1, 512D);
2212       message.setRepeatedField(f("repeated_bool"    ), 1, true);
2213       message.setRepeatedField(f("repeated_string"  ), 1, "515");
2214       message.setRepeatedField(f("repeated_bytes"   ), 1, toBytes("516"));
2215
2216       message.setRepeatedField(f("repeatedgroup"), 1,
2217         newBuilderForField(message, f("repeatedgroup"))
2218                .setField(repeatedGroupA, 517).build());
2219       message.setRepeatedField(f("repeated_nested_message"), 1,
2220         newBuilderForField(message, f("repeated_nested_message"))
2221                .setField(nestedB, 518).build());
2222       message.setRepeatedField(f("repeated_foreign_message"), 1,
2223         newBuilderForField(message, f("repeated_foreign_message"))
2224                .setField(foreignC, 519).build());
2225       message.setRepeatedField(f("repeated_import_message"), 1,
2226         newBuilderForField(message, f("repeated_import_message"))
2227                .setField(importD, 520).build());
2228       message.setRepeatedField(f("repeated_lazy_message"), 1,
2229         newBuilderForField(message, f("repeated_lazy_message"))
2230                .setField(nestedB, 527).build());
2231
2232       message.setRepeatedField(f("repeated_nested_enum" ), 1,  nestedFoo);
2233       message.setRepeatedField(f("repeated_foreign_enum"), 1, foreignFoo);
2234       message.setRepeatedField(f("repeated_import_enum" ), 1,  importFoo);
2235
2236       message.setRepeatedField(f("repeated_string_piece"), 1, "524");
2237       message.setRepeatedField(f("repeated_cord"), 1, "525");
2238     }
2239
2240     // -------------------------------------------------------------------
2241
2242     /**
2243      * Assert (using {@code junit.framework.Assert}} that all fields of
2244      * {@code message} are set to the values assigned by {@code setAllFields},
2245      * using the {@link Message} reflection interface.
2246      */
2247     public void assertAllFieldsSetViaReflection(MessageOrBuilder message) {
2248       Assert.assertTrue(message.hasField(f("optional_int32"   )));
2249       Assert.assertTrue(message.hasField(f("optional_int64"   )));
2250       Assert.assertTrue(message.hasField(f("optional_uint32"  )));
2251       Assert.assertTrue(message.hasField(f("optional_uint64"  )));
2252       Assert.assertTrue(message.hasField(f("optional_sint32"  )));
2253       Assert.assertTrue(message.hasField(f("optional_sint64"  )));
2254       Assert.assertTrue(message.hasField(f("optional_fixed32" )));
2255       Assert.assertTrue(message.hasField(f("optional_fixed64" )));
2256       Assert.assertTrue(message.hasField(f("optional_sfixed32")));
2257       Assert.assertTrue(message.hasField(f("optional_sfixed64")));
2258       Assert.assertTrue(message.hasField(f("optional_float"   )));
2259       Assert.assertTrue(message.hasField(f("optional_double"  )));
2260       Assert.assertTrue(message.hasField(f("optional_bool"    )));
2261       Assert.assertTrue(message.hasField(f("optional_string"  )));
2262       Assert.assertTrue(message.hasField(f("optional_bytes"   )));
2263
2264       Assert.assertTrue(message.hasField(f("optionalgroup"           )));
2265       Assert.assertTrue(message.hasField(f("optional_nested_message" )));
2266       Assert.assertTrue(message.hasField(f("optional_foreign_message")));
2267       Assert.assertTrue(message.hasField(f("optional_import_message" )));
2268
2269       Assert.assertTrue(
2270         ((Message)message.getField(f("optionalgroup"))).hasField(groupA));
2271       Assert.assertTrue(
2272         ((Message)message.getField(f("optional_nested_message")))
2273                          .hasField(nestedB));
2274       Assert.assertTrue(
2275         ((Message)message.getField(f("optional_foreign_message")))
2276                          .hasField(foreignC));
2277       Assert.assertTrue(
2278         ((Message)message.getField(f("optional_import_message")))
2279                          .hasField(importD));
2280
2281       Assert.assertTrue(message.hasField(f("optional_nested_enum" )));
2282       Assert.assertTrue(message.hasField(f("optional_foreign_enum")));
2283       Assert.assertTrue(message.hasField(f("optional_import_enum" )));
2284
2285       Assert.assertTrue(message.hasField(f("optional_string_piece")));
2286       Assert.assertTrue(message.hasField(f("optional_cord")));
2287
2288       Assert.assertEquals(101  , message.getField(f("optional_int32"   )));
2289       Assert.assertEquals(102L , message.getField(f("optional_int64"   )));
2290       Assert.assertEquals(103  , message.getField(f("optional_uint32"  )));
2291       Assert.assertEquals(104L , message.getField(f("optional_uint64"  )));
2292       Assert.assertEquals(105  , message.getField(f("optional_sint32"  )));
2293       Assert.assertEquals(106L , message.getField(f("optional_sint64"  )));
2294       Assert.assertEquals(107  , message.getField(f("optional_fixed32" )));
2295       Assert.assertEquals(108L , message.getField(f("optional_fixed64" )));
2296       Assert.assertEquals(109  , message.getField(f("optional_sfixed32")));
2297       Assert.assertEquals(110L , message.getField(f("optional_sfixed64")));
2298       Assert.assertEquals(111F , message.getField(f("optional_float"   )));
2299       Assert.assertEquals(112D , message.getField(f("optional_double"  )));
2300       Assert.assertEquals(true , message.getField(f("optional_bool"    )));
2301       Assert.assertEquals("115", message.getField(f("optional_string"  )));
2302       Assert.assertEquals(toBytes("116"), message.getField(f("optional_bytes")));
2303
2304       Assert.assertEquals(117,
2305         ((Message)message.getField(f("optionalgroup"))).getField(groupA));
2306       Assert.assertEquals(118,
2307         ((Message)message.getField(f("optional_nested_message")))
2308                          .getField(nestedB));
2309       Assert.assertEquals(119,
2310         ((Message)message.getField(f("optional_foreign_message")))
2311                          .getField(foreignC));
2312       Assert.assertEquals(120,
2313         ((Message)message.getField(f("optional_import_message")))
2314                          .getField(importD));
2315       Assert.assertEquals(126,
2316         ((Message)message.getField(f("optional_public_import_message")))
2317                          .getField(importE));
2318       Assert.assertEquals(127,
2319         ((Message)message.getField(f("optional_lazy_message")))
2320                          .getField(nestedB));
2321
2322       Assert.assertEquals( nestedBaz, message.getField(f("optional_nested_enum" )));
2323       Assert.assertEquals(foreignBaz, message.getField(f("optional_foreign_enum")));
2324       Assert.assertEquals( importBaz, message.getField(f("optional_import_enum" )));
2325
2326       Assert.assertEquals("124", message.getField(f("optional_string_piece")));
2327       Assert.assertEquals("125", message.getField(f("optional_cord")));
2328
2329       // -----------------------------------------------------------------
2330
2331       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int32"   )));
2332       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int64"   )));
2333       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint32"  )));
2334       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint64"  )));
2335       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint32"  )));
2336       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint64"  )));
2337       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed32" )));
2338       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed64" )));
2339       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed32")));
2340       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed64")));
2341       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_float"   )));
2342       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_double"  )));
2343       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bool"    )));
2344       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string"  )));
2345       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bytes"   )));
2346
2347       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeatedgroup"           )));
2348       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_message" )));
2349       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_message")));
2350       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_message" )));
2351       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_lazy_message" )));
2352       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_enum"    )));
2353       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_enum"   )));
2354       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_enum"    )));
2355
2356       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string_piece")));
2357       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_cord")));
2358
2359       Assert.assertEquals(201  , message.getRepeatedField(f("repeated_int32"   ), 0));
2360       Assert.assertEquals(202L , message.getRepeatedField(f("repeated_int64"   ), 0));
2361       Assert.assertEquals(203  , message.getRepeatedField(f("repeated_uint32"  ), 0));
2362       Assert.assertEquals(204L , message.getRepeatedField(f("repeated_uint64"  ), 0));
2363       Assert.assertEquals(205  , message.getRepeatedField(f("repeated_sint32"  ), 0));
2364       Assert.assertEquals(206L , message.getRepeatedField(f("repeated_sint64"  ), 0));
2365       Assert.assertEquals(207  , message.getRepeatedField(f("repeated_fixed32" ), 0));
2366       Assert.assertEquals(208L , message.getRepeatedField(f("repeated_fixed64" ), 0));
2367       Assert.assertEquals(209  , message.getRepeatedField(f("repeated_sfixed32"), 0));
2368       Assert.assertEquals(210L , message.getRepeatedField(f("repeated_sfixed64"), 0));
2369       Assert.assertEquals(211F , message.getRepeatedField(f("repeated_float"   ), 0));
2370       Assert.assertEquals(212D , message.getRepeatedField(f("repeated_double"  ), 0));
2371       Assert.assertEquals(true , message.getRepeatedField(f("repeated_bool"    ), 0));
2372       Assert.assertEquals("215", message.getRepeatedField(f("repeated_string"  ), 0));
2373       Assert.assertEquals(toBytes("216"), message.getRepeatedField(f("repeated_bytes"), 0));
2374
2375       Assert.assertEquals(217,
2376         ((Message)message.getRepeatedField(f("repeatedgroup"), 0))
2377                          .getField(repeatedGroupA));
2378       Assert.assertEquals(218,
2379         ((Message)message.getRepeatedField(f("repeated_nested_message"), 0))
2380                          .getField(nestedB));
2381       Assert.assertEquals(219,
2382         ((Message)message.getRepeatedField(f("repeated_foreign_message"), 0))
2383                          .getField(foreignC));
2384       Assert.assertEquals(220,
2385         ((Message)message.getRepeatedField(f("repeated_import_message"), 0))
2386                          .getField(importD));
2387       Assert.assertEquals(227,
2388         ((Message)message.getRepeatedField(f("repeated_lazy_message"), 0))
2389                          .getField(nestedB));
2390
2391       Assert.assertEquals( nestedBar, message.getRepeatedField(f("repeated_nested_enum" ),0));
2392       Assert.assertEquals(foreignBar, message.getRepeatedField(f("repeated_foreign_enum"),0));
2393       Assert.assertEquals( importBar, message.getRepeatedField(f("repeated_import_enum" ),0));
2394
2395       Assert.assertEquals("224", message.getRepeatedField(f("repeated_string_piece"), 0));
2396       Assert.assertEquals("225", message.getRepeatedField(f("repeated_cord"), 0));
2397
2398       Assert.assertEquals(301  , message.getRepeatedField(f("repeated_int32"   ), 1));
2399       Assert.assertEquals(302L , message.getRepeatedField(f("repeated_int64"   ), 1));
2400       Assert.assertEquals(303  , message.getRepeatedField(f("repeated_uint32"  ), 1));
2401       Assert.assertEquals(304L , message.getRepeatedField(f("repeated_uint64"  ), 1));
2402       Assert.assertEquals(305  , message.getRepeatedField(f("repeated_sint32"  ), 1));
2403       Assert.assertEquals(306L , message.getRepeatedField(f("repeated_sint64"  ), 1));
2404       Assert.assertEquals(307  , message.getRepeatedField(f("repeated_fixed32" ), 1));
2405       Assert.assertEquals(308L , message.getRepeatedField(f("repeated_fixed64" ), 1));
2406       Assert.assertEquals(309  , message.getRepeatedField(f("repeated_sfixed32"), 1));
2407       Assert.assertEquals(310L , message.getRepeatedField(f("repeated_sfixed64"), 1));
2408       Assert.assertEquals(311F , message.getRepeatedField(f("repeated_float"   ), 1));
2409       Assert.assertEquals(312D , message.getRepeatedField(f("repeated_double"  ), 1));
2410       Assert.assertEquals(false, message.getRepeatedField(f("repeated_bool"    ), 1));
2411       Assert.assertEquals("315", message.getRepeatedField(f("repeated_string"  ), 1));
2412       Assert.assertEquals(toBytes("316"), message.getRepeatedField(f("repeated_bytes"), 1));
2413
2414       Assert.assertEquals(317,
2415         ((Message)message.getRepeatedField(f("repeatedgroup"), 1))
2416                          .getField(repeatedGroupA));
2417       Assert.assertEquals(318,
2418         ((Message)message.getRepeatedField(f("repeated_nested_message"), 1))
2419                          .getField(nestedB));
2420       Assert.assertEquals(319,
2421         ((Message)message.getRepeatedField(f("repeated_foreign_message"), 1))
2422                          .getField(foreignC));
2423       Assert.assertEquals(320,
2424         ((Message)message.getRepeatedField(f("repeated_import_message"), 1))
2425                          .getField(importD));
2426       Assert.assertEquals(327,
2427         ((Message)message.getRepeatedField(f("repeated_lazy_message"), 1))
2428                          .getField(nestedB));
2429
2430       Assert.assertEquals( nestedBaz, message.getRepeatedField(f("repeated_nested_enum" ),1));
2431       Assert.assertEquals(foreignBaz, message.getRepeatedField(f("repeated_foreign_enum"),1));
2432       Assert.assertEquals( importBaz, message.getRepeatedField(f("repeated_import_enum" ),1));
2433
2434       Assert.assertEquals("324", message.getRepeatedField(f("repeated_string_piece"), 1));
2435       Assert.assertEquals("325", message.getRepeatedField(f("repeated_cord"), 1));
2436
2437       // -----------------------------------------------------------------
2438
2439       Assert.assertTrue(message.hasField(f("default_int32"   )));
2440       Assert.assertTrue(message.hasField(f("default_int64"   )));
2441       Assert.assertTrue(message.hasField(f("default_uint32"  )));
2442       Assert.assertTrue(message.hasField(f("default_uint64"  )));
2443       Assert.assertTrue(message.hasField(f("default_sint32"  )));
2444       Assert.assertTrue(message.hasField(f("default_sint64"  )));
2445       Assert.assertTrue(message.hasField(f("default_fixed32" )));
2446       Assert.assertTrue(message.hasField(f("default_fixed64" )));
2447       Assert.assertTrue(message.hasField(f("default_sfixed32")));
2448       Assert.assertTrue(message.hasField(f("default_sfixed64")));
2449       Assert.assertTrue(message.hasField(f("default_float"   )));
2450       Assert.assertTrue(message.hasField(f("default_double"  )));
2451       Assert.assertTrue(message.hasField(f("default_bool"    )));
2452       Assert.assertTrue(message.hasField(f("default_string"  )));
2453       Assert.assertTrue(message.hasField(f("default_bytes"   )));
2454
2455       Assert.assertTrue(message.hasField(f("default_nested_enum" )));
2456       Assert.assertTrue(message.hasField(f("default_foreign_enum")));
2457       Assert.assertTrue(message.hasField(f("default_import_enum" )));
2458
2459       Assert.assertTrue(message.hasField(f("default_string_piece")));
2460       Assert.assertTrue(message.hasField(f("default_cord")));
2461
2462       Assert.assertEquals(401  , message.getField(f("default_int32"   )));
2463       Assert.assertEquals(402L , message.getField(f("default_int64"   )));
2464       Assert.assertEquals(403  , message.getField(f("default_uint32"  )));
2465       Assert.assertEquals(404L , message.getField(f("default_uint64"  )));
2466       Assert.assertEquals(405  , message.getField(f("default_sint32"  )));
2467       Assert.assertEquals(406L , message.getField(f("default_sint64"  )));
2468       Assert.assertEquals(407  , message.getField(f("default_fixed32" )));
2469       Assert.assertEquals(408L , message.getField(f("default_fixed64" )));
2470       Assert.assertEquals(409  , message.getField(f("default_sfixed32")));
2471       Assert.assertEquals(410L , message.getField(f("default_sfixed64")));
2472       Assert.assertEquals(411F , message.getField(f("default_float"   )));
2473       Assert.assertEquals(412D , message.getField(f("default_double"  )));
2474       Assert.assertEquals(false, message.getField(f("default_bool"    )));
2475       Assert.assertEquals("415", message.getField(f("default_string"  )));
2476       Assert.assertEquals(toBytes("416"), message.getField(f("default_bytes")));
2477
2478       Assert.assertEquals( nestedFoo, message.getField(f("default_nested_enum" )));
2479       Assert.assertEquals(foreignFoo, message.getField(f("default_foreign_enum")));
2480       Assert.assertEquals( importFoo, message.getField(f("default_import_enum" )));
2481
2482       Assert.assertEquals("424", message.getField(f("default_string_piece")));
2483       Assert.assertEquals("425", message.getField(f("default_cord")));
2484     }
2485
2486     // -------------------------------------------------------------------
2487
2488     /**
2489      * Assert (using {@code junit.framework.Assert}} that all fields of
2490      * {@code message} are cleared, and that getting the fields returns their
2491      * default values, using the {@link Message} reflection interface.
2492      */
2493     public void assertClearViaReflection(MessageOrBuilder message) {
2494       // has_blah() should initially be false for all optional fields.
2495       Assert.assertFalse(message.hasField(f("optional_int32"   )));
2496       Assert.assertFalse(message.hasField(f("optional_int64"   )));
2497       Assert.assertFalse(message.hasField(f("optional_uint32"  )));
2498       Assert.assertFalse(message.hasField(f("optional_uint64"  )));
2499       Assert.assertFalse(message.hasField(f("optional_sint32"  )));
2500       Assert.assertFalse(message.hasField(f("optional_sint64"  )));
2501       Assert.assertFalse(message.hasField(f("optional_fixed32" )));
2502       Assert.assertFalse(message.hasField(f("optional_fixed64" )));
2503       Assert.assertFalse(message.hasField(f("optional_sfixed32")));
2504       Assert.assertFalse(message.hasField(f("optional_sfixed64")));
2505       Assert.assertFalse(message.hasField(f("optional_float"   )));
2506       Assert.assertFalse(message.hasField(f("optional_double"  )));
2507       Assert.assertFalse(message.hasField(f("optional_bool"    )));
2508       Assert.assertFalse(message.hasField(f("optional_string"  )));
2509       Assert.assertFalse(message.hasField(f("optional_bytes"   )));
2510
2511       Assert.assertFalse(message.hasField(f("optionalgroup"           )));
2512       Assert.assertFalse(message.hasField(f("optional_nested_message" )));
2513       Assert.assertFalse(message.hasField(f("optional_foreign_message")));
2514       Assert.assertFalse(message.hasField(f("optional_import_message" )));
2515
2516       Assert.assertFalse(message.hasField(f("optional_nested_enum" )));
2517       Assert.assertFalse(message.hasField(f("optional_foreign_enum")));
2518       Assert.assertFalse(message.hasField(f("optional_import_enum" )));
2519
2520       Assert.assertFalse(message.hasField(f("optional_string_piece")));
2521       Assert.assertFalse(message.hasField(f("optional_cord")));
2522
2523       // Optional fields without defaults are set to zero or something like it.
2524       Assert.assertEquals(0    , message.getField(f("optional_int32"   )));
2525       Assert.assertEquals(0L   , message.getField(f("optional_int64"   )));
2526       Assert.assertEquals(0    , message.getField(f("optional_uint32"  )));
2527       Assert.assertEquals(0L   , message.getField(f("optional_uint64"  )));
2528       Assert.assertEquals(0    , message.getField(f("optional_sint32"  )));
2529       Assert.assertEquals(0L   , message.getField(f("optional_sint64"  )));
2530       Assert.assertEquals(0    , message.getField(f("optional_fixed32" )));
2531       Assert.assertEquals(0L   , message.getField(f("optional_fixed64" )));
2532       Assert.assertEquals(0    , message.getField(f("optional_sfixed32")));
2533       Assert.assertEquals(0L   , message.getField(f("optional_sfixed64")));
2534       Assert.assertEquals(0F   , message.getField(f("optional_float"   )));
2535       Assert.assertEquals(0D   , message.getField(f("optional_double"  )));
2536       Assert.assertEquals(false, message.getField(f("optional_bool"    )));
2537       Assert.assertEquals(""   , message.getField(f("optional_string"  )));
2538       Assert.assertEquals(ByteString.EMPTY, message.getField(f("optional_bytes")));
2539
2540       // Embedded messages should also be clear.
2541       Assert.assertFalse(
2542         ((Message)message.getField(f("optionalgroup"))).hasField(groupA));
2543       Assert.assertFalse(
2544         ((Message)message.getField(f("optional_nested_message")))
2545                          .hasField(nestedB));
2546       Assert.assertFalse(
2547         ((Message)message.getField(f("optional_foreign_message")))
2548                          .hasField(foreignC));
2549       Assert.assertFalse(
2550         ((Message)message.getField(f("optional_import_message")))
2551                          .hasField(importD));
2552       Assert.assertFalse(
2553         ((Message)message.getField(f("optional_public_import_message")))
2554                          .hasField(importE));
2555       Assert.assertFalse(
2556         ((Message)message.getField(f("optional_lazy_message")))
2557                          .hasField(nestedB));
2558
2559       Assert.assertEquals(0,
2560         ((Message)message.getField(f("optionalgroup"))).getField(groupA));
2561       Assert.assertEquals(0,
2562         ((Message)message.getField(f("optional_nested_message")))
2563                          .getField(nestedB));
2564       Assert.assertEquals(0,
2565         ((Message)message.getField(f("optional_foreign_message")))
2566                          .getField(foreignC));
2567       Assert.assertEquals(0,
2568         ((Message)message.getField(f("optional_import_message")))
2569                          .getField(importD));
2570       Assert.assertEquals(0,
2571         ((Message)message.getField(f("optional_public_import_message")))
2572                          .getField(importE));
2573       Assert.assertEquals(0,
2574         ((Message)message.getField(f("optional_lazy_message")))
2575                          .getField(nestedB));
2576
2577       // Enums without defaults are set to the first value in the enum.
2578       Assert.assertEquals( nestedFoo, message.getField(f("optional_nested_enum" )));
2579       Assert.assertEquals(foreignFoo, message.getField(f("optional_foreign_enum")));
2580       Assert.assertEquals( importFoo, message.getField(f("optional_import_enum" )));
2581
2582       Assert.assertEquals("", message.getField(f("optional_string_piece")));
2583       Assert.assertEquals("", message.getField(f("optional_cord")));
2584
2585       // Repeated fields are empty.
2586       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_int32"   )));
2587       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_int64"   )));
2588       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_uint32"  )));
2589       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_uint64"  )));
2590       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sint32"  )));
2591       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sint64"  )));
2592       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_fixed32" )));
2593       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_fixed64" )));
2594       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sfixed32")));
2595       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sfixed64")));
2596       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_float"   )));
2597       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_double"  )));
2598       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_bool"    )));
2599       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_string"  )));
2600       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_bytes"   )));
2601
2602       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeatedgroup"           )));
2603       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_nested_message" )));
2604       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_foreign_message")));
2605       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_import_message" )));
2606       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_lazy_message"   )));
2607       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_nested_enum"    )));
2608       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_foreign_enum"   )));
2609       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_import_enum"    )));
2610
2611       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_string_piece")));
2612       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_cord")));
2613
2614       // has_blah() should also be false for all default fields.
2615       Assert.assertFalse(message.hasField(f("default_int32"   )));
2616       Assert.assertFalse(message.hasField(f("default_int64"   )));
2617       Assert.assertFalse(message.hasField(f("default_uint32"  )));
2618       Assert.assertFalse(message.hasField(f("default_uint64"  )));
2619       Assert.assertFalse(message.hasField(f("default_sint32"  )));
2620       Assert.assertFalse(message.hasField(f("default_sint64"  )));
2621       Assert.assertFalse(message.hasField(f("default_fixed32" )));
2622       Assert.assertFalse(message.hasField(f("default_fixed64" )));
2623       Assert.assertFalse(message.hasField(f("default_sfixed32")));
2624       Assert.assertFalse(message.hasField(f("default_sfixed64")));
2625       Assert.assertFalse(message.hasField(f("default_float"   )));
2626       Assert.assertFalse(message.hasField(f("default_double"  )));
2627       Assert.assertFalse(message.hasField(f("default_bool"    )));
2628       Assert.assertFalse(message.hasField(f("default_string"  )));
2629       Assert.assertFalse(message.hasField(f("default_bytes"   )));
2630
2631       Assert.assertFalse(message.hasField(f("default_nested_enum" )));
2632       Assert.assertFalse(message.hasField(f("default_foreign_enum")));
2633       Assert.assertFalse(message.hasField(f("default_import_enum" )));
2634
2635       Assert.assertFalse(message.hasField(f("default_string_piece" )));
2636       Assert.assertFalse(message.hasField(f("default_cord" )));
2637
2638       // Fields with defaults have their default values (duh).
2639       Assert.assertEquals( 41    , message.getField(f("default_int32"   )));
2640       Assert.assertEquals( 42L   , message.getField(f("default_int64"   )));
2641       Assert.assertEquals( 43    , message.getField(f("default_uint32"  )));
2642       Assert.assertEquals( 44L   , message.getField(f("default_uint64"  )));
2643       Assert.assertEquals(-45    , message.getField(f("default_sint32"  )));
2644       Assert.assertEquals( 46L   , message.getField(f("default_sint64"  )));
2645       Assert.assertEquals( 47    , message.getField(f("default_fixed32" )));
2646       Assert.assertEquals( 48L   , message.getField(f("default_fixed64" )));
2647       Assert.assertEquals( 49    , message.getField(f("default_sfixed32")));
2648       Assert.assertEquals(-50L   , message.getField(f("default_sfixed64")));
2649       Assert.assertEquals( 51.5F , message.getField(f("default_float"   )));
2650       Assert.assertEquals( 52e3D , message.getField(f("default_double"  )));
2651       Assert.assertEquals(true   , message.getField(f("default_bool"    )));
2652       Assert.assertEquals("hello", message.getField(f("default_string"  )));
2653       Assert.assertEquals(toBytes("world"), message.getField(f("default_bytes")));
2654
2655       Assert.assertEquals( nestedBar, message.getField(f("default_nested_enum" )));
2656       Assert.assertEquals(foreignBar, message.getField(f("default_foreign_enum")));
2657       Assert.assertEquals( importBar, message.getField(f("default_import_enum" )));
2658
2659       Assert.assertEquals("abc", message.getField(f("default_string_piece")));
2660       Assert.assertEquals("123", message.getField(f("default_cord")));
2661     }
2662
2663
2664     // ---------------------------------------------------------------
2665
2666     public void assertRepeatedFieldsModifiedViaReflection(
2667         MessageOrBuilder message) {
2668       // ModifyRepeatedFields only sets the second repeated element of each
2669       // field.  In addition to verifying this, we also verify that the first
2670       // element and size were *not* modified.
2671       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int32"   )));
2672       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int64"   )));
2673       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint32"  )));
2674       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint64"  )));
2675       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint32"  )));
2676       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint64"  )));
2677       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed32" )));
2678       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed64" )));
2679       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed32")));
2680       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed64")));
2681       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_float"   )));
2682       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_double"  )));
2683       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bool"    )));
2684       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string"  )));
2685       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bytes"   )));
2686
2687       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeatedgroup"           )));
2688       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_message" )));
2689       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_message")));
2690       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_message" )));
2691       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_lazy_message"   )));
2692       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_enum"    )));
2693       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_enum"   )));
2694       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_enum"    )));
2695
2696       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string_piece")));
2697       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_cord")));
2698
2699       Assert.assertEquals(201  , message.getRepeatedField(f("repeated_int32"   ), 0));
2700       Assert.assertEquals(202L , message.getRepeatedField(f("repeated_int64"   ), 0));
2701       Assert.assertEquals(203  , message.getRepeatedField(f("repeated_uint32"  ), 0));
2702       Assert.assertEquals(204L , message.getRepeatedField(f("repeated_uint64"  ), 0));
2703       Assert.assertEquals(205  , message.getRepeatedField(f("repeated_sint32"  ), 0));
2704       Assert.assertEquals(206L , message.getRepeatedField(f("repeated_sint64"  ), 0));
2705       Assert.assertEquals(207  , message.getRepeatedField(f("repeated_fixed32" ), 0));
2706       Assert.assertEquals(208L , message.getRepeatedField(f("repeated_fixed64" ), 0));
2707       Assert.assertEquals(209  , message.getRepeatedField(f("repeated_sfixed32"), 0));
2708       Assert.assertEquals(210L , message.getRepeatedField(f("repeated_sfixed64"), 0));
2709       Assert.assertEquals(211F , message.getRepeatedField(f("repeated_float"   ), 0));
2710       Assert.assertEquals(212D , message.getRepeatedField(f("repeated_double"  ), 0));
2711       Assert.assertEquals(true , message.getRepeatedField(f("repeated_bool"    ), 0));
2712       Assert.assertEquals("215", message.getRepeatedField(f("repeated_string"  ), 0));
2713       Assert.assertEquals(toBytes("216"), message.getRepeatedField(f("repeated_bytes"), 0));
2714
2715       Assert.assertEquals(217,
2716         ((Message)message.getRepeatedField(f("repeatedgroup"), 0))
2717                          .getField(repeatedGroupA));
2718       Assert.assertEquals(218,
2719         ((Message)message.getRepeatedField(f("repeated_nested_message"), 0))
2720                          .getField(nestedB));
2721       Assert.assertEquals(219,
2722         ((Message)message.getRepeatedField(f("repeated_foreign_message"), 0))
2723                          .getField(foreignC));
2724       Assert.assertEquals(220,
2725         ((Message)message.getRepeatedField(f("repeated_import_message"), 0))
2726                          .getField(importD));
2727       Assert.assertEquals(227,
2728         ((Message)message.getRepeatedField(f("repeated_lazy_message"), 0))
2729                          .getField(nestedB));
2730
2731       Assert.assertEquals( nestedBar, message.getRepeatedField(f("repeated_nested_enum" ),0));
2732       Assert.assertEquals(foreignBar, message.getRepeatedField(f("repeated_foreign_enum"),0));
2733       Assert.assertEquals( importBar, message.getRepeatedField(f("repeated_import_enum" ),0));
2734
2735       Assert.assertEquals("224", message.getRepeatedField(f("repeated_string_piece"), 0));
2736       Assert.assertEquals("225", message.getRepeatedField(f("repeated_cord"), 0));
2737
2738       Assert.assertEquals(501  , message.getRepeatedField(f("repeated_int32"   ), 1));
2739       Assert.assertEquals(502L , message.getRepeatedField(f("repeated_int64"   ), 1));
2740       Assert.assertEquals(503  , message.getRepeatedField(f("repeated_uint32"  ), 1));
2741       Assert.assertEquals(504L , message.getRepeatedField(f("repeated_uint64"  ), 1));
2742       Assert.assertEquals(505  , message.getRepeatedField(f("repeated_sint32"  ), 1));
2743       Assert.assertEquals(506L , message.getRepeatedField(f("repeated_sint64"  ), 1));
2744       Assert.assertEquals(507  , message.getRepeatedField(f("repeated_fixed32" ), 1));
2745       Assert.assertEquals(508L , message.getRepeatedField(f("repeated_fixed64" ), 1));
2746       Assert.assertEquals(509  , message.getRepeatedField(f("repeated_sfixed32"), 1));
2747       Assert.assertEquals(510L , message.getRepeatedField(f("repeated_sfixed64"), 1));
2748       Assert.assertEquals(511F , message.getRepeatedField(f("repeated_float"   ), 1));
2749       Assert.assertEquals(512D , message.getRepeatedField(f("repeated_double"  ), 1));
2750       Assert.assertEquals(true , message.getRepeatedField(f("repeated_bool"    ), 1));
2751       Assert.assertEquals("515", message.getRepeatedField(f("repeated_string"  ), 1));
2752       Assert.assertEquals(toBytes("516"), message.getRepeatedField(f("repeated_bytes"), 1));
2753
2754       Assert.assertEquals(517,
2755         ((Message)message.getRepeatedField(f("repeatedgroup"), 1))
2756                          .getField(repeatedGroupA));
2757       Assert.assertEquals(518,
2758         ((Message)message.getRepeatedField(f("repeated_nested_message"), 1))
2759                          .getField(nestedB));
2760       Assert.assertEquals(519,
2761         ((Message)message.getRepeatedField(f("repeated_foreign_message"), 1))
2762                          .getField(foreignC));
2763       Assert.assertEquals(520,
2764         ((Message)message.getRepeatedField(f("repeated_import_message"), 1))
2765                          .getField(importD));
2766       Assert.assertEquals(527,
2767         ((Message)message.getRepeatedField(f("repeated_lazy_message"), 1))
2768                          .getField(nestedB));
2769
2770       Assert.assertEquals( nestedFoo, message.getRepeatedField(f("repeated_nested_enum" ),1));
2771       Assert.assertEquals(foreignFoo, message.getRepeatedField(f("repeated_foreign_enum"),1));
2772       Assert.assertEquals( importFoo, message.getRepeatedField(f("repeated_import_enum" ),1));
2773
2774       Assert.assertEquals("524", message.getRepeatedField(f("repeated_string_piece"), 1));
2775       Assert.assertEquals("525", message.getRepeatedField(f("repeated_cord"), 1));
2776     }
2777
2778     public void setPackedFieldsViaReflection(Message.Builder message) {
2779       message.addRepeatedField(f("packed_int32"   ), 601 );
2780       message.addRepeatedField(f("packed_int64"   ), 602L);
2781       message.addRepeatedField(f("packed_uint32"  ), 603 );
2782       message.addRepeatedField(f("packed_uint64"  ), 604L);
2783       message.addRepeatedField(f("packed_sint32"  ), 605 );
2784       message.addRepeatedField(f("packed_sint64"  ), 606L);
2785       message.addRepeatedField(f("packed_fixed32" ), 607 );
2786       message.addRepeatedField(f("packed_fixed64" ), 608L);
2787       message.addRepeatedField(f("packed_sfixed32"), 609 );
2788       message.addRepeatedField(f("packed_sfixed64"), 610L);
2789       message.addRepeatedField(f("packed_float"   ), 611F);
2790       message.addRepeatedField(f("packed_double"  ), 612D);
2791       message.addRepeatedField(f("packed_bool"    ), true);
2792       message.addRepeatedField(f("packed_enum" ),  foreignBar);
2793       // Add a second one of each field.
2794       message.addRepeatedField(f("packed_int32"   ), 701 );
2795       message.addRepeatedField(f("packed_int64"   ), 702L);
2796       message.addRepeatedField(f("packed_uint32"  ), 703 );
2797       message.addRepeatedField(f("packed_uint64"  ), 704L);
2798       message.addRepeatedField(f("packed_sint32"  ), 705 );
2799       message.addRepeatedField(f("packed_sint64"  ), 706L);
2800       message.addRepeatedField(f("packed_fixed32" ), 707 );
2801       message.addRepeatedField(f("packed_fixed64" ), 708L);
2802       message.addRepeatedField(f("packed_sfixed32"), 709 );
2803       message.addRepeatedField(f("packed_sfixed64"), 710L);
2804       message.addRepeatedField(f("packed_float"   ), 711F);
2805       message.addRepeatedField(f("packed_double"  ), 712D);
2806       message.addRepeatedField(f("packed_bool"    ), false);
2807       message.addRepeatedField(f("packed_enum" ),  foreignBaz);
2808     }
2809
2810     public void assertPackedFieldsSetViaReflection(MessageOrBuilder message) {
2811       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int32"   )));
2812       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int64"   )));
2813       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint32"  )));
2814       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint64"  )));
2815       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint32"  )));
2816       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint64"  )));
2817       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed32" )));
2818       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed64" )));
2819       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed32")));
2820       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed64")));
2821       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_float"   )));
2822       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_double"  )));
2823       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_bool"    )));
2824       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_enum"   )));
2825       Assert.assertEquals(601  , message.getRepeatedField(f("packed_int32"   ), 0));
2826       Assert.assertEquals(602L , message.getRepeatedField(f("packed_int64"   ), 0));
2827       Assert.assertEquals(603  , message.getRepeatedField(f("packed_uint32"  ), 0));
2828       Assert.assertEquals(604L , message.getRepeatedField(f("packed_uint64"  ), 0));
2829       Assert.assertEquals(605  , message.getRepeatedField(f("packed_sint32"  ), 0));
2830       Assert.assertEquals(606L , message.getRepeatedField(f("packed_sint64"  ), 0));
2831       Assert.assertEquals(607  , message.getRepeatedField(f("packed_fixed32" ), 0));
2832       Assert.assertEquals(608L , message.getRepeatedField(f("packed_fixed64" ), 0));
2833       Assert.assertEquals(609  , message.getRepeatedField(f("packed_sfixed32"), 0));
2834       Assert.assertEquals(610L , message.getRepeatedField(f("packed_sfixed64"), 0));
2835       Assert.assertEquals(611F , message.getRepeatedField(f("packed_float"   ), 0));
2836       Assert.assertEquals(612D , message.getRepeatedField(f("packed_double"  ), 0));
2837       Assert.assertEquals(true , message.getRepeatedField(f("packed_bool"    ), 0));
2838       Assert.assertEquals(foreignBar, message.getRepeatedField(f("packed_enum" ),0));
2839       Assert.assertEquals(701  , message.getRepeatedField(f("packed_int32"   ), 1));
2840       Assert.assertEquals(702L , message.getRepeatedField(f("packed_int64"   ), 1));
2841       Assert.assertEquals(703  , message.getRepeatedField(f("packed_uint32"  ), 1));
2842       Assert.assertEquals(704L , message.getRepeatedField(f("packed_uint64"  ), 1));
2843       Assert.assertEquals(705  , message.getRepeatedField(f("packed_sint32"  ), 1));
2844       Assert.assertEquals(706L , message.getRepeatedField(f("packed_sint64"  ), 1));
2845       Assert.assertEquals(707  , message.getRepeatedField(f("packed_fixed32" ), 1));
2846       Assert.assertEquals(708L , message.getRepeatedField(f("packed_fixed64" ), 1));
2847       Assert.assertEquals(709  , message.getRepeatedField(f("packed_sfixed32"), 1));
2848       Assert.assertEquals(710L , message.getRepeatedField(f("packed_sfixed64"), 1));
2849       Assert.assertEquals(711F , message.getRepeatedField(f("packed_float"   ), 1));
2850       Assert.assertEquals(712D , message.getRepeatedField(f("packed_double"  ), 1));
2851       Assert.assertEquals(false, message.getRepeatedField(f("packed_bool"    ), 1));
2852       Assert.assertEquals(foreignBaz, message.getRepeatedField(f("packed_enum" ),1));
2853     }
2854
2855     /**
2856      * Verifies that the reflection setters for the given.Builder object throw a
2857      * NullPointerException if they are passed a null value.  Uses Assert to throw an
2858      * appropriate assertion failure, if the condition is not verified.
2859      */
2860     public void assertReflectionSettersRejectNull(Message.Builder builder)
2861         throws Exception {
2862       try {
2863         builder.setField(f("optional_string"), null);
2864         Assert.fail("Exception was not thrown");
2865       } catch (NullPointerException e) {
2866         // We expect this exception.
2867       }
2868       try {
2869         builder.setField(f("optional_bytes"), null);
2870         Assert.fail("Exception was not thrown");
2871       } catch (NullPointerException e) {
2872         // We expect this exception.
2873       }
2874       try {
2875         builder.setField(f("optional_nested_enum"), null);
2876         Assert.fail("Exception was not thrown");
2877       } catch (NullPointerException e) {
2878         // We expect this exception.
2879       }
2880       try {
2881         builder.setField(f("optional_nested_message"),
2882                          (TestAllTypes.NestedMessage) null);
2883         Assert.fail("Exception was not thrown");
2884       } catch (NullPointerException e) {
2885         // We expect this exception.
2886       }
2887       try {
2888         builder.setField(f("optional_nested_message"),
2889                          (TestAllTypes.NestedMessage.Builder) null);
2890         Assert.fail("Exception was not thrown");
2891       } catch (NullPointerException e) {
2892         // We expect this exception.
2893       }
2894
2895       try {
2896         builder.addRepeatedField(f("repeated_string"), null);
2897         Assert.fail("Exception was not thrown");
2898       } catch (NullPointerException e) {
2899         // We expect this exception.
2900       }
2901       try {
2902         builder.addRepeatedField(f("repeated_bytes"), null);
2903         Assert.fail("Exception was not thrown");
2904       } catch (NullPointerException e) {
2905         // We expect this exception.
2906       }
2907       try {
2908         builder.addRepeatedField(f("repeated_nested_enum"), null);
2909         Assert.fail("Exception was not thrown");
2910       } catch (NullPointerException e) {
2911         // We expect this exception.
2912       }
2913       try {
2914         builder.addRepeatedField(f("repeated_nested_message"), null);
2915         Assert.fail("Exception was not thrown");
2916       } catch (NullPointerException e) {
2917         // We expect this exception.
2918       }
2919     }
2920
2921     /**
2922      * Verifies that the reflection repeated setters for the given Builder object throw a
2923      * NullPointerException if they are passed a null value.  Uses Assert to throw an appropriate
2924      * assertion failure, if the condition is not verified.
2925      */
2926     public void assertReflectionRepeatedSettersRejectNull(Message.Builder builder)
2927         throws Exception {
2928       builder.addRepeatedField(f("repeated_string"), "one");
2929       try {
2930         builder.setRepeatedField(f("repeated_string"), 0, null);
2931         Assert.fail("Exception was not thrown");
2932       } catch (NullPointerException e) {
2933         // We expect this exception.
2934       }
2935
2936       builder.addRepeatedField(f("repeated_bytes"), toBytes("one"));
2937       try {
2938         builder.setRepeatedField(f("repeated_bytes"), 0, null);
2939         Assert.fail("Exception was not thrown");
2940       } catch (NullPointerException e) {
2941         // We expect this exception.
2942       }
2943
2944       builder.addRepeatedField(f("repeated_nested_enum"), nestedBaz);
2945       try {
2946         builder.setRepeatedField(f("repeated_nested_enum"), 0, null);
2947         Assert.fail("Exception was not thrown");
2948       } catch (NullPointerException e) {
2949         // We expect this exception.
2950       }
2951
2952       builder.addRepeatedField(
2953           f("repeated_nested_message"),
2954           TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
2955       try {
2956         builder.setRepeatedField(f("repeated_nested_message"), 0, null);
2957         Assert.fail("Exception was not thrown");
2958       } catch (NullPointerException e) {
2959         // We expect this exception.
2960       }
2961     }
2962   }
2963
2964   /**
2965    * @param filePath The path relative to
2966    * {@link #getTestDataDir}.
2967    */
2968   public static String readTextFromFile(String filePath) {
2969     return readBytesFromFile(filePath).toStringUtf8();
2970   }
2971
2972   private static File getTestDataDir() {
2973     // Search each parent directory looking for "src/google/protobuf".
2974     File ancestor = new File(".");
2975     try {
2976       ancestor = ancestor.getCanonicalFile();
2977     } catch (IOException e) {
2978       throw new RuntimeException(
2979         "Couldn't get canonical name of working directory.", e);
2980     }
2981     while (ancestor != null && ancestor.exists()) {
2982       if (new File(ancestor, "src/google/protobuf").exists()) {
2983         return new File(ancestor, "src/google/protobuf/testdata");
2984       }
2985       ancestor = ancestor.getParentFile();
2986     }
2987
2988     throw new RuntimeException(
2989       "Could not find golden files.  This test must be run from within the " +
2990       "protobuf source package so that it can read test data files from the " +
2991       "C++ source tree: " + new File(".").getAbsolutePath());
2992   }
2993
2994   /**
2995    * @param filename The path relative to
2996    * {@link #getTestDataDir}.
2997    */
2998   public static ByteString readBytesFromFile(String filename) {
2999     File fullPath = new File(getTestDataDir(), filename);
3000     try {
3001       RandomAccessFile file = new RandomAccessFile(fullPath, "r");
3002       byte[] content = new byte[(int) file.length()];
3003       file.readFully(content);
3004       return ByteString.copyFrom(content);
3005     } catch (IOException e) {
3006       // Throw a RuntimeException here so that we can call this function from
3007       // static initializers.
3008       throw new IllegalArgumentException(
3009         "Couldn't read file: " + fullPath.getPath(), e);
3010     }
3011   }
3012
3013   /**
3014    * Get the bytes of the "golden message".  This is a serialized TestAllTypes
3015    * with all fields set as they would be by
3016    * {@link #setAllFields(TestAllTypes.Builder)}, but it is loaded from a file
3017    * on disk rather than generated dynamically.  The file is actually generated
3018    * by C++ code, so testing against it verifies compatibility with C++.
3019    */
3020   public static ByteString getGoldenMessage() {
3021     if (goldenMessage == null) {
3022       goldenMessage = readBytesFromFile("golden_message");
3023     }
3024     return goldenMessage;
3025   }
3026   private static ByteString goldenMessage = null;
3027
3028   /**
3029    * Get the bytes of the "golden packed fields message".  This is a serialized
3030    * TestPackedTypes with all fields set as they would be by
3031    * {@link #setPackedFields(TestPackedTypes.Builder)}, but it is loaded from a
3032    * file on disk rather than generated dynamically.  The file is actually
3033    * generated by C++ code, so testing against it verifies compatibility with
3034    * C++.
3035    */
3036   public static ByteString getGoldenPackedFieldsMessage() {
3037     if (goldenPackedFieldsMessage == null) {
3038       goldenPackedFieldsMessage =
3039           readBytesFromFile("golden_packed_fields_message");
3040     }
3041     return goldenPackedFieldsMessage;
3042   }
3043   private static ByteString goldenPackedFieldsMessage = null;
3044
3045   public static abstract class HackMessage extends GeneratedMessage {
3046     public interface MyInterface extends BuilderParent {
3047     }
3048   }
3049   /**
3050    * Mock implementation of {@link GeneratedMessage.BuilderParent} for testing.
3051    *
3052    * @author jonp@google.com (Jon Perlow)
3053    */
3054   public static class MockBuilderParent
3055       implements HackMessage.MyInterface {
3056
3057     private int invalidations;
3058
3059     //@Override (Java 1.6 override semantics, but we must support 1.5)
3060     public void markDirty() {
3061       invalidations++;
3062     }
3063
3064     public int getInvalidationCount() {
3065       return invalidations;
3066     }
3067   }
3068 }