• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc.  All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 //     * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 //     * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 //     * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 
31 package com.google.protobuf;
32 
33 import protobuf_unittest.UnittestProto;
34 import protobuf_unittest.UnittestProto.ForeignEnum;
35 import protobuf_unittest.UnittestProto.TestAllExtensions;
36 import protobuf_unittest.UnittestProto.TestAllTypes;
37 import protobuf_unittest.UnittestProto.TestEmptyMessage;
38 import protobuf_unittest.UnittestProto.TestEmptyMessageWithExtensions;
39 import protobuf_unittest.UnittestProto.TestPackedExtensions;
40 import protobuf_unittest.UnittestProto.TestPackedTypes;
41 
42 import junit.framework.TestCase;
43 
44 import java.util.Arrays;
45 import java.util.Map;
46 
47 /**
48  * Tests related to unknown field handling.
49  *
50  * @author kenton@google.com (Kenton Varda)
51  */
52 public class UnknownFieldSetTest extends TestCase {
setUp()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 
getField(String name)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.
getBizarroData()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 
testVarint()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 
testFixed32()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 
testFixed64()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 
testLengthDelimited()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 
testGroup()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 
testSerialize()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 
testCopyFrom()157   public void testCopyFrom() throws Exception {
158     TestEmptyMessage message =
159       TestEmptyMessage.newBuilder().mergeFrom(emptyMessage).build();
160 
161     assertEquals(emptyMessage.toString(), message.toString());
162   }
163 
testMergeFrom()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 
testClear()199   public void testClear() throws Exception {
200     UnknownFieldSet fields =
201       UnknownFieldSet.newBuilder().mergeFrom(unknownFields).clear().build();
202     assertTrue(fields.asMap().isEmpty());
203   }
204 
testClearMessage()205   public void testClearMessage() throws Exception {
206     TestEmptyMessage message =
207       TestEmptyMessage.newBuilder().mergeFrom(emptyMessage).clear().build();
208     assertEquals(0, message.getSerializedSize());
209   }
210 
testClearField()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 
testParseKnownAndUnknown()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 
testWrongTypeTreatedAsUnknown()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 
testUnknownExtensions()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 
testWrongExtensionTypeTreatedAsUnknown()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 
testParseUnknownEnumValue()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 
testLargeVarint()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 
testEqualsAndHashCode()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    */
checkNotEqual(UnknownFieldSet s1, UnknownFieldSet s2)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    */
checkEqualsIsConsistent(UnknownFieldSet set)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 
testSerializeLite()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 
testAllExtensionsLite()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 
testAllPackedFieldsLite()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 
testAllPackedExtensionsLite()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 
testCopyFromLite()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 
testMergeFromLite()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 
testWrongTypeTreatedAsUnknownLite()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 
testUnknownExtensionsLite()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 
testWrongExtensionTypeTreatedAsUnknownLite()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 
testParseUnknownEnumValueLite()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 
testClearLite()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