content: // Protocol Buffers - Google's data interchange format
  // Copyright 2008 Google Inc.  All rights reserved.
  // https://developers.google.com/protocol-buffers/
  //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions are
  // met:
  //
  //     * Redistributions of source code must retain the above copyright
  // notice, this list of conditions and the following disclaimer.
  //     * Redistributions in binary form must reproduce the above
  // copyright notice, this list of conditions and the following disclaimer
  // in the documentation and/or other materials provided with the
  // distribution.
  //     * Neither the name of Google Inc. nor the names of its
  // contributors may be used to endorse or promote products derived from
  // this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  package com.google.protobuf;
  
  import static junit.framework.TestCase.assertEquals;
  
  import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
  import com.google.protobuf.UnittestLite.TestAllTypesLite;
  import protobuf_unittest.UnittestProto;
  import protobuf_unittest.UnittestProto.ForeignEnum;
  import protobuf_unittest.UnittestProto.TestAllExtensions;
  import protobuf_unittest.UnittestProto.TestAllTypes;
  import protobuf_unittest.UnittestProto.TestEmptyMessage;
  import protobuf_unittest.UnittestProto.TestPackedExtensions;
  import protobuf_unittest.UnittestProto.TestPackedTypes;
  import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash;
  import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Bar;
  import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Foo;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.util.Arrays;
  import java.util.Map;
  import junit.framework.TestCase;
  
  /**
   * Tests for {@link UnknownFieldSetLite}.
   *
   * @author dweis@google.com (Daniel Weis)
   */
  public class UnknownFieldSetLiteTest extends TestCase {
    @Override
    public void setUp() throws Exception {
      allFields = TestUtil.getAllSet();
      allFieldsData = allFields.toByteString();
      emptyMessage = TestEmptyMessage.parseFrom(allFieldsData);
      unknownFields = emptyMessage.getUnknownFields();
    }
  
    TestAllTypes allFields;
    ByteString allFieldsData;
  
    // Constructs a protocol buffer which contains fields with all the same
    // numbers as allFieldsData except that each field is some other wire
    // type.
    private ByteString getBizarroData() throws Exception {
      UnknownFieldSet.Builder bizarroFields = UnknownFieldSet.newBuilder();
  
      UnknownFieldSet.Field varintField = UnknownFieldSet.Field.newBuilder().addVarint(1).build();
      UnknownFieldSet.Field fixed32Field = UnknownFieldSet.Field.newBuilder().addFixed32(1).build();
  
      for (Map.Entry<Integer, UnknownFieldSet.Field> entry : unknownFields.asMap().entrySet()) {
        if (entry.getValue().getVarintList().isEmpty()) {
          // Original field is not a varint, so use a varint.
          bizarroFields.addField(entry.getKey(), varintField);
        } else {
          // Original field *is* a varint, so use something else.
          bizarroFields.addField(entry.getKey(), fixed32Field);
        }
      }
  
      return bizarroFields.build().toByteString();
    }
  
    // An empty message that has been parsed from allFieldsData.  So, it has
    // unknown fields of every type.
    TestEmptyMessage emptyMessage;
    UnknownFieldSet unknownFields;
  
    public void testDefaultInstance() {
      UnknownFieldSetLite unknownFields = UnknownFieldSetLite.getDefaultInstance();
  
      assertEquals(0, unknownFields.getSerializedSize());
      assertEquals(ByteString.EMPTY, toByteString(unknownFields));
    }
  
    public void testEmptyInstance() {
      UnknownFieldSetLite instance = UnknownFieldSetLite.newInstance();
  
      assertEquals(0, instance.getSerializedSize());
      assertEquals(ByteString.EMPTY, toByteString(instance));
      assertEquals(UnknownFieldSetLite.getDefaultInstance(), instance);
    }
  
    public void testMergeFieldFrom() throws IOException {
      Foo foo = Foo.newBuilder()
        .setValue(2)
        .build();
  
      CodedInputStream input = CodedInputStream.newInstance(foo.toByteArray());
  
      UnknownFieldSetLite instance = UnknownFieldSetLite.newInstance();
      instance.mergeFieldFrom(input.readTag(), input);
  
      assertEquals(foo.toByteString(), toByteString(instance));
    }
  
    public void testSerializedSize() throws IOException {
      Foo foo = Foo.newBuilder()
        .setValue(2)
        .build();
  
      CodedInputStream input = CodedInputStream.newInstance(foo.toByteArray());
  
      UnknownFieldSetLite instance = UnknownFieldSetLite.newInstance();
      instance.mergeFieldFrom(input.readTag(), input);
  
      assertEquals(foo.toByteString().size(), instance.getSerializedSize());
    }
  
    public void testHashCodeAfterDeserialization() throws IOException {
      Foo foo = Foo.newBuilder()
        .setValue(2)
        .build();
  
      Foo fooDeserialized = Foo.parseFrom(foo.toByteArray());
  
      assertEquals(fooDeserialized, foo);
      assertEquals(foo.hashCode(), fooDeserialized.hashCode());
    }
  
    public void testNewInstanceHashCode() {
      UnknownFieldSetLite emptyFieldSet = UnknownFieldSetLite.getDefaultInstance();
      UnknownFieldSetLite paddedFieldSet = UnknownFieldSetLite.newInstance();
  
      assertEquals(emptyFieldSet, paddedFieldSet);
      assertEquals(emptyFieldSet.hashCode(), paddedFieldSet.hashCode());
    }
  
    public void testMergeVarintField() throws IOException {
      UnknownFieldSetLite unknownFields = UnknownFieldSetLite.newInstance();
      unknownFields.mergeVarintField(10, 2);
  
      CodedInputStream input =
          CodedInputStream.newInstance(toByteString(unknownFields).toByteArray());
  
      int tag = input.readTag();
      assertEquals(10, WireFormat.getTagFieldNumber(tag));
      assertEquals(WireFormat.WIRETYPE_VARINT, WireFormat.getTagWireType(tag));
      assertEquals(2, input.readUInt64());
      assertTrue(input.isAtEnd());
    }
  
    public void testMergeVarintField_negative() throws IOException {
      UnknownFieldSetLite builder = UnknownFieldSetLite.newInstance();
      builder.mergeVarintField(10, -6);
  
      CodedInputStream input =
          CodedInputStream.newInstance(toByteString(builder).toByteArray());
  
      int tag = input.readTag();
      assertEquals(10, WireFormat.getTagFieldNumber(tag));
      assertEquals(WireFormat.WIRETYPE_VARINT, WireFormat.getTagWireType(tag));
      assertEquals(-6, input.readUInt64());
      assertTrue(input.isAtEnd());
    }
  
    public void testEqualsAndHashCode() {
      UnknownFieldSetLite unknownFields1 = UnknownFieldSetLite.newInstance();
      unknownFields1.mergeVarintField(10, 2);
  
      UnknownFieldSetLite unknownFields2 = UnknownFieldSetLite.newInstance();
      unknownFields2.mergeVarintField(10, 2);
  
      assertEquals(unknownFields1, unknownFields2);
      assertEquals(unknownFields1.hashCode(), unknownFields2.hashCode());
      assertFalse(unknownFields1.equals(UnknownFieldSetLite.getDefaultInstance()));
      assertFalse(unknownFields1.hashCode() == UnknownFieldSetLite.getDefaultInstance().hashCode());
    }
  
    public void testMutableCopyOf() throws IOException {
      UnknownFieldSetLite unknownFields = UnknownFieldSetLite.newInstance();
      unknownFields.mergeVarintField(10, 2);
      unknownFields = UnknownFieldSetLite.mutableCopyOf(unknownFields, unknownFields);
      unknownFields.checkMutable();
  
      CodedInputStream input =
          CodedInputStream.newInstance(toByteString(unknownFields).toByteArray());
  
      int tag = input.readTag();
      assertEquals(10, WireFormat.getTagFieldNumber(tag));
      assertEquals(WireFormat.WIRETYPE_VARINT, WireFormat.getTagWireType(tag));
      assertEquals(2, input.readUInt64());
      assertFalse(input.isAtEnd());
      input.readTag();
      assertEquals(10, WireFormat.getTagFieldNumber(tag));
      assertEquals(WireFormat.WIRETYPE_VARINT, WireFormat.getTagWireType(tag));
      assertEquals(2, input.readUInt64());
      assertTrue(input.isAtEnd());
    }
  
    public void testMutableCopyOf_empty() {
      UnknownFieldSetLite unknownFields = UnknownFieldSetLite.mutableCopyOf(
          UnknownFieldSetLite.getDefaultInstance(), UnknownFieldSetLite.getDefaultInstance());
      unknownFields.checkMutable();
  
      assertEquals(0, unknownFields.getSerializedSize());
      assertEquals(ByteString.EMPTY, toByteString(unknownFields));
    }
  
    public void testRoundTrips() throws InvalidProtocolBufferException {
      Foo foo = Foo.newBuilder()
          .setValue(1)
          .setExtension(Bar.fooExt, Bar.newBuilder()
              .setName("name")
              .build())
          .setExtension(LiteEqualsAndHash.varint, 22)
          .setExtension(LiteEqualsAndHash.fixed32, 44)
          .setExtension(LiteEqualsAndHash.fixed64, 66L)
          .setExtension(LiteEqualsAndHash.myGroup, LiteEqualsAndHash.MyGroup.newBuilder()
              .setGroupValue("value")
              .build())
          .build();
  
      Foo copy = Foo.parseFrom(foo.toByteArray());
  
      assertEquals(foo.getSerializedSize(), copy.getSerializedSize());
      assertFalse(foo.equals(copy));
  
      Foo secondCopy = Foo.parseFrom(foo.toByteArray());
      assertEquals(copy, secondCopy);
  
      ExtensionRegistryLite extensionRegistry = ExtensionRegistryLite.newInstance();
      LiteEqualsAndHash.registerAllExtensions(extensionRegistry);
      Foo copyOfCopy = Foo.parseFrom(copy.toByteArray(), extensionRegistry);
  
      assertEquals(foo, copyOfCopy);
    }
  
    public void testMalformedBytes() throws Exception {
      try {
        Foo.parseFrom("this is a malformed protocol buffer".getBytes(Internal.UTF_8));
        fail();
      } catch (InvalidProtocolBufferException e) {
        // Expected.
      }
    }
  
    public void testMissingStartGroupTag() throws IOException {
      ByteString.Output byteStringOutput = ByteString.newOutput();
      CodedOutputStream output = CodedOutputStream.newInstance(byteStringOutput);
      output.writeGroupNoTag(Foo.newBuilder().setValue(11).build());
      output.writeTag(100, WireFormat.WIRETYPE_END_GROUP);
      output.flush();
  
      try {
        Foo.parseFrom(byteStringOutput.toByteString());
        fail();
      } catch (InvalidProtocolBufferException e) {
        // Expected.
      }
    }
  
    public void testMissingEndGroupTag() throws IOException {
      ByteString.Output byteStringOutput = ByteString.newOutput();
      CodedOutputStream output = CodedOutputStream.newInstance(byteStringOutput);
      output.writeTag(100, WireFormat.WIRETYPE_START_GROUP);
      output.writeGroupNoTag(Foo.newBuilder().setValue(11).build());
      output.flush();
  
      try {
        Foo.parseFrom(byteStringOutput.toByteString());
        fail();
      } catch (InvalidProtocolBufferException e) {
        // Expected.
      }
    }
  
    public void testMismatchingGroupTags() throws IOException {
      ByteString.Output byteStringOutput = ByteString.newOutput();
      CodedOutputStream output = CodedOutputStream.newInstance(byteStringOutput);
      output.writeTag(100, WireFormat.WIRETYPE_START_GROUP);
      output.writeGroupNoTag(Foo.newBuilder().setValue(11).build());
      output.writeTag(101, WireFormat.WIRETYPE_END_GROUP);
      output.flush();
  
      try {
        Foo.parseFrom(byteStringOutput.toByteString());
        fail();
      } catch (InvalidProtocolBufferException e) {
        // Expected.
      }
    }
  
    public void testTruncatedInput() {
      Foo foo = Foo.newBuilder()
          .setValue(1)
          .setExtension(Bar.fooExt, Bar.newBuilder()
              .setName("name")
              .build())
          .setExtension(LiteEqualsAndHash.varint, 22)
          .setExtension(LiteEqualsAndHash.myGroup, LiteEqualsAndHash.MyGroup.newBuilder()
              .setGroupValue("value")
              .build())
          .build();
  
      try {
        Foo.parseFrom(foo.toByteString().substring(0, foo.toByteString().size() - 10));
        fail();
      } catch (InvalidProtocolBufferException e) {
        // Expected.
      }
    }
    
    public void testMakeImmutable() throws Exception {
      UnknownFieldSetLite unknownFields = UnknownFieldSetLite.newInstance();
      unknownFields.makeImmutable();
      
      try {
        unknownFields.mergeVarintField(1, 1);
        fail();
      } catch (UnsupportedOperationException expected) {}
      
      try {
        unknownFields.mergeLengthDelimitedField(2, ByteString.copyFromUtf8("hello"));
        fail();
      } catch (UnsupportedOperationException expected) {}
      
      try {
        unknownFields.mergeFieldFrom(1, CodedInputStream.newInstance(new byte[0]));
        fail();
      } catch (UnsupportedOperationException expected) {}
    }
    
    public void testEndToEnd() throws Exception {
      TestAllTypesLite testAllTypes = TestAllTypesLite.getDefaultInstance();
      try {
        testAllTypes.unknownFields.checkMutable();
        fail();
      } catch (UnsupportedOperationException expected) {}
      
      testAllTypes = TestAllTypesLite.parseFrom(new byte[0]);
      try {
        testAllTypes.unknownFields.checkMutable();
        fail();
      } catch (UnsupportedOperationException expected) {}
      
      testAllTypes = TestAllTypesLite.newBuilder().build();
      try {
        testAllTypes.unknownFields.checkMutable();
        fail();
      } catch (UnsupportedOperationException expected) {}
      
      testAllTypes = TestAllTypesLite.newBuilder()
          .setDefaultBool(true)
          .build();
      try {
        testAllTypes.unknownFields.checkMutable();
        fail();
      } catch (UnsupportedOperationException expected) {}
      
      TestAllExtensionsLite testAllExtensions = TestAllExtensionsLite.newBuilder()
          .mergeFrom(TestAllExtensionsLite.newBuilder()
              .setExtension(UnittestLite.optionalInt32ExtensionLite, 2)
              .build().toByteArray())
          .build();
      try {
        testAllExtensions.unknownFields.checkMutable();
        fail();
      } catch (UnsupportedOperationException expected) {}
    }
  
    private ByteString toByteString(UnknownFieldSetLite unknownFields) {
      ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
      CodedOutputStream output = CodedOutputStream.newInstance(byteArrayOutputStream);
      try {
        unknownFields.writeTo(output);
        output.flush();
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
      return ByteString.copyFrom(byteArrayOutputStream.toByteArray());
    }
  
    public void testSerializeLite() throws Exception {
      UnittestLite.TestEmptyMessageLite emptyMessageLite =
          UnittestLite.TestEmptyMessageLite.parseFrom(allFieldsData);
      assertEquals(allFieldsData.size(), emptyMessageLite.getSerializedSize());
      ByteString data = emptyMessageLite.toByteString();
      TestAllTypes message = TestAllTypes.parseFrom(data);
      TestUtil.assertAllFieldsSet(message);
      assertEquals(allFieldsData, data);
    }
  
    public void testAllExtensionsLite() throws Exception {
      TestAllExtensions allExtensions = TestUtil.getAllExtensionsSet();
      ByteString allExtensionsData = allExtensions.toByteString();
      UnittestLite.TestEmptyMessageLite emptyMessageLite =
          UnittestLite.TestEmptyMessageLite.parser().parseFrom(allExtensionsData);
      ByteString data = emptyMessageLite.toByteString();
      TestAllExtensions message = TestAllExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
      TestUtil.assertAllExtensionsSet(message);
      assertEquals(allExtensionsData, data);
    }
  
    public void testAllPackedFieldsLite() throws Exception {
      TestPackedTypes allPackedFields = TestUtil.getPackedSet();
      ByteString allPackedData = allPackedFields.toByteString();
      UnittestLite.TestEmptyMessageLite emptyMessageLite =
          UnittestLite.TestEmptyMessageLite.parseFrom(allPackedData);
      ByteString data = emptyMessageLite.toByteString();
      TestPackedTypes message = TestPackedTypes.parseFrom(data, TestUtil.getExtensionRegistry());
      TestUtil.assertPackedFieldsSet(message);
      assertEquals(allPackedData, data);
    }
  
    public void testAllPackedExtensionsLite() throws Exception {
      TestPackedExtensions allPackedExtensions = TestUtil.getPackedExtensionsSet();
      ByteString allPackedExtensionsData = allPackedExtensions.toByteString();
      UnittestLite.TestEmptyMessageLite emptyMessageLite =
          UnittestLite.TestEmptyMessageLite.parseFrom(allPackedExtensionsData);
      ByteString data = emptyMessageLite.toByteString();
      TestPackedExtensions message =
          TestPackedExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
      TestUtil.assertPackedExtensionsSet(message);
      assertEquals(allPackedExtensionsData, data);
    }
  
    public void testCopyFromLite() throws Exception {
      UnittestLite.TestEmptyMessageLite emptyMessageLite =
          UnittestLite.TestEmptyMessageLite.parseFrom(allFieldsData);
      UnittestLite.TestEmptyMessageLite emptyMessageLite2 =
          UnittestLite.TestEmptyMessageLite.newBuilder().mergeFrom(emptyMessageLite).build();
      assertEquals(emptyMessageLite.toByteString(), emptyMessageLite2.toByteString());
    }
  
    public void testMergeFromLite() throws Exception {
      TestAllTypes message1 =
          TestAllTypes.newBuilder()
              .setOptionalInt32(1)
              .setOptionalString("foo")
              .addRepeatedString("bar")
              .setOptionalNestedEnum(TestAllTypes.NestedEnum.BAZ)
              .build();
  
      TestAllTypes message2 =
          TestAllTypes.newBuilder()
              .setOptionalInt64(2)
              .setOptionalString("baz")
              .addRepeatedString("qux")
              .setOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ)
              .build();
  
      ByteString data1 = message1.toByteString();
      UnittestLite.TestEmptyMessageLite emptyMessageLite1 =
          UnittestLite.TestEmptyMessageLite.parseFrom(data1);
      ByteString data2 = message2.toByteString();
      UnittestLite.TestEmptyMessageLite emptyMessageLite2 =
          UnittestLite.TestEmptyMessageLite.parseFrom(data2);
  
      message1 = TestAllTypes.newBuilder(message1).mergeFrom(message2).build();
      emptyMessageLite1 =
          UnittestLite.TestEmptyMessageLite.newBuilder(emptyMessageLite1)
              .mergeFrom(emptyMessageLite2)
              .build();
  
      data1 = emptyMessageLite1.toByteString();
      message2 = TestAllTypes.parseFrom(data1);
  
      assertEquals(message1, message2);
    }
  
    public void testWrongTypeTreatedAsUnknownLite() throws Exception {
      // Test that fields of the wrong wire type are treated like unknown fields
      // when parsing.
  
      ByteString bizarroData = getBizarroData();
      TestAllTypes allTypesMessage = TestAllTypes.parseFrom(bizarroData);
      UnittestLite.TestEmptyMessageLite emptyMessageLite =
          UnittestLite.TestEmptyMessageLite.parseFrom(bizarroData);
      ByteString data = emptyMessageLite.toByteString();
      TestAllTypes allTypesMessage2 = TestAllTypes.parseFrom(data);
  
      assertEquals(allTypesMessage.toString(), allTypesMessage2.toString());
    }
  
    public void testUnknownExtensionsLite() throws Exception {
      // Make sure fields are properly parsed to the UnknownFieldSet even when
      // they are declared as extension numbers.
  
      UnittestLite.TestEmptyMessageWithExtensionsLite message =
          UnittestLite.TestEmptyMessageWithExtensionsLite.parseFrom(allFieldsData);
  
      assertEquals(allFieldsData, message.toByteString());
    }
  
    public void testWrongExtensionTypeTreatedAsUnknownLite() throws Exception {
      // Test that fields of the wrong wire type are treated like unknown fields
      // when parsing extensions.
  
      ByteString bizarroData = getBizarroData();
      TestAllExtensions allExtensionsMessage = TestAllExtensions.parseFrom(bizarroData);
      UnittestLite.TestEmptyMessageLite emptyMessageLite =
          UnittestLite.TestEmptyMessageLite.parseFrom(bizarroData);
  
      // All fields should have been interpreted as unknown, so the byte strings
      // should be the same.
      assertEquals(emptyMessageLite.toByteString(), allExtensionsMessage.toByteString());
    }
  
    public void testParseUnknownEnumValueLite() throws Exception {
      Descriptors.FieldDescriptor singularField =
          TestAllTypes.getDescriptor().findFieldByName("optional_nested_enum");
      Descriptors.FieldDescriptor repeatedField =
          TestAllTypes.getDescriptor().findFieldByName("repeated_nested_enum");
      assertNotNull(singularField);
      assertNotNull(repeatedField);
  
      ByteString data =
          UnknownFieldSet.newBuilder()
              .addField(
                  singularField.getNumber(),
                  UnknownFieldSet.Field.newBuilder()
                      .addVarint(TestAllTypes.NestedEnum.BAR.getNumber())
                      .addVarint(5) // not valid
                      .build())
              .addField(
                  repeatedField.getNumber(),
                  UnknownFieldSet.Field.newBuilder()
                      .addVarint(TestAllTypes.NestedEnum.FOO.getNumber())
                      .addVarint(4) // not valid
                      .addVarint(TestAllTypes.NestedEnum.BAZ.getNumber())
                      .addVarint(6) // not valid
                      .build())
              .build()
              .toByteString();
  
      UnittestLite.TestEmptyMessageLite emptyMessageLite =
          UnittestLite.TestEmptyMessageLite.parseFrom(data);
      data = emptyMessageLite.toByteString();
  
      {
        TestAllTypes message = TestAllTypes.parseFrom(data);
        assertEquals(TestAllTypes.NestedEnum.BAR, message.getOptionalNestedEnum());
        assertEquals(
            Arrays.asList(TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAZ),
            message.getRepeatedNestedEnumList());
        assertEquals(
            Arrays.asList(5L),
            message.getUnknownFields().getField(singularField.getNumber()).getVarintList());
        assertEquals(
            Arrays.asList(4L, 6L),
            message.getUnknownFields().getField(repeatedField.getNumber()).getVarintList());
      }
  
      {
        TestAllExtensions message =
            TestAllExtensions.parseFrom(data, TestUtil.getExtensionRegistry());
        assertEquals(
            TestAllTypes.NestedEnum.BAR,
            message.getExtension(UnittestProto.optionalNestedEnumExtension));
        assertEquals(
            Arrays.asList(TestAllTypes.NestedEnum.FOO, TestAllTypes.NestedEnum.BAZ),
            message.getExtension(UnittestProto.repeatedNestedEnumExtension));
        assertEquals(
            Arrays.asList(5L),
            message.getUnknownFields().getField(singularField.getNumber()).getVarintList());
        assertEquals(
            Arrays.asList(4L, 6L),
            message.getUnknownFields().getField(repeatedField.getNumber()).getVarintList());
      }
    }
  
    public void testClearLite() throws Exception {
      UnittestLite.TestEmptyMessageLite emptyMessageLite1 =
          UnittestLite.TestEmptyMessageLite.parseFrom(allFieldsData);
      UnittestLite.TestEmptyMessageLite emptyMessageLite2 =
          UnittestLite.TestEmptyMessageLite.newBuilder().mergeFrom(emptyMessageLite1).clear().build();
      assertEquals(0, emptyMessageLite2.getSerializedSize());
      ByteString data = emptyMessageLite2.toByteString();
      assertEquals(0, data.size());
    }
  }
  