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