Home | History | Annotate | Download | only in protobuf 
      1 // Protocol Buffers - Google's data interchange format
      2 // Copyright 2008 Google Inc.  All rights reserved.
      3 // https://developers.google.com/protocol-buffers/
      4 //
      5 // Redistribution and use in source and binary forms, with or without
      6 // modification, are permitted provided that the following conditions are
      7 // met:
      8 //
      9 //     * Redistributions of source code must retain the above copyright
     10 // notice, this list of conditions and the following disclaimer.
     11 //     * Redistributions in binary form must reproduce the above
     12 // copyright notice, this list of conditions and the following disclaimer
     13 // in the documentation and/or other materials provided with the
     14 // distribution.
     15 //     * Neither the name of Google Inc. nor the names of its
     16 // contributors may be used to endorse or promote products derived from
     17 // this software without specific prior written permission.
     18 //
     19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30 
     31 package com.google.protobuf;
     32 
     33 import protobuf_unittest.UnittestProto;
     34 import com.google.protobuf.UnittestLite;
     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.oneofUint32Extension;
     60 import static protobuf_unittest.UnittestProto.oneofNestedMessageExtension;
     61 import static protobuf_unittest.UnittestProto.oneofStringExtension;
     62 import static protobuf_unittest.UnittestProto.oneofBytesExtension;
     63 
     64 import static protobuf_unittest.UnittestProto.optionalInt32Extension;
     65 import static protobuf_unittest.UnittestProto.optionalInt64Extension;
     66 import static protobuf_unittest.UnittestProto.optionalUint32Extension;
     67 import static protobuf_unittest.UnittestProto.optionalUint64Extension;
     68 import static protobuf_unittest.UnittestProto.optionalSint32Extension;
     69 import static protobuf_unittest.UnittestProto.optionalSint64Extension;
     70 import static protobuf_unittest.UnittestProto.optionalFixed32Extension;
     71 import static protobuf_unittest.UnittestProto.optionalFixed64Extension;
     72 import static protobuf_unittest.UnittestProto.optionalSfixed32Extension;
     73 import static protobuf_unittest.UnittestProto.optionalSfixed64Extension;
     74 import static protobuf_unittest.UnittestProto.optionalFloatExtension;
     75 import static protobuf_unittest.UnittestProto.optionalDoubleExtension;
     76 import static protobuf_unittest.UnittestProto.optionalBoolExtension;
     77 import static protobuf_unittest.UnittestProto.optionalStringExtension;
     78 import static protobuf_unittest.UnittestProto.optionalBytesExtension;
     79 import static protobuf_unittest.UnittestProto.optionalGroupExtension;
     80 import static protobuf_unittest.UnittestProto.optionalCordExtension;
     81 import static protobuf_unittest.UnittestProto.optionalForeignEnumExtension;
     82 import static protobuf_unittest.UnittestProto.optionalForeignMessageExtension;
     83 import static protobuf_unittest.UnittestProto.optionalImportEnumExtension;
     84 import static protobuf_unittest.UnittestProto.optionalImportMessageExtension;
     85 import static protobuf_unittest.UnittestProto.optionalNestedEnumExtension;
     86 import static protobuf_unittest.UnittestProto.optionalNestedMessageExtension;
     87 import static protobuf_unittest.UnittestProto.optionalPublicImportMessageExtension;
     88 import static protobuf_unittest.UnittestProto.optionalLazyMessageExtension;
     89 import static protobuf_unittest.UnittestProto.optionalStringPieceExtension;
     90 
     91 import static protobuf_unittest.UnittestProto.repeatedInt32Extension;
     92 import static protobuf_unittest.UnittestProto.repeatedInt64Extension;
     93 import static protobuf_unittest.UnittestProto.repeatedUint32Extension;
     94 import static protobuf_unittest.UnittestProto.repeatedUint64Extension;
     95 import static protobuf_unittest.UnittestProto.repeatedSint32Extension;
     96 import static protobuf_unittest.UnittestProto.repeatedSint64Extension;
     97 import static protobuf_unittest.UnittestProto.repeatedFixed32Extension;
     98 import static protobuf_unittest.UnittestProto.repeatedFixed64Extension;
     99 import static protobuf_unittest.UnittestProto.repeatedSfixed32Extension;
    100 import static protobuf_unittest.UnittestProto.repeatedSfixed64Extension;
    101 import static protobuf_unittest.UnittestProto.repeatedFloatExtension;
    102 import static protobuf_unittest.UnittestProto.repeatedDoubleExtension;
    103 import static protobuf_unittest.UnittestProto.repeatedBoolExtension;
    104 import static protobuf_unittest.UnittestProto.repeatedStringExtension;
    105 import static protobuf_unittest.UnittestProto.repeatedBytesExtension;
    106 import static protobuf_unittest.UnittestProto.repeatedGroupExtension;
    107 import static protobuf_unittest.UnittestProto.repeatedNestedMessageExtension;
    108 import static protobuf_unittest.UnittestProto.repeatedForeignMessageExtension;
    109 import static protobuf_unittest.UnittestProto.repeatedImportMessageExtension;
    110 import static protobuf_unittest.UnittestProto.repeatedLazyMessageExtension;
    111 import static protobuf_unittest.UnittestProto.repeatedNestedEnumExtension;
    112 import static protobuf_unittest.UnittestProto.repeatedForeignEnumExtension;
    113 import static protobuf_unittest.UnittestProto.repeatedImportEnumExtension;
    114 import static protobuf_unittest.UnittestProto.repeatedStringPieceExtension;
    115 import static protobuf_unittest.UnittestProto.repeatedCordExtension;
    116 
    117 import static protobuf_unittest.UnittestProto.OptionalGroup_extension;
    118 import static protobuf_unittest.UnittestProto.RepeatedGroup_extension;
    119 
    120 import static protobuf_unittest.UnittestProto.packedInt32Extension;
    121 import static protobuf_unittest.UnittestProto.packedInt64Extension;
    122 import static protobuf_unittest.UnittestProto.packedUint32Extension;
    123 import static protobuf_unittest.UnittestProto.packedUint64Extension;
    124 import static protobuf_unittest.UnittestProto.packedSint32Extension;
    125 import static protobuf_unittest.UnittestProto.packedSint64Extension;
    126 import static protobuf_unittest.UnittestProto.packedFixed32Extension;
    127 import static protobuf_unittest.UnittestProto.packedFixed64Extension;
    128 import static protobuf_unittest.UnittestProto.packedSfixed32Extension;
    129 import static protobuf_unittest.UnittestProto.packedSfixed64Extension;
    130 import static protobuf_unittest.UnittestProto.packedFloatExtension;
    131 import static protobuf_unittest.UnittestProto.packedDoubleExtension;
    132 import static protobuf_unittest.UnittestProto.packedBoolExtension;
    133 import static protobuf_unittest.UnittestProto.packedEnumExtension;
    134 
    135 import static com.google.protobuf.UnittestLite.defaultInt32ExtensionLite;
    136 import static com.google.protobuf.UnittestLite.defaultInt64ExtensionLite;
    137 import static com.google.protobuf.UnittestLite.defaultUint32ExtensionLite;
    138 import static com.google.protobuf.UnittestLite.defaultUint64ExtensionLite;
    139 import static com.google.protobuf.UnittestLite.defaultSint32ExtensionLite;
    140 import static com.google.protobuf.UnittestLite.defaultSint64ExtensionLite;
    141 import static com.google.protobuf.UnittestLite.defaultFixed32ExtensionLite;
    142 import static com.google.protobuf.UnittestLite.defaultFixed64ExtensionLite;
    143 import static com.google.protobuf.UnittestLite.defaultSfixed32ExtensionLite;
    144 import static com.google.protobuf.UnittestLite.defaultSfixed64ExtensionLite;
    145 import static com.google.protobuf.UnittestLite.defaultFloatExtensionLite;
    146 import static com.google.protobuf.UnittestLite.defaultDoubleExtensionLite;
    147 import static com.google.protobuf.UnittestLite.defaultBoolExtensionLite;
    148 import static com.google.protobuf.UnittestLite.defaultStringExtensionLite;
    149 import static com.google.protobuf.UnittestLite.defaultBytesExtensionLite;
    150 import static com.google.protobuf.UnittestLite.defaultNestedEnumExtensionLite;
    151 import static com.google.protobuf.UnittestLite.defaultForeignEnumExtensionLite;
    152 import static com.google.protobuf.UnittestLite.defaultImportEnumExtensionLite;
    153 import static com.google.protobuf.UnittestLite.defaultStringPieceExtensionLite;
    154 import static com.google.protobuf.UnittestLite.defaultCordExtensionLite;
    155 
    156 import static com.google.protobuf.UnittestLite.oneofUint32ExtensionLite;
    157 import static com.google.protobuf.UnittestLite.oneofNestedMessageExtensionLite;
    158 import static com.google.protobuf.UnittestLite.oneofStringExtensionLite;
    159 import static com.google.protobuf.UnittestLite.oneofBytesExtensionLite;
    160 
    161 import static com.google.protobuf.UnittestLite.optionalInt32ExtensionLite;
    162 import static com.google.protobuf.UnittestLite.optionalInt64ExtensionLite;
    163 import static com.google.protobuf.UnittestLite.optionalUint32ExtensionLite;
    164 import static com.google.protobuf.UnittestLite.optionalUint64ExtensionLite;
    165 import static com.google.protobuf.UnittestLite.optionalSint32ExtensionLite;
    166 import static com.google.protobuf.UnittestLite.optionalSint64ExtensionLite;
    167 import static com.google.protobuf.UnittestLite.optionalFixed32ExtensionLite;
    168 import static com.google.protobuf.UnittestLite.optionalFixed64ExtensionLite;
    169 import static com.google.protobuf.UnittestLite.optionalSfixed32ExtensionLite;
    170 import static com.google.protobuf.UnittestLite.optionalSfixed64ExtensionLite;
    171 import static com.google.protobuf.UnittestLite.optionalFloatExtensionLite;
    172 import static com.google.protobuf.UnittestLite.optionalDoubleExtensionLite;
    173 import static com.google.protobuf.UnittestLite.optionalBoolExtensionLite;
    174 import static com.google.protobuf.UnittestLite.optionalStringExtensionLite;
    175 import static com.google.protobuf.UnittestLite.optionalBytesExtensionLite;
    176 import static com.google.protobuf.UnittestLite.optionalGroupExtensionLite;
    177 import static com.google.protobuf.UnittestLite.optionalNestedMessageExtensionLite;
    178 import static com.google.protobuf.UnittestLite.optionalForeignEnumExtensionLite;
    179 import static com.google.protobuf.UnittestLite.optionalForeignMessageExtensionLite;
    180 import static com.google.protobuf.UnittestLite.optionalImportEnumExtensionLite;
    181 import static com.google.protobuf.UnittestLite.optionalImportMessageExtensionLite;
    182 import static com.google.protobuf.UnittestLite.optionalNestedEnumExtensionLite;
    183 import static com.google.protobuf.UnittestLite.optionalPublicImportMessageExtensionLite;
    184 import static com.google.protobuf.UnittestLite.optionalLazyMessageExtensionLite;
    185 import static com.google.protobuf.UnittestLite.optionalStringPieceExtensionLite;
    186 import static com.google.protobuf.UnittestLite.optionalCordExtensionLite;
    187 
    188 import static com.google.protobuf.UnittestLite.repeatedInt32ExtensionLite;
    189 import static com.google.protobuf.UnittestLite.repeatedInt64ExtensionLite;
    190 import static com.google.protobuf.UnittestLite.repeatedUint32ExtensionLite;
    191 import static com.google.protobuf.UnittestLite.repeatedUint64ExtensionLite;
    192 import static com.google.protobuf.UnittestLite.repeatedSint32ExtensionLite;
    193 import static com.google.protobuf.UnittestLite.repeatedSint64ExtensionLite;
    194 import static com.google.protobuf.UnittestLite.repeatedFixed32ExtensionLite;
    195 import static com.google.protobuf.UnittestLite.repeatedFixed64ExtensionLite;
    196 import static com.google.protobuf.UnittestLite.repeatedSfixed32ExtensionLite;
    197 import static com.google.protobuf.UnittestLite.repeatedSfixed64ExtensionLite;
    198 import static com.google.protobuf.UnittestLite.repeatedFloatExtensionLite;
    199 import static com.google.protobuf.UnittestLite.repeatedDoubleExtensionLite;
    200 import static com.google.protobuf.UnittestLite.repeatedBoolExtensionLite;
    201 import static com.google.protobuf.UnittestLite.repeatedStringExtensionLite;
    202 import static com.google.protobuf.UnittestLite.repeatedBytesExtensionLite;
    203 import static com.google.protobuf.UnittestLite.repeatedGroupExtensionLite;
    204 import static com.google.protobuf.UnittestLite.repeatedNestedMessageExtensionLite;
    205 import static com.google.protobuf.UnittestLite.repeatedForeignMessageExtensionLite;
    206 import static com.google.protobuf.UnittestLite.repeatedImportMessageExtensionLite;
    207 import static com.google.protobuf.UnittestLite.repeatedLazyMessageExtensionLite;
    208 import static com.google.protobuf.UnittestLite.repeatedNestedEnumExtensionLite;
    209 import static com.google.protobuf.UnittestLite.repeatedForeignEnumExtensionLite;
    210 import static com.google.protobuf.UnittestLite.repeatedImportEnumExtensionLite;
    211 import static com.google.protobuf.UnittestLite.repeatedStringPieceExtensionLite;
    212 import static com.google.protobuf.UnittestLite.repeatedCordExtensionLite;
    213 
    214 import static com.google.protobuf.UnittestLite.OptionalGroup_extension_lite;
    215 import static com.google.protobuf.UnittestLite.RepeatedGroup_extension_lite;
    216 
    217 import static com.google.protobuf.UnittestLite.packedInt32ExtensionLite;
    218 import static com.google.protobuf.UnittestLite.packedInt64ExtensionLite;
    219 import static com.google.protobuf.UnittestLite.packedUint32ExtensionLite;
    220 import static com.google.protobuf.UnittestLite.packedUint64ExtensionLite;
    221 import static com.google.protobuf.UnittestLite.packedSint32ExtensionLite;
    222 import static com.google.protobuf.UnittestLite.packedSint64ExtensionLite;
    223 import static com.google.protobuf.UnittestLite.packedFixed32ExtensionLite;
    224 import static com.google.protobuf.UnittestLite.packedFixed64ExtensionLite;
    225 import static com.google.protobuf.UnittestLite.packedSfixed32ExtensionLite;
    226 import static com.google.protobuf.UnittestLite.packedSfixed64ExtensionLite;
    227 import static com.google.protobuf.UnittestLite.packedFloatExtensionLite;
    228 import static com.google.protobuf.UnittestLite.packedDoubleExtensionLite;
    229 import static com.google.protobuf.UnittestLite.packedBoolExtensionLite;
    230 import static com.google.protobuf.UnittestLite.packedEnumExtensionLite;
    231 
    232 import protobuf_unittest.UnittestProto.TestAllExtensions;
    233 import protobuf_unittest.UnittestProto.TestAllExtensionsOrBuilder;
    234 import protobuf_unittest.UnittestProto.TestAllTypes;
    235 import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder;
    236 import protobuf_unittest.UnittestProto.TestOneof2;
    237 import protobuf_unittest.UnittestProto.TestPackedExtensions;
    238 import protobuf_unittest.UnittestProto.TestPackedTypes;
    239 import protobuf_unittest.UnittestProto.TestUnpackedTypes;
    240 import protobuf_unittest.UnittestProto.ForeignMessage;
    241 import protobuf_unittest.UnittestProto.ForeignEnum;
    242 import com.google.protobuf.test.UnittestImport.ImportEnum;
    243 import com.google.protobuf.test.UnittestImport.ImportMessage;
    244 import com.google.protobuf.test.UnittestImportPublic.PublicImportMessage;
    245 
    246 import com.google.protobuf.UnittestLite.TestAllTypesLite;
    247 import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
    248 import com.google.protobuf.UnittestLite.TestAllExtensionsLiteOrBuilder;
    249 import com.google.protobuf.UnittestLite.TestPackedExtensionsLite;
    250 import com.google.protobuf.UnittestLite.ForeignMessageLite;
    251 import com.google.protobuf.UnittestLite.ForeignEnumLite;
    252 import com.google.protobuf.UnittestImportLite.ImportEnumLite;
    253 import com.google.protobuf.UnittestImportLite.ImportMessageLite;
    254 import com.google.protobuf.UnittestImportPublicLite.PublicImportMessageLite;
    255 
    256 import junit.framework.Assert;
    257 
    258 import java.io.File;
    259 import java.io.IOException;
    260 import java.io.RandomAccessFile;
    261 
    262 /**
    263  * Contains methods for setting all fields of {@code TestAllTypes} to
    264  * some values as well as checking that all the fields are set to those values.
    265  * These are useful for testing various protocol message features, e.g.
    266  * set all fields of a message, serialize it, parse it, and check that all
    267  * fields are set.
    268  *
    269  * <p>This code is not to be used outside of {@code com.google.protobuf} and
    270  * subpackages.
    271  *
    272  * @author kenton (at) google.com Kenton Varda
    273  */
    274 public final class TestUtil {
    275   private TestUtil() {}
    276 
    277   /** Helper to convert a String to ByteString. */
    278   static ByteString toBytes(String str) {
    279     try {
    280       return ByteString.copyFrom(str.getBytes("UTF-8"));
    281     } catch(java.io.UnsupportedEncodingException e) {
    282       throw new RuntimeException("UTF-8 not supported.", e);
    283     }
    284   }
    285 
    286   /**
    287    * Get a {@code TestAllTypes} with all fields set as they would be by
    288    * {@link #setAllFields(TestAllTypes.Builder)}.
    289    */
    290   public static TestAllTypes getAllSet() {
    291     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
    292     setAllFields(builder);
    293     return builder.build();
    294   }
    295 
    296   /**
    297    * Get a {@code TestAllTypes.Builder} with all fields set as they would be by
    298    * {@link #setAllFields(TestAllTypes.Builder)}.
    299    */
    300   public static TestAllTypes.Builder getAllSetBuilder() {
    301     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
    302     setAllFields(builder);
    303     return builder;
    304   }
    305 
    306   /**
    307    * Get a {@code TestAllExtensions} with all fields set as they would be by
    308    * {@link #setAllExtensions(TestAllExtensions.Builder)}.
    309    */
    310   public static TestAllExtensions getAllExtensionsSet() {
    311     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
    312     setAllExtensions(builder);
    313     return builder.build();
    314   }
    315 
    316   public static TestAllExtensionsLite getAllLiteExtensionsSet() {
    317     TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
    318     setAllExtensions(builder);
    319     return builder.build();
    320   }
    321 
    322   public static TestPackedTypes getPackedSet() {
    323     TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
    324     setPackedFields(builder);
    325     return builder.build();
    326   }
    327 
    328   public static TestUnpackedTypes getUnpackedSet() {
    329     TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder();
    330     setUnpackedFields(builder);
    331     return builder.build();
    332   }
    333 
    334   public static TestPackedExtensions getPackedExtensionsSet() {
    335     TestPackedExtensions.Builder builder = TestPackedExtensions.newBuilder();
    336     setPackedExtensions(builder);
    337     return builder.build();
    338   }
    339 
    340   public static TestPackedExtensionsLite getLitePackedExtensionsSet() {
    341     TestPackedExtensionsLite.Builder builder =
    342         TestPackedExtensionsLite.newBuilder();
    343     setPackedExtensions(builder);
    344     return builder.build();
    345   }
    346 
    347   /**
    348    * Set every field of {@code message} to the values expected by
    349    * {@code assertAllFieldsSet()}.
    350    */
    351   public static void setAllFields(TestAllTypes.Builder message) {
    352     message.setOptionalInt32   (101);
    353     message.setOptionalInt64   (102);
    354     message.setOptionalUint32  (103);
    355     message.setOptionalUint64  (104);
    356     message.setOptionalSint32  (105);
    357     message.setOptionalSint64  (106);
    358     message.setOptionalFixed32 (107);
    359     message.setOptionalFixed64 (108);
    360     message.setOptionalSfixed32(109);
    361     message.setOptionalSfixed64(110);
    362     message.setOptionalFloat   (111);
    363     message.setOptionalDouble  (112);
    364     message.setOptionalBool    (true);
    365     message.setOptionalString  ("115");
    366     message.setOptionalBytes   (toBytes("116"));
    367 
    368     message.setOptionalGroup(
    369       TestAllTypes.OptionalGroup.newBuilder().setA(117).build());
    370     message.setOptionalNestedMessage(
    371       TestAllTypes.NestedMessage.newBuilder().setBb(118).build());
    372     message.setOptionalForeignMessage(
    373       ForeignMessage.newBuilder().setC(119).build());
    374     message.setOptionalImportMessage(
    375       ImportMessage.newBuilder().setD(120).build());
    376     message.setOptionalPublicImportMessage(
    377       PublicImportMessage.newBuilder().setE(126).build());
    378     message.setOptionalLazyMessage(
    379       TestAllTypes.NestedMessage.newBuilder().setBb(127).build());
    380 
    381     message.setOptionalNestedEnum (TestAllTypes.NestedEnum.BAZ);
    382     message.setOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ);
    383     message.setOptionalImportEnum (ImportEnum.IMPORT_BAZ);
    384 
    385     message.setOptionalStringPiece("124");
    386     message.setOptionalCord("125");
    387 
    388     // -----------------------------------------------------------------
    389 
    390     message.addRepeatedInt32   (201);
    391     message.addRepeatedInt64   (202);
    392     message.addRepeatedUint32  (203);
    393     message.addRepeatedUint64  (204);
    394     message.addRepeatedSint32  (205);
    395     message.addRepeatedSint64  (206);
    396     message.addRepeatedFixed32 (207);
    397     message.addRepeatedFixed64 (208);
    398     message.addRepeatedSfixed32(209);
    399     message.addRepeatedSfixed64(210);
    400     message.addRepeatedFloat   (211);
    401     message.addRepeatedDouble  (212);
    402     message.addRepeatedBool    (true);
    403     message.addRepeatedString  ("215");
    404     message.addRepeatedBytes   (toBytes("216"));
    405 
    406     message.addRepeatedGroup(
    407       TestAllTypes.RepeatedGroup.newBuilder().setA(217).build());
    408     message.addRepeatedNestedMessage(
    409       TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
    410     message.addRepeatedForeignMessage(
    411       ForeignMessage.newBuilder().setC(219).build());
    412     message.addRepeatedImportMessage(
    413       ImportMessage.newBuilder().setD(220).build());
    414     message.addRepeatedLazyMessage(
    415       TestAllTypes.NestedMessage.newBuilder().setBb(227).build());
    416 
    417     message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAR);
    418     message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAR);
    419     message.addRepeatedImportEnum (ImportEnum.IMPORT_BAR);
    420 
    421     message.addRepeatedStringPiece("224");
    422     message.addRepeatedCord("225");
    423 
    424     // Add a second one of each field.
    425     message.addRepeatedInt32   (301);
    426     message.addRepeatedInt64   (302);
    427     message.addRepeatedUint32  (303);
    428     message.addRepeatedUint64  (304);
    429     message.addRepeatedSint32  (305);
    430     message.addRepeatedSint64  (306);
    431     message.addRepeatedFixed32 (307);
    432     message.addRepeatedFixed64 (308);
    433     message.addRepeatedSfixed32(309);
    434     message.addRepeatedSfixed64(310);
    435     message.addRepeatedFloat   (311);
    436     message.addRepeatedDouble  (312);
    437     message.addRepeatedBool    (false);
    438     message.addRepeatedString  ("315");
    439     message.addRepeatedBytes   (toBytes("316"));
    440 
    441     message.addRepeatedGroup(
    442       TestAllTypes.RepeatedGroup.newBuilder().setA(317).build());
    443     message.addRepeatedNestedMessage(
    444       TestAllTypes.NestedMessage.newBuilder().setBb(318).build());
    445     message.addRepeatedForeignMessage(
    446       ForeignMessage.newBuilder().setC(319).build());
    447     message.addRepeatedImportMessage(
    448       ImportMessage.newBuilder().setD(320).build());
    449     message.addRepeatedLazyMessage(
    450       TestAllTypes.NestedMessage.newBuilder().setBb(327).build());
    451 
    452     message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAZ);
    453     message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAZ);
    454     message.addRepeatedImportEnum (ImportEnum.IMPORT_BAZ);
    455 
    456     message.addRepeatedStringPiece("324");
    457     message.addRepeatedCord("325");
    458 
    459     // -----------------------------------------------------------------
    460 
    461     message.setDefaultInt32   (401);
    462     message.setDefaultInt64   (402);
    463     message.setDefaultUint32  (403);
    464     message.setDefaultUint64  (404);
    465     message.setDefaultSint32  (405);
    466     message.setDefaultSint64  (406);
    467     message.setDefaultFixed32 (407);
    468     message.setDefaultFixed64 (408);
    469     message.setDefaultSfixed32(409);
    470     message.setDefaultSfixed64(410);
    471     message.setDefaultFloat   (411);
    472     message.setDefaultDouble  (412);
    473     message.setDefaultBool    (false);
    474     message.setDefaultString  ("415");
    475     message.setDefaultBytes   (toBytes("416"));
    476 
    477     message.setDefaultNestedEnum (TestAllTypes.NestedEnum.FOO);
    478     message.setDefaultForeignEnum(ForeignEnum.FOREIGN_FOO);
    479     message.setDefaultImportEnum (ImportEnum.IMPORT_FOO);
    480 
    481     message.setDefaultStringPiece("424");
    482     message.setDefaultCord("425");
    483 
    484     message.setOneofUint32(601);
    485     message.setOneofNestedMessage(
    486       TestAllTypes.NestedMessage.newBuilder().setBb(602).build());
    487     message.setOneofString("603");
    488     message.setOneofBytes(toBytes("604"));
    489   }
    490 
    491   // -------------------------------------------------------------------
    492 
    493   /**
    494    * Modify the repeated fields of {@code message} to contain the values
    495    * expected by {@code assertRepeatedFieldsModified()}.
    496    */
    497   public static void modifyRepeatedFields(TestAllTypes.Builder message) {
    498     message.setRepeatedInt32   (1, 501);
    499     message.setRepeatedInt64   (1, 502);
    500     message.setRepeatedUint32  (1, 503);
    501     message.setRepeatedUint64  (1, 504);
    502     message.setRepeatedSint32  (1, 505);
    503     message.setRepeatedSint64  (1, 506);
    504     message.setRepeatedFixed32 (1, 507);
    505     message.setRepeatedFixed64 (1, 508);
    506     message.setRepeatedSfixed32(1, 509);
    507     message.setRepeatedSfixed64(1, 510);
    508     message.setRepeatedFloat   (1, 511);
    509     message.setRepeatedDouble  (1, 512);
    510     message.setRepeatedBool    (1, true);
    511     message.setRepeatedString  (1, "515");
    512     message.setRepeatedBytes   (1, toBytes("516"));
    513 
    514     message.setRepeatedGroup(1,
    515       TestAllTypes.RepeatedGroup.newBuilder().setA(517).build());
    516     message.setRepeatedNestedMessage(1,
    517       TestAllTypes.NestedMessage.newBuilder().setBb(518).build());
    518     message.setRepeatedForeignMessage(1,
    519       ForeignMessage.newBuilder().setC(519).build());
    520     message.setRepeatedImportMessage(1,
    521       ImportMessage.newBuilder().setD(520).build());
    522     message.setRepeatedLazyMessage(1,
    523       TestAllTypes.NestedMessage.newBuilder().setBb(527).build());
    524 
    525     message.setRepeatedNestedEnum (1, TestAllTypes.NestedEnum.FOO);
    526     message.setRepeatedForeignEnum(1, ForeignEnum.FOREIGN_FOO);
    527     message.setRepeatedImportEnum (1, ImportEnum.IMPORT_FOO);
    528 
    529     message.setRepeatedStringPiece(1, "524");
    530     message.setRepeatedCord(1, "525");
    531   }
    532 
    533   // -------------------------------------------------------------------
    534 
    535   /**
    536    * Assert (using {@code junit.framework.Assert}} that all fields of
    537    * {@code message} are set to the values assigned by {@code setAllFields}.
    538    */
    539   public static void assertAllFieldsSet(TestAllTypesOrBuilder message) {
    540     Assert.assertTrue(message.hasOptionalInt32   ());
    541     Assert.assertTrue(message.hasOptionalInt64   ());
    542     Assert.assertTrue(message.hasOptionalUint32  ());
    543     Assert.assertTrue(message.hasOptionalUint64  ());
    544     Assert.assertTrue(message.hasOptionalSint32  ());
    545     Assert.assertTrue(message.hasOptionalSint64  ());
    546     Assert.assertTrue(message.hasOptionalFixed32 ());
    547     Assert.assertTrue(message.hasOptionalFixed64 ());
    548     Assert.assertTrue(message.hasOptionalSfixed32());
    549     Assert.assertTrue(message.hasOptionalSfixed64());
    550     Assert.assertTrue(message.hasOptionalFloat   ());
    551     Assert.assertTrue(message.hasOptionalDouble  ());
    552     Assert.assertTrue(message.hasOptionalBool    ());
    553     Assert.assertTrue(message.hasOptionalString  ());
    554     Assert.assertTrue(message.hasOptionalBytes   ());
    555 
    556     Assert.assertTrue(message.hasOptionalGroup         ());
    557     Assert.assertTrue(message.hasOptionalNestedMessage ());
    558     Assert.assertTrue(message.hasOptionalForeignMessage());
    559     Assert.assertTrue(message.hasOptionalImportMessage ());
    560 
    561     Assert.assertTrue(message.getOptionalGroup         ().hasA());
    562     Assert.assertTrue(message.getOptionalNestedMessage ().hasBb());
    563     Assert.assertTrue(message.getOptionalForeignMessage().hasC());
    564     Assert.assertTrue(message.getOptionalImportMessage ().hasD());
    565 
    566     Assert.assertTrue(message.hasOptionalNestedEnum ());
    567     Assert.assertTrue(message.hasOptionalForeignEnum());
    568     Assert.assertTrue(message.hasOptionalImportEnum ());
    569 
    570     Assert.assertTrue(message.hasOptionalStringPiece());
    571     Assert.assertTrue(message.hasOptionalCord());
    572 
    573     Assert.assertEquals(101  , message.getOptionalInt32   ());
    574     Assert.assertEquals(102  , message.getOptionalInt64   ());
    575     Assert.assertEquals(103  , message.getOptionalUint32  ());
    576     Assert.assertEquals(104  , message.getOptionalUint64  ());
    577     Assert.assertEquals(105  , message.getOptionalSint32  ());
    578     Assert.assertEquals(106  , message.getOptionalSint64  ());
    579     Assert.assertEquals(107  , message.getOptionalFixed32 ());
    580     Assert.assertEquals(108  , message.getOptionalFixed64 ());
    581     Assert.assertEquals(109  , message.getOptionalSfixed32());
    582     Assert.assertEquals(110  , message.getOptionalSfixed64());
    583     Assert.assertEquals(111  , message.getOptionalFloat   (), 0.0);
    584     Assert.assertEquals(112  , message.getOptionalDouble  (), 0.0);
    585     Assert.assertEquals(true , message.getOptionalBool    ());
    586     Assert.assertEquals("115", message.getOptionalString  ());
    587     Assert.assertEquals(toBytes("116"), message.getOptionalBytes());
    588 
    589     Assert.assertEquals(117, message.getOptionalGroup              ().getA());
    590     Assert.assertEquals(118, message.getOptionalNestedMessage      ().getBb());
    591     Assert.assertEquals(119, message.getOptionalForeignMessage     ().getC());
    592     Assert.assertEquals(120, message.getOptionalImportMessage      ().getD());
    593     Assert.assertEquals(126, message.getOptionalPublicImportMessage().getE());
    594     Assert.assertEquals(127, message.getOptionalLazyMessage        ().getBb());
    595 
    596     Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getOptionalNestedEnum());
    597     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getOptionalForeignEnum());
    598     Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getOptionalImportEnum());
    599 
    600     Assert.assertEquals("124", message.getOptionalStringPiece());
    601     Assert.assertEquals("125", message.getOptionalCord());
    602 
    603     // -----------------------------------------------------------------
    604 
    605     Assert.assertEquals(2, message.getRepeatedInt32Count   ());
    606     Assert.assertEquals(2, message.getRepeatedInt64Count   ());
    607     Assert.assertEquals(2, message.getRepeatedUint32Count  ());
    608     Assert.assertEquals(2, message.getRepeatedUint64Count  ());
    609     Assert.assertEquals(2, message.getRepeatedSint32Count  ());
    610     Assert.assertEquals(2, message.getRepeatedSint64Count  ());
    611     Assert.assertEquals(2, message.getRepeatedFixed32Count ());
    612     Assert.assertEquals(2, message.getRepeatedFixed64Count ());
    613     Assert.assertEquals(2, message.getRepeatedSfixed32Count());
    614     Assert.assertEquals(2, message.getRepeatedSfixed64Count());
    615     Assert.assertEquals(2, message.getRepeatedFloatCount   ());
    616     Assert.assertEquals(2, message.getRepeatedDoubleCount  ());
    617     Assert.assertEquals(2, message.getRepeatedBoolCount    ());
    618     Assert.assertEquals(2, message.getRepeatedStringCount  ());
    619     Assert.assertEquals(2, message.getRepeatedBytesCount   ());
    620 
    621     Assert.assertEquals(2, message.getRepeatedGroupCount         ());
    622     Assert.assertEquals(2, message.getRepeatedNestedMessageCount ());
    623     Assert.assertEquals(2, message.getRepeatedForeignMessageCount());
    624     Assert.assertEquals(2, message.getRepeatedImportMessageCount ());
    625     Assert.assertEquals(2, message.getRepeatedLazyMessageCount   ());
    626     Assert.assertEquals(2, message.getRepeatedNestedEnumCount    ());
    627     Assert.assertEquals(2, message.getRepeatedForeignEnumCount   ());
    628     Assert.assertEquals(2, message.getRepeatedImportEnumCount    ());
    629 
    630     Assert.assertEquals(2, message.getRepeatedStringPieceCount());
    631     Assert.assertEquals(2, message.getRepeatedCordCount());
    632 
    633     Assert.assertEquals(201  , message.getRepeatedInt32   (0));
    634     Assert.assertEquals(202  , message.getRepeatedInt64   (0));
    635     Assert.assertEquals(203  , message.getRepeatedUint32  (0));
    636     Assert.assertEquals(204  , message.getRepeatedUint64  (0));
    637     Assert.assertEquals(205  , message.getRepeatedSint32  (0));
    638     Assert.assertEquals(206  , message.getRepeatedSint64  (0));
    639     Assert.assertEquals(207  , message.getRepeatedFixed32 (0));
    640     Assert.assertEquals(208  , message.getRepeatedFixed64 (0));
    641     Assert.assertEquals(209  , message.getRepeatedSfixed32(0));
    642     Assert.assertEquals(210  , message.getRepeatedSfixed64(0));
    643     Assert.assertEquals(211  , message.getRepeatedFloat   (0), 0.0);
    644     Assert.assertEquals(212  , message.getRepeatedDouble  (0), 0.0);
    645     Assert.assertEquals(true , message.getRepeatedBool    (0));
    646     Assert.assertEquals("215", message.getRepeatedString  (0));
    647     Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0));
    648 
    649     Assert.assertEquals(217, message.getRepeatedGroup         (0).getA());
    650     Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb());
    651     Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC());
    652     Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD());
    653     Assert.assertEquals(227, message.getRepeatedLazyMessage   (0).getBb());
    654 
    655     Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEnum (0));
    656     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(0));
    657     Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0));
    658 
    659     Assert.assertEquals("224", message.getRepeatedStringPiece(0));
    660     Assert.assertEquals("225", message.getRepeatedCord(0));
    661 
    662     Assert.assertEquals(301  , message.getRepeatedInt32   (1));
    663     Assert.assertEquals(302  , message.getRepeatedInt64   (1));
    664     Assert.assertEquals(303  , message.getRepeatedUint32  (1));
    665     Assert.assertEquals(304  , message.getRepeatedUint64  (1));
    666     Assert.assertEquals(305  , message.getRepeatedSint32  (1));
    667     Assert.assertEquals(306  , message.getRepeatedSint64  (1));
    668     Assert.assertEquals(307  , message.getRepeatedFixed32 (1));
    669     Assert.assertEquals(308  , message.getRepeatedFixed64 (1));
    670     Assert.assertEquals(309  , message.getRepeatedSfixed32(1));
    671     Assert.assertEquals(310  , message.getRepeatedSfixed64(1));
    672     Assert.assertEquals(311  , message.getRepeatedFloat   (1), 0.0);
    673     Assert.assertEquals(312  , message.getRepeatedDouble  (1), 0.0);
    674     Assert.assertEquals(false, message.getRepeatedBool    (1));
    675     Assert.assertEquals("315", message.getRepeatedString  (1));
    676     Assert.assertEquals(toBytes("316"), message.getRepeatedBytes(1));
    677 
    678     Assert.assertEquals(317, message.getRepeatedGroup         (1).getA());
    679     Assert.assertEquals(318, message.getRepeatedNestedMessage (1).getBb());
    680     Assert.assertEquals(319, message.getRepeatedForeignMessage(1).getC());
    681     Assert.assertEquals(320, message.getRepeatedImportMessage (1).getD());
    682     Assert.assertEquals(327, message.getRepeatedLazyMessage   (1).getBb());
    683 
    684     Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getRepeatedNestedEnum (1));
    685     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getRepeatedForeignEnum(1));
    686     Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getRepeatedImportEnum(1));
    687 
    688     Assert.assertEquals("324", message.getRepeatedStringPiece(1));
    689     Assert.assertEquals("325", message.getRepeatedCord(1));
    690 
    691     // -----------------------------------------------------------------
    692 
    693     Assert.assertTrue(message.hasDefaultInt32   ());
    694     Assert.assertTrue(message.hasDefaultInt64   ());
    695     Assert.assertTrue(message.hasDefaultUint32  ());
    696     Assert.assertTrue(message.hasDefaultUint64  ());
    697     Assert.assertTrue(message.hasDefaultSint32  ());
    698     Assert.assertTrue(message.hasDefaultSint64  ());
    699     Assert.assertTrue(message.hasDefaultFixed32 ());
    700     Assert.assertTrue(message.hasDefaultFixed64 ());
    701     Assert.assertTrue(message.hasDefaultSfixed32());
    702     Assert.assertTrue(message.hasDefaultSfixed64());
    703     Assert.assertTrue(message.hasDefaultFloat   ());
    704     Assert.assertTrue(message.hasDefaultDouble  ());
    705     Assert.assertTrue(message.hasDefaultBool    ());
    706     Assert.assertTrue(message.hasDefaultString  ());
    707     Assert.assertTrue(message.hasDefaultBytes   ());
    708 
    709     Assert.assertTrue(message.hasDefaultNestedEnum ());
    710     Assert.assertTrue(message.hasDefaultForeignEnum());
    711     Assert.assertTrue(message.hasDefaultImportEnum ());
    712 
    713     Assert.assertTrue(message.hasDefaultStringPiece());
    714     Assert.assertTrue(message.hasDefaultCord());
    715 
    716     Assert.assertEquals(401  , message.getDefaultInt32   ());
    717     Assert.assertEquals(402  , message.getDefaultInt64   ());
    718     Assert.assertEquals(403  , message.getDefaultUint32  ());
    719     Assert.assertEquals(404  , message.getDefaultUint64  ());
    720     Assert.assertEquals(405  , message.getDefaultSint32  ());
    721     Assert.assertEquals(406  , message.getDefaultSint64  ());
    722     Assert.assertEquals(407  , message.getDefaultFixed32 ());
    723     Assert.assertEquals(408  , message.getDefaultFixed64 ());
    724     Assert.assertEquals(409  , message.getDefaultSfixed32());
    725     Assert.assertEquals(410  , message.getDefaultSfixed64());
    726     Assert.assertEquals(411  , message.getDefaultFloat   (), 0.0);
    727     Assert.assertEquals(412  , message.getDefaultDouble  (), 0.0);
    728     Assert.assertEquals(false, message.getDefaultBool    ());
    729     Assert.assertEquals("415", message.getDefaultString  ());
    730     Assert.assertEquals(toBytes("416"), message.getDefaultBytes());
    731 
    732     Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getDefaultNestedEnum ());
    733     Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getDefaultForeignEnum());
    734     Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getDefaultImportEnum());
    735 
    736     Assert.assertEquals("424", message.getDefaultStringPiece());
    737     Assert.assertEquals("425", message.getDefaultCord());
    738 
    739     Assert.assertFalse(message.hasOneofUint32());
    740     Assert.assertFalse(message.hasOneofNestedMessage());
    741     Assert.assertFalse(message.hasOneofString());
    742     Assert.assertTrue(message.hasOneofBytes());
    743 
    744     Assert.assertEquals(toBytes("604"), message.getOneofBytes());
    745   }
    746 
    747   // -------------------------------------------------------------------
    748   /**
    749    * Assert (using {@code junit.framework.Assert}} that all fields of
    750    * {@code message} are cleared, and that getting the fields returns their
    751    * default values.
    752    */
    753   public static void assertClear(TestAllTypesOrBuilder message) {
    754     // hasBlah() should initially be false for all optional fields.
    755     Assert.assertFalse(message.hasOptionalInt32   ());
    756     Assert.assertFalse(message.hasOptionalInt64   ());
    757     Assert.assertFalse(message.hasOptionalUint32  ());
    758     Assert.assertFalse(message.hasOptionalUint64  ());
    759     Assert.assertFalse(message.hasOptionalSint32  ());
    760     Assert.assertFalse(message.hasOptionalSint64  ());
    761     Assert.assertFalse(message.hasOptionalFixed32 ());
    762     Assert.assertFalse(message.hasOptionalFixed64 ());
    763     Assert.assertFalse(message.hasOptionalSfixed32());
    764     Assert.assertFalse(message.hasOptionalSfixed64());
    765     Assert.assertFalse(message.hasOptionalFloat   ());
    766     Assert.assertFalse(message.hasOptionalDouble  ());
    767     Assert.assertFalse(message.hasOptionalBool    ());
    768     Assert.assertFalse(message.hasOptionalString  ());
    769     Assert.assertFalse(message.hasOptionalBytes   ());
    770 
    771     Assert.assertFalse(message.hasOptionalGroup         ());
    772     Assert.assertFalse(message.hasOptionalNestedMessage ());
    773     Assert.assertFalse(message.hasOptionalForeignMessage());
    774     Assert.assertFalse(message.hasOptionalImportMessage ());
    775 
    776     Assert.assertFalse(message.hasOptionalNestedEnum ());
    777     Assert.assertFalse(message.hasOptionalForeignEnum());
    778     Assert.assertFalse(message.hasOptionalImportEnum ());
    779 
    780     Assert.assertFalse(message.hasOptionalStringPiece());
    781     Assert.assertFalse(message.hasOptionalCord());
    782 
    783     // Optional fields without defaults are set to zero or something like it.
    784     Assert.assertEquals(0    , message.getOptionalInt32   ());
    785     Assert.assertEquals(0    , message.getOptionalInt64   ());
    786     Assert.assertEquals(0    , message.getOptionalUint32  ());
    787     Assert.assertEquals(0    , message.getOptionalUint64  ());
    788     Assert.assertEquals(0    , message.getOptionalSint32  ());
    789     Assert.assertEquals(0    , message.getOptionalSint64  ());
    790     Assert.assertEquals(0    , message.getOptionalFixed32 ());
    791     Assert.assertEquals(0    , message.getOptionalFixed64 ());
    792     Assert.assertEquals(0    , message.getOptionalSfixed32());
    793     Assert.assertEquals(0    , message.getOptionalSfixed64());
    794     Assert.assertEquals(0    , message.getOptionalFloat   (), 0.0);
    795     Assert.assertEquals(0    , message.getOptionalDouble  (), 0.0);
    796     Assert.assertEquals(false, message.getOptionalBool    ());
    797     Assert.assertEquals(""   , message.getOptionalString  ());
    798     Assert.assertEquals(ByteString.EMPTY, message.getOptionalBytes());
    799 
    800     // Embedded messages should also be clear.
    801     Assert.assertFalse(message.getOptionalGroup              ().hasA());
    802     Assert.assertFalse(message.getOptionalNestedMessage      ().hasBb());
    803     Assert.assertFalse(message.getOptionalForeignMessage     ().hasC());
    804     Assert.assertFalse(message.getOptionalImportMessage      ().hasD());
    805     Assert.assertFalse(message.getOptionalPublicImportMessage().hasE());
    806     Assert.assertFalse(message.getOptionalLazyMessage        ().hasBb());
    807 
    808     Assert.assertEquals(0, message.getOptionalGroup              ().getA());
    809     Assert.assertEquals(0, message.getOptionalNestedMessage      ().getBb());
    810     Assert.assertEquals(0, message.getOptionalForeignMessage     ().getC());
    811     Assert.assertEquals(0, message.getOptionalImportMessage      ().getD());
    812     Assert.assertEquals(0, message.getOptionalPublicImportMessage().getE());
    813     Assert.assertEquals(0, message.getOptionalLazyMessage        ().getBb());
    814 
    815     // Enums without defaults are set to the first value in the enum.
    816     Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getOptionalNestedEnum ());
    817     Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getOptionalForeignEnum());
    818     Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getOptionalImportEnum());
    819 
    820     Assert.assertEquals("", message.getOptionalStringPiece());
    821     Assert.assertEquals("", message.getOptionalCord());
    822 
    823     // Repeated fields are empty.
    824     Assert.assertEquals(0, message.getRepeatedInt32Count   ());
    825     Assert.assertEquals(0, message.getRepeatedInt64Count   ());
    826     Assert.assertEquals(0, message.getRepeatedUint32Count  ());
    827     Assert.assertEquals(0, message.getRepeatedUint64Count  ());
    828     Assert.assertEquals(0, message.getRepeatedSint32Count  ());
    829     Assert.assertEquals(0, message.getRepeatedSint64Count  ());
    830     Assert.assertEquals(0, message.getRepeatedFixed32Count ());
    831     Assert.assertEquals(0, message.getRepeatedFixed64Count ());
    832     Assert.assertEquals(0, message.getRepeatedSfixed32Count());
    833     Assert.assertEquals(0, message.getRepeatedSfixed64Count());
    834     Assert.assertEquals(0, message.getRepeatedFloatCount   ());
    835     Assert.assertEquals(0, message.getRepeatedDoubleCount  ());
    836     Assert.assertEquals(0, message.getRepeatedBoolCount    ());
    837     Assert.assertEquals(0, message.getRepeatedStringCount  ());
    838     Assert.assertEquals(0, message.getRepeatedBytesCount   ());
    839 
    840     Assert.assertEquals(0, message.getRepeatedGroupCount         ());
    841     Assert.assertEquals(0, message.getRepeatedNestedMessageCount ());
    842     Assert.assertEquals(0, message.getRepeatedForeignMessageCount());
    843     Assert.assertEquals(0, message.getRepeatedImportMessageCount ());
    844     Assert.assertEquals(0, message.getRepeatedLazyMessageCount   ());
    845     Assert.assertEquals(0, message.getRepeatedNestedEnumCount    ());
    846     Assert.assertEquals(0, message.getRepeatedForeignEnumCount   ());
    847     Assert.assertEquals(0, message.getRepeatedImportEnumCount    ());
    848 
    849     Assert.assertEquals(0, message.getRepeatedStringPieceCount());
    850     Assert.assertEquals(0, message.getRepeatedCordCount());
    851 
    852     // hasBlah() should also be false for all default fields.
    853     Assert.assertFalse(message.hasDefaultInt32   ());
    854     Assert.assertFalse(message.hasDefaultInt64   ());
    855     Assert.assertFalse(message.hasDefaultUint32  ());
    856     Assert.assertFalse(message.hasDefaultUint64  ());
    857     Assert.assertFalse(message.hasDefaultSint32  ());
    858     Assert.assertFalse(message.hasDefaultSint64  ());
    859     Assert.assertFalse(message.hasDefaultFixed32 ());
    860     Assert.assertFalse(message.hasDefaultFixed64 ());
    861     Assert.assertFalse(message.hasDefaultSfixed32());
    862     Assert.assertFalse(message.hasDefaultSfixed64());
    863     Assert.assertFalse(message.hasDefaultFloat   ());
    864     Assert.assertFalse(message.hasDefaultDouble  ());
    865     Assert.assertFalse(message.hasDefaultBool    ());
    866     Assert.assertFalse(message.hasDefaultString  ());
    867     Assert.assertFalse(message.hasDefaultBytes   ());
    868 
    869     Assert.assertFalse(message.hasDefaultNestedEnum ());
    870     Assert.assertFalse(message.hasDefaultForeignEnum());
    871     Assert.assertFalse(message.hasDefaultImportEnum ());
    872 
    873     Assert.assertFalse(message.hasDefaultStringPiece());
    874     Assert.assertFalse(message.hasDefaultCord());
    875 
    876     // Fields with defaults have their default values (duh).
    877     Assert.assertEquals( 41    , message.getDefaultInt32   ());
    878     Assert.assertEquals( 42    , message.getDefaultInt64   ());
    879     Assert.assertEquals( 43    , message.getDefaultUint32  ());
    880     Assert.assertEquals( 44    , message.getDefaultUint64  ());
    881     Assert.assertEquals(-45    , message.getDefaultSint32  ());
    882     Assert.assertEquals( 46    , message.getDefaultSint64  ());
    883     Assert.assertEquals( 47    , message.getDefaultFixed32 ());
    884     Assert.assertEquals( 48    , message.getDefaultFixed64 ());
    885     Assert.assertEquals( 49    , message.getDefaultSfixed32());
    886     Assert.assertEquals(-50    , message.getDefaultSfixed64());
    887     Assert.assertEquals( 51.5  , message.getDefaultFloat   (), 0.0);
    888     Assert.assertEquals( 52e3  , message.getDefaultDouble  (), 0.0);
    889     Assert.assertEquals(true   , message.getDefaultBool    ());
    890     Assert.assertEquals("hello", message.getDefaultString  ());
    891     Assert.assertEquals(toBytes("world"), message.getDefaultBytes());
    892 
    893     Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getDefaultNestedEnum ());
    894     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getDefaultForeignEnum());
    895     Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getDefaultImportEnum());
    896 
    897     Assert.assertEquals("abc", message.getDefaultStringPiece());
    898     Assert.assertEquals("123", message.getDefaultCord());
    899 
    900     Assert.assertFalse(message.hasOneofUint32());
    901     Assert.assertFalse(message.hasOneofNestedMessage());
    902     Assert.assertFalse(message.hasOneofString());
    903     Assert.assertFalse(message.hasOneofBytes());
    904   }
    905 
    906   // -------------------------------------------------------------------
    907 
    908   /**
    909    * Assert (using {@code junit.framework.Assert}} that all fields of
    910    * {@code message} are set to the values assigned by {@code setAllFields}
    911    * followed by {@code modifyRepeatedFields}.
    912    */
    913   public static void assertRepeatedFieldsModified(
    914       TestAllTypesOrBuilder message) {
    915     // ModifyRepeatedFields only sets the second repeated element of each
    916     // field.  In addition to verifying this, we also verify that the first
    917     // element and size were *not* modified.
    918     Assert.assertEquals(2, message.getRepeatedInt32Count   ());
    919     Assert.assertEquals(2, message.getRepeatedInt64Count   ());
    920     Assert.assertEquals(2, message.getRepeatedUint32Count  ());
    921     Assert.assertEquals(2, message.getRepeatedUint64Count  ());
    922     Assert.assertEquals(2, message.getRepeatedSint32Count  ());
    923     Assert.assertEquals(2, message.getRepeatedSint64Count  ());
    924     Assert.assertEquals(2, message.getRepeatedFixed32Count ());
    925     Assert.assertEquals(2, message.getRepeatedFixed64Count ());
    926     Assert.assertEquals(2, message.getRepeatedSfixed32Count());
    927     Assert.assertEquals(2, message.getRepeatedSfixed64Count());
    928     Assert.assertEquals(2, message.getRepeatedFloatCount   ());
    929     Assert.assertEquals(2, message.getRepeatedDoubleCount  ());
    930     Assert.assertEquals(2, message.getRepeatedBoolCount    ());
    931     Assert.assertEquals(2, message.getRepeatedStringCount  ());
    932     Assert.assertEquals(2, message.getRepeatedBytesCount   ());
    933 
    934     Assert.assertEquals(2, message.getRepeatedGroupCount         ());
    935     Assert.assertEquals(2, message.getRepeatedNestedMessageCount ());
    936     Assert.assertEquals(2, message.getRepeatedForeignMessageCount());
    937     Assert.assertEquals(2, message.getRepeatedImportMessageCount ());
    938     Assert.assertEquals(2, message.getRepeatedLazyMessageCount   ());
    939     Assert.assertEquals(2, message.getRepeatedNestedEnumCount    ());
    940     Assert.assertEquals(2, message.getRepeatedForeignEnumCount   ());
    941     Assert.assertEquals(2, message.getRepeatedImportEnumCount    ());
    942 
    943     Assert.assertEquals(2, message.getRepeatedStringPieceCount());
    944     Assert.assertEquals(2, message.getRepeatedCordCount());
    945 
    946     Assert.assertEquals(201  , message.getRepeatedInt32   (0));
    947     Assert.assertEquals(202L , message.getRepeatedInt64   (0));
    948     Assert.assertEquals(203  , message.getRepeatedUint32  (0));
    949     Assert.assertEquals(204L , message.getRepeatedUint64  (0));
    950     Assert.assertEquals(205  , message.getRepeatedSint32  (0));
    951     Assert.assertEquals(206L , message.getRepeatedSint64  (0));
    952     Assert.assertEquals(207  , message.getRepeatedFixed32 (0));
    953     Assert.assertEquals(208L , message.getRepeatedFixed64 (0));
    954     Assert.assertEquals(209  , message.getRepeatedSfixed32(0));
    955     Assert.assertEquals(210L , message.getRepeatedSfixed64(0));
    956     Assert.assertEquals(211F , message.getRepeatedFloat   (0));
    957     Assert.assertEquals(212D , message.getRepeatedDouble  (0));
    958     Assert.assertEquals(true , message.getRepeatedBool    (0));
    959     Assert.assertEquals("215", message.getRepeatedString  (0));
    960     Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0));
    961 
    962     Assert.assertEquals(217, message.getRepeatedGroup         (0).getA());
    963     Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb());
    964     Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC());
    965     Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD());
    966     Assert.assertEquals(227, message.getRepeatedLazyMessage   (0).getBb());
    967 
    968     Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEnum (0));
    969     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(0));
    970     Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0));
    971 
    972     Assert.assertEquals("224", message.getRepeatedStringPiece(0));
    973     Assert.assertEquals("225", message.getRepeatedCord(0));
    974 
    975     // Actually verify the second (modified) elements now.
    976     Assert.assertEquals(501  , message.getRepeatedInt32   (1));
    977     Assert.assertEquals(502L , message.getRepeatedInt64   (1));
    978     Assert.assertEquals(503  , message.getRepeatedUint32  (1));
    979     Assert.assertEquals(504L , message.getRepeatedUint64  (1));
    980     Assert.assertEquals(505  , message.getRepeatedSint32  (1));
    981     Assert.assertEquals(506L , message.getRepeatedSint64  (1));
    982     Assert.assertEquals(507  , message.getRepeatedFixed32 (1));
    983     Assert.assertEquals(508L , message.getRepeatedFixed64 (1));
    984     Assert.assertEquals(509  , message.getRepeatedSfixed32(1));
    985     Assert.assertEquals(510L , message.getRepeatedSfixed64(1));
    986     Assert.assertEquals(511F , message.getRepeatedFloat   (1));
    987     Assert.assertEquals(512D , message.getRepeatedDouble  (1));
    988     Assert.assertEquals(true , message.getRepeatedBool    (1));
    989     Assert.assertEquals("515", message.getRepeatedString  (1));
    990     Assert.assertEquals(toBytes("516"), message.getRepeatedBytes(1));
    991 
    992     Assert.assertEquals(517, message.getRepeatedGroup         (1).getA());
    993     Assert.assertEquals(518, message.getRepeatedNestedMessage (1).getBb());
    994     Assert.assertEquals(519, message.getRepeatedForeignMessage(1).getC());
    995     Assert.assertEquals(520, message.getRepeatedImportMessage (1).getD());
    996     Assert.assertEquals(527, message.getRepeatedLazyMessage   (1).getBb());
    997 
    998     Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getRepeatedNestedEnum (1));
    999     Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getRepeatedForeignEnum(1));
   1000     Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getRepeatedImportEnum(1));
   1001 
   1002     Assert.assertEquals("524", message.getRepeatedStringPiece(1));
   1003     Assert.assertEquals("525", message.getRepeatedCord(1));
   1004   }
   1005 
   1006   /**
   1007    * Set every field of {@code message} to a unique value.
   1008    */
   1009   public static void setPackedFields(TestPackedTypes.Builder message) {
   1010     message.addPackedInt32   (601);
   1011     message.addPackedInt64   (602);
   1012     message.addPackedUint32  (603);
   1013     message.addPackedUint64  (604);
   1014     message.addPackedSint32  (605);
   1015     message.addPackedSint64  (606);
   1016     message.addPackedFixed32 (607);
   1017     message.addPackedFixed64 (608);
   1018     message.addPackedSfixed32(609);
   1019     message.addPackedSfixed64(610);
   1020     message.addPackedFloat   (611);
   1021     message.addPackedDouble  (612);
   1022     message.addPackedBool    (true);
   1023     message.addPackedEnum    (ForeignEnum.FOREIGN_BAR);
   1024     // Add a second one of each field.
   1025     message.addPackedInt32   (701);
   1026     message.addPackedInt64   (702);
   1027     message.addPackedUint32  (703);
   1028     message.addPackedUint64  (704);
   1029     message.addPackedSint32  (705);
   1030     message.addPackedSint64  (706);
   1031     message.addPackedFixed32 (707);
   1032     message.addPackedFixed64 (708);
   1033     message.addPackedSfixed32(709);
   1034     message.addPackedSfixed64(710);
   1035     message.addPackedFloat   (711);
   1036     message.addPackedDouble  (712);
   1037     message.addPackedBool    (false);
   1038     message.addPackedEnum    (ForeignEnum.FOREIGN_BAZ);
   1039   }
   1040 
   1041   /**
   1042    * Set every field of {@code message} to a unique value. Must correspond with
   1043    * the values applied by {@code setPackedFields}.
   1044    */
   1045   public static void setUnpackedFields(TestUnpackedTypes.Builder message) {
   1046     message.addUnpackedInt32   (601);
   1047     message.addUnpackedInt64   (602);
   1048     message.addUnpackedUint32  (603);
   1049     message.addUnpackedUint64  (604);
   1050     message.addUnpackedSint32  (605);
   1051     message.addUnpackedSint64  (606);
   1052     message.addUnpackedFixed32 (607);
   1053     message.addUnpackedFixed64 (608);
   1054     message.addUnpackedSfixed32(609);
   1055     message.addUnpackedSfixed64(610);
   1056     message.addUnpackedFloat   (611);
   1057     message.addUnpackedDouble  (612);
   1058     message.addUnpackedBool    (true);
   1059     message.addUnpackedEnum    (ForeignEnum.FOREIGN_BAR);
   1060     // Add a second one of each field.
   1061     message.addUnpackedInt32   (701);
   1062     message.addUnpackedInt64   (702);
   1063     message.addUnpackedUint32  (703);
   1064     message.addUnpackedUint64  (704);
   1065     message.addUnpackedSint32  (705);
   1066     message.addUnpackedSint64  (706);
   1067     message.addUnpackedFixed32 (707);
   1068     message.addUnpackedFixed64 (708);
   1069     message.addUnpackedSfixed32(709);
   1070     message.addUnpackedSfixed64(710);
   1071     message.addUnpackedFloat   (711);
   1072     message.addUnpackedDouble  (712);
   1073     message.addUnpackedBool    (false);
   1074     message.addUnpackedEnum    (ForeignEnum.FOREIGN_BAZ);
   1075   }
   1076 
   1077   /**
   1078    * Assert (using {@code junit.framework.Assert}} that all fields of
   1079    * {@code message} are set to the values assigned by {@code setPackedFields}.
   1080    */
   1081   public static void assertPackedFieldsSet(TestPackedTypes message) {
   1082     Assert.assertEquals(2, message.getPackedInt32Count   ());
   1083     Assert.assertEquals(2, message.getPackedInt64Count   ());
   1084     Assert.assertEquals(2, message.getPackedUint32Count  ());
   1085     Assert.assertEquals(2, message.getPackedUint64Count  ());
   1086     Assert.assertEquals(2, message.getPackedSint32Count  ());
   1087     Assert.assertEquals(2, message.getPackedSint64Count  ());
   1088     Assert.assertEquals(2, message.getPackedFixed32Count ());
   1089     Assert.assertEquals(2, message.getPackedFixed64Count ());
   1090     Assert.assertEquals(2, message.getPackedSfixed32Count());
   1091     Assert.assertEquals(2, message.getPackedSfixed64Count());
   1092     Assert.assertEquals(2, message.getPackedFloatCount   ());
   1093     Assert.assertEquals(2, message.getPackedDoubleCount  ());
   1094     Assert.assertEquals(2, message.getPackedBoolCount    ());
   1095     Assert.assertEquals(2, message.getPackedEnumCount   ());
   1096     Assert.assertEquals(601  , message.getPackedInt32   (0));
   1097     Assert.assertEquals(602  , message.getPackedInt64   (0));
   1098     Assert.assertEquals(603  , message.getPackedUint32  (0));
   1099     Assert.assertEquals(604  , message.getPackedUint64  (0));
   1100     Assert.assertEquals(605  , message.getPackedSint32  (0));
   1101     Assert.assertEquals(606  , message.getPackedSint64  (0));
   1102     Assert.assertEquals(607  , message.getPackedFixed32 (0));
   1103     Assert.assertEquals(608  , message.getPackedFixed64 (0));
   1104     Assert.assertEquals(609  , message.getPackedSfixed32(0));
   1105     Assert.assertEquals(610  , message.getPackedSfixed64(0));
   1106     Assert.assertEquals(611  , message.getPackedFloat   (0), 0.0);
   1107     Assert.assertEquals(612  , message.getPackedDouble  (0), 0.0);
   1108     Assert.assertEquals(true , message.getPackedBool    (0));
   1109     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getPackedEnum(0));
   1110     Assert.assertEquals(701  , message.getPackedInt32   (1));
   1111     Assert.assertEquals(702  , message.getPackedInt64   (1));
   1112     Assert.assertEquals(703  , message.getPackedUint32  (1));
   1113     Assert.assertEquals(704  , message.getPackedUint64  (1));
   1114     Assert.assertEquals(705  , message.getPackedSint32  (1));
   1115     Assert.assertEquals(706  , message.getPackedSint64  (1));
   1116     Assert.assertEquals(707  , message.getPackedFixed32 (1));
   1117     Assert.assertEquals(708  , message.getPackedFixed64 (1));
   1118     Assert.assertEquals(709  , message.getPackedSfixed32(1));
   1119     Assert.assertEquals(710  , message.getPackedSfixed64(1));
   1120     Assert.assertEquals(711  , message.getPackedFloat   (1), 0.0);
   1121     Assert.assertEquals(712  , message.getPackedDouble  (1), 0.0);
   1122     Assert.assertEquals(false, message.getPackedBool    (1));
   1123     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getPackedEnum(1));
   1124   }
   1125 
   1126   /**
   1127    * Assert (using {@code junit.framework.Assert}} that all fields of
   1128    * {@code message} are set to the values assigned by {@code setUnpackedFields}.
   1129    */
   1130   public static void assertUnpackedFieldsSet(TestUnpackedTypes message) {
   1131     Assert.assertEquals(2, message.getUnpackedInt32Count   ());
   1132     Assert.assertEquals(2, message.getUnpackedInt64Count   ());
   1133     Assert.assertEquals(2, message.getUnpackedUint32Count  ());
   1134     Assert.assertEquals(2, message.getUnpackedUint64Count  ());
   1135     Assert.assertEquals(2, message.getUnpackedSint32Count  ());
   1136     Assert.assertEquals(2, message.getUnpackedSint64Count  ());
   1137     Assert.assertEquals(2, message.getUnpackedFixed32Count ());
   1138     Assert.assertEquals(2, message.getUnpackedFixed64Count ());
   1139     Assert.assertEquals(2, message.getUnpackedSfixed32Count());
   1140     Assert.assertEquals(2, message.getUnpackedSfixed64Count());
   1141     Assert.assertEquals(2, message.getUnpackedFloatCount   ());
   1142     Assert.assertEquals(2, message.getUnpackedDoubleCount  ());
   1143     Assert.assertEquals(2, message.getUnpackedBoolCount    ());
   1144     Assert.assertEquals(2, message.getUnpackedEnumCount   ());
   1145     Assert.assertEquals(601  , message.getUnpackedInt32   (0));
   1146     Assert.assertEquals(602  , message.getUnpackedInt64   (0));
   1147     Assert.assertEquals(603  , message.getUnpackedUint32  (0));
   1148     Assert.assertEquals(604  , message.getUnpackedUint64  (0));
   1149     Assert.assertEquals(605  , message.getUnpackedSint32  (0));
   1150     Assert.assertEquals(606  , message.getUnpackedSint64  (0));
   1151     Assert.assertEquals(607  , message.getUnpackedFixed32 (0));
   1152     Assert.assertEquals(608  , message.getUnpackedFixed64 (0));
   1153     Assert.assertEquals(609  , message.getUnpackedSfixed32(0));
   1154     Assert.assertEquals(610  , message.getUnpackedSfixed64(0));
   1155     Assert.assertEquals(611  , message.getUnpackedFloat   (0), 0.0);
   1156     Assert.assertEquals(612  , message.getUnpackedDouble  (0), 0.0);
   1157     Assert.assertEquals(true , message.getUnpackedBool    (0));
   1158     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getUnpackedEnum(0));
   1159     Assert.assertEquals(701  , message.getUnpackedInt32   (1));
   1160     Assert.assertEquals(702  , message.getUnpackedInt64   (1));
   1161     Assert.assertEquals(703  , message.getUnpackedUint32  (1));
   1162     Assert.assertEquals(704  , message.getUnpackedUint64  (1));
   1163     Assert.assertEquals(705  , message.getUnpackedSint32  (1));
   1164     Assert.assertEquals(706  , message.getUnpackedSint64  (1));
   1165     Assert.assertEquals(707  , message.getUnpackedFixed32 (1));
   1166     Assert.assertEquals(708  , message.getUnpackedFixed64 (1));
   1167     Assert.assertEquals(709  , message.getUnpackedSfixed32(1));
   1168     Assert.assertEquals(710  , message.getUnpackedSfixed64(1));
   1169     Assert.assertEquals(711  , message.getUnpackedFloat   (1), 0.0);
   1170     Assert.assertEquals(712  , message.getUnpackedDouble  (1), 0.0);
   1171     Assert.assertEquals(false, message.getUnpackedBool    (1));
   1172     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getUnpackedEnum(1));
   1173   }
   1174 
   1175   // ===================================================================
   1176   // Like above, but for extensions
   1177 
   1178   // Java gets confused with things like assertEquals(int, Integer):  it can't
   1179   // decide whether to call assertEquals(int, int) or assertEquals(Object,
   1180   // Object).  So we define these methods to help it.
   1181   private static void assertEqualsExactType(int a, int b) {
   1182     Assert.assertEquals(a, b);
   1183   }
   1184   private static void assertEqualsExactType(long a, long b) {
   1185     Assert.assertEquals(a, b);
   1186   }
   1187   private static void assertEqualsExactType(float a, float b) {
   1188     Assert.assertEquals(a, b, 0.0);
   1189   }
   1190   private static void assertEqualsExactType(double a, double b) {
   1191     Assert.assertEquals(a, b, 0.0);
   1192   }
   1193   private static void assertEqualsExactType(boolean a, boolean b) {
   1194     Assert.assertEquals(a, b);
   1195   }
   1196   private static void assertEqualsExactType(String a, String b) {
   1197     Assert.assertEquals(a, b);
   1198   }
   1199   private static void assertEqualsExactType(ByteString a, ByteString b) {
   1200     Assert.assertEquals(a, b);
   1201   }
   1202   private static void assertEqualsExactType(TestAllTypes.NestedEnum a,
   1203                                             TestAllTypes.NestedEnum b) {
   1204     Assert.assertEquals(a, b);
   1205   }
   1206   private static void assertEqualsExactType(ForeignEnum a, ForeignEnum b) {
   1207     Assert.assertEquals(a, b);
   1208   }
   1209   private static void assertEqualsExactType(ImportEnum a, ImportEnum b) {
   1210     Assert.assertEquals(a, b);
   1211   }
   1212   private static void assertEqualsExactType(TestAllTypesLite.NestedEnum a,
   1213                                             TestAllTypesLite.NestedEnum b) {
   1214     Assert.assertEquals(a, b);
   1215   }
   1216   private static void assertEqualsExactType(ForeignEnumLite a,
   1217                                             ForeignEnumLite b) {
   1218     Assert.assertEquals(a, b);
   1219   }
   1220   private static void assertEqualsExactType(ImportEnumLite a,
   1221                                             ImportEnumLite b) {
   1222     Assert.assertEquals(a, b);
   1223   }
   1224 
   1225   /**
   1226    * Get an unmodifiable {@link ExtensionRegistry} containing all the
   1227    * extensions of {@code TestAllExtensions}.
   1228    */
   1229   public static ExtensionRegistry getExtensionRegistry() {
   1230     ExtensionRegistry registry = ExtensionRegistry.newInstance();
   1231     registerAllExtensions(registry);
   1232     return registry.getUnmodifiable();
   1233   }
   1234 
   1235   public static ExtensionRegistryLite getExtensionRegistryLite() {
   1236     ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
   1237     registerAllExtensionsLite(registry);
   1238     return registry.getUnmodifiable();
   1239   }
   1240 
   1241   /**
   1242    * Register all of {@code TestAllExtensions}'s extensions with the
   1243    * given {@link ExtensionRegistry}.
   1244    */
   1245   public static void registerAllExtensions(ExtensionRegistry registry) {
   1246     UnittestProto.registerAllExtensions(registry);
   1247     registerAllExtensionsLite(registry);
   1248   }
   1249 
   1250   public static void registerAllExtensionsLite(ExtensionRegistryLite registry) {
   1251     UnittestLite.registerAllExtensions(registry);
   1252   }
   1253 
   1254   /**
   1255    * Set every field of {@code message} to the values expected by
   1256    * {@code assertAllExtensionsSet()}.
   1257    */
   1258   public static void setAllExtensions(TestAllExtensions.Builder message) {
   1259     message.setExtension(optionalInt32Extension   , 101);
   1260     message.setExtension(optionalInt64Extension   , 102L);
   1261     message.setExtension(optionalUint32Extension  , 103);
   1262     message.setExtension(optionalUint64Extension  , 104L);
   1263     message.setExtension(optionalSint32Extension  , 105);
   1264     message.setExtension(optionalSint64Extension  , 106L);
   1265     message.setExtension(optionalFixed32Extension , 107);
   1266     message.setExtension(optionalFixed64Extension , 108L);
   1267     message.setExtension(optionalSfixed32Extension, 109);
   1268     message.setExtension(optionalSfixed64Extension, 110L);
   1269     message.setExtension(optionalFloatExtension   , 111F);
   1270     message.setExtension(optionalDoubleExtension  , 112D);
   1271     message.setExtension(optionalBoolExtension    , true);
   1272     message.setExtension(optionalStringExtension  , "115");
   1273     message.setExtension(optionalBytesExtension   , toBytes("116"));
   1274 
   1275     message.setExtension(optionalGroupExtension,
   1276       OptionalGroup_extension.newBuilder().setA(117).build());
   1277     message.setExtension(optionalNestedMessageExtension,
   1278       TestAllTypes.NestedMessage.newBuilder().setBb(118).build());
   1279     message.setExtension(optionalForeignMessageExtension,
   1280       ForeignMessage.newBuilder().setC(119).build());
   1281     message.setExtension(optionalImportMessageExtension,
   1282       ImportMessage.newBuilder().setD(120).build());
   1283     message.setExtension(optionalPublicImportMessageExtension,
   1284       PublicImportMessage.newBuilder().setE(126).build());
   1285     message.setExtension(optionalLazyMessageExtension,
   1286       TestAllTypes.NestedMessage.newBuilder().setBb(127).build());
   1287 
   1288     message.setExtension(optionalNestedEnumExtension, TestAllTypes.NestedEnum.BAZ);
   1289     message.setExtension(optionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ);
   1290     message.setExtension(optionalImportEnumExtension, ImportEnum.IMPORT_BAZ);
   1291 
   1292     message.setExtension(optionalStringPieceExtension, "124");
   1293     message.setExtension(optionalCordExtension, "125");
   1294 
   1295     // -----------------------------------------------------------------
   1296 
   1297     message.addExtension(repeatedInt32Extension   , 201);
   1298     message.addExtension(repeatedInt64Extension   , 202L);
   1299     message.addExtension(repeatedUint32Extension  , 203);
   1300     message.addExtension(repeatedUint64Extension  , 204L);
   1301     message.addExtension(repeatedSint32Extension  , 205);
   1302     message.addExtension(repeatedSint64Extension  , 206L);
   1303     message.addExtension(repeatedFixed32Extension , 207);
   1304     message.addExtension(repeatedFixed64Extension , 208L);
   1305     message.addExtension(repeatedSfixed32Extension, 209);
   1306     message.addExtension(repeatedSfixed64Extension, 210L);
   1307     message.addExtension(repeatedFloatExtension   , 211F);
   1308     message.addExtension(repeatedDoubleExtension  , 212D);
   1309     message.addExtension(repeatedBoolExtension    , true);
   1310     message.addExtension(repeatedStringExtension  , "215");
   1311     message.addExtension(repeatedBytesExtension   , toBytes("216"));
   1312 
   1313     message.addExtension(repeatedGroupExtension,
   1314       RepeatedGroup_extension.newBuilder().setA(217).build());
   1315     message.addExtension(repeatedNestedMessageExtension,
   1316       TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
   1317     message.addExtension(repeatedForeignMessageExtension,
   1318       ForeignMessage.newBuilder().setC(219).build());
   1319     message.addExtension(repeatedImportMessageExtension,
   1320       ImportMessage.newBuilder().setD(220).build());
   1321     message.addExtension(repeatedLazyMessageExtension,
   1322       TestAllTypes.NestedMessage.newBuilder().setBb(227).build());
   1323 
   1324     message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAR);
   1325     message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAR);
   1326     message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAR);
   1327 
   1328     message.addExtension(repeatedStringPieceExtension, "224");
   1329     message.addExtension(repeatedCordExtension, "225");
   1330 
   1331     // Add a second one of each field.
   1332     message.addExtension(repeatedInt32Extension   , 301);
   1333     message.addExtension(repeatedInt64Extension   , 302L);
   1334     message.addExtension(repeatedUint32Extension  , 303);
   1335     message.addExtension(repeatedUint64Extension  , 304L);
   1336     message.addExtension(repeatedSint32Extension  , 305);
   1337     message.addExtension(repeatedSint64Extension  , 306L);
   1338     message.addExtension(repeatedFixed32Extension , 307);
   1339     message.addExtension(repeatedFixed64Extension , 308L);
   1340     message.addExtension(repeatedSfixed32Extension, 309);
   1341     message.addExtension(repeatedSfixed64Extension, 310L);
   1342     message.addExtension(repeatedFloatExtension   , 311F);
   1343     message.addExtension(repeatedDoubleExtension  , 312D);
   1344     message.addExtension(repeatedBoolExtension    , false);
   1345     message.addExtension(repeatedStringExtension  , "315");
   1346     message.addExtension(repeatedBytesExtension   , toBytes("316"));
   1347 
   1348     message.addExtension(repeatedGroupExtension,
   1349       RepeatedGroup_extension.newBuilder().setA(317).build());
   1350     message.addExtension(repeatedNestedMessageExtension,
   1351       TestAllTypes.NestedMessage.newBuilder().setBb(318).build());
   1352     message.addExtension(repeatedForeignMessageExtension,
   1353       ForeignMessage.newBuilder().setC(319).build());
   1354     message.addExtension(repeatedImportMessageExtension,
   1355       ImportMessage.newBuilder().setD(320).build());
   1356     message.addExtension(repeatedLazyMessageExtension,
   1357       TestAllTypes.NestedMessage.newBuilder().setBb(327).build());
   1358 
   1359     message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAZ);
   1360     message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ);
   1361     message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAZ);
   1362 
   1363     message.addExtension(repeatedStringPieceExtension, "324");
   1364     message.addExtension(repeatedCordExtension, "325");
   1365 
   1366     // -----------------------------------------------------------------
   1367 
   1368     message.setExtension(defaultInt32Extension   , 401);
   1369     message.setExtension(defaultInt64Extension   , 402L);
   1370     message.setExtension(defaultUint32Extension  , 403);
   1371     message.setExtension(defaultUint64Extension  , 404L);
   1372     message.setExtension(defaultSint32Extension  , 405);
   1373     message.setExtension(defaultSint64Extension  , 406L);
   1374     message.setExtension(defaultFixed32Extension , 407);
   1375     message.setExtension(defaultFixed64Extension , 408L);
   1376     message.setExtension(defaultSfixed32Extension, 409);
   1377     message.setExtension(defaultSfixed64Extension, 410L);
   1378     message.setExtension(defaultFloatExtension   , 411F);
   1379     message.setExtension(defaultDoubleExtension  , 412D);
   1380     message.setExtension(defaultBoolExtension    , false);
   1381     message.setExtension(defaultStringExtension  , "415");
   1382     message.setExtension(defaultBytesExtension   , toBytes("416"));
   1383 
   1384     message.setExtension(defaultNestedEnumExtension, TestAllTypes.NestedEnum.FOO);
   1385     message.setExtension(defaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO);
   1386     message.setExtension(defaultImportEnumExtension, ImportEnum.IMPORT_FOO);
   1387 
   1388     message.setExtension(defaultStringPieceExtension, "424");
   1389     message.setExtension(defaultCordExtension, "425");
   1390 
   1391     message.setExtension(oneofUint32Extension, 601);
   1392     message.setExtension(oneofNestedMessageExtension,
   1393       TestAllTypes.NestedMessage.newBuilder().setBb(602).build());
   1394     message.setExtension(oneofStringExtension, "603");
   1395     message.setExtension(oneofBytesExtension, toBytes("604"));
   1396   }
   1397 
   1398   // -------------------------------------------------------------------
   1399 
   1400   /**
   1401    * Modify the repeated extensions of {@code message} to contain the values
   1402    * expected by {@code assertRepeatedExtensionsModified()}.
   1403    */
   1404   public static void modifyRepeatedExtensions(
   1405       TestAllExtensions.Builder message) {
   1406     message.setExtension(repeatedInt32Extension   , 1, 501);
   1407     message.setExtension(repeatedInt64Extension   , 1, 502L);
   1408     message.setExtension(repeatedUint32Extension  , 1, 503);
   1409     message.setExtension(repeatedUint64Extension  , 1, 504L);
   1410     message.setExtension(repeatedSint32Extension  , 1, 505);
   1411     message.setExtension(repeatedSint64Extension  , 1, 506L);
   1412     message.setExtension(repeatedFixed32Extension , 1, 507);
   1413     message.setExtension(repeatedFixed64Extension , 1, 508L);
   1414     message.setExtension(repeatedSfixed32Extension, 1, 509);
   1415     message.setExtension(repeatedSfixed64Extension, 1, 510L);
   1416     message.setExtension(repeatedFloatExtension   , 1, 511F);
   1417     message.setExtension(repeatedDoubleExtension  , 1, 512D);
   1418     message.setExtension(repeatedBoolExtension    , 1, true);
   1419     message.setExtension(repeatedStringExtension  , 1, "515");
   1420     message.setExtension(repeatedBytesExtension   , 1, toBytes("516"));
   1421 
   1422     message.setExtension(repeatedGroupExtension, 1,
   1423       RepeatedGroup_extension.newBuilder().setA(517).build());
   1424     message.setExtension(repeatedNestedMessageExtension, 1,
   1425       TestAllTypes.NestedMessage.newBuilder().setBb(518).build());
   1426     message.setExtension(repeatedForeignMessageExtension, 1,
   1427       ForeignMessage.newBuilder().setC(519).build());
   1428     message.setExtension(repeatedImportMessageExtension, 1,
   1429       ImportMessage.newBuilder().setD(520).build());
   1430     message.setExtension(repeatedLazyMessageExtension, 1,
   1431       TestAllTypes.NestedMessage.newBuilder().setBb(527).build());
   1432 
   1433     message.setExtension(repeatedNestedEnumExtension , 1, TestAllTypes.NestedEnum.FOO);
   1434     message.setExtension(repeatedForeignEnumExtension, 1, ForeignEnum.FOREIGN_FOO);
   1435     message.setExtension(repeatedImportEnumExtension , 1, ImportEnum.IMPORT_FOO);
   1436 
   1437     message.setExtension(repeatedStringPieceExtension, 1, "524");
   1438     message.setExtension(repeatedCordExtension, 1, "525");
   1439   }
   1440 
   1441   // -------------------------------------------------------------------
   1442 
   1443   /**
   1444    * Assert (using {@code junit.framework.Assert}} that all extensions of
   1445    * {@code message} are set to the values assigned by {@code setAllExtensions}.
   1446    */
   1447   public static void assertAllExtensionsSet(
   1448       TestAllExtensionsOrBuilder message) {
   1449     Assert.assertTrue(message.hasExtension(optionalInt32Extension   ));
   1450     Assert.assertTrue(message.hasExtension(optionalInt64Extension   ));
   1451     Assert.assertTrue(message.hasExtension(optionalUint32Extension  ));
   1452     Assert.assertTrue(message.hasExtension(optionalUint64Extension  ));
   1453     Assert.assertTrue(message.hasExtension(optionalSint32Extension  ));
   1454     Assert.assertTrue(message.hasExtension(optionalSint64Extension  ));
   1455     Assert.assertTrue(message.hasExtension(optionalFixed32Extension ));
   1456     Assert.assertTrue(message.hasExtension(optionalFixed64Extension ));
   1457     Assert.assertTrue(message.hasExtension(optionalSfixed32Extension));
   1458     Assert.assertTrue(message.hasExtension(optionalSfixed64Extension));
   1459     Assert.assertTrue(message.hasExtension(optionalFloatExtension   ));
   1460     Assert.assertTrue(message.hasExtension(optionalDoubleExtension  ));
   1461     Assert.assertTrue(message.hasExtension(optionalBoolExtension    ));
   1462     Assert.assertTrue(message.hasExtension(optionalStringExtension  ));
   1463     Assert.assertTrue(message.hasExtension(optionalBytesExtension   ));
   1464 
   1465     Assert.assertTrue(message.hasExtension(optionalGroupExtension         ));
   1466     Assert.assertTrue(message.hasExtension(optionalNestedMessageExtension ));
   1467     Assert.assertTrue(message.hasExtension(optionalForeignMessageExtension));
   1468     Assert.assertTrue(message.hasExtension(optionalImportMessageExtension ));
   1469 
   1470     Assert.assertTrue(message.getExtension(optionalGroupExtension         ).hasA());
   1471     Assert.assertTrue(message.getExtension(optionalNestedMessageExtension ).hasBb());
   1472     Assert.assertTrue(message.getExtension(optionalForeignMessageExtension).hasC());
   1473     Assert.assertTrue(message.getExtension(optionalImportMessageExtension ).hasD());
   1474 
   1475     Assert.assertTrue(message.hasExtension(optionalNestedEnumExtension ));
   1476     Assert.assertTrue(message.hasExtension(optionalForeignEnumExtension));
   1477     Assert.assertTrue(message.hasExtension(optionalImportEnumExtension ));
   1478 
   1479     Assert.assertTrue(message.hasExtension(optionalStringPieceExtension));
   1480     Assert.assertTrue(message.hasExtension(optionalCordExtension));
   1481 
   1482     assertEqualsExactType(101  , message.getExtension(optionalInt32Extension   ));
   1483     assertEqualsExactType(102L , message.getExtension(optionalInt64Extension   ));
   1484     assertEqualsExactType(103  , message.getExtension(optionalUint32Extension  ));
   1485     assertEqualsExactType(104L , message.getExtension(optionalUint64Extension  ));
   1486     assertEqualsExactType(105  , message.getExtension(optionalSint32Extension  ));
   1487     assertEqualsExactType(106L , message.getExtension(optionalSint64Extension  ));
   1488     assertEqualsExactType(107  , message.getExtension(optionalFixed32Extension ));
   1489     assertEqualsExactType(108L , message.getExtension(optionalFixed64Extension ));
   1490     assertEqualsExactType(109  , message.getExtension(optionalSfixed32Extension));
   1491     assertEqualsExactType(110L , message.getExtension(optionalSfixed64Extension));
   1492     assertEqualsExactType(111F , message.getExtension(optionalFloatExtension   ));
   1493     assertEqualsExactType(112D , message.getExtension(optionalDoubleExtension  ));
   1494     assertEqualsExactType(true , message.getExtension(optionalBoolExtension    ));
   1495     assertEqualsExactType("115", message.getExtension(optionalStringExtension  ));
   1496     assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExtension));
   1497 
   1498     assertEqualsExactType(117, message.getExtension(optionalGroupExtension              ).getA());
   1499     assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtension      ).getBb());
   1500     assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtension     ).getC());
   1501     assertEqualsExactType(120, message.getExtension(optionalImportMessageExtension      ).getD());
   1502     assertEqualsExactType(126, message.getExtension(optionalPublicImportMessageExtension).getE());
   1503     assertEqualsExactType(127, message.getExtension(optionalLazyMessageExtension        ).getBb());
   1504 
   1505     assertEqualsExactType(TestAllTypes.NestedEnum.BAZ,
   1506       message.getExtension(optionalNestedEnumExtension));
   1507     assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
   1508       message.getExtension(optionalForeignEnumExtension));
   1509     assertEqualsExactType(ImportEnum.IMPORT_BAZ,
   1510       message.getExtension(optionalImportEnumExtension));
   1511 
   1512     assertEqualsExactType("124", message.getExtension(optionalStringPieceExtension));
   1513     assertEqualsExactType("125", message.getExtension(optionalCordExtension));
   1514 
   1515     // -----------------------------------------------------------------
   1516 
   1517     Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension   ));
   1518     Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension   ));
   1519     Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension  ));
   1520     Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension  ));
   1521     Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension  ));
   1522     Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension  ));
   1523     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension ));
   1524     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension ));
   1525     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension));
   1526     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension));
   1527     Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension   ));
   1528     Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension  ));
   1529     Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension    ));
   1530     Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension  ));
   1531     Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension   ));
   1532 
   1533     Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension         ));
   1534     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension ));
   1535     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));
   1536     Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension ));
   1537     Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtension   ));
   1538     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension    ));
   1539     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension   ));
   1540     Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension    ));
   1541 
   1542     Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension));
   1543     Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension));
   1544 
   1545     assertEqualsExactType(201  , message.getExtension(repeatedInt32Extension   , 0));
   1546     assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension   , 0));
   1547     assertEqualsExactType(203  , message.getExtension(repeatedUint32Extension  , 0));
   1548     assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension  , 0));
   1549     assertEqualsExactType(205  , message.getExtension(repeatedSint32Extension  , 0));
   1550     assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension  , 0));
   1551     assertEqualsExactType(207  , message.getExtension(repeatedFixed32Extension , 0));
   1552     assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension , 0));
   1553     assertEqualsExactType(209  , message.getExtension(repeatedSfixed32Extension, 0));
   1554     assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension, 0));
   1555     assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension   , 0));
   1556     assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension  , 0));
   1557     assertEqualsExactType(true , message.getExtension(repeatedBoolExtension    , 0));
   1558     assertEqualsExactType("215", message.getExtension(repeatedStringExtension  , 0));
   1559     assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0));
   1560 
   1561     assertEqualsExactType(217, message.getExtension(repeatedGroupExtension         , 0).getA());
   1562     assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb());
   1563     assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());
   1564     assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD());
   1565     assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension   , 0).getBb());
   1566 
   1567     assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
   1568       message.getExtension(repeatedNestedEnumExtension, 0));
   1569     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
   1570       message.getExtension(repeatedForeignEnumExtension, 0));
   1571     assertEqualsExactType(ImportEnum.IMPORT_BAR,
   1572       message.getExtension(repeatedImportEnumExtension, 0));
   1573 
   1574     assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0));
   1575     assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0));
   1576 
   1577     assertEqualsExactType(301  , message.getExtension(repeatedInt32Extension   , 1));
   1578     assertEqualsExactType(302L , message.getExtension(repeatedInt64Extension   , 1));
   1579     assertEqualsExactType(303  , message.getExtension(repeatedUint32Extension  , 1));
   1580     assertEqualsExactType(304L , message.getExtension(repeatedUint64Extension  , 1));
   1581     assertEqualsExactType(305  , message.getExtension(repeatedSint32Extension  , 1));
   1582     assertEqualsExactType(306L , message.getExtension(repeatedSint64Extension  , 1));
   1583     assertEqualsExactType(307  , message.getExtension(repeatedFixed32Extension , 1));
   1584     assertEqualsExactType(308L , message.getExtension(repeatedFixed64Extension , 1));
   1585     assertEqualsExactType(309  , message.getExtension(repeatedSfixed32Extension, 1));
   1586     assertEqualsExactType(310L , message.getExtension(repeatedSfixed64Extension, 1));
   1587     assertEqualsExactType(311F , message.getExtension(repeatedFloatExtension   , 1));
   1588     assertEqualsExactType(312D , message.getExtension(repeatedDoubleExtension  , 1));
   1589     assertEqualsExactType(false, message.getExtension(repeatedBoolExtension    , 1));
   1590     assertEqualsExactType("315", message.getExtension(repeatedStringExtension  , 1));
   1591     assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExtension, 1));
   1592 
   1593     assertEqualsExactType(317, message.getExtension(repeatedGroupExtension         , 1).getA());
   1594     assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtension , 1).getBb());
   1595     assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtension, 1).getC());
   1596     assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtension , 1).getD());
   1597     assertEqualsExactType(327, message.getExtension(repeatedLazyMessageExtension   , 1).getBb());
   1598 
   1599     assertEqualsExactType(TestAllTypes.NestedEnum.BAZ,
   1600       message.getExtension(repeatedNestedEnumExtension, 1));
   1601     assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
   1602       message.getExtension(repeatedForeignEnumExtension, 1));
   1603     assertEqualsExactType(ImportEnum.IMPORT_BAZ,
   1604       message.getExtension(repeatedImportEnumExtension, 1));
   1605 
   1606     assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtension, 1));
   1607     assertEqualsExactType("325", message.getExtension(repeatedCordExtension, 1));
   1608 
   1609     // -----------------------------------------------------------------
   1610 
   1611     Assert.assertTrue(message.hasExtension(defaultInt32Extension   ));
   1612     Assert.assertTrue(message.hasExtension(defaultInt64Extension   ));
   1613     Assert.assertTrue(message.hasExtension(defaultUint32Extension  ));
   1614     Assert.assertTrue(message.hasExtension(defaultUint64Extension  ));
   1615     Assert.assertTrue(message.hasExtension(defaultSint32Extension  ));
   1616     Assert.assertTrue(message.hasExtension(defaultSint64Extension  ));
   1617     Assert.assertTrue(message.hasExtension(defaultFixed32Extension ));
   1618     Assert.assertTrue(message.hasExtension(defaultFixed64Extension ));
   1619     Assert.assertTrue(message.hasExtension(defaultSfixed32Extension));
   1620     Assert.assertTrue(message.hasExtension(defaultSfixed64Extension));
   1621     Assert.assertTrue(message.hasExtension(defaultFloatExtension   ));
   1622     Assert.assertTrue(message.hasExtension(defaultDoubleExtension  ));
   1623     Assert.assertTrue(message.hasExtension(defaultBoolExtension    ));
   1624     Assert.assertTrue(message.hasExtension(defaultStringExtension  ));
   1625     Assert.assertTrue(message.hasExtension(defaultBytesExtension   ));
   1626 
   1627     Assert.assertTrue(message.hasExtension(defaultNestedEnumExtension ));
   1628     Assert.assertTrue(message.hasExtension(defaultForeignEnumExtension));
   1629     Assert.assertTrue(message.hasExtension(defaultImportEnumExtension ));
   1630 
   1631     Assert.assertTrue(message.hasExtension(defaultStringPieceExtension));
   1632     Assert.assertTrue(message.hasExtension(defaultCordExtension));
   1633 
   1634     assertEqualsExactType(401  , message.getExtension(defaultInt32Extension   ));
   1635     assertEqualsExactType(402L , message.getExtension(defaultInt64Extension   ));
   1636     assertEqualsExactType(403  , message.getExtension(defaultUint32Extension  ));
   1637     assertEqualsExactType(404L , message.getExtension(defaultUint64Extension  ));
   1638     assertEqualsExactType(405  , message.getExtension(defaultSint32Extension  ));
   1639     assertEqualsExactType(406L , message.getExtension(defaultSint64Extension  ));
   1640     assertEqualsExactType(407  , message.getExtension(defaultFixed32Extension ));
   1641     assertEqualsExactType(408L , message.getExtension(defaultFixed64Extension ));
   1642     assertEqualsExactType(409  , message.getExtension(defaultSfixed32Extension));
   1643     assertEqualsExactType(410L , message.getExtension(defaultSfixed64Extension));
   1644     assertEqualsExactType(411F , message.getExtension(defaultFloatExtension   ));
   1645     assertEqualsExactType(412D , message.getExtension(defaultDoubleExtension  ));
   1646     assertEqualsExactType(false, message.getExtension(defaultBoolExtension    ));
   1647     assertEqualsExactType("415", message.getExtension(defaultStringExtension  ));
   1648     assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExtension));
   1649 
   1650     assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
   1651       message.getExtension(defaultNestedEnumExtension ));
   1652     assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
   1653       message.getExtension(defaultForeignEnumExtension));
   1654     assertEqualsExactType(ImportEnum.IMPORT_FOO,
   1655       message.getExtension(defaultImportEnumExtension));
   1656 
   1657     assertEqualsExactType("424", message.getExtension(defaultStringPieceExtension));
   1658     assertEqualsExactType("425", message.getExtension(defaultCordExtension));
   1659 
   1660     Assert.assertTrue(message.hasExtension(oneofBytesExtension));
   1661 
   1662     assertEqualsExactType(toBytes("604"), message.getExtension(oneofBytesExtension));
   1663   }
   1664 
   1665   // -------------------------------------------------------------------
   1666 
   1667   /**
   1668    * Assert (using {@code junit.framework.Assert}} that all extensions of
   1669    * {@code message} are cleared, and that getting the extensions returns their
   1670    * default values.
   1671    */
   1672   public static void assertExtensionsClear(TestAllExtensionsOrBuilder message) {
   1673     // hasBlah() should initially be false for all optional fields.
   1674     Assert.assertFalse(message.hasExtension(optionalInt32Extension   ));
   1675     Assert.assertFalse(message.hasExtension(optionalInt64Extension   ));
   1676     Assert.assertFalse(message.hasExtension(optionalUint32Extension  ));
   1677     Assert.assertFalse(message.hasExtension(optionalUint64Extension  ));
   1678     Assert.assertFalse(message.hasExtension(optionalSint32Extension  ));
   1679     Assert.assertFalse(message.hasExtension(optionalSint64Extension  ));
   1680     Assert.assertFalse(message.hasExtension(optionalFixed32Extension ));
   1681     Assert.assertFalse(message.hasExtension(optionalFixed64Extension ));
   1682     Assert.assertFalse(message.hasExtension(optionalSfixed32Extension));
   1683     Assert.assertFalse(message.hasExtension(optionalSfixed64Extension));
   1684     Assert.assertFalse(message.hasExtension(optionalFloatExtension   ));
   1685     Assert.assertFalse(message.hasExtension(optionalDoubleExtension  ));
   1686     Assert.assertFalse(message.hasExtension(optionalBoolExtension    ));
   1687     Assert.assertFalse(message.hasExtension(optionalStringExtension  ));
   1688     Assert.assertFalse(message.hasExtension(optionalBytesExtension   ));
   1689 
   1690     Assert.assertFalse(message.hasExtension(optionalGroupExtension         ));
   1691     Assert.assertFalse(message.hasExtension(optionalNestedMessageExtension ));
   1692     Assert.assertFalse(message.hasExtension(optionalForeignMessageExtension));
   1693     Assert.assertFalse(message.hasExtension(optionalImportMessageExtension ));
   1694 
   1695     Assert.assertFalse(message.hasExtension(optionalNestedEnumExtension ));
   1696     Assert.assertFalse(message.hasExtension(optionalForeignEnumExtension));
   1697     Assert.assertFalse(message.hasExtension(optionalImportEnumExtension ));
   1698 
   1699     Assert.assertFalse(message.hasExtension(optionalStringPieceExtension));
   1700     Assert.assertFalse(message.hasExtension(optionalCordExtension));
   1701 
   1702     // Optional fields without defaults are set to zero or something like it.
   1703     assertEqualsExactType(0    , message.getExtension(optionalInt32Extension   ));
   1704     assertEqualsExactType(0L   , message.getExtension(optionalInt64Extension   ));
   1705     assertEqualsExactType(0    , message.getExtension(optionalUint32Extension  ));
   1706     assertEqualsExactType(0L   , message.getExtension(optionalUint64Extension  ));
   1707     assertEqualsExactType(0    , message.getExtension(optionalSint32Extension  ));
   1708     assertEqualsExactType(0L   , message.getExtension(optionalSint64Extension  ));
   1709     assertEqualsExactType(0    , message.getExtension(optionalFixed32Extension ));
   1710     assertEqualsExactType(0L   , message.getExtension(optionalFixed64Extension ));
   1711     assertEqualsExactType(0    , message.getExtension(optionalSfixed32Extension));
   1712     assertEqualsExactType(0L   , message.getExtension(optionalSfixed64Extension));
   1713     assertEqualsExactType(0F   , message.getExtension(optionalFloatExtension   ));
   1714     assertEqualsExactType(0D   , message.getExtension(optionalDoubleExtension  ));
   1715     assertEqualsExactType(false, message.getExtension(optionalBoolExtension    ));
   1716     assertEqualsExactType(""   , message.getExtension(optionalStringExtension  ));
   1717     assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesExtension));
   1718 
   1719     // Embedded messages should also be clear.
   1720     Assert.assertFalse(message.getExtension(optionalGroupExtension         ).hasA());
   1721     Assert.assertFalse(message.getExtension(optionalNestedMessageExtension ).hasBb());
   1722     Assert.assertFalse(message.getExtension(optionalForeignMessageExtension).hasC());
   1723     Assert.assertFalse(message.getExtension(optionalImportMessageExtension ).hasD());
   1724 
   1725     assertEqualsExactType(0, message.getExtension(optionalGroupExtension         ).getA());
   1726     assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtension ).getBb());
   1727     assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtension).getC());
   1728     assertEqualsExactType(0, message.getExtension(optionalImportMessageExtension ).getD());
   1729 
   1730     // Enums without defaults are set to the first value in the enum.
   1731     assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
   1732       message.getExtension(optionalNestedEnumExtension ));
   1733     assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
   1734       message.getExtension(optionalForeignEnumExtension));
   1735     assertEqualsExactType(ImportEnum.IMPORT_FOO,
   1736       message.getExtension(optionalImportEnumExtension));
   1737 
   1738     assertEqualsExactType("", message.getExtension(optionalStringPieceExtension));
   1739     assertEqualsExactType("", message.getExtension(optionalCordExtension));
   1740 
   1741     // Repeated fields are empty.
   1742     Assert.assertEquals(0, message.getExtensionCount(repeatedInt32Extension   ));
   1743     Assert.assertEquals(0, message.getExtensionCount(repeatedInt64Extension   ));
   1744     Assert.assertEquals(0, message.getExtensionCount(repeatedUint32Extension  ));
   1745     Assert.assertEquals(0, message.getExtensionCount(repeatedUint64Extension  ));
   1746     Assert.assertEquals(0, message.getExtensionCount(repeatedSint32Extension  ));
   1747     Assert.assertEquals(0, message.getExtensionCount(repeatedSint64Extension  ));
   1748     Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32Extension ));
   1749     Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64Extension ));
   1750     Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32Extension));
   1751     Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64Extension));
   1752     Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtension   ));
   1753     Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtension  ));
   1754     Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtension    ));
   1755     Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtension  ));
   1756     Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtension   ));
   1757 
   1758     Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtension         ));
   1759     Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtension ));
   1760     Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExtension));
   1761     Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtension ));
   1762     Assert.assertEquals(0, message.getExtensionCount(repeatedLazyMessageExtension   ));
   1763     Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtension    ));
   1764     Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtension   ));
   1765     Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtension    ));
   1766 
   1767     Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtension));
   1768     Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtension));
   1769 
   1770     // Repeated fields are empty via getExtension().size().
   1771     Assert.assertEquals(0, message.getExtension(repeatedInt32Extension   ).size());
   1772     Assert.assertEquals(0, message.getExtension(repeatedInt64Extension   ).size());
   1773     Assert.assertEquals(0, message.getExtension(repeatedUint32Extension  ).size());
   1774     Assert.assertEquals(0, message.getExtension(repeatedUint64Extension  ).size());
   1775     Assert.assertEquals(0, message.getExtension(repeatedSint32Extension  ).size());
   1776     Assert.assertEquals(0, message.getExtension(repeatedSint64Extension  ).size());
   1777     Assert.assertEquals(0, message.getExtension(repeatedFixed32Extension ).size());
   1778     Assert.assertEquals(0, message.getExtension(repeatedFixed64Extension ).size());
   1779     Assert.assertEquals(0, message.getExtension(repeatedSfixed32Extension).size());
   1780     Assert.assertEquals(0, message.getExtension(repeatedSfixed64Extension).size());
   1781     Assert.assertEquals(0, message.getExtension(repeatedFloatExtension   ).size());
   1782     Assert.assertEquals(0, message.getExtension(repeatedDoubleExtension  ).size());
   1783     Assert.assertEquals(0, message.getExtension(repeatedBoolExtension    ).size());
   1784     Assert.assertEquals(0, message.getExtension(repeatedStringExtension  ).size());
   1785     Assert.assertEquals(0, message.getExtension(repeatedBytesExtension   ).size());
   1786 
   1787     Assert.assertEquals(0, message.getExtension(repeatedGroupExtension         ).size());
   1788     Assert.assertEquals(0, message.getExtension(repeatedNestedMessageExtension ).size());
   1789     Assert.assertEquals(0, message.getExtension(repeatedForeignMessageExtension).size());
   1790     Assert.assertEquals(0, message.getExtension(repeatedImportMessageExtension ).size());
   1791     Assert.assertEquals(0, message.getExtension(repeatedLazyMessageExtension   ).size());
   1792     Assert.assertEquals(0, message.getExtension(repeatedNestedEnumExtension    ).size());
   1793     Assert.assertEquals(0, message.getExtension(repeatedForeignEnumExtension   ).size());
   1794     Assert.assertEquals(0, message.getExtension(repeatedImportEnumExtension    ).size());
   1795 
   1796     Assert.assertEquals(0, message.getExtension(repeatedStringPieceExtension).size());
   1797     Assert.assertEquals(0, message.getExtension(repeatedCordExtension).size());
   1798 
   1799     // hasBlah() should also be false for all default fields.
   1800     Assert.assertFalse(message.hasExtension(defaultInt32Extension   ));
   1801     Assert.assertFalse(message.hasExtension(defaultInt64Extension   ));
   1802     Assert.assertFalse(message.hasExtension(defaultUint32Extension  ));
   1803     Assert.assertFalse(message.hasExtension(defaultUint64Extension  ));
   1804     Assert.assertFalse(message.hasExtension(defaultSint32Extension  ));
   1805     Assert.assertFalse(message.hasExtension(defaultSint64Extension  ));
   1806     Assert.assertFalse(message.hasExtension(defaultFixed32Extension ));
   1807     Assert.assertFalse(message.hasExtension(defaultFixed64Extension ));
   1808     Assert.assertFalse(message.hasExtension(defaultSfixed32Extension));
   1809     Assert.assertFalse(message.hasExtension(defaultSfixed64Extension));
   1810     Assert.assertFalse(message.hasExtension(defaultFloatExtension   ));
   1811     Assert.assertFalse(message.hasExtension(defaultDoubleExtension  ));
   1812     Assert.assertFalse(message.hasExtension(defaultBoolExtension    ));
   1813     Assert.assertFalse(message.hasExtension(defaultStringExtension  ));
   1814     Assert.assertFalse(message.hasExtension(defaultBytesExtension   ));
   1815 
   1816     Assert.assertFalse(message.hasExtension(defaultNestedEnumExtension ));
   1817     Assert.assertFalse(message.hasExtension(defaultForeignEnumExtension));
   1818     Assert.assertFalse(message.hasExtension(defaultImportEnumExtension ));
   1819 
   1820     Assert.assertFalse(message.hasExtension(defaultStringPieceExtension));
   1821     Assert.assertFalse(message.hasExtension(defaultCordExtension));
   1822 
   1823     // Fields with defaults have their default values (duh).
   1824     assertEqualsExactType( 41    , message.getExtension(defaultInt32Extension   ));
   1825     assertEqualsExactType( 42L   , message.getExtension(defaultInt64Extension   ));
   1826     assertEqualsExactType( 43    , message.getExtension(defaultUint32Extension  ));
   1827     assertEqualsExactType( 44L   , message.getExtension(defaultUint64Extension  ));
   1828     assertEqualsExactType(-45    , message.getExtension(defaultSint32Extension  ));
   1829     assertEqualsExactType( 46L   , message.getExtension(defaultSint64Extension  ));
   1830     assertEqualsExactType( 47    , message.getExtension(defaultFixed32Extension ));
   1831     assertEqualsExactType( 48L   , message.getExtension(defaultFixed64Extension ));
   1832     assertEqualsExactType( 49    , message.getExtension(defaultSfixed32Extension));
   1833     assertEqualsExactType(-50L   , message.getExtension(defaultSfixed64Extension));
   1834     assertEqualsExactType( 51.5F , message.getExtension(defaultFloatExtension   ));
   1835     assertEqualsExactType( 52e3D , message.getExtension(defaultDoubleExtension  ));
   1836     assertEqualsExactType(true   , message.getExtension(defaultBoolExtension    ));
   1837     assertEqualsExactType("hello", message.getExtension(defaultStringExtension  ));
   1838     assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExtension));
   1839 
   1840     assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
   1841       message.getExtension(defaultNestedEnumExtension ));
   1842     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
   1843       message.getExtension(defaultForeignEnumExtension));
   1844     assertEqualsExactType(ImportEnum.IMPORT_BAR,
   1845       message.getExtension(defaultImportEnumExtension));
   1846 
   1847     assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtension));
   1848     assertEqualsExactType("123", message.getExtension(defaultCordExtension));
   1849 
   1850     Assert.assertFalse(message.hasExtension(oneofUint32Extension));
   1851     Assert.assertFalse(message.hasExtension(oneofNestedMessageExtension));
   1852     Assert.assertFalse(message.hasExtension(oneofStringExtension));
   1853     Assert.assertFalse(message.hasExtension(oneofBytesExtension));
   1854   }
   1855 
   1856   // -------------------------------------------------------------------
   1857 
   1858   /**
   1859    * Assert (using {@code junit.framework.Assert}} that all extensions of
   1860    * {@code message} are set to the values assigned by {@code setAllExtensions}
   1861    * followed by {@code modifyRepeatedExtensions}.
   1862    */
   1863   public static void assertRepeatedExtensionsModified(
   1864       TestAllExtensionsOrBuilder message) {
   1865     // ModifyRepeatedFields only sets the second repeated element of each
   1866     // field.  In addition to verifying this, we also verify that the first
   1867     // element and size were *not* modified.
   1868     Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension   ));
   1869     Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension   ));
   1870     Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension  ));
   1871     Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension  ));
   1872     Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension  ));
   1873     Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension  ));
   1874     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension ));
   1875     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension ));
   1876     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension));
   1877     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension));
   1878     Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension   ));
   1879     Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension  ));
   1880     Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension    ));
   1881     Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension  ));
   1882     Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension   ));
   1883 
   1884     Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension         ));
   1885     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension ));
   1886     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension));
   1887     Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension ));
   1888     Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtension   ));
   1889     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension    ));
   1890     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension   ));
   1891     Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension    ));
   1892 
   1893     Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension));
   1894     Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension));
   1895 
   1896     assertEqualsExactType(201  , message.getExtension(repeatedInt32Extension   , 0));
   1897     assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension   , 0));
   1898     assertEqualsExactType(203  , message.getExtension(repeatedUint32Extension  , 0));
   1899     assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension  , 0));
   1900     assertEqualsExactType(205  , message.getExtension(repeatedSint32Extension  , 0));
   1901     assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension  , 0));
   1902     assertEqualsExactType(207  , message.getExtension(repeatedFixed32Extension , 0));
   1903     assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension , 0));
   1904     assertEqualsExactType(209  , message.getExtension(repeatedSfixed32Extension, 0));
   1905     assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension, 0));
   1906     assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension   , 0));
   1907     assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension  , 0));
   1908     assertEqualsExactType(true , message.getExtension(repeatedBoolExtension    , 0));
   1909     assertEqualsExactType("215", message.getExtension(repeatedStringExtension  , 0));
   1910     assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0));
   1911 
   1912     assertEqualsExactType(217, message.getExtension(repeatedGroupExtension         , 0).getA());
   1913     assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb());
   1914     assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC());
   1915     assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD());
   1916     assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension   , 0).getBb());
   1917 
   1918     assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
   1919       message.getExtension(repeatedNestedEnumExtension, 0));
   1920     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
   1921       message.getExtension(repeatedForeignEnumExtension, 0));
   1922     assertEqualsExactType(ImportEnum.IMPORT_BAR,
   1923       message.getExtension(repeatedImportEnumExtension, 0));
   1924 
   1925     assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0));
   1926     assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0));
   1927 
   1928     // Actually verify the second (modified) elements now.
   1929     assertEqualsExactType(501  , message.getExtension(repeatedInt32Extension   , 1));
   1930     assertEqualsExactType(502L , message.getExtension(repeatedInt64Extension   , 1));
   1931     assertEqualsExactType(503  , message.getExtension(repeatedUint32Extension  , 1));
   1932     assertEqualsExactType(504L , message.getExtension(repeatedUint64Extension  , 1));
   1933     assertEqualsExactType(505  , message.getExtension(repeatedSint32Extension  , 1));
   1934     assertEqualsExactType(506L , message.getExtension(repeatedSint64Extension  , 1));
   1935     assertEqualsExactType(507  , message.getExtension(repeatedFixed32Extension , 1));
   1936     assertEqualsExactType(508L , message.getExtension(repeatedFixed64Extension , 1));
   1937     assertEqualsExactType(509  , message.getExtension(repeatedSfixed32Extension, 1));
   1938     assertEqualsExactType(510L , message.getExtension(repeatedSfixed64Extension, 1));
   1939     assertEqualsExactType(511F , message.getExtension(repeatedFloatExtension   , 1));
   1940     assertEqualsExactType(512D , message.getExtension(repeatedDoubleExtension  , 1));
   1941     assertEqualsExactType(true , message.getExtension(repeatedBoolExtension    , 1));
   1942     assertEqualsExactType("515", message.getExtension(repeatedStringExtension  , 1));
   1943     assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExtension, 1));
   1944 
   1945     assertEqualsExactType(517, message.getExtension(repeatedGroupExtension         , 1).getA());
   1946     assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtension , 1).getBb());
   1947     assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtension, 1).getC());
   1948     assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtension , 1).getD());
   1949     assertEqualsExactType(527, message.getExtension(repeatedLazyMessageExtension   , 1).getBb());
   1950 
   1951     assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
   1952       message.getExtension(repeatedNestedEnumExtension, 1));
   1953     assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
   1954       message.getExtension(repeatedForeignEnumExtension, 1));
   1955     assertEqualsExactType(ImportEnum.IMPORT_FOO,
   1956       message.getExtension(repeatedImportEnumExtension, 1));
   1957 
   1958     assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtension, 1));
   1959     assertEqualsExactType("525", message.getExtension(repeatedCordExtension, 1));
   1960   }
   1961 
   1962   public static void setPackedExtensions(TestPackedExtensions.Builder message) {
   1963     message.addExtension(packedInt32Extension   , 601);
   1964     message.addExtension(packedInt64Extension   , 602L);
   1965     message.addExtension(packedUint32Extension  , 603);
   1966     message.addExtension(packedUint64Extension  , 604L);
   1967     message.addExtension(packedSint32Extension  , 605);
   1968     message.addExtension(packedSint64Extension  , 606L);
   1969     message.addExtension(packedFixed32Extension , 607);
   1970     message.addExtension(packedFixed64Extension , 608L);
   1971     message.addExtension(packedSfixed32Extension, 609);
   1972     message.addExtension(packedSfixed64Extension, 610L);
   1973     message.addExtension(packedFloatExtension   , 611F);
   1974     message.addExtension(packedDoubleExtension  , 612D);
   1975     message.addExtension(packedBoolExtension    , true);
   1976     message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAR);
   1977     // Add a second one of each field.
   1978     message.addExtension(packedInt32Extension   , 701);
   1979     message.addExtension(packedInt64Extension   , 702L);
   1980     message.addExtension(packedUint32Extension  , 703);
   1981     message.addExtension(packedUint64Extension  , 704L);
   1982     message.addExtension(packedSint32Extension  , 705);
   1983     message.addExtension(packedSint64Extension  , 706L);
   1984     message.addExtension(packedFixed32Extension , 707);
   1985     message.addExtension(packedFixed64Extension , 708L);
   1986     message.addExtension(packedSfixed32Extension, 709);
   1987     message.addExtension(packedSfixed64Extension, 710L);
   1988     message.addExtension(packedFloatExtension   , 711F);
   1989     message.addExtension(packedDoubleExtension  , 712D);
   1990     message.addExtension(packedBoolExtension    , false);
   1991     message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAZ);
   1992   }
   1993 
   1994   public static void assertPackedExtensionsSet(TestPackedExtensions message) {
   1995     Assert.assertEquals(2, message.getExtensionCount(packedInt32Extension   ));
   1996     Assert.assertEquals(2, message.getExtensionCount(packedInt64Extension   ));
   1997     Assert.assertEquals(2, message.getExtensionCount(packedUint32Extension  ));
   1998     Assert.assertEquals(2, message.getExtensionCount(packedUint64Extension  ));
   1999     Assert.assertEquals(2, message.getExtensionCount(packedSint32Extension  ));
   2000     Assert.assertEquals(2, message.getExtensionCount(packedSint64Extension  ));
   2001     Assert.assertEquals(2, message.getExtensionCount(packedFixed32Extension ));
   2002     Assert.assertEquals(2, message.getExtensionCount(packedFixed64Extension ));
   2003     Assert.assertEquals(2, message.getExtensionCount(packedSfixed32Extension));
   2004     Assert.assertEquals(2, message.getExtensionCount(packedSfixed64Extension));
   2005     Assert.assertEquals(2, message.getExtensionCount(packedFloatExtension   ));
   2006     Assert.assertEquals(2, message.getExtensionCount(packedDoubleExtension  ));
   2007     Assert.assertEquals(2, message.getExtensionCount(packedBoolExtension    ));
   2008     Assert.assertEquals(2, message.getExtensionCount(packedEnumExtension));
   2009     assertEqualsExactType(601  , message.getExtension(packedInt32Extension   , 0));
   2010     assertEqualsExactType(602L , message.getExtension(packedInt64Extension   , 0));
   2011     assertEqualsExactType(603  , message.getExtension(packedUint32Extension  , 0));
   2012     assertEqualsExactType(604L , message.getExtension(packedUint64Extension  , 0));
   2013     assertEqualsExactType(605  , message.getExtension(packedSint32Extension  , 0));
   2014     assertEqualsExactType(606L , message.getExtension(packedSint64Extension  , 0));
   2015     assertEqualsExactType(607  , message.getExtension(packedFixed32Extension , 0));
   2016     assertEqualsExactType(608L , message.getExtension(packedFixed64Extension , 0));
   2017     assertEqualsExactType(609  , message.getExtension(packedSfixed32Extension, 0));
   2018     assertEqualsExactType(610L , message.getExtension(packedSfixed64Extension, 0));
   2019     assertEqualsExactType(611F , message.getExtension(packedFloatExtension   , 0));
   2020     assertEqualsExactType(612D , message.getExtension(packedDoubleExtension  , 0));
   2021     assertEqualsExactType(true , message.getExtension(packedBoolExtension    , 0));
   2022     assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
   2023                           message.getExtension(packedEnumExtension, 0));
   2024     assertEqualsExactType(701  , message.getExtension(packedInt32Extension   , 1));
   2025     assertEqualsExactType(702L , message.getExtension(packedInt64Extension   , 1));
   2026     assertEqualsExactType(703  , message.getExtension(packedUint32Extension  , 1));
   2027     assertEqualsExactType(704L , message.getExtension(packedUint64Extension  , 1));
   2028     assertEqualsExactType(705  , message.getExtension(packedSint32Extension  , 1));
   2029     assertEqualsExactType(706L , message.getExtension(packedSint64Extension  , 1));
   2030     assertEqualsExactType(707  , message.getExtension(packedFixed32Extension , 1));
   2031     assertEqualsExactType(708L , message.getExtension(packedFixed64Extension , 1));
   2032     assertEqualsExactType(709  , message.getExtension(packedSfixed32Extension, 1));
   2033     assertEqualsExactType(710L , message.getExtension(packedSfixed64Extension, 1));
   2034     assertEqualsExactType(711F , message.getExtension(packedFloatExtension   , 1));
   2035     assertEqualsExactType(712D , message.getExtension(packedDoubleExtension  , 1));
   2036     assertEqualsExactType(false, message.getExtension(packedBoolExtension    , 1));
   2037     assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
   2038                           message.getExtension(packedEnumExtension, 1));
   2039   }
   2040 
   2041   // ===================================================================
   2042   // Lite extensions
   2043 
   2044   /**
   2045    * Set every field of {@code message} to the values expected by
   2046    * {@code assertAllExtensionsSet()}.
   2047    */
   2048   public static void setAllExtensions(TestAllExtensionsLite.Builder message) {
   2049     message.setExtension(optionalInt32ExtensionLite   , 101);
   2050     message.setExtension(optionalInt64ExtensionLite   , 102L);
   2051     message.setExtension(optionalUint32ExtensionLite  , 103);
   2052     message.setExtension(optionalUint64ExtensionLite  , 104L);
   2053     message.setExtension(optionalSint32ExtensionLite  , 105);
   2054     message.setExtension(optionalSint64ExtensionLite  , 106L);
   2055     message.setExtension(optionalFixed32ExtensionLite , 107);
   2056     message.setExtension(optionalFixed64ExtensionLite , 108L);
   2057     message.setExtension(optionalSfixed32ExtensionLite, 109);
   2058     message.setExtension(optionalSfixed64ExtensionLite, 110L);
   2059     message.setExtension(optionalFloatExtensionLite   , 111F);
   2060     message.setExtension(optionalDoubleExtensionLite  , 112D);
   2061     message.setExtension(optionalBoolExtensionLite    , true);
   2062     message.setExtension(optionalStringExtensionLite  , "115");
   2063     message.setExtension(optionalBytesExtensionLite   , toBytes("116"));
   2064 
   2065     message.setExtension(optionalGroupExtensionLite,
   2066       OptionalGroup_extension_lite.newBuilder().setA(117).build());
   2067     message.setExtension(optionalNestedMessageExtensionLite,
   2068       TestAllTypesLite.NestedMessage.newBuilder().setBb(118).build());
   2069     message.setExtension(optionalForeignMessageExtensionLite,
   2070       ForeignMessageLite.newBuilder().setC(119).build());
   2071     message.setExtension(optionalImportMessageExtensionLite,
   2072       ImportMessageLite.newBuilder().setD(120).build());
   2073     message.setExtension(optionalPublicImportMessageExtensionLite,
   2074       PublicImportMessageLite.newBuilder().setE(126).build());
   2075     message.setExtension(optionalLazyMessageExtensionLite,
   2076       TestAllTypesLite.NestedMessage.newBuilder().setBb(127).build());
   2077 
   2078     message.setExtension(optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ);
   2079     message.setExtension(optionalForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);
   2080     message.setExtension(optionalImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ);
   2081 
   2082     message.setExtension(optionalStringPieceExtensionLite, "124");
   2083     message.setExtension(optionalCordExtensionLite, "125");
   2084 
   2085     // -----------------------------------------------------------------
   2086 
   2087     message.addExtension(repeatedInt32ExtensionLite   , 201);
   2088     message.addExtension(repeatedInt64ExtensionLite   , 202L);
   2089     message.addExtension(repeatedUint32ExtensionLite  , 203);
   2090     message.addExtension(repeatedUint64ExtensionLite  , 204L);
   2091     message.addExtension(repeatedSint32ExtensionLite  , 205);
   2092     message.addExtension(repeatedSint64ExtensionLite  , 206L);
   2093     message.addExtension(repeatedFixed32ExtensionLite , 207);
   2094     message.addExtension(repeatedFixed64ExtensionLite , 208L);
   2095     message.addExtension(repeatedSfixed32ExtensionLite, 209);
   2096     message.addExtension(repeatedSfixed64ExtensionLite, 210L);
   2097     message.addExtension(repeatedFloatExtensionLite   , 211F);
   2098     message.addExtension(repeatedDoubleExtensionLite  , 212D);
   2099     message.addExtension(repeatedBoolExtensionLite    , true);
   2100     message.addExtension(repeatedStringExtensionLite  , "215");
   2101     message.addExtension(repeatedBytesExtensionLite   , toBytes("216"));
   2102 
   2103     message.addExtension(repeatedGroupExtensionLite,
   2104       RepeatedGroup_extension_lite.newBuilder().setA(217).build());
   2105     message.addExtension(repeatedNestedMessageExtensionLite,
   2106       TestAllTypesLite.NestedMessage.newBuilder().setBb(218).build());
   2107     message.addExtension(repeatedForeignMessageExtensionLite,
   2108       ForeignMessageLite.newBuilder().setC(219).build());
   2109     message.addExtension(repeatedImportMessageExtensionLite,
   2110       ImportMessageLite.newBuilder().setD(220).build());
   2111     message.addExtension(repeatedLazyMessageExtensionLite,
   2112       TestAllTypesLite.NestedMessage.newBuilder().setBb(227).build());
   2113 
   2114     message.addExtension(repeatedNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAR);
   2115     message.addExtension(repeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAR);
   2116     message.addExtension(repeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAR);
   2117 
   2118     message.addExtension(repeatedStringPieceExtensionLite, "224");
   2119     message.addExtension(repeatedCordExtensionLite, "225");
   2120 
   2121     // Add a second one of each field.
   2122     message.addExtension(repeatedInt32ExtensionLite   , 301);
   2123     message.addExtension(repeatedInt64ExtensionLite   , 302L);
   2124     message.addExtension(repeatedUint32ExtensionLite  , 303);
   2125     message.addExtension(repeatedUint64ExtensionLite  , 304L);
   2126     message.addExtension(repeatedSint32ExtensionLite  , 305);
   2127     message.addExtension(repeatedSint64ExtensionLite  , 306L);
   2128     message.addExtension(repeatedFixed32ExtensionLite , 307);
   2129     message.addExtension(repeatedFixed64ExtensionLite , 308L);
   2130     message.addExtension(repeatedSfixed32ExtensionLite, 309);
   2131     message.addExtension(repeatedSfixed64ExtensionLite, 310L);
   2132     message.addExtension(repeatedFloatExtensionLite   , 311F);
   2133     message.addExtension(repeatedDoubleExtensionLite  , 312D);
   2134     message.addExtension(repeatedBoolExtensionLite    , false);
   2135     message.addExtension(repeatedStringExtensionLite  , "315");
   2136     message.addExtension(repeatedBytesExtensionLite   , toBytes("316"));
   2137 
   2138     message.addExtension(repeatedGroupExtensionLite,
   2139       RepeatedGroup_extension_lite.newBuilder().setA(317).build());
   2140     message.addExtension(repeatedNestedMessageExtensionLite,
   2141       TestAllTypesLite.NestedMessage.newBuilder().setBb(318).build());
   2142     message.addExtension(repeatedForeignMessageExtensionLite,
   2143       ForeignMessageLite.newBuilder().setC(319).build());
   2144     message.addExtension(repeatedImportMessageExtensionLite,
   2145       ImportMessageLite.newBuilder().setD(320).build());
   2146     message.addExtension(repeatedLazyMessageExtensionLite,
   2147       TestAllTypesLite.NestedMessage.newBuilder().setBb(327).build());
   2148 
   2149     message.addExtension(repeatedNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ);
   2150     message.addExtension(repeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);
   2151     message.addExtension(repeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ);
   2152 
   2153     message.addExtension(repeatedStringPieceExtensionLite, "324");
   2154     message.addExtension(repeatedCordExtensionLite, "325");
   2155 
   2156     // -----------------------------------------------------------------
   2157 
   2158     message.setExtension(defaultInt32ExtensionLite   , 401);
   2159     message.setExtension(defaultInt64ExtensionLite   , 402L);
   2160     message.setExtension(defaultUint32ExtensionLite  , 403);
   2161     message.setExtension(defaultUint64ExtensionLite  , 404L);
   2162     message.setExtension(defaultSint32ExtensionLite  , 405);
   2163     message.setExtension(defaultSint64ExtensionLite  , 406L);
   2164     message.setExtension(defaultFixed32ExtensionLite , 407);
   2165     message.setExtension(defaultFixed64ExtensionLite , 408L);
   2166     message.setExtension(defaultSfixed32ExtensionLite, 409);
   2167     message.setExtension(defaultSfixed64ExtensionLite, 410L);
   2168     message.setExtension(defaultFloatExtensionLite   , 411F);
   2169     message.setExtension(defaultDoubleExtensionLite  , 412D);
   2170     message.setExtension(defaultBoolExtensionLite    , false);
   2171     message.setExtension(defaultStringExtensionLite  , "415");
   2172     message.setExtension(defaultBytesExtensionLite   , toBytes("416"));
   2173 
   2174     message.setExtension(defaultNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.FOO);
   2175     message.setExtension(defaultForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_FOO);
   2176     message.setExtension(defaultImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_FOO);
   2177 
   2178     message.setExtension(defaultStringPieceExtensionLite, "424");
   2179     message.setExtension(defaultCordExtensionLite, "425");
   2180 
   2181     message.setExtension(oneofUint32ExtensionLite, 601);
   2182     message.setExtension(oneofNestedMessageExtensionLite,
   2183       TestAllTypesLite.NestedMessage.newBuilder().setBb(602).build());
   2184     message.setExtension(oneofStringExtensionLite, "603");
   2185     message.setExtension(oneofBytesExtensionLite, toBytes("604"));
   2186   }
   2187 
   2188   // -------------------------------------------------------------------
   2189 
   2190   /**
   2191    * Modify the repeated extensions of {@code message} to contain the values
   2192    * expected by {@code assertRepeatedExtensionsModified()}.
   2193    */
   2194   public static void modifyRepeatedExtensions(
   2195       TestAllExtensionsLite.Builder message) {
   2196     message.setExtension(repeatedInt32ExtensionLite   , 1, 501);
   2197     message.setExtension(repeatedInt64ExtensionLite   , 1, 502L);
   2198     message.setExtension(repeatedUint32ExtensionLite  , 1, 503);
   2199     message.setExtension(repeatedUint64ExtensionLite  , 1, 504L);
   2200     message.setExtension(repeatedSint32ExtensionLite  , 1, 505);
   2201     message.setExtension(repeatedSint64ExtensionLite  , 1, 506L);
   2202     message.setExtension(repeatedFixed32ExtensionLite , 1, 507);
   2203     message.setExtension(repeatedFixed64ExtensionLite , 1, 508L);
   2204     message.setExtension(repeatedSfixed32ExtensionLite, 1, 509);
   2205     message.setExtension(repeatedSfixed64ExtensionLite, 1, 510L);
   2206     message.setExtension(repeatedFloatExtensionLite   , 1, 511F);
   2207     message.setExtension(repeatedDoubleExtensionLite  , 1, 512D);
   2208     message.setExtension(repeatedBoolExtensionLite    , 1, true);
   2209     message.setExtension(repeatedStringExtensionLite  , 1, "515");
   2210     message.setExtension(repeatedBytesExtensionLite   , 1, toBytes("516"));
   2211 
   2212     message.setExtension(repeatedGroupExtensionLite, 1,
   2213       RepeatedGroup_extension_lite.newBuilder().setA(517).build());
   2214     message.setExtension(repeatedNestedMessageExtensionLite, 1,
   2215       TestAllTypesLite.NestedMessage.newBuilder().setBb(518).build());
   2216     message.setExtension(repeatedForeignMessageExtensionLite, 1,
   2217       ForeignMessageLite.newBuilder().setC(519).build());
   2218     message.setExtension(repeatedImportMessageExtensionLite, 1,
   2219       ImportMessageLite.newBuilder().setD(520).build());
   2220     message.setExtension(repeatedLazyMessageExtensionLite, 1,
   2221       TestAllTypesLite.NestedMessage.newBuilder().setBb(527).build());
   2222 
   2223     message.setExtension(repeatedNestedEnumExtensionLite , 1, TestAllTypesLite.NestedEnum.FOO);
   2224     message.setExtension(repeatedForeignEnumExtensionLite, 1, ForeignEnumLite.FOREIGN_LITE_FOO);
   2225     message.setExtension(repeatedImportEnumExtensionLite , 1, ImportEnumLite.IMPORT_LITE_FOO);
   2226 
   2227     message.setExtension(repeatedStringPieceExtensionLite, 1, "524");
   2228     message.setExtension(repeatedCordExtensionLite, 1, "525");
   2229   }
   2230 
   2231   // -------------------------------------------------------------------
   2232 
   2233   /**
   2234    * Assert (using {@code junit.framework.Assert}} that all extensions of
   2235    * {@code message} are set to the values assigned by {@code setAllExtensions}.
   2236    */
   2237   public static void assertAllExtensionsSet(
   2238       TestAllExtensionsLiteOrBuilder message) {
   2239     Assert.assertTrue(message.hasExtension(optionalInt32ExtensionLite   ));
   2240     Assert.assertTrue(message.hasExtension(optionalInt64ExtensionLite   ));
   2241     Assert.assertTrue(message.hasExtension(optionalUint32ExtensionLite  ));
   2242     Assert.assertTrue(message.hasExtension(optionalUint64ExtensionLite  ));
   2243     Assert.assertTrue(message.hasExtension(optionalSint32ExtensionLite  ));
   2244     Assert.assertTrue(message.hasExtension(optionalSint64ExtensionLite  ));
   2245     Assert.assertTrue(message.hasExtension(optionalFixed32ExtensionLite ));
   2246     Assert.assertTrue(message.hasExtension(optionalFixed64ExtensionLite ));
   2247     Assert.assertTrue(message.hasExtension(optionalSfixed32ExtensionLite));
   2248     Assert.assertTrue(message.hasExtension(optionalSfixed64ExtensionLite));
   2249     Assert.assertTrue(message.hasExtension(optionalFloatExtensionLite   ));
   2250     Assert.assertTrue(message.hasExtension(optionalDoubleExtensionLite  ));
   2251     Assert.assertTrue(message.hasExtension(optionalBoolExtensionLite    ));
   2252     Assert.assertTrue(message.hasExtension(optionalStringExtensionLite  ));
   2253     Assert.assertTrue(message.hasExtension(optionalBytesExtensionLite   ));
   2254 
   2255     Assert.assertTrue(message.hasExtension(optionalGroupExtensionLite         ));
   2256     Assert.assertTrue(message.hasExtension(optionalNestedMessageExtensionLite ));
   2257     Assert.assertTrue(message.hasExtension(optionalForeignMessageExtensionLite));
   2258     Assert.assertTrue(message.hasExtension(optionalImportMessageExtensionLite ));
   2259 
   2260     Assert.assertTrue(message.getExtension(optionalGroupExtensionLite         ).hasA());
   2261     Assert.assertTrue(message.getExtension(optionalNestedMessageExtensionLite ).hasBb());
   2262     Assert.assertTrue(message.getExtension(optionalForeignMessageExtensionLite).hasC());
   2263     Assert.assertTrue(message.getExtension(optionalImportMessageExtensionLite ).hasD());
   2264 
   2265     Assert.assertTrue(message.hasExtension(optionalNestedEnumExtensionLite ));
   2266     Assert.assertTrue(message.hasExtension(optionalForeignEnumExtensionLite));
   2267     Assert.assertTrue(message.hasExtension(optionalImportEnumExtensionLite ));
   2268 
   2269     Assert.assertTrue(message.hasExtension(optionalStringPieceExtensionLite));
   2270     Assert.assertTrue(message.hasExtension(optionalCordExtensionLite));
   2271 
   2272     assertEqualsExactType(101  , message.getExtension(optionalInt32ExtensionLite   ));
   2273     assertEqualsExactType(102L , message.getExtension(optionalInt64ExtensionLite   ));
   2274     assertEqualsExactType(103  , message.getExtension(optionalUint32ExtensionLite  ));
   2275     assertEqualsExactType(104L , message.getExtension(optionalUint64ExtensionLite  ));
   2276     assertEqualsExactType(105  , message.getExtension(optionalSint32ExtensionLite  ));
   2277     assertEqualsExactType(106L , message.getExtension(optionalSint64ExtensionLite  ));
   2278     assertEqualsExactType(107  , message.getExtension(optionalFixed32ExtensionLite ));
   2279     assertEqualsExactType(108L , message.getExtension(optionalFixed64ExtensionLite ));
   2280     assertEqualsExactType(109  , message.getExtension(optionalSfixed32ExtensionLite));
   2281     assertEqualsExactType(110L , message.getExtension(optionalSfixed64ExtensionLite));
   2282     assertEqualsExactType(111F , message.getExtension(optionalFloatExtensionLite   ));
   2283     assertEqualsExactType(112D , message.getExtension(optionalDoubleExtensionLite  ));
   2284     assertEqualsExactType(true , message.getExtension(optionalBoolExtensionLite    ));
   2285     assertEqualsExactType("115", message.getExtension(optionalStringExtensionLite  ));
   2286     assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExtensionLite));
   2287 
   2288     assertEqualsExactType(117, message.getExtension(optionalGroupExtensionLite         ).getA());
   2289     assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtensionLite ).getBb());
   2290     assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtensionLite).getC());
   2291     assertEqualsExactType(120, message.getExtension(optionalImportMessageExtensionLite ).getD());
   2292     assertEqualsExactType(126, message.getExtension(
   2293         optionalPublicImportMessageExtensionLite).getE());
   2294     assertEqualsExactType(127, message.getExtension(optionalLazyMessageExtensionLite).getBb());
   2295 
   2296     assertEqualsExactType(TestAllTypesLite.NestedEnum.BAZ,
   2297       message.getExtension(optionalNestedEnumExtensionLite));
   2298     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAZ,
   2299       message.getExtension(optionalForeignEnumExtensionLite));
   2300     assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAZ,
   2301       message.getExtension(optionalImportEnumExtensionLite));
   2302 
   2303     assertEqualsExactType("124", message.getExtension(optionalStringPieceExtensionLite));
   2304     assertEqualsExactType("125", message.getExtension(optionalCordExtensionLite));
   2305 
   2306     // -----------------------------------------------------------------
   2307 
   2308     Assert.assertEquals(2, message.getExtensionCount(repeatedInt32ExtensionLite   ));
   2309     Assert.assertEquals(2, message.getExtensionCount(repeatedInt64ExtensionLite   ));
   2310     Assert.assertEquals(2, message.getExtensionCount(repeatedUint32ExtensionLite  ));
   2311     Assert.assertEquals(2, message.getExtensionCount(repeatedUint64ExtensionLite  ));
   2312     Assert.assertEquals(2, message.getExtensionCount(repeatedSint32ExtensionLite  ));
   2313     Assert.assertEquals(2, message.getExtensionCount(repeatedSint64ExtensionLite  ));
   2314     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32ExtensionLite ));
   2315     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64ExtensionLite ));
   2316     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32ExtensionLite));
   2317     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64ExtensionLite));
   2318     Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtensionLite   ));
   2319     Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtensionLite  ));
   2320     Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtensionLite    ));
   2321     Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtensionLite  ));
   2322     Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtensionLite   ));
   2323 
   2324     Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtensionLite         ));
   2325     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtensionLite ));
   2326     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtensionLite));
   2327     Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtensionLite ));
   2328     Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtensionLite   ));
   2329     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtensionLite    ));
   2330     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensionLite   ));
   2331     Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtensionLite    ));
   2332 
   2333     Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensionLite));
   2334     Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtensionLite));
   2335 
   2336     assertEqualsExactType(201  , message.getExtension(repeatedInt32ExtensionLite   , 0));
   2337     assertEqualsExactType(202L , message.getExtension(repeatedInt64ExtensionLite   , 0));
   2338     assertEqualsExactType(203  , message.getExtension(repeatedUint32ExtensionLite  , 0));
   2339     assertEqualsExactType(204L , message.getExtension(repeatedUint64ExtensionLite  , 0));
   2340     assertEqualsExactType(205  , message.getExtension(repeatedSint32ExtensionLite  , 0));
   2341     assertEqualsExactType(206L , message.getExtension(repeatedSint64ExtensionLite  , 0));
   2342     assertEqualsExactType(207  , message.getExtension(repeatedFixed32ExtensionLite , 0));
   2343     assertEqualsExactType(208L , message.getExtension(repeatedFixed64ExtensionLite , 0));
   2344     assertEqualsExactType(209  , message.getExtension(repeatedSfixed32ExtensionLite, 0));
   2345     assertEqualsExactType(210L , message.getExtension(repeatedSfixed64ExtensionLite, 0));
   2346     assertEqualsExactType(211F , message.getExtension(repeatedFloatExtensionLite   , 0));
   2347     assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtensionLite  , 0));
   2348     assertEqualsExactType(true , message.getExtension(repeatedBoolExtensionLite    , 0));
   2349     assertEqualsExactType("215", message.getExtension(repeatedStringExtensionLite  , 0));
   2350     assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtensionLite, 0));
   2351 
   2352     assertEqualsExactType(217, message.getExtension(repeatedGroupExtensionLite         ,0).getA());
   2353     assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensionLite ,0).getBb());
   2354     assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtensionLite,0).getC());
   2355     assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensionLite ,0).getD());
   2356     assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtensionLite   ,0).getBb());
   2357 
   2358     assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,
   2359       message.getExtension(repeatedNestedEnumExtensionLite, 0));
   2360     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
   2361       message.getExtension(repeatedForeignEnumExtensionLite, 0));
   2362     assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAR,
   2363       message.getExtension(repeatedImportEnumExtensionLite, 0));
   2364 
   2365     assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensionLite, 0));
   2366     assertEqualsExactType("225", message.getExtension(repeatedCordExtensionLite, 0));
   2367 
   2368     assertEqualsExactType(301  , message.getExtension(repeatedInt32ExtensionLite   , 1));
   2369     assertEqualsExactType(302L , message.getExtension(repeatedInt64ExtensionLite   , 1));
   2370     assertEqualsExactType(303  , message.getExtension(repeatedUint32ExtensionLite  , 1));
   2371     assertEqualsExactType(304L , message.getExtension(repeatedUint64ExtensionLite  , 1));
   2372     assertEqualsExactType(305  , message.getExtension(repeatedSint32ExtensionLite  , 1));
   2373     assertEqualsExactType(306L , message.getExtension(repeatedSint64ExtensionLite  , 1));
   2374     assertEqualsExactType(307  , message.getExtension(repeatedFixed32ExtensionLite , 1));
   2375     assertEqualsExactType(308L , message.getExtension(repeatedFixed64ExtensionLite , 1));
   2376     assertEqualsExactType(309  , message.getExtension(repeatedSfixed32ExtensionLite, 1));
   2377     assertEqualsExactType(310L , message.getExtension(repeatedSfixed64ExtensionLite, 1));
   2378     assertEqualsExactType(311F , message.getExtension(repeatedFloatExtensionLite   , 1));
   2379     assertEqualsExactType(312D , message.getExtension(repeatedDoubleExtensionLite  , 1));
   2380     assertEqualsExactType(false, message.getExtension(repeatedBoolExtensionLite    , 1));
   2381     assertEqualsExactType("315", message.getExtension(repeatedStringExtensionLite  , 1));
   2382     assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExtensionLite, 1));
   2383 
   2384     assertEqualsExactType(317, message.getExtension(repeatedGroupExtensionLite         ,1).getA());
   2385     assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtensionLite ,1).getBb());
   2386     assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtensionLite,1).getC());
   2387     assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtensionLite ,1).getD());
   2388     assertEqualsExactType(327, message.getExtension(repeatedLazyMessageExtensionLite   ,1).getBb());
   2389 
   2390     assertEqualsExactType(TestAllTypesLite.NestedEnum.BAZ,
   2391       message.getExtension(repeatedNestedEnumExtensionLite, 1));
   2392     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAZ,
   2393       message.getExtension(repeatedForeignEnumExtensionLite, 1));
   2394     assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAZ,
   2395       message.getExtension(repeatedImportEnumExtensionLite, 1));
   2396 
   2397     assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtensionLite, 1));
   2398     assertEqualsExactType("325", message.getExtension(repeatedCordExtensionLite, 1));
   2399 
   2400     // -----------------------------------------------------------------
   2401 
   2402     Assert.assertTrue(message.hasExtension(defaultInt32ExtensionLite   ));
   2403     Assert.assertTrue(message.hasExtension(defaultInt64ExtensionLite   ));
   2404     Assert.assertTrue(message.hasExtension(defaultUint32ExtensionLite  ));
   2405     Assert.assertTrue(message.hasExtension(defaultUint64ExtensionLite  ));
   2406     Assert.assertTrue(message.hasExtension(defaultSint32ExtensionLite  ));
   2407     Assert.assertTrue(message.hasExtension(defaultSint64ExtensionLite  ));
   2408     Assert.assertTrue(message.hasExtension(defaultFixed32ExtensionLite ));
   2409     Assert.assertTrue(message.hasExtension(defaultFixed64ExtensionLite ));
   2410     Assert.assertTrue(message.hasExtension(defaultSfixed32ExtensionLite));
   2411     Assert.assertTrue(message.hasExtension(defaultSfixed64ExtensionLite));
   2412     Assert.assertTrue(message.hasExtension(defaultFloatExtensionLite   ));
   2413     Assert.assertTrue(message.hasExtension(defaultDoubleExtensionLite  ));
   2414     Assert.assertTrue(message.hasExtension(defaultBoolExtensionLite    ));
   2415     Assert.assertTrue(message.hasExtension(defaultStringExtensionLite  ));
   2416     Assert.assertTrue(message.hasExtension(defaultBytesExtensionLite   ));
   2417 
   2418     Assert.assertTrue(message.hasExtension(defaultNestedEnumExtensionLite ));
   2419     Assert.assertTrue(message.hasExtension(defaultForeignEnumExtensionLite));
   2420     Assert.assertTrue(message.hasExtension(defaultImportEnumExtensionLite ));
   2421 
   2422     Assert.assertTrue(message.hasExtension(defaultStringPieceExtensionLite));
   2423     Assert.assertTrue(message.hasExtension(defaultCordExtensionLite));
   2424 
   2425     assertEqualsExactType(401  , message.getExtension(defaultInt32ExtensionLite   ));
   2426     assertEqualsExactType(402L , message.getExtension(defaultInt64ExtensionLite   ));
   2427     assertEqualsExactType(403  , message.getExtension(defaultUint32ExtensionLite  ));
   2428     assertEqualsExactType(404L , message.getExtension(defaultUint64ExtensionLite  ));
   2429     assertEqualsExactType(405  , message.getExtension(defaultSint32ExtensionLite  ));
   2430     assertEqualsExactType(406L , message.getExtension(defaultSint64ExtensionLite  ));
   2431     assertEqualsExactType(407  , message.getExtension(defaultFixed32ExtensionLite ));
   2432     assertEqualsExactType(408L , message.getExtension(defaultFixed64ExtensionLite ));
   2433     assertEqualsExactType(409  , message.getExtension(defaultSfixed32ExtensionLite));
   2434     assertEqualsExactType(410L , message.getExtension(defaultSfixed64ExtensionLite));
   2435     assertEqualsExactType(411F , message.getExtension(defaultFloatExtensionLite   ));
   2436     assertEqualsExactType(412D , message.getExtension(defaultDoubleExtensionLite  ));
   2437     assertEqualsExactType(false, message.getExtension(defaultBoolExtensionLite    ));
   2438     assertEqualsExactType("415", message.getExtension(defaultStringExtensionLite  ));
   2439     assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExtensionLite));
   2440 
   2441     assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,
   2442       message.getExtension(defaultNestedEnumExtensionLite ));
   2443     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_FOO,
   2444       message.getExtension(defaultForeignEnumExtensionLite));
   2445     assertEqualsExactType(ImportEnumLite.IMPORT_LITE_FOO,
   2446       message.getExtension(defaultImportEnumExtensionLite));
   2447 
   2448     assertEqualsExactType("424", message.getExtension(defaultStringPieceExtensionLite));
   2449     assertEqualsExactType("425", message.getExtension(defaultCordExtensionLite));
   2450 
   2451     Assert.assertTrue(message.hasExtension(oneofBytesExtensionLite));
   2452 
   2453     assertEqualsExactType(toBytes("604"), message.getExtension(oneofBytesExtensionLite));
   2454   }
   2455 
   2456   // -------------------------------------------------------------------
   2457 
   2458   /**
   2459    * Assert (using {@code junit.framework.Assert}} that all extensions of
   2460    * {@code message} are cleared, and that getting the extensions returns their
   2461    * default values.
   2462    */
   2463   public static void assertExtensionsClear(
   2464       TestAllExtensionsLiteOrBuilder message) {
   2465     // hasBlah() should initially be false for all optional fields.
   2466     Assert.assertFalse(message.hasExtension(optionalInt32ExtensionLite   ));
   2467     Assert.assertFalse(message.hasExtension(optionalInt64ExtensionLite   ));
   2468     Assert.assertFalse(message.hasExtension(optionalUint32ExtensionLite  ));
   2469     Assert.assertFalse(message.hasExtension(optionalUint64ExtensionLite  ));
   2470     Assert.assertFalse(message.hasExtension(optionalSint32ExtensionLite  ));
   2471     Assert.assertFalse(message.hasExtension(optionalSint64ExtensionLite  ));
   2472     Assert.assertFalse(message.hasExtension(optionalFixed32ExtensionLite ));
   2473     Assert.assertFalse(message.hasExtension(optionalFixed64ExtensionLite ));
   2474     Assert.assertFalse(message.hasExtension(optionalSfixed32ExtensionLite));
   2475     Assert.assertFalse(message.hasExtension(optionalSfixed64ExtensionLite));
   2476     Assert.assertFalse(message.hasExtension(optionalFloatExtensionLite   ));
   2477     Assert.assertFalse(message.hasExtension(optionalDoubleExtensionLite  ));
   2478     Assert.assertFalse(message.hasExtension(optionalBoolExtensionLite    ));
   2479     Assert.assertFalse(message.hasExtension(optionalStringExtensionLite  ));
   2480     Assert.assertFalse(message.hasExtension(optionalBytesExtensionLite   ));
   2481 
   2482     Assert.assertFalse(message.hasExtension(optionalGroupExtensionLite              ));
   2483     Assert.assertFalse(message.hasExtension(optionalNestedMessageExtensionLite      ));
   2484     Assert.assertFalse(message.hasExtension(optionalForeignMessageExtensionLite     ));
   2485     Assert.assertFalse(message.hasExtension(optionalImportMessageExtensionLite      ));
   2486     Assert.assertFalse(message.hasExtension(optionalPublicImportMessageExtensionLite));
   2487     Assert.assertFalse(message.hasExtension(optionalLazyMessageExtensionLite        ));
   2488 
   2489     Assert.assertFalse(message.hasExtension(optionalNestedEnumExtensionLite ));
   2490     Assert.assertFalse(message.hasExtension(optionalForeignEnumExtensionLite));
   2491     Assert.assertFalse(message.hasExtension(optionalImportEnumExtensionLite ));
   2492 
   2493     Assert.assertFalse(message.hasExtension(optionalStringPieceExtensionLite));
   2494     Assert.assertFalse(message.hasExtension(optionalCordExtensionLite));
   2495 
   2496     // Optional fields without defaults are set to zero or something like it.
   2497     assertEqualsExactType(0    , message.getExtension(optionalInt32ExtensionLite   ));
   2498     assertEqualsExactType(0L   , message.getExtension(optionalInt64ExtensionLite   ));
   2499     assertEqualsExactType(0    , message.getExtension(optionalUint32ExtensionLite  ));
   2500     assertEqualsExactType(0L   , message.getExtension(optionalUint64ExtensionLite  ));
   2501     assertEqualsExactType(0    , message.getExtension(optionalSint32ExtensionLite  ));
   2502     assertEqualsExactType(0L   , message.getExtension(optionalSint64ExtensionLite  ));
   2503     assertEqualsExactType(0    , message.getExtension(optionalFixed32ExtensionLite ));
   2504     assertEqualsExactType(0L   , message.getExtension(optionalFixed64ExtensionLite ));
   2505     assertEqualsExactType(0    , message.getExtension(optionalSfixed32ExtensionLite));
   2506     assertEqualsExactType(0L   , message.getExtension(optionalSfixed64ExtensionLite));
   2507     assertEqualsExactType(0F   , message.getExtension(optionalFloatExtensionLite   ));
   2508     assertEqualsExactType(0D   , message.getExtension(optionalDoubleExtensionLite  ));
   2509     assertEqualsExactType(false, message.getExtension(optionalBoolExtensionLite    ));
   2510     assertEqualsExactType(""   , message.getExtension(optionalStringExtensionLite  ));
   2511     assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesExtensionLite));
   2512 
   2513     // Embedded messages should also be clear.
   2514     Assert.assertFalse(message.getExtension(optionalGroupExtensionLite              ).hasA());
   2515     Assert.assertFalse(message.getExtension(optionalNestedMessageExtensionLite      ).hasBb());
   2516     Assert.assertFalse(message.getExtension(optionalForeignMessageExtensionLite     ).hasC());
   2517     Assert.assertFalse(message.getExtension(optionalImportMessageExtensionLite      ).hasD());
   2518     Assert.assertFalse(message.getExtension(optionalPublicImportMessageExtensionLite).hasE());
   2519     Assert.assertFalse(message.getExtension(optionalLazyMessageExtensionLite        ).hasBb());
   2520 
   2521     assertEqualsExactType(0, message.getExtension(optionalGroupExtensionLite         ).getA());
   2522     assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtensionLite ).getBb());
   2523     assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtensionLite).getC());
   2524     assertEqualsExactType(0, message.getExtension(optionalImportMessageExtensionLite ).getD());
   2525     assertEqualsExactType(0, message.getExtension(
   2526         optionalPublicImportMessageExtensionLite).getE());
   2527     assertEqualsExactType(0, message.getExtension(optionalLazyMessageExtensionLite   ).getBb());
   2528 
   2529     // Enums without defaults are set to the first value in the enum.
   2530     assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,
   2531       message.getExtension(optionalNestedEnumExtensionLite ));
   2532     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_FOO,
   2533       message.getExtension(optionalForeignEnumExtensionLite));
   2534     assertEqualsExactType(ImportEnumLite.IMPORT_LITE_FOO,
   2535       message.getExtension(optionalImportEnumExtensionLite));
   2536 
   2537     assertEqualsExactType("", message.getExtension(optionalStringPieceExtensionLite));
   2538     assertEqualsExactType("", message.getExtension(optionalCordExtensionLite));
   2539 
   2540     // Repeated fields are empty.
   2541     Assert.assertEquals(0, message.getExtensionCount(repeatedInt32ExtensionLite   ));
   2542     Assert.assertEquals(0, message.getExtensionCount(repeatedInt64ExtensionLite   ));
   2543     Assert.assertEquals(0, message.getExtensionCount(repeatedUint32ExtensionLite  ));
   2544     Assert.assertEquals(0, message.getExtensionCount(repeatedUint64ExtensionLite  ));
   2545     Assert.assertEquals(0, message.getExtensionCount(repeatedSint32ExtensionLite  ));
   2546     Assert.assertEquals(0, message.getExtensionCount(repeatedSint64ExtensionLite  ));
   2547     Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32ExtensionLite ));
   2548     Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64ExtensionLite ));
   2549     Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32ExtensionLite));
   2550     Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64ExtensionLite));
   2551     Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtensionLite   ));
   2552     Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtensionLite  ));
   2553     Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtensionLite    ));
   2554     Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtensionLite  ));
   2555     Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtensionLite   ));
   2556 
   2557     Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtensionLite         ));
   2558     Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtensionLite ));
   2559     Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExtensionLite));
   2560     Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtensionLite ));
   2561     Assert.assertEquals(0, message.getExtensionCount(repeatedLazyMessageExtensionLite   ));
   2562     Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtensionLite    ));
   2563     Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtensionLite   ));
   2564     Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtensionLite    ));
   2565 
   2566     Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtensionLite));
   2567     Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtensionLite));
   2568 
   2569     // hasBlah() should also be false for all default fields.
   2570     Assert.assertFalse(message.hasExtension(defaultInt32ExtensionLite   ));
   2571     Assert.assertFalse(message.hasExtension(defaultInt64ExtensionLite   ));
   2572     Assert.assertFalse(message.hasExtension(defaultUint32ExtensionLite  ));
   2573     Assert.assertFalse(message.hasExtension(defaultUint64ExtensionLite  ));
   2574     Assert.assertFalse(message.hasExtension(defaultSint32ExtensionLite  ));
   2575     Assert.assertFalse(message.hasExtension(defaultSint64ExtensionLite  ));
   2576     Assert.assertFalse(message.hasExtension(defaultFixed32ExtensionLite ));
   2577     Assert.assertFalse(message.hasExtension(defaultFixed64ExtensionLite ));
   2578     Assert.assertFalse(message.hasExtension(defaultSfixed32ExtensionLite));
   2579     Assert.assertFalse(message.hasExtension(defaultSfixed64ExtensionLite));
   2580     Assert.assertFalse(message.hasExtension(defaultFloatExtensionLite   ));
   2581     Assert.assertFalse(message.hasExtension(defaultDoubleExtensionLite  ));
   2582     Assert.assertFalse(message.hasExtension(defaultBoolExtensionLite    ));
   2583     Assert.assertFalse(message.hasExtension(defaultStringExtensionLite  ));
   2584     Assert.assertFalse(message.hasExtension(defaultBytesExtensionLite   ));
   2585 
   2586     Assert.assertFalse(message.hasExtension(defaultNestedEnumExtensionLite ));
   2587     Assert.assertFalse(message.hasExtension(defaultForeignEnumExtensionLite));
   2588     Assert.assertFalse(message.hasExtension(defaultImportEnumExtensionLite ));
   2589 
   2590     Assert.assertFalse(message.hasExtension(defaultStringPieceExtensionLite));
   2591     Assert.assertFalse(message.hasExtension(defaultCordExtensionLite));
   2592 
   2593     // Fields with defaults have their default values (duh).
   2594     assertEqualsExactType( 41    , message.getExtension(defaultInt32ExtensionLite   ));
   2595     assertEqualsExactType( 42L   , message.getExtension(defaultInt64ExtensionLite   ));
   2596     assertEqualsExactType( 43    , message.getExtension(defaultUint32ExtensionLite  ));
   2597     assertEqualsExactType( 44L   , message.getExtension(defaultUint64ExtensionLite  ));
   2598     assertEqualsExactType(-45    , message.getExtension(defaultSint32ExtensionLite  ));
   2599     assertEqualsExactType( 46L   , message.getExtension(defaultSint64ExtensionLite  ));
   2600     assertEqualsExactType( 47    , message.getExtension(defaultFixed32ExtensionLite ));
   2601     assertEqualsExactType( 48L   , message.getExtension(defaultFixed64ExtensionLite ));
   2602     assertEqualsExactType( 49    , message.getExtension(defaultSfixed32ExtensionLite));
   2603     assertEqualsExactType(-50L   , message.getExtension(defaultSfixed64ExtensionLite));
   2604     assertEqualsExactType( 51.5F , message.getExtension(defaultFloatExtensionLite   ));
   2605     assertEqualsExactType( 52e3D , message.getExtension(defaultDoubleExtensionLite  ));
   2606     assertEqualsExactType(true   , message.getExtension(defaultBoolExtensionLite    ));
   2607     assertEqualsExactType("hello", message.getExtension(defaultStringExtensionLite  ));
   2608     assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExtensionLite));
   2609 
   2610     assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,
   2611       message.getExtension(defaultNestedEnumExtensionLite ));
   2612     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
   2613       message.getExtension(defaultForeignEnumExtensionLite));
   2614     assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAR,
   2615       message.getExtension(defaultImportEnumExtensionLite));
   2616 
   2617     assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtensionLite));
   2618     assertEqualsExactType("123", message.getExtension(defaultCordExtensionLite));
   2619 
   2620     Assert.assertFalse(message.hasExtension(oneofUint32ExtensionLite));
   2621     Assert.assertFalse(message.hasExtension(oneofNestedMessageExtensionLite));
   2622     Assert.assertFalse(message.hasExtension(oneofStringExtensionLite));
   2623     Assert.assertFalse(message.hasExtension(oneofBytesExtensionLite));
   2624   }
   2625 
   2626   // -------------------------------------------------------------------
   2627 
   2628   /**
   2629    * Assert (using {@code junit.framework.Assert}} that all extensions of
   2630    * {@code message} are set to the values assigned by {@code setAllExtensions}
   2631    * followed by {@code modifyRepeatedExtensions}.
   2632    */
   2633   public static void assertRepeatedExtensionsModified(
   2634       TestAllExtensionsLiteOrBuilder message) {
   2635     // ModifyRepeatedFields only sets the second repeated element of each
   2636     // field.  In addition to verifying this, we also verify that the first
   2637     // element and size were *not* modified.
   2638     Assert.assertEquals(2, message.getExtensionCount(repeatedInt32ExtensionLite   ));
   2639     Assert.assertEquals(2, message.getExtensionCount(repeatedInt64ExtensionLite   ));
   2640     Assert.assertEquals(2, message.getExtensionCount(repeatedUint32ExtensionLite  ));
   2641     Assert.assertEquals(2, message.getExtensionCount(repeatedUint64ExtensionLite  ));
   2642     Assert.assertEquals(2, message.getExtensionCount(repeatedSint32ExtensionLite  ));
   2643     Assert.assertEquals(2, message.getExtensionCount(repeatedSint64ExtensionLite  ));
   2644     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32ExtensionLite ));
   2645     Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64ExtensionLite ));
   2646     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32ExtensionLite));
   2647     Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64ExtensionLite));
   2648     Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtensionLite   ));
   2649     Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtensionLite  ));
   2650     Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtensionLite    ));
   2651     Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtensionLite  ));
   2652     Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtensionLite   ));
   2653 
   2654     Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtensionLite         ));
   2655     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtensionLite ));
   2656     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtensionLite));
   2657     Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtensionLite ));
   2658     Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtensionLite   ));
   2659     Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtensionLite    ));
   2660     Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensionLite   ));
   2661     Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtensionLite    ));
   2662 
   2663     Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensionLite));
   2664     Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtensionLite));
   2665 
   2666     assertEqualsExactType(201  , message.getExtension(repeatedInt32ExtensionLite   , 0));
   2667     assertEqualsExactType(202L , message.getExtension(repeatedInt64ExtensionLite   , 0));
   2668     assertEqualsExactType(203  , message.getExtension(repeatedUint32ExtensionLite  , 0));
   2669     assertEqualsExactType(204L , message.getExtension(repeatedUint64ExtensionLite  , 0));
   2670     assertEqualsExactType(205  , message.getExtension(repeatedSint32ExtensionLite  , 0));
   2671     assertEqualsExactType(206L , message.getExtension(repeatedSint64ExtensionLite  , 0));
   2672     assertEqualsExactType(207  , message.getExtension(repeatedFixed32ExtensionLite , 0));
   2673     assertEqualsExactType(208L , message.getExtension(repeatedFixed64ExtensionLite , 0));
   2674     assertEqualsExactType(209  , message.getExtension(repeatedSfixed32ExtensionLite, 0));
   2675     assertEqualsExactType(210L , message.getExtension(repeatedSfixed64ExtensionLite, 0));
   2676     assertEqualsExactType(211F , message.getExtension(repeatedFloatExtensionLite   , 0));
   2677     assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtensionLite  , 0));
   2678     assertEqualsExactType(true , message.getExtension(repeatedBoolExtensionLite    , 0));
   2679     assertEqualsExactType("215", message.getExtension(repeatedStringExtensionLite  , 0));
   2680     assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtensionLite, 0));
   2681 
   2682     assertEqualsExactType(217, message.getExtension(repeatedGroupExtensionLite         ,0).getA());
   2683     assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensionLite ,0).getBb());
   2684     assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtensionLite,0).getC());
   2685     assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensionLite ,0).getD());
   2686     assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtensionLite   ,0).getBb());
   2687 
   2688     assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,
   2689       message.getExtension(repeatedNestedEnumExtensionLite, 0));
   2690     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
   2691       message.getExtension(repeatedForeignEnumExtensionLite, 0));
   2692     assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAR,
   2693       message.getExtension(repeatedImportEnumExtensionLite, 0));
   2694 
   2695     assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensionLite, 0));
   2696     assertEqualsExactType("225", message.getExtension(repeatedCordExtensionLite, 0));
   2697 
   2698     // Actually verify the second (modified) elements now.
   2699     assertEqualsExactType(501  , message.getExtension(repeatedInt32ExtensionLite   , 1));
   2700     assertEqualsExactType(502L , message.getExtension(repeatedInt64ExtensionLite   , 1));
   2701     assertEqualsExactType(503  , message.getExtension(repeatedUint32ExtensionLite  , 1));
   2702     assertEqualsExactType(504L , message.getExtension(repeatedUint64ExtensionLite  , 1));
   2703     assertEqualsExactType(505  , message.getExtension(repeatedSint32ExtensionLite  , 1));
   2704     assertEqualsExactType(506L , message.getExtension(repeatedSint64ExtensionLite  , 1));
   2705     assertEqualsExactType(507  , message.getExtension(repeatedFixed32ExtensionLite , 1));
   2706     assertEqualsExactType(508L , message.getExtension(repeatedFixed64ExtensionLite , 1));
   2707     assertEqualsExactType(509  , message.getExtension(repeatedSfixed32ExtensionLite, 1));
   2708     assertEqualsExactType(510L , message.getExtension(repeatedSfixed64ExtensionLite, 1));
   2709     assertEqualsExactType(511F , message.getExtension(repeatedFloatExtensionLite   , 1));
   2710     assertEqualsExactType(512D , message.getExtension(repeatedDoubleExtensionLite  , 1));
   2711     assertEqualsExactType(true , message.getExtension(repeatedBoolExtensionLite    , 1));
   2712     assertEqualsExactType("515", message.getExtension(repeatedStringExtensionLite  , 1));
   2713     assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExtensionLite, 1));
   2714 
   2715     assertEqualsExactType(517, message.getExtension(repeatedGroupExtensionLite         ,1).getA());
   2716     assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtensionLite ,1).getBb());
   2717     assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtensionLite,1).getC());
   2718     assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtensionLite ,1).getD());
   2719     assertEqualsExactType(527, message.getExtension(repeatedLazyMessageExtensionLite   ,1).getBb());
   2720 
   2721     assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,
   2722       message.getExtension(repeatedNestedEnumExtensionLite, 1));
   2723     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_FOO,
   2724       message.getExtension(repeatedForeignEnumExtensionLite, 1));
   2725     assertEqualsExactType(ImportEnumLite.IMPORT_LITE_FOO,
   2726       message.getExtension(repeatedImportEnumExtensionLite, 1));
   2727 
   2728     assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtensionLite, 1));
   2729     assertEqualsExactType("525", message.getExtension(repeatedCordExtensionLite, 1));
   2730   }
   2731 
   2732   public static void setPackedExtensions(TestPackedExtensionsLite.Builder message) {
   2733     message.addExtension(packedInt32ExtensionLite   , 601);
   2734     message.addExtension(packedInt64ExtensionLite   , 602L);
   2735     message.addExtension(packedUint32ExtensionLite  , 603);
   2736     message.addExtension(packedUint64ExtensionLite  , 604L);
   2737     message.addExtension(packedSint32ExtensionLite  , 605);
   2738     message.addExtension(packedSint64ExtensionLite  , 606L);
   2739     message.addExtension(packedFixed32ExtensionLite , 607);
   2740     message.addExtension(packedFixed64ExtensionLite , 608L);
   2741     message.addExtension(packedSfixed32ExtensionLite, 609);
   2742     message.addExtension(packedSfixed64ExtensionLite, 610L);
   2743     message.addExtension(packedFloatExtensionLite   , 611F);
   2744     message.addExtension(packedDoubleExtensionLite  , 612D);
   2745     message.addExtension(packedBoolExtensionLite    , true);
   2746     message.addExtension(packedEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAR);
   2747     // Add a second one of each field.
   2748     message.addExtension(packedInt32ExtensionLite   , 701);
   2749     message.addExtension(packedInt64ExtensionLite   , 702L);
   2750     message.addExtension(packedUint32ExtensionLite  , 703);
   2751     message.addExtension(packedUint64ExtensionLite  , 704L);
   2752     message.addExtension(packedSint32ExtensionLite  , 705);
   2753     message.addExtension(packedSint64ExtensionLite  , 706L);
   2754     message.addExtension(packedFixed32ExtensionLite , 707);
   2755     message.addExtension(packedFixed64ExtensionLite , 708L);
   2756     message.addExtension(packedSfixed32ExtensionLite, 709);
   2757     message.addExtension(packedSfixed64ExtensionLite, 710L);
   2758     message.addExtension(packedFloatExtensionLite   , 711F);
   2759     message.addExtension(packedDoubleExtensionLite  , 712D);
   2760     message.addExtension(packedBoolExtensionLite    , false);
   2761     message.addExtension(packedEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);
   2762   }
   2763 
   2764   public static void assertPackedExtensionsSet(TestPackedExtensionsLite message) {
   2765     Assert.assertEquals(2, message.getExtensionCount(packedInt32ExtensionLite   ));
   2766     Assert.assertEquals(2, message.getExtensionCount(packedInt64ExtensionLite   ));
   2767     Assert.assertEquals(2, message.getExtensionCount(packedUint32ExtensionLite  ));
   2768     Assert.assertEquals(2, message.getExtensionCount(packedUint64ExtensionLite  ));
   2769     Assert.assertEquals(2, message.getExtensionCount(packedSint32ExtensionLite  ));
   2770     Assert.assertEquals(2, message.getExtensionCount(packedSint64ExtensionLite  ));
   2771     Assert.assertEquals(2, message.getExtensionCount(packedFixed32ExtensionLite ));
   2772     Assert.assertEquals(2, message.getExtensionCount(packedFixed64ExtensionLite ));
   2773     Assert.assertEquals(2, message.getExtensionCount(packedSfixed32ExtensionLite));
   2774     Assert.assertEquals(2, message.getExtensionCount(packedSfixed64ExtensionLite));
   2775     Assert.assertEquals(2, message.getExtensionCount(packedFloatExtensionLite   ));
   2776     Assert.assertEquals(2, message.getExtensionCount(packedDoubleExtensionLite  ));
   2777     Assert.assertEquals(2, message.getExtensionCount(packedBoolExtensionLite    ));
   2778     Assert.assertEquals(2, message.getExtensionCount(packedEnumExtensionLite));
   2779     assertEqualsExactType(601  , message.getExtension(packedInt32ExtensionLite   , 0));
   2780     assertEqualsExactType(602L , message.getExtension(packedInt64ExtensionLite   , 0));
   2781     assertEqualsExactType(603  , message.getExtension(packedUint32ExtensionLite  , 0));
   2782     assertEqualsExactType(604L , message.getExtension(packedUint64ExtensionLite  , 0));
   2783     assertEqualsExactType(605  , message.getExtension(packedSint32ExtensionLite  , 0));
   2784     assertEqualsExactType(606L , message.getExtension(packedSint64ExtensionLite  , 0));
   2785     assertEqualsExactType(607  , message.getExtension(packedFixed32ExtensionLite , 0));
   2786     assertEqualsExactType(608L , message.getExtension(packedFixed64ExtensionLite , 0));
   2787     assertEqualsExactType(609  , message.getExtension(packedSfixed32ExtensionLite, 0));
   2788     assertEqualsExactType(610L , message.getExtension(packedSfixed64ExtensionLite, 0));
   2789     assertEqualsExactType(611F , message.getExtension(packedFloatExtensionLite   , 0));
   2790     assertEqualsExactType(612D , message.getExtension(packedDoubleExtensionLite  , 0));
   2791     assertEqualsExactType(true , message.getExtension(packedBoolExtensionLite    , 0));
   2792     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
   2793                           message.getExtension(packedEnumExtensionLite, 0));
   2794     assertEqualsExactType(701  , message.getExtension(packedInt32ExtensionLite   , 1));
   2795     assertEqualsExactType(702L , message.getExtension(packedInt64ExtensionLite   , 1));
   2796     assertEqualsExactType(703  , message.getExtension(packedUint32ExtensionLite  , 1));
   2797     assertEqualsExactType(704L , message.getExtension(packedUint64ExtensionLite  , 1));
   2798     assertEqualsExactType(705  , message.getExtension(packedSint32ExtensionLite  , 1));
   2799     assertEqualsExactType(706L , message.getExtension(packedSint64ExtensionLite  , 1));
   2800     assertEqualsExactType(707  , message.getExtension(packedFixed32ExtensionLite , 1));
   2801     assertEqualsExactType(708L , message.getExtension(packedFixed64ExtensionLite , 1));
   2802     assertEqualsExactType(709  , message.getExtension(packedSfixed32ExtensionLite, 1));
   2803     assertEqualsExactType(710L , message.getExtension(packedSfixed64ExtensionLite, 1));
   2804     assertEqualsExactType(711F , message.getExtension(packedFloatExtensionLite   , 1));
   2805     assertEqualsExactType(712D , message.getExtension(packedDoubleExtensionLite  , 1));
   2806     assertEqualsExactType(false, message.getExtension(packedBoolExtensionLite    , 1));
   2807     assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAZ,
   2808                           message.getExtension(packedEnumExtensionLite, 1));
   2809   }
   2810 
   2811   // ===================================================================
   2812   // oneof
   2813   public static void setOneof(TestOneof2.Builder message) {
   2814     message.setFooLazyMessage(
   2815         TestOneof2.NestedMessage.newBuilder().setQuxInt(100).build());
   2816     message.setBarString("101");
   2817     message.setBazInt(102);
   2818     message.setBazString("103");
   2819   }
   2820 
   2821   public static void assertOneofSet(TestOneof2 message) {
   2822     Assert.assertTrue(message.hasFooLazyMessage            ());
   2823     Assert.assertTrue(message.getFooLazyMessage().hasQuxInt());
   2824 
   2825     Assert.assertTrue(message.hasBarString());
   2826     Assert.assertTrue(message.hasBazInt   ());
   2827     Assert.assertTrue(message.hasBazString());
   2828 
   2829     Assert.assertEquals(100  , message.getFooLazyMessage().getQuxInt());
   2830     Assert.assertEquals("101", message.getBarString                 ());
   2831     Assert.assertEquals(102  , message.getBazInt                    ());
   2832     Assert.assertEquals("103", message.getBazString                 ());
   2833   }
   2834 
   2835   public static void assertAtMostOneFieldSetOneof(TestOneof2 message) {
   2836     int count = 0;
   2837     if (message.hasFooInt()) { ++count; }
   2838     if (message.hasFooString()) { ++count; }
   2839     if (message.hasFooCord()) { ++count; }
   2840     if (message.hasFooStringPiece()) { ++count; }
   2841     if (message.hasFooBytes()) { ++count; }
   2842     if (message.hasFooEnum()) { ++count; }
   2843     if (message.hasFooMessage()) { ++count; }
   2844     if (message.hasFooGroup()) { ++count; }
   2845     if (message.hasFooLazyMessage()) { ++count; }
   2846     Assert.assertTrue(count <= 1);
   2847 
   2848     count = 0;
   2849     if (message.hasBarInt()) { ++count; }
   2850     if (message.hasBarString()) { ++count; }
   2851     if (message.hasBarCord()) { ++count; }
   2852     if (message.hasBarStringPiece()) { ++count; }
   2853     if (message.hasBarBytes()) { ++count; }
   2854     if (message.hasBarEnum()) { ++count; }
   2855     Assert.assertTrue(count <= 1);
   2856 
   2857     switch (message.getFooCase()) {
   2858       case FOO_INT:
   2859         Assert.assertTrue(message.hasFooInt());
   2860         break;
   2861       case FOO_STRING:
   2862         Assert.assertTrue(message.hasFooString());
   2863         break;
   2864       case FOO_CORD:
   2865         Assert.assertTrue(message.hasFooCord());
   2866         break;
   2867       case FOO_BYTES:
   2868         Assert.assertTrue(message.hasFooBytes());
   2869         break;
   2870       case FOO_ENUM:
   2871         Assert.assertTrue(message.hasFooEnum());
   2872         break;
   2873       case FOO_MESSAGE:
   2874         Assert.assertTrue(message.hasFooMessage());
   2875         break;
   2876       case FOOGROUP:
   2877         Assert.assertTrue(message.hasFooGroup());
   2878         break;
   2879       case FOO_LAZY_MESSAGE:
   2880         Assert.assertTrue(message.hasFooLazyMessage());
   2881         break;
   2882       case FOO_NOT_SET:
   2883         break;
   2884     }
   2885   }
   2886 
   2887   // =================================================================
   2888 
   2889   /**
   2890    * Performs the same things that the methods of {@code TestUtil} do, but
   2891    * via the reflection interface.  This is its own class because it needs
   2892    * to know what descriptor to use.
   2893    */
   2894   public static class ReflectionTester {
   2895     private final Descriptors.Descriptor baseDescriptor;
   2896     private final ExtensionRegistry extensionRegistry;
   2897 
   2898     private final Descriptors.FileDescriptor file;
   2899     private final Descriptors.FileDescriptor importFile;
   2900     private final Descriptors.FileDescriptor publicImportFile;
   2901 
   2902     private final Descriptors.Descriptor optionalGroup;
   2903     private final Descriptors.Descriptor repeatedGroup;
   2904     private final Descriptors.Descriptor nestedMessage;
   2905     private final Descriptors.Descriptor foreignMessage;
   2906     private final Descriptors.Descriptor importMessage;
   2907     private final Descriptors.Descriptor publicImportMessage;
   2908 
   2909     private final Descriptors.FieldDescriptor groupA;
   2910     private final Descriptors.FieldDescriptor repeatedGroupA;
   2911     private final Descriptors.FieldDescriptor nestedB;
   2912     private final Descriptors.FieldDescriptor foreignC;
   2913     private final Descriptors.FieldDescriptor importD;
   2914     private final Descriptors.FieldDescriptor importE;
   2915 
   2916     private final Descriptors.EnumDescriptor nestedEnum;
   2917     private final Descriptors.EnumDescriptor foreignEnum;
   2918     private final Descriptors.EnumDescriptor importEnum;
   2919 
   2920     private final Descriptors.EnumValueDescriptor nestedFoo;
   2921     private final Descriptors.EnumValueDescriptor nestedBar;
   2922     private final Descriptors.EnumValueDescriptor nestedBaz;
   2923     private final Descriptors.EnumValueDescriptor foreignFoo;
   2924     private final Descriptors.EnumValueDescriptor foreignBar;
   2925     private final Descriptors.EnumValueDescriptor foreignBaz;
   2926     private final Descriptors.EnumValueDescriptor importFoo;
   2927     private final Descriptors.EnumValueDescriptor importBar;
   2928     private final Descriptors.EnumValueDescriptor importBaz;
   2929 
   2930     /**
   2931      * Construct a {@code ReflectionTester} that will expect messages using
   2932      * the given descriptor.
   2933      *
   2934      * Normally {@code baseDescriptor} should be a descriptor for the type
   2935      * {@code TestAllTypes}, defined in
   2936      * {@code google/protobuf/unittest.proto}.  However, if
   2937      * {@code extensionRegistry} is non-null, then {@code baseDescriptor} should
   2938      * be for {@code TestAllExtensions} instead, and instead of reading and
   2939      * writing normal fields, the tester will read and write extensions.
   2940      * All of {@code TestAllExtensions}' extensions must be registered in the
   2941      * registry.
   2942      */
   2943     public ReflectionTester(Descriptors.Descriptor baseDescriptor,
   2944                             ExtensionRegistry extensionRegistry) {
   2945       this.baseDescriptor = baseDescriptor;
   2946       this.extensionRegistry = extensionRegistry;
   2947 
   2948       this.file = baseDescriptor.getFile();
   2949       Assert.assertEquals(1, file.getDependencies().size());
   2950       this.importFile = file.getDependencies().get(0);
   2951       this.publicImportFile = importFile.getDependencies().get(0);
   2952 
   2953       Descriptors.Descriptor testAllTypes;
   2954       if (baseDescriptor.getName() == "TestAllTypes") {
   2955         testAllTypes = baseDescriptor;
   2956       } else {
   2957         testAllTypes = file.findMessageTypeByName("TestAllTypes");
   2958         Assert.assertNotNull(testAllTypes);
   2959       }
   2960 
   2961       if (extensionRegistry == null) {
   2962         // Use testAllTypes, rather than baseDescriptor, to allow
   2963         // initialization using TestPackedTypes descriptors. These objects
   2964         // won't be used by the methods for packed fields.
   2965         this.optionalGroup =
   2966           testAllTypes.findNestedTypeByName("OptionalGroup");
   2967         this.repeatedGroup =
   2968           testAllTypes.findNestedTypeByName("RepeatedGroup");
   2969       } else {
   2970         this.optionalGroup =
   2971           file.findMessageTypeByName("OptionalGroup_extension");
   2972         this.repeatedGroup =
   2973           file.findMessageTypeByName("RepeatedGroup_extension");
   2974       }
   2975       this.nestedMessage = testAllTypes.findNestedTypeByName("NestedMessage");
   2976       this.foreignMessage = file.findMessageTypeByName("ForeignMessage");
   2977       this.importMessage = importFile.findMessageTypeByName("ImportMessage");
   2978       this.publicImportMessage = publicImportFile.findMessageTypeByName(
   2979           "PublicImportMessage");
   2980 
   2981       this.nestedEnum = testAllTypes.findEnumTypeByName("NestedEnum");
   2982       this.foreignEnum = file.findEnumTypeByName("ForeignEnum");
   2983       this.importEnum = importFile.findEnumTypeByName("ImportEnum");
   2984 
   2985       Assert.assertNotNull(optionalGroup );
   2986       Assert.assertNotNull(repeatedGroup );
   2987       Assert.assertNotNull(nestedMessage );
   2988       Assert.assertNotNull(foreignMessage);
   2989       Assert.assertNotNull(importMessage );
   2990       Assert.assertNotNull(nestedEnum    );
   2991       Assert.assertNotNull(foreignEnum   );
   2992       Assert.assertNotNull(importEnum    );
   2993 
   2994       this.nestedB  = nestedMessage .findFieldByName("bb");
   2995       this.foreignC = foreignMessage.findFieldByName("c");
   2996       this.importD  = importMessage .findFieldByName("d");
   2997       this.importE  = publicImportMessage.findFieldByName("e");
   2998       this.nestedFoo = nestedEnum.findValueByName("FOO");
   2999       this.nestedBar = nestedEnum.findValueByName("BAR");
   3000       this.nestedBaz = nestedEnum.findValueByName("BAZ");
   3001       this.foreignFoo = foreignEnum.findValueByName("FOREIGN_FOO");
   3002       this.foreignBar = foreignEnum.findValueByName("FOREIGN_BAR");
   3003       this.foreignBaz = foreignEnum.findValueByName("FOREIGN_BAZ");
   3004       this.importFoo = importEnum.findValueByName("IMPORT_FOO");
   3005       this.importBar = importEnum.findValueByName("IMPORT_BAR");
   3006       this.importBaz = importEnum.findValueByName("IMPORT_BAZ");
   3007 
   3008       this.groupA = optionalGroup.findFieldByName("a");
   3009       this.repeatedGroupA = repeatedGroup.findFieldByName("a");
   3010 
   3011       Assert.assertNotNull(groupA        );
   3012       Assert.assertNotNull(repeatedGroupA);
   3013       Assert.assertNotNull(nestedB       );
   3014       Assert.assertNotNull(foreignC      );
   3015       Assert.assertNotNull(importD       );
   3016       Assert.assertNotNull(importE       );
   3017       Assert.assertNotNull(nestedFoo     );
   3018       Assert.assertNotNull(nestedBar     );
   3019       Assert.assertNotNull(nestedBaz     );
   3020       Assert.assertNotNull(foreignFoo    );
   3021       Assert.assertNotNull(foreignBar    );
   3022       Assert.assertNotNull(foreignBaz    );
   3023       Assert.assertNotNull(importFoo     );
   3024       Assert.assertNotNull(importBar     );
   3025       Assert.assertNotNull(importBaz     );
   3026     }
   3027 
   3028     /**
   3029      * Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes.
   3030      */
   3031     private Descriptors.FieldDescriptor f(String name) {
   3032       Descriptors.FieldDescriptor result;
   3033       if (extensionRegistry == null) {
   3034         result = baseDescriptor.findFieldByName(name);
   3035       } else {
   3036         result = file.findExtensionByName(name + "_extension");
   3037       }
   3038       Assert.assertNotNull(result);
   3039       return result;
   3040     }
   3041 
   3042     /**
   3043      * Calls {@code parent.newBuilderForField()} or uses the
   3044      * {@code ExtensionRegistry} to find an appropriate builder, depending
   3045      * on what type is being tested.
   3046      */
   3047     private Message.Builder newBuilderForField(
   3048         Message.Builder parent, Descriptors.FieldDescriptor field) {
   3049       if (extensionRegistry == null) {
   3050         return parent.newBuilderForField(field);
   3051       } else {
   3052         ExtensionRegistry.ExtensionInfo extension =
   3053           extensionRegistry.findImmutableExtensionByNumber(
   3054               field.getContainingType(), field.getNumber());
   3055         Assert.assertNotNull(extension);
   3056         Assert.assertNotNull(extension.defaultInstance);
   3057         return extension.defaultInstance.newBuilderForType();
   3058       }
   3059     }
   3060 
   3061     // -------------------------------------------------------------------
   3062 
   3063     /**
   3064      * Set every field of {@code message} to the values expected by
   3065      * {@code assertAllFieldsSet()}, using the {@link Message.Builder}
   3066      * reflection interface.
   3067      */
   3068     void setAllFieldsViaReflection(Message.Builder message) {
   3069       message.setField(f("optional_int32"   ), 101 );
   3070       message.setField(f("optional_int64"   ), 102L);
   3071       message.setField(f("optional_uint32"  ), 103 );
   3072       message.setField(f("optional_uint64"  ), 104L);
   3073       message.setField(f("optional_sint32"  ), 105 );
   3074       message.setField(f("optional_sint64"  ), 106L);
   3075       message.setField(f("optional_fixed32" ), 107 );
   3076       message.setField(f("optional_fixed64" ), 108L);
   3077       message.setField(f("optional_sfixed32"), 109 );
   3078       message.setField(f("optional_sfixed64"), 110L);
   3079       message.setField(f("optional_float"   ), 111F);
   3080       message.setField(f("optional_double"  ), 112D);
   3081       message.setField(f("optional_bool"    ), true);
   3082       message.setField(f("optional_string"  ), "115");
   3083       message.setField(f("optional_bytes"   ), toBytes("116"));
   3084 
   3085       message.setField(f("optionalgroup"),
   3086         newBuilderForField(message, f("optionalgroup"))
   3087                .setField(groupA, 117).build());
   3088       message.setField(f("optional_nested_message"),
   3089         newBuilderForField(message, f("optional_nested_message"))
   3090                .setField(nestedB, 118).build());
   3091       message.setField(f("optional_foreign_message"),
   3092         newBuilderForField(message, f("optional_foreign_message"))
   3093                .setField(foreignC, 119).build());
   3094       message.setField(f("optional_import_message"),
   3095         newBuilderForField(message, f("optional_import_message"))
   3096                .setField(importD, 120).build());
   3097       message.setField(f("optional_public_import_message"),
   3098         newBuilderForField(message, f("optional_public_import_message"))
   3099                .setField(importE, 126).build());
   3100       message.setField(f("optional_lazy_message"),
   3101         newBuilderForField(message, f("optional_lazy_message"))
   3102                .setField(nestedB, 127).build());
   3103 
   3104       message.setField(f("optional_nested_enum" ),  nestedBaz);
   3105       message.setField(f("optional_foreign_enum"), foreignBaz);
   3106       message.setField(f("optional_import_enum" ),  importBaz);
   3107 
   3108       message.setField(f("optional_string_piece" ), "124");
   3109       message.setField(f("optional_cord" ), "125");
   3110 
   3111       // -----------------------------------------------------------------
   3112 
   3113       message.addRepeatedField(f("repeated_int32"   ), 201 );
   3114       message.addRepeatedField(f("repeated_int64"   ), 202L);
   3115       message.addRepeatedField(f("repeated_uint32"  ), 203 );
   3116       message.addRepeatedField(f("repeated_uint64"  ), 204L);
   3117       message.addRepeatedField(f("repeated_sint32"  ), 205 );
   3118       message.addRepeatedField(f("repeated_sint64"  ), 206L);
   3119       message.addRepeatedField(f("repeated_fixed32" ), 207 );
   3120       message.addRepeatedField(f("repeated_fixed64" ), 208L);
   3121       message.addRepeatedField(f("repeated_sfixed32"), 209 );
   3122       message.addRepeatedField(f("repeated_sfixed64"), 210L);
   3123       message.addRepeatedField(f("repeated_float"   ), 211F);
   3124       message.addRepeatedField(f("repeated_double"  ), 212D);
   3125       message.addRepeatedField(f("repeated_bool"    ), true);
   3126       message.addRepeatedField(f("repeated_string"  ), "215");
   3127       message.addRepeatedField(f("repeated_bytes"   ), toBytes("216"));
   3128 
   3129       message.addRepeatedField(f("repeatedgroup"),
   3130         newBuilderForField(message, f("repeatedgroup"))
   3131                .setField(repeatedGroupA, 217).build());
   3132       message.addRepeatedField(f("repeated_nested_message"),
   3133         newBuilderForField(message, f("repeated_nested_message"))
   3134                .setField(nestedB, 218).build());
   3135       message.addRepeatedField(f("repeated_foreign_message"),
   3136         newBuilderForField(message, f("repeated_foreign_message"))
   3137                .setField(foreignC, 219).build());
   3138       message.addRepeatedField(f("repeated_import_message"),
   3139         newBuilderForField(message, f("repeated_import_message"))
   3140                .setField(importD, 220).build());
   3141       message.addRepeatedField(f("repeated_lazy_message"),
   3142         newBuilderForField(message, f("repeated_lazy_message"))
   3143                .setField(nestedB, 227).build());
   3144 
   3145       message.addRepeatedField(f("repeated_nested_enum" ),  nestedBar);
   3146       message.addRepeatedField(f("repeated_foreign_enum"), foreignBar);
   3147       message.addRepeatedField(f("repeated_import_enum" ),  importBar);
   3148 
   3149       message.addRepeatedField(f("repeated_string_piece" ), "224");
   3150       message.addRepeatedField(f("repeated_cord" ), "225");
   3151 
   3152       // Add a second one of each field.
   3153       message.addRepeatedField(f("repeated_int32"   ), 301 );
   3154       message.addRepeatedField(f("repeated_int64"   ), 302L);
   3155       message.addRepeatedField(f("repeated_uint32"  ), 303 );
   3156       message.addRepeatedField(f("repeated_uint64"  ), 304L);
   3157       message.addRepeatedField(f("repeated_sint32"  ), 305 );
   3158       message.addRepeatedField(f("repeated_sint64"  ), 306L);
   3159       message.addRepeatedField(f("repeated_fixed32" ), 307 );
   3160       message.addRepeatedField(f("repeated_fixed64" ), 308L);
   3161       message.addRepeatedField(f("repeated_sfixed32"), 309 );
   3162       message.addRepeatedField(f("repeated_sfixed64"), 310L);
   3163       message.addRepeatedField(f("repeated_float"   ), 311F);
   3164       message.addRepeatedField(f("repeated_double"  ), 312D);
   3165       message.addRepeatedField(f("repeated_bool"    ), false);
   3166       message.addRepeatedField(f("repeated_string"  ), "315");
   3167       message.addRepeatedField(f("repeated_bytes"   ), toBytes("316"));
   3168 
   3169       message.addRepeatedField(f("repeatedgroup"),
   3170         newBuilderForField(message, f("repeatedgroup"))
   3171                .setField(repeatedGroupA, 317).build());
   3172       message.addRepeatedField(f("repeated_nested_message"),
   3173         newBuilderForField(message, f("repeated_nested_message"))
   3174                .setField(nestedB, 318).build());
   3175       message.addRepeatedField(f("repeated_foreign_message"),
   3176         newBuilderForField(message, f("repeated_foreign_message"))
   3177                .setField(foreignC, 319).build());
   3178       message.addRepeatedField(f("repeated_import_message"),
   3179         newBuilderForField(message, f("repeated_import_message"))
   3180                .setField(importD, 320).build());
   3181       message.addRepeatedField(f("repeated_lazy_message"),
   3182         newBuilderForField(message, f("repeated_lazy_message"))
   3183                .setField(nestedB, 327).build());
   3184 
   3185       message.addRepeatedField(f("repeated_nested_enum" ),  nestedBaz);
   3186       message.addRepeatedField(f("repeated_foreign_enum"), foreignBaz);
   3187       message.addRepeatedField(f("repeated_import_enum" ),  importBaz);
   3188 
   3189       message.addRepeatedField(f("repeated_string_piece" ), "324");
   3190       message.addRepeatedField(f("repeated_cord" ), "325");
   3191 
   3192       // -----------------------------------------------------------------
   3193 
   3194       message.setField(f("default_int32"   ), 401 );
   3195       message.setField(f("default_int64"   ), 402L);
   3196       message.setField(f("default_uint32"  ), 403 );
   3197       message.setField(f("default_uint64"  ), 404L);
   3198       message.setField(f("default_sint32"  ), 405 );
   3199       message.setField(f("default_sint64"  ), 406L);
   3200       message.setField(f("default_fixed32" ), 407 );
   3201       message.setField(f("default_fixed64" ), 408L);
   3202       message.setField(f("default_sfixed32"), 409 );
   3203       message.setField(f("default_sfixed64"), 410L);
   3204       message.setField(f("default_float"   ), 411F);
   3205       message.setField(f("default_double"  ), 412D);
   3206       message.setField(f("default_bool"    ), false);
   3207       message.setField(f("default_string"  ), "415");
   3208       message.setField(f("default_bytes"   ), toBytes("416"));
   3209 
   3210       message.setField(f("default_nested_enum" ),  nestedFoo);
   3211       message.setField(f("default_foreign_enum"), foreignFoo);
   3212       message.setField(f("default_import_enum" ),  importFoo);
   3213 
   3214       message.setField(f("default_string_piece" ), "424");
   3215       message.setField(f("default_cord" ), "425");
   3216 
   3217       message.setField(f("oneof_uint32" ), 601);
   3218       message.setField(f("oneof_nested_message"),
   3219         newBuilderForField(message, f("oneof_nested_message"))
   3220           .setField(nestedB, 602).build());
   3221       message.setField(f("oneof_string" ), "603");
   3222       message.setField(f("oneof_bytes" ), toBytes("604"));
   3223     }
   3224 
   3225     // -------------------------------------------------------------------
   3226 
   3227     /**
   3228      * Modify the repeated fields of {@code message} to contain the values
   3229      * expected by {@code assertRepeatedFieldsModified()}, using the
   3230      * {@link Message.Builder} reflection interface.
   3231      */
   3232     void modifyRepeatedFieldsViaReflection(Message.Builder message) {
   3233       message.setRepeatedField(f("repeated_int32"   ), 1, 501 );
   3234       message.setRepeatedField(f("repeated_int64"   ), 1, 502L);
   3235       message.setRepeatedField(f("repeated_uint32"  ), 1, 503 );
   3236       message.setRepeatedField(f("repeated_uint64"  ), 1, 504L);
   3237       message.setRepeatedField(f("repeated_sint32"  ), 1, 505 );
   3238       message.setRepeatedField(f("repeated_sint64"  ), 1, 506L);
   3239       message.setRepeatedField(f("repeated_fixed32" ), 1, 507 );
   3240       message.setRepeatedField(f("repeated_fixed64" ), 1, 508L);
   3241       message.setRepeatedField(f("repeated_sfixed32"), 1, 509 );
   3242       message.setRepeatedField(f("repeated_sfixed64"), 1, 510L);
   3243       message.setRepeatedField(f("repeated_float"   ), 1, 511F);
   3244       message.setRepeatedField(f("repeated_double"  ), 1, 512D);
   3245       message.setRepeatedField(f("repeated_bool"    ), 1, true);
   3246       message.setRepeatedField(f("repeated_string"  ), 1, "515");
   3247       message.setRepeatedField(f("repeated_bytes"   ), 1, toBytes("516"));
   3248 
   3249       message.setRepeatedField(f("repeatedgroup"), 1,
   3250         newBuilderForField(message, f("repeatedgroup"))
   3251                .setField(repeatedGroupA, 517).build());
   3252       message.setRepeatedField(f("repeated_nested_message"), 1,
   3253         newBuilderForField(message, f("repeated_nested_message"))
   3254                .setField(nestedB, 518).build());
   3255       message.setRepeatedField(f("repeated_foreign_message"), 1,
   3256         newBuilderForField(message, f("repeated_foreign_message"))
   3257                .setField(foreignC, 519).build());
   3258       message.setRepeatedField(f("repeated_import_message"), 1,
   3259         newBuilderForField(message, f("repeated_import_message"))
   3260                .setField(importD, 520).build());
   3261       message.setRepeatedField(f("repeated_lazy_message"), 1,
   3262         newBuilderForField(message, f("repeated_lazy_message"))
   3263                .setField(nestedB, 527).build());
   3264 
   3265       message.setRepeatedField(f("repeated_nested_enum" ), 1,  nestedFoo);
   3266       message.setRepeatedField(f("repeated_foreign_enum"), 1, foreignFoo);
   3267       message.setRepeatedField(f("repeated_import_enum" ), 1,  importFoo);
   3268 
   3269       message.setRepeatedField(f("repeated_string_piece"), 1, "524");
   3270       message.setRepeatedField(f("repeated_cord"), 1, "525");
   3271     }
   3272 
   3273     // -------------------------------------------------------------------
   3274 
   3275     /**
   3276      * Assert (using {@code junit.framework.Assert}} that all fields of
   3277      * {@code message} are set to the values assigned by {@code setAllFields},
   3278      * using the {@link Message} reflection interface.
   3279      */
   3280     public void assertAllFieldsSetViaReflection(MessageOrBuilder message) {
   3281       Assert.assertTrue(message.hasField(f("optional_int32"   )));
   3282       Assert.assertTrue(message.hasField(f("optional_int64"   )));
   3283       Assert.assertTrue(message.hasField(f("optional_uint32"  )));
   3284       Assert.assertTrue(message.hasField(f("optional_uint64"  )));
   3285       Assert.assertTrue(message.hasField(f("optional_sint32"  )));
   3286       Assert.assertTrue(message.hasField(f("optional_sint64"  )));
   3287       Assert.assertTrue(message.hasField(f("optional_fixed32" )));
   3288       Assert.assertTrue(message.hasField(f("optional_fixed64" )));
   3289       Assert.assertTrue(message.hasField(f("optional_sfixed32")));
   3290       Assert.assertTrue(message.hasField(f("optional_sfixed64")));
   3291       Assert.assertTrue(message.hasField(f("optional_float"   )));
   3292       Assert.assertTrue(message.hasField(f("optional_double"  )));
   3293       Assert.assertTrue(message.hasField(f("optional_bool"    )));
   3294       Assert.assertTrue(message.hasField(f("optional_string"  )));
   3295       Assert.assertTrue(message.hasField(f("optional_bytes"   )));
   3296 
   3297       Assert.assertTrue(message.hasField(f("optionalgroup"           )));
   3298       Assert.assertTrue(message.hasField(f("optional_nested_message" )));
   3299       Assert.assertTrue(message.hasField(f("optional_foreign_message")));
   3300       Assert.assertTrue(message.hasField(f("optional_import_message" )));
   3301 
   3302       Assert.assertTrue(
   3303         ((Message)message.getField(f("optionalgroup"))).hasField(groupA));
   3304       Assert.assertTrue(
   3305         ((Message)message.getField(f("optional_nested_message")))
   3306                          .hasField(nestedB));
   3307       Assert.assertTrue(
   3308         ((Message)message.getField(f("optional_foreign_message")))
   3309                          .hasField(foreignC));
   3310       Assert.assertTrue(
   3311         ((Message)message.getField(f("optional_import_message")))
   3312                          .hasField(importD));
   3313 
   3314       Assert.assertTrue(message.hasField(f("optional_nested_enum" )));
   3315       Assert.assertTrue(message.hasField(f("optional_foreign_enum")));
   3316       Assert.assertTrue(message.hasField(f("optional_import_enum" )));
   3317 
   3318       Assert.assertTrue(message.hasField(f("optional_string_piece")));
   3319       Assert.assertTrue(message.hasField(f("optional_cord")));
   3320 
   3321       Assert.assertEquals(101  , message.getField(f("optional_int32"   )));
   3322       Assert.assertEquals(102L , message.getField(f("optional_int64"   )));
   3323       Assert.assertEquals(103  , message.getField(f("optional_uint32"  )));
   3324       Assert.assertEquals(104L , message.getField(f("optional_uint64"  )));
   3325       Assert.assertEquals(105  , message.getField(f("optional_sint32"  )));
   3326       Assert.assertEquals(106L , message.getField(f("optional_sint64"  )));
   3327       Assert.assertEquals(107  , message.getField(f("optional_fixed32" )));
   3328       Assert.assertEquals(108L , message.getField(f("optional_fixed64" )));
   3329       Assert.assertEquals(109  , message.getField(f("optional_sfixed32")));
   3330       Assert.assertEquals(110L , message.getField(f("optional_sfixed64")));
   3331       Assert.assertEquals(111F , message.getField(f("optional_float"   )));
   3332       Assert.assertEquals(112D , message.getField(f("optional_double"  )));
   3333       Assert.assertEquals(true , message.getField(f("optional_bool"    )));
   3334       Assert.assertEquals("115", message.getField(f("optional_string"  )));
   3335       Assert.assertEquals(toBytes("116"), message.getField(f("optional_bytes")));
   3336 
   3337       Assert.assertEquals(117,
   3338         ((Message)message.getField(f("optionalgroup"))).getField(groupA));
   3339       Assert.assertEquals(118,
   3340         ((Message)message.getField(f("optional_nested_message")))
   3341                          .getField(nestedB));
   3342       Assert.assertEquals(119,
   3343         ((Message)message.getField(f("optional_foreign_message")))
   3344                          .getField(foreignC));
   3345       Assert.assertEquals(120,
   3346         ((Message)message.getField(f("optional_import_message")))
   3347                          .getField(importD));
   3348       Assert.assertEquals(126,
   3349         ((Message)message.getField(f("optional_public_import_message")))
   3350                          .getField(importE));
   3351       Assert.assertEquals(127,
   3352         ((Message)message.getField(f("optional_lazy_message")))
   3353                          .getField(nestedB));
   3354 
   3355       Assert.assertEquals( nestedBaz, message.getField(f("optional_nested_enum" )));
   3356       Assert.assertEquals(foreignBaz, message.getField(f("optional_foreign_enum")));
   3357       Assert.assertEquals( importBaz, message.getField(f("optional_import_enum" )));
   3358 
   3359       Assert.assertEquals("124", message.getField(f("optional_string_piece")));
   3360       Assert.assertEquals("125", message.getField(f("optional_cord")));
   3361 
   3362       // -----------------------------------------------------------------
   3363 
   3364       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int32"   )));
   3365       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int64"   )));
   3366       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint32"  )));
   3367       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint64"  )));
   3368       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint32"  )));
   3369       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint64"  )));
   3370       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed32" )));
   3371       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed64" )));
   3372       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed32")));
   3373       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed64")));
   3374       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_float"   )));
   3375       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_double"  )));
   3376       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bool"    )));
   3377       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string"  )));
   3378       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bytes"   )));
   3379 
   3380       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeatedgroup"           )));
   3381       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_message" )));
   3382       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_message")));
   3383       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_message" )));
   3384       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_lazy_message" )));
   3385       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_enum"    )));
   3386       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_enum"   )));
   3387       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_enum"    )));
   3388 
   3389       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string_piece")));
   3390       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_cord")));
   3391 
   3392       Assert.assertEquals(201  , message.getRepeatedField(f("repeated_int32"   ), 0));
   3393       Assert.assertEquals(202L , message.getRepeatedField(f("repeated_int64"   ), 0));
   3394       Assert.assertEquals(203  , message.getRepeatedField(f("repeated_uint32"  ), 0));
   3395       Assert.assertEquals(204L , message.getRepeatedField(f("repeated_uint64"  ), 0));
   3396       Assert.assertEquals(205  , message.getRepeatedField(f("repeated_sint32"  ), 0));
   3397       Assert.assertEquals(206L , message.getRepeatedField(f("repeated_sint64"  ), 0));
   3398       Assert.assertEquals(207  , message.getRepeatedField(f("repeated_fixed32" ), 0));
   3399       Assert.assertEquals(208L , message.getRepeatedField(f("repeated_fixed64" ), 0));
   3400       Assert.assertEquals(209  , message.getRepeatedField(f("repeated_sfixed32"), 0));
   3401       Assert.assertEquals(210L , message.getRepeatedField(f("repeated_sfixed64"), 0));
   3402       Assert.assertEquals(211F , message.getRepeatedField(f("repeated_float"   ), 0));
   3403       Assert.assertEquals(212D , message.getRepeatedField(f("repeated_double"  ), 0));
   3404       Assert.assertEquals(true , message.getRepeatedField(f("repeated_bool"    ), 0));
   3405       Assert.assertEquals("215", message.getRepeatedField(f("repeated_string"  ), 0));
   3406       Assert.assertEquals(toBytes("216"), message.getRepeatedField(f("repeated_bytes"), 0));
   3407 
   3408       Assert.assertEquals(217,
   3409         ((Message)message.getRepeatedField(f("repeatedgroup"), 0))
   3410                          .getField(repeatedGroupA));
   3411       Assert.assertEquals(218,
   3412         ((Message)message.getRepeatedField(f("repeated_nested_message"), 0))
   3413                          .getField(nestedB));
   3414       Assert.assertEquals(219,
   3415         ((Message)message.getRepeatedField(f("repeated_foreign_message"), 0))
   3416                          .getField(foreignC));
   3417       Assert.assertEquals(220,
   3418         ((Message)message.getRepeatedField(f("repeated_import_message"), 0))
   3419                          .getField(importD));
   3420       Assert.assertEquals(227,
   3421         ((Message)message.getRepeatedField(f("repeated_lazy_message"), 0))
   3422                          .getField(nestedB));
   3423 
   3424       Assert.assertEquals( nestedBar, message.getRepeatedField(f("repeated_nested_enum" ),0));
   3425       Assert.assertEquals(foreignBar, message.getRepeatedField(f("repeated_foreign_enum"),0));
   3426       Assert.assertEquals( importBar, message.getRepeatedField(f("repeated_import_enum" ),0));
   3427 
   3428       Assert.assertEquals("224", message.getRepeatedField(f("repeated_string_piece"), 0));
   3429       Assert.assertEquals("225", message.getRepeatedField(f("repeated_cord"), 0));
   3430 
   3431       Assert.assertEquals(301  , message.getRepeatedField(f("repeated_int32"   ), 1));
   3432       Assert.assertEquals(302L , message.getRepeatedField(f("repeated_int64"   ), 1));
   3433       Assert.assertEquals(303  , message.getRepeatedField(f("repeated_uint32"  ), 1));
   3434       Assert.assertEquals(304L , message.getRepeatedField(f("repeated_uint64"  ), 1));
   3435       Assert.assertEquals(305  , message.getRepeatedField(f("repeated_sint32"  ), 1));
   3436       Assert.assertEquals(306L , message.getRepeatedField(f("repeated_sint64"  ), 1));
   3437       Assert.assertEquals(307  , message.getRepeatedField(f("repeated_fixed32" ), 1));
   3438       Assert.assertEquals(308L , message.getRepeatedField(f("repeated_fixed64" ), 1));
   3439       Assert.assertEquals(309  , message.getRepeatedField(f("repeated_sfixed32"), 1));
   3440       Assert.assertEquals(310L , message.getRepeatedField(f("repeated_sfixed64"), 1));
   3441       Assert.assertEquals(311F , message.getRepeatedField(f("repeated_float"   ), 1));
   3442       Assert.assertEquals(312D , message.getRepeatedField(f("repeated_double"  ), 1));
   3443       Assert.assertEquals(false, message.getRepeatedField(f("repeated_bool"    ), 1));
   3444       Assert.assertEquals("315", message.getRepeatedField(f("repeated_string"  ), 1));
   3445       Assert.assertEquals(toBytes("316"), message.getRepeatedField(f("repeated_bytes"), 1));
   3446 
   3447       Assert.assertEquals(317,
   3448         ((Message)message.getRepeatedField(f("repeatedgroup"), 1))
   3449                          .getField(repeatedGroupA));
   3450       Assert.assertEquals(318,
   3451         ((Message)message.getRepeatedField(f("repeated_nested_message"), 1))
   3452                          .getField(nestedB));
   3453       Assert.assertEquals(319,
   3454         ((Message)message.getRepeatedField(f("repeated_foreign_message"), 1))
   3455                          .getField(foreignC));
   3456       Assert.assertEquals(320,
   3457         ((Message)message.getRepeatedField(f("repeated_import_message"), 1))
   3458                          .getField(importD));
   3459       Assert.assertEquals(327,
   3460         ((Message)message.getRepeatedField(f("repeated_lazy_message"), 1))
   3461                          .getField(nestedB));
   3462 
   3463       Assert.assertEquals( nestedBaz, message.getRepeatedField(f("repeated_nested_enum" ),1));
   3464       Assert.assertEquals(foreignBaz, message.getRepeatedField(f("repeated_foreign_enum"),1));
   3465       Assert.assertEquals( importBaz, message.getRepeatedField(f("repeated_import_enum" ),1));
   3466 
   3467       Assert.assertEquals("324", message.getRepeatedField(f("repeated_string_piece"), 1));
   3468       Assert.assertEquals("325", message.getRepeatedField(f("repeated_cord"), 1));
   3469 
   3470       // -----------------------------------------------------------------
   3471 
   3472       Assert.assertTrue(message.hasField(f("default_int32"   )));
   3473       Assert.assertTrue(message.hasField(f("default_int64"   )));
   3474       Assert.assertTrue(message.hasField(f("default_uint32"  )));
   3475       Assert.assertTrue(message.hasField(f("default_uint64"  )));
   3476       Assert.assertTrue(message.hasField(f("default_sint32"  )));
   3477       Assert.assertTrue(message.hasField(f("default_sint64"  )));
   3478       Assert.assertTrue(message.hasField(f("default_fixed32" )));
   3479       Assert.assertTrue(message.hasField(f("default_fixed64" )));
   3480       Assert.assertTrue(message.hasField(f("default_sfixed32")));
   3481       Assert.assertTrue(message.hasField(f("default_sfixed64")));
   3482       Assert.assertTrue(message.hasField(f("default_float"   )));
   3483       Assert.assertTrue(message.hasField(f("default_double"  )));
   3484       Assert.assertTrue(message.hasField(f("default_bool"    )));
   3485       Assert.assertTrue(message.hasField(f("default_string"  )));
   3486       Assert.assertTrue(message.hasField(f("default_bytes"   )));
   3487 
   3488       Assert.assertTrue(message.hasField(f("default_nested_enum" )));
   3489       Assert.assertTrue(message.hasField(f("default_foreign_enum")));
   3490       Assert.assertTrue(message.hasField(f("default_import_enum" )));
   3491 
   3492       Assert.assertTrue(message.hasField(f("default_string_piece")));
   3493       Assert.assertTrue(message.hasField(f("default_cord")));
   3494 
   3495       Assert.assertEquals(401  , message.getField(f("default_int32"   )));
   3496       Assert.assertEquals(402L , message.getField(f("default_int64"   )));
   3497       Assert.assertEquals(403  , message.getField(f("default_uint32"  )));
   3498       Assert.assertEquals(404L , message.getField(f("default_uint64"  )));
   3499       Assert.assertEquals(405  , message.getField(f("default_sint32"  )));
   3500       Assert.assertEquals(406L , message.getField(f("default_sint64"  )));
   3501       Assert.assertEquals(407  , message.getField(f("default_fixed32" )));
   3502       Assert.assertEquals(408L , message.getField(f("default_fixed64" )));
   3503       Assert.assertEquals(409  , message.getField(f("default_sfixed32")));
   3504       Assert.assertEquals(410L , message.getField(f("default_sfixed64")));
   3505       Assert.assertEquals(411F , message.getField(f("default_float"   )));
   3506       Assert.assertEquals(412D , message.getField(f("default_double"  )));
   3507       Assert.assertEquals(false, message.getField(f("default_bool"    )));
   3508       Assert.assertEquals("415", message.getField(f("default_string"  )));
   3509       Assert.assertEquals(toBytes("416"), message.getField(f("default_bytes")));
   3510 
   3511       Assert.assertEquals( nestedFoo, message.getField(f("default_nested_enum" )));
   3512       Assert.assertEquals(foreignFoo, message.getField(f("default_foreign_enum")));
   3513       Assert.assertEquals( importFoo, message.getField(f("default_import_enum" )));
   3514 
   3515       Assert.assertEquals("424", message.getField(f("default_string_piece")));
   3516       Assert.assertEquals("425", message.getField(f("default_cord")));
   3517 
   3518       Assert.assertTrue(message.hasField(f("oneof_bytes")));
   3519       Assert.assertEquals(toBytes("604"), message.getField(f("oneof_bytes")));
   3520 
   3521       if (extensionRegistry == null) {
   3522         Assert.assertFalse(message.hasField(f("oneof_uint32")));
   3523         Assert.assertFalse(message.hasField(f("oneof_nested_message")));
   3524         Assert.assertFalse(message.hasField(f("oneof_string")));
   3525       } else {
   3526         Assert.assertTrue(message.hasField(f("oneof_uint32")));
   3527         Assert.assertTrue(message.hasField(f("oneof_nested_message")));
   3528         Assert.assertTrue(message.hasField(f("oneof_string")));
   3529         Assert.assertEquals(601, message.getField(f("oneof_uint32")));
   3530         Assert.assertEquals(602,
   3531             ((MessageOrBuilder) message.getField(f("oneof_nested_message")))
   3532             .getField(nestedB));
   3533         Assert.assertEquals("603", message.getField(f("oneof_string")));
   3534       }
   3535     }
   3536 
   3537     // -------------------------------------------------------------------
   3538 
   3539     /**
   3540      * Assert (using {@code junit.framework.Assert}} that all fields of
   3541      * {@code message} are cleared, and that getting the fields returns their
   3542      * default values, using the {@link Message} reflection interface.
   3543      */
   3544     public void assertClearViaReflection(MessageOrBuilder message) {
   3545       // has_blah() should initially be false for all optional fields.
   3546       Assert.assertFalse(message.hasField(f("optional_int32"   )));
   3547       Assert.assertFalse(message.hasField(f("optional_int64"   )));
   3548       Assert.assertFalse(message.hasField(f("optional_uint32"  )));
   3549       Assert.assertFalse(message.hasField(f("optional_uint64"  )));
   3550       Assert.assertFalse(message.hasField(f("optional_sint32"  )));
   3551       Assert.assertFalse(message.hasField(f("optional_sint64"  )));
   3552       Assert.assertFalse(message.hasField(f("optional_fixed32" )));
   3553       Assert.assertFalse(message.hasField(f("optional_fixed64" )));
   3554       Assert.assertFalse(message.hasField(f("optional_sfixed32")));
   3555       Assert.assertFalse(message.hasField(f("optional_sfixed64")));
   3556       Assert.assertFalse(message.hasField(f("optional_float"   )));
   3557       Assert.assertFalse(message.hasField(f("optional_double"  )));
   3558       Assert.assertFalse(message.hasField(f("optional_bool"    )));
   3559       Assert.assertFalse(message.hasField(f("optional_string"  )));
   3560       Assert.assertFalse(message.hasField(f("optional_bytes"   )));
   3561 
   3562       Assert.assertFalse(message.hasField(f("optionalgroup"           )));
   3563       Assert.assertFalse(message.hasField(f("optional_nested_message" )));
   3564       Assert.assertFalse(message.hasField(f("optional_foreign_message")));
   3565       Assert.assertFalse(message.hasField(f("optional_import_message" )));
   3566 
   3567       Assert.assertFalse(message.hasField(f("optional_nested_enum" )));
   3568       Assert.assertFalse(message.hasField(f("optional_foreign_enum")));
   3569       Assert.assertFalse(message.hasField(f("optional_import_enum" )));
   3570 
   3571       Assert.assertFalse(message.hasField(f("optional_string_piece")));
   3572       Assert.assertFalse(message.hasField(f("optional_cord")));
   3573 
   3574       // Optional fields without defaults are set to zero or something like it.
   3575       Assert.assertEquals(0    , message.getField(f("optional_int32"   )));
   3576       Assert.assertEquals(0L   , message.getField(f("optional_int64"   )));
   3577       Assert.assertEquals(0    , message.getField(f("optional_uint32"  )));
   3578       Assert.assertEquals(0L   , message.getField(f("optional_uint64"  )));
   3579       Assert.assertEquals(0    , message.getField(f("optional_sint32"  )));
   3580       Assert.assertEquals(0L   , message.getField(f("optional_sint64"  )));
   3581       Assert.assertEquals(0    , message.getField(f("optional_fixed32" )));
   3582       Assert.assertEquals(0L   , message.getField(f("optional_fixed64" )));
   3583       Assert.assertEquals(0    , message.getField(f("optional_sfixed32")));
   3584       Assert.assertEquals(0L   , message.getField(f("optional_sfixed64")));
   3585       Assert.assertEquals(0F   , message.getField(f("optional_float"   )));
   3586       Assert.assertEquals(0D   , message.getField(f("optional_double"  )));
   3587       Assert.assertEquals(false, message.getField(f("optional_bool"    )));
   3588       Assert.assertEquals(""   , message.getField(f("optional_string"  )));
   3589       Assert.assertEquals(ByteString.EMPTY, message.getField(f("optional_bytes")));
   3590 
   3591       // Embedded messages should also be clear.
   3592       Assert.assertFalse(
   3593         ((Message)message.getField(f("optionalgroup"))).hasField(groupA));
   3594       Assert.assertFalse(
   3595         ((Message)message.getField(f("optional_nested_message")))
   3596                          .hasField(nestedB));
   3597       Assert.assertFalse(
   3598         ((Message)message.getField(f("optional_foreign_message")))
   3599                          .hasField(foreignC));
   3600       Assert.assertFalse(
   3601         ((Message)message.getField(f("optional_import_message")))
   3602                          .hasField(importD));
   3603       Assert.assertFalse(
   3604         ((Message)message.getField(f("optional_public_import_message")))
   3605                          .hasField(importE));
   3606       Assert.assertFalse(
   3607         ((Message)message.getField(f("optional_lazy_message")))
   3608                          .hasField(nestedB));
   3609 
   3610       Assert.assertEquals(0,
   3611         ((Message)message.getField(f("optionalgroup"))).getField(groupA));
   3612       Assert.assertEquals(0,
   3613         ((Message)message.getField(f("optional_nested_message")))
   3614                          .getField(nestedB));
   3615       Assert.assertEquals(0,
   3616         ((Message)message.getField(f("optional_foreign_message")))
   3617                          .getField(foreignC));
   3618       Assert.assertEquals(0,
   3619         ((Message)message.getField(f("optional_import_message")))
   3620                          .getField(importD));
   3621       Assert.assertEquals(0,
   3622         ((Message)message.getField(f("optional_public_import_message")))
   3623                          .getField(importE));
   3624       Assert.assertEquals(0,
   3625         ((Message)message.getField(f("optional_lazy_message")))
   3626                          .getField(nestedB));
   3627 
   3628       // Enums without defaults are set to the first value in the enum.
   3629       Assert.assertEquals( nestedFoo, message.getField(f("optional_nested_enum" )));
   3630       Assert.assertEquals(foreignFoo, message.getField(f("optional_foreign_enum")));
   3631       Assert.assertEquals( importFoo, message.getField(f("optional_import_enum" )));
   3632 
   3633       Assert.assertEquals("", message.getField(f("optional_string_piece")));
   3634       Assert.assertEquals("", message.getField(f("optional_cord")));
   3635 
   3636       // Repeated fields are empty.
   3637       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_int32"   )));
   3638       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_int64"   )));
   3639       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_uint32"  )));
   3640       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_uint64"  )));
   3641       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sint32"  )));
   3642       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sint64"  )));
   3643       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_fixed32" )));
   3644       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_fixed64" )));
   3645       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sfixed32")));
   3646       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sfixed64")));
   3647       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_float"   )));
   3648       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_double"  )));
   3649       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_bool"    )));
   3650       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_string"  )));
   3651       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_bytes"   )));
   3652 
   3653       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeatedgroup"           )));
   3654       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_nested_message" )));
   3655       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_foreign_message")));
   3656       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_import_message" )));
   3657       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_lazy_message"   )));
   3658       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_nested_enum"    )));
   3659       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_foreign_enum"   )));
   3660       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_import_enum"    )));
   3661 
   3662       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_string_piece")));
   3663       Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_cord")));
   3664 
   3665       // has_blah() should also be false for all default fields.
   3666       Assert.assertFalse(message.hasField(f("default_int32"   )));
   3667       Assert.assertFalse(message.hasField(f("default_int64"   )));
   3668       Assert.assertFalse(message.hasField(f("default_uint32"  )));
   3669       Assert.assertFalse(message.hasField(f("default_uint64"  )));
   3670       Assert.assertFalse(message.hasField(f("default_sint32"  )));
   3671       Assert.assertFalse(message.hasField(f("default_sint64"  )));
   3672       Assert.assertFalse(message.hasField(f("default_fixed32" )));
   3673       Assert.assertFalse(message.hasField(f("default_fixed64" )));
   3674       Assert.assertFalse(message.hasField(f("default_sfixed32")));
   3675       Assert.assertFalse(message.hasField(f("default_sfixed64")));
   3676       Assert.assertFalse(message.hasField(f("default_float"   )));
   3677       Assert.assertFalse(message.hasField(f("default_double"  )));
   3678       Assert.assertFalse(message.hasField(f("default_bool"    )));
   3679       Assert.assertFalse(message.hasField(f("default_string"  )));
   3680       Assert.assertFalse(message.hasField(f("default_bytes"   )));
   3681 
   3682       Assert.assertFalse(message.hasField(f("default_nested_enum" )));
   3683       Assert.assertFalse(message.hasField(f("default_foreign_enum")));
   3684       Assert.assertFalse(message.hasField(f("default_import_enum" )));
   3685 
   3686       Assert.assertFalse(message.hasField(f("default_string_piece" )));
   3687       Assert.assertFalse(message.hasField(f("default_cord" )));
   3688 
   3689       // Fields with defaults have their default values (duh).
   3690       Assert.assertEquals( 41    , message.getField(f("default_int32"   )));
   3691       Assert.assertEquals( 42L   , message.getField(f("default_int64"   )));
   3692       Assert.assertEquals( 43    , message.getField(f("default_uint32"  )));
   3693       Assert.assertEquals( 44L   , message.getField(f("default_uint64"  )));
   3694       Assert.assertEquals(-45    , message.getField(f("default_sint32"  )));
   3695       Assert.assertEquals( 46L   , message.getField(f("default_sint64"  )));
   3696       Assert.assertEquals( 47    , message.getField(f("default_fixed32" )));
   3697       Assert.assertEquals( 48L   , message.getField(f("default_fixed64" )));
   3698       Assert.assertEquals( 49    , message.getField(f("default_sfixed32")));
   3699       Assert.assertEquals(-50L   , message.getField(f("default_sfixed64")));
   3700       Assert.assertEquals( 51.5F , message.getField(f("default_float"   )));
   3701       Assert.assertEquals( 52e3D , message.getField(f("default_double"  )));
   3702       Assert.assertEquals(true   , message.getField(f("default_bool"    )));
   3703       Assert.assertEquals("hello", message.getField(f("default_string"  )));
   3704       Assert.assertEquals(toBytes("world"), message.getField(f("default_bytes")));
   3705 
   3706       Assert.assertEquals( nestedBar, message.getField(f("default_nested_enum" )));
   3707       Assert.assertEquals(foreignBar, message.getField(f("default_foreign_enum")));
   3708       Assert.assertEquals( importBar, message.getField(f("default_import_enum" )));
   3709 
   3710       Assert.assertEquals("abc", message.getField(f("default_string_piece")));
   3711       Assert.assertEquals("123", message.getField(f("default_cord")));
   3712 
   3713       Assert.assertFalse(message.hasField(f("oneof_uint32")));
   3714       Assert.assertFalse(message.hasField(f("oneof_nested_message")));
   3715       Assert.assertFalse(message.hasField(f("oneof_string")));
   3716       Assert.assertFalse(message.hasField(f("oneof_bytes")));
   3717 
   3718       Assert.assertEquals(0, message.getField(f("oneof_uint32")));
   3719       Assert.assertEquals("", message.getField(f("oneof_string")));
   3720       Assert.assertEquals(toBytes(""), message.getField(f("oneof_bytes")));
   3721     }
   3722 
   3723 
   3724     // ---------------------------------------------------------------
   3725 
   3726     public void assertRepeatedFieldsModifiedViaReflection(
   3727         MessageOrBuilder message) {
   3728       // ModifyRepeatedFields only sets the second repeated element of each
   3729       // field.  In addition to verifying this, we also verify that the first
   3730       // element and size were *not* modified.
   3731       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int32"   )));
   3732       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int64"   )));
   3733       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint32"  )));
   3734       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint64"  )));
   3735       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint32"  )));
   3736       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint64"  )));
   3737       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed32" )));
   3738       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed64" )));
   3739       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed32")));
   3740       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed64")));
   3741       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_float"   )));
   3742       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_double"  )));
   3743       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bool"    )));
   3744       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string"  )));
   3745       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bytes"   )));
   3746 
   3747       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeatedgroup"           )));
   3748       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_message" )));
   3749       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_message")));
   3750       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_message" )));
   3751       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_lazy_message"   )));
   3752       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_enum"    )));
   3753       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_enum"   )));
   3754       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_enum"    )));
   3755 
   3756       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string_piece")));
   3757       Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_cord")));
   3758 
   3759       Assert.assertEquals(201  , message.getRepeatedField(f("repeated_int32"   ), 0));
   3760       Assert.assertEquals(202L , message.getRepeatedField(f("repeated_int64"   ), 0));
   3761       Assert.assertEquals(203  , message.getRepeatedField(f("repeated_uint32"  ), 0));
   3762       Assert.assertEquals(204L , message.getRepeatedField(f("repeated_uint64"  ), 0));
   3763       Assert.assertEquals(205  , message.getRepeatedField(f("repeated_sint32"  ), 0));
   3764       Assert.assertEquals(206L , message.getRepeatedField(f("repeated_sint64"  ), 0));
   3765       Assert.assertEquals(207  , message.getRepeatedField(f("repeated_fixed32" ), 0));
   3766       Assert.assertEquals(208L , message.getRepeatedField(f("repeated_fixed64" ), 0));
   3767       Assert.assertEquals(209  , message.getRepeatedField(f("repeated_sfixed32"), 0));
   3768       Assert.assertEquals(210L , message.getRepeatedField(f("repeated_sfixed64"), 0));
   3769       Assert.assertEquals(211F , message.getRepeatedField(f("repeated_float"   ), 0));
   3770       Assert.assertEquals(212D , message.getRepeatedField(f("repeated_double"  ), 0));
   3771       Assert.assertEquals(true , message.getRepeatedField(f("repeated_bool"    ), 0));
   3772       Assert.assertEquals("215", message.getRepeatedField(f("repeated_string"  ), 0));
   3773       Assert.assertEquals(toBytes("216"), message.getRepeatedField(f("repeated_bytes"), 0));
   3774 
   3775       Assert.assertEquals(217,
   3776         ((Message)message.getRepeatedField(f("repeatedgroup"), 0))
   3777                          .getField(repeatedGroupA));
   3778       Assert.assertEquals(218,
   3779         ((Message)message.getRepeatedField(f("repeated_nested_message"), 0))
   3780                          .getField(nestedB));
   3781       Assert.assertEquals(219,
   3782         ((Message)message.getRepeatedField(f("repeated_foreign_message"), 0))
   3783                          .getField(foreignC));
   3784       Assert.assertEquals(220,
   3785         ((Message)message.getRepeatedField(f("repeated_import_message"), 0))
   3786                          .getField(importD));
   3787       Assert.assertEquals(227,
   3788         ((Message)message.getRepeatedField(f("repeated_lazy_message"), 0))
   3789                          .getField(nestedB));
   3790 
   3791       Assert.assertEquals( nestedBar, message.getRepeatedField(f("repeated_nested_enum" ),0));
   3792       Assert.assertEquals(foreignBar, message.getRepeatedField(f("repeated_foreign_enum"),0));
   3793       Assert.assertEquals( importBar, message.getRepeatedField(f("repeated_import_enum" ),0));
   3794 
   3795       Assert.assertEquals("224", message.getRepeatedField(f("repeated_string_piece"), 0));
   3796       Assert.assertEquals("225", message.getRepeatedField(f("repeated_cord"), 0));
   3797 
   3798       Assert.assertEquals(501  , message.getRepeatedField(f("repeated_int32"   ), 1));
   3799       Assert.assertEquals(502L , message.getRepeatedField(f("repeated_int64"   ), 1));
   3800       Assert.assertEquals(503  , message.getRepeatedField(f("repeated_uint32"  ), 1));
   3801       Assert.assertEquals(504L , message.getRepeatedField(f("repeated_uint64"  ), 1));
   3802       Assert.assertEquals(505  , message.getRepeatedField(f("repeated_sint32"  ), 1));
   3803       Assert.assertEquals(506L , message.getRepeatedField(f("repeated_sint64"  ), 1));
   3804       Assert.assertEquals(507  , message.getRepeatedField(f("repeated_fixed32" ), 1));
   3805       Assert.assertEquals(508L , message.getRepeatedField(f("repeated_fixed64" ), 1));
   3806       Assert.assertEquals(509  , message.getRepeatedField(f("repeated_sfixed32"), 1));
   3807       Assert.assertEquals(510L , message.getRepeatedField(f("repeated_sfixed64"), 1));
   3808       Assert.assertEquals(511F , message.getRepeatedField(f("repeated_float"   ), 1));
   3809       Assert.assertEquals(512D , message.getRepeatedField(f("repeated_double"  ), 1));
   3810       Assert.assertEquals(true , message.getRepeatedField(f("repeated_bool"    ), 1));
   3811       Assert.assertEquals("515", message.getRepeatedField(f("repeated_string"  ), 1));
   3812       Assert.assertEquals(toBytes("516"), message.getRepeatedField(f("repeated_bytes"), 1));
   3813 
   3814       Assert.assertEquals(517,
   3815         ((Message)message.getRepeatedField(f("repeatedgroup"), 1))
   3816                          .getField(repeatedGroupA));
   3817       Assert.assertEquals(518,
   3818         ((Message)message.getRepeatedField(f("repeated_nested_message"), 1))
   3819                          .getField(nestedB));
   3820       Assert.assertEquals(519,
   3821         ((Message)message.getRepeatedField(f("repeated_foreign_message"), 1))
   3822                          .getField(foreignC));
   3823       Assert.assertEquals(520,
   3824         ((Message)message.getRepeatedField(f("repeated_import_message"), 1))
   3825                          .getField(importD));
   3826       Assert.assertEquals(527,
   3827         ((Message)message.getRepeatedField(f("repeated_lazy_message"), 1))
   3828                          .getField(nestedB));
   3829 
   3830       Assert.assertEquals( nestedFoo, message.getRepeatedField(f("repeated_nested_enum" ),1));
   3831       Assert.assertEquals(foreignFoo, message.getRepeatedField(f("repeated_foreign_enum"),1));
   3832       Assert.assertEquals( importFoo, message.getRepeatedField(f("repeated_import_enum" ),1));
   3833 
   3834       Assert.assertEquals("524", message.getRepeatedField(f("repeated_string_piece"), 1));
   3835       Assert.assertEquals("525", message.getRepeatedField(f("repeated_cord"), 1));
   3836     }
   3837 
   3838     public void setPackedFieldsViaReflection(Message.Builder message) {
   3839       message.addRepeatedField(f("packed_int32"   ), 601 );
   3840       message.addRepeatedField(f("packed_int64"   ), 602L);
   3841       message.addRepeatedField(f("packed_uint32"  ), 603 );
   3842       message.addRepeatedField(f("packed_uint64"  ), 604L);
   3843       message.addRepeatedField(f("packed_sint32"  ), 605 );
   3844       message.addRepeatedField(f("packed_sint64"  ), 606L);
   3845       message.addRepeatedField(f("packed_fixed32" ), 607 );
   3846       message.addRepeatedField(f("packed_fixed64" ), 608L);
   3847       message.addRepeatedField(f("packed_sfixed32"), 609 );
   3848       message.addRepeatedField(f("packed_sfixed64"), 610L);
   3849       message.addRepeatedField(f("packed_float"   ), 611F);
   3850       message.addRepeatedField(f("packed_double"  ), 612D);
   3851       message.addRepeatedField(f("packed_bool"    ), true);
   3852       message.addRepeatedField(f("packed_enum" ),  foreignBar);
   3853       // Add a second one of each field.
   3854       message.addRepeatedField(f("packed_int32"   ), 701 );
   3855       message.addRepeatedField(f("packed_int64"   ), 702L);
   3856       message.addRepeatedField(f("packed_uint32"  ), 703 );
   3857       message.addRepeatedField(f("packed_uint64"  ), 704L);
   3858       message.addRepeatedField(f("packed_sint32"  ), 705 );
   3859       message.addRepeatedField(f("packed_sint64"  ), 706L);
   3860       message.addRepeatedField(f("packed_fixed32" ), 707 );
   3861       message.addRepeatedField(f("packed_fixed64" ), 708L);
   3862       message.addRepeatedField(f("packed_sfixed32"), 709 );
   3863       message.addRepeatedField(f("packed_sfixed64"), 710L);
   3864       message.addRepeatedField(f("packed_float"   ), 711F);
   3865       message.addRepeatedField(f("packed_double"  ), 712D);
   3866       message.addRepeatedField(f("packed_bool"    ), false);
   3867       message.addRepeatedField(f("packed_enum" ),  foreignBaz);
   3868     }
   3869 
   3870     public void assertPackedFieldsSetViaReflection(MessageOrBuilder message) {
   3871       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int32"   )));
   3872       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int64"   )));
   3873       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint32"  )));
   3874       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint64"  )));
   3875       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint32"  )));
   3876       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint64"  )));
   3877       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed32" )));
   3878       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed64" )));
   3879       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed32")));
   3880       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed64")));
   3881       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_float"   )));
   3882       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_double"  )));
   3883       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_bool"    )));
   3884       Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_enum"   )));
   3885       Assert.assertEquals(601  , message.getRepeatedField(f("packed_int32"   ), 0));
   3886       Assert.assertEquals(602L , message.getRepeatedField(f("packed_int64"   ), 0));
   3887       Assert.assertEquals(603  , message.getRepeatedField(f("packed_uint32"  ), 0));
   3888       Assert.assertEquals(604L , message.getRepeatedField(f("packed_uint64"  ), 0));
   3889       Assert.assertEquals(605  , message.getRepeatedField(f("packed_sint32"  ), 0));
   3890       Assert.assertEquals(606L , message.getRepeatedField(f("packed_sint64"  ), 0));
   3891       Assert.assertEquals(607  , message.getRepeatedField(f("packed_fixed32" ), 0));
   3892       Assert.assertEquals(608L , message.getRepeatedField(f("packed_fixed64" ), 0));
   3893       Assert.assertEquals(609  , message.getRepeatedField(f("packed_sfixed32"), 0));
   3894       Assert.assertEquals(610L , message.getRepeatedField(f("packed_sfixed64"), 0));
   3895       Assert.assertEquals(611F , message.getRepeatedField(f("packed_float"   ), 0));
   3896       Assert.assertEquals(612D , message.getRepeatedField(f("packed_double"  ), 0));
   3897       Assert.assertEquals(true , message.getRepeatedField(f("packed_bool"    ), 0));
   3898       Assert.assertEquals(foreignBar, message.getRepeatedField(f("packed_enum" ),0));
   3899       Assert.assertEquals(701  , message.getRepeatedField(f("packed_int32"   ), 1));
   3900       Assert.assertEquals(702L , message.getRepeatedField(f("packed_int64"   ), 1));
   3901       Assert.assertEquals(703  , message.getRepeatedField(f("packed_uint32"  ), 1));
   3902       Assert.assertEquals(704L , message.getRepeatedField(f("packed_uint64"  ), 1));
   3903       Assert.assertEquals(705  , message.getRepeatedField(f("packed_sint32"  ), 1));
   3904       Assert.assertEquals(706L , message.getRepeatedField(f("packed_sint64"  ), 1));
   3905       Assert.assertEquals(707  , message.getRepeatedField(f("packed_fixed32" ), 1));
   3906       Assert.assertEquals(708L , message.getRepeatedField(f("packed_fixed64" ), 1));
   3907       Assert.assertEquals(709  , message.getRepeatedField(f("packed_sfixed32"), 1));
   3908       Assert.assertEquals(710L , message.getRepeatedField(f("packed_sfixed64"), 1));
   3909       Assert.assertEquals(711F , message.getRepeatedField(f("packed_float"   ), 1));
   3910       Assert.assertEquals(712D , message.getRepeatedField(f("packed_double"  ), 1));
   3911       Assert.assertEquals(false, message.getRepeatedField(f("packed_bool"    ), 1));
   3912       Assert.assertEquals(foreignBaz, message.getRepeatedField(f("packed_enum" ),1));
   3913     }
   3914 
   3915     /**
   3916      * Verifies that the reflection setters for the given.Builder object throw a
   3917      * NullPointerException if they are passed a null value.  Uses Assert to throw an
   3918      * appropriate assertion failure, if the condition is not verified.
   3919      */
   3920     public void assertReflectionSettersRejectNull(Message.Builder builder)
   3921         throws Exception {
   3922       try {
   3923         builder.setField(f("optional_string"), null);
   3924         Assert.fail("Exception was not thrown");
   3925       } catch (NullPointerException e) {
   3926         // We expect this exception.
   3927       }
   3928       try {
   3929         builder.setField(f("optional_bytes"), null);
   3930         Assert.fail("Exception was not thrown");
   3931       } catch (NullPointerException e) {
   3932         // We expect this exception.
   3933       }
   3934       try {
   3935         builder.setField(f("optional_nested_enum"), null);
   3936         Assert.fail("Exception was not thrown");
   3937       } catch (NullPointerException e) {
   3938         // We expect this exception.
   3939       }
   3940       try {
   3941         builder.setField(f("optional_nested_message"),
   3942                          (TestAllTypes.NestedMessage) null);
   3943         Assert.fail("Exception was not thrown");
   3944       } catch (NullPointerException e) {
   3945         // We expect this exception.
   3946       }
   3947       try {
   3948         builder.setField(f("optional_nested_message"),
   3949                          (TestAllTypes.NestedMessage.Builder) null);
   3950         Assert.fail("Exception was not thrown");
   3951       } catch (NullPointerException e) {
   3952         // We expect this exception.
   3953       }
   3954 
   3955       try {
   3956         builder.addRepeatedField(f("repeated_string"), null);
   3957         Assert.fail("Exception was not thrown");
   3958       } catch (NullPointerException e) {
   3959         // We expect this exception.
   3960       }
   3961       try {
   3962         builder.addRepeatedField(f("repeated_bytes"), null);
   3963         Assert.fail("Exception was not thrown");
   3964       } catch (NullPointerException e) {
   3965         // We expect this exception.
   3966       }
   3967       try {
   3968         builder.addRepeatedField(f("repeated_nested_enum"), null);
   3969         Assert.fail("Exception was not thrown");
   3970       } catch (NullPointerException e) {
   3971         // We expect this exception.
   3972       }
   3973       try {
   3974         builder.addRepeatedField(f("repeated_nested_message"), null);
   3975         Assert.fail("Exception was not thrown");
   3976       } catch (NullPointerException e) {
   3977         // We expect this exception.
   3978       }
   3979     }
   3980 
   3981     /**
   3982      * Verifies that the reflection repeated setters for the given Builder object throw a
   3983      * NullPointerException if they are passed a null value.  Uses Assert to throw an appropriate
   3984      * assertion failure, if the condition is not verified.
   3985      */
   3986     public void assertReflectionRepeatedSettersRejectNull(Message.Builder builder)
   3987         throws Exception {
   3988       builder.addRepeatedField(f("repeated_string"), "one");
   3989       try {
   3990         builder.setRepeatedField(f("repeated_string"), 0, null);
   3991         Assert.fail("Exception was not thrown");
   3992       } catch (NullPointerException e) {
   3993         // We expect this exception.
   3994       }
   3995 
   3996       builder.addRepeatedField(f("repeated_bytes"), toBytes("one"));
   3997       try {
   3998         builder.setRepeatedField(f("repeated_bytes"), 0, null);
   3999         Assert.fail("Exception was not thrown");
   4000       } catch (NullPointerException e) {
   4001         // We expect this exception.
   4002       }
   4003 
   4004       builder.addRepeatedField(f("repeated_nested_enum"), nestedBaz);
   4005       try {
   4006         builder.setRepeatedField(f("repeated_nested_enum"), 0, null);
   4007         Assert.fail("Exception was not thrown");
   4008       } catch (NullPointerException e) {
   4009         // We expect this exception.
   4010       }
   4011 
   4012       builder.addRepeatedField(
   4013           f("repeated_nested_message"),
   4014           TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
   4015       try {
   4016         builder.setRepeatedField(f("repeated_nested_message"), 0, null);
   4017         Assert.fail("Exception was not thrown");
   4018       } catch (NullPointerException e) {
   4019         // We expect this exception.
   4020       }
   4021     }
   4022   }
   4023 
   4024   /**
   4025    * @param filePath The path relative to
   4026    * {@link #getTestDataDir}.
   4027    */
   4028   public static String readTextFromFile(String filePath) {
   4029     return readBytesFromFile(filePath).toStringUtf8();
   4030   }
   4031 
   4032   private static File getTestDataDir() {
   4033     // Search each parent directory looking for "src/google/protobuf".
   4034     File ancestor = new File(".");
   4035     try {
   4036       ancestor = ancestor.getCanonicalFile();
   4037     } catch (IOException e) {
   4038       throw new RuntimeException(
   4039         "Couldn't get canonical name of working directory.", e);
   4040     }
   4041     while (ancestor != null && ancestor.exists()) {
   4042       if (new File(ancestor, "src/google/protobuf").exists()) {
   4043         return new File(ancestor, "src/google/protobuf/testdata");
   4044       }
   4045       ancestor = ancestor.getParentFile();
   4046     }
   4047 
   4048     throw new RuntimeException(
   4049       "Could not find golden files.  This test must be run from within the " +
   4050       "protobuf source package so that it can read test data files from the " +
   4051       "C++ source tree.");
   4052   }
   4053 
   4054   /**
   4055    * @param filename The path relative to
   4056    * {@link #getTestDataDir}.
   4057    */
   4058   public static ByteString readBytesFromFile(String filename) {
   4059     File fullPath = new File(getTestDataDir(), filename);
   4060     try {
   4061       RandomAccessFile file = new RandomAccessFile(fullPath, "r");
   4062       byte[] content = new byte[(int) file.length()];
   4063       file.readFully(content);
   4064       return ByteString.copyFrom(content);
   4065     } catch (IOException e) {
   4066       // Throw a RuntimeException here so that we can call this function from
   4067       // static initializers.
   4068       throw new IllegalArgumentException(
   4069         "Couldn't read file: " + fullPath.getPath(), e);
   4070     }
   4071   }
   4072 
   4073   /**
   4074    * Get the bytes of the "golden message".  This is a serialized TestAllTypes
   4075    * with all fields set as they would be by
   4076    * {@link #setAllFields(TestAllTypes.Builder)}, but it is loaded from a file
   4077    * on disk rather than generated dynamically.  The file is actually generated
   4078    * by C++ code, so testing against it verifies compatibility with C++.
   4079    */
   4080   public static ByteString getGoldenMessage() {
   4081     if (goldenMessage == null) {
   4082       goldenMessage = readBytesFromFile("golden_message_oneof_implemented");
   4083     }
   4084     return goldenMessage;
   4085   }
   4086   private static ByteString goldenMessage = null;
   4087 
   4088   /**
   4089    * Get the bytes of the "golden packed fields message".  This is a serialized
   4090    * TestPackedTypes with all fields set as they would be by
   4091    * {@link #setPackedFields(TestPackedTypes.Builder)}, but it is loaded from a
   4092    * file on disk rather than generated dynamically.  The file is actually
   4093    * generated by C++ code, so testing against it verifies compatibility with
   4094    * C++.
   4095    */
   4096   public static ByteString getGoldenPackedFieldsMessage() {
   4097     if (goldenPackedFieldsMessage == null) {
   4098       goldenPackedFieldsMessage =
   4099           readBytesFromFile("golden_packed_fields_message");
   4100     }
   4101     return goldenPackedFieldsMessage;
   4102   }
   4103   private static ByteString goldenPackedFieldsMessage = null;
   4104 
   4105   /**
   4106    * Mock implementation of {@link GeneratedMessage.BuilderParent} for testing.
   4107    *
   4108    * @author jonp (at) google.com (Jon Perlow)
   4109    */
   4110   public static class MockBuilderParent
   4111       implements GeneratedMessage.BuilderParent {
   4112 
   4113     private int invalidations;
   4114 
   4115     //@Override (Java 1.6 override semantics, but we must support 1.5)
   4116     public void markDirty() {
   4117       invalidations++;
   4118     }
   4119 
   4120     public int getInvalidationCount() {
   4121       return invalidations;
   4122     }
   4123   }
   4124 }
   4125