1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc.  All rights reserved.
3// https://developers.google.com/protocol-buffers/
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions are
7// met:
8//
9//     * Redistributions of source code must retain the above copyright
10// notice, this list of conditions and the following disclaimer.
11//     * Redistributions in binary form must reproduce the above
12// copyright notice, this list of conditions and the following disclaimer
13// in the documentation and/or other materials provided with the
14// distribution.
15//     * Neither the name of Google Inc. nor the names of its
16// contributors may be used to endorse or promote products derived from
17// this software without specific prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31package com.google.protobuf;
32
33import protobuf_unittest.UnittestProto;
34import protobuf_unittest.UnittestProto.ForeignEnum;
35import protobuf_unittest.UnittestProto.TestAllExtensions;
36import protobuf_unittest.UnittestProto.TestAllTypes;
37import protobuf_unittest.UnittestProto.TestEmptyMessage;
38import protobuf_unittest.UnittestProto.TestEmptyMessageWithExtensions;
39import protobuf_unittest.UnittestProto.TestPackedExtensions;
40import protobuf_unittest.UnittestProto.TestPackedTypes;
41
42import junit.framework.TestCase;
43
44import java.util.Arrays;
45import java.util.Map;
46
47/**
48 * Tests related to unknown field handling.
49 *
50 * @author kenton@google.com (Kenton Varda)
51 */
52public class UnknownFieldSetTest extends TestCase {
53  public void setUp() throws Exception {
54    descriptor = TestAllTypes.getDescriptor();
55    allFields = TestUtil.getAllSet();
56    allFieldsData = allFields.toByteString();
57    emptyMessage = TestEmptyMessage.parseFrom(allFieldsData);
58    unknownFields = emptyMessage.getUnknownFields();
59  }
60
61  UnknownFieldSet.Field getField(String name) {
62    Descriptors.FieldDescriptor field = descriptor.findFieldByName(name);
63    assertNotNull(field);
64    return unknownFields.getField(field.getNumber());
65  }
66
67  // Constructs a protocol buffer which contains fields with all the same
68  // numbers as allFieldsData except that each field is some other wire
69  // type.
70  ByteString getBizarroData() throws Exception {
71    UnknownFieldSet.Builder bizarroFields = UnknownFieldSet.newBuilder();
72
73    UnknownFieldSet.Field varintField =
74      UnknownFieldSet.Field.newBuilder().addVarint(1).build();
75    UnknownFieldSet.Field fixed32Field =
76      UnknownFieldSet.Field.newBuilder().addFixed32(1).build();
77
78    for (Map.Entry<Integer, UnknownFieldSet.Field> entry :
79         unknownFields.asMap().entrySet()) {
80      if (entry.getValue().getVarintList().isEmpty()) {
81        // Original field is not a varint, so use a varint.
82        bizarroFields.addField(entry.getKey(), varintField);
83      } else {
84        // Original field *is* a varint, so use something else.
85        bizarroFields.addField(entry.getKey(), fixed32Field);
86      }
87    }
88
89    return bizarroFields.build().toByteString();
90  }
91
92  Descriptors.Descriptor descriptor;
93  TestAllTypes allFields;
94  ByteString allFieldsData;
95
96  // An empty message that has been parsed from allFieldsData.  So, it has
97  // unknown fields of every type.
98  TestEmptyMessage emptyMessage;
99  UnknownFieldSet unknownFields;
100
101  // =================================================================
102
103  public void testVarint() throws Exception {
104    UnknownFieldSet.Field field = getField("optional_int32");
105    assertEquals(1, field.getVarintList().size());
106    assertEquals(allFields.getOptionalInt32(),
107                 (long) field.getVarintList().get(0));
108  }
109
110  public void testFixed32() throws Exception {
111    UnknownFieldSet.Field field = getField("optional_fixed32");
112    assertEquals(1, field.getFixed32List().size());
113    assertEquals(allFields.getOptionalFixed32(),
114                 (int) field.getFixed32List().get(0));
115  }
116
117  public void testFixed64() throws Exception {
118    UnknownFieldSet.Field field = getField("optional_fixed64");
119    assertEquals(1, field.getFixed64List().size());
120    assertEquals(allFields.getOptionalFixed64(),
121                 (long) field.getFixed64List().get(0));
122  }
123
124  public void testLengthDelimited() throws Exception {
125    UnknownFieldSet.Field field = getField("optional_bytes");
126    assertEquals(1, field.getLengthDelimitedList().size());
127    assertEquals(allFields.getOptionalBytes(),
128                 field.getLengthDelimitedList().get(0));
129  }
130
131  public void testGroup() throws Exception {
132    Descriptors.FieldDescriptor nestedFieldDescriptor =
133      TestAllTypes.OptionalGroup.getDescriptor().findFieldByName("a");
134    assertNotNull(nestedFieldDescriptor);
135
136    UnknownFieldSet.Field field = getField("optionalgroup");
137    assertEquals(1, field.getGroupList().size());
138
139    UnknownFieldSet group = field.getGroupList().get(0);
140    assertEquals(1, group.asMap().size());
141    assertTrue(group.hasField(nestedFieldDescriptor.getNumber()));
142
143    UnknownFieldSet.Field nestedField =
144      group.getField(nestedFieldDescriptor.getNumber());
145    assertEquals(1, nestedField.getVarintList().size());
146    assertEquals(allFields.getOptionalGroup().getA(),
147                 (long) nestedField.getVarintList().get(0));
148  }
149
150  public void testSerialize() throws Exception {
151    // Check that serializing the UnknownFieldSet produces the original data
152    // again.
153    ByteString data = emptyMessage.toByteString();
154    assertEquals(allFieldsData, data);
155  }
156
157  public void testCopyFrom() throws Exception {
158    TestEmptyMessage message =
159      TestEmptyMessage.newBuilder().mergeFrom(emptyMessage).build();
160
161    assertEquals(emptyMessage.toString(), message.toString());
162  }
163
164  public void testMergeFrom() throws Exception {
165    TestEmptyMessage source =
166      TestEmptyMessage.newBuilder()
167        .setUnknownFields(
168          UnknownFieldSet.newBuilder()
169            .addField(2,
170              UnknownFieldSet.Field.newBuilder()
171                .addVarint(2).build())
172            .addField(3,
173              UnknownFieldSet.Field.newBuilder()
174                .addVarint(4).build())
175            .build())
176        .build();
177    TestEmptyMessage destination =
178      TestEmptyMessage.newBuilder()
179        .setUnknownFields(
180          UnknownFieldSet.newBuilder()
181            .addField(1,
182              UnknownFieldSet.Field.newBuilder()
183                .addVarint(1).build())
184            .addField(3,
185              UnknownFieldSet.Field.newBuilder()
186                .addVarint(3).build())
187            .build())
188        .mergeFrom(source)
189        .build();
190
191    assertEquals(
192      "1: 1\n" +
193      "2: 2\n" +
194      "3: 3\n" +
195      "3: 4\n",
196      destination.toString());
197  }
198
199  public void testClear() throws Exception {
200    UnknownFieldSet fields =
201      UnknownFieldSet.newBuilder().mergeFrom(unknownFields).clear().build();
202    assertTrue(fields.asMap().isEmpty());
203  }
204
205  public void testClearMessage() throws Exception {
206    TestEmptyMessage message =
207      TestEmptyMessage.newBuilder().mergeFrom(emptyMessage).clear().build();
208    assertEquals(0, message.getSerializedSize());
209  }
210
211  public void testClearField() throws Exception {
212    int fieldNumber = unknownFields.asMap().keySet().iterator().next();
213    UnknownFieldSet fields =
214        UnknownFieldSet.newBuilder().mergeFrom(unknownFields).clearField(fieldNumber).build();
215    assertFalse(fields.hasField(fieldNumber));
216  }
217
218  public void testParseKnownAndUnknown() throws Exception {
219    // Test mixing known and unknown fields when parsing.
220
221    UnknownFieldSet fields =
222      UnknownFieldSet.newBuilder(unknownFields)
223        .addField(123456,
224          UnknownFieldSet.Field.newBuilder().addVarint(654321).build())
225        .build();
226
227    ByteString data = fields.toByteString();
228    TestAllTypes destination = TestAllTypes.parseFrom(data);
229
230    TestUtil.assertAllFieldsSet(destination);
231    assertEquals(1, destination.getUnknownFields().asMap().size());
232
233    UnknownFieldSet.Field field =
234      destination.getUnknownFields().getField(123456);
235    assertEquals(1, field.getVarintList().size());
236    assertEquals(654321, (long) field.getVarintList().get(0));
237  }
238
239  public void testWrongTypeTreatedAsUnknown() throws Exception {
240    // Test that fields of the wrong wire type are treated like unknown fields
241    // when parsing.
242
243    ByteString bizarroData = getBizarroData();
244    TestAllTypes allTypesMessage = TestAllTypes.parseFrom(bizarroData);
245    TestEmptyMessage emptyMessage = TestEmptyMessage.parseFrom(bizarroData);
246
247    // All fields should have been interpreted as unknown, so the debug strings
248    // should be the same.
249    assertEquals(emptyMessage.toString(), allTypesMessage.toString());
250  }
251
252  public void testUnknownExtensions() throws Exception {
253    // Make sure fields are properly parsed to the UnknownFieldSet even when
254    // they are declared as extension numbers.
255
256    TestEmptyMessageWithExtensions message =
257      TestEmptyMessageWithExtensions.parseFrom(allFieldsData);
258
259    assertEquals(unknownFields.asMap().size(),
260                 message.getUnknownFields().asMap().size());
261    assertEquals(allFieldsData, message.toByteString());
262  }
263
264  public void testWrongExtensionTypeTreatedAsUnknown() throws Exception {
265    // Test that fields of the wrong wire type are treated like unknown fields
266    // when parsing extensions.
267
268    ByteString bizarroData = getBizarroData();
269    TestAllExtensions allExtensionsMessage =
270      TestAllExtensions.parseFrom(bizarroData);
271    TestEmptyMessage emptyMessage = TestEmptyMessage.parseFrom(bizarroData);
272
273    // All fields should have been interpreted as unknown, so the debug strings
274    // should be the same.
275    assertEquals(emptyMessage.toString(),
276                 allExtensionsMessage.toString());
277  }
278
279  public void testParseUnknownEnumValue() throws Exception {
280    Descriptors.FieldDescriptor singularField =
281      TestAllTypes.getDescriptor().findFieldByName("optional_nested_enum");
282    Descriptors.FieldDescriptor repeatedField =
283      TestAllTypes.getDescriptor().findFieldByName("repeated_nested_enum");
284    assertNotNull(singularField);
285    assertNotNull(repeatedField);
286
287    ByteString data =
288      UnknownFieldSet.newBuilder()
289        .addField(singularField.getNumber(),
290          UnknownFieldSet.Field.newBuilder()
291            .addVarint(TestAllTypes.NestedEnum.BAR.getNumber())
292            .addVarint(5)   // not valid
293            .build())
294        .addField(repeatedField.getNumber(),
295          UnknownFieldSet.Field.newBuilder()
296            .addVarint(TestAllTypes.NestedEnum.FOO.getNumber())
297            .addVarint(4)   // not valid
298            .addVarint(TestAllTypes.NestedEnum.BAZ.getNumber())
299            .addVarint(6)   // not valid
300            .build())
301        .build()
302        .toByteString();
303
304    {
305      TestAllTypes message = TestAllTypes.parseFrom(data);
306      assertEquals(TestAllTypes.NestedEnum.BAR,
307                   message.getOptionalNestedEnum());
308      assertEquals(
309        Arrays.asList(TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAZ),
310        message.getRepeatedNestedEnumList());
311      assertEquals(Arrays.asList(5L),
312                   message.getUnknownFields()
313                          .getField(singularField.getNumber())
314                          .getVarintList());
315      assertEquals(Arrays.asList(4L, 6L),
316                   message.getUnknownFields()
317                          .getField(repeatedField.getNumber())
318                          .getVarintList());
319    }
320
321    {
322      TestAllExtensions message =
323        TestAllExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
324      assertEquals(TestAllTypes.NestedEnum.BAR,
325        message.getExtension(UnittestProto.optionalNestedEnumExtension));
326      assertEquals(
327        Arrays.asList(TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAZ),
328        message.getExtension(UnittestProto.repeatedNestedEnumExtension));
329      assertEquals(Arrays.asList(5L),
330                   message.getUnknownFields()
331                          .getField(singularField.getNumber())
332                          .getVarintList());
333      assertEquals(Arrays.asList(4L, 6L),
334                   message.getUnknownFields()
335                          .getField(repeatedField.getNumber())
336                          .getVarintList());
337    }
338  }
339
340  public void testLargeVarint() throws Exception {
341    ByteString data =
342      UnknownFieldSet.newBuilder()
343        .addField(1,
344          UnknownFieldSet.Field.newBuilder()
345            .addVarint(0x7FFFFFFFFFFFFFFFL)
346            .build())
347        .build()
348        .toByteString();
349    UnknownFieldSet parsed = UnknownFieldSet.parseFrom(data);
350    UnknownFieldSet.Field field = parsed.getField(1);
351    assertEquals(1, field.getVarintList().size());
352    assertEquals(0x7FFFFFFFFFFFFFFFL, (long)field.getVarintList().get(0));
353  }
354
355  public void testEqualsAndHashCode() {
356    UnknownFieldSet.Field fixed32Field =
357        UnknownFieldSet.Field.newBuilder()
358            .addFixed32(1)
359            .build();
360    UnknownFieldSet.Field fixed64Field =
361        UnknownFieldSet.Field.newBuilder()
362            .addFixed64(1)
363            .build();
364    UnknownFieldSet.Field varIntField =
365        UnknownFieldSet.Field.newBuilder()
366            .addVarint(1)
367            .build();
368    UnknownFieldSet.Field lengthDelimitedField =
369        UnknownFieldSet.Field.newBuilder()
370            .addLengthDelimited(ByteString.EMPTY)
371            .build();
372    UnknownFieldSet.Field groupField =
373        UnknownFieldSet.Field.newBuilder()
374            .addGroup(unknownFields)
375            .build();
376
377    UnknownFieldSet a =
378        UnknownFieldSet.newBuilder()
379            .addField(1, fixed32Field)
380            .build();
381    UnknownFieldSet b =
382        UnknownFieldSet.newBuilder()
383            .addField(1, fixed64Field)
384            .build();
385    UnknownFieldSet c =
386        UnknownFieldSet.newBuilder()
387            .addField(1, varIntField)
388            .build();
389    UnknownFieldSet d =
390        UnknownFieldSet.newBuilder()
391            .addField(1, lengthDelimitedField)
392            .build();
393    UnknownFieldSet e =
394        UnknownFieldSet.newBuilder()
395            .addField(1, groupField)
396            .build();
397
398    checkEqualsIsConsistent(a);
399    checkEqualsIsConsistent(b);
400    checkEqualsIsConsistent(c);
401    checkEqualsIsConsistent(d);
402    checkEqualsIsConsistent(e);
403
404    checkNotEqual(a, b);
405    checkNotEqual(a, c);
406    checkNotEqual(a, d);
407    checkNotEqual(a, e);
408    checkNotEqual(b, c);
409    checkNotEqual(b, d);
410    checkNotEqual(b, e);
411    checkNotEqual(c, d);
412    checkNotEqual(c, e);
413    checkNotEqual(d, e);
414  }
415
416  /**
417   * Asserts that the given field sets are not equal and have different
418   * hash codes.
419   *
420   * @warning It's valid for non-equal objects to have the same hash code, so
421   *   this test is stricter than it needs to be. However, this should happen
422   *   relatively rarely.
423   */
424  private void checkNotEqual(UnknownFieldSet s1, UnknownFieldSet s2) {
425    String equalsError = String.format("%s should not be equal to %s", s1, s2);
426    assertFalse(equalsError, s1.equals(s2));
427    assertFalse(equalsError, s2.equals(s1));
428
429    assertFalse(
430        String.format("%s should have a different hash code from %s", s1, s2),
431        s1.hashCode() == s2.hashCode());
432  }
433
434  /**
435   * Asserts that the given field sets are equal and have identical hash codes.
436   */
437  private void checkEqualsIsConsistent(UnknownFieldSet set) {
438    // Object should be equal to itself.
439    assertEquals(set, set);
440
441    // Object should be equal to a copy of itself.
442    UnknownFieldSet copy = UnknownFieldSet.newBuilder(set).build();
443    assertEquals(set, copy);
444    assertEquals(copy, set);
445    assertEquals(set.hashCode(), copy.hashCode());
446  }
447
448  // =================================================================
449
450  public void testSerializeLite() throws Exception {
451    UnittestLite.TestEmptyMessageLite emptyMessageLite =
452        UnittestLite.TestEmptyMessageLite.parseFrom(allFieldsData);
453    assertEquals(allFieldsData.size(), emptyMessageLite.getSerializedSize());
454    ByteString data = emptyMessageLite.toByteString();
455    TestAllTypes message = TestAllTypes.parseFrom(data);
456    TestUtil.assertAllFieldsSet(message);
457    assertEquals(allFieldsData, data);
458  }
459
460  public void testAllExtensionsLite() throws Exception {
461    TestAllExtensions allExtensions = TestUtil.getAllExtensionsSet();
462    ByteString allExtensionsData = allExtensions.toByteString();
463    UnittestLite.TestEmptyMessageLite emptyMessageLite =
464        UnittestLite.TestEmptyMessageLite.PARSER.parseFrom(allExtensionsData);
465    ByteString data = emptyMessageLite.toByteString();
466    TestAllExtensions message =
467        TestAllExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
468    TestUtil.assertAllExtensionsSet(message);
469    assertEquals(allExtensionsData, data);
470  }
471
472  public void testAllPackedFieldsLite() throws Exception {
473    TestPackedTypes allPackedFields = TestUtil.getPackedSet();
474    ByteString allPackedData = allPackedFields.toByteString();
475    UnittestLite.TestEmptyMessageLite emptyMessageLite =
476        UnittestLite.TestEmptyMessageLite.parseFrom(allPackedData);
477    ByteString data = emptyMessageLite.toByteString();
478    TestPackedTypes message =
479        TestPackedTypes.parseFrom(data, TestUtil.getExtensionRegistry());
480    TestUtil.assertPackedFieldsSet(message);
481    assertEquals(allPackedData, data);
482  }
483
484  public void testAllPackedExtensionsLite() throws Exception {
485    TestPackedExtensions allPackedExtensions = TestUtil.getPackedExtensionsSet();
486    ByteString allPackedExtensionsData = allPackedExtensions.toByteString();
487    UnittestLite.TestEmptyMessageLite emptyMessageLite =
488        UnittestLite.TestEmptyMessageLite.parseFrom(allPackedExtensionsData);
489    ByteString data = emptyMessageLite.toByteString();
490    TestPackedExtensions message =
491        TestPackedExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
492    TestUtil.assertPackedExtensionsSet(message);
493    assertEquals(allPackedExtensionsData, data);
494  }
495
496  public void testCopyFromLite() throws Exception {
497    UnittestLite.TestEmptyMessageLite emptyMessageLite =
498        UnittestLite.TestEmptyMessageLite.parseFrom(allFieldsData);
499    UnittestLite.TestEmptyMessageLite emptyMessageLite2 =
500        UnittestLite.TestEmptyMessageLite.newBuilder()
501        .mergeFrom(emptyMessageLite).build();
502    assertEquals(emptyMessageLite.toByteString(), emptyMessageLite2.toByteString());
503  }
504
505  public void testMergeFromLite() throws Exception {
506    TestAllTypes message1 = TestAllTypes.newBuilder()
507        .setOptionalInt32(1)
508        .setOptionalString("foo")
509        .addRepeatedString("bar")
510        .setOptionalNestedEnum(TestAllTypes.NestedEnum.BAZ)
511        .build();
512
513    TestAllTypes message2 = TestAllTypes.newBuilder()
514        .setOptionalInt64(2)
515        .setOptionalString("baz")
516        .addRepeatedString("qux")
517        .setOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ)
518        .build();
519
520    ByteString data1 = message1.toByteString();
521    UnittestLite.TestEmptyMessageLite emptyMessageLite1 =
522        UnittestLite.TestEmptyMessageLite.parseFrom(data1);
523    ByteString data2 = message2.toByteString();
524    UnittestLite.TestEmptyMessageLite emptyMessageLite2 =
525        UnittestLite.TestEmptyMessageLite.parseFrom(data2);
526
527    message1 = TestAllTypes.newBuilder(message1).mergeFrom(message2).build();
528    emptyMessageLite1 = UnittestLite.TestEmptyMessageLite.newBuilder(emptyMessageLite1)
529                        .mergeFrom(emptyMessageLite2).build();
530
531    data1 = emptyMessageLite1.toByteString();
532    message2 = TestAllTypes.parseFrom(data1);
533
534    assertEquals(message1, message2);
535  }
536
537  public void testWrongTypeTreatedAsUnknownLite() throws Exception {
538    // Test that fields of the wrong wire type are treated like unknown fields
539    // when parsing.
540
541    ByteString bizarroData = getBizarroData();
542    TestAllTypes allTypesMessage = TestAllTypes.parseFrom(bizarroData);
543    UnittestLite.TestEmptyMessageLite emptyMessageLite =
544        UnittestLite.TestEmptyMessageLite.parseFrom(bizarroData);
545    ByteString data = emptyMessageLite.toByteString();
546    TestAllTypes allTypesMessage2 = TestAllTypes.parseFrom(data);
547
548    assertEquals(allTypesMessage.toString(), allTypesMessage2.toString());
549  }
550
551  public void testUnknownExtensionsLite() throws Exception {
552    // Make sure fields are properly parsed to the UnknownFieldSet even when
553    // they are declared as extension numbers.
554
555    UnittestLite.TestEmptyMessageWithExtensionsLite message =
556      UnittestLite.TestEmptyMessageWithExtensionsLite.parseFrom(allFieldsData);
557
558    assertEquals(allFieldsData, message.toByteString());
559  }
560
561  public void testWrongExtensionTypeTreatedAsUnknownLite() throws Exception {
562    // Test that fields of the wrong wire type are treated like unknown fields
563    // when parsing extensions.
564
565    ByteString bizarroData = getBizarroData();
566    TestAllExtensions allExtensionsMessage =
567      TestAllExtensions.parseFrom(bizarroData);
568    UnittestLite.TestEmptyMessageLite emptyMessageLite =
569        UnittestLite.TestEmptyMessageLite.parseFrom(bizarroData);
570
571    // All fields should have been interpreted as unknown, so the byte strings
572    // should be the same.
573    assertEquals(emptyMessageLite.toByteString(),
574                 allExtensionsMessage.toByteString());
575  }
576
577  public void testParseUnknownEnumValueLite() throws Exception {
578    Descriptors.FieldDescriptor singularField =
579      TestAllTypes.getDescriptor().findFieldByName("optional_nested_enum");
580    Descriptors.FieldDescriptor repeatedField =
581      TestAllTypes.getDescriptor().findFieldByName("repeated_nested_enum");
582    assertNotNull(singularField);
583    assertNotNull(repeatedField);
584
585    ByteString data =
586      UnknownFieldSet.newBuilder()
587        .addField(singularField.getNumber(),
588          UnknownFieldSet.Field.newBuilder()
589            .addVarint(TestAllTypes.NestedEnum.BAR.getNumber())
590            .addVarint(5)   // not valid
591            .build())
592        .addField(repeatedField.getNumber(),
593          UnknownFieldSet.Field.newBuilder()
594            .addVarint(TestAllTypes.NestedEnum.FOO.getNumber())
595            .addVarint(4)   // not valid
596            .addVarint(TestAllTypes.NestedEnum.BAZ.getNumber())
597            .addVarint(6)   // not valid
598            .build())
599        .build()
600        .toByteString();
601
602    UnittestLite.TestEmptyMessageLite emptyMessageLite =
603        UnittestLite.TestEmptyMessageLite.parseFrom(data);
604    data = emptyMessageLite.toByteString();
605
606    {
607      TestAllTypes message = TestAllTypes.parseFrom(data);
608      assertEquals(TestAllTypes.NestedEnum.BAR,
609                   message.getOptionalNestedEnum());
610      assertEquals(
611        Arrays.asList(TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAZ),
612        message.getRepeatedNestedEnumList());
613      assertEquals(Arrays.asList(5L),
614                   message.getUnknownFields()
615                          .getField(singularField.getNumber())
616                          .getVarintList());
617      assertEquals(Arrays.asList(4L, 6L),
618                   message.getUnknownFields()
619                          .getField(repeatedField.getNumber())
620                          .getVarintList());
621    }
622
623    {
624      TestAllExtensions message =
625        TestAllExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
626      assertEquals(TestAllTypes.NestedEnum.BAR,
627        message.getExtension(UnittestProto.optionalNestedEnumExtension));
628      assertEquals(
629        Arrays.asList(TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAZ),
630        message.getExtension(UnittestProto.repeatedNestedEnumExtension));
631      assertEquals(Arrays.asList(5L),
632                   message.getUnknownFields()
633                          .getField(singularField.getNumber())
634                          .getVarintList());
635      assertEquals(Arrays.asList(4L, 6L),
636                   message.getUnknownFields()
637                          .getField(repeatedField.getNumber())
638                          .getVarintList());
639    }
640  }
641
642  public void testClearLite() throws Exception {
643    UnittestLite.TestEmptyMessageLite emptyMessageLite1 =
644        UnittestLite.TestEmptyMessageLite.parseFrom(allFieldsData);
645    UnittestLite.TestEmptyMessageLite emptyMessageLite2 =
646        UnittestLite.TestEmptyMessageLite.newBuilder()
647        .mergeFrom(emptyMessageLite1).clear().build();
648    assertEquals(0, emptyMessageLite2.getSerializedSize());
649    ByteString data = emptyMessageLite2.toByteString();
650    assertEquals(0, data.size());
651  }
652
653}
654