java/src/test/java/com/google/protobuf/UnknownFieldSetTest.java

   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 {
  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 }