diff options
Diffstat (limited to 'java/core/src/test/java')
17 files changed, 1223 insertions, 903 deletions
diff --git a/java/core/src/test/java/com/google/protobuf/AbstractMessageTest.java b/java/core/src/test/java/com/google/protobuf/AbstractMessageTest.java index 622e36a4..cb2d34eb 100644 --- a/java/core/src/test/java/com/google/protobuf/AbstractMessageTest.java +++ b/java/core/src/test/java/com/google/protobuf/AbstractMessageTest.java @@ -30,6 +30,9 @@ package com.google.protobuf; +import static com.google.protobuf.TestUtil.TEST_REQUIRED_INITIALIZED; +import static com.google.protobuf.TestUtil.TEST_REQUIRED_UNINITIALIZED; + import com.google.protobuf.Descriptors.FieldDescriptor; import protobuf_unittest.UnittestOptimizeFor.TestOptimizedForSize; import protobuf_unittest.UnittestProto; @@ -346,11 +349,6 @@ public class AbstractMessageTest extends TestCase { // ----------------------------------------------------------------- // Tests for isInitialized(). - private static final TestRequired TEST_REQUIRED_UNINITIALIZED = - TestRequired.getDefaultInstance(); - private static final TestRequired TEST_REQUIRED_INITIALIZED = - TestRequired.newBuilder().setA(1).setB(2).setC(3).build(); - public void testIsInitialized() throws Exception { TestRequired.Builder builder = TestRequired.newBuilder(); AbstractMessageWrapper.Builder abstractBuilder = @@ -380,7 +378,7 @@ public class AbstractMessageTest extends TestCase { builder.setOptionalMessage(TEST_REQUIRED_UNINITIALIZED); assertFalse(abstractBuilder.isInitialized()); assertEquals( - "optional_message.a, optional_message.b, optional_message.c", + "optional_message.b, optional_message.c", abstractBuilder.getInitializationErrorString()); builder.setOptionalMessage(TEST_REQUIRED_INITIALIZED); @@ -390,7 +388,7 @@ public class AbstractMessageTest extends TestCase { builder.addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED); assertFalse(abstractBuilder.isInitialized()); assertEquals( - "repeated_message[0].a, repeated_message[0].b, repeated_message[0].c", + "repeated_message[0].b, repeated_message[0].c", abstractBuilder.getInitializationErrorString()); builder.setRepeatedMessage(0, TEST_REQUIRED_INITIALIZED); diff --git a/java/core/src/test/java/com/google/protobuf/BooleanArrayListTest.java b/java/core/src/test/java/com/google/protobuf/BooleanArrayListTest.java index 18132e9e..4906763c 100644 --- a/java/core/src/test/java/com/google/protobuf/BooleanArrayListTest.java +++ b/java/core/src/test/java/com/google/protobuf/BooleanArrayListTest.java @@ -32,6 +32,7 @@ package com.google.protobuf; import static java.util.Arrays.asList; +import com.google.protobuf.Internal.BooleanList; import java.util.Collections; import java.util.ConcurrentModificationException; import java.util.Iterator; @@ -297,6 +298,20 @@ public class BooleanArrayListTest extends TestCase { } } + public void testRemoveEndOfCapacity() { + BooleanList toRemove = BooleanArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addBoolean(true); + toRemove.remove(0); + assertEquals(0, toRemove.size()); + } + + public void testSublistRemoveEndOfCapacity() { + BooleanList toRemove = BooleanArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addBoolean(true); + toRemove.subList(0, 1).clear(); + assertEquals(0, toRemove.size()); + } + private void assertImmutable(BooleanArrayList list) { try { diff --git a/java/core/src/test/java/com/google/protobuf/CheckUtf8Test.java b/java/core/src/test/java/com/google/protobuf/CheckUtf8Test.java index cc65d19a..50b87ae3 100644 --- a/java/core/src/test/java/com/google/protobuf/CheckUtf8Test.java +++ b/java/core/src/test/java/com/google/protobuf/CheckUtf8Test.java @@ -34,7 +34,7 @@ import proto2_test_check_utf8.TestCheckUtf8.BytesWrapper; import proto2_test_check_utf8.TestCheckUtf8.StringWrapper; import proto2_test_check_utf8_size.TestCheckUtf8Size.BytesWrapperSize; import proto2_test_check_utf8_size.TestCheckUtf8Size.StringWrapperSize; - +import java.io.ByteArrayInputStream; import junit.framework.TestCase; /** @@ -90,14 +90,9 @@ public class CheckUtf8Test extends TestCase { } public void testParseRequiredStringWithBadUtf8() throws Exception { - ByteString serialized = - BytesWrapper.newBuilder().setReq(NON_UTF8_BYTE_STRING).build().toByteString(); - try { - StringWrapper.parser().parseFrom(serialized); - fail("Expected InvalidProtocolBufferException for non UTF-8 byte string."); - } catch (InvalidProtocolBufferException exception) { - assertEquals("Protocol message had invalid UTF-8.", exception.getMessage()); - } + byte[] serialized = + BytesWrapper.newBuilder().setReq(NON_UTF8_BYTE_STRING).build().toByteArray(); + assertParseBadUtf8(StringWrapper.getDefaultInstance(), serialized); } public void testBuildRequiredStringWithBadUtf8Size() throws Exception { @@ -128,14 +123,36 @@ public class CheckUtf8Test extends TestCase { } public void testParseRequiredStringWithBadUtf8Size() throws Exception { - ByteString serialized = - BytesWrapperSize.newBuilder().setReq(NON_UTF8_BYTE_STRING).build().toByteString(); + byte[] serialized = + BytesWrapperSize.newBuilder().setReq(NON_UTF8_BYTE_STRING).build().toByteArray(); + assertParseBadUtf8(StringWrapperSize.getDefaultInstance(), serialized); + } + + private void assertParseBadUtf8(MessageLite defaultInstance, byte[] data) throws Exception { + // Check combinations of (parser vs. builder) x (byte[] vs. InputStream) + try { + defaultInstance.getParserForType().parseFrom(data); + fail("Expected InvalidProtocolBufferException for non UTF-8 byte string."); + } catch (InvalidProtocolBufferException exception) { + assertEquals("Protocol message had invalid UTF-8.", exception.getMessage()); + } + try { + defaultInstance.newBuilderForType().mergeFrom(data); + fail("Expected InvalidProtocolBufferException for non UTF-8 byte string."); + } catch (InvalidProtocolBufferException exception) { + assertEquals("Protocol message had invalid UTF-8.", exception.getMessage()); + } try { - StringWrapperSize.parser().parseFrom(serialized); + defaultInstance.getParserForType().parseFrom(new ByteArrayInputStream(data)); + fail("Expected InvalidProtocolBufferException for non UTF-8 byte string."); + } catch (InvalidProtocolBufferException exception) { + assertEquals("Protocol message had invalid UTF-8.", exception.getMessage()); + } + try { + defaultInstance.newBuilderForType().mergeFrom(new ByteArrayInputStream(data)); fail("Expected InvalidProtocolBufferException for non UTF-8 byte string."); } catch (InvalidProtocolBufferException exception) { assertEquals("Protocol message had invalid UTF-8.", exception.getMessage()); } } - } diff --git a/java/core/src/test/java/com/google/protobuf/DecodeUtf8Test.java b/java/core/src/test/java/com/google/protobuf/DecodeUtf8Test.java new file mode 100644 index 00000000..359d4d74 --- /dev/null +++ b/java/core/src/test/java/com/google/protobuf/DecodeUtf8Test.java @@ -0,0 +1,325 @@ +package com.google.protobuf; + +import com.google.protobuf.Utf8.Processor; +import com.google.protobuf.Utf8.SafeProcessor; +import com.google.protobuf.Utf8.UnsafeProcessor; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Logger; +import junit.framework.TestCase; + +public class DecodeUtf8Test extends TestCase { + private static Logger logger = Logger.getLogger(DecodeUtf8Test.class.getName()); + + private static final Processor SAFE_PROCESSOR = new SafeProcessor(); + private static final Processor UNSAFE_PROCESSOR = new UnsafeProcessor(); + + public void testRoundTripAllValidChars() throws Exception { + for (int i = Character.MIN_CODE_POINT; i < Character.MAX_CODE_POINT; i++) { + if (i < Character.MIN_SURROGATE || i > Character.MAX_SURROGATE) { + String str = new String(Character.toChars(i)); + assertRoundTrips(str); + } + } + } + + // Test all 1, 2, 3 invalid byte combinations. Valid ones would have been covered above. + + public void testOneByte() throws Exception { + int valid = 0; + for (int i = Byte.MIN_VALUE; i <= Byte.MAX_VALUE; i++) { + ByteString bs = ByteString.copyFrom(new byte[] { (byte) i }); + if (!bs.isValidUtf8()) { + assertInvalid(bs.toByteArray()); + } else { + valid++; + } + } + assertEquals(IsValidUtf8TestUtil.EXPECTED_ONE_BYTE_ROUNDTRIPPABLE_COUNT, valid); + } + + public void testTwoBytes() throws Exception { + int valid = 0; + for (int i = Byte.MIN_VALUE; i <= Byte.MAX_VALUE; i++) { + for (int j = Byte.MIN_VALUE; j <= Byte.MAX_VALUE; j++) { + ByteString bs = ByteString.copyFrom(new byte[]{(byte) i, (byte) j}); + if (!bs.isValidUtf8()) { + assertInvalid(bs.toByteArray()); + } else { + valid++; + } + } + } + assertEquals(IsValidUtf8TestUtil.EXPECTED_TWO_BYTE_ROUNDTRIPPABLE_COUNT, valid); + } + + public void testThreeBytes() throws Exception { + // Travis' OOM killer doesn't like this test + if (System.getenv("TRAVIS") == null) { + int count = 0; + int valid = 0; + for (int i = Byte.MIN_VALUE; i <= Byte.MAX_VALUE; i++) { + for (int j = Byte.MIN_VALUE; j <= Byte.MAX_VALUE; j++) { + for (int k = Byte.MIN_VALUE; k <= Byte.MAX_VALUE; k++) { + byte[] bytes = new byte[]{(byte) i, (byte) j, (byte) k}; + ByteString bs = ByteString.copyFrom(bytes); + if (!bs.isValidUtf8()) { + assertInvalid(bytes); + } else { + valid++; + } + count++; + if (count % 1000000L == 0) { + logger.info("Processed " + (count / 1000000L) + " million characters"); + } + } + } + } + assertEquals(IsValidUtf8TestUtil.EXPECTED_THREE_BYTE_ROUNDTRIPPABLE_COUNT, valid); + } + } + + /** + * Tests that round tripping of a sample of four byte permutations work. + */ + public void testInvalid_4BytesSamples() throws Exception { + // Bad trailing bytes + assertInvalid(0xF0, 0xA4, 0xAD, 0x7F); + assertInvalid(0xF0, 0xA4, 0xAD, 0xC0); + + // Special cases for byte2 + assertInvalid(0xF0, 0x8F, 0xAD, 0xA2); + assertInvalid(0xF4, 0x90, 0xAD, 0xA2); + } + + public void testRealStrings() throws Exception { + // English + assertRoundTrips("The quick brown fox jumps over the lazy dog"); + // German + assertRoundTrips("Quizdeltagerne spiste jordb\u00e6r med fl\u00f8de, mens cirkusklovnen"); + // Japanese + assertRoundTrips( + "\u3044\u308d\u306f\u306b\u307b\u3078\u3068\u3061\u308a\u306c\u308b\u3092"); + // Hebrew + assertRoundTrips( + "\u05d3\u05d2 \u05e1\u05e7\u05e8\u05df \u05e9\u05d8 \u05d1\u05d9\u05dd " + + "\u05de\u05d0\u05d5\u05db\u05d6\u05d1 \u05d5\u05dc\u05e4\u05ea\u05e2" + + " \u05de\u05e6\u05d0 \u05dc\u05d5 \u05d7\u05d1\u05e8\u05d4 " + + "\u05d0\u05d9\u05da \u05d4\u05e7\u05dc\u05d9\u05d8\u05d4"); + // Thai + assertRoundTrips( + " \u0e08\u0e07\u0e1d\u0e48\u0e32\u0e1f\u0e31\u0e19\u0e1e\u0e31\u0e12" + + "\u0e19\u0e32\u0e27\u0e34\u0e0a\u0e32\u0e01\u0e32\u0e23"); + // Chinese + assertRoundTrips( + "\u8fd4\u56de\u94fe\u4e2d\u7684\u4e0b\u4e00\u4e2a\u4ee3\u7406\u9879\u9009\u62e9\u5668"); + // Chinese with 4-byte chars + assertRoundTrips("\uD841\uDF0E\uD841\uDF31\uD841\uDF79\uD843\uDC53\uD843\uDC78" + + "\uD843\uDC96\uD843\uDCCF\uD843\uDCD5\uD843\uDD15\uD843\uDD7C\uD843\uDD7F" + + "\uD843\uDE0E\uD843\uDE0F\uD843\uDE77\uD843\uDE9D\uD843\uDEA2"); + // Mixed + assertRoundTrips( + "The quick brown \u3044\u308d\u306f\u306b\u307b\u3078\u8fd4\u56de\u94fe" + + "\u4e2d\u7684\u4e0b\u4e00"); + } + + public void testOverlong() throws Exception { + assertInvalid(0xc0, 0xaf); + assertInvalid(0xe0, 0x80, 0xaf); + assertInvalid(0xf0, 0x80, 0x80, 0xaf); + + // Max overlong + assertInvalid(0xc1, 0xbf); + assertInvalid(0xe0, 0x9f, 0xbf); + assertInvalid(0xf0 ,0x8f, 0xbf, 0xbf); + + // null overlong + assertInvalid(0xc0, 0x80); + assertInvalid(0xe0, 0x80, 0x80); + assertInvalid(0xf0, 0x80, 0x80, 0x80); + } + + public void testIllegalCodepoints() throws Exception { + // Single surrogate + assertInvalid(0xed, 0xa0, 0x80); + assertInvalid(0xed, 0xad, 0xbf); + assertInvalid(0xed, 0xae, 0x80); + assertInvalid(0xed, 0xaf, 0xbf); + assertInvalid(0xed, 0xb0, 0x80); + assertInvalid(0xed, 0xbe, 0x80); + assertInvalid(0xed, 0xbf, 0xbf); + + // Paired surrogates + assertInvalid(0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80); + assertInvalid(0xed, 0xa0, 0x80, 0xed, 0xbf, 0xbf); + assertInvalid(0xed, 0xad, 0xbf, 0xed, 0xb0, 0x80); + assertInvalid(0xed, 0xad, 0xbf, 0xed, 0xbf, 0xbf); + assertInvalid(0xed, 0xae, 0x80, 0xed, 0xb0, 0x80); + assertInvalid(0xed, 0xae, 0x80, 0xed, 0xbf, 0xbf); + assertInvalid(0xed, 0xaf, 0xbf, 0xed, 0xb0, 0x80); + assertInvalid(0xed, 0xaf, 0xbf, 0xed, 0xbf, 0xbf); + } + + public void testBufferSlice() throws Exception { + String str = "The quick brown fox jumps over the lazy dog"; + assertRoundTrips(str, 10, 4); + assertRoundTrips(str, str.length(), 0); + } + + public void testInvalidBufferSlice() throws Exception { + byte[] bytes = "The quick brown fox jumps over the lazy dog".getBytes(Internal.UTF_8); + assertInvalidSlice(bytes, bytes.length - 3, 4); + assertInvalidSlice(bytes, bytes.length, 1); + assertInvalidSlice(bytes, bytes.length + 1, 0); + assertInvalidSlice(bytes, 0, bytes.length + 1); + } + + private void assertInvalid(int... bytesAsInt) throws Exception { + byte[] bytes = new byte[bytesAsInt.length]; + for (int i = 0; i < bytesAsInt.length; i++) { + bytes[i] = (byte) bytesAsInt[i]; + } + assertInvalid(bytes); + } + + private void assertInvalid(byte[] bytes) throws Exception { + try { + UNSAFE_PROCESSOR.decodeUtf8(bytes, 0, bytes.length); + fail(); + } catch (InvalidProtocolBufferException e) { + // Expected. + } + try { + SAFE_PROCESSOR.decodeUtf8(bytes, 0, bytes.length); + fail(); + } catch (InvalidProtocolBufferException e) { + // Expected. + } + + ByteBuffer direct = ByteBuffer.allocateDirect(bytes.length); + direct.put(bytes); + direct.flip(); + try { + UNSAFE_PROCESSOR.decodeUtf8(direct, 0, bytes.length); + fail(); + } catch (InvalidProtocolBufferException e) { + // Expected. + } + try { + SAFE_PROCESSOR.decodeUtf8(direct, 0, bytes.length); + fail(); + } catch (InvalidProtocolBufferException e) { + // Expected. + } + + ByteBuffer heap = ByteBuffer.allocate(bytes.length); + heap.put(bytes); + heap.flip(); + try { + UNSAFE_PROCESSOR.decodeUtf8(heap, 0, bytes.length); + fail(); + } catch (InvalidProtocolBufferException e) { + // Expected. + } + try { + SAFE_PROCESSOR.decodeUtf8(heap, 0, bytes.length); + fail(); + } catch (InvalidProtocolBufferException e) { + // Expected. + } + } + + private void assertInvalidSlice(byte[] bytes, int index, int size) throws Exception { + try { + UNSAFE_PROCESSOR.decodeUtf8(bytes, index, size); + fail(); + } catch (ArrayIndexOutOfBoundsException e) { + // Expected. + } + try { + SAFE_PROCESSOR.decodeUtf8(bytes, index, size); + fail(); + } catch (ArrayIndexOutOfBoundsException e) { + // Expected. + } + + ByteBuffer direct = ByteBuffer.allocateDirect(bytes.length); + direct.put(bytes); + direct.flip(); + try { + UNSAFE_PROCESSOR.decodeUtf8(direct, index, size); + fail(); + } catch (ArrayIndexOutOfBoundsException e) { + // Expected. + } + try { + SAFE_PROCESSOR.decodeUtf8(direct, index, size); + fail(); + } catch (ArrayIndexOutOfBoundsException e) { + // Expected. + } + + ByteBuffer heap = ByteBuffer.allocate(bytes.length); + heap.put(bytes); + heap.flip(); + try { + UNSAFE_PROCESSOR.decodeUtf8(heap, index, size); + fail(); + } catch (ArrayIndexOutOfBoundsException e) { + // Expected. + } + try { + SAFE_PROCESSOR.decodeUtf8(heap, index, size); + fail(); + } catch (ArrayIndexOutOfBoundsException e) { + // Expected. + } + } + + private void assertRoundTrips(String str) throws Exception { + assertRoundTrips(str, 0, -1); + } + + private void assertRoundTrips(String str, int index, int size) throws Exception { + byte[] bytes = str.getBytes(Internal.UTF_8); + if (size == -1) { + size = bytes.length; + } + assertDecode(new String(bytes, index, size, Internal.UTF_8), + UNSAFE_PROCESSOR.decodeUtf8(bytes, index, size)); + assertDecode(new String(bytes, index, size, Internal.UTF_8), + SAFE_PROCESSOR.decodeUtf8(bytes, index, size)); + + ByteBuffer direct = ByteBuffer.allocateDirect(bytes.length); + direct.put(bytes); + direct.flip(); + assertDecode(new String(bytes, index, size, Internal.UTF_8), + UNSAFE_PROCESSOR.decodeUtf8(direct, index, size)); + assertDecode(new String(bytes, index, size, Internal.UTF_8), + SAFE_PROCESSOR.decodeUtf8(direct, index, size)); + + ByteBuffer heap = ByteBuffer.allocate(bytes.length); + heap.put(bytes); + heap.flip(); + assertDecode(new String(bytes, index, size, Internal.UTF_8), + UNSAFE_PROCESSOR.decodeUtf8(heap, index, size)); + assertDecode(new String(bytes, index, size, Internal.UTF_8), + SAFE_PROCESSOR.decodeUtf8(heap, index, size)); + } + + private void assertDecode(String expected, String actual) { + if (!expected.equals(actual)) { + fail("Failure: Expected (" + codepoints(expected) + ") Actual (" + codepoints(actual) + ")"); + } + } + + private List<String> codepoints(String str) { + List<String> codepoints = new ArrayList<String>(); + for (int i = 0; i < str.length(); i++) { + codepoints.add(Long.toHexString(str.charAt(i))); + } + return codepoints; + } + +} diff --git a/java/core/src/test/java/com/google/protobuf/DeprecatedFieldTest.java b/java/core/src/test/java/com/google/protobuf/DeprecatedFieldTest.java index 2c272a73..9c0997c4 100644 --- a/java/core/src/test/java/com/google/protobuf/DeprecatedFieldTest.java +++ b/java/core/src/test/java/com/google/protobuf/DeprecatedFieldTest.java @@ -37,22 +37,22 @@ import junit.framework.TestCase; /** * Test field deprecation - * + * * @author birdo@google.com (Roberto Scaramuzzi) */ public class DeprecatedFieldTest extends TestCase { private String[] deprecatedGetterNames = { "hasDeprecatedInt32", "getDeprecatedInt32"}; - + private String[] deprecatedBuilderGetterNames = { "hasDeprecatedInt32", "getDeprecatedInt32", "clearDeprecatedInt32"}; - + private String[] deprecatedBuilderSetterNames = { - "setDeprecatedInt32"}; - + "setDeprecatedInt32"}; + public void testDeprecatedField() throws Exception { Class<?> deprecatedFields = TestDeprecatedFields.class; Class<?> deprecatedFieldsBuilder = TestDeprecatedFields.Builder.class; @@ -72,7 +72,15 @@ public class DeprecatedFieldTest extends TestCase { isDeprecated(method)); } } - + + public void testDeprecatedFieldInOneof() throws Exception { + Class<?> oneofCase = TestDeprecatedFields.OneofFieldsCase.class; + String name = "DEPRECATED_INT32_IN_ONEOF"; + java.lang.reflect.Field enumValue = oneofCase.getField(name); + assertTrue("Enum value " + name + " should be deprecated.", + isDeprecated(enumValue)); + } + private boolean isDeprecated(AnnotatedElement annotated) { return annotated.isAnnotationPresent(Deprecated.class); } diff --git a/java/core/src/test/java/com/google/protobuf/DoubleArrayListTest.java b/java/core/src/test/java/com/google/protobuf/DoubleArrayListTest.java index d8942792..923d7f43 100644 --- a/java/core/src/test/java/com/google/protobuf/DoubleArrayListTest.java +++ b/java/core/src/test/java/com/google/protobuf/DoubleArrayListTest.java @@ -32,6 +32,7 @@ package com.google.protobuf; import static java.util.Arrays.asList; +import com.google.protobuf.Internal.DoubleList; import java.util.Collections; import java.util.ConcurrentModificationException; import java.util.Iterator; @@ -297,6 +298,20 @@ public class DoubleArrayListTest extends TestCase { } } + public void testRemoveEndOfCapacity() { + DoubleList toRemove = DoubleArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addDouble(3); + toRemove.remove(0); + assertEquals(0, toRemove.size()); + } + + public void testSublistRemoveEndOfCapacity() { + DoubleList toRemove = DoubleArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addDouble(3); + toRemove.subList(0, 1).clear(); + assertEquals(0, toRemove.size()); + } + private void assertImmutable(DoubleArrayList list) { if (list.contains(1D)) { throw new RuntimeException("Cannot test the immutability of lists that contain 1."); diff --git a/java/core/src/test/java/com/google/protobuf/FloatArrayListTest.java b/java/core/src/test/java/com/google/protobuf/FloatArrayListTest.java index aa36be49..903a79db 100644 --- a/java/core/src/test/java/com/google/protobuf/FloatArrayListTest.java +++ b/java/core/src/test/java/com/google/protobuf/FloatArrayListTest.java @@ -32,6 +32,7 @@ package com.google.protobuf; import static java.util.Arrays.asList; +import com.google.protobuf.Internal.FloatList; import java.util.Collections; import java.util.ConcurrentModificationException; import java.util.Iterator; @@ -297,6 +298,20 @@ public class FloatArrayListTest extends TestCase { } } + public void testRemoveEndOfCapacity() { + FloatList toRemove = FloatArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addFloat(3); + toRemove.remove(0); + assertEquals(0, toRemove.size()); + } + + public void testSublistRemoveEndOfCapacity() { + FloatList toRemove = FloatArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addFloat(3); + toRemove.subList(0, 1).clear(); + assertEquals(0, toRemove.size()); + } + private void assertImmutable(FloatArrayList list) { if (list.contains(1F)) { throw new RuntimeException("Cannot test the immutability of lists that contain 1."); diff --git a/java/core/src/test/java/com/google/protobuf/IntArrayListTest.java b/java/core/src/test/java/com/google/protobuf/IntArrayListTest.java index 60c85450..d8e97d4f 100644 --- a/java/core/src/test/java/com/google/protobuf/IntArrayListTest.java +++ b/java/core/src/test/java/com/google/protobuf/IntArrayListTest.java @@ -32,6 +32,7 @@ package com.google.protobuf; import static java.util.Arrays.asList; +import com.google.protobuf.Internal.IntList; import java.util.Collections; import java.util.ConcurrentModificationException; import java.util.Iterator; @@ -297,6 +298,20 @@ public class IntArrayListTest extends TestCase { } } + public void testRemoveEndOfCapacity() { + IntList toRemove = IntArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addInt(3); + toRemove.remove(0); + assertEquals(0, toRemove.size()); + } + + public void testSublistRemoveEndOfCapacity() { + IntList toRemove = IntArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addInt(3); + toRemove.subList(0, 1).clear(); + assertEquals(0, toRemove.size()); + } + private void assertImmutable(IntArrayList list) { if (list.contains(1)) { throw new RuntimeException("Cannot test the immutability of lists that contain 1."); diff --git a/java/core/src/test/java/com/google/protobuf/IsValidUtf8TestUtil.java b/java/core/src/test/java/com/google/protobuf/IsValidUtf8TestUtil.java index 16a808bf..1bcf63e7 100644 --- a/java/core/src/test/java/com/google/protobuf/IsValidUtf8TestUtil.java +++ b/java/core/src/test/java/com/google/protobuf/IsValidUtf8TestUtil.java @@ -273,6 +273,15 @@ final class IsValidUtf8TestUtil { assertEquals(isRoundTrippable, Utf8.isValidUtf8(bytes)); assertEquals(isRoundTrippable, Utf8.isValidUtf8(bytes, 0, numBytes)); + try { + assertEquals(s, Utf8.decodeUtf8(bytes, 0, numBytes)); + } catch (InvalidProtocolBufferException e) { + if (isRoundTrippable) { + System.out.println("Could not decode utf-8"); + outputFailure(byteChar, bytes, bytesReencoded); + } + } + // Test partial sequences. // Partition numBytes into three segments (not necessarily non-empty). int i = rnd.nextInt(numBytes); diff --git a/java/core/src/test/java/com/google/protobuf/LiteTest.java b/java/core/src/test/java/com/google/protobuf/LiteTest.java index 40b44538..5ab80ca2 100644 --- a/java/core/src/test/java/com/google/protobuf/LiteTest.java +++ b/java/core/src/test/java/com/google/protobuf/LiteTest.java @@ -48,11 +48,15 @@ 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 map_lite_test.MapTestProto.TestMap; +import map_lite_test.MapTestProto.TestMap.MessageValue; 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 java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; import java.lang.reflect.Field; import java.nio.ByteBuffer; import java.util.ArrayList; @@ -88,12 +92,11 @@ public class LiteTest extends TestCase { // stuff to make sure the lite message is actually here and usable. TestAllTypesLite message = - TestAllTypesLite.newBuilder() - .setOptionalInt32(123) - .addRepeatedString("hello") - .setOptionalNestedMessage( - TestAllTypesLite.NestedMessage.newBuilder().setBb(7)) - .build(); + TestAllTypesLite.newBuilder() + .setOptionalInt32(123) + .addRepeatedString("hello") + .setOptionalNestedMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(7)) + .build(); ByteString data = message.toByteString(); @@ -105,57 +108,66 @@ public class LiteTest extends TestCase { assertEquals(7, message2.getOptionalNestedMessage().getBb()); } + public void testLite_unknownEnumAtListBoundary() throws Exception { + ByteArrayOutputStream byteStream = new ByteArrayOutputStream(); + CodedOutputStream output = CodedOutputStream.newInstance(byteStream); + for (int i = 0; i < AbstractProtobufList.DEFAULT_CAPACITY; i++) { + output.writeInt32(TestAllTypesLite.REPEATED_NESTED_ENUM_FIELD_NUMBER, 1); + } + // 0 is not a valid enum value for NestedEnum + output.writeInt32(TestAllTypesLite.REPEATED_NESTED_ENUM_FIELD_NUMBER, 0); + output.flush(); + // This tests a bug we had once with removal right at the boundary of the array. It would throw + // at runtime so no need to assert. + TestAllTypesLite.parseFrom(new ByteArrayInputStream(byteStream.toByteArray())); + } + public void testLiteExtensions() throws Exception { // TODO(kenton): Unlike other features of the lite library, extensions are // implemented completely differently from the regular library. We // should probably test them more thoroughly. TestAllExtensionsLite message = - TestAllExtensionsLite.newBuilder() - .setExtension(UnittestLite.optionalInt32ExtensionLite, 123) - .addExtension(UnittestLite.repeatedStringExtensionLite, "hello") - .setExtension(UnittestLite.optionalNestedEnumExtensionLite, - TestAllTypesLite.NestedEnum.BAZ) - .setExtension(UnittestLite.optionalNestedMessageExtensionLite, - TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build()) - .build(); + TestAllExtensionsLite.newBuilder() + .setExtension(UnittestLite.optionalInt32ExtensionLite, 123) + .addExtension(UnittestLite.repeatedStringExtensionLite, "hello") + .setExtension( + UnittestLite.optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ) + .setExtension( + UnittestLite.optionalNestedMessageExtensionLite, + TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build()) + .build(); // Test copying a message, since coping extensions actually does use a // different code path between lite and regular libraries, and as of this // writing, parsing hasn't been implemented yet. TestAllExtensionsLite message2 = message.toBuilder().build(); - assertEquals(123, (int) message2.getExtension( - UnittestLite.optionalInt32ExtensionLite)); - assertEquals(1, message2.getExtensionCount( - UnittestLite.repeatedStringExtensionLite)); - 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()); + assertEquals(123, (int) message2.getExtension(UnittestLite.optionalInt32ExtensionLite)); + assertEquals(1, message2.getExtensionCount(UnittestLite.repeatedStringExtensionLite)); + 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); + 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), expected2.clone().getExtension(UnittestLite.optionalInt32ExtensionLite)); } - + public void testAddAll() { try { - TestAllTypesLite.newBuilder() - .addAllRepeatedBytes(null); + TestAllTypesLite.newBuilder().addAllRepeatedBytes(null); fail(); } catch (NullPointerException e) { // expected. @@ -186,7 +198,7 @@ public class LiteTest extends TestCase { // We have to cast to Byte first. Casting to byte causes a type error assertEquals(1, ((Byte) memo.get(message)).intValue()); } - + public void testSanityCopyOnWrite() throws InvalidProtocolBufferException { // Since builders are implemented as a thin wrapper around a message // instance, we attempt to verify that we can't cause the builder to modify @@ -210,13 +222,11 @@ public class LiteTest extends TestCase { assertEquals(ByteString.EMPTY, message.getOptionalBytes()); assertEquals(ByteString.copyFromUtf8("hi"), builder.getOptionalBytes()); messageAfterBuild = builder.build(); - assertEquals( - ByteString.copyFromUtf8("hi"), messageAfterBuild.getOptionalBytes()); + assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getOptionalBytes()); assertEquals(ByteString.EMPTY, message.getOptionalBytes()); builder.clearOptionalBytes(); assertEquals(ByteString.EMPTY, builder.getOptionalBytes()); - assertEquals( - ByteString.copyFromUtf8("hi"), messageAfterBuild.getOptionalBytes()); + assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getOptionalBytes()); message = builder.build(); builder.setOptionalCord("hi"); @@ -234,27 +244,23 @@ public class LiteTest extends TestCase { assertEquals(ByteString.EMPTY, message.getOptionalCordBytes()); assertEquals(ByteString.copyFromUtf8("no"), builder.getOptionalCordBytes()); messageAfterBuild = builder.build(); - assertEquals( - ByteString.copyFromUtf8("no"), - messageAfterBuild.getOptionalCordBytes()); + assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalCordBytes()); assertEquals(ByteString.EMPTY, message.getOptionalCordBytes()); builder.clearOptionalCord(); assertEquals(ByteString.EMPTY, builder.getOptionalCordBytes()); - assertEquals( - ByteString.copyFromUtf8("no"), - messageAfterBuild.getOptionalCordBytes()); - + assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalCordBytes()); + message = builder.build(); builder.setOptionalDouble(1); - assertEquals(0D, message.getOptionalDouble()); - assertEquals(1D, builder.getOptionalDouble()); + assertEquals(0D, message.getOptionalDouble(), 0.0); + assertEquals(1D, builder.getOptionalDouble(), 0.0); messageAfterBuild = builder.build(); - assertEquals(1D, messageAfterBuild.getOptionalDouble()); - assertEquals(0D, message.getOptionalDouble()); + assertEquals(1D, messageAfterBuild.getOptionalDouble(), 0.0); + assertEquals(0D, message.getOptionalDouble(), 0.0); builder.clearOptionalDouble(); - assertEquals(0D, builder.getOptionalDouble()); - assertEquals(1D, messageAfterBuild.getOptionalDouble()); - + assertEquals(0D, builder.getOptionalDouble(), 0.0); + assertEquals(1D, messageAfterBuild.getOptionalDouble(), 0.0); + message = builder.build(); builder.setOptionalFixed32(1); assertEquals(0, message.getOptionalFixed32()); @@ -265,7 +271,7 @@ public class LiteTest extends TestCase { builder.clearOptionalFixed32(); assertEquals(0, builder.getOptionalFixed32()); assertEquals(1, messageAfterBuild.getOptionalFixed32()); - + message = builder.build(); builder.setOptionalFixed64(1); assertEquals(0L, message.getOptionalFixed64()); @@ -279,105 +285,72 @@ public class LiteTest extends TestCase { message = builder.build(); builder.setOptionalFloat(1); - assertEquals(0F, message.getOptionalFloat()); - assertEquals(1F, builder.getOptionalFloat()); + assertEquals(0F, message.getOptionalFloat(), 0.0f); + assertEquals(1F, builder.getOptionalFloat(), 0.0f); messageAfterBuild = builder.build(); - assertEquals(1F, messageAfterBuild.getOptionalFloat()); - assertEquals(0F, message.getOptionalFloat()); + assertEquals(1F, messageAfterBuild.getOptionalFloat(), 0.0f); + assertEquals(0F, message.getOptionalFloat(), 0.0f); builder.clearOptionalFloat(); - assertEquals(0F, builder.getOptionalFloat()); - assertEquals(1F, messageAfterBuild.getOptionalFloat()); + assertEquals(0F, builder.getOptionalFloat(), 0.0f); + assertEquals(1F, messageAfterBuild.getOptionalFloat(), 0.0f); message = builder.build(); builder.setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR); - assertEquals( - ForeignEnumLite.FOREIGN_LITE_FOO, message.getOptionalForeignEnum()); - assertEquals( - ForeignEnumLite.FOREIGN_LITE_BAR, builder.getOptionalForeignEnum()); + assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, message.getOptionalForeignEnum()); + assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, builder.getOptionalForeignEnum()); messageAfterBuild = builder.build(); - assertEquals( - ForeignEnumLite.FOREIGN_LITE_BAR, - messageAfterBuild.getOptionalForeignEnum()); - assertEquals( - ForeignEnumLite.FOREIGN_LITE_FOO, message.getOptionalForeignEnum()); + assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, messageAfterBuild.getOptionalForeignEnum()); + assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, message.getOptionalForeignEnum()); builder.clearOptionalForeignEnum(); - assertEquals( - ForeignEnumLite.FOREIGN_LITE_FOO, builder.getOptionalForeignEnum()); - assertEquals( - ForeignEnumLite.FOREIGN_LITE_BAR, - messageAfterBuild.getOptionalForeignEnum()); + assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, builder.getOptionalForeignEnum()); + assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, messageAfterBuild.getOptionalForeignEnum()); message = builder.build(); - ForeignMessageLite foreignMessage = ForeignMessageLite.newBuilder() - .setC(1) - .build(); + ForeignMessageLite foreignMessage = ForeignMessageLite.newBuilder().setC(1).build(); builder.setOptionalForeignMessage(foreignMessage); - assertEquals( - ForeignMessageLite.getDefaultInstance(), - message.getOptionalForeignMessage()); + assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage()); assertEquals(foreignMessage, builder.getOptionalForeignMessage()); messageAfterBuild = builder.build(); assertEquals(foreignMessage, messageAfterBuild.getOptionalForeignMessage()); - assertEquals( - ForeignMessageLite.getDefaultInstance(), - message.getOptionalForeignMessage()); + assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage()); builder.clearOptionalForeignMessage(); - assertEquals( - ForeignMessageLite.getDefaultInstance(), - builder.getOptionalForeignMessage()); + assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getOptionalForeignMessage()); assertEquals(foreignMessage, messageAfterBuild.getOptionalForeignMessage()); message = builder.build(); - ForeignMessageLite.Builder foreignMessageBuilder = - ForeignMessageLite.newBuilder() - .setC(3); + ForeignMessageLite.Builder foreignMessageBuilder = ForeignMessageLite.newBuilder().setC(3); builder.setOptionalForeignMessage(foreignMessageBuilder); - assertEquals( - ForeignMessageLite.getDefaultInstance(), - message.getOptionalForeignMessage()); + assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage()); assertEquals(foreignMessageBuilder.build(), builder.getOptionalForeignMessage()); messageAfterBuild = builder.build(); assertEquals(foreignMessageBuilder.build(), messageAfterBuild.getOptionalForeignMessage()); - assertEquals( - ForeignMessageLite.getDefaultInstance(), - message.getOptionalForeignMessage()); + assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage()); builder.clearOptionalForeignMessage(); - assertEquals( - ForeignMessageLite.getDefaultInstance(), - builder.getOptionalForeignMessage()); + assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getOptionalForeignMessage()); assertEquals(foreignMessageBuilder.build(), messageAfterBuild.getOptionalForeignMessage()); message = builder.build(); - OptionalGroup optionalGroup = OptionalGroup.newBuilder() - .setA(1) - .build(); + OptionalGroup optionalGroup = OptionalGroup.newBuilder().setA(1).build(); builder.setOptionalGroup(optionalGroup); - assertEquals( - OptionalGroup.getDefaultInstance(), message.getOptionalGroup()); + assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup()); assertEquals(optionalGroup, builder.getOptionalGroup()); messageAfterBuild = builder.build(); assertEquals(optionalGroup, messageAfterBuild.getOptionalGroup()); - assertEquals( - OptionalGroup.getDefaultInstance(), message.getOptionalGroup()); + assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup()); builder.clearOptionalGroup(); - assertEquals( - OptionalGroup.getDefaultInstance(), builder.getOptionalGroup()); + assertEquals(OptionalGroup.getDefaultInstance(), builder.getOptionalGroup()); assertEquals(optionalGroup, messageAfterBuild.getOptionalGroup()); message = builder.build(); - OptionalGroup.Builder optionalGroupBuilder = OptionalGroup.newBuilder() - .setA(3); + OptionalGroup.Builder optionalGroupBuilder = OptionalGroup.newBuilder().setA(3); builder.setOptionalGroup(optionalGroupBuilder); - assertEquals( - OptionalGroup.getDefaultInstance(), message.getOptionalGroup()); + assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup()); assertEquals(optionalGroupBuilder.build(), builder.getOptionalGroup()); messageAfterBuild = builder.build(); assertEquals(optionalGroupBuilder.build(), messageAfterBuild.getOptionalGroup()); - assertEquals( - OptionalGroup.getDefaultInstance(), message.getOptionalGroup()); + assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup()); builder.clearOptionalGroup(); - assertEquals( - OptionalGroup.getDefaultInstance(), builder.getOptionalGroup()); + assertEquals(OptionalGroup.getDefaultInstance(), builder.getOptionalGroup()); assertEquals(optionalGroupBuilder.build(), messageAfterBuild.getOptionalGroup()); message = builder.build(); @@ -401,43 +374,29 @@ public class LiteTest extends TestCase { builder.clearOptionalInt64(); assertEquals(0L, builder.getOptionalInt64()); assertEquals(1L, messageAfterBuild.getOptionalInt64()); - + message = builder.build(); - NestedMessage nestedMessage = NestedMessage.newBuilder() - .setBb(1) - .build(); + NestedMessage nestedMessage = NestedMessage.newBuilder().setBb(1).build(); builder.setOptionalLazyMessage(nestedMessage); - assertEquals( - NestedMessage.getDefaultInstance(), - message.getOptionalLazyMessage()); + assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage()); assertEquals(nestedMessage, builder.getOptionalLazyMessage()); messageAfterBuild = builder.build(); assertEquals(nestedMessage, messageAfterBuild.getOptionalLazyMessage()); - assertEquals( - NestedMessage.getDefaultInstance(), - message.getOptionalLazyMessage()); + assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage()); builder.clearOptionalLazyMessage(); - assertEquals( - NestedMessage.getDefaultInstance(), builder.getOptionalLazyMessage()); + assertEquals(NestedMessage.getDefaultInstance(), builder.getOptionalLazyMessage()); assertEquals(nestedMessage, messageAfterBuild.getOptionalLazyMessage()); message = builder.build(); - NestedMessage.Builder nestedMessageBuilder = - NestedMessage.newBuilder() - .setBb(3); + NestedMessage.Builder nestedMessageBuilder = NestedMessage.newBuilder().setBb(3); builder.setOptionalLazyMessage(nestedMessageBuilder); - assertEquals( - NestedMessage.getDefaultInstance(), - message.getOptionalLazyMessage()); + assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage()); assertEquals(nestedMessageBuilder.build(), builder.getOptionalLazyMessage()); messageAfterBuild = builder.build(); assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getOptionalLazyMessage()); - assertEquals( - NestedMessage.getDefaultInstance(), - message.getOptionalLazyMessage()); + assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage()); builder.clearOptionalLazyMessage(); - assertEquals( - NestedMessage.getDefaultInstance(), builder.getOptionalLazyMessage()); + assertEquals(NestedMessage.getDefaultInstance(), builder.getOptionalLazyMessage()); assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getOptionalLazyMessage()); message = builder.build(); @@ -497,19 +456,14 @@ public class LiteTest extends TestCase { message = builder.build(); builder.setOptionalStringBytes(ByteString.copyFromUtf8("no")); assertEquals(ByteString.EMPTY, message.getOptionalStringBytes()); - assertEquals( - ByteString.copyFromUtf8("no"), builder.getOptionalStringBytes()); + assertEquals(ByteString.copyFromUtf8("no"), builder.getOptionalStringBytes()); messageAfterBuild = builder.build(); - assertEquals( - ByteString.copyFromUtf8("no"), - messageAfterBuild.getOptionalStringBytes()); + assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringBytes()); assertEquals(ByteString.EMPTY, message.getOptionalStringBytes()); builder.clearOptionalString(); assertEquals(ByteString.EMPTY, builder.getOptionalStringBytes()); - assertEquals( - ByteString.copyFromUtf8("no"), - messageAfterBuild.getOptionalStringBytes()); - + assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringBytes()); + message = builder.build(); builder.setOptionalStringPiece("hi"); assertEquals("", message.getOptionalStringPiece()); @@ -524,18 +478,13 @@ public class LiteTest extends TestCase { message = builder.build(); builder.setOptionalStringPieceBytes(ByteString.copyFromUtf8("no")); assertEquals(ByteString.EMPTY, message.getOptionalStringPieceBytes()); - assertEquals( - ByteString.copyFromUtf8("no"), builder.getOptionalStringPieceBytes()); + assertEquals(ByteString.copyFromUtf8("no"), builder.getOptionalStringPieceBytes()); messageAfterBuild = builder.build(); - assertEquals( - ByteString.copyFromUtf8("no"), - messageAfterBuild.getOptionalStringPieceBytes()); + assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringPieceBytes()); assertEquals(ByteString.EMPTY, message.getOptionalStringPieceBytes()); builder.clearOptionalStringPiece(); assertEquals(ByteString.EMPTY, builder.getOptionalStringPieceBytes()); - assertEquals( - ByteString.copyFromUtf8("no"), - messageAfterBuild.getOptionalStringPieceBytes()); + assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringPieceBytes()); message = builder.build(); builder.setOptionalUint32(1); @@ -572,16 +521,13 @@ public class LiteTest extends TestCase { message = builder.build(); builder.addAllRepeatedBytes(singletonList(ByteString.copyFromUtf8("hi"))); assertEquals(emptyList(), message.getRepeatedBytesList()); - assertEquals( - singletonList(ByteString.copyFromUtf8("hi")), - builder.getRepeatedBytesList()); + assertEquals(singletonList(ByteString.copyFromUtf8("hi")), builder.getRepeatedBytesList()); assertEquals(emptyList(), message.getRepeatedBytesList()); messageAfterBuild = builder.build(); builder.clearRepeatedBytes(); assertEquals(emptyList(), builder.getRepeatedBytesList()); assertEquals( - singletonList(ByteString.copyFromUtf8("hi")), - messageAfterBuild.getRepeatedBytesList()); + singletonList(ByteString.copyFromUtf8("hi")), messageAfterBuild.getRepeatedBytesList()); message = builder.build(); builder.addAllRepeatedCord(singletonList("hi")); @@ -634,12 +580,10 @@ public class LiteTest extends TestCase { assertEquals(singletonList(1F), messageAfterBuild.getRepeatedFloatList()); message = builder.build(); - builder.addAllRepeatedForeignEnum( - singletonList(ForeignEnumLite.FOREIGN_LITE_BAR)); + builder.addAllRepeatedForeignEnum(singletonList(ForeignEnumLite.FOREIGN_LITE_BAR)); assertEquals(emptyList(), message.getRepeatedForeignEnumList()); assertEquals( - singletonList(ForeignEnumLite.FOREIGN_LITE_BAR), - builder.getRepeatedForeignEnumList()); + singletonList(ForeignEnumLite.FOREIGN_LITE_BAR), builder.getRepeatedForeignEnumList()); assertEquals(emptyList(), message.getRepeatedForeignEnumList()); messageAfterBuild = builder.build(); builder.clearRepeatedForeignEnum(); @@ -651,23 +595,17 @@ public class LiteTest extends TestCase { message = builder.build(); builder.addAllRepeatedForeignMessage(singletonList(foreignMessage)); assertEquals(emptyList(), message.getRepeatedForeignMessageList()); - assertEquals( - singletonList(foreignMessage), builder.getRepeatedForeignMessageList()); + assertEquals(singletonList(foreignMessage), builder.getRepeatedForeignMessageList()); assertEquals(emptyList(), message.getRepeatedForeignMessageList()); messageAfterBuild = builder.build(); builder.clearRepeatedForeignMessage(); assertEquals(emptyList(), builder.getRepeatedForeignMessageList()); - assertEquals( - singletonList(foreignMessage), - messageAfterBuild.getRepeatedForeignMessageList()); + assertEquals(singletonList(foreignMessage), messageAfterBuild.getRepeatedForeignMessageList()); message = builder.build(); - builder.addAllRepeatedGroup( - singletonList(RepeatedGroup.getDefaultInstance())); + builder.addAllRepeatedGroup(singletonList(RepeatedGroup.getDefaultInstance())); assertEquals(emptyList(), message.getRepeatedGroupList()); - assertEquals( - singletonList(RepeatedGroup.getDefaultInstance()), - builder.getRepeatedGroupList()); + assertEquals(singletonList(RepeatedGroup.getDefaultInstance()), builder.getRepeatedGroupList()); assertEquals(emptyList(), message.getRepeatedGroupList()); messageAfterBuild = builder.build(); builder.clearRepeatedGroup(); @@ -699,15 +637,12 @@ public class LiteTest extends TestCase { message = builder.build(); builder.addAllRepeatedLazyMessage(singletonList(nestedMessage)); assertEquals(emptyList(), message.getRepeatedLazyMessageList()); - assertEquals( - singletonList(nestedMessage), builder.getRepeatedLazyMessageList()); + assertEquals(singletonList(nestedMessage), builder.getRepeatedLazyMessageList()); assertEquals(emptyList(), message.getRepeatedLazyMessageList()); messageAfterBuild = builder.build(); builder.clearRepeatedLazyMessage(); assertEquals(emptyList(), builder.getRepeatedLazyMessageList()); - assertEquals( - singletonList(nestedMessage), - messageAfterBuild.getRepeatedLazyMessageList()); + assertEquals(singletonList(nestedMessage), messageAfterBuild.getRepeatedLazyMessageList()); message = builder.build(); builder.addAllRepeatedSfixed32(singletonList(1)); @@ -727,8 +662,7 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); builder.clearRepeatedSfixed64(); assertEquals(emptyList(), builder.getRepeatedSfixed64List()); - assertEquals( - singletonList(1L), messageAfterBuild.getRepeatedSfixed64List()); + assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSfixed64List()); message = builder.build(); builder.addAllRepeatedSint32(singletonList(1)); @@ -758,8 +692,7 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); builder.clearRepeatedString(); assertEquals(emptyList(), builder.getRepeatedStringList()); - assertEquals( - singletonList("hi"), messageAfterBuild.getRepeatedStringList()); + assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringList()); message = builder.build(); builder.addAllRepeatedStringPiece(singletonList("hi")); @@ -769,8 +702,7 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); builder.clearRepeatedStringPiece(); assertEquals(emptyList(), builder.getRepeatedStringPieceList()); - assertEquals( - singletonList("hi"), messageAfterBuild.getRepeatedStringPieceList()); + assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringPieceList()); message = builder.build(); builder.addAllRepeatedUint32(singletonList(1)); @@ -805,16 +737,13 @@ public class LiteTest extends TestCase { message = builder.build(); builder.addRepeatedBytes(ByteString.copyFromUtf8("hi")); assertEquals(emptyList(), message.getRepeatedBytesList()); - assertEquals( - singletonList(ByteString.copyFromUtf8("hi")), - builder.getRepeatedBytesList()); + assertEquals(singletonList(ByteString.copyFromUtf8("hi")), builder.getRepeatedBytesList()); assertEquals(emptyList(), message.getRepeatedBytesList()); messageAfterBuild = builder.build(); builder.clearRepeatedBytes(); assertEquals(emptyList(), builder.getRepeatedBytesList()); assertEquals( - singletonList(ByteString.copyFromUtf8("hi")), - messageAfterBuild.getRepeatedBytesList()); + singletonList(ByteString.copyFromUtf8("hi")), messageAfterBuild.getRepeatedBytesList()); message = builder.build(); builder.addRepeatedCord("hi"); @@ -870,8 +799,7 @@ public class LiteTest extends TestCase { builder.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR); assertEquals(emptyList(), message.getRepeatedForeignEnumList()); assertEquals( - singletonList(ForeignEnumLite.FOREIGN_LITE_BAR), - builder.getRepeatedForeignEnumList()); + singletonList(ForeignEnumLite.FOREIGN_LITE_BAR), builder.getRepeatedForeignEnumList()); assertEquals(emptyList(), message.getRepeatedForeignEnumList()); messageAfterBuild = builder.build(); builder.clearRepeatedForeignEnum(); @@ -883,22 +811,17 @@ public class LiteTest extends TestCase { message = builder.build(); builder.addRepeatedForeignMessage(foreignMessage); assertEquals(emptyList(), message.getRepeatedForeignMessageList()); - assertEquals( - singletonList(foreignMessage), builder.getRepeatedForeignMessageList()); + assertEquals(singletonList(foreignMessage), builder.getRepeatedForeignMessageList()); assertEquals(emptyList(), message.getRepeatedForeignMessageList()); messageAfterBuild = builder.build(); builder.removeRepeatedForeignMessage(0); assertEquals(emptyList(), builder.getRepeatedForeignMessageList()); - assertEquals( - singletonList(foreignMessage), - messageAfterBuild.getRepeatedForeignMessageList()); + assertEquals(singletonList(foreignMessage), messageAfterBuild.getRepeatedForeignMessageList()); message = builder.build(); builder.addRepeatedGroup(RepeatedGroup.getDefaultInstance()); assertEquals(emptyList(), message.getRepeatedGroupList()); - assertEquals( - singletonList(RepeatedGroup.getDefaultInstance()), - builder.getRepeatedGroupList()); + assertEquals(singletonList(RepeatedGroup.getDefaultInstance()), builder.getRepeatedGroupList()); assertEquals(emptyList(), message.getRepeatedGroupList()); messageAfterBuild = builder.build(); builder.removeRepeatedGroup(0); @@ -930,15 +853,12 @@ public class LiteTest extends TestCase { message = builder.build(); builder.addRepeatedLazyMessage(nestedMessage); assertEquals(emptyList(), message.getRepeatedLazyMessageList()); - assertEquals( - singletonList(nestedMessage), builder.getRepeatedLazyMessageList()); + assertEquals(singletonList(nestedMessage), builder.getRepeatedLazyMessageList()); assertEquals(emptyList(), message.getRepeatedLazyMessageList()); messageAfterBuild = builder.build(); builder.removeRepeatedLazyMessage(0); assertEquals(emptyList(), builder.getRepeatedLazyMessageList()); - assertEquals( - singletonList(nestedMessage), - messageAfterBuild.getRepeatedLazyMessageList()); + assertEquals(singletonList(nestedMessage), messageAfterBuild.getRepeatedLazyMessageList()); message = builder.build(); builder.addRepeatedSfixed32(1); @@ -958,8 +878,7 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); builder.clearRepeatedSfixed64(); assertEquals(emptyList(), builder.getRepeatedSfixed64List()); - assertEquals( - singletonList(1L), messageAfterBuild.getRepeatedSfixed64List()); + assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSfixed64List()); message = builder.build(); builder.addRepeatedSint32(1); @@ -989,8 +908,7 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); builder.clearRepeatedString(); assertEquals(emptyList(), builder.getRepeatedStringList()); - assertEquals( - singletonList("hi"), messageAfterBuild.getRepeatedStringList()); + assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringList()); message = builder.build(); builder.addRepeatedStringPiece("hi"); @@ -1000,8 +918,7 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); builder.clearRepeatedStringPiece(); assertEquals(emptyList(), builder.getRepeatedStringPieceList()); - assertEquals( - singletonList("hi"), messageAfterBuild.getRepeatedStringPieceList()); + assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringPieceList()); message = builder.build(); builder.addRepeatedUint32(1); @@ -1022,7 +939,7 @@ public class LiteTest extends TestCase { builder.clearRepeatedUint64(); assertEquals(emptyList(), builder.getRepeatedUint64List()); assertEquals(singletonList(1L), messageAfterBuild.getRepeatedUint64List()); - + message = builder.build(); builder.addRepeatedBool(true); messageAfterBuild = builder.build(); @@ -1031,14 +948,13 @@ public class LiteTest extends TestCase { assertEquals(true, messageAfterBuild.getRepeatedBool(0)); assertEquals(false, builder.getRepeatedBool(0)); builder.clearRepeatedBool(); - + message = builder.build(); builder.addRepeatedBytes(ByteString.copyFromUtf8("hi")); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedBytesCount()); builder.setRepeatedBytes(0, ByteString.EMPTY); - assertEquals( - ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedBytes(0)); + assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedBytes(0)); assertEquals(ByteString.EMPTY, builder.getRepeatedBytes(0)); builder.clearRepeatedBytes(); @@ -1056,8 +972,7 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedCordCount()); builder.setRepeatedCord(0, ""); - assertEquals( - ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedCordBytes(0)); + assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedCordBytes(0)); assertEquals(ByteString.EMPTY, builder.getRepeatedCordBytes(0)); builder.clearRepeatedCord(); @@ -1066,8 +981,8 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedDoubleCount()); builder.setRepeatedDouble(0, 0D); - assertEquals(1D, messageAfterBuild.getRepeatedDouble(0)); - assertEquals(0D, builder.getRepeatedDouble(0)); + assertEquals(1D, messageAfterBuild.getRepeatedDouble(0), 0.0); + assertEquals(0D, builder.getRepeatedDouble(0), 0.0); builder.clearRepeatedDouble(); message = builder.build(); @@ -1093,8 +1008,8 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedFloatCount()); builder.setRepeatedFloat(0, 0F); - assertEquals(1F, messageAfterBuild.getRepeatedFloat(0)); - assertEquals(0F, builder.getRepeatedFloat(0)); + assertEquals(1F, messageAfterBuild.getRepeatedFloat(0), 0.0f); + assertEquals(0F, builder.getRepeatedFloat(0), 0.0f); builder.clearRepeatedFloat(); message = builder.build(); @@ -1102,36 +1017,26 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedForeignEnumCount()); builder.setRepeatedForeignEnum(0, ForeignEnumLite.FOREIGN_LITE_FOO); - assertEquals( - ForeignEnumLite.FOREIGN_LITE_BAR, - messageAfterBuild.getRepeatedForeignEnum(0)); - assertEquals( - ForeignEnumLite.FOREIGN_LITE_FOO, builder.getRepeatedForeignEnum(0)); + assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, messageAfterBuild.getRepeatedForeignEnum(0)); + assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, builder.getRepeatedForeignEnum(0)); builder.clearRepeatedForeignEnum(); message = builder.build(); builder.addRepeatedForeignMessage(foreignMessage); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedForeignMessageCount()); - builder.setRepeatedForeignMessage( - 0, ForeignMessageLite.getDefaultInstance()); - assertEquals( - foreignMessage, messageAfterBuild.getRepeatedForeignMessage(0)); - assertEquals( - ForeignMessageLite.getDefaultInstance(), - builder.getRepeatedForeignMessage(0)); + builder.setRepeatedForeignMessage(0, ForeignMessageLite.getDefaultInstance()); + assertEquals(foreignMessage, messageAfterBuild.getRepeatedForeignMessage(0)); + assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getRepeatedForeignMessage(0)); builder.clearRepeatedForeignMessage(); - + message = builder.build(); builder.addRepeatedForeignMessage(foreignMessageBuilder); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedForeignMessageCount()); - builder.setRepeatedForeignMessage( - 0, ForeignMessageLite.getDefaultInstance()); + builder.setRepeatedForeignMessage(0, ForeignMessageLite.getDefaultInstance()); assertEquals(foreignMessageBuilder.build(), messageAfterBuild.getRepeatedForeignMessage(0)); - assertEquals( - ForeignMessageLite.getDefaultInstance(), - builder.getRepeatedForeignMessage(0)); + assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getRepeatedForeignMessage(0)); builder.clearRepeatedForeignMessage(); message = builder.build(); @@ -1139,54 +1044,46 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedForeignMessageCount()); builder.setRepeatedForeignMessage(0, foreignMessageBuilder); - assertEquals( - foreignMessage, messageAfterBuild.getRepeatedForeignMessage(0)); + assertEquals(foreignMessage, messageAfterBuild.getRepeatedForeignMessage(0)); assertEquals(foreignMessageBuilder.build(), builder.getRepeatedForeignMessage(0)); builder.clearRepeatedForeignMessage(); message = builder.build(); - RepeatedGroup repeatedGroup = RepeatedGroup.newBuilder() - .setA(1) - .build(); + RepeatedGroup repeatedGroup = RepeatedGroup.newBuilder().setA(1).build(); builder.addRepeatedGroup(repeatedGroup); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedGroupCount()); builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance()); assertEquals(repeatedGroup, messageAfterBuild.getRepeatedGroup(0)); - assertEquals( - RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0)); + assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0)); builder.clearRepeatedGroup(); - + message = builder.build(); builder.addRepeatedGroup(0, repeatedGroup); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedGroupCount()); builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance()); assertEquals(repeatedGroup, messageAfterBuild.getRepeatedGroup(0)); - assertEquals( - RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0)); + assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0)); builder.clearRepeatedGroup(); - + message = builder.build(); - RepeatedGroup.Builder repeatedGroupBuilder = RepeatedGroup.newBuilder() - .setA(3); + RepeatedGroup.Builder repeatedGroupBuilder = RepeatedGroup.newBuilder().setA(3); builder.addRepeatedGroup(repeatedGroupBuilder); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedGroupCount()); builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance()); assertEquals(repeatedGroupBuilder.build(), messageAfterBuild.getRepeatedGroup(0)); - assertEquals( - RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0)); + assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0)); builder.clearRepeatedGroup(); - + message = builder.build(); builder.addRepeatedGroup(0, repeatedGroupBuilder); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedGroupCount()); builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance()); assertEquals(repeatedGroupBuilder.build(), messageAfterBuild.getRepeatedGroup(0)); - assertEquals( - RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0)); + assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0)); builder.clearRepeatedGroup(); message = builder.build(); @@ -1206,45 +1103,41 @@ public class LiteTest extends TestCase { assertEquals(1L, messageAfterBuild.getRepeatedInt64(0)); assertEquals(0L, builder.getRepeatedInt64(0)); builder.clearRepeatedInt64(); - + message = builder.build(); builder.addRepeatedLazyMessage(nestedMessage); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedLazyMessageCount()); builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance()); assertEquals(nestedMessage, messageAfterBuild.getRepeatedLazyMessage(0)); - assertEquals( - NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0)); + assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0)); builder.clearRepeatedLazyMessage(); - + message = builder.build(); builder.addRepeatedLazyMessage(0, nestedMessage); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedLazyMessageCount()); builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance()); assertEquals(nestedMessage, messageAfterBuild.getRepeatedLazyMessage(0)); - assertEquals( - NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0)); + assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0)); builder.clearRepeatedLazyMessage(); - + message = builder.build(); builder.addRepeatedLazyMessage(nestedMessageBuilder); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedLazyMessageCount()); builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance()); assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getRepeatedLazyMessage(0)); - assertEquals( - NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0)); + assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0)); builder.clearRepeatedLazyMessage(); - + message = builder.build(); builder.addRepeatedLazyMessage(0, nestedMessageBuilder); messageAfterBuild = builder.build(); assertEquals(0, message.getRepeatedLazyMessageCount()); builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance()); assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getRepeatedLazyMessage(0)); - assertEquals( - NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0)); + assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0)); builder.clearRepeatedLazyMessage(); message = builder.build(); @@ -1297,9 +1190,7 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); assertEquals(0L, message.getRepeatedStringCount()); builder.setRepeatedString(0, ""); - assertEquals( - ByteString.copyFromUtf8("hi"), - messageAfterBuild.getRepeatedStringBytes(0)); + assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedStringBytes(0)); assertEquals(ByteString.EMPTY, builder.getRepeatedStringBytes(0)); builder.clearRepeatedString(); @@ -1317,9 +1208,7 @@ public class LiteTest extends TestCase { messageAfterBuild = builder.build(); assertEquals(0L, message.getRepeatedStringPieceCount()); builder.setRepeatedStringPiece(0, ""); - assertEquals( - ByteString.copyFromUtf8("hi"), - messageAfterBuild.getRepeatedStringPieceBytes(0)); + assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedStringPieceBytes(0)); assertEquals(ByteString.EMPTY, builder.getRepeatedStringPieceBytes(0)); builder.clearRepeatedStringPiece(); @@ -1343,18 +1232,14 @@ public class LiteTest extends TestCase { message = builder.build(); assertEquals(0, message.getSerializedSize()); - builder.mergeFrom(TestAllTypesLite.newBuilder() - .setOptionalBool(true) - .build()); + builder.mergeFrom(TestAllTypesLite.newBuilder().setOptionalBool(true).build()); assertEquals(0, message.getSerializedSize()); assertEquals(true, builder.build().getOptionalBool()); builder.clearOptionalBool(); message = builder.build(); assertEquals(0, message.getSerializedSize()); - builder.mergeFrom(TestAllTypesLite.newBuilder() - .setOptionalBool(true) - .build()); + builder.mergeFrom(TestAllTypesLite.newBuilder().setOptionalBool(true).build()); assertEquals(0, message.getSerializedSize()); assertEquals(true, builder.build().getOptionalBool()); builder.clear(); @@ -1364,93 +1249,68 @@ public class LiteTest extends TestCase { assertEquals(0, message.getSerializedSize()); builder.mergeOptionalForeignMessage(foreignMessage); assertEquals(0, message.getSerializedSize()); - assertEquals( - foreignMessage.getC(), - builder.build().getOptionalForeignMessage().getC()); + assertEquals(foreignMessage.getC(), builder.build().getOptionalForeignMessage().getC()); builder.clearOptionalForeignMessage(); message = builder.build(); assertEquals(0, message.getSerializedSize()); builder.mergeOptionalLazyMessage(nestedMessage); assertEquals(0, message.getSerializedSize()); - assertEquals( - nestedMessage.getBb(), - builder.build().getOptionalLazyMessage().getBb()); + assertEquals(nestedMessage.getBb(), builder.build().getOptionalLazyMessage().getBb()); builder.clearOptionalLazyMessage(); - + message = builder.build(); builder.setOneofString("hi"); - assertEquals( - OneofFieldCase.ONEOFFIELD_NOT_SET, message.getOneofFieldCase()); + assertEquals(OneofFieldCase.ONEOFFIELD_NOT_SET, message.getOneofFieldCase()); assertEquals(OneofFieldCase.ONEOF_STRING, builder.getOneofFieldCase()); assertEquals("hi", builder.getOneofString()); messageAfterBuild = builder.build(); - assertEquals( - OneofFieldCase.ONEOF_STRING, messageAfterBuild.getOneofFieldCase()); + assertEquals(OneofFieldCase.ONEOF_STRING, messageAfterBuild.getOneofFieldCase()); assertEquals("hi", messageAfterBuild.getOneofString()); builder.setOneofUint32(1); - assertEquals( - OneofFieldCase.ONEOF_STRING, messageAfterBuild.getOneofFieldCase()); + assertEquals(OneofFieldCase.ONEOF_STRING, messageAfterBuild.getOneofFieldCase()); assertEquals("hi", messageAfterBuild.getOneofString()); assertEquals(OneofFieldCase.ONEOF_UINT32, builder.getOneofFieldCase()); assertEquals(1, builder.getOneofUint32()); TestAllTypesLiteOrBuilder messageOrBuilder = builder; assertEquals(OneofFieldCase.ONEOF_UINT32, messageOrBuilder.getOneofFieldCase()); - - TestAllExtensionsLite.Builder extendableMessageBuilder = - TestAllExtensionsLite.newBuilder(); + + TestAllExtensionsLite.Builder extendableMessageBuilder = TestAllExtensionsLite.newBuilder(); TestAllExtensionsLite extendableMessage = extendableMessageBuilder.build(); - extendableMessageBuilder.setExtension( - UnittestLite.optionalInt32ExtensionLite, 1); - assertFalse(extendableMessage.hasExtension( - UnittestLite.optionalInt32ExtensionLite)); + extendableMessageBuilder.setExtension(UnittestLite.optionalInt32ExtensionLite, 1); + assertFalse(extendableMessage.hasExtension(UnittestLite.optionalInt32ExtensionLite)); extendableMessage = extendableMessageBuilder.build(); assertEquals( - 1, (int) extendableMessageBuilder.getExtension( - UnittestLite.optionalInt32ExtensionLite)); + 1, (int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite)); + assertEquals(1, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite)); + extendableMessageBuilder.setExtension(UnittestLite.optionalInt32ExtensionLite, 3); assertEquals( - 1, (int) extendableMessage.getExtension( - UnittestLite.optionalInt32ExtensionLite)); - extendableMessageBuilder.setExtension( - UnittestLite.optionalInt32ExtensionLite, 3); - assertEquals( - 3, (int) extendableMessageBuilder.getExtension( - UnittestLite.optionalInt32ExtensionLite)); - assertEquals( - 1, (int) extendableMessage.getExtension( - UnittestLite.optionalInt32ExtensionLite)); + 3, (int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite)); + assertEquals(1, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite)); extendableMessage = extendableMessageBuilder.build(); assertEquals( - 3, (int) extendableMessageBuilder.getExtension( - UnittestLite.optionalInt32ExtensionLite)); - assertEquals( - 3, (int) extendableMessage.getExtension( - UnittestLite.optionalInt32ExtensionLite)); - + 3, (int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite)); + assertEquals(3, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite)); + // No extension registry, so it should be in unknown fields. - extendableMessage = - TestAllExtensionsLite.parseFrom(extendableMessage.toByteArray()); - assertFalse(extendableMessage.hasExtension( - UnittestLite.optionalInt32ExtensionLite)); - + extendableMessage = TestAllExtensionsLite.parseFrom(extendableMessage.toByteArray()); + assertFalse(extendableMessage.hasExtension(UnittestLite.optionalInt32ExtensionLite)); + extendableMessageBuilder = extendableMessage.toBuilder(); - extendableMessageBuilder.mergeFrom(TestAllExtensionsLite.newBuilder() - .setExtension(UnittestLite.optionalFixed32ExtensionLite, 11) - .build()); - + extendableMessageBuilder.mergeFrom( + TestAllExtensionsLite.newBuilder() + .setExtension(UnittestLite.optionalFixed32ExtensionLite, 11) + .build()); + extendableMessage = extendableMessageBuilder.build(); ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance(); UnittestLite.registerAllExtensions(registry); - extendableMessage = TestAllExtensionsLite.parseFrom( - extendableMessage.toByteArray(), registry); - + extendableMessage = TestAllExtensionsLite.parseFrom(extendableMessage.toByteArray(), registry); + // The unknown field was preserved. + assertEquals(3, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite)); assertEquals( - 3, (int) extendableMessage.getExtension( - UnittestLite.optionalInt32ExtensionLite)); - assertEquals( - 11, (int) extendableMessage.getExtension( - UnittestLite.optionalFixed32ExtensionLite)); + 11, (int) extendableMessage.getExtension(UnittestLite.optionalFixed32ExtensionLite)); } public void testBuilderMergeFromNull() throws Exception { @@ -1497,140 +1357,174 @@ public class LiteTest extends TestCase { } public void testToStringScalarFieldsSuffixedWithList() throws Exception { - assertToStringEquals("deceptively_named_list: 7", TestAllTypesLite.newBuilder() - .setDeceptivelyNamedList(7) - .build()); + assertToStringEquals( + "deceptively_named_list: 7", + TestAllTypesLite.newBuilder().setDeceptivelyNamedList(7).build()); } public void testToStringPrimitives() throws Exception { - TestAllTypesLite proto = TestAllTypesLite.newBuilder() - .setOptionalInt32(1) - .setOptionalInt64(9223372036854775807L) - .build(); + 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) - .build(); + proto = + TestAllTypesLite.newBuilder() + .setOptionalBool(true) + .setOptionalNestedEnum(TestAllTypesLite.NestedEnum.BAZ) + .build(); assertToStringEquals("optional_bool: true\noptional_nested_enum: BAZ", proto); - proto = TestAllTypesLite.newBuilder() - .setOptionalFloat(2.72f) - .setOptionalDouble(3.14) - .build(); + proto = TestAllTypesLite.newBuilder().setOptionalFloat(2.72f).setOptionalDouble(3.14).build(); assertToStringEquals("optional_double: 3.14\noptional_float: 2.72", proto); } public void testToStringStringFields() throws Exception { - TestAllTypesLite proto = TestAllTypesLite.newBuilder() - .setOptionalString("foo\"bar\nbaz\\") - .build(); + TestAllTypesLite proto = + TestAllTypesLite.newBuilder().setOptionalString("foo\"bar\nbaz\\").build(); assertToStringEquals("optional_string: \"foo\\\"bar\\nbaz\\\\\"", proto); - proto = TestAllTypesLite.newBuilder() - .setOptionalString("\u6587") - .build(); + proto = TestAllTypesLite.newBuilder().setOptionalString("\u6587").build(); assertToStringEquals("optional_string: \"\\346\\226\\207\"", proto); } public void testToStringNestedMessage() throws Exception { - TestAllTypesLite proto = TestAllTypesLite.newBuilder() - .setOptionalNestedMessage(TestAllTypesLite.NestedMessage.getDefaultInstance()) - .build(); + TestAllTypesLite proto = + TestAllTypesLite.newBuilder() + .setOptionalNestedMessage(TestAllTypesLite.NestedMessage.getDefaultInstance()) + .build(); assertToStringEquals("optional_nested_message {\n}", proto); - proto = TestAllTypesLite.newBuilder() - .setOptionalNestedMessage( - TestAllTypesLite.NestedMessage.newBuilder().setBb(7)) - .build(); + proto = + TestAllTypesLite.newBuilder() + .setOptionalNestedMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(7)) + .build(); assertToStringEquals("optional_nested_message {\n bb: 7\n}", proto); } public void testToStringRepeatedFields() throws Exception { - TestAllTypesLite proto = TestAllTypesLite.newBuilder() - .addRepeatedInt32(32) - .addRepeatedInt32(32) - .addRepeatedInt64(64) - .build(); + TestAllTypesLite proto = + TestAllTypesLite.newBuilder() + .addRepeatedInt32(32) + .addRepeatedInt32(32) + .addRepeatedInt64(64) + .build(); assertToStringEquals("repeated_int32: 32\nrepeated_int32: 32\nrepeated_int64: 64", proto); - proto = TestAllTypesLite.newBuilder() - .addRepeatedLazyMessage( - TestAllTypesLite.NestedMessage.newBuilder().setBb(7)) - .addRepeatedLazyMessage( - TestAllTypesLite.NestedMessage.newBuilder().setBb(8)) - .build(); + proto = + TestAllTypesLite.newBuilder() + .addRepeatedLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(7)) + .addRepeatedLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(8)) + .build(); assertToStringEquals( - "repeated_lazy_message {\n bb: 7\n}\nrepeated_lazy_message {\n bb: 8\n}", - proto); + "repeated_lazy_message {\n bb: 7\n}\nrepeated_lazy_message {\n bb: 8\n}", proto); } public void testToStringForeignFields() throws Exception { - TestAllTypesLite proto = TestAllTypesLite.newBuilder() - .setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR) - .setOptionalForeignMessage( - ForeignMessageLite.newBuilder() - .setC(3)) - .build(); + TestAllTypesLite proto = + TestAllTypesLite.newBuilder() + .setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR) + .setOptionalForeignMessage(ForeignMessageLite.newBuilder().setC(3)) + .build(); assertToStringEquals( - "optional_foreign_enum: FOREIGN_LITE_BAR\noptional_foreign_message {\n c: 3\n}", - proto); + "optional_foreign_enum: FOREIGN_LITE_BAR\noptional_foreign_message {\n c: 3\n}", proto); } public void testToStringExtensions() throws Exception { - TestAllExtensionsLite message = TestAllExtensionsLite.newBuilder() - .setExtension(UnittestLite.optionalInt32ExtensionLite, 123) - .addExtension(UnittestLite.repeatedStringExtensionLite, "spam") - .addExtension(UnittestLite.repeatedStringExtensionLite, "eggs") - .setExtension(UnittestLite.optionalNestedEnumExtensionLite, - TestAllTypesLite.NestedEnum.BAZ) - .setExtension(UnittestLite.optionalNestedMessageExtensionLite, - TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build()) - .build(); + TestAllExtensionsLite message = + TestAllExtensionsLite.newBuilder() + .setExtension(UnittestLite.optionalInt32ExtensionLite, 123) + .addExtension(UnittestLite.repeatedStringExtensionLite, "spam") + .addExtension(UnittestLite.repeatedStringExtensionLite, "eggs") + .setExtension( + UnittestLite.optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ) + .setExtension( + UnittestLite.optionalNestedMessageExtensionLite, + TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build()) + .build(); assertToStringEquals( - "[1]: 123\n[18] {\n bb: 7\n}\n[21]: 3\n[44]: \"spam\"\n[44]: \"eggs\"", - message); + "[1]: 123\n[18] {\n bb: 7\n}\n[21]: 3\n[44]: \"spam\"\n[44]: \"eggs\"", message); } public void testToStringUnknownFields() throws Exception { - TestAllExtensionsLite messageWithExtensions = TestAllExtensionsLite.newBuilder() - .setExtension(UnittestLite.optionalInt32ExtensionLite, 123) - .addExtension(UnittestLite.repeatedStringExtensionLite, "spam") - .addExtension(UnittestLite.repeatedStringExtensionLite, "eggs") - .setExtension(UnittestLite.optionalNestedEnumExtensionLite, - TestAllTypesLite.NestedEnum.BAZ) - .setExtension(UnittestLite.optionalNestedMessageExtensionLite, - TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build()) - .build(); - TestAllExtensionsLite messageWithUnknownFields = TestAllExtensionsLite.parseFrom( - messageWithExtensions.toByteArray()); + TestAllExtensionsLite messageWithExtensions = + TestAllExtensionsLite.newBuilder() + .setExtension(UnittestLite.optionalInt32ExtensionLite, 123) + .addExtension(UnittestLite.repeatedStringExtensionLite, "spam") + .addExtension(UnittestLite.repeatedStringExtensionLite, "eggs") + .setExtension( + UnittestLite.optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ) + .setExtension( + UnittestLite.optionalNestedMessageExtensionLite, + TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build()) + .build(); + TestAllExtensionsLite messageWithUnknownFields = + TestAllExtensionsLite.parseFrom(messageWithExtensions.toByteArray()); assertToStringEquals( - "1: 123\n18: \"\\b\\a\"\n21: 3\n44: \"spam\"\n44: \"eggs\"", - messageWithUnknownFields); + "1: 123\n18: \"\\b\\a\"\n21: 3\n44: \"spam\"\n44: \"eggs\"", messageWithUnknownFields); } - + public void testToStringLazyMessage() throws Exception { - TestAllTypesLite message = TestAllTypesLite.newBuilder() - .setOptionalLazyMessage(NestedMessage.newBuilder().setBb(1).build()) - .build(); + TestAllTypesLite message = + TestAllTypesLite.newBuilder() + .setOptionalLazyMessage(NestedMessage.newBuilder().setBb(1).build()) + .build(); assertToStringEquals("optional_lazy_message {\n bb: 1\n}", message); } - + public void testToStringGroup() throws Exception { - TestAllTypesLite message = TestAllTypesLite.newBuilder() - .setOptionalGroup(OptionalGroup.newBuilder().setA(1).build()) - .build(); + TestAllTypesLite message = + TestAllTypesLite.newBuilder() + .setOptionalGroup(OptionalGroup.newBuilder().setA(1).build()) + .build(); assertToStringEquals("optional_group {\n a: 1\n}", message); } - + public void testToStringOneof() throws Exception { - TestAllTypesLite message = TestAllTypesLite.newBuilder() - .setOneofString("hello") - .build(); + TestAllTypesLite message = TestAllTypesLite.newBuilder().setOneofString("hello").build(); assertToStringEquals("oneof_string: \"hello\"", message); } + public void testToStringMapFields() throws Exception { + TestMap message1 = + TestMap.newBuilder() + .putInt32ToStringField(1, "alpha") + .putInt32ToStringField(2, "beta") + .build(); + assertToStringEquals( + "int32_to_string_field {\n" + + " key: 1\n" + + " value: \"alpha\"\n" + + "}\n" + + "int32_to_string_field {\n" + + " key: 2\n" + + " value: \"beta\"\n" + + "}", + message1); + + TestMap message2 = + TestMap.newBuilder() + .putInt32ToMessageField(1, MessageValue.newBuilder().setValue(10).build()) + .putInt32ToMessageField(2, MessageValue.newBuilder().setValue(20).build()) + .build(); + assertToStringEquals( + "int32_to_message_field {\n" + + " key: 1\n" + + " value {\n" + + " value: 10\n" + + " }\n" + + "}\n" + + "int32_to_message_field {\n" + + " key: 2\n" + + " value {\n" + + " value: 20\n" + + " }\n" + + "}", + message2); + } + // Asserts that the toString() representation of the message matches the expected. This verifies // the first line starts with a comment; but, does not factor in said comment as part of the // comparison as it contains unstable addresses. @@ -1644,38 +1538,38 @@ public class LiteTest extends TestCase { } assertEquals(expected, toString); } - + public void testParseLazy() throws Exception { - ByteString bb = TestAllTypesLite.newBuilder() - .setOptionalLazyMessage(NestedMessage.newBuilder() - .setBb(11) - .build()) - .build().toByteString(); - ByteString cc = TestAllTypesLite.newBuilder() - .setOptionalLazyMessage(NestedMessage.newBuilder() - .setCc(22) - .build()) - .build().toByteString(); - + ByteString bb = + TestAllTypesLite.newBuilder() + .setOptionalLazyMessage(NestedMessage.newBuilder().setBb(11).build()) + .build() + .toByteString(); + ByteString cc = + TestAllTypesLite.newBuilder() + .setOptionalLazyMessage(NestedMessage.newBuilder().setCc(22).build()) + .build() + .toByteString(); + ByteString concat = bb.concat(cc); TestAllTypesLite message = TestAllTypesLite.parseFrom(concat); assertEquals(11, message.getOptionalLazyMessage().getBb()); assertEquals(22L, message.getOptionalLazyMessage().getCc()); } - + public void testParseLazy_oneOf() throws Exception { - ByteString bb = TestAllTypesLite.newBuilder() - .setOneofLazyNestedMessage(NestedMessage.newBuilder() - .setBb(11) - .build()) - .build().toByteString(); - ByteString cc = TestAllTypesLite.newBuilder() - .setOneofLazyNestedMessage(NestedMessage.newBuilder() - .setCc(22) - .build()) - .build().toByteString(); - + ByteString bb = + TestAllTypesLite.newBuilder() + .setOneofLazyNestedMessage(NestedMessage.newBuilder().setBb(11).build()) + .build() + .toByteString(); + ByteString cc = + TestAllTypesLite.newBuilder() + .setOneofLazyNestedMessage(NestedMessage.newBuilder().setCc(22).build()) + .build() + .toByteString(); + ByteString concat = bb.concat(cc); TestAllTypesLite message = TestAllTypesLite.parseFrom(concat); @@ -1684,27 +1578,26 @@ public class LiteTest extends TestCase { } public void testMergeFromStream_repeatedField() throws Exception { - TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder() - .addRepeatedString("hello"); + TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder().addRepeatedString("hello"); builder.mergeFrom(CodedInputStream.newInstance(builder.build().toByteArray())); assertEquals(2, builder.getRepeatedStringCount()); } public void testMergeFromStream_invalidBytes() throws Exception { - TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder() - .setDefaultBool(true); + TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder().setDefaultBool(true); try { builder.mergeFrom(CodedInputStream.newInstance("Invalid bytes".getBytes(Internal.UTF_8))); fail(); - } catch (InvalidProtocolBufferException expected) {} + } 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); @@ -1713,14 +1606,14 @@ public class LiteTest extends TestCase { } public void testMergeFromNoLazyFieldSharing() throws Exception { - TestAllTypesLite.Builder sourceBuilder = TestAllTypesLite.newBuilder().setOptionalLazyMessage( - TestAllTypesLite.NestedMessage.newBuilder().setBb(1)); + 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)); + sourceBuilder.setOptionalLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(2)); assertEquals(1, targetBuilder.getOptionalLazyMessage().getBb()); } @@ -1728,508 +1621,373 @@ public class LiteTest extends TestCase { 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)); - - TestAllTypesLite oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultBool(true) - .build(); + + TestAllTypesLite oneFieldSet = TestAllTypesLite.newBuilder().setDefaultBool(true).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultCord("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultCord("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultCordBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultCordBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultDouble(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultDouble(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultFixed32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFixed32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultFixed64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFixed64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultFloat(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFloat(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder() + .setDefaultForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR) + .build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultImportEnum(ImportEnumLite.IMPORT_LITE_BAR) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder().setDefaultImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultInt32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultInt32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultInt64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultInt64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultNestedEnum(NestedEnum.BAR) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultNestedEnum(NestedEnum.BAR).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultSfixed32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSfixed32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultSfixed64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSfixed64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultSint32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSint32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultSint64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSint64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultString("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultString("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultStringBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultStringBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultStringPiece("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultStringPiece("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultStringPieceBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder().setDefaultStringPieceBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultUint32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultUint32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setDefaultUint64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setDefaultUint64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedBool(true) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedBool(true).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedCord("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedCord("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedCordBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedCordBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedDouble(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedDouble(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedFixed32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFixed32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedFixed64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFixed64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedFloat(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFloat(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder() + .addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR) + .build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedImportEnum(ImportEnumLite.IMPORT_LITE_BAR) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder().addRepeatedImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedInt32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedInt32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedInt64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedInt64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedNestedEnum(NestedEnum.BAR) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedNestedEnum(NestedEnum.BAR).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedSfixed32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSfixed32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedSfixed64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSfixed64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedSint32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSint32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedSint64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSint64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedString("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedString("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedStringBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedStringBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedStringPiece("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedStringPiece("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedStringPieceBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder().addRepeatedStringPieceBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedUint32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedUint32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedUint64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedUint64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalBool(true) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalBool(true).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalCord("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalCord("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalCordBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalCordBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalDouble(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalDouble(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalFixed32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFixed32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalFixed64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFixed64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalFloat(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFloat(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder() + .setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR) + .build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAR) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder().setOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalInt32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalInt32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalInt64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalInt64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalNestedEnum(NestedEnum.BAR) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalNestedEnum(NestedEnum.BAR).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalSfixed32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSfixed32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalSfixed64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSfixed64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalSint32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSint32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalSint64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSint64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalString("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalString("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalStringBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalStringBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalStringPiece("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalStringPiece("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalStringPieceBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder().setOptionalStringPieceBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalUint32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalUint32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalUint64(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOptionalUint64(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOneofBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOneofBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOneofLazyNestedMessage(NestedMessage.getDefaultInstance()) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder() + .setOneofLazyNestedMessage(NestedMessage.getDefaultInstance()) + .build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOneofNestedMessage(NestedMessage.getDefaultInstance()) - .build(); + + oneFieldSet = + TestAllTypesLite.newBuilder() + .setOneofNestedMessage(NestedMessage.getDefaultInstance()) + .build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOneofString("") - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOneofString("").build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOneofStringBytes(ByteString.EMPTY) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOneofStringBytes(ByteString.EMPTY).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - - oneFieldSet = TestAllTypesLite.newBuilder() - .setOneofUint32(0) - .build(); + + oneFieldSet = TestAllTypesLite.newBuilder().setOneofUint32(0).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalForeignMessage(ForeignMessageLite.getDefaultInstance()) - .build(); + oneFieldSet = + TestAllTypesLite.newBuilder() + .setOptionalForeignMessage(ForeignMessageLite.getDefaultInstance()) + .build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalGroup(OptionalGroup.getDefaultInstance()) - .build(); + oneFieldSet = + TestAllTypesLite.newBuilder().setOptionalGroup(OptionalGroup.getDefaultInstance()).build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalPublicImportMessage(PublicImportMessageLite.getDefaultInstance()) - .build(); + oneFieldSet = + TestAllTypesLite.newBuilder() + .setOptionalPublicImportMessage(PublicImportMessageLite.getDefaultInstance()) + .build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - oneFieldSet = TestAllTypesLite.newBuilder() - .setOptionalLazyMessage(NestedMessage.getDefaultInstance()) - .build(); + oneFieldSet = + TestAllTypesLite.newBuilder() + .setOptionalLazyMessage(NestedMessage.getDefaultInstance()) + .build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); - + assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); - oneFieldSet = TestAllTypesLite.newBuilder() - .addRepeatedLazyMessage(NestedMessage.getDefaultInstance()) - .build(); + oneFieldSet = + TestAllTypesLite.newBuilder() + .addRepeatedLazyMessage(NestedMessage.getDefaultInstance()) + .build(); assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())); assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)); } public void testEquals() throws Exception { // Check that two identical objs are equal. - Foo foo1a = Foo.newBuilder() - .setValue(1) - .addBar(Bar.newBuilder().setName("foo1")) - .build(); - Foo foo1b = Foo.newBuilder() - .setValue(1) - .addBar(Bar.newBuilder().setName("foo1")) - .build(); - Foo foo2 = Foo.newBuilder() - .setValue(1) - .addBar(Bar.newBuilder().setName("foo2")) - .build(); + Foo foo1a = Foo.newBuilder().setValue(1).addBar(Bar.newBuilder().setName("foo1")).build(); + Foo foo1b = Foo.newBuilder().setValue(1).addBar(Bar.newBuilder().setName("foo1")).build(); + Foo foo2 = Foo.newBuilder().setValue(1).addBar(Bar.newBuilder().setName("foo2")).build(); // Check that equals is doing value rather than object equality. assertEquals(foo1a, foo1b); @@ -2246,17 +2004,10 @@ public class LiteTest extends TestCase { } public void testEqualsAndHashCodeForTrickySchemaTypes() { - Foo foo1 = Foo.newBuilder() - .build(); - Foo foo2 = Foo.newBuilder() - .setSint64(1) - .build(); - Foo foo3 = Foo.newBuilder() - .putMyMap("key", "value2") - .build(); - Foo foo4 = Foo.newBuilder() - .setMyGroup(Foo.MyGroup.newBuilder().setValue(4).build()) - .build(); + Foo foo1 = Foo.getDefaultInstance(); + Foo foo2 = Foo.newBuilder().setSint64(1).build(); + Foo foo3 = Foo.newBuilder().putMyMap("key", "value2").build(); + Foo foo4 = Foo.newBuilder().setMyGroup(Foo.MyGroup.newBuilder().setValue(4).build()).build(); assertEqualsAndHashCodeAreFalse(foo1, foo2); assertEqualsAndHashCodeAreFalse(foo1, foo3); @@ -2272,29 +2023,27 @@ public class LiteTest extends TestCase { TestOneofEquals message2 = builder.build(); assertFalse(message1.equals(message2)); } - + public void testEquals_sanity() throws Exception { TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build(); TestAllTypesLite two = TestAllTypesLite.parseFrom(one.toByteArray()); assertEquals(one, two); assertEquals(one.hashCode(), two.hashCode()); - + assertEquals( one.toBuilder().mergeFrom(two).build(), two.toBuilder().mergeFrom(two.toByteArray()).build()); } public void testEqualsAndHashCodeWithUnknownFields() throws InvalidProtocolBufferException { - Foo fooWithOnlyValue = Foo.newBuilder() - .setValue(1) - .build(); + Foo fooWithOnlyValue = Foo.newBuilder().setValue(1).build(); - Foo fooWithValueAndExtension = fooWithOnlyValue.toBuilder() - .setValue(1) - .setExtension(Bar.fooExt, Bar.newBuilder() - .setName("name") - .build()) - .build(); + Foo fooWithValueAndExtension = + fooWithOnlyValue + .toBuilder() + .setValue(1) + .setExtension(Bar.fooExt, Bar.newBuilder().setName("name").build()) + .build(); Foo fooWithValueAndUnknownFields = Foo.parseFrom(fooWithValueAndExtension.toByteArray()); @@ -2303,30 +2052,27 @@ public class LiteTest extends TestCase { } public void testEqualsAndHashCodeWithExtensions() throws InvalidProtocolBufferException { - Foo fooWithOnlyValue = Foo.newBuilder() - .setValue(1) - .build(); + Foo fooWithOnlyValue = Foo.newBuilder().setValue(1).build(); - Foo fooWithValueAndExtension = fooWithOnlyValue.toBuilder() - .setValue(1) - .setExtension(Bar.fooExt, Bar.newBuilder() - .setName("name") - .build()) - .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(); - + TestAllTypesLite mine = TestAllTypesLite.newBuilder().setOneofString("Hello").build(); + + TestAllTypesLite other = + TestAllTypesLite.newBuilder() + .setOneofNestedMessage(NestedMessage.getDefaultInstance()) + .build(); + assertFalse(mine.equals(other)); assertFalse(other.equals(mine)); } @@ -2376,16 +2122,13 @@ public class LiteTest extends TestCase { public void testParseFromByteBufferThrows() { try { - TestAllTypesLite.parseFrom(ByteBuffer.wrap(new byte[] { 0x5 })); + TestAllTypesLite.parseFrom(ByteBuffer.wrap(new byte[] {0x5})); fail(); } catch (InvalidProtocolBufferException expected) { } TestAllTypesLite message = - TestAllTypesLite.newBuilder() - .setOptionalInt32(123) - .addRepeatedString("hello") - .build(); + TestAllTypesLite.newBuilder().setOptionalInt32(123).addRepeatedString("hello").build(); ByteBuffer buffer = ByteBuffer.wrap(message.toByteArray(), 0, message.getSerializedSize() - 1); try { @@ -2393,9 +2136,7 @@ public class LiteTest extends TestCase { fail(); } catch (InvalidProtocolBufferException expected) { assertEquals( - TestAllTypesLite.newBuilder() - .setOptionalInt32(123) - .build(), + TestAllTypesLite.newBuilder().setOptionalInt32(123).build(), expected.getUnfinishedMessage()); } } @@ -2425,7 +2166,7 @@ public class LiteTest extends TestCase { ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance(); UnittestLite.registerAllExtensions(registry); try { - TestAllExtensionsLite.parseFrom(ByteBuffer.wrap(new byte[] { 0x5 }), registry); + TestAllExtensionsLite.parseFrom(ByteBuffer.wrap(new byte[] {0x5}), registry); fail(); } catch (InvalidProtocolBufferException expected) { } @@ -2466,26 +2207,24 @@ public class LiteTest extends TestCase { } public void testAddAllIteratesOnce() { - TestAllTypesLite message = - TestAllTypesLite.newBuilder() - .addAllRepeatedBool(new OneTimeIterableList(false)) - .addAllRepeatedInt32(new OneTimeIterableList(0)) - .addAllRepeatedInt64(new OneTimeIterableList(0L)) - .addAllRepeatedFloat(new OneTimeIterableList(0f)) - .addAllRepeatedDouble(new OneTimeIterableList(0d)) - .addAllRepeatedBytes(new OneTimeIterableList(ByteString.EMPTY)) - .addAllRepeatedString(new OneTimeIterableList("")) - .addAllRepeatedNestedMessage( - new OneTimeIterableList(NestedMessage.getDefaultInstance())) - .addAllRepeatedBool(new OneTimeIterable(false)) - .addAllRepeatedInt32(new OneTimeIterable(0)) - .addAllRepeatedInt64(new OneTimeIterable(0L)) - .addAllRepeatedFloat(new OneTimeIterable(0f)) - .addAllRepeatedDouble(new OneTimeIterable(0d)) - .addAllRepeatedBytes(new OneTimeIterable(ByteString.EMPTY)) - .addAllRepeatedString(new OneTimeIterable("")) - .addAllRepeatedNestedMessage(new OneTimeIterable(NestedMessage.getDefaultInstance())) - .build(); + TestAllTypesLite.newBuilder() + .addAllRepeatedBool(new OneTimeIterableList(false)) + .addAllRepeatedInt32(new OneTimeIterableList(0)) + .addAllRepeatedInt64(new OneTimeIterableList(0L)) + .addAllRepeatedFloat(new OneTimeIterableList(0f)) + .addAllRepeatedDouble(new OneTimeIterableList(0d)) + .addAllRepeatedBytes(new OneTimeIterableList(ByteString.EMPTY)) + .addAllRepeatedString(new OneTimeIterableList("")) + .addAllRepeatedNestedMessage(new OneTimeIterableList(NestedMessage.getDefaultInstance())) + .addAllRepeatedBool(new OneTimeIterable(false)) + .addAllRepeatedInt32(new OneTimeIterable(0)) + .addAllRepeatedInt64(new OneTimeIterable(0L)) + .addAllRepeatedFloat(new OneTimeIterable(0f)) + .addAllRepeatedDouble(new OneTimeIterable(0d)) + .addAllRepeatedBytes(new OneTimeIterable(ByteString.EMPTY)) + .addAllRepeatedString(new OneTimeIterable("")) + .addAllRepeatedNestedMessage(new OneTimeIterable(NestedMessage.getDefaultInstance())) + .build(); } public void testAddAllIteratesOnce_throwsOnNull() { diff --git a/java/core/src/test/java/com/google/protobuf/LongArrayListTest.java b/java/core/src/test/java/com/google/protobuf/LongArrayListTest.java index 6bbdfcaa..e50c7d1e 100644 --- a/java/core/src/test/java/com/google/protobuf/LongArrayListTest.java +++ b/java/core/src/test/java/com/google/protobuf/LongArrayListTest.java @@ -32,6 +32,7 @@ package com.google.protobuf; import static java.util.Arrays.asList; +import com.google.protobuf.Internal.LongList; import java.util.Collections; import java.util.ConcurrentModificationException; import java.util.Iterator; @@ -297,6 +298,20 @@ public class LongArrayListTest extends TestCase { } } + public void testRemoveEndOfCapacity() { + LongList toRemove = LongArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addLong(3); + toRemove.remove(0); + assertEquals(0, toRemove.size()); + } + + public void testSublistRemoveEndOfCapacity() { + LongList toRemove = LongArrayList.emptyList().mutableCopyWithCapacity(1); + toRemove.addLong(3); + toRemove.subList(0, 1).clear(); + assertEquals(0, toRemove.size()); + } + private void assertImmutable(LongArrayList list) { if (list.contains(1L)) { throw new RuntimeException("Cannot test the immutability of lists that contain 1."); diff --git a/java/core/src/test/java/com/google/protobuf/MapForProto2Test.java b/java/core/src/test/java/com/google/protobuf/MapForProto2Test.java index 37827f76..bcfd927c 100644 --- a/java/core/src/test/java/com/google/protobuf/MapForProto2Test.java +++ b/java/core/src/test/java/com/google/protobuf/MapForProto2Test.java @@ -788,6 +788,24 @@ public class MapForProto2Test extends TestCase { assertEquals(message.hashCode(), dynamicMessage.hashCode()); } + // Check that DynamicMessage handles map field serialization the same way as generated code + // regarding unset key and value field in a map entry. + public void testDynamicMessageUnsetKeyAndValue() throws Exception { + FieldDescriptor field = f("int32_to_int32_field"); + + Message dynamicDefaultInstance = + DynamicMessage.getDefaultInstance(TestMap.getDescriptor()); + Message.Builder builder = dynamicDefaultInstance.newBuilderForType(); + // Add an entry without key and value. + builder.addRepeatedField(field, builder.newBuilderForField(field).build()); + Message message = builder.build(); + ByteString bytes = message.toByteString(); + // Parse it back to the same generated type. + Message generatedMessage = TestMap.parseFrom(bytes); + // Assert the serialized bytes are equivalent. + assertEquals(generatedMessage.toByteString(), bytes); + } + public void testReflectionEqualsAndHashCode() throws Exception { // Test that generated equals() and hashCode() will disregard the order // of map entries when comparing/hashing map fields. diff --git a/java/core/src/test/java/com/google/protobuf/MapTest.java b/java/core/src/test/java/com/google/protobuf/MapTest.java index 64ae4435..58efce92 100644 --- a/java/core/src/test/java/com/google/protobuf/MapTest.java +++ b/java/core/src/test/java/com/google/protobuf/MapTest.java @@ -893,6 +893,24 @@ public class MapTest extends TestCase { assertEquals(message.hashCode(), dynamicMessage.hashCode()); } + // Check that DynamicMessage handles map field serialization the same way as generated code + // regarding unset key and value field in a map entry. + public void testDynamicMessageUnsetKeyAndValue() throws Exception { + FieldDescriptor field = f("int32_to_int32_field"); + + Message dynamicDefaultInstance = + DynamicMessage.getDefaultInstance(TestMap.getDescriptor()); + Message.Builder builder = dynamicDefaultInstance.newBuilderForType(); + // Add an entry without key and value. + builder.addRepeatedField(field, builder.newBuilderForField(field).build()); + Message message = builder.build(); + ByteString bytes = message.toByteString(); + // Parse it back to the same generated type. + Message generatedMessage = TestMap.parseFrom(bytes); + // Assert the serialized bytes are equivalent. + assertEquals(generatedMessage.toByteString(), bytes); + } + public void testReflectionEqualsAndHashCode() throws Exception { // Test that generated equals() and hashCode() will disregard the order // of map entries when comparing/hashing map fields. diff --git a/java/core/src/test/java/com/google/protobuf/TestUtil.java b/java/core/src/test/java/com/google/protobuf/TestUtil.java index e96adf07..b4bc3a3d 100644 --- a/java/core/src/test/java/com/google/protobuf/TestUtil.java +++ b/java/core/src/test/java/com/google/protobuf/TestUtil.java @@ -231,6 +231,7 @@ import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder; import protobuf_unittest.UnittestProto.TestOneof2; import protobuf_unittest.UnittestProto.TestPackedExtensions; import protobuf_unittest.UnittestProto.TestPackedTypes; +import protobuf_unittest.UnittestProto.TestRequired; import protobuf_unittest.UnittestProto.TestUnpackedTypes; import java.io.File; import java.io.IOException; @@ -252,6 +253,11 @@ import junit.framework.Assert; public final class TestUtil { private TestUtil() {} + public static final TestRequired TEST_REQUIRED_UNINITIALIZED = + TestRequired.newBuilder().setA(1).buildPartial(); + public static final TestRequired TEST_REQUIRED_INITIALIZED = + TestRequired.newBuilder().setA(1).setB(2).setC(3).build(); + /** Helper to convert a String to ByteString. */ static ByteString toBytes(String str) { return ByteString.copyFrom(str.getBytes(Internal.UTF_8)); diff --git a/java/core/src/test/java/com/google/protobuf/TextFormatTest.java b/java/core/src/test/java/com/google/protobuf/TextFormatTest.java index 28c4fdea..720061d2 100644 --- a/java/core/src/test/java/com/google/protobuf/TextFormatTest.java +++ b/java/core/src/test/java/com/google/protobuf/TextFormatTest.java @@ -30,6 +30,9 @@ package com.google.protobuf; +import static com.google.protobuf.TestUtil.TEST_REQUIRED_INITIALIZED; +import static com.google.protobuf.TestUtil.TEST_REQUIRED_UNINITIALIZED; + import com.google.protobuf.Descriptors.Descriptor; import com.google.protobuf.Descriptors.FieldDescriptor; import com.google.protobuf.TextFormat.Parser.SingularOverwritePolicy; @@ -42,6 +45,7 @@ import protobuf_unittest.UnittestProto.TestAllTypes; import protobuf_unittest.UnittestProto.TestAllTypes.NestedMessage; import protobuf_unittest.UnittestProto.TestEmptyMessage; import protobuf_unittest.UnittestProto.TestOneof2; +import protobuf_unittest.UnittestProto.TestRequired; import proto2_wireformat_unittest.UnittestMsetWireFormat.TestMessageSet; import java.io.StringReader; import java.util.List; @@ -57,12 +61,11 @@ import junit.framework.TestCase; public class TextFormatTest extends TestCase { // A basic string with different escapable characters for testing. - private final static String kEscapeTestString = - "\"A string with ' characters \n and \r newlines and \t tabs and \001 " - + "slashes \\"; + private static final String ESCAPE_TEST_STRING = + "\"A string with ' characters \n and \r newlines and \t tabs and \001 " + "slashes \\"; // A representation of the above string with all the characters escaped. - private final static String kEscapeTestStringEscaped = + private static final String ESCAPE_TEST_STRING_ESCAPED = "\\\"A string with \\' characters \\n and \\r newlines " + "and \\t tabs and \\001 slashes \\\\"; @@ -326,19 +329,58 @@ public class TextFormatTest extends TestCase { // ================================================================= - public void testParse() throws Exception { + public void testMerge() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); TextFormat.merge(allFieldsSetText, builder); TestUtil.assertAllFieldsSet(builder.build()); } - public void testParseReader() throws Exception { + public void testParse() throws Exception { + TestUtil.assertAllFieldsSet( + TextFormat.parse(allFieldsSetText, TestAllTypes.class)); + } + + public void testMergeInitialized() throws Exception { + TestRequired.Builder builder = TestRequired.newBuilder(); + TextFormat.merge(TEST_REQUIRED_INITIALIZED.toString(), builder); + assertEquals(TEST_REQUIRED_INITIALIZED.toString(), + builder.buildPartial().toString()); + assertTrue(builder.isInitialized()); + } + + public void testParseInitialized() throws Exception { + TestRequired parsed = + TextFormat.parse(TEST_REQUIRED_INITIALIZED.toString(), + TestRequired.class); + assertEquals(TEST_REQUIRED_INITIALIZED.toString(), parsed.toString()); + assertTrue(parsed.isInitialized()); + } + + public void testMergeUninitialized() throws Exception { + TestRequired.Builder builder = TestRequired.newBuilder(); + TextFormat.merge(TEST_REQUIRED_UNINITIALIZED.toString(), builder); + assertEquals(TEST_REQUIRED_UNINITIALIZED.toString(), + builder.buildPartial().toString()); + assertFalse(builder.isInitialized()); + } + + public void testParseUninitialized() throws Exception { + try { + TextFormat.parse(TEST_REQUIRED_UNINITIALIZED.toString(), + TestRequired.class); + fail("Expected UninitializedMessageException."); + } catch (UninitializedMessageException e) { + assertEquals("Message missing required fields: b, c", e.getMessage()); + } + } + + public void testMergeReader() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); TextFormat.merge(new StringReader(allFieldsSetText), builder); TestUtil.assertAllFieldsSet(builder.build()); } - public void testParseExtensions() throws Exception { + public void testMergeExtensions() throws Exception { TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); TextFormat.merge(allExtensionsSetText, TestUtil.getExtensionRegistry(), @@ -346,7 +388,14 @@ public class TextFormatTest extends TestCase { TestUtil.assertAllExtensionsSet(builder.build()); } - public void testParseCompatibility() throws Exception { + public void testParseExtensions() throws Exception { + TestUtil.assertAllExtensionsSet( + TextFormat.parse(allExtensionsSetText, + TestUtil.getExtensionRegistry(), + TestAllExtensions.class)); + } + + public void testMergeAndParseCompatibility() throws Exception { String original = "repeated_float: inf\n" + "repeated_float: -inf\n" + "repeated_float: nan\n" + @@ -371,21 +420,29 @@ public class TextFormatTest extends TestCase { "repeated_double: Infinity\n" + "repeated_double: -Infinity\n" + "repeated_double: NaN\n"; + + // Test merge(). TestAllTypes.Builder builder = TestAllTypes.newBuilder(); TextFormat.merge(original, builder); assertEquals(canonical, builder.build().toString()); + + // Test parse(). + assertEquals(canonical, + TextFormat.parse(original, TestAllTypes.class).toString()); } - public void testParseExotic() throws Exception { + public void testMergeAndParseExotic() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); TextFormat.merge(exoticText, builder); // Too lazy to check things individually. Don't try to debug this // if testPrintExotic() is failing. assertEquals(canonicalExoticText, builder.build().toString()); + assertEquals(canonicalExoticText, + TextFormat.parse(exoticText, TestAllTypes.class).toString()); } - public void testParseMessageSet() throws Exception { + public void testMergeMessageSet() throws Exception { ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance(); extensionRegistry.add(TestMessageSetExtension1.messageSetExtension); extensionRegistry.add(TestMessageSetExtension2.messageSetExtension); @@ -411,7 +468,7 @@ public class TextFormatTest extends TestCase { TestMessageSetExtension1.messageSetExtension).getI()); } - public void testParseMessageSetWithOverwriteForbidden() throws Exception { + public void testMergeMessageSetWithOverwriteForbidden() throws Exception { ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance(); extensionRegistry.add(TestMessageSetExtension1.messageSetExtension); extensionRegistry.add(TestMessageSetExtension2.messageSetExtension); @@ -438,20 +495,20 @@ public class TextFormatTest extends TestCase { } } - public void testParseNumericEnum() throws Exception { + public void testMergeNumericEnum() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); TextFormat.merge("optional_nested_enum: 2", builder); assertEquals(TestAllTypes.NestedEnum.BAR, builder.getOptionalNestedEnum()); } - public void testParseAngleBrackets() throws Exception { + public void testMergeAngleBrackets() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); TextFormat.merge("OptionalGroup: < a: 1 >", builder); assertTrue(builder.hasOptionalGroup()); assertEquals(1, builder.getOptionalGroup().getA()); } - public void testParseComment() throws Exception { + public void testMergeComment() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); TextFormat.merge( "# this is a comment\n" + @@ -463,6 +520,7 @@ public class TextFormatTest extends TestCase { } private void assertParseError(String error, String text) { + // Test merge(). TestAllTypes.Builder builder = TestAllTypes.newBuilder(); try { TextFormat.merge(text, TestUtil.getExtensionRegistry(), builder); @@ -470,6 +528,15 @@ public class TextFormatTest extends TestCase { } catch (TextFormat.ParseException e) { assertEquals(error, e.getMessage()); } + + // Test parse(). + try { + TextFormat.parse( + text, TestUtil.getExtensionRegistry(), TestAllTypes.class); + fail("Expected parse exception."); + } catch (TextFormat.ParseException e) { + assertEquals(error, e.getMessage()); + } } @@ -508,10 +575,10 @@ public class TextFormatTest extends TestCase { "integer: 82301481290849012385230157", "optional_int32: 82301481290849012385230157"); assertParseError( - "1:16: Expected \"true\" or \"false\".", + "1:16: Expected \"true\" or \"false\". Found \"maybe\".", "optional_bool: maybe"); assertParseError( - "1:16: Expected \"true\" or \"false\".", + "1:16: Expected \"true\" or \"false\". Found \"2\".", "optional_bool: 2"); assertParseError( "1:18: Expected string.", @@ -575,10 +642,8 @@ public class TextFormatTest extends TestCase { TextFormat.unescapeBytes("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"")); assertEquals("\0\001\007\b\f\n\r\t\013\\\'\"", TextFormat.unescapeText("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"")); - assertEquals(kEscapeTestStringEscaped, - TextFormat.escapeText(kEscapeTestString)); - assertEquals(kEscapeTestString, - TextFormat.unescapeText(kEscapeTestStringEscaped)); + assertEquals(ESCAPE_TEST_STRING_ESCAPED, TextFormat.escapeText(ESCAPE_TEST_STRING)); + assertEquals(ESCAPE_TEST_STRING, TextFormat.unescapeText(ESCAPE_TEST_STRING_ESCAPED)); // Invariant assertEquals("hello", diff --git a/java/core/src/test/java/com/google/protobuf/UnknownFieldSetLiteTest.java b/java/core/src/test/java/com/google/protobuf/UnknownFieldSetLiteTest.java index 9928d44a..8ce0ca73 100644 --- a/java/core/src/test/java/com/google/protobuf/UnknownFieldSetLiteTest.java +++ b/java/core/src/test/java/com/google/protobuf/UnknownFieldSetLiteTest.java @@ -30,6 +30,8 @@ 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; @@ -133,6 +135,25 @@ public class UnknownFieldSetLiteTest extends TestCase { 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); diff --git a/java/core/src/test/java/com/google/protobuf/WireFormatTest.java b/java/core/src/test/java/com/google/protobuf/WireFormatTest.java index 625d4b42..03c33ecf 100644 --- a/java/core/src/test/java/com/google/protobuf/WireFormatTest.java +++ b/java/core/src/test/java/com/google/protobuf/WireFormatTest.java @@ -36,6 +36,7 @@ import protobuf_unittest.UnittestMset.TestMessageSetExtension2; import protobuf_unittest.UnittestProto; import protobuf_unittest.UnittestProto.TestAllExtensions; import protobuf_unittest.UnittestProto.TestAllTypes; +import protobuf_unittest.UnittestProto.TestExtensionInsideTable; import protobuf_unittest.UnittestProto.TestFieldOrderings; import protobuf_unittest.UnittestProto.TestOneof2; import protobuf_unittest.UnittestProto.TestOneofBackwardsCompatible; @@ -235,6 +236,26 @@ public class WireFormatTest extends TestCase { getTestFieldOrderingsRegistry()); assertEquals(source, dest); } + + private static ExtensionRegistry getTestExtensionInsideTableRegistry() { + ExtensionRegistry result = ExtensionRegistry.newInstance(); + result.add(UnittestProto.testExtensionInsideTableExtension); + return result; + } + + public void testExtensionInsideTable() throws Exception { + // Make sure the extension within the range of table is parsed correctly in experimental + // runtime. + TestExtensionInsideTable source = + TestExtensionInsideTable.newBuilder() + .setField1(1) + .setExtension(UnittestProto.testExtensionInsideTableExtension, 23) + .build(); + TestExtensionInsideTable dest = + TestExtensionInsideTable.parseFrom(source.toByteString(), + getTestExtensionInsideTableRegistry()); + assertEquals(source, dest); + } public void testParseMultipleExtensionRangesDynamic() throws Exception { // Same as above except with DynamicMessage. |