1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc.  All rights reserved.
3// http://code.google.com/p/protobuf/
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions are
7// met:
8//
9//     * Redistributions of source code must retain the above copyright
10// notice, this list of conditions and the following disclaimer.
11//     * Redistributions in binary form must reproduce the above
12// copyright notice, this list of conditions and the following disclaimer
13// in the documentation and/or other materials provided with the
14// distribution.
15//     * Neither the name of Google Inc. nor the names of its
16// contributors may be used to endorse or promote products derived from
17// this software without specific prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31package com.google.protobuf;
32
33import protobuf_unittest.UnittestOptimizeFor.TestOptimizedForSize;
34import protobuf_unittest.UnittestOptimizeFor.TestOptionalOptimizedForSize;
35import protobuf_unittest.UnittestOptimizeFor.TestRequiredOptimizedForSize;
36import protobuf_unittest.UnittestProto;
37import protobuf_unittest.UnittestProto.ForeignMessage;
38import protobuf_unittest.UnittestProto.ForeignEnum;
39import protobuf_unittest.UnittestProto.TestAllTypes;
40import protobuf_unittest.UnittestProto.TestAllExtensions;
41import protobuf_unittest.UnittestProto.TestExtremeDefaultValues;
42import protobuf_unittest.UnittestProto.TestPackedTypes;
43import protobuf_unittest.UnittestProto.TestUnpackedTypes;
44import protobuf_unittest.MultipleFilesTestProto;
45import protobuf_unittest.MessageWithNoOuter;
46import protobuf_unittest.EnumWithNoOuter;
47import protobuf_unittest.ServiceWithNoOuter;
48import com.google.protobuf.UnittestLite;
49import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
50
51import junit.framework.TestCase;
52import java.util.Arrays;
53
54/**
55 * Unit test for generated messages and generated code.  See also
56 * {@link MessageTest}, which tests some generated message functionality.
57 *
58 * @author kenton@google.com Kenton Varda
59 */
60public class GeneratedMessageTest extends TestCase {
61  TestUtil.ReflectionTester reflectionTester =
62    new TestUtil.ReflectionTester(TestAllTypes.getDescriptor(), null);
63
64  public void testDefaultInstance() throws Exception {
65    assertSame(TestAllTypes.getDefaultInstance(),
66               TestAllTypes.getDefaultInstance().getDefaultInstanceForType());
67    assertSame(TestAllTypes.getDefaultInstance(),
68               TestAllTypes.newBuilder().getDefaultInstanceForType());
69  }
70
71  public void testAccessors() throws Exception {
72    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
73    TestUtil.setAllFields(builder);
74    TestAllTypes message = builder.build();
75    TestUtil.assertAllFieldsSet(message);
76  }
77
78  public void testDoubleBuildError() throws Exception {
79    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
80    builder.build();
81    try {
82      builder.build();
83      fail("Should have thrown exception.");
84    } catch (IllegalStateException e) {
85      // Success.
86    }
87  }
88
89  public void testClearAfterBuildError() throws Exception {
90    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
91    builder.build();
92    try {
93      builder.clear();
94      fail("Should have thrown exception.");
95    } catch (IllegalStateException e) {
96      // Success.
97    }
98  }
99
100  public void testSettersRejectNull() throws Exception {
101    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
102    try {
103      builder.setOptionalString(null);
104      fail("Exception was not thrown");
105    } catch (NullPointerException e) {
106      // We expect this exception.
107    }
108    try {
109      builder.setOptionalBytes(null);
110      fail("Exception was not thrown");
111    } catch (NullPointerException e) {
112      // We expect this exception.
113    }
114    try {
115      builder.setOptionalNestedMessage((TestAllTypes.NestedMessage) null);
116      fail("Exception was not thrown");
117    } catch (NullPointerException e) {
118      // We expect this exception.
119    }
120    try {
121      builder.setOptionalNestedMessage(
122          (TestAllTypes.NestedMessage.Builder) null);
123      fail("Exception was not thrown");
124    } catch (NullPointerException e) {
125      // We expect this exception.
126    }
127    try {
128      builder.setOptionalNestedEnum(null);
129      fail("Exception was not thrown");
130    } catch (NullPointerException e) {
131      // We expect this exception.
132    }
133    try {
134      builder.addRepeatedString(null);
135      fail("Exception was not thrown");
136    } catch (NullPointerException e) {
137      // We expect this exception.
138    }
139    try {
140      builder.addRepeatedBytes(null);
141      fail("Exception was not thrown");
142    } catch (NullPointerException e) {
143      // We expect this exception.
144    }
145    try {
146      builder.addRepeatedNestedMessage((TestAllTypes.NestedMessage) null);
147      fail("Exception was not thrown");
148    } catch (NullPointerException e) {
149      // We expect this exception.
150    }
151    try {
152      builder.addRepeatedNestedMessage(
153          (TestAllTypes.NestedMessage.Builder) null);
154      fail("Exception was not thrown");
155    } catch (NullPointerException e) {
156      // We expect this exception.
157    }
158    try {
159      builder.addRepeatedNestedEnum(null);
160      fail("Exception was not thrown");
161    } catch (NullPointerException e) {
162      // We expect this exception.
163    }
164  }
165
166  public void testRepeatedSetters() throws Exception {
167    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
168    TestUtil.setAllFields(builder);
169    TestUtil.modifyRepeatedFields(builder);
170    TestAllTypes message = builder.build();
171    TestUtil.assertRepeatedFieldsModified(message);
172  }
173
174  public void testRepeatedSettersRejectNull() throws Exception {
175    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
176
177    builder.addRepeatedString("one");
178    builder.addRepeatedString("two");
179    try {
180      builder.setRepeatedString(1, null);
181      fail("Exception was not thrown");
182    } catch (NullPointerException e) {
183      // We expect this exception.
184    }
185
186    builder.addRepeatedBytes(TestUtil.toBytes("one"));
187    builder.addRepeatedBytes(TestUtil.toBytes("two"));
188    try {
189      builder.setRepeatedBytes(1, null);
190      fail("Exception was not thrown");
191    } catch (NullPointerException e) {
192      // We expect this exception.
193    }
194
195    builder.addRepeatedNestedMessage(
196      TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
197    builder.addRepeatedNestedMessage(
198      TestAllTypes.NestedMessage.newBuilder().setBb(456).build());
199    try {
200      builder.setRepeatedNestedMessage(1, (TestAllTypes.NestedMessage) null);
201      fail("Exception was not thrown");
202    } catch (NullPointerException e) {
203      // We expect this exception.
204    }
205    try {
206      builder.setRepeatedNestedMessage(
207          1, (TestAllTypes.NestedMessage.Builder) null);
208      fail("Exception was not thrown");
209    } catch (NullPointerException e) {
210      // We expect this exception.
211    }
212
213    builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.FOO);
214    builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR);
215    try {
216      builder.setRepeatedNestedEnum(1, null);
217      fail("Exception was not thrown");
218    } catch (NullPointerException e) {
219      // We expect this exception.
220    }
221  }
222
223  public void testRepeatedAppend() throws Exception {
224    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
225
226    builder.addAllRepeatedInt32(Arrays.asList(1, 2, 3, 4));
227    builder.addAllRepeatedForeignEnum(Arrays.asList(ForeignEnum.FOREIGN_BAZ));
228
229    ForeignMessage foreignMessage =
230        ForeignMessage.newBuilder().setC(12).build();
231    builder.addAllRepeatedForeignMessage(Arrays.asList(foreignMessage));
232
233    TestAllTypes message = builder.build();
234    assertEquals(message.getRepeatedInt32List(), Arrays.asList(1, 2, 3, 4));
235    assertEquals(message.getRepeatedForeignEnumList(),
236        Arrays.asList(ForeignEnum.FOREIGN_BAZ));
237    assertEquals(1, message.getRepeatedForeignMessageCount());
238    assertEquals(12, message.getRepeatedForeignMessage(0).getC());
239  }
240
241  public void testRepeatedAppendRejectsNull() throws Exception {
242    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
243
244    ForeignMessage foreignMessage =
245        ForeignMessage.newBuilder().setC(12).build();
246    try {
247      builder.addAllRepeatedForeignMessage(
248          Arrays.asList(foreignMessage, (ForeignMessage) null));
249      fail("Exception was not thrown");
250    } catch (NullPointerException e) {
251      // We expect this exception.
252    }
253
254    try {
255      builder.addAllRepeatedForeignEnum(
256          Arrays.asList(ForeignEnum.FOREIGN_BAZ, null));
257      fail("Exception was not thrown");
258    } catch (NullPointerException e) {
259      // We expect this exception.
260    }
261
262    try {
263      builder.addAllRepeatedString(Arrays.asList("one", null));
264      fail("Exception was not thrown");
265    } catch (NullPointerException e) {
266      // We expect this exception.
267    }
268
269    try {
270      builder.addAllRepeatedBytes(Arrays.asList(TestUtil.toBytes("one"), null));
271      fail("Exception was not thrown");
272    } catch (NullPointerException e) {
273      // We expect this exception.
274    }
275  }
276
277  public void testSettingForeignMessageUsingBuilder() throws Exception {
278    TestAllTypes message = TestAllTypes.newBuilder()
279        // Pass builder for foreign message instance.
280        .setOptionalForeignMessage(ForeignMessage.newBuilder().setC(123))
281        .build();
282    TestAllTypes expectedMessage = TestAllTypes.newBuilder()
283        // Create expected version passing foreign message instance explicitly.
284        .setOptionalForeignMessage(
285            ForeignMessage.newBuilder().setC(123).build())
286        .build();
287    // TODO(ngd): Upgrade to using real #equals method once implemented
288    assertEquals(expectedMessage.toString(), message.toString());
289  }
290
291  public void testSettingRepeatedForeignMessageUsingBuilder() throws Exception {
292    TestAllTypes message = TestAllTypes.newBuilder()
293        // Pass builder for foreign message instance.
294        .addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(456))
295        .build();
296    TestAllTypes expectedMessage = TestAllTypes.newBuilder()
297        // Create expected version passing foreign message instance explicitly.
298        .addRepeatedForeignMessage(
299            ForeignMessage.newBuilder().setC(456).build())
300        .build();
301    assertEquals(expectedMessage.toString(), message.toString());
302  }
303
304  public void testDefaults() throws Exception {
305    TestUtil.assertClear(TestAllTypes.getDefaultInstance());
306    TestUtil.assertClear(TestAllTypes.newBuilder().build());
307
308    TestExtremeDefaultValues message =
309        TestExtremeDefaultValues.getDefaultInstance();
310    assertEquals("\u1234", message.getUtf8String());
311    assertEquals(Double.POSITIVE_INFINITY, message.getInfDouble());
312    assertEquals(Double.NEGATIVE_INFINITY, message.getNegInfDouble());
313    assertTrue(Double.isNaN(message.getNanDouble()));
314    assertEquals(Float.POSITIVE_INFINITY, message.getInfFloat());
315    assertEquals(Float.NEGATIVE_INFINITY, message.getNegInfFloat());
316    assertTrue(Float.isNaN(message.getNanFloat()));
317  }
318
319  public void testReflectionGetters() throws Exception {
320    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
321    TestUtil.setAllFields(builder);
322    TestAllTypes message = builder.build();
323    reflectionTester.assertAllFieldsSetViaReflection(message);
324  }
325
326  public void testReflectionSetters() throws Exception {
327    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
328    reflectionTester.setAllFieldsViaReflection(builder);
329    TestAllTypes message = builder.build();
330    TestUtil.assertAllFieldsSet(message);
331  }
332
333  public void testReflectionSettersRejectNull() throws Exception {
334    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
335    reflectionTester.assertReflectionSettersRejectNull(builder);
336  }
337
338  public void testReflectionRepeatedSetters() throws Exception {
339    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
340    reflectionTester.setAllFieldsViaReflection(builder);
341    reflectionTester.modifyRepeatedFieldsViaReflection(builder);
342    TestAllTypes message = builder.build();
343    TestUtil.assertRepeatedFieldsModified(message);
344  }
345
346  public void testReflectionRepeatedSettersRejectNull() throws Exception {
347    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
348    reflectionTester.assertReflectionRepeatedSettersRejectNull(builder);
349  }
350
351  public void testReflectionDefaults() throws Exception {
352    reflectionTester.assertClearViaReflection(
353      TestAllTypes.getDefaultInstance());
354    reflectionTester.assertClearViaReflection(
355      TestAllTypes.newBuilder().build());
356  }
357
358  public void testEnumInterface() throws Exception {
359    assertTrue(TestAllTypes.getDefaultInstance().getDefaultNestedEnum()
360        instanceof ProtocolMessageEnum);
361  }
362
363  public void testEnumMap() throws Exception {
364    Internal.EnumLiteMap<ForeignEnum> map = ForeignEnum.internalGetValueMap();
365
366    for (ForeignEnum value : ForeignEnum.values()) {
367      assertEquals(value, map.findValueByNumber(value.getNumber()));
368    }
369
370    assertTrue(map.findValueByNumber(12345) == null);
371  }
372
373  public void testParsePackedToUnpacked() throws Exception {
374    TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder();
375    TestUnpackedTypes message =
376      builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build();
377    TestUtil.assertUnpackedFieldsSet(message);
378  }
379
380  public void testParseUnpackedToPacked() throws Exception {
381    TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
382    TestPackedTypes message =
383      builder.mergeFrom(TestUtil.getUnpackedSet().toByteString()).build();
384    TestUtil.assertPackedFieldsSet(message);
385  }
386
387  // =================================================================
388  // Extensions.
389
390  TestUtil.ReflectionTester extensionsReflectionTester =
391    new TestUtil.ReflectionTester(TestAllExtensions.getDescriptor(),
392                                  TestUtil.getExtensionRegistry());
393
394  public void testExtensionAccessors() throws Exception {
395    TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
396    TestUtil.setAllExtensions(builder);
397    TestAllExtensions message = builder.build();
398    TestUtil.assertAllExtensionsSet(message);
399  }
400
401  public void testExtensionRepeatedSetters() throws Exception {
402    TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
403    TestUtil.setAllExtensions(builder);
404    TestUtil.modifyRepeatedExtensions(builder);
405    TestAllExtensions message = builder.build();
406    TestUtil.assertRepeatedExtensionsModified(message);
407  }
408
409  public void testExtensionDefaults() throws Exception {
410    TestUtil.assertExtensionsClear(TestAllExtensions.getDefaultInstance());
411    TestUtil.assertExtensionsClear(TestAllExtensions.newBuilder().build());
412  }
413
414  public void testExtensionReflectionGetters() throws Exception {
415    TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
416    TestUtil.setAllExtensions(builder);
417    TestAllExtensions message = builder.build();
418    extensionsReflectionTester.assertAllFieldsSetViaReflection(message);
419  }
420
421  public void testExtensionReflectionSetters() throws Exception {
422    TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
423    extensionsReflectionTester.setAllFieldsViaReflection(builder);
424    TestAllExtensions message = builder.build();
425    TestUtil.assertAllExtensionsSet(message);
426  }
427
428  public void testExtensionReflectionSettersRejectNull() throws Exception {
429    TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
430    extensionsReflectionTester.assertReflectionSettersRejectNull(builder);
431  }
432
433  public void testExtensionReflectionRepeatedSetters() throws Exception {
434    TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
435    extensionsReflectionTester.setAllFieldsViaReflection(builder);
436    extensionsReflectionTester.modifyRepeatedFieldsViaReflection(builder);
437    TestAllExtensions message = builder.build();
438    TestUtil.assertRepeatedExtensionsModified(message);
439  }
440
441  public void testExtensionReflectionRepeatedSettersRejectNull()
442      throws Exception {
443    TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
444    extensionsReflectionTester.assertReflectionRepeatedSettersRejectNull(
445        builder);
446  }
447
448  public void testExtensionReflectionDefaults() throws Exception {
449    extensionsReflectionTester.assertClearViaReflection(
450      TestAllExtensions.getDefaultInstance());
451    extensionsReflectionTester.assertClearViaReflection(
452      TestAllExtensions.newBuilder().build());
453  }
454
455  public void testClearExtension() throws Exception {
456    // clearExtension() is not actually used in TestUtil, so try it manually.
457    assertFalse(
458      TestAllExtensions.newBuilder()
459        .setExtension(UnittestProto.optionalInt32Extension, 1)
460        .clearExtension(UnittestProto.optionalInt32Extension)
461        .hasExtension(UnittestProto.optionalInt32Extension));
462    assertEquals(0,
463      TestAllExtensions.newBuilder()
464        .addExtension(UnittestProto.repeatedInt32Extension, 1)
465        .clearExtension(UnittestProto.repeatedInt32Extension)
466        .getExtensionCount(UnittestProto.repeatedInt32Extension));
467  }
468
469  public void testExtensionCopy() throws Exception {
470    TestAllExtensions original = TestUtil.getAllExtensionsSet();
471    TestAllExtensions copy = TestAllExtensions.newBuilder(original).build();
472    TestUtil.assertAllExtensionsSet(copy);
473  }
474
475  public void testExtensionMergeFrom() throws Exception {
476    TestAllExtensions original =
477      TestAllExtensions.newBuilder()
478        .setExtension(UnittestProto.optionalInt32Extension, 1).build();
479    TestAllExtensions merged =
480        TestAllExtensions.newBuilder().mergeFrom(original).build();
481    assertTrue(merged.hasExtension(UnittestProto.optionalInt32Extension));
482    assertEquals(
483        1, (int) merged.getExtension(UnittestProto.optionalInt32Extension));
484  }
485
486  // =================================================================
487  // Lite Extensions.
488
489  // We test lite extensions directly because they have a separate
490  // implementation from full extensions.  In contrast, we do not test
491  // lite fields directly since they are implemented exactly the same as
492  // regular fields.
493
494  public void testLiteExtensionAccessors() throws Exception {
495    TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
496    TestUtil.setAllExtensions(builder);
497    TestAllExtensionsLite message = builder.build();
498    TestUtil.assertAllExtensionsSet(message);
499  }
500
501  public void testLiteExtensionRepeatedSetters() throws Exception {
502    TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
503    TestUtil.setAllExtensions(builder);
504    TestUtil.modifyRepeatedExtensions(builder);
505    TestAllExtensionsLite message = builder.build();
506    TestUtil.assertRepeatedExtensionsModified(message);
507  }
508
509  public void testLiteExtensionDefaults() throws Exception {
510    TestUtil.assertExtensionsClear(TestAllExtensionsLite.getDefaultInstance());
511    TestUtil.assertExtensionsClear(TestAllExtensionsLite.newBuilder().build());
512  }
513
514  public void testClearLiteExtension() throws Exception {
515    // clearExtension() is not actually used in TestUtil, so try it manually.
516    assertFalse(
517      TestAllExtensionsLite.newBuilder()
518        .setExtension(UnittestLite.optionalInt32ExtensionLite, 1)
519        .clearExtension(UnittestLite.optionalInt32ExtensionLite)
520        .hasExtension(UnittestLite.optionalInt32ExtensionLite));
521    assertEquals(0,
522      TestAllExtensionsLite.newBuilder()
523        .addExtension(UnittestLite.repeatedInt32ExtensionLite, 1)
524        .clearExtension(UnittestLite.repeatedInt32ExtensionLite)
525        .getExtensionCount(UnittestLite.repeatedInt32ExtensionLite));
526  }
527
528  public void testLiteExtensionCopy() throws Exception {
529    TestAllExtensionsLite original = TestUtil.getAllLiteExtensionsSet();
530    TestAllExtensionsLite copy =
531        TestAllExtensionsLite.newBuilder(original).build();
532    TestUtil.assertAllExtensionsSet(copy);
533  }
534
535  public void testLiteExtensionMergeFrom() throws Exception {
536    TestAllExtensionsLite original =
537      TestAllExtensionsLite.newBuilder()
538        .setExtension(UnittestLite.optionalInt32ExtensionLite, 1).build();
539    TestAllExtensionsLite merged =
540        TestAllExtensionsLite.newBuilder().mergeFrom(original).build();
541    assertTrue(merged.hasExtension(UnittestLite.optionalInt32ExtensionLite));
542    assertEquals(
543        1, (int) merged.getExtension(UnittestLite.optionalInt32ExtensionLite));
544  }
545
546  // =================================================================
547  // multiple_files_test
548
549  public void testMultipleFilesOption() throws Exception {
550    // We mostly just want to check that things compile.
551    MessageWithNoOuter message =
552      MessageWithNoOuter.newBuilder()
553        .setNested(MessageWithNoOuter.NestedMessage.newBuilder().setI(1))
554        .addForeign(TestAllTypes.newBuilder().setOptionalInt32(1))
555        .setNestedEnum(MessageWithNoOuter.NestedEnum.BAZ)
556        .setForeignEnum(EnumWithNoOuter.BAR)
557        .build();
558    assertEquals(message, MessageWithNoOuter.parseFrom(message.toByteString()));
559
560    assertEquals(MultipleFilesTestProto.getDescriptor(),
561                 MessageWithNoOuter.getDescriptor().getFile());
562
563    Descriptors.FieldDescriptor field =
564      MessageWithNoOuter.getDescriptor().findFieldByName("foreign_enum");
565    assertEquals(EnumWithNoOuter.BAR.getValueDescriptor(),
566                 message.getField(field));
567
568    assertEquals(MultipleFilesTestProto.getDescriptor(),
569                 ServiceWithNoOuter.getDescriptor().getFile());
570
571    assertFalse(
572      TestAllExtensions.getDefaultInstance().hasExtension(
573        MultipleFilesTestProto.extensionWithOuter));
574  }
575
576  public void testOptionalFieldWithRequiredSubfieldsOptimizedForSize()
577    throws Exception {
578    TestOptionalOptimizedForSize message =
579        TestOptionalOptimizedForSize.getDefaultInstance();
580    assertTrue(message.isInitialized());
581
582    message = TestOptionalOptimizedForSize.newBuilder().setO(
583        TestRequiredOptimizedForSize.newBuilder().buildPartial()
584        ).buildPartial();
585    assertFalse(message.isInitialized());
586
587    message = TestOptionalOptimizedForSize.newBuilder().setO(
588        TestRequiredOptimizedForSize.newBuilder().setX(5).buildPartial()
589        ).buildPartial();
590    assertTrue(message.isInitialized());
591  }
592
593  public void testUninitializedExtensionInOptimizedForSize()
594      throws Exception {
595    TestOptimizedForSize.Builder builder = TestOptimizedForSize.newBuilder();
596    builder.setExtension(TestOptimizedForSize.testExtension2,
597        TestRequiredOptimizedForSize.newBuilder().buildPartial());
598    assertFalse(builder.isInitialized());
599    assertFalse(builder.buildPartial().isInitialized());
600
601    builder = TestOptimizedForSize.newBuilder();
602    builder.setExtension(TestOptimizedForSize.testExtension2,
603        TestRequiredOptimizedForSize.newBuilder().setX(10).buildPartial());
604    assertTrue(builder.isInitialized());
605    assertTrue(builder.buildPartial().isInitialized());
606  }
607
608  public void testToBuilder() throws Exception {
609    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
610    TestUtil.setAllFields(builder);
611    TestAllTypes message = builder.build();
612    TestUtil.assertAllFieldsSet(message.toBuilder().build());
613  }
614
615  public void testFieldConstantValues() throws Exception {
616    assertEquals(TestAllTypes.NestedMessage.BB_FIELD_NUMBER, 1);
617    assertEquals(TestAllTypes.OPTIONAL_INT32_FIELD_NUMBER, 1);
618    assertEquals(TestAllTypes.OPTIONALGROUP_FIELD_NUMBER, 16);
619    assertEquals(TestAllTypes.OPTIONAL_NESTED_MESSAGE_FIELD_NUMBER, 18);
620    assertEquals(TestAllTypes.OPTIONAL_NESTED_ENUM_FIELD_NUMBER, 21);
621    assertEquals(TestAllTypes.REPEATED_INT32_FIELD_NUMBER, 31);
622    assertEquals(TestAllTypes.REPEATEDGROUP_FIELD_NUMBER, 46);
623    assertEquals(TestAllTypes.REPEATED_NESTED_MESSAGE_FIELD_NUMBER, 48);
624    assertEquals(TestAllTypes.REPEATED_NESTED_ENUM_FIELD_NUMBER, 51);
625  }
626
627  public void testExtensionConstantValues() throws Exception {
628    assertEquals(UnittestProto.TestRequired.SINGLE_FIELD_NUMBER, 1000);
629    assertEquals(UnittestProto.TestRequired.MULTI_FIELD_NUMBER, 1001);
630    assertEquals(UnittestProto.OPTIONAL_INT32_EXTENSION_FIELD_NUMBER, 1);
631    assertEquals(UnittestProto.OPTIONALGROUP_EXTENSION_FIELD_NUMBER, 16);
632    assertEquals(
633      UnittestProto.OPTIONAL_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 18);
634    assertEquals(UnittestProto.OPTIONAL_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 21);
635    assertEquals(UnittestProto.REPEATED_INT32_EXTENSION_FIELD_NUMBER, 31);
636    assertEquals(UnittestProto.REPEATEDGROUP_EXTENSION_FIELD_NUMBER, 46);
637    assertEquals(
638      UnittestProto.REPEATED_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 48);
639    assertEquals(UnittestProto.REPEATED_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 51);
640  }
641
642  public void testRecursiveMessageDefaultInstance() throws Exception {
643    UnittestProto.TestRecursiveMessage message =
644        UnittestProto.TestRecursiveMessage.getDefaultInstance();
645    assertTrue(message != null);
646    assertTrue(message.getA() != null);
647    assertTrue(message.getA() == message);
648  }
649}
650