java/lite/src/test/java/com/google/protobuf/LiteTest.java

   1 // Protocol Buffers - Google's data interchange format
   2 // Copyright 2008 Google Inc.  All rights reserved.
   3 // https://developers.google.com/protocol-buffers/
   4 //
   5 // Redistribution and use in source and binary forms, with or without
   6 // modification, are permitted provided that the following conditions are
   7 // met:
   8 //
   9 //     * Redistributions of source code must retain the above copyright
  10 // notice, this list of conditions and the following disclaimer.
  11 //     * Redistributions in binary form must reproduce the above
  12 // copyright notice, this list of conditions and the following disclaimer
  13 // in the documentation and/or other materials provided with the
  14 // distribution.
  15 //     * Neither the name of Google Inc. nor the names of its
  16 // contributors may be used to endorse or promote products derived from
  17 // this software without specific prior written permission.
  18 //
  19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30
  31 package com.google.protobuf;
  32
  33 import static java.util.Collections.emptyList;
  34 import static java.util.Collections.singletonList;
  35
  36 import com.google.protobuf.FieldPresenceTestProto.TestAllTypes;
  37 import com.google.protobuf.UnittestImportLite.ImportEnumLite;
  38 import com.google.protobuf.UnittestImportPublicLite.PublicImportMessageLite;
  39 import com.google.protobuf.UnittestLite.ForeignEnumLite;
  40 import com.google.protobuf.UnittestLite.ForeignMessageLite;
  41 import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
  42 import com.google.protobuf.UnittestLite.TestAllTypesLite;
  43 import com.google.protobuf.UnittestLite.TestAllTypesLite.NestedEnum;
  44 import com.google.protobuf.UnittestLite.TestAllTypesLite.NestedMessage;
  45 import com.google.protobuf.UnittestLite.TestAllTypesLite.OneofFieldCase;
  46 import com.google.protobuf.UnittestLite.TestAllTypesLite.OptionalGroup;
  47 import com.google.protobuf.UnittestLite.TestAllTypesLite.RepeatedGroup;
  48 import com.google.protobuf.UnittestLite.TestAllTypesLiteOrBuilder;
  49 import com.google.protobuf.UnittestLite.TestHugeFieldNumbersLite;
  50 import com.google.protobuf.UnittestLite.TestNestedExtensionLite;
  51 import map_lite_test.MapTestProto.TestMap;
  52 import map_lite_test.MapTestProto.TestMap.MessageValue;
  53 import protobuf_unittest.NestedExtensionLite;
  54 import protobuf_unittest.NonNestedExtensionLite;
  55 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Bar;
  56 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.BarPrime;
  57 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Foo;
  58 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestOneofEquals;
  59 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestRecursiveOneof;
  60 import java.io.ByteArrayInputStream;
  61 import java.io.ByteArrayOutputStream;
  62 import java.io.IOException;
  63 import java.io.OutputStream;
  64 import java.lang.reflect.Field;
  65 import java.nio.ByteBuffer;
  66 import java.util.ArrayList;
  67 import java.util.Arrays;
  68 import java.util.Iterator;
  69 import java.util.List;
  70 import junit.framework.TestCase;
  71
  72 /**
  73  * Test lite runtime.
  74  *
  75  * @author kenton@google.com Kenton Varda
  76  */
  77 public class LiteTest extends TestCase {
  78   @Override
  79   public void setUp() throws Exception {
  80     // Test that nested extensions are initialized correctly even if the outer
  81     // class has not been accessed directly.  This was once a bug with lite
  82     // messages.
  83     //
  84     // We put this in setUp() rather than in its own test method because we
  85     // need to make sure it runs before any actual tests.
  86     assertNotNull(TestNestedExtensionLite.nestedExtension);
  87   }
  88
  89   public void testLite() throws Exception {
  90     // Since lite messages are a subset of regular messages, we can mostly
  91     // assume that the functionality of lite messages is already thoroughly
  92     // tested by the regular tests.  All this test really verifies is that
  93     // a proto with optimize_for = LITE_RUNTIME compiles correctly when
  94     // linked only against the lite library.  That is all tested at compile
  95     // time, leaving not much to do in this method.  Let's just do some random
  96     // stuff to make sure the lite message is actually here and usable.
  97
  98     TestAllTypesLite message =
  99         TestAllTypesLite.newBuilder()
 100             .setOptionalInt32(123)
 101             .addRepeatedString("hello")
 102             .setOptionalNestedMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(7))
 103             .build();
 104
 105     ByteString data = message.toByteString();
 106
 107     TestAllTypesLite message2 = TestAllTypesLite.parseFrom(data);
 108
 109     assertEquals(123, message2.getOptionalInt32());
 110     assertEquals(1, message2.getRepeatedStringCount());
 111     assertEquals("hello", message2.getRepeatedString(0));
 112     assertEquals(7, message2.getOptionalNestedMessage().getBb());
 113   }
 114
 115   public void testLite_unknownEnumAtListBoundary() throws Exception {
 116     ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
 117     CodedOutputStream output = CodedOutputStream.newInstance(byteStream);
 118     for (int i = 0; i < AbstractProtobufList.DEFAULT_CAPACITY; i++) {
 119       output.writeInt32(TestAllTypesLite.REPEATED_NESTED_ENUM_FIELD_NUMBER, 1);
 120     }
 121     // 0 is not a valid enum value for NestedEnum
 122     output.writeInt32(TestAllTypesLite.REPEATED_NESTED_ENUM_FIELD_NUMBER, 0);
 123     output.flush();
 124     // This tests a bug we had once with removal right at the boundary of the array. It would throw
 125     // at runtime so no need to assert.
 126     TestAllTypesLite.parseFrom(new ByteArrayInputStream(byteStream.toByteArray()));
 127   }
 128
 129   public void testLiteExtensions() throws Exception {
 130     // TODO(kenton):  Unlike other features of the lite library, extensions are
 131     //   implemented completely differently from the regular library.  We
 132     //   should probably test them more thoroughly.
 133
 134     TestAllExtensionsLite message =
 135         TestAllExtensionsLite.newBuilder()
 136             .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
 137             .addExtension(UnittestLite.repeatedStringExtensionLite, "hello")
 138             .setExtension(
 139                 UnittestLite.optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ)
 140             .setExtension(
 141                 UnittestLite.optionalNestedMessageExtensionLite,
 142                 TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build())
 143             .build();
 144
 145     // Test copying a message, since coping extensions actually does use a
 146     // different code path between lite and regular libraries, and as of this
 147     // writing, parsing hasn't been implemented yet.
 148     TestAllExtensionsLite message2 = message.toBuilder().build();
 149
 150     assertEquals(123, (int) message2.getExtension(UnittestLite.optionalInt32ExtensionLite));
 151     assertEquals(1, message2.getExtensionCount(UnittestLite.repeatedStringExtensionLite));
 152     assertEquals(1, message2.getExtension(UnittestLite.repeatedStringExtensionLite).size());
 153     assertEquals("hello", message2.getExtension(UnittestLite.repeatedStringExtensionLite, 0));
 154     assertEquals(
 155         TestAllTypesLite.NestedEnum.BAZ,
 156         message2.getExtension(UnittestLite.optionalNestedEnumExtensionLite));
 157     assertEquals(7, message2.getExtension(UnittestLite.optionalNestedMessageExtensionLite).getBb());
 158   }
 159
 160   public void testClone() {
 161     TestAllTypesLite.Builder expected = TestAllTypesLite.newBuilder().setOptionalInt32(123);
 162     assertEquals(expected.getOptionalInt32(), expected.clone().getOptionalInt32());
 163
 164     TestAllExtensionsLite.Builder expected2 =
 165         TestAllExtensionsLite.newBuilder()
 166             .setExtension(UnittestLite.optionalInt32ExtensionLite, 123);
 167     assertEquals(
 168         expected2.getExtension(UnittestLite.optionalInt32ExtensionLite),
 169         expected2.clone().getExtension(UnittestLite.optionalInt32ExtensionLite));
 170   }
 171
 172   public void testAddAll() {
 173     try {
 174       TestAllTypesLite.newBuilder().addAllRepeatedBytes(null);
 175       fail();
 176     } catch (NullPointerException e) {
 177       // expected.
 178     }
 179   }
 180
 181   public void testMemoization() throws Exception {
 182     TestAllExtensionsLite message = TestUtilLite.getAllLiteExtensionsSet();
 183
 184     // Test serialized size is memoized
 185     message.memoizedSerializedSize = -1;
 186     int size = message.getSerializedSize();
 187     assertTrue(size > 0);
 188     assertEquals(size, message.memoizedSerializedSize);
 189
 190     // Test hashCode is memoized
 191     assertEquals(0, message.memoizedHashCode);
 192     int hashCode = message.hashCode();
 193     assertTrue(hashCode != 0);
 194     assertEquals(hashCode, message.memoizedHashCode);
 195
 196     // Test isInitialized is memoized
 197     Field memo = message.getClass().getDeclaredField("memoizedIsInitialized");
 198     memo.setAccessible(true);
 199     memo.set(message, (byte) -1);
 200     boolean initialized = message.isInitialized();
 201     assertTrue(initialized);
 202     // We have to cast to Byte first. Casting to byte causes a type error
 203     assertEquals(1, ((Byte) memo.get(message)).intValue());
 204   }
 205
 206   public void testSanityCopyOnWrite() throws InvalidProtocolBufferException {
 207     // Since builders are implemented as a thin wrapper around a message
 208     // instance, we attempt to verify that we can't cause the builder to modify
 209     // a produced message.
 210
 211     TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder();
 212     TestAllTypesLite message = builder.build();
 213     TestAllTypesLite messageAfterBuild;
 214     builder.setOptionalBool(true);
 215     assertEquals(false, message.getOptionalBool());
 216     assertEquals(true, builder.getOptionalBool());
 217     messageAfterBuild = builder.build();
 218     assertEquals(true, messageAfterBuild.getOptionalBool());
 219     assertEquals(false, message.getOptionalBool());
 220     builder.clearOptionalBool();
 221     assertEquals(false, builder.getOptionalBool());
 222     assertEquals(true, messageAfterBuild.getOptionalBool());
 223
 224     message = builder.build();
 225     builder.setOptionalBytes(ByteString.copyFromUtf8("hi"));
 226     assertEquals(ByteString.EMPTY, message.getOptionalBytes());
 227     assertEquals(ByteString.copyFromUtf8("hi"), builder.getOptionalBytes());
 228     messageAfterBuild = builder.build();
 229     assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getOptionalBytes());
 230     assertEquals(ByteString.EMPTY, message.getOptionalBytes());
 231     builder.clearOptionalBytes();
 232     assertEquals(ByteString.EMPTY, builder.getOptionalBytes());
 233     assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getOptionalBytes());
 234
 235     message = builder.build();
 236     builder.setOptionalCord("hi");
 237     assertEquals("", message.getOptionalCord());
 238     assertEquals("hi", builder.getOptionalCord());
 239     messageAfterBuild = builder.build();
 240     assertEquals("hi", messageAfterBuild.getOptionalCord());
 241     assertEquals("", message.getOptionalCord());
 242     builder.clearOptionalCord();
 243     assertEquals("", builder.getOptionalCord());
 244     assertEquals("hi", messageAfterBuild.getOptionalCord());
 245
 246     message = builder.build();
 247     builder.setOptionalCordBytes(ByteString.copyFromUtf8("no"));
 248     assertEquals(ByteString.EMPTY, message.getOptionalCordBytes());
 249     assertEquals(ByteString.copyFromUtf8("no"), builder.getOptionalCordBytes());
 250     messageAfterBuild = builder.build();
 251     assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalCordBytes());
 252     assertEquals(ByteString.EMPTY, message.getOptionalCordBytes());
 253     builder.clearOptionalCord();
 254     assertEquals(ByteString.EMPTY, builder.getOptionalCordBytes());
 255     assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalCordBytes());
 256
 257     message = builder.build();
 258     builder.setOptionalDouble(1);
 259     assertEquals(0D, message.getOptionalDouble(), 0.0);
 260     assertEquals(1D, builder.getOptionalDouble(), 0.0);
 261     messageAfterBuild = builder.build();
 262     assertEquals(1D, messageAfterBuild.getOptionalDouble(), 0.0);
 263     assertEquals(0D, message.getOptionalDouble(), 0.0);
 264     builder.clearOptionalDouble();
 265     assertEquals(0D, builder.getOptionalDouble(), 0.0);
 266     assertEquals(1D, messageAfterBuild.getOptionalDouble(), 0.0);
 267
 268     message = builder.build();
 269     builder.setOptionalFixed32(1);
 270     assertEquals(0, message.getOptionalFixed32());
 271     assertEquals(1, builder.getOptionalFixed32());
 272     messageAfterBuild = builder.build();
 273     assertEquals(1, messageAfterBuild.getOptionalFixed32());
 274     assertEquals(0, message.getOptionalFixed32());
 275     builder.clearOptionalFixed32();
 276     assertEquals(0, builder.getOptionalFixed32());
 277     assertEquals(1, messageAfterBuild.getOptionalFixed32());
 278
 279     message = builder.build();
 280     builder.setOptionalFixed64(1);
 281     assertEquals(0L, message.getOptionalFixed64());
 282     assertEquals(1L, builder.getOptionalFixed64());
 283     messageAfterBuild = builder.build();
 284     assertEquals(1L, messageAfterBuild.getOptionalFixed64());
 285     assertEquals(0L, message.getOptionalFixed64());
 286     builder.clearOptionalFixed64();
 287     assertEquals(0L, builder.getOptionalFixed64());
 288     assertEquals(1L, messageAfterBuild.getOptionalFixed64());
 289
 290     message = builder.build();
 291     builder.setOptionalFloat(1);
 292     assertEquals(0F, message.getOptionalFloat(), 0.0f);
 293     assertEquals(1F, builder.getOptionalFloat(), 0.0f);
 294     messageAfterBuild = builder.build();
 295     assertEquals(1F, messageAfterBuild.getOptionalFloat(), 0.0f);
 296     assertEquals(0F, message.getOptionalFloat(), 0.0f);
 297     builder.clearOptionalFloat();
 298     assertEquals(0F, builder.getOptionalFloat(), 0.0f);
 299     assertEquals(1F, messageAfterBuild.getOptionalFloat(), 0.0f);
 300
 301     message = builder.build();
 302     builder.setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
 303     assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, message.getOptionalForeignEnum());
 304     assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, builder.getOptionalForeignEnum());
 305     messageAfterBuild = builder.build();
 306     assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, messageAfterBuild.getOptionalForeignEnum());
 307     assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, message.getOptionalForeignEnum());
 308     builder.clearOptionalForeignEnum();
 309     assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, builder.getOptionalForeignEnum());
 310     assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, messageAfterBuild.getOptionalForeignEnum());
 311
 312     message = builder.build();
 313     ForeignMessageLite foreignMessage = ForeignMessageLite.newBuilder().setC(1).build();
 314     builder.setOptionalForeignMessage(foreignMessage);
 315     assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage());
 316     assertEquals(foreignMessage, builder.getOptionalForeignMessage());
 317     messageAfterBuild = builder.build();
 318     assertEquals(foreignMessage, messageAfterBuild.getOptionalForeignMessage());
 319     assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage());
 320     builder.clearOptionalForeignMessage();
 321     assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getOptionalForeignMessage());
 322     assertEquals(foreignMessage, messageAfterBuild.getOptionalForeignMessage());
 323
 324     message = builder.build();
 325     ForeignMessageLite foreignMessageC3 = ForeignMessageLite.newBuilder().setC(3).build();
 326     builder.setOptionalForeignMessage(foreignMessageC3);
 327     assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage());
 328     assertEquals(foreignMessageC3, builder.getOptionalForeignMessage());
 329     messageAfterBuild = builder.build();
 330     assertEquals(foreignMessageC3, messageAfterBuild.getOptionalForeignMessage());
 331     assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage());
 332     builder.clearOptionalForeignMessage();
 333     assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getOptionalForeignMessage());
 334     assertEquals(foreignMessageC3, messageAfterBuild.getOptionalForeignMessage());
 335
 336     message = builder.build();
 337     OptionalGroup optionalGroup = OptionalGroup.newBuilder().setA(1).build();
 338     builder.setOptionalGroup(optionalGroup);
 339     assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup());
 340     assertEquals(optionalGroup, builder.getOptionalGroup());
 341     messageAfterBuild = builder.build();
 342     assertEquals(optionalGroup, messageAfterBuild.getOptionalGroup());
 343     assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup());
 344     builder.clearOptionalGroup();
 345     assertEquals(OptionalGroup.getDefaultInstance(), builder.getOptionalGroup());
 346     assertEquals(optionalGroup, messageAfterBuild.getOptionalGroup());
 347
 348     message = builder.build();
 349     OptionalGroup.Builder optionalGroupBuilder = OptionalGroup.newBuilder().setA(3);
 350     builder.setOptionalGroup(optionalGroupBuilder);
 351     assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup());
 352     assertEquals(optionalGroupBuilder.build(), builder.getOptionalGroup());
 353     messageAfterBuild = builder.build();
 354     assertEquals(optionalGroupBuilder.build(), messageAfterBuild.getOptionalGroup());
 355     assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup());
 356     builder.clearOptionalGroup();
 357     assertEquals(OptionalGroup.getDefaultInstance(), builder.getOptionalGroup());
 358     assertEquals(optionalGroupBuilder.build(), messageAfterBuild.getOptionalGroup());
 359
 360     message = builder.build();
 361     builder.setOptionalInt32(1);
 362     assertEquals(0, message.getOptionalInt32());
 363     assertEquals(1, builder.getOptionalInt32());
 364     messageAfterBuild = builder.build();
 365     assertEquals(1, messageAfterBuild.getOptionalInt32());
 366     assertEquals(0, message.getOptionalInt32());
 367     builder.clearOptionalInt32();
 368     assertEquals(0, builder.getOptionalInt32());
 369     assertEquals(1, messageAfterBuild.getOptionalInt32());
 370
 371     message = builder.build();
 372     builder.setOptionalInt64(1);
 373     assertEquals(0L, message.getOptionalInt64());
 374     assertEquals(1L, builder.getOptionalInt64());
 375     messageAfterBuild = builder.build();
 376     assertEquals(1L, messageAfterBuild.getOptionalInt64());
 377     assertEquals(0L, message.getOptionalInt64());
 378     builder.clearOptionalInt64();
 379     assertEquals(0L, builder.getOptionalInt64());
 380     assertEquals(1L, messageAfterBuild.getOptionalInt64());
 381
 382     message = builder.build();
 383     NestedMessage nestedMessage = NestedMessage.newBuilder().setBb(1).build();
 384     builder.setOptionalLazyMessage(nestedMessage);
 385     assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage());
 386     assertEquals(nestedMessage, builder.getOptionalLazyMessage());
 387     messageAfterBuild = builder.build();
 388     assertEquals(nestedMessage, messageAfterBuild.getOptionalLazyMessage());
 389     assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage());
 390     builder.clearOptionalLazyMessage();
 391     assertEquals(NestedMessage.getDefaultInstance(), builder.getOptionalLazyMessage());
 392     assertEquals(nestedMessage, messageAfterBuild.getOptionalLazyMessage());
 393
 394     message = builder.build();
 395     NestedMessage.Builder nestedMessageBuilder = NestedMessage.newBuilder().setBb(3);
 396     builder.setOptionalLazyMessage(nestedMessageBuilder);
 397     assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage());
 398     assertEquals(nestedMessageBuilder.build(), builder.getOptionalLazyMessage());
 399     messageAfterBuild = builder.build();
 400     assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getOptionalLazyMessage());
 401     assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage());
 402     builder.clearOptionalLazyMessage();
 403     assertEquals(NestedMessage.getDefaultInstance(), builder.getOptionalLazyMessage());
 404     assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getOptionalLazyMessage());
 405
 406     message = builder.build();
 407     builder.setOptionalSfixed32(1);
 408     assertEquals(0, message.getOptionalSfixed32());
 409     assertEquals(1, builder.getOptionalSfixed32());
 410     messageAfterBuild = builder.build();
 411     assertEquals(1, messageAfterBuild.getOptionalSfixed32());
 412     assertEquals(0, message.getOptionalSfixed32());
 413     builder.clearOptionalSfixed32();
 414     assertEquals(0, builder.getOptionalSfixed32());
 415     assertEquals(1, messageAfterBuild.getOptionalSfixed32());
 416
 417     message = builder.build();
 418     builder.setOptionalSfixed64(1);
 419     assertEquals(0L, message.getOptionalSfixed64());
 420     assertEquals(1L, builder.getOptionalSfixed64());
 421     messageAfterBuild = builder.build();
 422     assertEquals(1L, messageAfterBuild.getOptionalSfixed64());
 423     assertEquals(0L, message.getOptionalSfixed64());
 424     builder.clearOptionalSfixed64();
 425     assertEquals(0L, builder.getOptionalSfixed64());
 426     assertEquals(1L, messageAfterBuild.getOptionalSfixed64());
 427
 428     message = builder.build();
 429     builder.setOptionalSint32(1);
 430     assertEquals(0, message.getOptionalSint32());
 431     assertEquals(1, builder.getOptionalSint32());
 432     messageAfterBuild = builder.build();
 433     assertEquals(1, messageAfterBuild.getOptionalSint32());
 434     builder.clearOptionalSint32();
 435     assertEquals(0, builder.getOptionalSint32());
 436     assertEquals(1, messageAfterBuild.getOptionalSint32());
 437
 438     message = builder.build();
 439     builder.setOptionalSint64(1);
 440     assertEquals(0L, message.getOptionalSint64());
 441     assertEquals(1L, builder.getOptionalSint64());
 442     messageAfterBuild = builder.build();
 443     assertEquals(1L, messageAfterBuild.getOptionalSint64());
 444     assertEquals(0L, message.getOptionalSint64());
 445     builder.clearOptionalSint64();
 446     assertEquals(0L, builder.getOptionalSint64());
 447     assertEquals(1L, messageAfterBuild.getOptionalSint64());
 448
 449     message = builder.build();
 450     builder.setOptionalString("hi");
 451     assertEquals("", message.getOptionalString());
 452     assertEquals("hi", builder.getOptionalString());
 453     messageAfterBuild = builder.build();
 454     assertEquals("hi", messageAfterBuild.getOptionalString());
 455     assertEquals("", message.getOptionalString());
 456     builder.clearOptionalString();
 457     assertEquals("", builder.getOptionalString());
 458     assertEquals("hi", messageAfterBuild.getOptionalString());
 459
 460     message = builder.build();
 461     builder.setOptionalStringBytes(ByteString.copyFromUtf8("no"));
 462     assertEquals(ByteString.EMPTY, message.getOptionalStringBytes());
 463     assertEquals(ByteString.copyFromUtf8("no"), builder.getOptionalStringBytes());
 464     messageAfterBuild = builder.build();
 465     assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringBytes());
 466     assertEquals(ByteString.EMPTY, message.getOptionalStringBytes());
 467     builder.clearOptionalString();
 468     assertEquals(ByteString.EMPTY, builder.getOptionalStringBytes());
 469     assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringBytes());
 470
 471     message = builder.build();
 472     builder.setOptionalStringPiece("hi");
 473     assertEquals("", message.getOptionalStringPiece());
 474     assertEquals("hi", builder.getOptionalStringPiece());
 475     messageAfterBuild = builder.build();
 476     assertEquals("hi", messageAfterBuild.getOptionalStringPiece());
 477     assertEquals("", message.getOptionalStringPiece());
 478     builder.clearOptionalStringPiece();
 479     assertEquals("", builder.getOptionalStringPiece());
 480     assertEquals("hi", messageAfterBuild.getOptionalStringPiece());
 481
 482     message = builder.build();
 483     builder.setOptionalStringPieceBytes(ByteString.copyFromUtf8("no"));
 484     assertEquals(ByteString.EMPTY, message.getOptionalStringPieceBytes());
 485     assertEquals(ByteString.copyFromUtf8("no"), builder.getOptionalStringPieceBytes());
 486     messageAfterBuild = builder.build();
 487     assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringPieceBytes());
 488     assertEquals(ByteString.EMPTY, message.getOptionalStringPieceBytes());
 489     builder.clearOptionalStringPiece();
 490     assertEquals(ByteString.EMPTY, builder.getOptionalStringPieceBytes());
 491     assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringPieceBytes());
 492
 493     message = builder.build();
 494     builder.setOptionalUint32(1);
 495     assertEquals(0, message.getOptionalUint32());
 496     assertEquals(1, builder.getOptionalUint32());
 497     messageAfterBuild = builder.build();
 498     assertEquals(1, messageAfterBuild.getOptionalUint32());
 499     assertEquals(0, message.getOptionalUint32());
 500     builder.clearOptionalUint32();
 501     assertEquals(0, builder.getOptionalUint32());
 502     assertEquals(1, messageAfterBuild.getOptionalUint32());
 503
 504     message = builder.build();
 505     builder.setOptionalUint64(1);
 506     assertEquals(0L, message.getOptionalUint64());
 507     assertEquals(1L, builder.getOptionalUint64());
 508     messageAfterBuild = builder.build();
 509     assertEquals(1L, messageAfterBuild.getOptionalUint64());
 510     assertEquals(0L, message.getOptionalUint64());
 511     builder.clearOptionalUint64();
 512     assertEquals(0L, builder.getOptionalUint64());
 513     assertEquals(1L, messageAfterBuild.getOptionalUint64());
 514
 515     message = builder.build();
 516     builder.addAllRepeatedBool(singletonList(true));
 517     assertEquals(emptyList(), message.getRepeatedBoolList());
 518     assertEquals(singletonList(true), builder.getRepeatedBoolList());
 519     assertEquals(emptyList(), message.getRepeatedBoolList());
 520     messageAfterBuild = builder.build();
 521     builder.clearRepeatedBool();
 522     assertEquals(emptyList(), builder.getRepeatedBoolList());
 523     assertEquals(singletonList(true), messageAfterBuild.getRepeatedBoolList());
 524
 525     message = builder.build();
 526     builder.addAllRepeatedBytes(singletonList(ByteString.copyFromUtf8("hi")));
 527     assertEquals(emptyList(), message.getRepeatedBytesList());
 528     assertEquals(singletonList(ByteString.copyFromUtf8("hi")), builder.getRepeatedBytesList());
 529     assertEquals(emptyList(), message.getRepeatedBytesList());
 530     messageAfterBuild = builder.build();
 531     builder.clearRepeatedBytes();
 532     assertEquals(emptyList(), builder.getRepeatedBytesList());
 533     assertEquals(
 534         singletonList(ByteString.copyFromUtf8("hi")), messageAfterBuild.getRepeatedBytesList());
 535
 536     message = builder.build();
 537     builder.addAllRepeatedCord(singletonList("hi"));
 538     assertEquals(emptyList(), message.getRepeatedCordList());
 539     assertEquals(singletonList("hi"), builder.getRepeatedCordList());
 540     assertEquals(emptyList(), message.getRepeatedCordList());
 541     messageAfterBuild = builder.build();
 542     builder.clearRepeatedCord();
 543     assertEquals(emptyList(), builder.getRepeatedCordList());
 544     assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedCordList());
 545
 546     message = builder.build();
 547     builder.addAllRepeatedDouble(singletonList(1D));
 548     assertEquals(emptyList(), message.getRepeatedDoubleList());
 549     assertEquals(singletonList(1D), builder.getRepeatedDoubleList());
 550     assertEquals(emptyList(), message.getRepeatedDoubleList());
 551     messageAfterBuild = builder.build();
 552     builder.clearRepeatedDouble();
 553     assertEquals(emptyList(), builder.getRepeatedDoubleList());
 554     assertEquals(singletonList(1D), messageAfterBuild.getRepeatedDoubleList());
 555
 556     message = builder.build();
 557     builder.addAllRepeatedFixed32(singletonList(1));
 558     assertEquals(emptyList(), message.getRepeatedFixed32List());
 559     assertEquals(singletonList(1), builder.getRepeatedFixed32List());
 560     assertEquals(emptyList(), message.getRepeatedFixed32List());
 561     messageAfterBuild = builder.build();
 562     builder.clearRepeatedFixed32();
 563     assertEquals(emptyList(), builder.getRepeatedFixed32List());
 564     assertEquals(singletonList(1), messageAfterBuild.getRepeatedFixed32List());
 565
 566     message = builder.build();
 567     builder.addAllRepeatedFixed64(singletonList(1L));
 568     assertEquals(emptyList(), message.getRepeatedFixed64List());
 569     assertEquals(singletonList(1L), builder.getRepeatedFixed64List());
 570     assertEquals(emptyList(), message.getRepeatedFixed64List());
 571     messageAfterBuild = builder.build();
 572     builder.clearRepeatedFixed64();
 573     assertEquals(emptyList(), builder.getRepeatedFixed64List());
 574     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedFixed64List());
 575
 576     message = builder.build();
 577     builder.addAllRepeatedFloat(singletonList(1F));
 578     assertEquals(emptyList(), message.getRepeatedFloatList());
 579     assertEquals(singletonList(1F), builder.getRepeatedFloatList());
 580     assertEquals(emptyList(), message.getRepeatedFloatList());
 581     messageAfterBuild = builder.build();
 582     builder.clearRepeatedFloat();
 583     assertEquals(emptyList(), builder.getRepeatedFloatList());
 584     assertEquals(singletonList(1F), messageAfterBuild.getRepeatedFloatList());
 585
 586     message = builder.build();
 587     builder.addAllRepeatedForeignEnum(singletonList(ForeignEnumLite.FOREIGN_LITE_BAR));
 588     assertEquals(emptyList(), message.getRepeatedForeignEnumList());
 589     assertEquals(
 590         singletonList(ForeignEnumLite.FOREIGN_LITE_BAR), builder.getRepeatedForeignEnumList());
 591     assertEquals(emptyList(), message.getRepeatedForeignEnumList());
 592     messageAfterBuild = builder.build();
 593     builder.clearRepeatedForeignEnum();
 594     assertEquals(emptyList(), builder.getRepeatedForeignEnumList());
 595     assertEquals(
 596         singletonList(ForeignEnumLite.FOREIGN_LITE_BAR),
 597         messageAfterBuild.getRepeatedForeignEnumList());
 598
 599     message = builder.build();
 600     builder.addAllRepeatedForeignMessage(singletonList(foreignMessage));
 601     assertEquals(emptyList(), message.getRepeatedForeignMessageList());
 602     assertEquals(singletonList(foreignMessage), builder.getRepeatedForeignMessageList());
 603     assertEquals(emptyList(), message.getRepeatedForeignMessageList());
 604     messageAfterBuild = builder.build();
 605     builder.clearRepeatedForeignMessage();
 606     assertEquals(emptyList(), builder.getRepeatedForeignMessageList());
 607     assertEquals(singletonList(foreignMessage), messageAfterBuild.getRepeatedForeignMessageList());
 608
 609     message = builder.build();
 610     builder.addAllRepeatedGroup(singletonList(RepeatedGroup.getDefaultInstance()));
 611     assertEquals(emptyList(), message.getRepeatedGroupList());
 612     assertEquals(singletonList(RepeatedGroup.getDefaultInstance()), builder.getRepeatedGroupList());
 613     assertEquals(emptyList(), message.getRepeatedGroupList());
 614     messageAfterBuild = builder.build();
 615     builder.clearRepeatedGroup();
 616     assertEquals(emptyList(), builder.getRepeatedGroupList());
 617     assertEquals(
 618         singletonList(RepeatedGroup.getDefaultInstance()),
 619         messageAfterBuild.getRepeatedGroupList());
 620
 621     message = builder.build();
 622     builder.addAllRepeatedInt32(singletonList(1));
 623     assertEquals(emptyList(), message.getRepeatedInt32List());
 624     assertEquals(singletonList(1), builder.getRepeatedInt32List());
 625     assertEquals(emptyList(), message.getRepeatedInt32List());
 626     messageAfterBuild = builder.build();
 627     builder.clearRepeatedInt32();
 628     assertEquals(emptyList(), builder.getRepeatedInt32List());
 629     assertEquals(singletonList(1), messageAfterBuild.getRepeatedInt32List());
 630
 631     message = builder.build();
 632     builder.addAllRepeatedInt64(singletonList(1L));
 633     assertEquals(emptyList(), message.getRepeatedInt64List());
 634     assertEquals(singletonList(1L), builder.getRepeatedInt64List());
 635     assertEquals(emptyList(), message.getRepeatedInt64List());
 636     messageAfterBuild = builder.build();
 637     builder.clearRepeatedInt64();
 638     assertEquals(emptyList(), builder.getRepeatedInt64List());
 639     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedInt64List());
 640
 641     message = builder.build();
 642     builder.addAllRepeatedLazyMessage(singletonList(nestedMessage));
 643     assertEquals(emptyList(), message.getRepeatedLazyMessageList());
 644     assertEquals(singletonList(nestedMessage), builder.getRepeatedLazyMessageList());
 645     assertEquals(emptyList(), message.getRepeatedLazyMessageList());
 646     messageAfterBuild = builder.build();
 647     builder.clearRepeatedLazyMessage();
 648     assertEquals(emptyList(), builder.getRepeatedLazyMessageList());
 649     assertEquals(singletonList(nestedMessage), messageAfterBuild.getRepeatedLazyMessageList());
 650
 651     message = builder.build();
 652     builder.addAllRepeatedSfixed32(singletonList(1));
 653     assertEquals(emptyList(), message.getRepeatedSfixed32List());
 654     assertEquals(singletonList(1), builder.getRepeatedSfixed32List());
 655     assertEquals(emptyList(), message.getRepeatedSfixed32List());
 656     messageAfterBuild = builder.build();
 657     builder.clearRepeatedSfixed32();
 658     assertEquals(emptyList(), builder.getRepeatedSfixed32List());
 659     assertEquals(singletonList(1), messageAfterBuild.getRepeatedSfixed32List());
 660
 661     message = builder.build();
 662     builder.addAllRepeatedSfixed64(singletonList(1L));
 663     assertEquals(emptyList(), message.getRepeatedSfixed64List());
 664     assertEquals(singletonList(1L), builder.getRepeatedSfixed64List());
 665     assertEquals(emptyList(), message.getRepeatedSfixed64List());
 666     messageAfterBuild = builder.build();
 667     builder.clearRepeatedSfixed64();
 668     assertEquals(emptyList(), builder.getRepeatedSfixed64List());
 669     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSfixed64List());
 670
 671     message = builder.build();
 672     builder.addAllRepeatedSint32(singletonList(1));
 673     assertEquals(emptyList(), message.getRepeatedSint32List());
 674     assertEquals(singletonList(1), builder.getRepeatedSint32List());
 675     assertEquals(emptyList(), message.getRepeatedSint32List());
 676     messageAfterBuild = builder.build();
 677     builder.clearRepeatedSint32();
 678     assertEquals(emptyList(), builder.getRepeatedSint32List());
 679     assertEquals(singletonList(1), messageAfterBuild.getRepeatedSint32List());
 680
 681     message = builder.build();
 682     builder.addAllRepeatedSint64(singletonList(1L));
 683     assertEquals(emptyList(), message.getRepeatedSint64List());
 684     assertEquals(singletonList(1L), builder.getRepeatedSint64List());
 685     assertEquals(emptyList(), message.getRepeatedSint64List());
 686     messageAfterBuild = builder.build();
 687     builder.clearRepeatedSint64();
 688     assertEquals(emptyList(), builder.getRepeatedSint64List());
 689     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSint64List());
 690
 691     message = builder.build();
 692     builder.addAllRepeatedString(singletonList("hi"));
 693     assertEquals(emptyList(), message.getRepeatedStringList());
 694     assertEquals(singletonList("hi"), builder.getRepeatedStringList());
 695     assertEquals(emptyList(), message.getRepeatedStringList());
 696     messageAfterBuild = builder.build();
 697     builder.clearRepeatedString();
 698     assertEquals(emptyList(), builder.getRepeatedStringList());
 699     assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringList());
 700
 701     message = builder.build();
 702     builder.addAllRepeatedStringPiece(singletonList("hi"));
 703     assertEquals(emptyList(), message.getRepeatedStringPieceList());
 704     assertEquals(singletonList("hi"), builder.getRepeatedStringPieceList());
 705     assertEquals(emptyList(), message.getRepeatedStringPieceList());
 706     messageAfterBuild = builder.build();
 707     builder.clearRepeatedStringPiece();
 708     assertEquals(emptyList(), builder.getRepeatedStringPieceList());
 709     assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringPieceList());
 710
 711     message = builder.build();
 712     builder.addAllRepeatedUint32(singletonList(1));
 713     assertEquals(emptyList(), message.getRepeatedUint32List());
 714     assertEquals(singletonList(1), builder.getRepeatedUint32List());
 715     assertEquals(emptyList(), message.getRepeatedUint32List());
 716     messageAfterBuild = builder.build();
 717     builder.clearRepeatedUint32();
 718     assertEquals(emptyList(), builder.getRepeatedUint32List());
 719     assertEquals(singletonList(1), messageAfterBuild.getRepeatedUint32List());
 720
 721     message = builder.build();
 722     builder.addAllRepeatedUint64(singletonList(1L));
 723     assertEquals(emptyList(), message.getRepeatedUint64List());
 724     assertEquals(singletonList(1L), builder.getRepeatedUint64List());
 725     assertEquals(emptyList(), message.getRepeatedUint64List());
 726     messageAfterBuild = builder.build();
 727     builder.clearRepeatedUint64();
 728     assertEquals(emptyList(), builder.getRepeatedUint64List());
 729     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedUint64List());
 730
 731     message = builder.build();
 732     builder.addRepeatedBool(true);
 733     assertEquals(emptyList(), message.getRepeatedBoolList());
 734     assertEquals(singletonList(true), builder.getRepeatedBoolList());
 735     assertEquals(emptyList(), message.getRepeatedBoolList());
 736     messageAfterBuild = builder.build();
 737     builder.clearRepeatedBool();
 738     assertEquals(emptyList(), builder.getRepeatedBoolList());
 739     assertEquals(singletonList(true), messageAfterBuild.getRepeatedBoolList());
 740
 741     message = builder.build();
 742     builder.addRepeatedBytes(ByteString.copyFromUtf8("hi"));
 743     assertEquals(emptyList(), message.getRepeatedBytesList());
 744     assertEquals(singletonList(ByteString.copyFromUtf8("hi")), builder.getRepeatedBytesList());
 745     assertEquals(emptyList(), message.getRepeatedBytesList());
 746     messageAfterBuild = builder.build();
 747     builder.clearRepeatedBytes();
 748     assertEquals(emptyList(), builder.getRepeatedBytesList());
 749     assertEquals(
 750         singletonList(ByteString.copyFromUtf8("hi")), messageAfterBuild.getRepeatedBytesList());
 751
 752     message = builder.build();
 753     builder.addRepeatedCord("hi");
 754     assertEquals(emptyList(), message.getRepeatedCordList());
 755     assertEquals(singletonList("hi"), builder.getRepeatedCordList());
 756     assertEquals(emptyList(), message.getRepeatedCordList());
 757     messageAfterBuild = builder.build();
 758     builder.clearRepeatedCord();
 759     assertEquals(emptyList(), builder.getRepeatedCordList());
 760     assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedCordList());
 761
 762     message = builder.build();
 763     builder.addRepeatedDouble(1D);
 764     assertEquals(emptyList(), message.getRepeatedDoubleList());
 765     assertEquals(singletonList(1D), builder.getRepeatedDoubleList());
 766     assertEquals(emptyList(), message.getRepeatedDoubleList());
 767     messageAfterBuild = builder.build();
 768     builder.clearRepeatedDouble();
 769     assertEquals(emptyList(), builder.getRepeatedDoubleList());
 770     assertEquals(singletonList(1D), messageAfterBuild.getRepeatedDoubleList());
 771
 772     message = builder.build();
 773     builder.addRepeatedFixed32(1);
 774     assertEquals(emptyList(), message.getRepeatedFixed32List());
 775     assertEquals(singletonList(1), builder.getRepeatedFixed32List());
 776     assertEquals(emptyList(), message.getRepeatedFixed32List());
 777     messageAfterBuild = builder.build();
 778     builder.clearRepeatedFixed32();
 779     assertEquals(emptyList(), builder.getRepeatedFixed32List());
 780     assertEquals(singletonList(1), messageAfterBuild.getRepeatedFixed32List());
 781
 782     message = builder.build();
 783     builder.addRepeatedFixed64(1L);
 784     assertEquals(emptyList(), message.getRepeatedFixed64List());
 785     assertEquals(singletonList(1L), builder.getRepeatedFixed64List());
 786     assertEquals(emptyList(), message.getRepeatedFixed64List());
 787     messageAfterBuild = builder.build();
 788     builder.clearRepeatedFixed64();
 789     assertEquals(emptyList(), builder.getRepeatedFixed64List());
 790     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedFixed64List());
 791
 792     message = builder.build();
 793     builder.addRepeatedFloat(1F);
 794     assertEquals(emptyList(), message.getRepeatedFloatList());
 795     assertEquals(singletonList(1F), builder.getRepeatedFloatList());
 796     assertEquals(emptyList(), message.getRepeatedFloatList());
 797     messageAfterBuild = builder.build();
 798     builder.clearRepeatedFloat();
 799     assertEquals(emptyList(), builder.getRepeatedFloatList());
 800     assertEquals(singletonList(1F), messageAfterBuild.getRepeatedFloatList());
 801
 802     message = builder.build();
 803     builder.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
 804     assertEquals(emptyList(), message.getRepeatedForeignEnumList());
 805     assertEquals(
 806         singletonList(ForeignEnumLite.FOREIGN_LITE_BAR), builder.getRepeatedForeignEnumList());
 807     assertEquals(emptyList(), message.getRepeatedForeignEnumList());
 808     messageAfterBuild = builder.build();
 809     builder.clearRepeatedForeignEnum();
 810     assertEquals(emptyList(), builder.getRepeatedForeignEnumList());
 811     assertEquals(
 812         singletonList(ForeignEnumLite.FOREIGN_LITE_BAR),
 813         messageAfterBuild.getRepeatedForeignEnumList());
 814
 815     message = builder.build();
 816     builder.addRepeatedForeignMessage(foreignMessage);
 817     assertEquals(emptyList(), message.getRepeatedForeignMessageList());
 818     assertEquals(singletonList(foreignMessage), builder.getRepeatedForeignMessageList());
 819     assertEquals(emptyList(), message.getRepeatedForeignMessageList());
 820     messageAfterBuild = builder.build();
 821     builder.removeRepeatedForeignMessage(0);
 822     assertEquals(emptyList(), builder.getRepeatedForeignMessageList());
 823     assertEquals(singletonList(foreignMessage), messageAfterBuild.getRepeatedForeignMessageList());
 824
 825     message = builder.build();
 826     builder.addRepeatedGroup(RepeatedGroup.getDefaultInstance());
 827     assertEquals(emptyList(), message.getRepeatedGroupList());
 828     assertEquals(singletonList(RepeatedGroup.getDefaultInstance()), builder.getRepeatedGroupList());
 829     assertEquals(emptyList(), message.getRepeatedGroupList());
 830     messageAfterBuild = builder.build();
 831     builder.removeRepeatedGroup(0);
 832     assertEquals(emptyList(), builder.getRepeatedGroupList());
 833     assertEquals(
 834         singletonList(RepeatedGroup.getDefaultInstance()),
 835         messageAfterBuild.getRepeatedGroupList());
 836
 837     message = builder.build();
 838     builder.addRepeatedInt32(1);
 839     assertEquals(emptyList(), message.getRepeatedInt32List());
 840     assertEquals(singletonList(1), builder.getRepeatedInt32List());
 841     assertEquals(emptyList(), message.getRepeatedInt32List());
 842     messageAfterBuild = builder.build();
 843     builder.clearRepeatedInt32();
 844     assertEquals(emptyList(), builder.getRepeatedInt32List());
 845     assertEquals(singletonList(1), messageAfterBuild.getRepeatedInt32List());
 846
 847     message = builder.build();
 848     builder.addRepeatedInt64(1L);
 849     assertEquals(emptyList(), message.getRepeatedInt64List());
 850     assertEquals(singletonList(1L), builder.getRepeatedInt64List());
 851     assertEquals(emptyList(), message.getRepeatedInt64List());
 852     messageAfterBuild = builder.build();
 853     builder.clearRepeatedInt64();
 854     assertEquals(emptyList(), builder.getRepeatedInt64List());
 855     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedInt64List());
 856
 857     message = builder.build();
 858     builder.addRepeatedLazyMessage(nestedMessage);
 859     assertEquals(emptyList(), message.getRepeatedLazyMessageList());
 860     assertEquals(singletonList(nestedMessage), builder.getRepeatedLazyMessageList());
 861     assertEquals(emptyList(), message.getRepeatedLazyMessageList());
 862     messageAfterBuild = builder.build();
 863     builder.removeRepeatedLazyMessage(0);
 864     assertEquals(emptyList(), builder.getRepeatedLazyMessageList());
 865     assertEquals(singletonList(nestedMessage), messageAfterBuild.getRepeatedLazyMessageList());
 866
 867     message = builder.build();
 868     builder.addRepeatedSfixed32(1);
 869     assertEquals(emptyList(), message.getRepeatedSfixed32List());
 870     assertEquals(singletonList(1), builder.getRepeatedSfixed32List());
 871     assertEquals(emptyList(), message.getRepeatedSfixed32List());
 872     messageAfterBuild = builder.build();
 873     builder.clearRepeatedSfixed32();
 874     assertEquals(emptyList(), builder.getRepeatedSfixed32List());
 875     assertEquals(singletonList(1), messageAfterBuild.getRepeatedSfixed32List());
 876
 877     message = builder.build();
 878     builder.addRepeatedSfixed64(1L);
 879     assertEquals(emptyList(), message.getRepeatedSfixed64List());
 880     assertEquals(singletonList(1L), builder.getRepeatedSfixed64List());
 881     assertEquals(emptyList(), message.getRepeatedSfixed64List());
 882     messageAfterBuild = builder.build();
 883     builder.clearRepeatedSfixed64();
 884     assertEquals(emptyList(), builder.getRepeatedSfixed64List());
 885     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSfixed64List());
 886
 887     message = builder.build();
 888     builder.addRepeatedSint32(1);
 889     assertEquals(emptyList(), message.getRepeatedSint32List());
 890     assertEquals(singletonList(1), builder.getRepeatedSint32List());
 891     assertEquals(emptyList(), message.getRepeatedSint32List());
 892     messageAfterBuild = builder.build();
 893     builder.clearRepeatedSint32();
 894     assertEquals(emptyList(), builder.getRepeatedSint32List());
 895     assertEquals(singletonList(1), messageAfterBuild.getRepeatedSint32List());
 896
 897     message = builder.build();
 898     builder.addRepeatedSint64(1L);
 899     assertEquals(emptyList(), message.getRepeatedSint64List());
 900     assertEquals(singletonList(1L), builder.getRepeatedSint64List());
 901     assertEquals(emptyList(), message.getRepeatedSint64List());
 902     messageAfterBuild = builder.build();
 903     builder.clearRepeatedSint64();
 904     assertEquals(emptyList(), builder.getRepeatedSint64List());
 905     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSint64List());
 906
 907     message = builder.build();
 908     builder.addRepeatedString("hi");
 909     assertEquals(emptyList(), message.getRepeatedStringList());
 910     assertEquals(singletonList("hi"), builder.getRepeatedStringList());
 911     assertEquals(emptyList(), message.getRepeatedStringList());
 912     messageAfterBuild = builder.build();
 913     builder.clearRepeatedString();
 914     assertEquals(emptyList(), builder.getRepeatedStringList());
 915     assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringList());
 916
 917     message = builder.build();
 918     builder.addRepeatedStringPiece("hi");
 919     assertEquals(emptyList(), message.getRepeatedStringPieceList());
 920     assertEquals(singletonList("hi"), builder.getRepeatedStringPieceList());
 921     assertEquals(emptyList(), message.getRepeatedStringPieceList());
 922     messageAfterBuild = builder.build();
 923     builder.clearRepeatedStringPiece();
 924     assertEquals(emptyList(), builder.getRepeatedStringPieceList());
 925     assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringPieceList());
 926
 927     message = builder.build();
 928     builder.addRepeatedUint32(1);
 929     assertEquals(emptyList(), message.getRepeatedUint32List());
 930     assertEquals(singletonList(1), builder.getRepeatedUint32List());
 931     assertEquals(emptyList(), message.getRepeatedUint32List());
 932     messageAfterBuild = builder.build();
 933     builder.clearRepeatedUint32();
 934     assertEquals(emptyList(), builder.getRepeatedUint32List());
 935     assertEquals(singletonList(1), messageAfterBuild.getRepeatedUint32List());
 936
 937     message = builder.build();
 938     builder.addRepeatedUint64(1L);
 939     assertEquals(emptyList(), message.getRepeatedUint64List());
 940     assertEquals(singletonList(1L), builder.getRepeatedUint64List());
 941     assertEquals(emptyList(), message.getRepeatedUint64List());
 942     messageAfterBuild = builder.build();
 943     builder.clearRepeatedUint64();
 944     assertEquals(emptyList(), builder.getRepeatedUint64List());
 945     assertEquals(singletonList(1L), messageAfterBuild.getRepeatedUint64List());
 946
 947     message = builder.build();
 948     builder.addRepeatedBool(true);
 949     messageAfterBuild = builder.build();
 950     assertEquals(0, message.getRepeatedBoolCount());
 951     builder.setRepeatedBool(0, false);
 952     assertEquals(true, messageAfterBuild.getRepeatedBool(0));
 953     assertEquals(false, builder.getRepeatedBool(0));
 954     builder.clearRepeatedBool();
 955
 956     message = builder.build();
 957     builder.addRepeatedBytes(ByteString.copyFromUtf8("hi"));
 958     messageAfterBuild = builder.build();
 959     assertEquals(0, message.getRepeatedBytesCount());
 960     builder.setRepeatedBytes(0, ByteString.EMPTY);
 961     assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedBytes(0));
 962     assertEquals(ByteString.EMPTY, builder.getRepeatedBytes(0));
 963     builder.clearRepeatedBytes();
 964
 965     message = builder.build();
 966     builder.addRepeatedCord("hi");
 967     messageAfterBuild = builder.build();
 968     assertEquals(0, message.getRepeatedCordCount());
 969     builder.setRepeatedCord(0, "");
 970     assertEquals("hi", messageAfterBuild.getRepeatedCord(0));
 971     assertEquals("", builder.getRepeatedCord(0));
 972     builder.clearRepeatedCord();
 973     message = builder.build();
 974
 975     builder.addRepeatedCordBytes(ByteString.copyFromUtf8("hi"));
 976     messageAfterBuild = builder.build();
 977     assertEquals(0, message.getRepeatedCordCount());
 978     builder.setRepeatedCord(0, "");
 979     assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedCordBytes(0));
 980     assertEquals(ByteString.EMPTY, builder.getRepeatedCordBytes(0));
 981     builder.clearRepeatedCord();
 982
 983     message = builder.build();
 984     builder.addRepeatedDouble(1D);
 985     messageAfterBuild = builder.build();
 986     assertEquals(0, message.getRepeatedDoubleCount());
 987     builder.setRepeatedDouble(0, 0D);
 988     assertEquals(1D, messageAfterBuild.getRepeatedDouble(0), 0.0);
 989     assertEquals(0D, builder.getRepeatedDouble(0), 0.0);
 990     builder.clearRepeatedDouble();
 991
 992     message = builder.build();
 993     builder.addRepeatedFixed32(1);
 994     messageAfterBuild = builder.build();
 995     assertEquals(0, message.getRepeatedFixed32Count());
 996     builder.setRepeatedFixed32(0, 0);
 997     assertEquals(1, messageAfterBuild.getRepeatedFixed32(0));
 998     assertEquals(0, builder.getRepeatedFixed32(0));
 999     builder.clearRepeatedFixed32();
1000
1001     message = builder.build();
1002     builder.addRepeatedFixed64(1L);
1003     messageAfterBuild = builder.build();
1004     assertEquals(0, message.getRepeatedFixed64Count());
1005     builder.setRepeatedFixed64(0, 0L);
1006     assertEquals(1L, messageAfterBuild.getRepeatedFixed64(0));
1007     assertEquals(0L, builder.getRepeatedFixed64(0));
1008     builder.clearRepeatedFixed64();
1009
1010     message = builder.build();
1011     builder.addRepeatedFloat(1F);
1012     messageAfterBuild = builder.build();
1013     assertEquals(0, message.getRepeatedFloatCount());
1014     builder.setRepeatedFloat(0, 0F);
1015     assertEquals(1F, messageAfterBuild.getRepeatedFloat(0), 0.0f);
1016     assertEquals(0F, builder.getRepeatedFloat(0), 0.0f);
1017     builder.clearRepeatedFloat();
1018
1019     message = builder.build();
1020     builder.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
1021     messageAfterBuild = builder.build();
1022     assertEquals(0, message.getRepeatedForeignEnumCount());
1023     builder.setRepeatedForeignEnum(0, ForeignEnumLite.FOREIGN_LITE_FOO);
1024     assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, messageAfterBuild.getRepeatedForeignEnum(0));
1025     assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, builder.getRepeatedForeignEnum(0));
1026     builder.clearRepeatedForeignEnum();
1027
1028     message = builder.build();
1029     builder.addRepeatedForeignMessage(foreignMessage);
1030     messageAfterBuild = builder.build();
1031     assertEquals(0, message.getRepeatedForeignMessageCount());
1032     builder.setRepeatedForeignMessage(0, ForeignMessageLite.getDefaultInstance());
1033     assertEquals(foreignMessage, messageAfterBuild.getRepeatedForeignMessage(0));
1034     assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getRepeatedForeignMessage(0));
1035     builder.clearRepeatedForeignMessage();
1036
1037     message = builder.build();
1038     builder.addRepeatedForeignMessage(foreignMessageC3);
1039     messageAfterBuild = builder.build();
1040     assertEquals(0, message.getRepeatedForeignMessageCount());
1041     builder.setRepeatedForeignMessage(0, ForeignMessageLite.getDefaultInstance());
1042     assertEquals(foreignMessageC3, messageAfterBuild.getRepeatedForeignMessage(0));
1043     assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getRepeatedForeignMessage(0));
1044     builder.clearRepeatedForeignMessage();
1045
1046     message = builder.build();
1047     builder.addRepeatedForeignMessage(0, foreignMessage);
1048     messageAfterBuild = builder.build();
1049     assertEquals(0, message.getRepeatedForeignMessageCount());
1050     builder.setRepeatedForeignMessage(0, foreignMessageC3);
1051     assertEquals(foreignMessage, messageAfterBuild.getRepeatedForeignMessage(0));
1052     assertEquals(foreignMessageC3, builder.getRepeatedForeignMessage(0));
1053     builder.clearRepeatedForeignMessage();
1054
1055     message = builder.build();
1056     RepeatedGroup repeatedGroup = RepeatedGroup.newBuilder().setA(1).build();
1057     builder.addRepeatedGroup(repeatedGroup);
1058     messageAfterBuild = builder.build();
1059     assertEquals(0, message.getRepeatedGroupCount());
1060     builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
1061     assertEquals(repeatedGroup, messageAfterBuild.getRepeatedGroup(0));
1062     assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0));
1063     builder.clearRepeatedGroup();
1064
1065     message = builder.build();
1066     builder.addRepeatedGroup(0, repeatedGroup);
1067     messageAfterBuild = builder.build();
1068     assertEquals(0, message.getRepeatedGroupCount());
1069     builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
1070     assertEquals(repeatedGroup, messageAfterBuild.getRepeatedGroup(0));
1071     assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0));
1072     builder.clearRepeatedGroup();
1073
1074     message = builder.build();
1075     RepeatedGroup.Builder repeatedGroupBuilder = RepeatedGroup.newBuilder().setA(3);
1076     builder.addRepeatedGroup(repeatedGroupBuilder);
1077     messageAfterBuild = builder.build();
1078     assertEquals(0, message.getRepeatedGroupCount());
1079     builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
1080     assertEquals(repeatedGroupBuilder.build(), messageAfterBuild.getRepeatedGroup(0));
1081     assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0));
1082     builder.clearRepeatedGroup();
1083
1084     message = builder.build();
1085     builder.addRepeatedGroup(0, repeatedGroupBuilder);
1086     messageAfterBuild = builder.build();
1087     assertEquals(0, message.getRepeatedGroupCount());
1088     builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
1089     assertEquals(repeatedGroupBuilder.build(), messageAfterBuild.getRepeatedGroup(0));
1090     assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0));
1091     builder.clearRepeatedGroup();
1092
1093     message = builder.build();
1094     builder.addRepeatedInt32(1);
1095     messageAfterBuild = builder.build();
1096     assertEquals(0, message.getRepeatedInt32Count());
1097     builder.setRepeatedInt32(0, 0);
1098     assertEquals(1, messageAfterBuild.getRepeatedInt32(0));
1099     assertEquals(0, builder.getRepeatedInt32(0));
1100     builder.clearRepeatedInt32();
1101
1102     message = builder.build();
1103     builder.addRepeatedInt64(1L);
1104     messageAfterBuild = builder.build();
1105     assertEquals(0L, message.getRepeatedInt64Count());
1106     builder.setRepeatedInt64(0, 0L);
1107     assertEquals(1L, messageAfterBuild.getRepeatedInt64(0));
1108     assertEquals(0L, builder.getRepeatedInt64(0));
1109     builder.clearRepeatedInt64();
1110
1111     message = builder.build();
1112     builder.addRepeatedLazyMessage(nestedMessage);
1113     messageAfterBuild = builder.build();
1114     assertEquals(0, message.getRepeatedLazyMessageCount());
1115     builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
1116     assertEquals(nestedMessage, messageAfterBuild.getRepeatedLazyMessage(0));
1117     assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0));
1118     builder.clearRepeatedLazyMessage();
1119
1120     message = builder.build();
1121     builder.addRepeatedLazyMessage(0, nestedMessage);
1122     messageAfterBuild = builder.build();
1123     assertEquals(0, message.getRepeatedLazyMessageCount());
1124     builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
1125     assertEquals(nestedMessage, messageAfterBuild.getRepeatedLazyMessage(0));
1126     assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0));
1127     builder.clearRepeatedLazyMessage();
1128
1129     message = builder.build();
1130     builder.addRepeatedLazyMessage(nestedMessageBuilder);
1131     messageAfterBuild = builder.build();
1132     assertEquals(0, message.getRepeatedLazyMessageCount());
1133     builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
1134     assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getRepeatedLazyMessage(0));
1135     assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0));
1136     builder.clearRepeatedLazyMessage();
1137
1138     message = builder.build();
1139     builder.addRepeatedLazyMessage(0, nestedMessageBuilder);
1140     messageAfterBuild = builder.build();
1141     assertEquals(0, message.getRepeatedLazyMessageCount());
1142     builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
1143     assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getRepeatedLazyMessage(0));
1144     assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0));
1145     builder.clearRepeatedLazyMessage();
1146
1147     message = builder.build();
1148     builder.addRepeatedSfixed32(1);
1149     messageAfterBuild = builder.build();
1150     assertEquals(0, message.getRepeatedSfixed32Count());
1151     builder.setRepeatedSfixed32(0, 0);
1152     assertEquals(1, messageAfterBuild.getRepeatedSfixed32(0));
1153     assertEquals(0, builder.getRepeatedSfixed32(0));
1154     builder.clearRepeatedSfixed32();
1155
1156     message = builder.build();
1157     builder.addRepeatedSfixed64(1L);
1158     messageAfterBuild = builder.build();
1159     assertEquals(0L, message.getRepeatedSfixed64Count());
1160     builder.setRepeatedSfixed64(0, 0L);
1161     assertEquals(1L, messageAfterBuild.getRepeatedSfixed64(0));
1162     assertEquals(0L, builder.getRepeatedSfixed64(0));
1163     builder.clearRepeatedSfixed64();
1164
1165     message = builder.build();
1166     builder.addRepeatedSint32(1);
1167     messageAfterBuild = builder.build();
1168     assertEquals(0, message.getRepeatedSint32Count());
1169     builder.setRepeatedSint32(0, 0);
1170     assertEquals(1, messageAfterBuild.getRepeatedSint32(0));
1171     assertEquals(0, builder.getRepeatedSint32(0));
1172     builder.clearRepeatedSint32();
1173
1174     message = builder.build();
1175     builder.addRepeatedSint64(1L);
1176     messageAfterBuild = builder.build();
1177     assertEquals(0L, message.getRepeatedSint64Count());
1178     builder.setRepeatedSint64(0, 0L);
1179     assertEquals(1L, messageAfterBuild.getRepeatedSint64(0));
1180     assertEquals(0L, builder.getRepeatedSint64(0));
1181     builder.clearRepeatedSint64();
1182
1183     message = builder.build();
1184     builder.addRepeatedString("hi");
1185     messageAfterBuild = builder.build();
1186     assertEquals(0L, message.getRepeatedStringCount());
1187     builder.setRepeatedString(0, "");
1188     assertEquals("hi", messageAfterBuild.getRepeatedString(0));
1189     assertEquals("", builder.getRepeatedString(0));
1190     builder.clearRepeatedString();
1191
1192     message = builder.build();
1193     builder.addRepeatedStringBytes(ByteString.copyFromUtf8("hi"));
1194     messageAfterBuild = builder.build();
1195     assertEquals(0L, message.getRepeatedStringCount());
1196     builder.setRepeatedString(0, "");
1197     assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedStringBytes(0));
1198     assertEquals(ByteString.EMPTY, builder.getRepeatedStringBytes(0));
1199     builder.clearRepeatedString();
1200
1201     message = builder.build();
1202     builder.addRepeatedStringPiece("hi");
1203     messageAfterBuild = builder.build();
1204     assertEquals(0L, message.getRepeatedStringPieceCount());
1205     builder.setRepeatedStringPiece(0, "");
1206     assertEquals("hi", messageAfterBuild.getRepeatedStringPiece(0));
1207     assertEquals("", builder.getRepeatedStringPiece(0));
1208     builder.clearRepeatedStringPiece();
1209
1210     message = builder.build();
1211     builder.addRepeatedStringPieceBytes(ByteString.copyFromUtf8("hi"));
1212     messageAfterBuild = builder.build();
1213     assertEquals(0L, message.getRepeatedStringPieceCount());
1214     builder.setRepeatedStringPiece(0, "");
1215     assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedStringPieceBytes(0));
1216     assertEquals(ByteString.EMPTY, builder.getRepeatedStringPieceBytes(0));
1217     builder.clearRepeatedStringPiece();
1218
1219     message = builder.build();
1220     builder.addRepeatedUint32(1);
1221     messageAfterBuild = builder.build();
1222     assertEquals(0, message.getRepeatedUint32Count());
1223     builder.setRepeatedUint32(0, 0);
1224     assertEquals(1, messageAfterBuild.getRepeatedUint32(0));
1225     assertEquals(0, builder.getRepeatedUint32(0));
1226     builder.clearRepeatedUint32();
1227
1228     message = builder.build();
1229     builder.addRepeatedUint64(1L);
1230     messageAfterBuild = builder.build();
1231     assertEquals(0L, message.getRepeatedUint64Count());
1232     builder.setRepeatedUint64(0, 0L);
1233     assertEquals(1L, messageAfterBuild.getRepeatedUint64(0));
1234     assertEquals(0L, builder.getRepeatedUint64(0));
1235     builder.clearRepeatedUint64();
1236
1237     message = builder.build();
1238     assertEquals(0, message.getSerializedSize());
1239     builder.mergeFrom(TestAllTypesLite.newBuilder().setOptionalBool(true).build());
1240     assertEquals(0, message.getSerializedSize());
1241     assertEquals(true, builder.build().getOptionalBool());
1242     builder.clearOptionalBool();
1243
1244     message = builder.build();
1245     assertEquals(0, message.getSerializedSize());
1246     builder.mergeFrom(TestAllTypesLite.newBuilder().setOptionalBool(true).build());
1247     assertEquals(0, message.getSerializedSize());
1248     assertEquals(true, builder.build().getOptionalBool());
1249     builder.clear();
1250     assertEquals(0, builder.build().getSerializedSize());
1251
1252     message = builder.build();
1253     assertEquals(0, message.getSerializedSize());
1254     builder.mergeOptionalForeignMessage(foreignMessage);
1255     assertEquals(0, message.getSerializedSize());
1256     assertEquals(foreignMessage.getC(), builder.build().getOptionalForeignMessage().getC());
1257     builder.clearOptionalForeignMessage();
1258
1259     message = builder.build();
1260     assertEquals(0, message.getSerializedSize());
1261     builder.mergeOptionalLazyMessage(nestedMessage);
1262     assertEquals(0, message.getSerializedSize());
1263     assertEquals(nestedMessage.getBb(), builder.build().getOptionalLazyMessage().getBb());
1264     builder.clearOptionalLazyMessage();
1265
1266     message = builder.build();
1267     builder.setOneofString("hi");
1268     assertEquals(OneofFieldCase.ONEOFFIELD_NOT_SET, message.getOneofFieldCase());
1269     assertEquals(OneofFieldCase.ONEOF_STRING, builder.getOneofFieldCase());
1270     assertEquals("hi", builder.getOneofString());
1271     messageAfterBuild = builder.build();
1272     assertEquals(OneofFieldCase.ONEOF_STRING, messageAfterBuild.getOneofFieldCase());
1273     assertEquals("hi", messageAfterBuild.getOneofString());
1274     builder.setOneofUint32(1);
1275     assertEquals(OneofFieldCase.ONEOF_STRING, messageAfterBuild.getOneofFieldCase());
1276     assertEquals("hi", messageAfterBuild.getOneofString());
1277     assertEquals(OneofFieldCase.ONEOF_UINT32, builder.getOneofFieldCase());
1278     assertEquals(1, builder.getOneofUint32());
1279     TestAllTypesLiteOrBuilder messageOrBuilder = builder;
1280     assertEquals(OneofFieldCase.ONEOF_UINT32, messageOrBuilder.getOneofFieldCase());
1281
1282     TestAllExtensionsLite.Builder extendableMessageBuilder = TestAllExtensionsLite.newBuilder();
1283     TestAllExtensionsLite extendableMessage = extendableMessageBuilder.build();
1284     extendableMessageBuilder.setExtension(UnittestLite.optionalInt32ExtensionLite, 1);
1285     assertFalse(extendableMessage.hasExtension(UnittestLite.optionalInt32ExtensionLite));
1286     extendableMessage = extendableMessageBuilder.build();
1287     assertEquals(
1288         1, (int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite));
1289     assertEquals(1, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite));
1290     extendableMessageBuilder.setExtension(UnittestLite.optionalInt32ExtensionLite, 3);
1291     assertEquals(
1292         3, (int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite));
1293     assertEquals(1, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite));
1294     extendableMessage = extendableMessageBuilder.build();
1295     assertEquals(
1296         3, (int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite));
1297     assertEquals(3, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite));
1298
1299     // No extension registry, so it should be in unknown fields.
1300     extendableMessage = TestAllExtensionsLite.parseFrom(extendableMessage.toByteArray());
1301     assertFalse(extendableMessage.hasExtension(UnittestLite.optionalInt32ExtensionLite));
1302
1303     extendableMessageBuilder = extendableMessage.toBuilder();
1304     extendableMessageBuilder.mergeFrom(
1305         TestAllExtensionsLite.newBuilder()
1306             .setExtension(UnittestLite.optionalFixed32ExtensionLite, 11)
1307             .build());
1308
1309     extendableMessage = extendableMessageBuilder.build();
1310     ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
1311     UnittestLite.registerAllExtensions(registry);
1312     extendableMessage = TestAllExtensionsLite.parseFrom(extendableMessage.toByteArray(), registry);
1313
1314     // The unknown field was preserved.
1315     assertEquals(3, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite));
1316     assertEquals(
1317         11, (int) extendableMessage.getExtension(UnittestLite.optionalFixed32ExtensionLite));
1318   }
1319
1320   public void testBuilderMergeFromNull() throws Exception {
1321     try {
1322       TestAllTypesLite.newBuilder().mergeFrom((TestAllTypesLite) null);
1323       fail("Expected exception");
1324     } catch (NullPointerException e) {
1325       // Pass.
1326     }
1327   }
1328
1329   // Builder.mergeFrom() should keep existing extensions.
1330   public void testBuilderMergeFromWithExtensions() throws Exception {
1331     TestAllExtensionsLite message =
1332         TestAllExtensionsLite.newBuilder()
1333             .addExtension(UnittestLite.repeatedInt32ExtensionLite, 12)
1334             .build();
1335
1336     ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
1337     UnittestLite.registerAllExtensions(registry);
1338
1339     TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
1340     builder.mergeFrom(message.toByteArray(), registry);
1341     builder.mergeFrom(message.toByteArray(), registry);
1342     TestAllExtensionsLite result = builder.build();
1343     assertEquals(2, result.getExtensionCount(UnittestLite.repeatedInt32ExtensionLite));
1344     assertEquals(12, result.getExtension(UnittestLite.repeatedInt32ExtensionLite, 0).intValue());
1345     assertEquals(12, result.getExtension(UnittestLite.repeatedInt32ExtensionLite, 1).intValue());
1346   }
1347
1348   // Builder.mergeFrom() should keep existing unknown fields.
1349   public void testBuilderMergeFromWithUnknownFields() throws Exception {
1350     TestAllTypesLite message = TestAllTypesLite.newBuilder().addRepeatedInt32(1).build();
1351
1352     NestedMessage.Builder builder = NestedMessage.newBuilder();
1353     builder.mergeFrom(message.toByteArray());
1354     builder.mergeFrom(message.toByteArray());
1355     NestedMessage result = builder.build();
1356     assertEquals(message.getSerializedSize() * 2, result.getSerializedSize());
1357   }
1358
1359   public void testToStringDefaultInstance() throws Exception {
1360     assertToStringEquals("", TestAllTypesLite.getDefaultInstance());
1361   }
1362
1363   public void testToStringScalarFieldsSuffixedWithList() throws Exception {
1364     assertToStringEquals(
1365         "deceptively_named_list: 7",
1366         TestAllTypesLite.newBuilder().setDeceptivelyNamedList(7).build());
1367   }
1368
1369   public void testToStringPrimitives() throws Exception {
1370     TestAllTypesLite proto =
1371         TestAllTypesLite.newBuilder()
1372             .setOptionalInt32(1)
1373             .setOptionalInt64(9223372036854775807L)
1374             .build();
1375     assertToStringEquals("optional_int32: 1\noptional_int64: 9223372036854775807", proto);
1376
1377     proto =
1378         TestAllTypesLite.newBuilder()
1379             .setOptionalBool(true)
1380             .setOptionalNestedEnum(TestAllTypesLite.NestedEnum.BAZ)
1381             .build();
1382     assertToStringEquals("optional_bool: true\noptional_nested_enum: BAZ", proto);
1383
1384     proto = TestAllTypesLite.newBuilder().setOptionalFloat(2.72f).setOptionalDouble(3.14).build();
1385     assertToStringEquals("optional_double: 3.14\noptional_float: 2.72", proto);
1386   }
1387
1388   public void testToStringStringFields() throws Exception {
1389     TestAllTypesLite proto =
1390         TestAllTypesLite.newBuilder().setOptionalString("foo\"bar\nbaz\\").build();
1391     assertToStringEquals("optional_string: \"foo\\\"bar\\nbaz\\\\\"", proto);
1392
1393     proto = TestAllTypesLite.newBuilder().setOptionalString("\u6587").build();
1394     assertToStringEquals("optional_string: \"\\346\\226\\207\"", proto);
1395   }
1396
1397   public void testToStringNestedMessage() throws Exception {
1398     TestAllTypesLite proto =
1399         TestAllTypesLite.newBuilder()
1400             .setOptionalNestedMessage(TestAllTypesLite.NestedMessage.getDefaultInstance())
1401             .build();
1402     assertToStringEquals("optional_nested_message {\n}", proto);
1403
1404     proto =
1405         TestAllTypesLite.newBuilder()
1406             .setOptionalNestedMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(7))
1407             .build();
1408     assertToStringEquals("optional_nested_message {\n  bb: 7\n}", proto);
1409   }
1410
1411   public void testToStringRepeatedFields() throws Exception {
1412     TestAllTypesLite proto =
1413         TestAllTypesLite.newBuilder()
1414             .addRepeatedInt32(32)
1415             .addRepeatedInt32(32)
1416             .addRepeatedInt64(64)
1417             .build();
1418     assertToStringEquals("repeated_int32: 32\nrepeated_int32: 32\nrepeated_int64: 64", proto);
1419
1420     proto =
1421         TestAllTypesLite.newBuilder()
1422             .addRepeatedLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(7))
1423             .addRepeatedLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(8))
1424             .build();
1425     assertToStringEquals(
1426         "repeated_lazy_message {\n  bb: 7\n}\nrepeated_lazy_message {\n  bb: 8\n}", proto);
1427   }
1428
1429   public void testToStringForeignFields() throws Exception {
1430     TestAllTypesLite proto =
1431         TestAllTypesLite.newBuilder()
1432             .setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
1433             .setOptionalForeignMessage(ForeignMessageLite.newBuilder().setC(3))
1434             .build();
1435     assertToStringEquals(
1436         "optional_foreign_enum: FOREIGN_LITE_BAR\noptional_foreign_message {\n  c: 3\n}", proto);
1437   }
1438
1439   public void testToStringExtensions() throws Exception {
1440     TestAllExtensionsLite message =
1441         TestAllExtensionsLite.newBuilder()
1442             .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
1443             .addExtension(UnittestLite.repeatedStringExtensionLite, "spam")
1444             .addExtension(UnittestLite.repeatedStringExtensionLite, "eggs")
1445             .setExtension(
1446                 UnittestLite.optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ)
1447             .setExtension(
1448                 UnittestLite.optionalNestedMessageExtensionLite,
1449                 TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build())
1450             .build();
1451     assertToStringEquals(
1452         "[1]: 123\n[18] {\n  bb: 7\n}\n[21]: 3\n[44]: \"spam\"\n[44]: \"eggs\"", message);
1453   }
1454
1455   public void testToStringUnknownFields() throws Exception {
1456     TestAllExtensionsLite messageWithExtensions =
1457         TestAllExtensionsLite.newBuilder()
1458             .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
1459             .addExtension(UnittestLite.repeatedStringExtensionLite, "spam")
1460             .addExtension(UnittestLite.repeatedStringExtensionLite, "eggs")
1461             .setExtension(
1462                 UnittestLite.optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ)
1463             .setExtension(
1464                 UnittestLite.optionalNestedMessageExtensionLite,
1465                 TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build())
1466             .build();
1467     TestAllExtensionsLite messageWithUnknownFields =
1468         TestAllExtensionsLite.parseFrom(messageWithExtensions.toByteArray());
1469     assertToStringEquals(
1470         "1: 123\n18: \"\\b\\a\"\n21: 3\n44: \"spam\"\n44: \"eggs\"", messageWithUnknownFields);
1471   }
1472
1473   public void testToStringLazyMessage() throws Exception {
1474     TestAllTypesLite message =
1475         TestAllTypesLite.newBuilder()
1476             .setOptionalLazyMessage(NestedMessage.newBuilder().setBb(1).build())
1477             .build();
1478     assertToStringEquals("optional_lazy_message {\n  bb: 1\n}", message);
1479   }
1480
1481   public void testToStringGroup() throws Exception {
1482     TestAllTypesLite message =
1483         TestAllTypesLite.newBuilder()
1484             .setOptionalGroup(OptionalGroup.newBuilder().setA(1).build())
1485             .build();
1486     assertToStringEquals("optional_group {\n  a: 1\n}", message);
1487   }
1488
1489   public void testToStringOneof() throws Exception {
1490     TestAllTypesLite message = TestAllTypesLite.newBuilder().setOneofString("hello").build();
1491     assertToStringEquals("oneof_string: \"hello\"", message);
1492   }
1493
1494   public void testToStringMapFields() throws Exception {
1495     TestMap message1 =
1496         TestMap.newBuilder()
1497             .putInt32ToStringField(1, "alpha")
1498             .putInt32ToStringField(2, "beta")
1499             .build();
1500     assertToStringEquals(
1501         "int32_to_string_field {\n"
1502             + "  key: 1\n"
1503             + "  value: \"alpha\"\n"
1504             + "}\n"
1505             + "int32_to_string_field {\n"
1506             + "  key: 2\n"
1507             + "  value: \"beta\"\n"
1508             + "}",
1509         message1);
1510
1511     TestMap message2 =
1512         TestMap.newBuilder()
1513             .putInt32ToMessageField(1, MessageValue.newBuilder().setValue(10).build())
1514             .putInt32ToMessageField(2, MessageValue.newBuilder().setValue(20).build())
1515             .build();
1516     assertToStringEquals(
1517         "int32_to_message_field {\n"
1518             + "  key: 1\n"
1519             + "  value {\n"
1520             + "    value: 10\n"
1521             + "  }\n"
1522             + "}\n"
1523             + "int32_to_message_field {\n"
1524             + "  key: 2\n"
1525             + "  value {\n"
1526             + "    value: 20\n"
1527             + "  }\n"
1528             + "}",
1529         message2);
1530   }
1531
1532   // Asserts that the toString() representation of the message matches the expected. This verifies
1533   // the first line starts with a comment; but, does not factor in said comment as part of the
1534   // comparison as it contains unstable addresses.
1535   private static void assertToStringEquals(String expected, MessageLite message) {
1536     String toString = message.toString();
1537     assertEquals('#', toString.charAt(0));
1538     if (toString.contains("\n")) {
1539       toString = toString.substring(toString.indexOf("\n") + 1);
1540     } else {
1541       toString = "";
1542     }
1543     assertEquals(expected, toString);
1544   }
1545
1546   public void testParseLazy() throws Exception {
1547     ByteString bb =
1548         TestAllTypesLite.newBuilder()
1549             .setOptionalLazyMessage(NestedMessage.newBuilder().setBb(11).build())
1550             .build()
1551             .toByteString();
1552     ByteString cc =
1553         TestAllTypesLite.newBuilder()
1554             .setOptionalLazyMessage(NestedMessage.newBuilder().setCc(22).build())
1555             .build()
1556             .toByteString();
1557
1558     ByteString concat = bb.concat(cc);
1559     TestAllTypesLite message = TestAllTypesLite.parseFrom(concat);
1560
1561     assertEquals(11, message.getOptionalLazyMessage().getBb());
1562     assertEquals(22L, message.getOptionalLazyMessage().getCc());
1563   }
1564
1565   public void testParseLazy_oneOf() throws Exception {
1566     ByteString bb =
1567         TestAllTypesLite.newBuilder()
1568             .setOneofLazyNestedMessage(NestedMessage.newBuilder().setBb(11).build())
1569             .build()
1570             .toByteString();
1571     ByteString cc =
1572         TestAllTypesLite.newBuilder()
1573             .setOneofLazyNestedMessage(NestedMessage.newBuilder().setCc(22).build())
1574             .build()
1575             .toByteString();
1576
1577     ByteString concat = bb.concat(cc);
1578     TestAllTypesLite message = TestAllTypesLite.parseFrom(concat);
1579
1580     assertEquals(11, message.getOneofLazyNestedMessage().getBb());
1581     assertEquals(22L, message.getOneofLazyNestedMessage().getCc());
1582   }
1583
1584   public void testMergeFromStream_repeatedField() throws Exception {
1585     TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder().addRepeatedString("hello");
1586     builder.mergeFrom(CodedInputStream.newInstance(builder.build().toByteArray()));
1587
1588     assertEquals(2, builder.getRepeatedStringCount());
1589   }
1590
1591   public void testMergeFromStream_invalidBytes() throws Exception {
1592     TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder().setDefaultBool(true);
1593     try {
1594       builder.mergeFrom(CodedInputStream.newInstance("Invalid bytes".getBytes(Internal.UTF_8)));
1595       fail();
1596     } catch (InvalidProtocolBufferException expected) {
1597     }
1598   }
1599
1600   public void testMergeFrom_sanity() throws Exception {
1601     TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
1602     byte[] bytes = one.toByteArray();
1603     TestAllTypesLite two = TestAllTypesLite.parseFrom(bytes);
1604
1605     one = one.toBuilder().mergeFrom(one).build();
1606     two = two.toBuilder().mergeFrom(bytes).build();
1607     assertEquals(one, two);
1608     assertEquals(two, one);
1609     assertEquals(one.hashCode(), two.hashCode());
1610   }
1611
1612   public void testMergeFromNoLazyFieldSharing() throws Exception {
1613     TestAllTypesLite.Builder sourceBuilder =
1614         TestAllTypesLite.newBuilder()
1615             .setOptionalLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(1));
1616     TestAllTypesLite.Builder targetBuilder =
1617         TestAllTypesLite.newBuilder().mergeFrom(sourceBuilder.build());
1618     assertEquals(1, sourceBuilder.getOptionalLazyMessage().getBb());
1619     // now change the sourceBuilder, and target value shouldn't be affected.
1620     sourceBuilder.setOptionalLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(2));
1621     assertEquals(1, targetBuilder.getOptionalLazyMessage().getBb());
1622   }
1623
1624   public void testEquals_notEqual() throws Exception {
1625     TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
1626     byte[] bytes = one.toByteArray();
1627     TestAllTypesLite two = one.toBuilder().mergeFrom(one).mergeFrom(bytes).build();
1628
1629     assertFalse(one.equals(two));
1630     assertFalse(two.equals(one));
1631
1632     assertFalse(one.equals(TestAllTypesLite.getDefaultInstance()));
1633     assertFalse(TestAllTypesLite.getDefaultInstance().equals(one));
1634
1635     TestAllTypesLite oneFieldSet = TestAllTypesLite.newBuilder().setDefaultBool(true).build();
1636     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1637     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1638
1639     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultBytes(ByteString.EMPTY).build();
1640     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1641     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1642
1643     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultCord("").build();
1644     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1645     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1646
1647     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultCordBytes(ByteString.EMPTY).build();
1648     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1649     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1650
1651     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultDouble(0).build();
1652     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1653     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1654
1655     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFixed32(0).build();
1656     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1657     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1658
1659     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFixed64(0).build();
1660     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1661     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1662
1663     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFloat(0).build();
1664     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1665     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1666
1667     oneFieldSet =
1668         TestAllTypesLite.newBuilder()
1669             .setDefaultForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
1670             .build();
1671     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1672     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1673
1674     oneFieldSet =
1675         TestAllTypesLite.newBuilder().setDefaultImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build();
1676     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1677     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1678
1679     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultInt32(0).build();
1680     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1681     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1682
1683     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultInt64(0).build();
1684     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1685     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1686
1687     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultNestedEnum(NestedEnum.BAR).build();
1688     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1689     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1690
1691     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSfixed32(0).build();
1692     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1693     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1694
1695     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSfixed64(0).build();
1696     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1697     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1698
1699     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSint32(0).build();
1700     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1701     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1702
1703     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSint64(0).build();
1704     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1705     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1706
1707     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultString("").build();
1708     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1709     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1710
1711     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultStringBytes(ByteString.EMPTY).build();
1712     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1713     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1714
1715     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultStringPiece("").build();
1716     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1717     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1718
1719     oneFieldSet =
1720         TestAllTypesLite.newBuilder().setDefaultStringPieceBytes(ByteString.EMPTY).build();
1721     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1722     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1723
1724     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultUint32(0).build();
1725     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1726     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1727
1728     oneFieldSet = TestAllTypesLite.newBuilder().setDefaultUint64(0).build();
1729     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1730     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1731
1732     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedBool(true).build();
1733     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1734     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1735
1736     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedBytes(ByteString.EMPTY).build();
1737     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1738     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1739
1740     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedCord("").build();
1741     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1742     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1743
1744     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedCordBytes(ByteString.EMPTY).build();
1745     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1746     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1747
1748     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedDouble(0).build();
1749     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1750     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1751
1752     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFixed32(0).build();
1753     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1754     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1755
1756     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFixed64(0).build();
1757     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1758     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1759
1760     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFloat(0).build();
1761     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1762     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1763
1764     oneFieldSet =
1765         TestAllTypesLite.newBuilder()
1766             .addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
1767             .build();
1768     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1769     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1770
1771     oneFieldSet =
1772         TestAllTypesLite.newBuilder().addRepeatedImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build();
1773     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1774     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1775
1776     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedInt32(0).build();
1777     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1778     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1779
1780     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedInt64(0).build();
1781     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1782     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1783
1784     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedNestedEnum(NestedEnum.BAR).build();
1785     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1786     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1787
1788     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSfixed32(0).build();
1789     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1790     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1791
1792     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSfixed64(0).build();
1793     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1794     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1795
1796     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSint32(0).build();
1797     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1798     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1799
1800     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSint64(0).build();
1801     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1802     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1803
1804     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedString("").build();
1805     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1806     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1807
1808     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedStringBytes(ByteString.EMPTY).build();
1809     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1810     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1811
1812     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedStringPiece("").build();
1813     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1814     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1815
1816     oneFieldSet =
1817         TestAllTypesLite.newBuilder().addRepeatedStringPieceBytes(ByteString.EMPTY).build();
1818     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1819     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1820
1821     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedUint32(0).build();
1822     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1823     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1824
1825     oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedUint64(0).build();
1826     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1827     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1828
1829     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalBool(true).build();
1830     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1831     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1832
1833     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalBytes(ByteString.EMPTY).build();
1834     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1835     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1836
1837     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalCord("").build();
1838     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1839     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1840
1841     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalCordBytes(ByteString.EMPTY).build();
1842     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1843     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1844
1845     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalDouble(0).build();
1846     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1847     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1848
1849     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFixed32(0).build();
1850     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1851     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1852
1853     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFixed64(0).build();
1854     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1855     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1856
1857     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFloat(0).build();
1858     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1859     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1860
1861     oneFieldSet =
1862         TestAllTypesLite.newBuilder()
1863             .setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
1864             .build();
1865     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1866     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1867
1868     oneFieldSet =
1869         TestAllTypesLite.newBuilder().setOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build();
1870     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1871     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1872
1873     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalInt32(0).build();
1874     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1875     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1876
1877     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalInt64(0).build();
1878     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1879     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1880
1881     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalNestedEnum(NestedEnum.BAR).build();
1882     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1883     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1884
1885     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSfixed32(0).build();
1886     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1887     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1888
1889     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSfixed64(0).build();
1890     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1891     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1892
1893     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSint32(0).build();
1894     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1895     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1896
1897     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSint64(0).build();
1898     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1899     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1900
1901     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalString("").build();
1902     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1903     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1904
1905     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalStringBytes(ByteString.EMPTY).build();
1906     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1907     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1908
1909     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalStringPiece("").build();
1910     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1911     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1912
1913     oneFieldSet =
1914         TestAllTypesLite.newBuilder().setOptionalStringPieceBytes(ByteString.EMPTY).build();
1915     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1916     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1917
1918     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalUint32(0).build();
1919     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1920     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1921
1922     oneFieldSet = TestAllTypesLite.newBuilder().setOptionalUint64(0).build();
1923     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1924     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1925
1926     oneFieldSet = TestAllTypesLite.newBuilder().setOneofBytes(ByteString.EMPTY).build();
1927     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1928     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1929
1930     oneFieldSet =
1931         TestAllTypesLite.newBuilder()
1932             .setOneofLazyNestedMessage(NestedMessage.getDefaultInstance())
1933             .build();
1934     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1935     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1936
1937     oneFieldSet =
1938         TestAllTypesLite.newBuilder()
1939             .setOneofNestedMessage(NestedMessage.getDefaultInstance())
1940             .build();
1941     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1942     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1943
1944     oneFieldSet = TestAllTypesLite.newBuilder().setOneofString("").build();
1945     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1946     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1947
1948     oneFieldSet = TestAllTypesLite.newBuilder().setOneofStringBytes(ByteString.EMPTY).build();
1949     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1950     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1951
1952     oneFieldSet = TestAllTypesLite.newBuilder().setOneofUint32(0).build();
1953     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1954     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1955
1956     oneFieldSet =
1957         TestAllTypesLite.newBuilder()
1958             .setOptionalForeignMessage(ForeignMessageLite.getDefaultInstance())
1959             .build();
1960     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1961     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1962
1963     oneFieldSet =
1964         TestAllTypesLite.newBuilder().setOptionalGroup(OptionalGroup.getDefaultInstance()).build();
1965     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1966     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1967
1968     oneFieldSet =
1969         TestAllTypesLite.newBuilder()
1970             .setOptionalPublicImportMessage(PublicImportMessageLite.getDefaultInstance())
1971             .build();
1972     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1973     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1974
1975     oneFieldSet =
1976         TestAllTypesLite.newBuilder()
1977             .setOptionalLazyMessage(NestedMessage.getDefaultInstance())
1978             .build();
1979     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1980
1981     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1982     oneFieldSet =
1983         TestAllTypesLite.newBuilder()
1984             .addRepeatedLazyMessage(NestedMessage.getDefaultInstance())
1985             .build();
1986     assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1987     assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1988   }
1989
1990   public void testEquals() throws Exception {
1991     // Check that two identical objs are equal.
1992     Foo foo1a = Foo.newBuilder().setValue(1).addBar(Bar.newBuilder().setName("foo1")).build();
1993     Foo foo1b = Foo.newBuilder().setValue(1).addBar(Bar.newBuilder().setName("foo1")).build();
1994     Foo foo2 = Foo.newBuilder().setValue(1).addBar(Bar.newBuilder().setName("foo2")).build();
1995
1996     // Check that equals is doing value rather than object equality.
1997     assertEquals(foo1a, foo1b);
1998     assertEquals(foo1a.hashCode(), foo1b.hashCode());
1999
2000     // Check that a diffeent object is not equal.
2001     assertFalse(foo1a.equals(foo2));
2002
2003     // Check that two objects which have different types but the same field values are not
2004     // considered to be equal.
2005     Bar bar = Bar.newBuilder().setName("bar").build();
2006     BarPrime barPrime = BarPrime.newBuilder().setName("bar").build();
2007     assertFalse(bar.equals(barPrime));
2008   }
2009
2010   public void testEqualsAndHashCodeForTrickySchemaTypes() {
2011     Foo foo1 = Foo.getDefaultInstance();
2012     Foo foo2 = Foo.newBuilder().setSint64(1).build();
2013     Foo foo3 = Foo.newBuilder().putMyMap("key", "value2").build();
2014     Foo foo4 = Foo.newBuilder().setMyGroup(Foo.MyGroup.newBuilder().setValue(4).build()).build();
2015
2016     assertEqualsAndHashCodeAreFalse(foo1, foo2);
2017     assertEqualsAndHashCodeAreFalse(foo1, foo3);
2018     assertEqualsAndHashCodeAreFalse(foo1, foo4);
2019   }
2020
2021   public void testOneofEquals() throws Exception {
2022     TestOneofEquals.Builder builder = TestOneofEquals.newBuilder();
2023     TestOneofEquals message1 = builder.build();
2024     // Set message2's name field to default value. The two messages should be different when we
2025     // check with the oneof case.
2026     builder.setName("");
2027     TestOneofEquals message2 = builder.build();
2028     assertFalse(message1.equals(message2));
2029   }
2030
2031   public void testEquals_sanity() throws Exception {
2032     TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
2033     TestAllTypesLite two = TestAllTypesLite.parseFrom(one.toByteArray());
2034     assertEquals(one, two);
2035     assertEquals(one.hashCode(), two.hashCode());
2036
2037     assertEquals(
2038         one.toBuilder().mergeFrom(two).build(),
2039         two.toBuilder().mergeFrom(two.toByteArray()).build());
2040   }
2041
2042   public void testEqualsAndHashCodeWithUnknownFields() throws InvalidProtocolBufferException {
2043     Foo fooWithOnlyValue = Foo.newBuilder().setValue(1).build();
2044
2045     Foo fooWithValueAndExtension =
2046         fooWithOnlyValue
2047             .toBuilder()
2048             .setValue(1)
2049             .setExtension(Bar.fooExt, Bar.newBuilder().setName("name").build())
2050             .build();
2051
2052     Foo fooWithValueAndUnknownFields = Foo.parseFrom(fooWithValueAndExtension.toByteArray());
2053
2054     assertEqualsAndHashCodeAreFalse(fooWithOnlyValue, fooWithValueAndUnknownFields);
2055     assertEqualsAndHashCodeAreFalse(fooWithValueAndExtension, fooWithValueAndUnknownFields);
2056   }
2057
2058   public void testEqualsAndHashCodeWithExtensions() throws InvalidProtocolBufferException {
2059     Foo fooWithOnlyValue = Foo.newBuilder().setValue(1).build();
2060
2061     Foo fooWithValueAndExtension =
2062         fooWithOnlyValue
2063             .toBuilder()
2064             .setValue(1)
2065             .setExtension(Bar.fooExt, Bar.newBuilder().setName("name").build())
2066             .build();
2067
2068     assertEqualsAndHashCodeAreFalse(fooWithOnlyValue, fooWithValueAndExtension);
2069   }
2070
2071   // Test to ensure we avoid a class cast exception with oneofs.
2072   public void testEquals_oneOfMessages() {
2073     TestAllTypesLite mine = TestAllTypesLite.newBuilder().setOneofString("Hello").build();
2074
2075     TestAllTypesLite other =
2076         TestAllTypesLite.newBuilder()
2077             .setOneofNestedMessage(NestedMessage.getDefaultInstance())
2078             .build();
2079
2080     assertFalse(mine.equals(other));
2081     assertFalse(other.equals(mine));
2082   }
2083
2084   public void testHugeFieldNumbers() throws InvalidProtocolBufferException {
2085     TestHugeFieldNumbersLite message =
2086         TestHugeFieldNumbersLite.newBuilder()
2087             .setOptionalInt32(1)
2088             .addRepeatedInt32(2)
2089             .setOptionalEnum(ForeignEnumLite.FOREIGN_LITE_FOO)
2090             .setOptionalString("xyz")
2091             .setOptionalMessage(ForeignMessageLite.newBuilder().setC(3).build())
2092             .build();
2093
2094     TestHugeFieldNumbersLite parsedMessage =
2095         TestHugeFieldNumbersLite.parseFrom(message.toByteArray());
2096     assertEquals(1, parsedMessage.getOptionalInt32());
2097     assertEquals(2, parsedMessage.getRepeatedInt32(0));
2098     assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, parsedMessage.getOptionalEnum());
2099     assertEquals("xyz", parsedMessage.getOptionalString());
2100     assertEquals(3, parsedMessage.getOptionalMessage().getC());
2101   }
2102
2103   private void assertEqualsAndHashCodeAreFalse(Object o1, Object o2) {
2104     assertFalse(o1.equals(o2));
2105     assertFalse(o1.hashCode() == o2.hashCode());
2106   }
2107
2108   public void testRecursiveHashcode() {
2109     // This tests that we don't infinite loop.
2110     TestRecursiveOneof.getDefaultInstance().hashCode();
2111   }
2112
2113   public void testParseFromByteBuffer() throws Exception {
2114     TestAllTypesLite message =
2115         TestAllTypesLite.newBuilder()
2116             .setOptionalInt32(123)
2117             .addRepeatedString("hello")
2118             .setOptionalNestedMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(7))
2119             .build();
2120
2121     TestAllTypesLite copy =
2122         TestAllTypesLite.parseFrom(message.toByteString().asReadOnlyByteBuffer());
2123
2124     assertEquals(message, copy);
2125   }
2126
2127   public void testParseFromByteBufferThrows() {
2128     try {
2129       TestAllTypesLite.parseFrom(ByteBuffer.wrap(new byte[] {0x5}));
2130       fail();
2131     } catch (InvalidProtocolBufferException expected) {
2132     }
2133
2134     TestAllTypesLite message =
2135         TestAllTypesLite.newBuilder().setOptionalInt32(123).addRepeatedString("hello").build();
2136
2137     ByteBuffer buffer = ByteBuffer.wrap(message.toByteArray(), 0, message.getSerializedSize() - 1);
2138     try {
2139       TestAllTypesLite.parseFrom(buffer);
2140       fail();
2141     } catch (InvalidProtocolBufferException expected) {
2142       assertEquals(
2143           TestAllTypesLite.newBuilder().setOptionalInt32(123).build(),
2144           expected.getUnfinishedMessage());
2145     }
2146   }
2147
2148   public void testParseFromByteBuffer_extensions() throws Exception {
2149     TestAllExtensionsLite message =
2150         TestAllExtensionsLite.newBuilder()
2151             .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
2152             .addExtension(UnittestLite.repeatedStringExtensionLite, "hello")
2153             .setExtension(
2154                 UnittestLite.optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ)
2155             .setExtension(
2156                 UnittestLite.optionalNestedMessageExtensionLite,
2157                 TestAllTypesLite.NestedMessage.newBuilder().setBb(7).build())
2158             .build();
2159
2160     ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
2161     UnittestLite.registerAllExtensions(registry);
2162
2163     TestAllExtensionsLite copy =
2164         TestAllExtensionsLite.parseFrom(message.toByteString().asReadOnlyByteBuffer(), registry);
2165
2166     assertEquals(message, copy);
2167   }
2168
2169   public void testParseFromByteBufferThrows_extensions() {
2170     ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
2171     UnittestLite.registerAllExtensions(registry);
2172     try {
2173       TestAllExtensionsLite.parseFrom(ByteBuffer.wrap(new byte[] {0x5}), registry);
2174       fail();
2175     } catch (InvalidProtocolBufferException expected) {
2176     }
2177
2178     TestAllExtensionsLite message =
2179         TestAllExtensionsLite.newBuilder()
2180             .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
2181             .addExtension(UnittestLite.repeatedStringExtensionLite, "hello")
2182             .build();
2183
2184     ByteBuffer buffer = ByteBuffer.wrap(message.toByteArray(), 0, message.getSerializedSize() - 1);
2185     try {
2186       TestAllExtensionsLite.parseFrom(buffer, registry);
2187       fail();
2188     } catch (InvalidProtocolBufferException expected) {
2189       assertEquals(
2190           TestAllExtensionsLite.newBuilder()
2191               .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
2192               .build(),
2193           expected.getUnfinishedMessage());
2194     }
2195   }
2196
2197   // Make sure we haven't screwed up the code generation for packing fields by default.
2198   public void testPackedSerialization() throws Exception {
2199     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
2200     builder.addRepeatedInt32(4321);
2201     builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ);
2202     TestAllTypes message = builder.build();
2203
2204     CodedInputStream in = CodedInputStream.newInstance(message.toByteArray());
2205
2206     while (!in.isAtEnd()) {
2207       int tag = in.readTag();
2208       assertEquals(WireFormat.WIRETYPE_LENGTH_DELIMITED, WireFormat.getTagWireType(tag));
2209       in.skipField(tag);
2210     }
2211   }
2212
2213   public void testAddAllIteratesOnce() {
2214     TestAllTypesLite.newBuilder()
2215         .addAllRepeatedBool(new OneTimeIterableList<>(false))
2216         .addAllRepeatedInt32(new OneTimeIterableList<>(0))
2217         .addAllRepeatedInt64(new OneTimeIterableList<>(0L))
2218         .addAllRepeatedFloat(new OneTimeIterableList<>(0f))
2219         .addAllRepeatedDouble(new OneTimeIterableList<>(0d))
2220         .addAllRepeatedBytes(new OneTimeIterableList<>(ByteString.EMPTY))
2221         .addAllRepeatedString(new OneTimeIterableList<>(""))
2222         .addAllRepeatedNestedMessage(new OneTimeIterableList<>(NestedMessage.getDefaultInstance()))
2223         .addAllRepeatedBool(new OneTimeIterable<>(false))
2224         .addAllRepeatedInt32(new OneTimeIterable<>(0))
2225         .addAllRepeatedInt64(new OneTimeIterable<>(0L))
2226         .addAllRepeatedFloat(new OneTimeIterable<>(0f))
2227         .addAllRepeatedDouble(new OneTimeIterable<>(0d))
2228         .addAllRepeatedBytes(new OneTimeIterable<>(ByteString.EMPTY))
2229         .addAllRepeatedString(new OneTimeIterable<>(""))
2230         .addAllRepeatedNestedMessage(new OneTimeIterable<>(NestedMessage.getDefaultInstance()))
2231         .build();
2232   }
2233
2234   public void testAddAllIteratesOnce_throwsOnNull() {
2235     TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder();
2236     try {
2237       builder.addAllRepeatedBool(new OneTimeIterableList<>(true, false, null));
2238       fail();
2239     } catch (NullPointerException expected) {
2240       assertEquals("Element at index 2 is null.", expected.getMessage());
2241       assertEquals(0, builder.getRepeatedBoolCount());
2242     }
2243
2244     try {
2245       builder.addAllRepeatedBool(new OneTimeIterable<>(true, false, null));
2246       fail();
2247     } catch (NullPointerException expected) {
2248       assertEquals("Element at index 2 is null.", expected.getMessage());
2249       assertEquals(0, builder.getRepeatedBoolCount());
2250     }
2251
2252     try {
2253       builder = TestAllTypesLite.newBuilder();
2254       builder.addAllRepeatedBool(new OneTimeIterableList<>((Boolean) null));
2255       fail();
2256     } catch (NullPointerException expected) {
2257       assertEquals("Element at index 0 is null.", expected.getMessage());
2258       assertEquals(0, builder.getRepeatedBoolCount());
2259     }
2260
2261     try {
2262       builder = TestAllTypesLite.newBuilder();
2263       builder.addAllRepeatedInt32(new OneTimeIterableList<>((Integer) null));
2264       fail();
2265     } catch (NullPointerException expected) {
2266       assertEquals("Element at index 0 is null.", expected.getMessage());
2267       assertEquals(0, builder.getRepeatedInt32Count());
2268     }
2269
2270     try {
2271       builder = TestAllTypesLite.newBuilder();
2272       builder.addAllRepeatedInt64(new OneTimeIterableList<>((Long) null));
2273       fail();
2274     } catch (NullPointerException expected) {
2275       assertEquals("Element at index 0 is null.", expected.getMessage());
2276       assertEquals(0, builder.getRepeatedInt64Count());
2277     }
2278
2279     try {
2280       builder = TestAllTypesLite.newBuilder();
2281       builder.addAllRepeatedFloat(new OneTimeIterableList<>((Float) null));
2282       fail();
2283     } catch (NullPointerException expected) {
2284       assertEquals("Element at index 0 is null.", expected.getMessage());
2285       assertEquals(0, builder.getRepeatedFloatCount());
2286     }
2287
2288     try {
2289       builder = TestAllTypesLite.newBuilder();
2290       builder.addAllRepeatedDouble(new OneTimeIterableList<>((Double) null));
2291       fail();
2292     } catch (NullPointerException expected) {
2293       assertEquals("Element at index 0 is null.", expected.getMessage());
2294       assertEquals(0, builder.getRepeatedDoubleCount());
2295     }
2296
2297     try {
2298       builder = TestAllTypesLite.newBuilder();
2299       builder.addAllRepeatedBytes(new OneTimeIterableList<>((ByteString) null));
2300       fail();
2301     } catch (NullPointerException expected) {
2302       assertEquals("Element at index 0 is null.", expected.getMessage());
2303       assertEquals(0, builder.getRepeatedBytesCount());
2304     }
2305
2306     try {
2307       builder = TestAllTypesLite.newBuilder();
2308       builder.addAllRepeatedString(new OneTimeIterableList<>("", "", null, ""));
2309       fail();
2310     } catch (NullPointerException expected) {
2311       assertEquals("Element at index 2 is null.", expected.getMessage());
2312       assertEquals(0, builder.getRepeatedStringCount());
2313     }
2314
2315     try {
2316       builder = TestAllTypesLite.newBuilder();
2317       builder.addAllRepeatedString(new OneTimeIterable<>("", "", null, ""));
2318       fail();
2319     } catch (NullPointerException expected) {
2320       assertEquals("Element at index 2 is null.", expected.getMessage());
2321       assertEquals(0, builder.getRepeatedStringCount());
2322     }
2323
2324     try {
2325       builder = TestAllTypesLite.newBuilder();
2326       builder.addAllRepeatedString(new OneTimeIterableList<>((String) null));
2327       fail();
2328     } catch (NullPointerException expected) {
2329       assertEquals("Element at index 0 is null.", expected.getMessage());
2330       assertEquals(0, builder.getRepeatedStringCount());
2331     }
2332
2333     try {
2334       builder = TestAllTypesLite.newBuilder();
2335       builder.addAllRepeatedNestedMessage(new OneTimeIterableList<>((NestedMessage) null));
2336       fail();
2337     } catch (NullPointerException expected) {
2338       assertEquals("Element at index 0 is null.", expected.getMessage());
2339       assertEquals(0, builder.getRepeatedNestedMessageCount());
2340     }
2341   }
2342
2343   public void testExtensionRenamesKeywords() {
2344     assertTrue(NonNestedExtensionLite.package_ instanceof GeneratedMessageLite.GeneratedExtension);
2345     assertTrue(
2346         NestedExtensionLite.MyNestedExtensionLite.private_
2347             instanceof GeneratedMessageLite.GeneratedExtension);
2348
2349     NonNestedExtensionLite.MessageLiteToBeExtended msg =
2350         NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
2351             .setExtension(NonNestedExtensionLite.package_, true)
2352             .build();
2353     assertTrue(msg.getExtension(NonNestedExtensionLite.package_));
2354
2355     msg =
2356         NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
2357             .setExtension(NestedExtensionLite.MyNestedExtensionLite.private_, 2.4)
2358             .build();
2359     assertEquals(
2360         2.4, msg.getExtension(NestedExtensionLite.MyNestedExtensionLite.private_), 0.001);
2361   }
2362
2363   private static final class OneTimeIterableList<T> extends ArrayList<T> {
2364     private boolean wasIterated = false;
2365
2366     OneTimeIterableList(T... contents) {
2367       addAll(Arrays.asList(contents));
2368     }
2369
2370     @Override
2371     public Iterator<T> iterator() {
2372       if (wasIterated) {
2373         fail();
2374       }
2375       wasIterated = true;
2376       return super.iterator();
2377     }
2378   }
2379
2380   private static final class OneTimeIterable<T> implements Iterable<T> {
2381     private final List<T> list;
2382     private boolean wasIterated = false;
2383
2384     OneTimeIterable(T... contents) {
2385       list = Arrays.asList(contents);
2386     }
2387
2388     @Override
2389     public Iterator<T> iterator() {
2390       if (wasIterated) {
2391         fail();
2392       }
2393       wasIterated = true;
2394       return list.iterator();
2395     }
2396   }
2397
2398   public void testNullExtensionRegistry() throws Exception {
2399     try {
2400       TestAllTypesLite.parseFrom(new byte[] {}, null);
2401       fail();
2402     } catch (NullPointerException expected) {
2403     }
2404   }
2405
2406   public void testSerializeToOutputStreamThrowsIOException() {
2407     try {
2408       TestAllTypesLite.newBuilder()
2409           .setOptionalBytes(ByteString.copyFromUtf8("hello"))
2410           .build()
2411           .writeTo(
2412               new OutputStream() {
2413
2414                 @Override
2415                 public void write(int b) throws IOException {
2416                   throw new IOException();
2417                 }
2418               });
2419       fail();
2420     } catch (IOException expected) {
2421     }
2422   }
2423
2424   public void testUnpairedSurrogatesReplacedByQuestionMark() throws InvalidProtocolBufferException {
2425     String testString = "foo \ud83d bar";
2426     String expectedString = "foo ? bar";
2427
2428     TestAllTypesLite testMessage =
2429         TestAllTypesLite.newBuilder().setOptionalString(testString).build();
2430     ByteString serializedMessage = testMessage.toByteString();
2431
2432     // Behavior is compatible with String.getBytes("UTF-8"), which replaces
2433     // unpaired surrogates with a question mark.
2434     TestAllTypesLite parsedMessage = TestAllTypesLite.parseFrom(serializedMessage);
2435     assertEquals(expectedString, parsedMessage.getOptionalString());
2436
2437     // Conversion happens during serialization.
2438     ByteString expectedBytes = ByteString.copyFromUtf8(expectedString);
2439     assertTrue(
2440         String.format(
2441             "Expected serializedMessage (%s) to contain \"%s\" (%s).",
2442             encodeHex(serializedMessage), expectedString, encodeHex(expectedBytes)),
2443         contains(serializedMessage, expectedBytes));
2444   }
2445
2446   private String encodeHex(ByteString bytes) {
2447     String hexDigits = "0123456789abcdef";
2448     StringBuilder stringBuilder = new StringBuilder(bytes.size() * 2);
2449     for (byte b : bytes) {
2450       stringBuilder.append(hexDigits.charAt((b & 0xf0) >> 4));
2451       stringBuilder.append(hexDigits.charAt(b & 0x0f));
2452     }
2453     return stringBuilder.toString();
2454   }
2455
2456   private boolean contains(ByteString a, ByteString b) {
2457     for (int i = 0; i <= a.size() - b.size(); ++i) {
2458       if (a.substring(i, i + b.size()).equals(b)) {
2459         return true;
2460       }
2461     }
2462     return false;
2463   }
2464 }