Home | History | Annotate | Download | only in protobuf 
      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 (at) google.com (Kenton Varda)
     51  */
     52 public 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