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