// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package com.google.protobuf;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.util.Collections.singletonList;
import com.google.protobuf.FieldPresenceTestProto.TestAllTypes;
import com.google.protobuf.UnittestImportLite.ImportEnumLite;
import com.google.protobuf.UnittestImportPublicLite.PublicImportMessageLite;
import com.google.protobuf.UnittestLite.ForeignEnumLite;
import com.google.protobuf.UnittestLite.ForeignMessageLite;
import com.google.protobuf.UnittestLite.RecursiveMessage;
import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
import com.google.protobuf.UnittestLite.TestAllTypesLite;
import com.google.protobuf.UnittestLite.TestAllTypesLite.NestedEnum;
import com.google.protobuf.UnittestLite.TestAllTypesLite.NestedMessage;
import com.google.protobuf.UnittestLite.TestAllTypesLite.NestedMessage2;
import com.google.protobuf.UnittestLite.TestAllTypesLite.OneofFieldCase;
import com.google.protobuf.UnittestLite.TestAllTypesLite.OptionalGroup;
import com.google.protobuf.UnittestLite.TestAllTypesLite.RepeatedGroup;
import com.google.protobuf.UnittestLite.TestAllTypesLiteOrBuilder;
import com.google.protobuf.UnittestLite.TestHugeFieldNumbersLite;
import com.google.protobuf.UnittestLite.TestNestedExtensionLite;
import map_lite_test.MapTestProto.TestMap;
import map_lite_test.MapTestProto.TestMap.MessageValue;
import protobuf_unittest.NestedExtensionLite;
import protobuf_unittest.NonNestedExtensionLite;
import protobuf_unittest.UnittestProto.TestOneof2;
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.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
/** Test lite runtime. */
@RunWith(JUnit4.class)
public class LiteTest {
@Before
public void setUp() throws Exception {
// Test that nested extensions are initialized correctly even if the outer
// class has not been accessed directly. This was once a bug with lite
// messages.
//
// We put this in setUp() rather than in its own test method because we
// need to make sure it runs before any actual tests.
assertThat(TestNestedExtensionLite.nestedExtension).isNotNull();
}
@Test
public void testLite() throws Exception {
// Since lite messages are a subset of regular messages, we can mostly
// assume that the functionality of lite messages is already thoroughly
// tested by the regular tests. All this test really verifies is that
// a proto with optimize_for = LITE_RUNTIME compiles correctly when
// linked only against the lite library. That is all tested at compile
// time, leaving not much to do in this method. Let's just do some random
// stuff to make sure the lite message is actually here and usable.
TestAllTypesLite message =
TestAllTypesLite.newBuilder()
.setOptionalInt32(123)
.addRepeatedString("hello")
.setOptionalNestedMessage(NestedMessage.newBuilder().setBb(7))
.build();
ByteString data = message.toByteString();
TestAllTypesLite message2 = TestAllTypesLite.parseFrom(data);
assertThat(message2.getOptionalInt32()).isEqualTo(123);
assertThat(message2.getRepeatedStringCount()).isEqualTo(1);
assertThat(message2.getRepeatedString(0)).isEqualTo("hello");
assertThat(message2.getOptionalNestedMessage().getBb()).isEqualTo(7);
}
@Test
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 unused =
TestAllTypesLite.parseFrom(new ByteArrayInputStream(byteStream.toByteArray()));
}
@Test
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, NestedEnum.BAZ)
.setExtension(
UnittestLite.optionalNestedMessageExtensionLite,
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();
assertThat((int) message2.getExtension(UnittestLite.optionalInt32ExtensionLite)).isEqualTo(123);
assertThat(message2.getExtensionCount(UnittestLite.repeatedStringExtensionLite)).isEqualTo(1);
assertThat(message2.getExtension(UnittestLite.repeatedStringExtensionLite)).hasSize(1);
assertThat(message2.getExtension(UnittestLite.repeatedStringExtensionLite, 0))
.isEqualTo("hello");
assertThat(message2.getExtension(UnittestLite.optionalNestedEnumExtensionLite))
.isEqualTo(NestedEnum.BAZ);
assertThat(message2.getExtension(UnittestLite.optionalNestedMessageExtensionLite).getBb())
.isEqualTo(7);
}
@Test
public void testClone() {
TestAllTypesLite.Builder expected = TestAllTypesLite.newBuilder().setOptionalInt32(123);
assertThat(expected.getOptionalInt32()).isEqualTo(expected.clone().getOptionalInt32());
TestAllExtensionsLite.Builder expected2 =
TestAllExtensionsLite.newBuilder()
.setExtension(UnittestLite.optionalInt32ExtensionLite, 123);
assertThat(expected2.getExtension(UnittestLite.optionalInt32ExtensionLite))
.isEqualTo(expected2.clone().getExtension(UnittestLite.optionalInt32ExtensionLite));
}
@Test
public void testAddAll() {
try {
TestAllTypesLite.newBuilder().addAllRepeatedBytes(null);
assertWithMessage("expected exception").fail();
} catch (NullPointerException e) {
// expected.
}
}
@Test
public void testMemoization() throws Exception {
GeneratedMessageLite<?, ?> message = TestUtilLite.getAllLiteExtensionsSet();
// This built message should not be mutable
assertThat(message.isMutable()).isFalse();
// Test serialized size is memoized
assertThat(message.getMemoizedSerializedSize())
.isEqualTo(GeneratedMessageLite.UNINITIALIZED_SERIALIZED_SIZE);
int size = message.getSerializedSize();
assertThat(size).isGreaterThan(0);
assertThat(message.getMemoizedSerializedSize()).isEqualTo(size);
message.clearMemoizedSerializedSize();
assertThat(message.getMemoizedSerializedSize())
.isEqualTo(GeneratedMessageLite.UNINITIALIZED_SERIALIZED_SIZE);
// Test hashCode is memoized
assertThat(message.hashCodeIsNotMemoized()).isTrue();
int hashCode = message.hashCode();
assertThat(message.hashCodeIsNotMemoized()).isFalse();
assertThat(message.getMemoizedHashCode()).isEqualTo(hashCode);
message.clearMemoizedHashCode();
assertThat(message.hashCodeIsNotMemoized()).isTrue();
// Test isInitialized is memoized
Field memo = message.getClass().getDeclaredField("memoizedIsInitialized");
memo.setAccessible(true);
memo.set(message, (byte) -1);
boolean initialized = message.isInitialized();
assertThat(initialized).isTrue();
// We have to cast to Byte first. Casting to byte causes a type error
assertThat(((Byte) memo.get(message)).intValue()).isEqualTo(1);
}
@Test
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
// a produced message.
TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder();
TestAllTypesLite message = builder.build();
TestAllTypesLite messageAfterBuild;
builder.setOptionalBool(true);
assertThat(message.getOptionalBool()).isFalse();
assertThat(builder.getOptionalBool()).isTrue();
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalBool()).isTrue();
assertThat(message.getOptionalBool()).isFalse();
builder.clearOptionalBool();
assertThat(builder.getOptionalBool()).isFalse();
assertThat(messageAfterBuild.getOptionalBool()).isTrue();
message = builder.build();
builder.setOptionalBytes(ByteString.copyFromUtf8("hi"));
assertThat(message.getOptionalBytes()).isEqualTo(ByteString.EMPTY);
assertThat(builder.getOptionalBytes()).isEqualTo(ByteString.copyFromUtf8("hi"));
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalBytes()).isEqualTo(ByteString.copyFromUtf8("hi"));
assertThat(message.getOptionalBytes()).isEqualTo(ByteString.EMPTY);
builder.clearOptionalBytes();
assertThat(builder.getOptionalBytes()).isEqualTo(ByteString.EMPTY);
assertThat(messageAfterBuild.getOptionalBytes()).isEqualTo(ByteString.copyFromUtf8("hi"));
message = builder.build();
builder.setOptionalCord("hi");
assertThat(message.getOptionalCord()).isEmpty();
assertThat(builder.getOptionalCord()).isEqualTo("hi");
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalCord()).isEqualTo("hi");
assertThat(message.getOptionalCord()).isEmpty();
builder.clearOptionalCord();
assertThat(builder.getOptionalCord()).isEmpty();
assertThat(messageAfterBuild.getOptionalCord()).isEqualTo("hi");
message = builder.build();
builder.setOptionalCordBytes(ByteString.copyFromUtf8("no"));
assertThat(message.getOptionalCordBytes()).isEqualTo(ByteString.EMPTY);
assertThat(builder.getOptionalCordBytes()).isEqualTo(ByteString.copyFromUtf8("no"));
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalCordBytes()).isEqualTo(ByteString.copyFromUtf8("no"));
assertThat(message.getOptionalCordBytes()).isEqualTo(ByteString.EMPTY);
builder.clearOptionalCord();
assertThat(builder.getOptionalCordBytes()).isEqualTo(ByteString.EMPTY);
assertThat(messageAfterBuild.getOptionalCordBytes()).isEqualTo(ByteString.copyFromUtf8("no"));
message = builder.build();
builder.setOptionalDouble(1);
assertThat(message.getOptionalDouble()).isEqualTo(0D);
assertThat(builder.getOptionalDouble()).isEqualTo(1D);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalDouble()).isEqualTo(1D);
assertThat(message.getOptionalDouble()).isEqualTo(0D);
builder.clearOptionalDouble();
assertThat(builder.getOptionalDouble()).isEqualTo(0D);
assertThat(messageAfterBuild.getOptionalDouble()).isEqualTo(1D);
message = builder.build();
builder.setOptionalFixed32(1);
assertThat(message.getOptionalFixed32()).isEqualTo(0);
assertThat(builder.getOptionalFixed32()).isEqualTo(1);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalFixed32()).isEqualTo(1);
assertThat(message.getOptionalFixed32()).isEqualTo(0);
builder.clearOptionalFixed32();
assertThat(builder.getOptionalFixed32()).isEqualTo(0);
assertThat(messageAfterBuild.getOptionalFixed32()).isEqualTo(1);
message = builder.build();
builder.setOptionalFixed64(1);
assertThat(message.getOptionalFixed64()).isEqualTo(0L);
assertThat(builder.getOptionalFixed64()).isEqualTo(1L);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalFixed64()).isEqualTo(1L);
assertThat(message.getOptionalFixed64()).isEqualTo(0L);
builder.clearOptionalFixed64();
assertThat(builder.getOptionalFixed64()).isEqualTo(0L);
assertThat(messageAfterBuild.getOptionalFixed64()).isEqualTo(1L);
message = builder.build();
builder.setOptionalFloat(1);
assertThat(message.getOptionalFloat()).isEqualTo(0F);
assertThat(builder.getOptionalFloat()).isEqualTo(1F);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalFloat()).isEqualTo(1F);
assertThat(message.getOptionalFloat()).isEqualTo(0F);
builder.clearOptionalFloat();
assertThat(builder.getOptionalFloat()).isEqualTo(0F);
assertThat(messageAfterBuild.getOptionalFloat()).isEqualTo(1F);
message = builder.build();
builder.setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
assertThat(message.getOptionalForeignEnum()).isEqualTo(ForeignEnumLite.FOREIGN_LITE_FOO);
assertThat(builder.getOptionalForeignEnum()).isEqualTo(ForeignEnumLite.FOREIGN_LITE_BAR);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalForeignEnum())
.isEqualTo(ForeignEnumLite.FOREIGN_LITE_BAR);
assertThat(message.getOptionalForeignEnum()).isEqualTo(ForeignEnumLite.FOREIGN_LITE_FOO);
builder.clearOptionalForeignEnum();
assertThat(builder.getOptionalForeignEnum()).isEqualTo(ForeignEnumLite.FOREIGN_LITE_FOO);
assertThat(messageAfterBuild.getOptionalForeignEnum())
.isEqualTo(ForeignEnumLite.FOREIGN_LITE_BAR);
message = builder.build();
ForeignMessageLite foreignMessage = ForeignMessageLite.newBuilder().setC(1).build();
builder.setOptionalForeignMessage(foreignMessage);
assertThat(message.getOptionalForeignMessage())
.isEqualTo(ForeignMessageLite.getDefaultInstance());
assertThat(builder.getOptionalForeignMessage()).isEqualTo(foreignMessage);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalForeignMessage()).isEqualTo(foreignMessage);
assertThat(message.getOptionalForeignMessage())
.isEqualTo(ForeignMessageLite.getDefaultInstance());
builder.clearOptionalForeignMessage();
assertThat(builder.getOptionalForeignMessage())
.isEqualTo(ForeignMessageLite.getDefaultInstance());
assertThat(messageAfterBuild.getOptionalForeignMessage()).isEqualTo(foreignMessage);
message = builder.build();
ForeignMessageLite foreignMessageC3 = ForeignMessageLite.newBuilder().setC(3).build();
builder.setOptionalForeignMessage(foreignMessageC3);
assertThat(message.getOptionalForeignMessage())
.isEqualTo(ForeignMessageLite.getDefaultInstance());
assertThat(builder.getOptionalForeignMessage()).isEqualTo(foreignMessageC3);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalForeignMessage()).isEqualTo(foreignMessageC3);
assertThat(message.getOptionalForeignMessage())
.isEqualTo(ForeignMessageLite.getDefaultInstance());
builder.clearOptionalForeignMessage();
assertThat(builder.getOptionalForeignMessage())
.isEqualTo(ForeignMessageLite.getDefaultInstance());
assertThat(messageAfterBuild.getOptionalForeignMessage()).isEqualTo(foreignMessageC3);
message = builder.build();
OptionalGroup optionalGroup = OptionalGroup.newBuilder().setA(1).build();
builder.setOptionalGroup(optionalGroup);
assertThat(message.getOptionalGroup()).isEqualTo(OptionalGroup.getDefaultInstance());
assertThat(builder.getOptionalGroup()).isEqualTo(optionalGroup);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalGroup()).isEqualTo(optionalGroup);
assertThat(message.getOptionalGroup()).isEqualTo(OptionalGroup.getDefaultInstance());
builder.clearOptionalGroup();
assertThat(builder.getOptionalGroup()).isEqualTo(OptionalGroup.getDefaultInstance());
assertThat(messageAfterBuild.getOptionalGroup()).isEqualTo(optionalGroup);
message = builder.build();
OptionalGroup.Builder optionalGroupBuilder = OptionalGroup.newBuilder().setA(3);
builder.setOptionalGroup(optionalGroupBuilder);
assertThat(message.getOptionalGroup()).isEqualTo(OptionalGroup.getDefaultInstance());
assertThat(builder.getOptionalGroup()).isEqualTo(optionalGroupBuilder.build());
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalGroup()).isEqualTo(optionalGroupBuilder.build());
assertThat(message.getOptionalGroup()).isEqualTo(OptionalGroup.getDefaultInstance());
builder.clearOptionalGroup();
assertThat(builder.getOptionalGroup()).isEqualTo(OptionalGroup.getDefaultInstance());
assertThat(messageAfterBuild.getOptionalGroup()).isEqualTo(optionalGroupBuilder.build());
message = builder.build();
builder.setOptionalInt32(1);
assertThat(message.getOptionalInt32()).isEqualTo(0);
assertThat(builder.getOptionalInt32()).isEqualTo(1);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalInt32()).isEqualTo(1);
assertThat(message.getOptionalInt32()).isEqualTo(0);
builder.clearOptionalInt32();
assertThat(builder.getOptionalInt32()).isEqualTo(0);
assertThat(messageAfterBuild.getOptionalInt32()).isEqualTo(1);
message = builder.build();
builder.setOptionalInt64(1);
assertThat(message.getOptionalInt64()).isEqualTo(0L);
assertThat(builder.getOptionalInt64()).isEqualTo(1L);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalInt64()).isEqualTo(1L);
assertThat(message.getOptionalInt64()).isEqualTo(0L);
builder.clearOptionalInt64();
assertThat(builder.getOptionalInt64()).isEqualTo(0L);
assertThat(messageAfterBuild.getOptionalInt64()).isEqualTo(1L);
message = builder.build();
NestedMessage nestedMessage = NestedMessage.newBuilder().setBb(1).build();
builder.setOptionalLazyMessage(nestedMessage);
assertThat(message.getOptionalLazyMessage()).isEqualTo(NestedMessage.getDefaultInstance());
assertThat(builder.getOptionalLazyMessage()).isEqualTo(nestedMessage);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalLazyMessage()).isEqualTo(nestedMessage);
assertThat(message.getOptionalLazyMessage()).isEqualTo(NestedMessage.getDefaultInstance());
builder.clearOptionalLazyMessage();
assertThat(builder.getOptionalLazyMessage()).isEqualTo(NestedMessage.getDefaultInstance());
assertThat(messageAfterBuild.getOptionalLazyMessage()).isEqualTo(nestedMessage);
message = builder.build();
NestedMessage.Builder nestedMessageBuilder = NestedMessage.newBuilder().setBb(3);
builder.setOptionalLazyMessage(nestedMessageBuilder);
assertThat(message.getOptionalLazyMessage()).isEqualTo(NestedMessage.getDefaultInstance());
assertThat(builder.getOptionalLazyMessage()).isEqualTo(nestedMessageBuilder.build());
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalLazyMessage()).isEqualTo(nestedMessageBuilder.build());
assertThat(message.getOptionalLazyMessage()).isEqualTo(NestedMessage.getDefaultInstance());
builder.clearOptionalLazyMessage();
assertThat(builder.getOptionalLazyMessage()).isEqualTo(NestedMessage.getDefaultInstance());
assertThat(messageAfterBuild.getOptionalLazyMessage()).isEqualTo(nestedMessageBuilder.build());
message = builder.build();
builder.setOptionalSfixed32(1);
assertThat(message.getOptionalSfixed32()).isEqualTo(0);
assertThat(builder.getOptionalSfixed32()).isEqualTo(1);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalSfixed32()).isEqualTo(1);
assertThat(message.getOptionalSfixed32()).isEqualTo(0);
builder.clearOptionalSfixed32();
assertThat(builder.getOptionalSfixed32()).isEqualTo(0);
assertThat(messageAfterBuild.getOptionalSfixed32()).isEqualTo(1);
message = builder.build();
builder.setOptionalSfixed64(1);
assertThat(message.getOptionalSfixed64()).isEqualTo(0L);
assertThat(builder.getOptionalSfixed64()).isEqualTo(1L);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalSfixed64()).isEqualTo(1L);
assertThat(message.getOptionalSfixed64()).isEqualTo(0L);
builder.clearOptionalSfixed64();
assertThat(builder.getOptionalSfixed64()).isEqualTo(0L);
assertThat(messageAfterBuild.getOptionalSfixed64()).isEqualTo(1L);
message = builder.build();
builder.setOptionalSint32(1);
assertThat(message.getOptionalSint32()).isEqualTo(0);
assertThat(builder.getOptionalSint32()).isEqualTo(1);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalSint32()).isEqualTo(1);
builder.clearOptionalSint32();
assertThat(builder.getOptionalSint32()).isEqualTo(0);
assertThat(messageAfterBuild.getOptionalSint32()).isEqualTo(1);
message = builder.build();
builder.setOptionalSint64(1);
assertThat(message.getOptionalSint64()).isEqualTo(0L);
assertThat(builder.getOptionalSint64()).isEqualTo(1L);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalSint64()).isEqualTo(1L);
assertThat(message.getOptionalSint64()).isEqualTo(0L);
builder.clearOptionalSint64();
assertThat(builder.getOptionalSint64()).isEqualTo(0L);
assertThat(messageAfterBuild.getOptionalSint64()).isEqualTo(1L);
message = builder.build();
builder.setOptionalString("hi");
assertThat(message.getOptionalString()).isEmpty();
assertThat(builder.getOptionalString()).isEqualTo("hi");
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalString()).isEqualTo("hi");
assertThat(message.getOptionalString()).isEmpty();
builder.clearOptionalString();
assertThat(builder.getOptionalString()).isEmpty();
assertThat(messageAfterBuild.getOptionalString()).isEqualTo("hi");
message = builder.build();
builder.setOptionalStringBytes(ByteString.copyFromUtf8("no"));
assertThat(message.getOptionalStringBytes()).isEqualTo(ByteString.EMPTY);
assertThat(builder.getOptionalStringBytes()).isEqualTo(ByteString.copyFromUtf8("no"));
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalStringBytes()).isEqualTo(ByteString.copyFromUtf8("no"));
assertThat(message.getOptionalStringBytes()).isEqualTo(ByteString.EMPTY);
builder.clearOptionalString();
assertThat(builder.getOptionalStringBytes()).isEqualTo(ByteString.EMPTY);
assertThat(messageAfterBuild.getOptionalStringBytes()).isEqualTo(ByteString.copyFromUtf8("no"));
message = builder.build();
builder.setOptionalStringPiece("hi");
assertThat(message.getOptionalStringPiece()).isEmpty();
assertThat(builder.getOptionalStringPiece()).isEqualTo("hi");
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalStringPiece()).isEqualTo("hi");
assertThat(message.getOptionalStringPiece()).isEmpty();
builder.clearOptionalStringPiece();
assertThat(builder.getOptionalStringPiece()).isEmpty();
assertThat(messageAfterBuild.getOptionalStringPiece()).isEqualTo("hi");
message = builder.build();
builder.setOptionalStringPieceBytes(ByteString.copyFromUtf8("no"));
assertThat(message.getOptionalStringPieceBytes()).isEqualTo(ByteString.EMPTY);
assertThat(builder.getOptionalStringPieceBytes()).isEqualTo(ByteString.copyFromUtf8("no"));
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalStringPieceBytes())
.isEqualTo(ByteString.copyFromUtf8("no"));
assertThat(message.getOptionalStringPieceBytes()).isEqualTo(ByteString.EMPTY);
builder.clearOptionalStringPiece();
assertThat(builder.getOptionalStringPieceBytes()).isEqualTo(ByteString.EMPTY);
assertThat(messageAfterBuild.getOptionalStringPieceBytes())
.isEqualTo(ByteString.copyFromUtf8("no"));
message = builder.build();
builder.setOptionalUint32(1);
assertThat(message.getOptionalUint32()).isEqualTo(0);
assertThat(builder.getOptionalUint32()).isEqualTo(1);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalUint32()).isEqualTo(1);
assertThat(message.getOptionalUint32()).isEqualTo(0);
builder.clearOptionalUint32();
assertThat(builder.getOptionalUint32()).isEqualTo(0);
assertThat(messageAfterBuild.getOptionalUint32()).isEqualTo(1);
message = builder.build();
builder.setOptionalUint64(1);
assertThat(message.getOptionalUint64()).isEqualTo(0L);
assertThat(builder.getOptionalUint64()).isEqualTo(1L);
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOptionalUint64()).isEqualTo(1L);
assertThat(message.getOptionalUint64()).isEqualTo(0L);
builder.clearOptionalUint64();
assertThat(builder.getOptionalUint64()).isEqualTo(0L);
assertThat(messageAfterBuild.getOptionalUint64()).isEqualTo(1L);
message = builder.build();
builder.addAllRepeatedBool(singletonList(true));
assertThat(message.getRepeatedBoolList()).isEmpty();
assertThat(builder.getRepeatedBoolList()).containsExactly(true);
assertThat(message.getRepeatedBoolList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedBool();
assertThat(builder.getRepeatedBoolList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedBoolList()).containsExactly(true);
message = builder.build();
builder.addAllRepeatedBytes(singletonList(ByteString.copyFromUtf8("hi")));
assertThat(message.getRepeatedBytesList()).isEmpty();
assertThat(builder.getRepeatedBytesList()).containsExactly(ByteString.copyFromUtf8("hi"));
assertThat(message.getRepeatedBytesList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedBytes();
assertThat(builder.getRepeatedBytesList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedBytesList())
.containsExactly(ByteString.copyFromUtf8("hi"));
message = builder.build();
builder.addAllRepeatedCord(singletonList("hi"));
assertThat(message.getRepeatedCordList()).isEmpty();
assertThat(builder.getRepeatedCordList()).containsExactly("hi");
assertThat(message.getRepeatedCordList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedCord();
assertThat(builder.getRepeatedCordList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedCordList()).containsExactly("hi");
message = builder.build();
builder.addAllRepeatedDouble(singletonList(1D));
assertThat(message.getRepeatedDoubleList()).isEmpty();
assertThat(builder.getRepeatedDoubleList()).containsExactly(1D);
assertThat(message.getRepeatedDoubleList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedDouble();
assertThat(builder.getRepeatedDoubleList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedDoubleList()).containsExactly(1D);
message = builder.build();
builder.addAllRepeatedFixed32(singletonList(1));
assertThat(message.getRepeatedFixed32List()).isEmpty();
assertThat(builder.getRepeatedFixed32List()).containsExactly(1);
assertThat(message.getRepeatedFixed32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedFixed32();
assertThat(builder.getRepeatedFixed32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedFixed32List()).containsExactly(1);
message = builder.build();
builder.addAllRepeatedFixed64(singletonList(1L));
assertThat(message.getRepeatedFixed64List()).isEmpty();
assertThat(builder.getRepeatedFixed64List()).containsExactly(1L);
assertThat(message.getRepeatedFixed64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedFixed64();
assertThat(builder.getRepeatedFixed64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedFixed64List()).containsExactly(1L);
message = builder.build();
builder.addAllRepeatedFloat(singletonList(1F));
assertThat(message.getRepeatedFloatList()).isEmpty();
assertThat(builder.getRepeatedFloatList()).containsExactly(1F);
assertThat(message.getRepeatedFloatList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedFloat();
assertThat(builder.getRepeatedFloatList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedFloatList()).containsExactly(1F);
message = builder.build();
builder.addAllRepeatedForeignEnum(singletonList(ForeignEnumLite.FOREIGN_LITE_BAR));
assertThat(message.getRepeatedForeignEnumList()).isEmpty();
assertThat(builder.getRepeatedForeignEnumList())
.containsExactly(ForeignEnumLite.FOREIGN_LITE_BAR);
assertThat(message.getRepeatedForeignEnumList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedForeignEnum();
assertThat(builder.getRepeatedForeignEnumList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedForeignEnumList())
.containsExactly(ForeignEnumLite.FOREIGN_LITE_BAR);
message = builder.build();
builder.addAllRepeatedForeignMessage(singletonList(foreignMessage));
assertThat(message.getRepeatedForeignMessageList()).isEmpty();
assertThat(builder.getRepeatedForeignMessageList()).containsExactly(foreignMessage);
assertThat(message.getRepeatedForeignMessageList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedForeignMessage();
assertThat(builder.getRepeatedForeignMessageList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedForeignMessageList()).containsExactly(foreignMessage);
message = builder.build();
builder.addAllRepeatedGroup(singletonList(RepeatedGroup.getDefaultInstance()));
assertThat(message.getRepeatedGroupList()).isEmpty();
assertThat(builder.getRepeatedGroupList()).containsExactly(RepeatedGroup.getDefaultInstance());
assertThat(message.getRepeatedGroupList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedGroup();
assertThat(builder.getRepeatedGroupList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedGroupList())
.containsExactly(RepeatedGroup.getDefaultInstance());
message = builder.build();
builder.addAllRepeatedInt32(singletonList(1));
assertThat(message.getRepeatedInt32List()).isEmpty();
assertThat(builder.getRepeatedInt32List()).containsExactly(1);
assertThat(message.getRepeatedInt32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedInt32();
assertThat(builder.getRepeatedInt32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedInt32List()).containsExactly(1);
message = builder.build();
builder.addAllRepeatedInt64(singletonList(1L));
assertThat(message.getRepeatedInt64List()).isEmpty();
assertThat(builder.getRepeatedInt64List()).containsExactly(1L);
assertThat(message.getRepeatedInt64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedInt64();
assertThat(builder.getRepeatedInt64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedInt64List()).containsExactly(1L);
message = builder.build();
builder.addAllRepeatedLazyMessage(singletonList(nestedMessage));
assertThat(message.getRepeatedLazyMessageList()).isEmpty();
assertThat(builder.getRepeatedLazyMessageList()).containsExactly(nestedMessage);
assertThat(message.getRepeatedLazyMessageList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedLazyMessage();
assertThat(builder.getRepeatedLazyMessageList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedLazyMessageList()).containsExactly(nestedMessage);
message = builder.build();
builder.addAllRepeatedSfixed32(singletonList(1));
assertThat(message.getRepeatedSfixed32List()).isEmpty();
assertThat(builder.getRepeatedSfixed32List()).containsExactly(1);
assertThat(message.getRepeatedSfixed32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedSfixed32();
assertThat(builder.getRepeatedSfixed32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedSfixed32List()).containsExactly(1);
message = builder.build();
builder.addAllRepeatedSfixed64(singletonList(1L));
assertThat(message.getRepeatedSfixed64List()).isEmpty();
assertThat(builder.getRepeatedSfixed64List()).containsExactly(1L);
assertThat(message.getRepeatedSfixed64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedSfixed64();
assertThat(builder.getRepeatedSfixed64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedSfixed64List()).containsExactly(1L);
message = builder.build();
builder.addAllRepeatedSint32(singletonList(1));
assertThat(message.getRepeatedSint32List()).isEmpty();
assertThat(builder.getRepeatedSint32List()).containsExactly(1);
assertThat(message.getRepeatedSint32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedSint32();
assertThat(builder.getRepeatedSint32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedSint32List()).containsExactly(1);
message = builder.build();
builder.addAllRepeatedSint64(singletonList(1L));
assertThat(message.getRepeatedSint64List()).isEmpty();
assertThat(builder.getRepeatedSint64List()).containsExactly(1L);
assertThat(message.getRepeatedSint64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedSint64();
assertThat(builder.getRepeatedSint64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedSint64List()).containsExactly(1L);
message = builder.build();
builder.addAllRepeatedString(singletonList("hi"));
assertThat(message.getRepeatedStringList()).isEmpty();
assertThat(builder.getRepeatedStringList()).containsExactly("hi");
assertThat(message.getRepeatedStringList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedString();
assertThat(builder.getRepeatedStringList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedStringList()).containsExactly("hi");
message = builder.build();
builder.addAllRepeatedStringPiece(singletonList("hi"));
assertThat(message.getRepeatedStringPieceList()).isEmpty();
assertThat(builder.getRepeatedStringPieceList()).containsExactly("hi");
assertThat(message.getRepeatedStringPieceList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedStringPiece();
assertThat(builder.getRepeatedStringPieceList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedStringPieceList()).containsExactly("hi");
message = builder.build();
builder.addAllRepeatedUint32(singletonList(1));
assertThat(message.getRepeatedUint32List()).isEmpty();
assertThat(builder.getRepeatedUint32List()).containsExactly(1);
assertThat(message.getRepeatedUint32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedUint32();
assertThat(builder.getRepeatedUint32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedUint32List()).containsExactly(1);
message = builder.build();
builder.addAllRepeatedUint64(singletonList(1L));
assertThat(message.getRepeatedUint64List()).isEmpty();
assertThat(builder.getRepeatedUint64List()).containsExactly(1L);
assertThat(message.getRepeatedUint64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedUint64();
assertThat(builder.getRepeatedUint64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedUint64List()).containsExactly(1L);
message = builder.build();
builder.addRepeatedBool(true);
assertThat(message.getRepeatedBoolList()).isEmpty();
assertThat(builder.getRepeatedBoolList()).containsExactly(true);
assertThat(message.getRepeatedBoolList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedBool();
assertThat(builder.getRepeatedBoolList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedBoolList()).containsExactly(true);
message = builder.build();
builder.addRepeatedBytes(ByteString.copyFromUtf8("hi"));
assertThat(message.getRepeatedBytesList()).isEmpty();
assertThat(builder.getRepeatedBytesList()).containsExactly(ByteString.copyFromUtf8("hi"));
assertThat(message.getRepeatedBytesList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedBytes();
assertThat(builder.getRepeatedBytesList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedBytesList())
.containsExactly(ByteString.copyFromUtf8("hi"));
message = builder.build();
builder.addRepeatedCord("hi");
assertThat(message.getRepeatedCordList()).isEmpty();
assertThat(builder.getRepeatedCordList()).containsExactly("hi");
assertThat(message.getRepeatedCordList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedCord();
assertThat(builder.getRepeatedCordList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedCordList()).containsExactly("hi");
message = builder.build();
builder.addRepeatedDouble(1D);
assertThat(message.getRepeatedDoubleList()).isEmpty();
assertThat(builder.getRepeatedDoubleList()).containsExactly(1D);
assertThat(message.getRepeatedDoubleList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedDouble();
assertThat(builder.getRepeatedDoubleList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedDoubleList()).containsExactly(1D);
message = builder.build();
builder.addRepeatedFixed32(1);
assertThat(message.getRepeatedFixed32List()).isEmpty();
assertThat(builder.getRepeatedFixed32List()).containsExactly(1);
assertThat(message.getRepeatedFixed32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedFixed32();
assertThat(builder.getRepeatedFixed32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedFixed32List()).containsExactly(1);
message = builder.build();
builder.addRepeatedFixed64(1L);
assertThat(message.getRepeatedFixed64List()).isEmpty();
assertThat(builder.getRepeatedFixed64List()).containsExactly(1L);
assertThat(message.getRepeatedFixed64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedFixed64();
assertThat(builder.getRepeatedFixed64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedFixed64List()).containsExactly(1L);
message = builder.build();
builder.addRepeatedFloat(1F);
assertThat(message.getRepeatedFloatList()).isEmpty();
assertThat(builder.getRepeatedFloatList()).containsExactly(1F);
assertThat(message.getRepeatedFloatList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedFloat();
assertThat(builder.getRepeatedFloatList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedFloatList()).containsExactly(1F);
message = builder.build();
builder.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
assertThat(message.getRepeatedForeignEnumList()).isEmpty();
assertThat(builder.getRepeatedForeignEnumList())
.containsExactly(ForeignEnumLite.FOREIGN_LITE_BAR);
assertThat(message.getRepeatedForeignEnumList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedForeignEnum();
assertThat(builder.getRepeatedForeignEnumList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedForeignEnumList())
.containsExactly(ForeignEnumLite.FOREIGN_LITE_BAR);
message = builder.build();
builder.addRepeatedForeignMessage(foreignMessage);
assertThat(message.getRepeatedForeignMessageList()).isEmpty();
assertThat(builder.getRepeatedForeignMessageList()).containsExactly(foreignMessage);
assertThat(message.getRepeatedForeignMessageList()).isEmpty();
messageAfterBuild = builder.build();
builder.removeRepeatedForeignMessage(0);
assertThat(builder.getRepeatedForeignMessageList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedForeignMessageList()).containsExactly(foreignMessage);
message = builder.build();
builder.addRepeatedGroup(RepeatedGroup.getDefaultInstance());
assertThat(message.getRepeatedGroupList()).isEmpty();
assertThat(builder.getRepeatedGroupList()).containsExactly(RepeatedGroup.getDefaultInstance());
assertThat(message.getRepeatedGroupList()).isEmpty();
messageAfterBuild = builder.build();
builder.removeRepeatedGroup(0);
assertThat(builder.getRepeatedGroupList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedGroupList())
.containsExactly(RepeatedGroup.getDefaultInstance());
message = builder.build();
builder.addRepeatedInt32(1);
assertThat(message.getRepeatedInt32List()).isEmpty();
assertThat(builder.getRepeatedInt32List()).containsExactly(1);
assertThat(message.getRepeatedInt32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedInt32();
assertThat(builder.getRepeatedInt32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedInt32List()).containsExactly(1);
message = builder.build();
builder.addRepeatedInt64(1L);
assertThat(message.getRepeatedInt64List()).isEmpty();
assertThat(builder.getRepeatedInt64List()).containsExactly(1L);
assertThat(message.getRepeatedInt64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedInt64();
assertThat(builder.getRepeatedInt64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedInt64List()).containsExactly(1L);
message = builder.build();
builder.addRepeatedLazyMessage(nestedMessage);
assertThat(message.getRepeatedLazyMessageList()).isEmpty();
assertThat(builder.getRepeatedLazyMessageList()).containsExactly(nestedMessage);
assertThat(message.getRepeatedLazyMessageList()).isEmpty();
messageAfterBuild = builder.build();
builder.removeRepeatedLazyMessage(0);
assertThat(builder.getRepeatedLazyMessageList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedLazyMessageList()).containsExactly(nestedMessage);
message = builder.build();
builder.addRepeatedSfixed32(1);
assertThat(message.getRepeatedSfixed32List()).isEmpty();
assertThat(builder.getRepeatedSfixed32List()).containsExactly(1);
assertThat(message.getRepeatedSfixed32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedSfixed32();
assertThat(builder.getRepeatedSfixed32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedSfixed32List()).containsExactly(1);
message = builder.build();
builder.addRepeatedSfixed64(1L);
assertThat(message.getRepeatedSfixed64List()).isEmpty();
assertThat(builder.getRepeatedSfixed64List()).containsExactly(1L);
assertThat(message.getRepeatedSfixed64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedSfixed64();
assertThat(builder.getRepeatedSfixed64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedSfixed64List()).containsExactly(1L);
message = builder.build();
builder.addRepeatedSint32(1);
assertThat(message.getRepeatedSint32List()).isEmpty();
assertThat(builder.getRepeatedSint32List()).containsExactly(1);
assertThat(message.getRepeatedSint32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedSint32();
assertThat(builder.getRepeatedSint32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedSint32List()).containsExactly(1);
message = builder.build();
builder.addRepeatedSint64(1L);
assertThat(message.getRepeatedSint64List()).isEmpty();
assertThat(builder.getRepeatedSint64List()).containsExactly(1L);
assertThat(message.getRepeatedSint64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedSint64();
assertThat(builder.getRepeatedSint64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedSint64List()).containsExactly(1L);
message = builder.build();
builder.addRepeatedString("hi");
assertThat(message.getRepeatedStringList()).isEmpty();
assertThat(builder.getRepeatedStringList()).containsExactly("hi");
assertThat(message.getRepeatedStringList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedString();
assertThat(builder.getRepeatedStringList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedStringList()).containsExactly("hi");
message = builder.build();
builder.addRepeatedStringPiece("hi");
assertThat(message.getRepeatedStringPieceList()).isEmpty();
assertThat(builder.getRepeatedStringPieceList()).containsExactly("hi");
assertThat(message.getRepeatedStringPieceList()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedStringPiece();
assertThat(builder.getRepeatedStringPieceList()).isEmpty();
assertThat(messageAfterBuild.getRepeatedStringPieceList()).containsExactly("hi");
message = builder.build();
builder.addRepeatedUint32(1);
assertThat(message.getRepeatedUint32List()).isEmpty();
assertThat(builder.getRepeatedUint32List()).containsExactly(1);
assertThat(message.getRepeatedUint32List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedUint32();
assertThat(builder.getRepeatedUint32List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedUint32List()).containsExactly(1);
message = builder.build();
builder.addRepeatedUint64(1L);
assertThat(message.getRepeatedUint64List()).isEmpty();
assertThat(builder.getRepeatedUint64List()).containsExactly(1L);
assertThat(message.getRepeatedUint64List()).isEmpty();
messageAfterBuild = builder.build();
builder.clearRepeatedUint64();
assertThat(builder.getRepeatedUint64List()).isEmpty();
assertThat(messageAfterBuild.getRepeatedUint64List()).containsExactly(1L);
message = builder.build();
builder.addRepeatedBool(true);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedBoolCount()).isEqualTo(0);
builder.setRepeatedBool(0, false);
assertThat(messageAfterBuild.getRepeatedBool(0)).isTrue();
assertThat(builder.getRepeatedBool(0)).isFalse();
builder.clearRepeatedBool();
message = builder.build();
builder.addRepeatedBytes(ByteString.copyFromUtf8("hi"));
messageAfterBuild = builder.build();
assertThat(message.getRepeatedBytesCount()).isEqualTo(0);
builder.setRepeatedBytes(0, ByteString.EMPTY);
assertThat(messageAfterBuild.getRepeatedBytes(0)).isEqualTo(ByteString.copyFromUtf8("hi"));
assertThat(builder.getRepeatedBytes(0)).isEqualTo(ByteString.EMPTY);
builder.clearRepeatedBytes();
message = builder.build();
builder.addRepeatedCord("hi");
messageAfterBuild = builder.build();
assertThat(message.getRepeatedCordCount()).isEqualTo(0);
builder.setRepeatedCord(0, "");
assertThat(messageAfterBuild.getRepeatedCord(0)).isEqualTo("hi");
assertThat(builder.getRepeatedCord(0)).isEmpty();
builder.clearRepeatedCord();
message = builder.build();
builder.addRepeatedCordBytes(ByteString.copyFromUtf8("hi"));
messageAfterBuild = builder.build();
assertThat(message.getRepeatedCordCount()).isEqualTo(0);
builder.setRepeatedCord(0, "");
assertThat(messageAfterBuild.getRepeatedCordBytes(0)).isEqualTo(ByteString.copyFromUtf8("hi"));
assertThat(builder.getRepeatedCordBytes(0)).isEqualTo(ByteString.EMPTY);
builder.clearRepeatedCord();
message = builder.build();
builder.addRepeatedDouble(1D);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedDoubleCount()).isEqualTo(0);
builder.setRepeatedDouble(0, 0D);
assertThat(messageAfterBuild.getRepeatedDouble(0)).isEqualTo(1D);
assertThat(builder.getRepeatedDouble(0)).isEqualTo(0D);
builder.clearRepeatedDouble();
message = builder.build();
builder.addRepeatedFixed32(1);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedFixed32Count()).isEqualTo(0);
builder.setRepeatedFixed32(0, 0);
assertThat(messageAfterBuild.getRepeatedFixed32(0)).isEqualTo(1);
assertThat(builder.getRepeatedFixed32(0)).isEqualTo(0);
builder.clearRepeatedFixed32();
message = builder.build();
builder.addRepeatedFixed64(1L);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedFixed64Count()).isEqualTo(0);
builder.setRepeatedFixed64(0, 0L);
assertThat(messageAfterBuild.getRepeatedFixed64(0)).isEqualTo(1L);
assertThat(builder.getRepeatedFixed64(0)).isEqualTo(0L);
builder.clearRepeatedFixed64();
message = builder.build();
builder.addRepeatedFloat(1F);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedFloatCount()).isEqualTo(0);
builder.setRepeatedFloat(0, 0F);
assertThat(messageAfterBuild.getRepeatedFloat(0)).isEqualTo(1F);
assertThat(builder.getRepeatedFloat(0)).isEqualTo(0F);
builder.clearRepeatedFloat();
message = builder.build();
builder.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedForeignEnumCount()).isEqualTo(0);
builder.setRepeatedForeignEnum(0, ForeignEnumLite.FOREIGN_LITE_FOO);
assertThat(messageAfterBuild.getRepeatedForeignEnum(0))
.isEqualTo(ForeignEnumLite.FOREIGN_LITE_BAR);
assertThat(builder.getRepeatedForeignEnum(0)).isEqualTo(ForeignEnumLite.FOREIGN_LITE_FOO);
builder.clearRepeatedForeignEnum();
message = builder.build();
builder.addRepeatedForeignMessage(foreignMessage);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedForeignMessageCount()).isEqualTo(0);
builder.setRepeatedForeignMessage(0, ForeignMessageLite.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedForeignMessage(0)).isEqualTo(foreignMessage);
assertThat(builder.getRepeatedForeignMessage(0))
.isEqualTo(ForeignMessageLite.getDefaultInstance());
builder.clearRepeatedForeignMessage();
message = builder.build();
builder.addRepeatedForeignMessage(foreignMessageC3);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedForeignMessageCount()).isEqualTo(0);
builder.setRepeatedForeignMessage(0, ForeignMessageLite.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedForeignMessage(0)).isEqualTo(foreignMessageC3);
assertThat(builder.getRepeatedForeignMessage(0))
.isEqualTo(ForeignMessageLite.getDefaultInstance());
builder.clearRepeatedForeignMessage();
message = builder.build();
builder.addRepeatedForeignMessage(0, foreignMessage);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedForeignMessageCount()).isEqualTo(0);
builder.setRepeatedForeignMessage(0, foreignMessageC3);
assertThat(messageAfterBuild.getRepeatedForeignMessage(0)).isEqualTo(foreignMessage);
assertThat(builder.getRepeatedForeignMessage(0)).isEqualTo(foreignMessageC3);
builder.clearRepeatedForeignMessage();
message = builder.build();
RepeatedGroup repeatedGroup = RepeatedGroup.newBuilder().setA(1).build();
builder.addRepeatedGroup(repeatedGroup);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedGroupCount()).isEqualTo(0);
builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedGroup(0)).isEqualTo(repeatedGroup);
assertThat(builder.getRepeatedGroup(0)).isEqualTo(RepeatedGroup.getDefaultInstance());
builder.clearRepeatedGroup();
message = builder.build();
builder.addRepeatedGroup(0, repeatedGroup);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedGroupCount()).isEqualTo(0);
builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedGroup(0)).isEqualTo(repeatedGroup);
assertThat(builder.getRepeatedGroup(0)).isEqualTo(RepeatedGroup.getDefaultInstance());
builder.clearRepeatedGroup();
message = builder.build();
RepeatedGroup.Builder repeatedGroupBuilder = RepeatedGroup.newBuilder().setA(3);
builder.addRepeatedGroup(repeatedGroupBuilder);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedGroupCount()).isEqualTo(0);
builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedGroup(0)).isEqualTo(repeatedGroupBuilder.build());
assertThat(builder.getRepeatedGroup(0)).isEqualTo(RepeatedGroup.getDefaultInstance());
builder.clearRepeatedGroup();
message = builder.build();
builder.addRepeatedGroup(0, repeatedGroupBuilder);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedGroupCount()).isEqualTo(0);
builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedGroup(0)).isEqualTo(repeatedGroupBuilder.build());
assertThat(builder.getRepeatedGroup(0)).isEqualTo(RepeatedGroup.getDefaultInstance());
builder.clearRepeatedGroup();
message = builder.build();
builder.addRepeatedInt32(1);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedInt32Count()).isEqualTo(0);
builder.setRepeatedInt32(0, 0);
assertThat(messageAfterBuild.getRepeatedInt32(0)).isEqualTo(1);
assertThat(builder.getRepeatedInt32(0)).isEqualTo(0);
builder.clearRepeatedInt32();
message = builder.build();
builder.addRepeatedInt64(1L);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedInt64Count()).isEqualTo(0L);
builder.setRepeatedInt64(0, 0L);
assertThat(messageAfterBuild.getRepeatedInt64(0)).isEqualTo(1L);
assertThat(builder.getRepeatedInt64(0)).isEqualTo(0L);
builder.clearRepeatedInt64();
message = builder.build();
builder.addRepeatedLazyMessage(nestedMessage);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedLazyMessageCount()).isEqualTo(0);
builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedLazyMessage(0)).isEqualTo(nestedMessage);
assertThat(builder.getRepeatedLazyMessage(0)).isEqualTo(NestedMessage.getDefaultInstance());
builder.clearRepeatedLazyMessage();
message = builder.build();
builder.addRepeatedLazyMessage(0, nestedMessage);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedLazyMessageCount()).isEqualTo(0);
builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedLazyMessage(0)).isEqualTo(nestedMessage);
assertThat(builder.getRepeatedLazyMessage(0)).isEqualTo(NestedMessage.getDefaultInstance());
builder.clearRepeatedLazyMessage();
message = builder.build();
builder.addRepeatedLazyMessage(nestedMessageBuilder);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedLazyMessageCount()).isEqualTo(0);
builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedLazyMessage(0)).isEqualTo(nestedMessageBuilder.build());
assertThat(builder.getRepeatedLazyMessage(0)).isEqualTo(NestedMessage.getDefaultInstance());
builder.clearRepeatedLazyMessage();
message = builder.build();
builder.addRepeatedLazyMessage(0, nestedMessageBuilder);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedLazyMessageCount()).isEqualTo(0);
builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
assertThat(messageAfterBuild.getRepeatedLazyMessage(0)).isEqualTo(nestedMessageBuilder.build());
assertThat(builder.getRepeatedLazyMessage(0)).isEqualTo(NestedMessage.getDefaultInstance());
builder.clearRepeatedLazyMessage();
message = builder.build();
builder.addRepeatedSfixed32(1);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedSfixed32Count()).isEqualTo(0);
builder.setRepeatedSfixed32(0, 0);
assertThat(messageAfterBuild.getRepeatedSfixed32(0)).isEqualTo(1);
assertThat(builder.getRepeatedSfixed32(0)).isEqualTo(0);
builder.clearRepeatedSfixed32();
message = builder.build();
builder.addRepeatedSfixed64(1L);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedSfixed64Count()).isEqualTo(0L);
builder.setRepeatedSfixed64(0, 0L);
assertThat(messageAfterBuild.getRepeatedSfixed64(0)).isEqualTo(1L);
assertThat(builder.getRepeatedSfixed64(0)).isEqualTo(0L);
builder.clearRepeatedSfixed64();
message = builder.build();
builder.addRepeatedSint32(1);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedSint32Count()).isEqualTo(0);
builder.setRepeatedSint32(0, 0);
assertThat(messageAfterBuild.getRepeatedSint32(0)).isEqualTo(1);
assertThat(builder.getRepeatedSint32(0)).isEqualTo(0);
builder.clearRepeatedSint32();
message = builder.build();
builder.addRepeatedSint64(1L);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedSint64Count()).isEqualTo(0L);
builder.setRepeatedSint64(0, 0L);
assertThat(messageAfterBuild.getRepeatedSint64(0)).isEqualTo(1L);
assertThat(builder.getRepeatedSint64(0)).isEqualTo(0L);
builder.clearRepeatedSint64();
message = builder.build();
builder.addRepeatedString("hi");
messageAfterBuild = builder.build();
assertThat(message.getRepeatedStringCount()).isEqualTo(0L);
builder.setRepeatedString(0, "");
assertThat(messageAfterBuild.getRepeatedString(0)).isEqualTo("hi");
assertThat(builder.getRepeatedString(0)).isEmpty();
builder.clearRepeatedString();
message = builder.build();
builder.addRepeatedStringBytes(ByteString.copyFromUtf8("hi"));
messageAfterBuild = builder.build();
assertThat(message.getRepeatedStringCount()).isEqualTo(0L);
builder.setRepeatedString(0, "");
assertThat(messageAfterBuild.getRepeatedStringBytes(0))
.isEqualTo(ByteString.copyFromUtf8("hi"));
assertThat(builder.getRepeatedStringBytes(0)).isEqualTo(ByteString.EMPTY);
builder.clearRepeatedString();
message = builder.build();
builder.addRepeatedStringPiece("hi");
messageAfterBuild = builder.build();
assertThat(message.getRepeatedStringPieceCount()).isEqualTo(0L);
builder.setRepeatedStringPiece(0, "");
assertThat(messageAfterBuild.getRepeatedStringPiece(0)).isEqualTo("hi");
assertThat(builder.getRepeatedStringPiece(0)).isEmpty();
builder.clearRepeatedStringPiece();
message = builder.build();
builder.addRepeatedStringPieceBytes(ByteString.copyFromUtf8("hi"));
messageAfterBuild = builder.build();
assertThat(message.getRepeatedStringPieceCount()).isEqualTo(0L);
builder.setRepeatedStringPiece(0, "");
assertThat(messageAfterBuild.getRepeatedStringPieceBytes(0))
.isEqualTo(ByteString.copyFromUtf8("hi"));
assertThat(builder.getRepeatedStringPieceBytes(0)).isEqualTo(ByteString.EMPTY);
builder.clearRepeatedStringPiece();
message = builder.build();
builder.addRepeatedUint32(1);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedUint32Count()).isEqualTo(0);
builder.setRepeatedUint32(0, 0);
assertThat(messageAfterBuild.getRepeatedUint32(0)).isEqualTo(1);
assertThat(builder.getRepeatedUint32(0)).isEqualTo(0);
builder.clearRepeatedUint32();
message = builder.build();
builder.addRepeatedUint64(1L);
messageAfterBuild = builder.build();
assertThat(message.getRepeatedUint64Count()).isEqualTo(0L);
builder.setRepeatedUint64(0, 0L);
assertThat(messageAfterBuild.getRepeatedUint64(0)).isEqualTo(1L);
assertThat(builder.getRepeatedUint64(0)).isEqualTo(0L);
builder.clearRepeatedUint64();
message = builder.build();
assertThat(message.getSerializedSize()).isEqualTo(0);
builder.mergeFrom(TestAllTypesLite.newBuilder().setOptionalBool(true).build());
assertThat(message.getSerializedSize()).isEqualTo(0);
assertThat(builder.build().getOptionalBool()).isTrue();
builder.clearOptionalBool();
message = builder.build();
assertThat(message.getSerializedSize()).isEqualTo(0);
builder.mergeFrom(TestAllTypesLite.newBuilder().setOptionalBool(true).build());
assertThat(message.getSerializedSize()).isEqualTo(0);
assertThat(builder.build().getOptionalBool()).isTrue();
builder.clear();
assertThat(builder.build().getSerializedSize()).isEqualTo(0);
message = builder.build();
assertThat(message.getSerializedSize()).isEqualTo(0);
builder.mergeOptionalForeignMessage(foreignMessage);
assertThat(message.getSerializedSize()).isEqualTo(0);
assertThat(builder.build().getOptionalForeignMessage().getC()).isEqualTo(foreignMessage.getC());
builder.clearOptionalForeignMessage();
message = builder.build();
assertThat(message.getSerializedSize()).isEqualTo(0);
builder.mergeOptionalLazyMessage(nestedMessage);
assertThat(message.getSerializedSize()).isEqualTo(0);
assertThat(builder.build().getOptionalLazyMessage().getBb()).isEqualTo(nestedMessage.getBb());
builder.clearOptionalLazyMessage();
message = builder.build();
builder.setOneofString("hi");
assertThat(message.getOneofFieldCase()).isEqualTo(OneofFieldCase.ONEOFFIELD_NOT_SET);
assertThat(builder.getOneofFieldCase()).isEqualTo(OneofFieldCase.ONEOF_STRING);
assertThat(builder.getOneofString()).isEqualTo("hi");
messageAfterBuild = builder.build();
assertThat(messageAfterBuild.getOneofFieldCase()).isEqualTo(OneofFieldCase.ONEOF_STRING);
assertThat(messageAfterBuild.getOneofString()).isEqualTo("hi");
builder.setOneofUint32(1);
assertThat(messageAfterBuild.getOneofFieldCase()).isEqualTo(OneofFieldCase.ONEOF_STRING);
assertThat(messageAfterBuild.getOneofString()).isEqualTo("hi");
assertThat(builder.getOneofFieldCase()).isEqualTo(OneofFieldCase.ONEOF_UINT32);
assertThat(builder.getOneofUint32()).isEqualTo(1);
TestAllTypesLiteOrBuilder messageOrBuilder = builder;
assertThat(messageOrBuilder.getOneofFieldCase()).isEqualTo(OneofFieldCase.ONEOF_UINT32);
TestAllExtensionsLite.Builder extendableMessageBuilder = TestAllExtensionsLite.newBuilder();
TestAllExtensionsLite extendableMessage = extendableMessageBuilder.build();
extendableMessageBuilder.setExtension(UnittestLite.optionalInt32ExtensionLite, 1);
assertThat(extendableMessage.hasExtension(UnittestLite.optionalInt32ExtensionLite)).isFalse();
extendableMessage = extendableMessageBuilder.build();
assertThat((int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite))
.isEqualTo(1);
assertThat((int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite))
.isEqualTo(1);
extendableMessageBuilder.setExtension(UnittestLite.optionalInt32ExtensionLite, 3);
assertThat((int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite))
.isEqualTo(3);
assertThat((int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite))
.isEqualTo(1);
extendableMessage = extendableMessageBuilder.build();
assertThat((int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite))
.isEqualTo(3);
assertThat((int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite))
.isEqualTo(3);
// No extension registry, so it should be in unknown fields.
extendableMessage = TestAllExtensionsLite.parseFrom(extendableMessage.toByteArray());
assertThat(extendableMessage.hasExtension(UnittestLite.optionalInt32ExtensionLite)).isFalse();
extendableMessageBuilder = extendableMessage.toBuilder();
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);
// The unknown field was preserved.
assertThat((int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite))
.isEqualTo(3);
assertThat((int) extendableMessage.getExtension(UnittestLite.optionalFixed32ExtensionLite))
.isEqualTo(11);
}
@Test
@SuppressWarnings("ProtoNewBuilderMergeFrom")
public void testBuilderMergeFromNull() throws Exception {
try {
TestAllTypesLite.newBuilder().mergeFrom((TestAllTypesLite) null);
assertWithMessage("expected exception").fail();
} catch (NullPointerException e) {
// Pass.
}
}
// Builder.mergeFrom() should keep existing extensions.
@Test
public void testBuilderMergeFromWithExtensions() throws Exception {
TestAllExtensionsLite message =
TestAllExtensionsLite.newBuilder()
.addExtension(UnittestLite.repeatedInt32ExtensionLite, 12)
.build();
ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
UnittestLite.registerAllExtensions(registry);
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
builder.mergeFrom(message.toByteArray(), registry);
builder.mergeFrom(message.toByteArray(), registry);
TestAllExtensionsLite result = builder.build();
assertThat(result.getExtensionCount(UnittestLite.repeatedInt32ExtensionLite)).isEqualTo(2);
assertThat(result.getExtension(UnittestLite.repeatedInt32ExtensionLite, 0).intValue())
.isEqualTo(12);
assertThat(result.getExtension(UnittestLite.repeatedInt32ExtensionLite, 1).intValue())
.isEqualTo(12);
}
// Builder.mergeFrom() should keep existing unknown fields.
@Test
public void testBuilderMergeFromWithUnknownFields() throws Exception {
TestAllTypesLite message = TestAllTypesLite.newBuilder().addRepeatedInt32(1).build();
NestedMessage.Builder builder = NestedMessage.newBuilder();
builder.mergeFrom(message.toByteArray());
builder.mergeFrom(message.toByteArray());
NestedMessage result = builder.build();
assertThat(result.getSerializedSize()).isEqualTo(message.getSerializedSize() * 2);
}
@Test
public void testMergeFrom_differentFieldsSetWithinOneField() throws Exception {
TestAllTypesLite result =
TestAllTypesLite.newBuilder()
.setOneofNestedMessage(NestedMessage.newBuilder().setBb(2))
.mergeFrom(
TestAllTypesLite.newBuilder()
.setOneofNestedMessage2(NestedMessage2.newBuilder().setDd(3))
.build())
.build();
assertToStringEquals("oneof_nested_message2 {\n dd: 3\n}", result);
}
@Test
public void testMergeFrom_differentFieldsOfSameTypeSetWithinOneField() throws Exception {
TestAllTypesLite result =
TestAllTypesLite.newBuilder()
.setOneofNestedMessage(NestedMessage.newBuilder().setBb(2))
.mergeFrom(
TestAllTypesLite.newBuilder()
.setOneofLazyNestedMessage(NestedMessage.newBuilder().setCc(3))
.build())
.build();
assertToStringEquals("oneof_lazy_nested_message {\n cc: 3\n}", result);
}
@Test
public void testMergeFrom_sameFieldSetWithinOneofField() throws Exception {
TestAllTypesLite result =
TestAllTypesLite.newBuilder()
.setOneofNestedMessage(NestedMessage.newBuilder().setBb(2))
.mergeFrom(
TestAllTypesLite.newBuilder()
.setOneofNestedMessage(NestedMessage.newBuilder().setCc(4))
.build())
.build();
assertToStringEquals("oneof_nested_message {\n bb: 2\n cc: 4\n}", result);
}
@Test
public void testMergeFrom_failureWhenReadingValue_propagatesOriginalException() {
final byte[] bytes = TestOneof2.newBuilder().setFooInt(123).build().toByteArray();
final IOException injectedException = new IOException("oh no");
CodedInputStream failingInputStream =
CodedInputStream.newInstance(
new InputStream() {
boolean first = true;
@Override
public int read(byte[] b, int off, int len) throws IOException {
if (!first) {
throw injectedException;
}
first = false;
System.arraycopy(bytes, 0, b, off, len);
return len;
}
@Override
public int read() {
throw new UnsupportedOperationException();
}
},
bytes.length - 1);
TestOneof2.Builder builder = TestOneof2.newBuilder();
try {
builder.mergeFrom(failingInputStream, ExtensionRegistryLite.getEmptyRegistry());
assertWithMessage("Expected mergeFrom to fail").fail();
} catch (IOException e) {
assertThat(e).isSameInstanceAs(injectedException);
}
}
@Test
public void testToStringDefaultInstance() throws Exception {
assertToStringEquals("", TestAllTypesLite.getDefaultInstance());
}
@Test
public void testToStringScalarFieldsSuffixedWithList() throws Exception {
assertToStringEquals(
"deceptively_named_list: 7",
TestAllTypesLite.newBuilder().setDeceptivelyNamedList(7).build());
}
@Test
public void testToStringPrimitives() throws Exception {
TestAllTypesLite proto =
TestAllTypesLite.newBuilder()
.setOptionalInt32(1)
.setOptionalInt64(9223372036854775807L)
.build();
assertToStringEquals("optional_int32: 1\noptional_int64: 9223372036854775807", proto);
proto =
TestAllTypesLite.newBuilder()
.setOptionalBool(true)
.setOptionalNestedEnum(NestedEnum.BAZ)
.build();
assertToStringEquals(
"optional_bool: true\noptional_nested_enum: " + NestedEnum.BAZ.toString(), proto);
proto = TestAllTypesLite.newBuilder().setOptionalFloat(2.72f).setOptionalDouble(3.14).build();
assertToStringEquals("optional_double: 3.14\noptional_float: 2.72", proto);
}
@Test
public void testToStringStringFields() throws Exception {
TestAllTypesLite proto =
TestAllTypesLite.newBuilder().setOptionalString("foo\"bar\nbaz\\").build();
assertToStringEquals("optional_string: \"foo\\\"bar\\nbaz\\\\\"", proto);
proto = TestAllTypesLite.newBuilder().setOptionalString("\u6587").build();
assertToStringEquals("optional_string: \"\\346\\226\\207\"", proto);
}
@Test
public void testToStringNestedMessage() throws Exception {
TestAllTypesLite proto =
TestAllTypesLite.newBuilder()
.setOptionalNestedMessage(NestedMessage.getDefaultInstance())
.build();
assertToStringEquals("optional_nested_message {\n}", proto);
proto =
TestAllTypesLite.newBuilder()
.setOptionalNestedMessage(NestedMessage.newBuilder().setBb(7))
.build();
assertToStringEquals("optional_nested_message {\n bb: 7\n}", proto);
}
@Test
public void testToStringRepeatedFields() throws Exception {
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(NestedMessage.newBuilder().setBb(7))
.addRepeatedLazyMessage(NestedMessage.newBuilder().setBb(8))
.build();
assertToStringEquals(
"repeated_lazy_message {\n bb: 7\n}\nrepeated_lazy_message {\n bb: 8\n}", proto);
}
@Test
public void testToStringForeignFields() throws Exception {
TestAllTypesLite proto =
TestAllTypesLite.newBuilder()
.setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
.setOptionalForeignMessage(ForeignMessageLite.newBuilder().setC(3))
.build();
assertToStringEquals(
"optional_foreign_enum: "
+ ForeignEnumLite.FOREIGN_LITE_BAR
+ "\noptional_foreign_message {\n c: 3\n}",
proto);
}
@Test
public void testToStringExtensions() throws Exception {
TestAllExtensionsLite message =
TestAllExtensionsLite.newBuilder()
.setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
.addExtension(UnittestLite.repeatedStringExtensionLite, "spam")
.addExtension(UnittestLite.repeatedStringExtensionLite, "eggs")
.setExtension(UnittestLite.optionalNestedEnumExtensionLite, NestedEnum.BAZ)
.setExtension(
UnittestLite.optionalNestedMessageExtensionLite,
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);
}
@Test
public void testToStringUnknownFields() throws Exception {
TestAllExtensionsLite messageWithExtensions =
TestAllExtensionsLite.newBuilder()
.setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
.addExtension(UnittestLite.repeatedStringExtensionLite, "spam")
.addExtension(UnittestLite.repeatedStringExtensionLite, "eggs")
.setExtension(UnittestLite.optionalNestedEnumExtensionLite, NestedEnum.BAZ)
.setExtension(
UnittestLite.optionalNestedMessageExtensionLite,
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);
}
@Test
public void testToStringLazyMessage() throws Exception {
TestAllTypesLite message =
TestAllTypesLite.newBuilder()
.setOptionalLazyMessage(NestedMessage.newBuilder().setBb(1).build())
.build();
assertToStringEquals("optional_lazy_message {\n bb: 1\n}", message);
}
@Test
public void testToStringGroup() throws Exception {
TestAllTypesLite message =
TestAllTypesLite.newBuilder()
.setOptionalGroup(OptionalGroup.newBuilder().setA(1).build())
.build();
assertToStringEquals("optional_group {\n a: 1\n}", message);
}
@Test
public void testToStringOneof() throws Exception {
TestAllTypesLite message = TestAllTypesLite.newBuilder().setOneofString("hello").build();
assertToStringEquals("oneof_string: \"hello\"", message);
}
@Test
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.
private static void assertToStringEquals(String expected, MessageLite message) {
String toString = message.toString();
assertThat(toString.charAt(0)).isEqualTo('#');
if (toString.contains("\n")) {
toString = toString.substring(toString.indexOf("\n") + 1);
} else {
toString = "";
}
assertThat(toString).isEqualTo(expected);
}
@Test
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 concat = bb.concat(cc);
TestAllTypesLite message = TestAllTypesLite.parseFrom(concat);
assertThat(message.getOptionalLazyMessage().getBb()).isEqualTo(11);
assertThat(message.getOptionalLazyMessage().getCc()).isEqualTo(22L);
}
@Test
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 concat = bb.concat(cc);
TestAllTypesLite message = TestAllTypesLite.parseFrom(concat);
assertThat(message.getOneofLazyNestedMessage().getBb()).isEqualTo(11);
assertThat(message.getOneofLazyNestedMessage().getCc()).isEqualTo(22L);
}
@Test
public void testMergeFromStream_repeatedField() throws Exception {
TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder().addRepeatedString("hello");
builder.mergeFrom(CodedInputStream.newInstance(builder.build().toByteArray()));
assertThat(builder.getRepeatedStringCount()).isEqualTo(2);
}
@Test
public void testMergeFromStream_invalidBytes() throws Exception {
TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder().setDefaultBool(true);
try {
builder.mergeFrom(CodedInputStream.newInstance("Invalid bytes".getBytes(Internal.UTF_8)));
assertWithMessage("expected exception").fail();
} catch (InvalidProtocolBufferException expected) {
}
}
@Test
public void testParseFromStream_IOExceptionNotLost() throws Exception {
final IOException readException = new IOException();
try {
TestAllTypesLite.parseFrom(
CodedInputStream.newInstance(
new InputStream() {
@Override
public int read() throws IOException {
throw readException;
}
}));
assertWithMessage("expected exception").fail();
} catch (InvalidProtocolBufferException expected) {
boolean found = false;
for (Throwable exception = expected; exception != null; exception = exception.getCause()) {
if (exception == readException) {
found = true;
break;
}
}
if (!found) {
throw new AssertionError("Lost cause of parsing error", expected);
}
}
}
@Test
public void testParseDelimitedFromStream_IOExceptionNotLost() throws Exception {
final IOException readException = new IOException();
try {
TestAllTypesLite.parseDelimitedFrom(
new InputStream() {
@Override
public int read() throws IOException {
throw readException;
}
});
assertWithMessage("expected exception").fail();
} catch (InvalidProtocolBufferException expected) {
boolean found = false;
for (Throwable exception = expected; exception != null; exception = exception.getCause()) {
if (exception == readException) {
found = true;
break;
}
}
if (!found) {
throw new AssertionError("Lost cause of parsing error", expected);
}
}
}
@Test
public void testParseFromArray_manyNestedMessagesError() throws Exception {
RecursiveMessage.Builder recursiveMessage =
RecursiveMessage.newBuilder().setPayload(ByteString.copyFrom(new byte[1]));
for (int i = 0; i < 20; i++) {
recursiveMessage = RecursiveMessage.newBuilder().setRecurse(recursiveMessage.build());
}
byte[] result = recursiveMessage.build().toByteArray();
result[
result.length
- CodedOutputStream.computeTagSize(RecursiveMessage.PAYLOAD_FIELD_NUMBER)
- CodedOutputStream.computeLengthDelimitedFieldSize(1)] =
0; // Set invalid tag
try {
RecursiveMessage.parseFrom(result);
assertWithMessage("Result was: " + Arrays.toString(result)).fail();
} catch (InvalidProtocolBufferException expected) {
boolean found = false;
int exceptionCount = 0;
for (Throwable exception = expected; exception != null; exception = exception.getCause()) {
if (exception instanceof InvalidProtocolBufferException) {
exceptionCount++;
}
for (StackTraceElement element : exception.getStackTrace()) {
if (InvalidProtocolBufferException.class.getName().equals(element.getClassName())
&& "invalidTag".equals(element.getMethodName())) {
found = true;
} else if (Android.isOnAndroidDevice()
&& "decodeUnknownField".equals(element.getMethodName())) {
// Android is missing the first element of the stack trace - b/181147885
found = true;
}
}
}
if (!found) {
throw new AssertionError("Lost cause of parsing error", expected);
}
if (exceptionCount > 1) {
throw new AssertionError(exceptionCount + " nested parsing exceptions", expected);
}
}
}
@Test
public void testParseFromStream_manyNestedMessagesError() throws Exception {
RecursiveMessage.Builder recursiveMessage =
RecursiveMessage.newBuilder().setPayload(ByteString.copyFrom(new byte[1]));
for (int i = 0; i < 20; i++) {
recursiveMessage = RecursiveMessage.newBuilder().setRecurse(recursiveMessage.build());
}
byte[] result = recursiveMessage.build().toByteArray();
result[
result.length
- CodedOutputStream.computeTagSize(RecursiveMessage.PAYLOAD_FIELD_NUMBER)
- CodedOutputStream.computeLengthDelimitedFieldSize(1)] =
0; // Set invalid tag
try {
RecursiveMessage.parseFrom(CodedInputStream.newInstance(new ByteArrayInputStream(result)));
assertWithMessage("Result was: " + Arrays.toString(result)).fail();
} catch (InvalidProtocolBufferException expected) {
boolean found = false;
int exceptionCount = 0;
for (Throwable exception = expected; exception != null; exception = exception.getCause()) {
if (exception instanceof InvalidProtocolBufferException) {
exceptionCount++;
}
for (StackTraceElement element : exception.getStackTrace()) {
if (InvalidProtocolBufferException.class.getName().equals(element.getClassName())
&& "invalidTag".equals(element.getMethodName())) {
found = true;
} else if (Android.isOnAndroidDevice() && "readTag".equals(element.getMethodName())) {
// Android is missing the first element of the stack trace - b/181147885
found = true;
}
}
}
if (!found) {
throw new AssertionError("Lost cause of parsing error", expected);
}
if (exceptionCount > 1) {
throw new AssertionError(exceptionCount + " nested parsing exceptions", expected);
}
}
}
@Test
public void testParseFromStream_sneakyNestedException() throws Exception {
final InvalidProtocolBufferException sketchy =
new InvalidProtocolBufferException("Created in a sketchy way!")
.setUnfinishedMessage(TestAllTypesLite.getDefaultInstance());
try {
RecursiveMessage.parseFrom(
CodedInputStream.newInstance(
new InputStream() {
@Override
public int read() throws IOException {
throw sketchy;
}
}));
assertWithMessage("expected exception").fail();
} catch (InvalidProtocolBufferException expected) {
assertThat(expected).isNotSameInstanceAs(sketchy);
}
assertThat(sketchy.getUnfinishedMessage()).isEqualTo(TestAllTypesLite.getDefaultInstance());
}
@Test
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();
assertThat(one).isEqualTo(two);
assertThat(two).isEqualTo(one);
assertThat(one.hashCode()).isEqualTo(two.hashCode());
}
@Test
@SuppressWarnings("ProtoNewBuilderMergeFrom")
public void testMergeFromNoLazyFieldSharing() throws Exception {
TestAllTypesLite.Builder sourceBuilder =
TestAllTypesLite.newBuilder().setOptionalLazyMessage(NestedMessage.newBuilder().setBb(1));
TestAllTypesLite.Builder targetBuilder =
TestAllTypesLite.newBuilder().mergeFrom(sourceBuilder.build());
assertThat(sourceBuilder.getOptionalLazyMessage().getBb()).isEqualTo(1);
// now change the sourceBuilder, and target value shouldn't be affected.
sourceBuilder.setOptionalLazyMessage(NestedMessage.newBuilder().setBb(2));
assertThat(targetBuilder.getOptionalLazyMessage().getBb()).isEqualTo(1);
}
@Test
public void testEquals_notEqual() throws Exception {
TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
byte[] bytes = one.toByteArray();
TestAllTypesLite two = one.toBuilder().mergeFrom(one).mergeFrom(bytes).build();
assertThat(one.equals(two)).isFalse();
assertThat(two.equals(one)).isFalse();
assertThat(one.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(one)).isFalse();
TestAllTypesLite oneFieldSet = TestAllTypesLite.newBuilder().setDefaultBool(true).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultCord("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultCordBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultDouble(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFixed32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFixed64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFloat(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder()
.setDefaultForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
.build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder().setDefaultImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultInt32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultInt64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultNestedEnum(NestedEnum.BAR).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSfixed32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSfixed64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSint32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSint64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultString("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultStringBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultStringPiece("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder().setDefaultStringPieceBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultUint32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setDefaultUint64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedBool(true).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedCord("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedCordBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedDouble(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFixed32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFixed64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFloat(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder()
.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
.build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder().addRepeatedImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedInt32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedInt64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedNestedEnum(NestedEnum.BAR).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSfixed32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSfixed64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSint32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSint64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedString("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedStringBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedStringPiece("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder().addRepeatedStringPieceBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedUint32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedUint64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalBool(true).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalCord("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalCordBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalDouble(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFixed32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFixed64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFloat(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder()
.setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
.build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder().setOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalInt32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalInt64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalNestedEnum(NestedEnum.BAR).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSfixed32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSfixed64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSint32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSint64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalString("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalStringBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalStringPiece("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder().setOptionalStringPieceBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalUint32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOptionalUint64(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOneofBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder()
.setOneofLazyNestedMessage(NestedMessage.getDefaultInstance())
.build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder()
.setOneofNestedMessage(NestedMessage.getDefaultInstance())
.build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOneofString("").build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOneofStringBytes(ByteString.EMPTY).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet = TestAllTypesLite.newBuilder().setOneofUint32(0).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder()
.setOptionalForeignMessage(ForeignMessageLite.getDefaultInstance())
.build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder().setOptionalGroup(OptionalGroup.getDefaultInstance()).build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder()
.setOptionalPublicImportMessage(PublicImportMessageLite.getDefaultInstance())
.build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder()
.setOptionalLazyMessage(NestedMessage.getDefaultInstance())
.build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
oneFieldSet =
TestAllTypesLite.newBuilder()
.addRepeatedLazyMessage(NestedMessage.getDefaultInstance())
.build();
assertThat(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance())).isFalse();
assertThat(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet)).isFalse();
}
@Test
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();
// Check that equals is doing value rather than object equality.
assertThat(foo1a).isEqualTo(foo1b);
assertThat(foo1a.hashCode()).isEqualTo(foo1b.hashCode());
// Check that a different object is not equal.
assertThat(foo1a.equals(foo2)).isFalse();
// Check that two objects which have different types but the same field values are not
// considered to be equal.
Bar bar = Bar.newBuilder().setName("bar").build();
BarPrime barPrime = BarPrime.newBuilder().setName("bar").build();
assertThat(bar).isNotEqualTo((Object) barPrime); // compiler already won't let this happen.
}
@Test
public void testEqualsAndHashCodeForTrickySchemaTypes() {
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);
assertEqualsAndHashCodeAreFalse(foo1, foo4);
}
@Test
public void testOneofEquals() throws Exception {
TestOneofEquals.Builder builder = TestOneofEquals.newBuilder();
TestOneofEquals message1 = builder.build();
// Set message2's name field to default value. The two messages should be different when we
// check with the oneof case.
builder.setName("");
TestOneofEquals message2 = builder.build();
assertThat(message1.equals(message2)).isFalse();
}
@Test
public void testEquals_sanity() throws Exception {
TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
TestAllTypesLite two = TestAllTypesLite.parseFrom(one.toByteArray());
assertThat(one).isEqualTo(two);
assertThat(one.hashCode()).isEqualTo(two.hashCode());
assertThat(one.toBuilder().mergeFrom(two).build())
.isEqualTo(two.toBuilder().mergeFrom(two.toByteArray()).build());
}
@Test
public void testEqualsAndHashCodeWithUnknownFields() throws InvalidProtocolBufferException {
Foo fooWithOnlyValue = Foo.newBuilder().setValue(1).build();
Foo fooWithValueAndExtension =
fooWithOnlyValue
.toBuilder()
.setValue(1)
.setExtension(Bar.fooExt, Bar.newBuilder().setName("name").build())
.build();
Foo fooWithValueAndUnknownFields = Foo.parseFrom(fooWithValueAndExtension.toByteArray());
assertEqualsAndHashCodeAreFalse(fooWithOnlyValue, fooWithValueAndUnknownFields);
assertEqualsAndHashCodeAreFalse(fooWithValueAndExtension, fooWithValueAndUnknownFields);
}
@Test
public void testEqualsAndHashCodeWithExtensions() throws InvalidProtocolBufferException {
Foo fooWithOnlyValue = Foo.newBuilder().setValue(1).build();
Foo fooWithValueAndExtension =
fooWithOnlyValue
.toBuilder()
.setValue(1)
.setExtension(Bar.fooExt, Bar.newBuilder().setName("name").build())
.build();
assertEqualsAndHashCodeAreFalse(fooWithOnlyValue, fooWithValueAndExtension);
}
// Test to ensure we avoid a class cast exception with oneofs.
@Test
public void testEquals_oneOfMessages() {
TestAllTypesLite mine = TestAllTypesLite.newBuilder().setOneofString("Hello").build();
TestAllTypesLite other =
TestAllTypesLite.newBuilder()
.setOneofNestedMessage(NestedMessage.getDefaultInstance())
.build();
assertThat(mine.equals(other)).isFalse();
assertThat(other.equals(mine)).isFalse();
}
@Test
public void testHugeFieldNumbers() throws InvalidProtocolBufferException {
TestHugeFieldNumbersLite message =
TestHugeFieldNumbersLite.newBuilder()
.setOptionalInt32(1)
.addRepeatedInt32(2)
.setOptionalEnum(ForeignEnumLite.FOREIGN_LITE_FOO)
.setOptionalString("xyz")
.setOptionalMessage(ForeignMessageLite.newBuilder().setC(3).build())
.build();
TestHugeFieldNumbersLite parsedMessage =
TestHugeFieldNumbersLite.parseFrom(message.toByteArray());
assertThat(parsedMessage.getOptionalInt32()).isEqualTo(1);
assertThat(parsedMessage.getRepeatedInt32(0)).isEqualTo(2);
assertThat(parsedMessage.getOptionalEnum()).isEqualTo(ForeignEnumLite.FOREIGN_LITE_FOO);
assertThat(parsedMessage.getOptionalString()).isEqualTo("xyz");
assertThat(parsedMessage.getOptionalMessage().getC()).isEqualTo(3);
}
private void assertEqualsAndHashCodeAreFalse(Object o1, Object o2) {
assertThat(o1.equals(o2)).isFalse();
assertThat(o1.hashCode()).isNotEqualTo(o2.hashCode());
}
@Test
public void testRecursiveHashcode() {
// This tests that we don't infinite loop.
int unused = TestRecursiveOneof.getDefaultInstance().hashCode();
}
@Test
public void testParseFromByteBuffer() throws Exception {
TestAllTypesLite message =
TestAllTypesLite.newBuilder()
.setOptionalInt32(123)
.addRepeatedString("hello")
.setOptionalNestedMessage(NestedMessage.newBuilder().setBb(7))
.build();
TestAllTypesLite copy =
TestAllTypesLite.parseFrom(message.toByteString().asReadOnlyByteBuffer());
assertThat(message).isEqualTo(copy);
}
@Test
public void testParseFromByteBufferThrows() {
try {
TestAllTypesLite.parseFrom(ByteBuffer.wrap(new byte[] {0x5}));
assertWithMessage("expected exception").fail();
} catch (InvalidProtocolBufferException expected) {
}
TestAllTypesLite message =
TestAllTypesLite.newBuilder().setOptionalInt32(123).addRepeatedString("hello").build();
ByteBuffer buffer = ByteBuffer.wrap(message.toByteArray(), 0, message.getSerializedSize() - 1);
try {
TestAllTypesLite.parseFrom(buffer);
assertWithMessage("expected exception").fail();
} catch (InvalidProtocolBufferException expected) {
assertThat(TestAllTypesLite.newBuilder().setOptionalInt32(123).build())
.isEqualTo(expected.getUnfinishedMessage());
}
}
@Test
public void testParseFromByteBuffer_extensions() throws Exception {
TestAllExtensionsLite message =
TestAllExtensionsLite.newBuilder()
.setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
.addExtension(UnittestLite.repeatedStringExtensionLite, "hello")
.setExtension(UnittestLite.optionalNestedEnumExtensionLite, NestedEnum.BAZ)
.setExtension(
UnittestLite.optionalNestedMessageExtensionLite,
NestedMessage.newBuilder().setBb(7).build())
.build();
ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
UnittestLite.registerAllExtensions(registry);
TestAllExtensionsLite copy =
TestAllExtensionsLite.parseFrom(message.toByteString().asReadOnlyByteBuffer(), registry);
assertThat(message).isEqualTo(copy);
}
@Test
public void testParseFromByteBufferThrows_extensions() {
ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
UnittestLite.registerAllExtensions(registry);
try {
TestAllExtensionsLite.parseFrom(ByteBuffer.wrap(new byte[] {0x5}), registry);
assertWithMessage("expected exception").fail();
} catch (InvalidProtocolBufferException expected) {
}
TestAllExtensionsLite message =
TestAllExtensionsLite.newBuilder()
.setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
.addExtension(UnittestLite.repeatedStringExtensionLite, "hello")
.build();
ByteBuffer buffer = ByteBuffer.wrap(message.toByteArray(), 0, message.getSerializedSize() - 1);
try {
TestAllExtensionsLite.parseFrom(buffer, registry);
assertWithMessage("expected exception").fail();
} catch (InvalidProtocolBufferException expected) {
assertThat(
TestAllExtensionsLite.newBuilder()
.setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
.build())
.isEqualTo(expected.getUnfinishedMessage());
}
}
// Make sure we haven't screwed up the code generation for packing fields by default.
@Test
public void testPackedSerialization() throws Exception {
TestAllTypes.Builder builder = TestAllTypes.newBuilder();
builder.addRepeatedInt32(4321);
builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ);
TestAllTypes message = builder.build();
CodedInputStream in = CodedInputStream.newInstance(message.toByteArray());
while (!in.isAtEnd()) {
int tag = in.readTag();
assertThat(WireFormat.getTagWireType(tag)).isEqualTo(WireFormat.WIRETYPE_LENGTH_DELIMITED);
in.skipField(tag);
}
}
@Test
public void testAddAllIteratesOnce() {
TestAllTypesLite unused =
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();
}
@Test
public void testAddAllIteratesOnce_throwsOnNull() {
TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder();
try {
builder.addAllRepeatedBool(new OneTimeIterableList<>(true, false, null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 2 is null.");
assertThat(builder.getRepeatedBoolCount()).isEqualTo(0);
}
try {
builder.addAllRepeatedBool(new OneTimeIterable<>(true, false, null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 2 is null.");
assertThat(builder.getRepeatedBoolCount()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedBool(new OneTimeIterableList<>((Boolean) null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 0 is null.");
assertThat(builder.getRepeatedBoolCount()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedInt32(new OneTimeIterableList<>((Integer) null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 0 is null.");
assertThat(builder.getRepeatedInt32Count()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedInt64(new OneTimeIterableList<>((Long) null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 0 is null.");
assertThat(builder.getRepeatedInt64Count()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedFloat(new OneTimeIterableList<>((Float) null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 0 is null.");
assertThat(builder.getRepeatedFloatCount()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedDouble(new OneTimeIterableList<>((Double) null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 0 is null.");
assertThat(builder.getRepeatedDoubleCount()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedBytes(new OneTimeIterableList<>((ByteString) null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 0 is null.");
assertThat(builder.getRepeatedBytesCount()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedString(new OneTimeIterableList<>("", "", null, ""));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 2 is null.");
assertThat(builder.getRepeatedStringCount()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedString(new OneTimeIterable<>("", "", null, ""));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 2 is null.");
assertThat(builder.getRepeatedStringCount()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedString(new OneTimeIterableList<>((String) null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 0 is null.");
assertThat(builder.getRepeatedStringCount()).isEqualTo(0);
}
try {
builder = TestAllTypesLite.newBuilder();
builder.addAllRepeatedNestedMessage(new OneTimeIterableList<>((NestedMessage) null));
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
assertThat(expected).hasMessageThat().isEqualTo("Element at index 0 is null.");
assertThat(builder.getRepeatedNestedMessageCount()).isEqualTo(0);
}
}
@Test
public void testExtensionRenamesKeywords() {
assertThat(NonNestedExtensionLite.package_)
.isInstanceOf(GeneratedMessageLite.GeneratedExtension.class);
assertThat(NestedExtensionLite.MyNestedExtensionLite.private_)
.isInstanceOf(GeneratedMessageLite.GeneratedExtension.class);
NonNestedExtensionLite.MessageLiteToBeExtended msg =
NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
.setExtension(NonNestedExtensionLite.package_, true)
.build();
assertThat(msg.getExtension(NonNestedExtensionLite.package_)).isTrue();
msg =
NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
.setExtension(NestedExtensionLite.MyNestedExtensionLite.private_, 2.4)
.build();
assertThat(msg.getExtension(NestedExtensionLite.MyNestedExtensionLite.private_)).isEqualTo(2.4);
}
private static final class OneTimeIterableList<T> extends ArrayList<T> {
private boolean wasIterated = false;
OneTimeIterableList(T... contents) {
addAll(Arrays.asList(contents));
}
@Override
public Iterator<T> iterator() {
if (wasIterated) {
assertWithMessage("expected exception").fail();
}
wasIterated = true;
return super.iterator();
}
}
private static final class OneTimeIterable<T> implements Iterable<T> {
private final List<T> list;
private boolean wasIterated = false;
OneTimeIterable(T... contents) {
list = Arrays.asList(contents);
}
@Override
public Iterator<T> iterator() {
if (wasIterated) {
assertWithMessage("expected exception").fail();
}
wasIterated = true;
return list.iterator();
}
}
@Test
public void testNullExtensionRegistry() throws Exception {
try {
TestAllTypesLite.parseFrom(new byte[] {}, null);
assertWithMessage("expected exception").fail();
} catch (NullPointerException expected) {
}
}
@Test
public void testSerializeToOutputStreamThrowsIOException() {
try {
TestAllTypesLite.newBuilder()
.setOptionalBytes(ByteString.copyFromUtf8("hello"))
.build()
.writeTo(
new OutputStream() {
@Override
public void write(int b) throws IOException {
throw new IOException();
}
});
assertWithMessage("expected exception").fail();
} catch (IOException expected) {
}
}
@Test
public void testUnpairedSurrogatesReplacedByQuestionMark() throws InvalidProtocolBufferException {
String testString = "foo \ud83d bar";
String expectedString = "foo ? bar";
TestAllTypesLite testMessage =
TestAllTypesLite.newBuilder().setOptionalString(testString).build();
ByteString serializedMessage = testMessage.toByteString();
// Behavior is compatible with String.getBytes("UTF-8"), which replaces
// unpaired surrogates with a question mark.
TestAllTypesLite parsedMessage = TestAllTypesLite.parseFrom(serializedMessage);
assertThat(parsedMessage.getOptionalString()).isEqualTo(expectedString);
// Conversion happens during serialization.
ByteString expectedBytes = ByteString.copyFromUtf8(expectedString);
assertWithMessage(
String.format(
"Expected serializedMessage (%s) to contain \"%s\" (%s).",
encodeHex(serializedMessage), expectedString, encodeHex(expectedBytes)))
.that(contains(serializedMessage, expectedBytes))
.isTrue();
}
@Test
public void testPreservesFloatingPointNegative0() throws Exception {
proto3_unittest.UnittestProto3.TestAllTypes message =
proto3_unittest.UnittestProto3.TestAllTypes.newBuilder()
.setOptionalFloat(-0.0f)
.setOptionalDouble(-0.0)
.build();
assertThat(
proto3_unittest.UnittestProto3.TestAllTypes.parseFrom(
message.toByteString(), ExtensionRegistryLite.getEmptyRegistry()))
.isEqualTo(message);
}
@Test
public void testNegative0FloatingPointEquality() throws Exception {
// Like Double#equals and Float#equals, we treat -0.0 as not being equal to +0.0 even though
// IEEE 754 mandates that they are equivalent. This test asserts that behavior.
proto3_unittest.UnittestProto3.TestAllTypes message1 =
proto3_unittest.UnittestProto3.TestAllTypes.newBuilder()
.setOptionalFloat(-0.0f)
.setOptionalDouble(-0.0)
.build();
proto3_unittest.UnittestProto3.TestAllTypes message2 =
proto3_unittest.UnittestProto3.TestAllTypes.newBuilder()
.setOptionalFloat(0.0f)
.setOptionalDouble(0.0)
.build();
assertThat(message1).isNotEqualTo(message2);
}
private static String encodeHex(ByteString bytes) {
String hexDigits = "0123456789abcdef";
StringBuilder stringBuilder = new StringBuilder(bytes.size() * 2);
for (byte b : bytes) {
stringBuilder.append(hexDigits.charAt((b & 0xf0) >> 4));
stringBuilder.append(hexDigits.charAt(b & 0x0f));
}
return stringBuilder.toString();
}
private static boolean contains(ByteString a, ByteString b) {
for (int i = 0; i <= a.size() - b.size(); ++i) {
if (a.substring(i, i + b.size()).equals(b)) {
return true;
}
}
return false;
}
}
Codebase Browser
chromium