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