third_party/protobuf: Update to HEAD (5f65ee6ac7)

third_party/protobuf/java/core/src/test/java/com/google/protobuf/LiteTest.java

 // 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.
@@ skipping 17 matching lines @@
 // (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 java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
 
 import com.google.protobuf.UnittestImportLite.ImportEnumLite;
 import com.google.protobuf.UnittestImportPublicLite.PublicImportMessageLite;
-import com.google.protobuf.UnittestLite;
 import com.google.protobuf.UnittestLite.ForeignEnumLite;
 import com.google.protobuf.UnittestLite.ForeignMessageLite;
 import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
 import com.google.protobuf.UnittestLite.TestAllTypesLite;
 import com.google.protobuf.UnittestLite.TestAllTypesLite.NestedEnum;
 import com.google.protobuf.UnittestLite.TestAllTypesLite.NestedMessage;
 import com.google.protobuf.UnittestLite.TestAllTypesLite.OneofFieldCase;
 import com.google.protobuf.UnittestLite.TestAllTypesLite.OptionalGroup;
 import com.google.protobuf.UnittestLite.TestAllTypesLite.RepeatedGroup;
 import com.google.protobuf.UnittestLite.TestAllTypesLiteOrBuilder;
+import com.google.protobuf.UnittestLite.TestHugeFieldNumbersLite;
 import com.google.protobuf.UnittestLite.TestNestedExtensionLite;
 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Bar;
 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.BarPrime;
 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Foo;
 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestOneofEquals;
 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestRecursiveOneof;
-
 import junit.framework.TestCase;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.NotSerializableException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-
 /**
  * Test lite runtime.
  *
  * @author kenton@google.com Kenton Varda
  */
 public class LiteTest extends TestCase {
   @Override
   public void setUp() throws Exception {
     // Test that nested extensions are initialized correctly even if the outer
     // class has not been accessed directly.  This was once a bug with lite
@@ skipping 58 matching lines @@
     assertEquals(1, message2.getExtension(
         UnittestLite.repeatedStringExtensionLite).size());
     assertEquals("hello", message2.getExtension(
         UnittestLite.repeatedStringExtensionLite, 0));
     assertEquals(TestAllTypesLite.NestedEnum.BAZ, message2.getExtension(
         UnittestLite.optionalNestedEnumExtensionLite));
     assertEquals(7, message2.getExtension(
         UnittestLite.optionalNestedMessageExtensionLite).getBb());
   }
   
-  
   public void testClone() {
     TestAllTypesLite.Builder expected = TestAllTypesLite.newBuilder()
         .setOptionalInt32(123);
     assertEquals(
         expected.getOptionalInt32(), expected.clone().getOptionalInt32());
    
     TestAllExtensionsLite.Builder expected2 = TestAllExtensionsLite.newBuilder()
         .setExtension(UnittestLite.optionalInt32ExtensionLite, 123);
     assertEquals(
         expected2.getExtension(UnittestLite.optionalInt32ExtensionLite),
@@ skipping 1273 matching lines @@
             UnittestLite.optionalInt32ExtensionLite));
     assertEquals(
         11, (int) extendableMessage.getExtension(
             UnittestLite.optionalFixed32ExtensionLite));
   }
 
   public void testToStringDefaultInstance() throws Exception {
     assertToStringEquals("", TestAllTypesLite.getDefaultInstance());
   }
 
+  public void testToStringScalarFieldsSuffixedWithList() throws Exception {
+    assertToStringEquals("deceptively_named_list: 7", TestAllTypesLite.newBuilder()
+        .setDeceptivelyNamedList(7)
+        .build());
+  }
+
   public void testToStringPrimitives() throws Exception {
     TestAllTypesLite proto = TestAllTypesLite.newBuilder()
         .setOptionalInt32(1)
         .setOptionalInt64(9223372036854775807L)
         .build();
     assertToStringEquals("optional_int32: 1\noptional_int64: 9223372036854775807", proto);
 
     proto = TestAllTypesLite.newBuilder()
         .setOptionalBool(true)
         .setOptionalNestedEnum(TestAllTypesLite.NestedEnum.BAZ)
@@ skipping 177 matching lines @@
   }
 
   public void testMergeFromStream_invalidBytes() throws Exception {
     TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder()
         .setDefaultBool(true);
     try {
       builder.mergeFrom(CodedInputStream.newInstance("Invalid bytes".getBytes(Internal.UTF_8)));
       fail();
     } catch (InvalidProtocolBufferException expected) {}
   }
-  
+
   public void testMergeFrom_sanity() throws Exception {
     TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
     byte[] bytes = one.toByteArray();
     TestAllTypesLite two = TestAllTypesLite.parseFrom(bytes);
     
     one = one.toBuilder().mergeFrom(one).build();
     two = two.toBuilder().mergeFrom(bytes).build();
     assertEquals(one, two);
     assertEquals(two, one);
     assertEquals(one.hashCode(), two.hashCode());
   }
-  
+
+  public void testMergeFromNoLazyFieldSharing() throws Exception {
+    TestAllTypesLite.Builder sourceBuilder = TestAllTypesLite.newBuilder().setOptionalLazyMessage(
+        TestAllTypesLite.NestedMessage.newBuilder().setBb(1));
+    TestAllTypesLite.Builder targetBuilder =
+        TestAllTypesLite.newBuilder().mergeFrom(sourceBuilder.build());
+    assertEquals(1, sourceBuilder.getOptionalLazyMessage().getBb());
+    // now change the sourceBuilder, and target value shouldn't be affected.
+    sourceBuilder.setOptionalLazyMessage(
+        TestAllTypesLite.NestedMessage.newBuilder().setBb(2));
+    assertEquals(1, targetBuilder.getOptionalLazyMessage().getBb());
+  }
+
   public void testEquals_notEqual() throws Exception {
     TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
     byte[] bytes = one.toByteArray();
     TestAllTypesLite two = one.toBuilder().mergeFrom(one).mergeFrom(bytes).build();
     
     assertFalse(one.equals(two));
     assertFalse(two.equals(one));
     
     assertFalse(one.equals(TestAllTypesLite.getDefaultInstance()));
     assertFalse(TestAllTypesLite.getDefaultInstance().equals(one));
@@ skipping 539 matching lines @@
         .setExtension(Bar.fooExt, Bar.newBuilder()
             .setName("name")
             .build())
         .build();
 
     Foo fooWithValueAndUnknownFields = Foo.parseFrom(fooWithValueAndExtension.toByteArray());
 
     assertEqualsAndHashCodeAreFalse(fooWithOnlyValue, fooWithValueAndUnknownFields);
     assertEqualsAndHashCodeAreFalse(fooWithValueAndExtension, fooWithValueAndUnknownFields);
   }
+
+  public void testEqualsAndHashCodeWithExtensions() throws InvalidProtocolBufferException {
+    Foo fooWithOnlyValue = Foo.newBuilder()
+        .setValue(1)
+        .build();
+
+    Foo fooWithValueAndExtension = fooWithOnlyValue.toBuilder()
+        .setValue(1)
+        .setExtension(Bar.fooExt, Bar.newBuilder()
+            .setName("name")
+            .build())
+        .build();
+
+    assertEqualsAndHashCodeAreFalse(fooWithOnlyValue, fooWithValueAndExtension);
+  }
   
   // Test to ensure we avoid a class cast exception with oneofs.
   public void testEquals_oneOfMessages() {
     TestAllTypesLite mine = TestAllTypesLite.newBuilder()
         .setOneofString("Hello")
         .build();
     
     TestAllTypesLite other = TestAllTypesLite.newBuilder()
         .setOneofNestedMessage(NestedMessage.getDefaultInstance())
         .build();
     
     assertFalse(mine.equals(other));
     assertFalse(other.equals(mine));
   }
 
+  public void testHugeFieldNumbers() throws InvalidProtocolBufferException {
+    TestHugeFieldNumbersLite message =
+        TestHugeFieldNumbersLite.newBuilder()
+            .setOptionalInt32(1)
+            .addRepeatedInt32(2)
+            .setOptionalEnum(ForeignEnumLite.FOREIGN_LITE_FOO)
+            .setOptionalString("xyz")
+            .setOptionalMessage(ForeignMessageLite.newBuilder().setC(3).build())
+            .build();
+
+    TestHugeFieldNumbersLite parsedMessage =
+        TestHugeFieldNumbersLite.parseFrom(message.toByteArray());
+    assertEquals(1, parsedMessage.getOptionalInt32());
+    assertEquals(2, parsedMessage.getRepeatedInt32(0));
+    assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, parsedMessage.getOptionalEnum());
+    assertEquals("xyz", parsedMessage.getOptionalString());
+    assertEquals(3, parsedMessage.getOptionalMessage().getC());
+  }
+
   private void assertEqualsAndHashCodeAreFalse(Object o1, Object o2) {
     assertFalse(o1.equals(o2));
     assertFalse(o1.hashCode() == o2.hashCode());
   }
 
   public void testRecursiveHashcode() {
     // This tests that we don't infinite loop.
     TestRecursiveOneof.getDefaultInstance().hashCode();
   }
 }