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