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 com.google.protobuf.Descriptors.Descriptor; 34 import com.google.protobuf.Descriptors.FieldDescriptor; 35 import com.google.protobuf.test.UnittestImport; 36 import protobuf_unittest.EnumWithNoOuter; 37 import protobuf_unittest.MessageWithNoOuter; 38 import protobuf_unittest.MultipleFilesTestProto; 39 import protobuf_unittest.NestedExtension.MyNestedExtension; 40 import protobuf_unittest.NonNestedExtension; 41 import protobuf_unittest.NonNestedExtension.MessageToBeExtended; 42 import protobuf_unittest.NonNestedExtension.MyNonNestedExtension; 43 import protobuf_unittest.OuterClassNameTest2OuterClass; 44 import protobuf_unittest.OuterClassNameTest3OuterClass; 45 import protobuf_unittest.OuterClassNameTestOuterClass; 46 import protobuf_unittest.ServiceWithNoOuter; 47 import protobuf_unittest.UnittestOptimizeFor.TestOptimizedForSize; 48 import protobuf_unittest.UnittestOptimizeFor.TestOptionalOptimizedForSize; 49 import protobuf_unittest.UnittestOptimizeFor.TestRequiredOptimizedForSize; 50 import protobuf_unittest.UnittestProto; 51 import protobuf_unittest.UnittestProto.ForeignEnum; 52 import protobuf_unittest.UnittestProto.ForeignMessage; 53 import protobuf_unittest.UnittestProto.ForeignMessageOrBuilder; 54 import protobuf_unittest.UnittestProto.NestedTestAllTypes; 55 import protobuf_unittest.UnittestProto.TestAllExtensions; 56 import protobuf_unittest.UnittestProto.TestAllTypes; 57 import protobuf_unittest.UnittestProto.TestAllTypes.NestedMessage; 58 import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder; 59 import protobuf_unittest.UnittestProto.TestExtremeDefaultValues; 60 import protobuf_unittest.UnittestProto.TestOneof2; 61 import protobuf_unittest.UnittestProto.TestPackedTypes; 62 import protobuf_unittest.UnittestProto.TestUnpackedTypes; 63 import java.io.ByteArrayInputStream; 64 import java.io.ByteArrayOutputStream; 65 import java.io.ObjectInputStream; 66 import java.io.ObjectOutputStream; 67 import java.util.Arrays; 68 import java.util.Collections; 69 import java.util.Iterator; 70 import java.util.List; 71 import junit.framework.TestCase; 72 73 /** 74 * Unit test for generated messages and generated code. See also {@link MessageTest}, which tests 75 * some generated message functionality. 76 * 77 * @author kenton@google.com Kenton Varda 78 */ 79 public class GeneratedMessageTest extends TestCase { 80 TestUtil.ReflectionTester reflectionTester = 81 new TestUtil.ReflectionTester(TestAllTypes.getDescriptor(), null); 82 83 @Override tearDown()84 public void tearDown() { 85 GeneratedMessageV3.setAlwaysUseFieldBuildersForTesting(false); 86 } 87 testGetFieldBuilderForExtensionField()88 public void testGetFieldBuilderForExtensionField() { 89 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 90 Message.Builder fieldBuilder = 91 builder.getFieldBuilder(UnittestProto.optionalNestedMessageExtension.getDescriptor()); 92 int expected = 7432; 93 FieldDescriptor field = 94 NestedMessage.getDescriptor().findFieldByNumber(NestedMessage.BB_FIELD_NUMBER); 95 fieldBuilder.setField(field, expected); 96 assertEquals( 97 expected, 98 builder.build().getExtension(UnittestProto.optionalNestedMessageExtension).getBb()); 99 100 // fieldBuilder still updates the builder after builder build() has been called. 101 expected += 100; 102 fieldBuilder.setField(field, expected); 103 assertEquals( 104 expected, 105 builder.build().getExtension(UnittestProto.optionalNestedMessageExtension).getBb()); 106 } 107 testGetFieldBuilderWithExistingMessage()108 public void testGetFieldBuilderWithExistingMessage() { 109 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 110 builder.setExtension( 111 UnittestProto.optionalNestedMessageExtension, 112 NestedMessage.newBuilder().setBb(123).build()); 113 Message.Builder fieldBuilder = 114 builder.getFieldBuilder(UnittestProto.optionalNestedMessageExtension.getDescriptor()); 115 int expected = 7432; 116 FieldDescriptor field = 117 NestedMessage.getDescriptor().findFieldByNumber(NestedMessage.BB_FIELD_NUMBER); 118 fieldBuilder.setField(field, expected); 119 assertEquals( 120 expected, 121 builder.build().getExtension(UnittestProto.optionalNestedMessageExtension).getBb()); 122 123 // fieldBuilder still updates the builder after builder build() has been called. 124 expected += 100; 125 fieldBuilder.setField(field, expected); 126 assertEquals( 127 expected, 128 builder.build().getExtension(UnittestProto.optionalNestedMessageExtension).getBb()); 129 } 130 testGetFieldBuilderWithExistingBuilder()131 public void testGetFieldBuilderWithExistingBuilder() { 132 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 133 NestedMessage.Builder nestedMessageBuilder = NestedMessage.newBuilder().setBb(123); 134 builder.setField( 135 UnittestProto.optionalNestedMessageExtension.getDescriptor(), nestedMessageBuilder); 136 Message.Builder fieldBuilder = 137 builder.getFieldBuilder(UnittestProto.optionalNestedMessageExtension.getDescriptor()); 138 int expected = 7432; 139 FieldDescriptor field = 140 NestedMessage.getDescriptor().findFieldByNumber(NestedMessage.BB_FIELD_NUMBER); 141 fieldBuilder.setField(field, expected); 142 assertEquals( 143 expected, 144 builder.build().getExtension(UnittestProto.optionalNestedMessageExtension).getBb()); 145 146 // Existing nestedMessageBuilder will also update builder. 147 expected += 100; 148 nestedMessageBuilder.setBb(expected); 149 assertEquals( 150 expected, 151 builder.build().getExtension(UnittestProto.optionalNestedMessageExtension).getBb()); 152 153 // fieldBuilder still updates the builder. 154 expected += 100; 155 fieldBuilder.setField(field, expected); 156 assertEquals( 157 expected, 158 builder.build().getExtension(UnittestProto.optionalNestedMessageExtension).getBb()); 159 } 160 testGetRepeatedFieldBuilderForExtensionField()161 public void testGetRepeatedFieldBuilderForExtensionField() { 162 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 163 builder.addExtension( 164 UnittestProto.repeatedNestedMessageExtension, 165 NestedMessage.newBuilder().setBb(123).build()); 166 Message.Builder fieldBuilder = 167 builder.getRepeatedFieldBuilder( 168 UnittestProto.repeatedNestedMessageExtension.getDescriptor(), 0); 169 int expected = 7432; 170 FieldDescriptor field = 171 NestedMessage.getDescriptor().findFieldByNumber(NestedMessage.BB_FIELD_NUMBER); 172 fieldBuilder.setField(field, expected); 173 assertEquals( 174 expected, 175 builder.build().getExtension(UnittestProto.repeatedNestedMessageExtension, 0).getBb()); 176 177 // fieldBuilder still updates the builder after builder build() has been called. 178 expected += 100; 179 fieldBuilder.setField(field, expected); 180 assertEquals( 181 expected, 182 builder.build().getExtension(UnittestProto.repeatedNestedMessageExtension, 0).getBb()); 183 } 184 testGetRepeatedFieldBuilderForExistingBuilder()185 public void testGetRepeatedFieldBuilderForExistingBuilder() { 186 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 187 NestedMessage.Builder nestedMessageBuilder = NestedMessage.newBuilder().setBb(123); 188 builder.addRepeatedField( 189 UnittestProto.repeatedNestedMessageExtension.getDescriptor(), nestedMessageBuilder); 190 Message.Builder fieldBuilder = 191 builder.getRepeatedFieldBuilder( 192 UnittestProto.repeatedNestedMessageExtension.getDescriptor(), 0); 193 int expected = 7432; 194 FieldDescriptor field = 195 NestedMessage.getDescriptor().findFieldByNumber(NestedMessage.BB_FIELD_NUMBER); 196 fieldBuilder.setField(field, expected); 197 assertEquals( 198 expected, 199 builder.build().getExtension(UnittestProto.repeatedNestedMessageExtension, 0).getBb()); 200 201 // Existing nestedMessageBuilder will also update builder. 202 expected += 100; 203 nestedMessageBuilder.setBb(expected); 204 assertEquals( 205 expected, 206 builder.build().getExtension(UnittestProto.repeatedNestedMessageExtension, 0).getBb()); 207 208 // fieldBuilder still updates the builder. 209 expected += 100; 210 fieldBuilder.setField(field, expected); 211 assertEquals( 212 expected, 213 builder.build().getExtension(UnittestProto.repeatedNestedMessageExtension, 0).getBb()); 214 } 215 testGetExtensionFieldOutOfBound()216 public void testGetExtensionFieldOutOfBound() { 217 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 218 try { 219 builder.getRepeatedField(UnittestProto.repeatedNestedMessageExtension.getDescriptor(), 0); 220 fail("Expected IndexOutOfBoundsException to be thrown"); 221 } catch (IndexOutOfBoundsException expected) { 222 } 223 try { 224 builder.getExtension(UnittestProto.repeatedNestedMessageExtension, 0); 225 fail("Expected IndexOutOfBoundsException to be thrown"); 226 } catch (IndexOutOfBoundsException expected) { 227 } 228 TestAllExtensions extensionsMessage = builder.build(); 229 try { 230 extensionsMessage.getRepeatedField( 231 UnittestProto.repeatedNestedMessageExtension.getDescriptor(), 0); 232 fail("Expected IndexOutOfBoundsException to be thrown"); 233 } catch (IndexOutOfBoundsException expected) { 234 } 235 try { 236 extensionsMessage.getExtension(UnittestProto.repeatedNestedMessageExtension, 0); 237 fail("Expected IndexOutOfBoundsException to be thrown"); 238 } catch (IndexOutOfBoundsException expected) { 239 } 240 } 241 testDefaultInstance()242 public void testDefaultInstance() throws Exception { 243 assertSame( 244 TestAllTypes.getDefaultInstance(), 245 TestAllTypes.getDefaultInstance().getDefaultInstanceForType()); 246 assertSame( 247 TestAllTypes.getDefaultInstance(), TestAllTypes.newBuilder().getDefaultInstanceForType()); 248 } 249 testMessageOrBuilder()250 public void testMessageOrBuilder() throws Exception { 251 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 252 TestUtil.setAllFields(builder); 253 TestAllTypes message = builder.build(); 254 TestUtil.assertAllFieldsSet(message); 255 } 256 testUsingBuilderMultipleTimes()257 public void testUsingBuilderMultipleTimes() throws Exception { 258 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 259 // primitive field scalar and repeated 260 builder.setOptionalSfixed64(100); 261 builder.addRepeatedInt32(100); 262 // enum field scalar and repeated 263 builder.setOptionalImportEnum(UnittestImport.ImportEnum.IMPORT_BAR); 264 builder.addRepeatedImportEnum(UnittestImport.ImportEnum.IMPORT_BAR); 265 // proto field scalar and repeated 266 builder.setOptionalForeignMessage(ForeignMessage.newBuilder().setC(1)); 267 builder.addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(1)); 268 269 TestAllTypes value1 = builder.build(); 270 271 assertEquals(100, value1.getOptionalSfixed64()); 272 assertEquals(100, value1.getRepeatedInt32(0)); 273 assertEquals(UnittestImport.ImportEnum.IMPORT_BAR, value1.getOptionalImportEnum()); 274 assertEquals(UnittestImport.ImportEnum.IMPORT_BAR, value1.getRepeatedImportEnum(0)); 275 assertEquals(1, value1.getOptionalForeignMessage().getC()); 276 assertEquals(1, value1.getRepeatedForeignMessage(0).getC()); 277 278 // Make sure that builder didn't update previously created values 279 builder.setOptionalSfixed64(200); 280 builder.setRepeatedInt32(0, 200); 281 builder.setOptionalImportEnum(UnittestImport.ImportEnum.IMPORT_FOO); 282 builder.setRepeatedImportEnum(0, UnittestImport.ImportEnum.IMPORT_FOO); 283 builder.setOptionalForeignMessage(ForeignMessage.newBuilder().setC(2)); 284 builder.setRepeatedForeignMessage(0, ForeignMessage.newBuilder().setC(2)); 285 286 TestAllTypes value2 = builder.build(); 287 288 // Make sure value1 didn't change. 289 assertEquals(100, value1.getOptionalSfixed64()); 290 assertEquals(100, value1.getRepeatedInt32(0)); 291 assertEquals(UnittestImport.ImportEnum.IMPORT_BAR, value1.getOptionalImportEnum()); 292 assertEquals(UnittestImport.ImportEnum.IMPORT_BAR, value1.getRepeatedImportEnum(0)); 293 assertEquals(1, value1.getOptionalForeignMessage().getC()); 294 assertEquals(1, value1.getRepeatedForeignMessage(0).getC()); 295 296 // Make sure value2 is correct 297 assertEquals(200, value2.getOptionalSfixed64()); 298 assertEquals(200, value2.getRepeatedInt32(0)); 299 assertEquals(UnittestImport.ImportEnum.IMPORT_FOO, value2.getOptionalImportEnum()); 300 assertEquals(UnittestImport.ImportEnum.IMPORT_FOO, value2.getRepeatedImportEnum(0)); 301 assertEquals(2, value2.getOptionalForeignMessage().getC()); 302 assertEquals(2, value2.getRepeatedForeignMessage(0).getC()); 303 } 304 testProtosShareRepeatedArraysIfDidntChange()305 public void testProtosShareRepeatedArraysIfDidntChange() throws Exception { 306 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 307 builder.addRepeatedInt32(100); 308 builder.addRepeatedForeignMessage(ForeignMessage.getDefaultInstance()); 309 310 TestAllTypes value1 = builder.build(); 311 TestAllTypes value2 = value1.toBuilder().build(); 312 313 assertSame(value1.getRepeatedInt32List(), value2.getRepeatedInt32List()); 314 assertSame(value1.getRepeatedForeignMessageList(), value2.getRepeatedForeignMessageList()); 315 } 316 testRepeatedArraysAreImmutable()317 public void testRepeatedArraysAreImmutable() throws Exception { 318 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 319 builder.addRepeatedInt32(100); 320 builder.addRepeatedImportEnum(UnittestImport.ImportEnum.IMPORT_BAR); 321 builder.addRepeatedForeignMessage(ForeignMessage.getDefaultInstance()); 322 assertIsUnmodifiable(builder.getRepeatedInt32List()); 323 assertIsUnmodifiable(builder.getRepeatedImportEnumList()); 324 assertIsUnmodifiable(builder.getRepeatedForeignMessageList()); 325 assertIsUnmodifiable(builder.getRepeatedFloatList()); 326 327 TestAllTypes value = builder.build(); 328 assertIsUnmodifiable(value.getRepeatedInt32List()); 329 assertIsUnmodifiable(value.getRepeatedImportEnumList()); 330 assertIsUnmodifiable(value.getRepeatedForeignMessageList()); 331 assertIsUnmodifiable(value.getRepeatedFloatList()); 332 } 333 testParsedMessagesAreImmutable()334 public void testParsedMessagesAreImmutable() throws Exception { 335 TestAllTypes value = TestAllTypes.parser().parseFrom(TestUtil.getAllSet().toByteString()); 336 assertIsUnmodifiable(value.getRepeatedInt32List()); 337 assertIsUnmodifiable(value.getRepeatedInt64List()); 338 assertIsUnmodifiable(value.getRepeatedUint32List()); 339 assertIsUnmodifiable(value.getRepeatedUint64List()); 340 assertIsUnmodifiable(value.getRepeatedSint32List()); 341 assertIsUnmodifiable(value.getRepeatedSint64List()); 342 assertIsUnmodifiable(value.getRepeatedFixed32List()); 343 assertIsUnmodifiable(value.getRepeatedFixed64List()); 344 assertIsUnmodifiable(value.getRepeatedSfixed32List()); 345 assertIsUnmodifiable(value.getRepeatedSfixed64List()); 346 assertIsUnmodifiable(value.getRepeatedFloatList()); 347 assertIsUnmodifiable(value.getRepeatedDoubleList()); 348 assertIsUnmodifiable(value.getRepeatedBoolList()); 349 assertIsUnmodifiable(value.getRepeatedStringList()); 350 assertIsUnmodifiable(value.getRepeatedBytesList()); 351 assertIsUnmodifiable(value.getRepeatedGroupList()); 352 assertIsUnmodifiable(value.getRepeatedNestedMessageList()); 353 assertIsUnmodifiable(value.getRepeatedForeignMessageList()); 354 assertIsUnmodifiable(value.getRepeatedImportMessageList()); 355 assertIsUnmodifiable(value.getRepeatedNestedEnumList()); 356 assertIsUnmodifiable(value.getRepeatedForeignEnumList()); 357 assertIsUnmodifiable(value.getRepeatedImportEnumList()); 358 } 359 assertIsUnmodifiable(List<?> list)360 private void assertIsUnmodifiable(List<?> list) { 361 if (list == Collections.emptyList()) { 362 // OKAY -- Need to check this b/c EmptyList allows you to call clear. 363 } else { 364 try { 365 list.clear(); 366 fail("List wasn't immutable"); 367 } catch (UnsupportedOperationException e) { 368 // good 369 } 370 } 371 } 372 testSettersRejectNull()373 public void testSettersRejectNull() throws Exception { 374 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 375 try { 376 builder.setOptionalString(null); 377 fail("Exception was not thrown"); 378 } catch (NullPointerException e) { 379 // We expect this exception. 380 } 381 try { 382 builder.setOptionalBytes(null); 383 fail("Exception was not thrown"); 384 } catch (NullPointerException e) { 385 // We expect this exception. 386 } 387 try { 388 builder.setOptionalNestedMessage((TestAllTypes.NestedMessage) null); 389 fail("Exception was not thrown"); 390 } catch (NullPointerException e) { 391 // We expect this exception. 392 } 393 try { 394 builder.setOptionalNestedMessage((TestAllTypes.NestedMessage.Builder) null); 395 fail("Exception was not thrown"); 396 } catch (NullPointerException e) { 397 // We expect this exception. 398 } 399 try { 400 builder.setOptionalNestedEnum(null); 401 fail("Exception was not thrown"); 402 } catch (NullPointerException e) { 403 // We expect this exception. 404 } 405 try { 406 builder.addRepeatedString(null); 407 fail("Exception was not thrown"); 408 } catch (NullPointerException e) { 409 // We expect this exception. 410 } 411 try { 412 builder.addRepeatedBytes(null); 413 fail("Exception was not thrown"); 414 } catch (NullPointerException e) { 415 // We expect this exception. 416 } 417 try { 418 builder.addRepeatedNestedMessage((TestAllTypes.NestedMessage) null); 419 fail("Exception was not thrown"); 420 } catch (NullPointerException e) { 421 // We expect this exception. 422 } 423 try { 424 builder.addRepeatedNestedMessage((TestAllTypes.NestedMessage.Builder) null); 425 fail("Exception was not thrown"); 426 } catch (NullPointerException e) { 427 // We expect this exception. 428 } 429 try { 430 builder.addRepeatedNestedEnum(null); 431 fail("Exception was not thrown"); 432 } catch (NullPointerException e) { 433 // We expect this exception. 434 } 435 } 436 testRepeatedSetters()437 public void testRepeatedSetters() throws Exception { 438 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 439 TestUtil.setAllFields(builder); 440 TestUtil.modifyRepeatedFields(builder); 441 TestAllTypes message = builder.build(); 442 TestUtil.assertRepeatedFieldsModified(message); 443 } 444 testRepeatedSettersRejectNull()445 public void testRepeatedSettersRejectNull() throws Exception { 446 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 447 448 builder.addRepeatedString("one"); 449 builder.addRepeatedString("two"); 450 try { 451 builder.setRepeatedString(1, null); 452 fail("Exception was not thrown"); 453 } catch (NullPointerException e) { 454 // We expect this exception. 455 } 456 457 builder.addRepeatedBytes(TestUtil.toBytes("one")); 458 builder.addRepeatedBytes(TestUtil.toBytes("two")); 459 try { 460 builder.setRepeatedBytes(1, null); 461 fail("Exception was not thrown"); 462 } catch (NullPointerException e) { 463 // We expect this exception. 464 } 465 466 builder.addRepeatedNestedMessage(TestAllTypes.NestedMessage.newBuilder().setBb(218).build()); 467 builder.addRepeatedNestedMessage(TestAllTypes.NestedMessage.newBuilder().setBb(456).build()); 468 try { 469 builder.setRepeatedNestedMessage(1, (TestAllTypes.NestedMessage) null); 470 fail("Exception was not thrown"); 471 } catch (NullPointerException e) { 472 // We expect this exception. 473 } 474 try { 475 builder.setRepeatedNestedMessage(1, (TestAllTypes.NestedMessage.Builder) null); 476 fail("Exception was not thrown"); 477 } catch (NullPointerException e) { 478 // We expect this exception. 479 } 480 481 builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.FOO); 482 builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR); 483 try { 484 builder.setRepeatedNestedEnum(1, null); 485 fail("Exception was not thrown"); 486 } catch (NullPointerException e) { 487 // We expect this exception. 488 } 489 } 490 testRepeatedAppend()491 public void testRepeatedAppend() throws Exception { 492 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 493 494 builder.addAllRepeatedInt32(Arrays.asList(1, 2, 3, 4)); 495 builder.addAllRepeatedForeignEnum(Arrays.asList(ForeignEnum.FOREIGN_BAZ)); 496 497 ForeignMessage foreignMessage = ForeignMessage.newBuilder().setC(12).build(); 498 builder.addAllRepeatedForeignMessage(Arrays.asList(foreignMessage)); 499 500 TestAllTypes message = builder.build(); 501 assertEquals(message.getRepeatedInt32List(), Arrays.asList(1, 2, 3, 4)); 502 assertEquals(message.getRepeatedForeignEnumList(), Arrays.asList(ForeignEnum.FOREIGN_BAZ)); 503 assertEquals(1, message.getRepeatedForeignMessageCount()); 504 assertEquals(12, message.getRepeatedForeignMessage(0).getC()); 505 } 506 testRepeatedAppendRejectsNull()507 public void testRepeatedAppendRejectsNull() throws Exception { 508 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 509 510 ForeignMessage foreignMessage = ForeignMessage.newBuilder().setC(12).build(); 511 try { 512 builder.addAllRepeatedForeignMessage(Arrays.asList(foreignMessage, (ForeignMessage) null)); 513 fail("Exception was not thrown"); 514 } catch (NullPointerException e) { 515 // We expect this exception. 516 } 517 518 try { 519 builder.addAllRepeatedForeignEnum(Arrays.asList(ForeignEnum.FOREIGN_BAZ, null)); 520 fail("Exception was not thrown"); 521 } catch (NullPointerException e) { 522 // We expect this exception. 523 } 524 525 try { 526 builder.addAllRepeatedString(Arrays.asList("one", null)); 527 fail("Exception was not thrown"); 528 } catch (NullPointerException e) { 529 // We expect this exception. 530 } 531 532 try { 533 builder.addAllRepeatedBytes(Arrays.asList(TestUtil.toBytes("one"), null)); 534 fail("Exception was not thrown"); 535 } catch (NullPointerException e) { 536 // We expect this exception. 537 } 538 } 539 testRepeatedAppendIterateOnlyOnce()540 public void testRepeatedAppendIterateOnlyOnce() throws Exception { 541 // Create a Iterable that can only be iterated once. 542 Iterable<String> stringIterable = 543 new Iterable<String>() { 544 private boolean called = false; 545 546 @Override 547 public Iterator<String> iterator() { 548 if (called) { 549 throw new IllegalStateException(); 550 } 551 called = true; 552 return Arrays.asList("one", "two", "three").iterator(); 553 } 554 }; 555 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 556 builder.addAllRepeatedString(stringIterable); 557 assertEquals(3, builder.getRepeatedStringCount()); 558 assertEquals("one", builder.getRepeatedString(0)); 559 assertEquals("two", builder.getRepeatedString(1)); 560 assertEquals("three", builder.getRepeatedString(2)); 561 562 try { 563 builder.addAllRepeatedString(stringIterable); 564 fail("Exception was not thrown"); 565 } catch (IllegalStateException e) { 566 // We expect this exception. 567 } 568 } 569 testMergeFromOtherRejectsNull()570 public void testMergeFromOtherRejectsNull() throws Exception { 571 try { 572 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 573 builder.mergeFrom((TestAllTypes) null); 574 fail("Exception was not thrown"); 575 } catch (NullPointerException e) { 576 // We expect this exception. 577 } 578 } 579 testSettingForeignMessageUsingBuilder()580 public void testSettingForeignMessageUsingBuilder() throws Exception { 581 TestAllTypes message = 582 TestAllTypes.newBuilder() 583 // Pass builder for foreign message instance. 584 .setOptionalForeignMessage(ForeignMessage.newBuilder().setC(123)) 585 .build(); 586 TestAllTypes expectedMessage = 587 TestAllTypes.newBuilder() 588 // Create expected version passing foreign message instance explicitly. 589 .setOptionalForeignMessage(ForeignMessage.newBuilder().setC(123).build()) 590 .build(); 591 // TODO(ngd): Upgrade to using real #equals method once implemented 592 assertEquals(expectedMessage.toString(), message.toString()); 593 } 594 testSettingRepeatedForeignMessageUsingBuilder()595 public void testSettingRepeatedForeignMessageUsingBuilder() throws Exception { 596 TestAllTypes message = 597 TestAllTypes.newBuilder() 598 // Pass builder for foreign message instance. 599 .addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(456)) 600 .build(); 601 TestAllTypes expectedMessage = 602 TestAllTypes.newBuilder() 603 // Create expected version passing foreign message instance explicitly. 604 .addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(456).build()) 605 .build(); 606 assertEquals(expectedMessage.toString(), message.toString()); 607 } 608 testDefaults()609 public void testDefaults() throws Exception { 610 TestUtil.assertClear(TestAllTypes.getDefaultInstance()); 611 TestUtil.assertClear(TestAllTypes.newBuilder().build()); 612 613 TestExtremeDefaultValues message = TestExtremeDefaultValues.getDefaultInstance(); 614 assertEquals("\u1234", message.getUtf8String()); 615 assertEquals(Double.POSITIVE_INFINITY, message.getInfDouble(), 0.0); 616 assertEquals(Double.NEGATIVE_INFINITY, message.getNegInfDouble(), 0.0); 617 assertTrue(Double.isNaN(message.getNanDouble())); 618 assertEquals(Float.POSITIVE_INFINITY, message.getInfFloat(), 0.0f); 619 assertEquals(Float.NEGATIVE_INFINITY, message.getNegInfFloat(), 0.0f); 620 assertTrue(Float.isNaN(message.getNanFloat())); 621 assertEquals("? ? ?? ?? ??? ??/ ??-", message.getCppTrigraph()); 622 } 623 testClear()624 public void testClear() throws Exception { 625 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 626 TestUtil.assertClear(builder); 627 TestUtil.setAllFields(builder); 628 builder.clear(); 629 TestUtil.assertClear(builder); 630 } 631 testReflectionGetters()632 public void testReflectionGetters() throws Exception { 633 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 634 TestUtil.setAllFields(builder); 635 reflectionTester.assertAllFieldsSetViaReflection(builder); 636 637 TestAllTypes message = builder.build(); 638 reflectionTester.assertAllFieldsSetViaReflection(message); 639 } 640 testReflectionSetters()641 public void testReflectionSetters() throws Exception { 642 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 643 reflectionTester.setAllFieldsViaReflection(builder); 644 TestUtil.assertAllFieldsSet(builder); 645 646 TestAllTypes message = builder.build(); 647 TestUtil.assertAllFieldsSet(message); 648 } 649 testReflectionSettersRejectNull()650 public void testReflectionSettersRejectNull() throws Exception { 651 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 652 reflectionTester.assertReflectionSettersRejectNull(builder); 653 } 654 testReflectionRepeatedSetters()655 public void testReflectionRepeatedSetters() throws Exception { 656 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 657 reflectionTester.setAllFieldsViaReflection(builder); 658 reflectionTester.modifyRepeatedFieldsViaReflection(builder); 659 TestUtil.assertRepeatedFieldsModified(builder); 660 661 TestAllTypes message = builder.build(); 662 TestUtil.assertRepeatedFieldsModified(message); 663 } 664 testReflectionRepeatedSettersRejectNull()665 public void testReflectionRepeatedSettersRejectNull() throws Exception { 666 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 667 reflectionTester.assertReflectionRepeatedSettersRejectNull(builder); 668 } 669 testReflectionDefaults()670 public void testReflectionDefaults() throws Exception { 671 reflectionTester.assertClearViaReflection(TestAllTypes.getDefaultInstance()); 672 reflectionTester.assertClearViaReflection(TestAllTypes.newBuilder().build()); 673 } 674 testReflectionGetOneof()675 public void testReflectionGetOneof() throws Exception { 676 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 677 reflectionTester.setAllFieldsViaReflection(builder); 678 Descriptors.OneofDescriptor oneof = TestAllTypes.getDescriptor().getOneofs().get(0); 679 Descriptors.FieldDescriptor field = TestAllTypes.getDescriptor().findFieldByName("oneof_bytes"); 680 assertSame(field, builder.getOneofFieldDescriptor(oneof)); 681 682 TestAllTypes message = builder.build(); 683 assertSame(field, message.getOneofFieldDescriptor(oneof)); 684 } 685 testReflectionClearOneof()686 public void testReflectionClearOneof() throws Exception { 687 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 688 reflectionTester.setAllFieldsViaReflection(builder); 689 Descriptors.OneofDescriptor oneof = TestAllTypes.getDescriptor().getOneofs().get(0); 690 Descriptors.FieldDescriptor field = TestAllTypes.getDescriptor().findFieldByName("oneof_bytes"); 691 692 assertTrue(builder.hasOneof(oneof)); 693 assertTrue(builder.hasField(field)); 694 builder.clearOneof(oneof); 695 assertFalse(builder.hasOneof(oneof)); 696 assertFalse(builder.hasField(field)); 697 } 698 testEnumInterface()699 public void testEnumInterface() throws Exception { 700 assertTrue( 701 TestAllTypes.getDefaultInstance().getDefaultNestedEnum() instanceof ProtocolMessageEnum); 702 } 703 testEnumMap()704 public void testEnumMap() throws Exception { 705 Internal.EnumLiteMap<ForeignEnum> map = ForeignEnum.internalGetValueMap(); 706 707 for (ForeignEnum value : ForeignEnum.values()) { 708 assertEquals(value, map.findValueByNumber(value.getNumber())); 709 } 710 711 assertTrue(map.findValueByNumber(12345) == null); 712 } 713 testParsePackedToUnpacked()714 public void testParsePackedToUnpacked() throws Exception { 715 TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder(); 716 TestUnpackedTypes message = builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build(); 717 TestUtil.assertUnpackedFieldsSet(message); 718 } 719 testParseUnpackedToPacked()720 public void testParseUnpackedToPacked() throws Exception { 721 TestPackedTypes.Builder builder = TestPackedTypes.newBuilder(); 722 TestPackedTypes message = builder.mergeFrom(TestUtil.getUnpackedSet().toByteString()).build(); 723 TestUtil.assertPackedFieldsSet(message); 724 } 725 726 // ================================================================= 727 // Extensions. 728 729 TestUtil.ReflectionTester extensionsReflectionTester = 730 new TestUtil.ReflectionTester( 731 TestAllExtensions.getDescriptor(), TestUtil.getFullExtensionRegistry()); 732 testExtensionMessageOrBuilder()733 public void testExtensionMessageOrBuilder() throws Exception { 734 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 735 TestUtil.setAllExtensions(builder); 736 TestAllExtensions message = builder.build(); 737 TestUtil.assertAllExtensionsSet(message); 738 } 739 testGetBuilderForExtensionField()740 public void testGetBuilderForExtensionField() { 741 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 742 Message.Builder fieldBuilder = 743 builder.newBuilderForField(UnittestProto.optionalNestedMessageExtension.getDescriptor()); 744 final int expected = 7432; 745 FieldDescriptor field = 746 NestedMessage.getDescriptor().findFieldByNumber(NestedMessage.BB_FIELD_NUMBER); 747 fieldBuilder.setField(field, expected); 748 assertEquals(expected, fieldBuilder.build().getField(field)); 749 } 750 751 testGetBuilderForNonMessageExtensionField()752 public void testGetBuilderForNonMessageExtensionField() { 753 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 754 try { 755 // This should throw an exception because the extension field is not a message. 756 builder.newBuilderForField(UnittestProto.optionalInt32Extension.getDescriptor()); 757 fail("Exception was not thrown"); 758 } catch (UnsupportedOperationException e) { 759 // This exception is expected. 760 } 761 } 762 testExtensionRepeatedSetters()763 public void testExtensionRepeatedSetters() throws Exception { 764 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 765 TestUtil.setAllExtensions(builder); 766 TestUtil.modifyRepeatedExtensions(builder); 767 TestAllExtensions message = builder.build(); 768 TestUtil.assertRepeatedExtensionsModified(message); 769 } 770 testExtensionDefaults()771 public void testExtensionDefaults() throws Exception { 772 TestUtil.assertExtensionsClear(TestAllExtensions.getDefaultInstance()); 773 TestUtil.assertExtensionsClear(TestAllExtensions.newBuilder().build()); 774 } 775 testUnsetRepeatedExtensionGetField()776 public void testUnsetRepeatedExtensionGetField() { 777 TestAllExtensions message = TestAllExtensions.getDefaultInstance(); 778 Object value; 779 780 value = message.getField(UnittestProto.repeatedStringExtension.getDescriptor()); 781 assertTrue(value instanceof List); 782 assertTrue(((List<?>) value).isEmpty()); 783 assertIsUnmodifiable((List<?>) value); 784 785 value = message.getField(UnittestProto.repeatedNestedMessageExtension.getDescriptor()); 786 assertTrue(value instanceof List); 787 assertTrue(((List<?>) value).isEmpty()); 788 assertIsUnmodifiable((List<?>) value); 789 } 790 testExtensionReflectionGetters()791 public void testExtensionReflectionGetters() throws Exception { 792 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 793 TestUtil.setAllExtensions(builder); 794 extensionsReflectionTester.assertAllFieldsSetViaReflection(builder); 795 796 TestAllExtensions message = builder.build(); 797 extensionsReflectionTester.assertAllFieldsSetViaReflection(message); 798 } 799 testExtensionReflectionSetters()800 public void testExtensionReflectionSetters() throws Exception { 801 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 802 extensionsReflectionTester.setAllFieldsViaReflection(builder); 803 TestUtil.assertAllExtensionsSet(builder); 804 805 TestAllExtensions message = builder.build(); 806 TestUtil.assertAllExtensionsSet(message); 807 } 808 testExtensionReflectionSettersRejectNull()809 public void testExtensionReflectionSettersRejectNull() throws Exception { 810 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 811 extensionsReflectionTester.assertReflectionSettersRejectNull(builder); 812 } 813 testExtensionReflectionRepeatedSetters()814 public void testExtensionReflectionRepeatedSetters() throws Exception { 815 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 816 extensionsReflectionTester.setAllFieldsViaReflection(builder); 817 extensionsReflectionTester.modifyRepeatedFieldsViaReflection(builder); 818 TestUtil.assertRepeatedExtensionsModified(builder); 819 820 TestAllExtensions message = builder.build(); 821 TestUtil.assertRepeatedExtensionsModified(message); 822 } 823 testExtensionReflectionRepeatedSettersRejectNull()824 public void testExtensionReflectionRepeatedSettersRejectNull() throws Exception { 825 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); 826 extensionsReflectionTester.assertReflectionRepeatedSettersRejectNull(builder); 827 } 828 testExtensionReflectionDefaults()829 public void testExtensionReflectionDefaults() throws Exception { 830 extensionsReflectionTester.assertClearViaReflection(TestAllExtensions.getDefaultInstance()); 831 extensionsReflectionTester.assertClearViaReflection(TestAllExtensions.newBuilder().build()); 832 } 833 testClearExtension()834 public void testClearExtension() throws Exception { 835 // clearExtension() is not actually used in TestUtil, so try it manually. 836 assertFalse( 837 TestAllExtensions.newBuilder() 838 .setExtension(UnittestProto.optionalInt32Extension, 1) 839 .clearExtension(UnittestProto.optionalInt32Extension) 840 .hasExtension(UnittestProto.optionalInt32Extension)); 841 assertEquals( 842 0, 843 TestAllExtensions.newBuilder() 844 .addExtension(UnittestProto.repeatedInt32Extension, 1) 845 .clearExtension(UnittestProto.repeatedInt32Extension) 846 .getExtensionCount(UnittestProto.repeatedInt32Extension)); 847 } 848 testExtensionCopy()849 public void testExtensionCopy() throws Exception { 850 TestAllExtensions original = TestUtil.getAllExtensionsSet(); 851 TestAllExtensions copy = TestAllExtensions.newBuilder(original).build(); 852 TestUtil.assertAllExtensionsSet(copy); 853 } 854 testExtensionMergeFrom()855 public void testExtensionMergeFrom() throws Exception { 856 TestAllExtensions original = 857 TestAllExtensions.newBuilder() 858 .setExtension(UnittestProto.optionalInt32Extension, 1) 859 .build(); 860 TestAllExtensions merged = TestAllExtensions.newBuilder().mergeFrom(original).build(); 861 assertTrue(merged.hasExtension(UnittestProto.optionalInt32Extension)); 862 assertEquals(1, (int) merged.getExtension(UnittestProto.optionalInt32Extension)); 863 } 864 865 // ================================================================= 866 // multiple_files_test 867 868 // Test that custom options of an file level enum are properly initialized. 869 // This test needs to be put before any other access to MultipleFilesTestProto 870 // or messages defined in multiple_files_test.proto because the class loading 871 // order affects initialization process of custom options. testEnumValueOptionsInMultipleFilesMode()872 public void testEnumValueOptionsInMultipleFilesMode() throws Exception { 873 assertEquals( 874 12345, 875 EnumWithNoOuter.FOO 876 .getValueDescriptor() 877 .getOptions() 878 .getExtension(MultipleFilesTestProto.enumValueOption) 879 .intValue()); 880 } 881 testMultipleFilesOption()882 public void testMultipleFilesOption() throws Exception { 883 // We mostly just want to check that things compile. 884 MessageWithNoOuter message = 885 MessageWithNoOuter.newBuilder() 886 .setNested(MessageWithNoOuter.NestedMessage.newBuilder().setI(1)) 887 .addForeign(TestAllTypes.newBuilder().setOptionalInt32(1)) 888 .setNestedEnum(MessageWithNoOuter.NestedEnum.BAZ) 889 .setForeignEnum(EnumWithNoOuter.BAR) 890 .build(); 891 assertEquals(message, MessageWithNoOuter.parseFrom(message.toByteString())); 892 893 assertEquals( 894 MultipleFilesTestProto.getDescriptor(), MessageWithNoOuter.getDescriptor().getFile()); 895 896 Descriptors.FieldDescriptor field = 897 MessageWithNoOuter.getDescriptor().findFieldByName("foreign_enum"); 898 assertEquals(EnumWithNoOuter.BAR.getValueDescriptor(), message.getField(field)); 899 900 assertEquals( 901 MultipleFilesTestProto.getDescriptor(), ServiceWithNoOuter.getDescriptor().getFile()); 902 903 assertFalse( 904 TestAllExtensions.getDefaultInstance() 905 .hasExtension(MultipleFilesTestProto.extensionWithOuter)); 906 } 907 testOptionalFieldWithRequiredSubfieldsOptimizedForSize()908 public void testOptionalFieldWithRequiredSubfieldsOptimizedForSize() throws Exception { 909 TestOptionalOptimizedForSize message = TestOptionalOptimizedForSize.getDefaultInstance(); 910 assertTrue(message.isInitialized()); 911 912 message = 913 TestOptionalOptimizedForSize.newBuilder() 914 .setO(TestRequiredOptimizedForSize.newBuilder().buildPartial()) 915 .buildPartial(); 916 assertFalse(message.isInitialized()); 917 918 message = 919 TestOptionalOptimizedForSize.newBuilder() 920 .setO(TestRequiredOptimizedForSize.newBuilder().setX(5).buildPartial()) 921 .buildPartial(); 922 assertTrue(message.isInitialized()); 923 } 924 testUninitializedExtensionInOptimizedForSize()925 public void testUninitializedExtensionInOptimizedForSize() throws Exception { 926 TestOptimizedForSize.Builder builder = TestOptimizedForSize.newBuilder(); 927 builder.setExtension( 928 TestOptimizedForSize.testExtension2, 929 TestRequiredOptimizedForSize.newBuilder().buildPartial()); 930 assertFalse(builder.isInitialized()); 931 assertFalse(builder.buildPartial().isInitialized()); 932 933 builder = TestOptimizedForSize.newBuilder(); 934 builder.setExtension( 935 TestOptimizedForSize.testExtension2, 936 TestRequiredOptimizedForSize.newBuilder().setX(10).buildPartial()); 937 assertTrue(builder.isInitialized()); 938 assertTrue(builder.buildPartial().isInitialized()); 939 } 940 testToBuilder()941 public void testToBuilder() throws Exception { 942 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 943 TestUtil.setAllFields(builder); 944 TestAllTypes message = builder.build(); 945 TestUtil.assertAllFieldsSet(message); 946 TestUtil.assertAllFieldsSet(message.toBuilder().build()); 947 } 948 testFieldConstantValues()949 public void testFieldConstantValues() throws Exception { 950 assertEquals(TestAllTypes.NestedMessage.BB_FIELD_NUMBER, 1); 951 assertEquals(TestAllTypes.OPTIONAL_INT32_FIELD_NUMBER, 1); 952 assertEquals(TestAllTypes.OPTIONALGROUP_FIELD_NUMBER, 16); 953 assertEquals(TestAllTypes.OPTIONAL_NESTED_MESSAGE_FIELD_NUMBER, 18); 954 assertEquals(TestAllTypes.OPTIONAL_NESTED_ENUM_FIELD_NUMBER, 21); 955 assertEquals(TestAllTypes.REPEATED_INT32_FIELD_NUMBER, 31); 956 assertEquals(TestAllTypes.REPEATEDGROUP_FIELD_NUMBER, 46); 957 assertEquals(TestAllTypes.REPEATED_NESTED_MESSAGE_FIELD_NUMBER, 48); 958 assertEquals(TestAllTypes.REPEATED_NESTED_ENUM_FIELD_NUMBER, 51); 959 } 960 testExtensionConstantValues()961 public void testExtensionConstantValues() throws Exception { 962 assertEquals(UnittestProto.TestRequired.SINGLE_FIELD_NUMBER, 1000); 963 assertEquals(UnittestProto.TestRequired.MULTI_FIELD_NUMBER, 1001); 964 assertEquals(UnittestProto.OPTIONAL_INT32_EXTENSION_FIELD_NUMBER, 1); 965 assertEquals(UnittestProto.OPTIONALGROUP_EXTENSION_FIELD_NUMBER, 16); 966 assertEquals(UnittestProto.OPTIONAL_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 18); 967 assertEquals(UnittestProto.OPTIONAL_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 21); 968 assertEquals(UnittestProto.REPEATED_INT32_EXTENSION_FIELD_NUMBER, 31); 969 assertEquals(UnittestProto.REPEATEDGROUP_EXTENSION_FIELD_NUMBER, 46); 970 assertEquals(UnittestProto.REPEATED_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 48); 971 assertEquals(UnittestProto.REPEATED_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 51); 972 } 973 testRecursiveMessageDefaultInstance()974 public void testRecursiveMessageDefaultInstance() throws Exception { 975 UnittestProto.TestRecursiveMessage message = 976 UnittestProto.TestRecursiveMessage.getDefaultInstance(); 977 assertTrue(message != null); 978 assertNotNull(message.getA()); 979 assertTrue(message.getA().equals(message)); 980 } 981 testSerialize()982 public void testSerialize() throws Exception { 983 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 984 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 985 TestUtil.setAllFields(builder); 986 TestAllTypes expected = builder.build(); 987 ObjectOutputStream out = new ObjectOutputStream(baos); 988 try { 989 out.writeObject(expected); 990 } finally { 991 out.close(); 992 } 993 ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); 994 ObjectInputStream in = new ObjectInputStream(bais); 995 TestAllTypes actual = (TestAllTypes) in.readObject(); 996 assertEquals(expected, actual); 997 } 998 testSerializePartial()999 public void testSerializePartial() throws Exception { 1000 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 1001 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 1002 TestAllTypes expected = builder.buildPartial(); 1003 ObjectOutputStream out = new ObjectOutputStream(baos); 1004 try { 1005 out.writeObject(expected); 1006 } finally { 1007 out.close(); 1008 } 1009 ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); 1010 ObjectInputStream in = new ObjectInputStream(bais); 1011 TestAllTypes actual = (TestAllTypes) in.readObject(); 1012 assertEquals(expected, actual); 1013 } 1014 testDeserializeWithoutClassField()1015 public void testDeserializeWithoutClassField() throws Exception { 1016 // serialized form for version <=3.6.0 1017 // just includes messageClassName and asBytes 1018 1019 // Int32Value.newBuilder().setValue(123).build() 1020 byte[] int32ValueBytes = 1021 new byte[] { 1022 -84, -19, 0, 5, 115, 114, 0, 55, 99, 111, 109, 46, 103, 111, 111, 103, 108, 101, 46, 112, 1023 114, 111, 116, 111, 98, 117, 102, 46, 71, 101, 110, 101, 114, 97, 116, 101, 100, 77, 101, 1024 115, 115, 97, 103, 101, 76, 105, 116, 101, 36, 83, 101, 114, 105, 97, 108, 105, 122, 101, 1025 100, 70, 111, 114, 109, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 91, 0, 7, 97, 115, 66, 121, 116, 1026 101, 115, 116, 0, 2, 91, 66, 76, 0, 16, 109, 101, 115, 115, 97, 103, 101, 67, 108, 97, 1027 115, 115, 78, 97, 109, 101, 116, 0, 18, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 1028 83, 116, 114, 105, 110, 103, 59, 120, 112, 117, 114, 0, 2, 91, 66, -84, -13, 23, -8, 6, 8, 1029 84, -32, 2, 0, 0, 120, 112, 0, 0, 0, 2, 8, 123, 116, 0, 30, 99, 111, 109, 46, 103, 111, 1030 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 73, 110, 116, 51, 50, 1031 86, 97, 108, 117, 101 1032 }; 1033 1034 ByteArrayInputStream bais = new ByteArrayInputStream(int32ValueBytes); 1035 ObjectInputStream in = new ObjectInputStream(bais); 1036 Int32Value int32Value = (Int32Value) in.readObject(); 1037 assertEquals(123, int32Value.getValue()); 1038 } 1039 testDeserializeWithClassField()1040 public void testDeserializeWithClassField() throws Exception { 1041 // serialized form for version > 3.6.0 1042 // includes messageClass, messageClassName (for compatibility), and asBytes 1043 1044 // Int32Value.newBuilder().setValue(123).build() 1045 byte[] int32ValueBytes = 1046 new byte[] { 1047 -84, -19, 0, 5, 115, 114, 0, 55, 99, 111, 109, 46, 103, 111, 111, 103, 108, 101, 46, 112, 1048 114, 111, 116, 111, 98, 117, 102, 46, 71, 101, 110, 101, 114, 97, 116, 101, 100, 77, 101, 1049 115, 115, 97, 103, 101, 76, 105, 116, 101, 36, 83, 101, 114, 105, 97, 108, 105, 122, 101, 1050 100, 70, 111, 114, 109, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 91, 0, 7, 97, 115, 66, 121, 116, 1051 101, 115, 116, 0, 2, 91, 66, 76, 0, 12, 109, 101, 115, 115, 97, 103, 101, 67, 108, 97, 1052 115, 115, 116, 0, 17, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 67, 108, 97, 115, 1053 115, 59, 76, 0, 16, 109, 101, 115, 115, 97, 103, 101, 67, 108, 97, 115, 115, 78, 97, 109, 1054 101, 116, 0, 18, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 1055 103, 59, 120, 112, 117, 114, 0, 2, 91, 66, -84, -13, 23, -8, 6, 8, 84, -32, 2, 0, 0, 120, 1056 112, 0, 0, 0, 2, 8, 123, 118, 114, 0, 30, 99, 111, 109, 46, 103, 111, 111, 103, 108, 101, 1057 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 73, 110, 116, 51, 50, 86, 97, 108, 117, 1058 101, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 66, 0, 21, 109, 101, 109, 111, 105, 122, 101, 100, 1059 73, 115, 73, 110, 105, 116, 105, 97, 108, 105, 122, 101, 100, 73, 0, 6, 118, 97, 108, 117, 1060 101, 95, 120, 114, 0, 38, 99, 111, 109, 46, 103, 111, 111, 103, 108, 101, 46, 112, 114, 1061 111, 116, 111, 98, 117, 102, 46, 71, 101, 110, 101, 114, 97, 116, 101, 100, 77, 101, 115, 1062 115, 97, 103, 101, 86, 51, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 76, 0, 13, 117, 110, 107, 110, 1063 111, 119, 110, 70, 105, 101, 108, 100, 115, 116, 0, 37, 76, 99, 111, 109, 47, 103, 111, 1064 111, 103, 108, 101, 47, 112, 114, 111, 116, 111, 98, 117, 102, 47, 85, 110, 107, 110, 111, 1065 119, 110, 70, 105, 101, 108, 100, 83, 101, 116, 59, 120, 112, 116, 0, 30, 99, 111, 109, 1066 46, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 73, 110, 1067 116, 51, 50, 86, 97, 108, 117, 101 1068 }; 1069 1070 ByteArrayInputStream bais = new ByteArrayInputStream(int32ValueBytes); 1071 ObjectInputStream in = new ObjectInputStream(bais); 1072 Int32Value int32Value = (Int32Value) in.readObject(); 1073 assertEquals(123, int32Value.getValue()); 1074 } 1075 testEnumValues()1076 public void testEnumValues() { 1077 assertEquals(TestAllTypes.NestedEnum.BAR_VALUE, TestAllTypes.NestedEnum.BAR.getNumber()); 1078 assertEquals(TestAllTypes.NestedEnum.BAZ_VALUE, TestAllTypes.NestedEnum.BAZ.getNumber()); 1079 assertEquals(TestAllTypes.NestedEnum.FOO_VALUE, TestAllTypes.NestedEnum.FOO.getNumber()); 1080 } 1081 testNonNestedExtensionInitialization()1082 public void testNonNestedExtensionInitialization() { 1083 assertTrue( 1084 NonNestedExtension.nonNestedExtension.getMessageDefaultInstance() 1085 instanceof MyNonNestedExtension); 1086 assertEquals( 1087 "nonNestedExtension", NonNestedExtension.nonNestedExtension.getDescriptor().getName()); 1088 } 1089 testNestedExtensionInitialization()1090 public void testNestedExtensionInitialization() { 1091 assertTrue( 1092 MyNestedExtension.recursiveExtension.getMessageDefaultInstance() 1093 instanceof MessageToBeExtended); 1094 assertEquals( 1095 "recursiveExtension", MyNestedExtension.recursiveExtension.getDescriptor().getName()); 1096 } 1097 testInvalidations()1098 public void testInvalidations() throws Exception { 1099 GeneratedMessageV3.setAlwaysUseFieldBuildersForTesting(true); 1100 TestAllTypes.NestedMessage nestedMessage1 = TestAllTypes.NestedMessage.newBuilder().build(); 1101 TestAllTypes.NestedMessage nestedMessage2 = TestAllTypes.NestedMessage.newBuilder().build(); 1102 1103 // Set all three flavors (enum, primitive, message and singular/repeated) 1104 // and verify no invalidations fired 1105 TestUtil.MockBuilderParent mockParent = new TestUtil.MockBuilderParent(); 1106 1107 TestAllTypes.Builder builder = 1108 (TestAllTypes.Builder) 1109 ((AbstractMessage) TestAllTypes.getDefaultInstance()).newBuilderForType(mockParent); 1110 builder.setOptionalInt32(1); 1111 builder.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAR); 1112 builder.setOptionalNestedMessage(nestedMessage1); 1113 builder.addRepeatedInt32(1); 1114 builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR); 1115 builder.addRepeatedNestedMessage(nestedMessage1); 1116 assertEquals(0, mockParent.getInvalidationCount()); 1117 1118 // Now tell it we want changes and make sure it's only fired once 1119 // And do this for each flavor 1120 1121 // primitive single 1122 builder.buildPartial(); 1123 builder.setOptionalInt32(2); 1124 builder.setOptionalInt32(3); 1125 assertEquals(1, mockParent.getInvalidationCount()); 1126 1127 // enum single 1128 builder.buildPartial(); 1129 builder.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAZ); 1130 builder.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAR); 1131 assertEquals(2, mockParent.getInvalidationCount()); 1132 1133 // message single 1134 builder.buildPartial(); 1135 builder.setOptionalNestedMessage(nestedMessage2); 1136 builder.setOptionalNestedMessage(nestedMessage1); 1137 assertEquals(3, mockParent.getInvalidationCount()); 1138 1139 // primitive repeated 1140 builder.buildPartial(); 1141 builder.addRepeatedInt32(2); 1142 builder.addRepeatedInt32(3); 1143 assertEquals(4, mockParent.getInvalidationCount()); 1144 1145 // enum repeated 1146 builder.buildPartial(); 1147 builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ); 1148 builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ); 1149 assertEquals(5, mockParent.getInvalidationCount()); 1150 1151 // message repeated 1152 builder.buildPartial(); 1153 builder.addRepeatedNestedMessage(nestedMessage2); 1154 builder.addRepeatedNestedMessage(nestedMessage1); 1155 assertEquals(6, mockParent.getInvalidationCount()); 1156 } 1157 testInvalidations_Extensions()1158 public void testInvalidations_Extensions() throws Exception { 1159 TestUtil.MockBuilderParent mockParent = new TestUtil.MockBuilderParent(); 1160 1161 TestAllExtensions.Builder builder = 1162 (TestAllExtensions.Builder) 1163 ((AbstractMessage) TestAllExtensions.getDefaultInstance()) 1164 .newBuilderForType(mockParent); 1165 1166 builder.addExtension(UnittestProto.repeatedInt32Extension, 1); 1167 builder.setExtension(UnittestProto.repeatedInt32Extension, 0, 2); 1168 builder.clearExtension(UnittestProto.repeatedInt32Extension); 1169 assertEquals(0, mockParent.getInvalidationCount()); 1170 1171 // Now tell it we want changes and make sure it's only fired once 1172 builder.buildPartial(); 1173 builder.addExtension(UnittestProto.repeatedInt32Extension, 2); 1174 builder.addExtension(UnittestProto.repeatedInt32Extension, 3); 1175 assertEquals(1, mockParent.getInvalidationCount()); 1176 1177 builder.buildPartial(); 1178 builder.setExtension(UnittestProto.repeatedInt32Extension, 0, 4); 1179 builder.setExtension(UnittestProto.repeatedInt32Extension, 1, 5); 1180 assertEquals(2, mockParent.getInvalidationCount()); 1181 1182 builder.buildPartial(); 1183 builder.clearExtension(UnittestProto.repeatedInt32Extension); 1184 builder.clearExtension(UnittestProto.repeatedInt32Extension); 1185 assertEquals(3, mockParent.getInvalidationCount()); 1186 } 1187 testBaseMessageOrBuilder()1188 public void testBaseMessageOrBuilder() { 1189 // Mostly just makes sure the base interface exists and has some methods. 1190 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 1191 TestAllTypes message = builder.buildPartial(); 1192 TestAllTypesOrBuilder messageAsInterface = (TestAllTypesOrBuilder) message; 1193 1194 assertEquals(messageAsInterface.getDefaultBool(), messageAsInterface.getDefaultBool()); 1195 assertEquals( 1196 messageAsInterface.getOptionalDouble(), messageAsInterface.getOptionalDouble(), 0.0); 1197 } 1198 testMessageOrBuilderGetters()1199 public void testMessageOrBuilderGetters() { 1200 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 1201 1202 // single fields 1203 assertSame(ForeignMessage.getDefaultInstance(), builder.getOptionalForeignMessageOrBuilder()); 1204 ForeignMessage.Builder subBuilder = builder.getOptionalForeignMessageBuilder(); 1205 assertSame(subBuilder, builder.getOptionalForeignMessageOrBuilder()); 1206 1207 // repeated fields 1208 ForeignMessage m0 = ForeignMessage.newBuilder().buildPartial(); 1209 ForeignMessage m1 = ForeignMessage.newBuilder().buildPartial(); 1210 ForeignMessage m2 = ForeignMessage.newBuilder().buildPartial(); 1211 builder.addRepeatedForeignMessage(m0); 1212 builder.addRepeatedForeignMessage(m1); 1213 builder.addRepeatedForeignMessage(m2); 1214 assertSame(m0, builder.getRepeatedForeignMessageOrBuilder(0)); 1215 assertSame(m1, builder.getRepeatedForeignMessageOrBuilder(1)); 1216 assertSame(m2, builder.getRepeatedForeignMessageOrBuilder(2)); 1217 ForeignMessage.Builder b0 = builder.getRepeatedForeignMessageBuilder(0); 1218 ForeignMessage.Builder b1 = builder.getRepeatedForeignMessageBuilder(1); 1219 assertSame(b0, builder.getRepeatedForeignMessageOrBuilder(0)); 1220 assertSame(b1, builder.getRepeatedForeignMessageOrBuilder(1)); 1221 assertSame(m2, builder.getRepeatedForeignMessageOrBuilder(2)); 1222 1223 List<? extends ForeignMessageOrBuilder> messageOrBuilderList = 1224 builder.getRepeatedForeignMessageOrBuilderList(); 1225 assertSame(b0, messageOrBuilderList.get(0)); 1226 assertSame(b1, messageOrBuilderList.get(1)); 1227 assertSame(m2, messageOrBuilderList.get(2)); 1228 } 1229 testGetFieldBuilder()1230 public void testGetFieldBuilder() { 1231 Descriptor descriptor = TestAllTypes.getDescriptor(); 1232 1233 FieldDescriptor fieldDescriptor = descriptor.findFieldByName("optional_nested_message"); 1234 FieldDescriptor foreignFieldDescriptor = descriptor.findFieldByName("optional_foreign_message"); 1235 FieldDescriptor importFieldDescriptor = descriptor.findFieldByName("optional_import_message"); 1236 1237 // Mutate the message with new field builder 1238 // Mutate nested message 1239 TestAllTypes.Builder builder1 = TestAllTypes.newBuilder(); 1240 Message.Builder fieldBuilder1 = 1241 builder1 1242 .newBuilderForField(fieldDescriptor) 1243 .mergeFrom((Message) builder1.getField(fieldDescriptor)); 1244 FieldDescriptor subFieldDescriptor1 = 1245 fieldBuilder1.getDescriptorForType().findFieldByName("bb"); 1246 fieldBuilder1.setField(subFieldDescriptor1, 1); 1247 builder1.setField(fieldDescriptor, fieldBuilder1.build()); 1248 1249 // Mutate foreign message 1250 Message.Builder foreignFieldBuilder1 = 1251 builder1 1252 .newBuilderForField(foreignFieldDescriptor) 1253 .mergeFrom((Message) builder1.getField(foreignFieldDescriptor)); 1254 FieldDescriptor subForeignFieldDescriptor1 = 1255 foreignFieldBuilder1.getDescriptorForType().findFieldByName("c"); 1256 foreignFieldBuilder1.setField(subForeignFieldDescriptor1, 2); 1257 builder1.setField(foreignFieldDescriptor, foreignFieldBuilder1.build()); 1258 1259 // Mutate import message 1260 Message.Builder importFieldBuilder1 = 1261 builder1 1262 .newBuilderForField(importFieldDescriptor) 1263 .mergeFrom((Message) builder1.getField(importFieldDescriptor)); 1264 FieldDescriptor subImportFieldDescriptor1 = 1265 importFieldBuilder1.getDescriptorForType().findFieldByName("d"); 1266 importFieldBuilder1.setField(subImportFieldDescriptor1, 3); 1267 builder1.setField(importFieldDescriptor, importFieldBuilder1.build()); 1268 1269 Message newMessage1 = builder1.build(); 1270 1271 // Mutate the message with existing field builder 1272 // Mutate nested message 1273 TestAllTypes.Builder builder2 = TestAllTypes.newBuilder(); 1274 Message.Builder fieldBuilder2 = builder2.getFieldBuilder(fieldDescriptor); 1275 FieldDescriptor subFieldDescriptor2 = 1276 fieldBuilder2.getDescriptorForType().findFieldByName("bb"); 1277 fieldBuilder2.setField(subFieldDescriptor2, 1); 1278 builder2.setField(fieldDescriptor, fieldBuilder2.build()); 1279 1280 // Mutate foreign message 1281 Message.Builder foreignFieldBuilder2 = 1282 builder2 1283 .newBuilderForField(foreignFieldDescriptor) 1284 .mergeFrom((Message) builder2.getField(foreignFieldDescriptor)); 1285 FieldDescriptor subForeignFieldDescriptor2 = 1286 foreignFieldBuilder2.getDescriptorForType().findFieldByName("c"); 1287 foreignFieldBuilder2.setField(subForeignFieldDescriptor2, 2); 1288 builder2.setField(foreignFieldDescriptor, foreignFieldBuilder2.build()); 1289 1290 // Mutate import message 1291 Message.Builder importFieldBuilder2 = 1292 builder2 1293 .newBuilderForField(importFieldDescriptor) 1294 .mergeFrom((Message) builder2.getField(importFieldDescriptor)); 1295 FieldDescriptor subImportFieldDescriptor2 = 1296 importFieldBuilder2.getDescriptorForType().findFieldByName("d"); 1297 importFieldBuilder2.setField(subImportFieldDescriptor2, 3); 1298 builder2.setField(importFieldDescriptor, importFieldBuilder2.build()); 1299 1300 Message newMessage2 = builder2.build(); 1301 1302 // These two messages should be equal. 1303 assertEquals(newMessage1, newMessage2); 1304 } 1305 testGetFieldBuilderWithInitializedValue()1306 public void testGetFieldBuilderWithInitializedValue() { 1307 Descriptor descriptor = TestAllTypes.getDescriptor(); 1308 FieldDescriptor fieldDescriptor = descriptor.findFieldByName("optional_nested_message"); 1309 1310 // Before setting field, builder is initialized by default value. 1311 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 1312 NestedMessage.Builder fieldBuilder = 1313 (NestedMessage.Builder) builder.getFieldBuilder(fieldDescriptor); 1314 assertEquals(0, fieldBuilder.getBb()); 1315 1316 // Setting field value with new field builder instance. 1317 builder = TestAllTypes.newBuilder(); 1318 NestedMessage.Builder newFieldBuilder = builder.getOptionalNestedMessageBuilder(); 1319 newFieldBuilder.setBb(2); 1320 // Then get the field builder instance by getFieldBuilder(). 1321 fieldBuilder = (NestedMessage.Builder) builder.getFieldBuilder(fieldDescriptor); 1322 // It should contain new value. 1323 assertEquals(2, fieldBuilder.getBb()); 1324 // These two builder should be equal. 1325 assertSame(fieldBuilder, newFieldBuilder); 1326 } 1327 testGetFieldBuilderNotSupportedException()1328 public void testGetFieldBuilderNotSupportedException() { 1329 Descriptor descriptor = TestAllTypes.getDescriptor(); 1330 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 1331 try { 1332 builder.getFieldBuilder(descriptor.findFieldByName("optional_int32")); 1333 fail("Exception was not thrown"); 1334 } catch (UnsupportedOperationException e) { 1335 // We expect this exception. 1336 } 1337 try { 1338 builder.getFieldBuilder(descriptor.findFieldByName("optional_nested_enum")); 1339 fail("Exception was not thrown"); 1340 } catch (UnsupportedOperationException e) { 1341 // We expect this exception. 1342 } 1343 try { 1344 builder.getFieldBuilder(descriptor.findFieldByName("repeated_int32")); 1345 fail("Exception was not thrown"); 1346 } catch (UnsupportedOperationException e) { 1347 // We expect this exception. 1348 } 1349 try { 1350 builder.getFieldBuilder(descriptor.findFieldByName("repeated_nested_enum")); 1351 fail("Exception was not thrown"); 1352 } catch (UnsupportedOperationException e) { 1353 // We expect this exception. 1354 } 1355 try { 1356 builder.getFieldBuilder(descriptor.findFieldByName("repeated_nested_message")); 1357 fail("Exception was not thrown"); 1358 } catch (UnsupportedOperationException e) { 1359 // We expect this exception. 1360 } 1361 } 1362 1363 // Test that when the default outer class name conflicts with another type 1364 // defined in the proto the compiler will append a suffix to avoid the 1365 // conflict. testConflictingOuterClassName()1366 public void testConflictingOuterClassName() { 1367 // We just need to make sure we can refer to the outer class with the 1368 // expected name. There is nothing else to test. 1369 OuterClassNameTestOuterClass.OuterClassNameTest message = 1370 OuterClassNameTestOuterClass.OuterClassNameTest.newBuilder().build(); 1371 assertTrue( 1372 message.getDescriptorForType() 1373 == OuterClassNameTestOuterClass.OuterClassNameTest.getDescriptor()); 1374 1375 OuterClassNameTest2OuterClass.TestMessage2.NestedMessage.OuterClassNameTest2 message2 = 1376 OuterClassNameTest2OuterClass.TestMessage2.NestedMessage.OuterClassNameTest2.newBuilder() 1377 .build(); 1378 assertEquals(0, message2.getSerializedSize()); 1379 1380 OuterClassNameTest3OuterClass.TestMessage3.NestedMessage.OuterClassNameTest3 enumValue = 1381 OuterClassNameTest3OuterClass.TestMessage3.NestedMessage.OuterClassNameTest3.DUMMY_VALUE; 1382 assertEquals(1, enumValue.getNumber()); 1383 } 1384 1385 // ================================================================= 1386 // oneof generated code test testOneofEnumCase()1387 public void testOneofEnumCase() throws Exception { 1388 TestOneof2 message = 1389 TestOneof2.newBuilder().setFooInt(123).setFooString("foo").setFooCord("bar").build(); 1390 TestUtil.assertAtMostOneFieldSetOneof(message); 1391 } 1392 testClearOneof()1393 public void testClearOneof() throws Exception { 1394 TestOneof2.Builder builder = TestOneof2.newBuilder().setFooInt(123); 1395 assertEquals(TestOneof2.FooCase.FOO_INT, builder.getFooCase()); 1396 builder.clearFoo(); 1397 assertEquals(TestOneof2.FooCase.FOO_NOT_SET, builder.getFooCase()); 1398 } 1399 testSetOneofClearsOthers()1400 public void testSetOneofClearsOthers() throws Exception { 1401 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1402 TestOneof2 message = builder.setFooInt(123).setFooString("foo").buildPartial(); 1403 assertTrue(message.hasFooString()); 1404 TestUtil.assertAtMostOneFieldSetOneof(message); 1405 1406 message = builder.setFooCord("bar").buildPartial(); 1407 assertTrue(message.hasFooCord()); 1408 TestUtil.assertAtMostOneFieldSetOneof(message); 1409 1410 message = builder.setFooStringPiece("baz").buildPartial(); 1411 assertTrue(message.hasFooStringPiece()); 1412 TestUtil.assertAtMostOneFieldSetOneof(message); 1413 1414 message = builder.setFooBytes(TestUtil.toBytes("qux")).buildPartial(); 1415 assertTrue(message.hasFooBytes()); 1416 TestUtil.assertAtMostOneFieldSetOneof(message); 1417 1418 message = builder.setFooEnum(TestOneof2.NestedEnum.FOO).buildPartial(); 1419 assertTrue(message.hasFooEnum()); 1420 TestUtil.assertAtMostOneFieldSetOneof(message); 1421 1422 message = 1423 builder 1424 .setFooMessage(TestOneof2.NestedMessage.newBuilder().setQuxInt(234).build()) 1425 .buildPartial(); 1426 assertTrue(message.hasFooMessage()); 1427 TestUtil.assertAtMostOneFieldSetOneof(message); 1428 1429 message = builder.setFooInt(123).buildPartial(); 1430 assertTrue(message.hasFooInt()); 1431 TestUtil.assertAtMostOneFieldSetOneof(message); 1432 } 1433 testOneofTypes()1434 public void testOneofTypes() throws Exception { 1435 // Primitive 1436 { 1437 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1438 assertEquals(builder.getFooInt(), 0); 1439 assertFalse(builder.hasFooInt()); 1440 assertTrue(builder.setFooInt(123).hasFooInt()); 1441 assertEquals(builder.getFooInt(), 123); 1442 TestOneof2 message = builder.buildPartial(); 1443 assertTrue(message.hasFooInt()); 1444 assertEquals(message.getFooInt(), 123); 1445 1446 assertFalse(builder.clearFooInt().hasFooInt()); 1447 TestOneof2 message2 = builder.build(); 1448 assertFalse(message2.hasFooInt()); 1449 assertEquals(0, message2.getFooInt()); 1450 } 1451 1452 // Enum 1453 { 1454 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1455 assertEquals(TestOneof2.NestedEnum.FOO, builder.getFooEnum()); 1456 assertTrue(builder.setFooEnum(TestOneof2.NestedEnum.BAR).hasFooEnum()); 1457 assertEquals(TestOneof2.NestedEnum.BAR, builder.getFooEnum()); 1458 TestOneof2 message = builder.buildPartial(); 1459 assertTrue(message.hasFooEnum()); 1460 assertEquals(TestOneof2.NestedEnum.BAR, message.getFooEnum()); 1461 1462 assertFalse(builder.clearFooEnum().hasFooEnum()); 1463 TestOneof2 message2 = builder.build(); 1464 assertFalse(message2.hasFooEnum()); 1465 assertEquals(TestOneof2.NestedEnum.FOO, message2.getFooEnum()); 1466 } 1467 1468 // String 1469 { 1470 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1471 assertEquals("", builder.getFooString()); 1472 builder.setFooString("foo"); 1473 assertTrue(builder.hasFooString()); 1474 assertEquals("foo", builder.getFooString()); 1475 TestOneof2 message = builder.buildPartial(); 1476 assertTrue(message.hasFooString()); 1477 assertEquals("foo", message.getFooString()); 1478 assertEquals(message.getFooStringBytes(), TestUtil.toBytes("foo")); 1479 1480 assertFalse(builder.clearFooString().hasFooString()); 1481 TestOneof2 message2 = builder.buildPartial(); 1482 assertFalse(message2.hasFooString()); 1483 assertEquals("", message2.getFooString()); 1484 assertEquals(message2.getFooStringBytes(), TestUtil.toBytes("")); 1485 1486 // Get method should not change the oneof value. 1487 builder.setFooInt(123); 1488 assertEquals("", builder.getFooString()); 1489 assertEquals(builder.getFooStringBytes(), TestUtil.toBytes("")); 1490 assertEquals(123, builder.getFooInt()); 1491 1492 message = builder.build(); 1493 assertEquals("", message.getFooString()); 1494 assertEquals(message.getFooStringBytes(), TestUtil.toBytes("")); 1495 assertEquals(123, message.getFooInt()); 1496 } 1497 1498 // Cord 1499 { 1500 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1501 assertEquals("", builder.getFooCord()); 1502 builder.setFooCord("foo"); 1503 assertTrue(builder.hasFooCord()); 1504 assertEquals("foo", builder.getFooCord()); 1505 TestOneof2 message = builder.buildPartial(); 1506 assertTrue(message.hasFooCord()); 1507 assertEquals("foo", message.getFooCord()); 1508 assertEquals(message.getFooCordBytes(), TestUtil.toBytes("foo")); 1509 1510 assertFalse(builder.clearFooCord().hasFooCord()); 1511 TestOneof2 message2 = builder.build(); 1512 assertFalse(message2.hasFooCord()); 1513 assertEquals("", message2.getFooCord()); 1514 assertEquals(message2.getFooCordBytes(), TestUtil.toBytes("")); 1515 } 1516 1517 // StringPiece 1518 { 1519 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1520 assertEquals("", builder.getFooStringPiece()); 1521 builder.setFooStringPiece("foo"); 1522 assertTrue(builder.hasFooStringPiece()); 1523 assertEquals("foo", builder.getFooStringPiece()); 1524 TestOneof2 message = builder.buildPartial(); 1525 assertTrue(message.hasFooStringPiece()); 1526 assertEquals("foo", message.getFooStringPiece()); 1527 assertEquals(message.getFooStringPieceBytes(), TestUtil.toBytes("foo")); 1528 1529 assertFalse(builder.clearFooStringPiece().hasFooStringPiece()); 1530 TestOneof2 message2 = builder.build(); 1531 assertFalse(message2.hasFooStringPiece()); 1532 assertEquals("", message2.getFooStringPiece()); 1533 assertEquals(message2.getFooStringPieceBytes(), TestUtil.toBytes("")); 1534 } 1535 1536 // Message 1537 { 1538 // set 1539 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1540 assertEquals(0, builder.getFooMessage().getQuxInt()); 1541 builder.setFooMessage(TestOneof2.NestedMessage.newBuilder().setQuxInt(234).build()); 1542 assertTrue(builder.hasFooMessage()); 1543 assertEquals(234, builder.getFooMessage().getQuxInt()); 1544 TestOneof2 message = builder.buildPartial(); 1545 assertTrue(message.hasFooMessage()); 1546 assertEquals(234, message.getFooMessage().getQuxInt()); 1547 1548 // clear 1549 assertFalse(builder.clearFooMessage().hasFooString()); 1550 message = builder.build(); 1551 assertFalse(message.hasFooMessage()); 1552 assertEquals(0, message.getFooMessage().getQuxInt()); 1553 1554 // nested builder 1555 builder = TestOneof2.newBuilder(); 1556 assertSame(builder.getFooMessageOrBuilder(), TestOneof2.NestedMessage.getDefaultInstance()); 1557 assertFalse(builder.hasFooMessage()); 1558 builder.getFooMessageBuilder().setQuxInt(123); 1559 assertTrue(builder.hasFooMessage()); 1560 assertEquals(123, builder.getFooMessage().getQuxInt()); 1561 message = builder.build(); 1562 assertTrue(message.hasFooMessage()); 1563 assertEquals(123, message.getFooMessage().getQuxInt()); 1564 } 1565 1566 // LazyMessage is tested in LazyMessageLiteTest.java 1567 } 1568 testOneofMerge()1569 public void testOneofMerge() throws Exception { 1570 // Primitive Type 1571 { 1572 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1573 TestOneof2 message = builder.setFooInt(123).build(); 1574 TestOneof2 message2 = TestOneof2.newBuilder().mergeFrom(message).build(); 1575 assertTrue(message2.hasFooInt()); 1576 assertEquals(123, message2.getFooInt()); 1577 } 1578 1579 // String 1580 { 1581 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1582 TestOneof2 message = builder.setFooString("foo").build(); 1583 TestOneof2 message2 = TestOneof2.newBuilder().mergeFrom(message).build(); 1584 assertTrue(message2.hasFooString()); 1585 assertEquals("foo", message2.getFooString()); 1586 } 1587 1588 // Enum 1589 { 1590 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1591 TestOneof2 message = builder.setFooEnum(TestOneof2.NestedEnum.BAR).build(); 1592 TestOneof2 message2 = TestOneof2.newBuilder().mergeFrom(message).build(); 1593 assertTrue(message2.hasFooEnum()); 1594 assertEquals(TestOneof2.NestedEnum.BAR, message2.getFooEnum()); 1595 } 1596 1597 // Message 1598 { 1599 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1600 TestOneof2 message = 1601 builder 1602 .setFooMessage(TestOneof2.NestedMessage.newBuilder().setQuxInt(234).build()) 1603 .build(); 1604 TestOneof2 message2 = TestOneof2.newBuilder().mergeFrom(message).build(); 1605 assertTrue(message2.hasFooMessage()); 1606 assertEquals(234, message2.getFooMessage().getQuxInt()); 1607 } 1608 } 1609 testOneofSerialization()1610 public void testOneofSerialization() throws Exception { 1611 // Primitive Type 1612 { 1613 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1614 TestOneof2 message = builder.setFooInt(123).build(); 1615 ByteString serialized = message.toByteString(); 1616 TestOneof2 message2 = TestOneof2.parseFrom(serialized); 1617 assertTrue(message2.hasFooInt()); 1618 assertEquals(123, message2.getFooInt()); 1619 } 1620 1621 // String 1622 { 1623 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1624 TestOneof2 message = builder.setFooString("foo").build(); 1625 ByteString serialized = message.toByteString(); 1626 TestOneof2 message2 = TestOneof2.parseFrom(serialized); 1627 assertTrue(message2.hasFooString()); 1628 assertEquals("foo", message2.getFooString()); 1629 } 1630 1631 // Enum 1632 { 1633 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1634 TestOneof2 message = builder.setFooEnum(TestOneof2.NestedEnum.BAR).build(); 1635 ByteString serialized = message.toByteString(); 1636 TestOneof2 message2 = TestOneof2.parseFrom(serialized); 1637 assertTrue(message2.hasFooEnum()); 1638 assertEquals(TestOneof2.NestedEnum.BAR, message2.getFooEnum()); 1639 } 1640 1641 // Message 1642 { 1643 TestOneof2.Builder builder = TestOneof2.newBuilder(); 1644 TestOneof2 message = 1645 builder 1646 .setFooMessage(TestOneof2.NestedMessage.newBuilder().setQuxInt(234).build()) 1647 .build(); 1648 ByteString serialized = message.toByteString(); 1649 TestOneof2 message2 = TestOneof2.parseFrom(serialized); 1650 assertTrue(message2.hasFooMessage()); 1651 assertEquals(234, message2.getFooMessage().getQuxInt()); 1652 } 1653 } 1654 testOneofNestedBuilderOnChangePropagation()1655 public void testOneofNestedBuilderOnChangePropagation() { 1656 NestedTestAllTypes.Builder parentBuilder = NestedTestAllTypes.newBuilder(); 1657 TestAllTypes.Builder builder = parentBuilder.getPayloadBuilder(); 1658 builder.getOneofNestedMessageBuilder(); 1659 assertTrue(builder.hasOneofNestedMessage()); 1660 assertTrue(parentBuilder.hasPayload()); 1661 NestedTestAllTypes message = parentBuilder.build(); 1662 assertTrue(message.hasPayload()); 1663 assertTrue(message.getPayload().hasOneofNestedMessage()); 1664 } 1665 testGetRepeatedFieldBuilder()1666 public void testGetRepeatedFieldBuilder() { 1667 Descriptor descriptor = TestAllTypes.getDescriptor(); 1668 1669 FieldDescriptor fieldDescriptor = descriptor.findFieldByName("repeated_nested_message"); 1670 FieldDescriptor foreignFieldDescriptor = descriptor.findFieldByName("repeated_foreign_message"); 1671 FieldDescriptor importFieldDescriptor = descriptor.findFieldByName("repeated_import_message"); 1672 1673 // Mutate the message with new field builder 1674 // Mutate nested message 1675 TestAllTypes.Builder builder1 = TestAllTypes.newBuilder(); 1676 Message.Builder fieldBuilder1 = builder1.newBuilderForField(fieldDescriptor); 1677 FieldDescriptor subFieldDescriptor1 = 1678 fieldBuilder1.getDescriptorForType().findFieldByName("bb"); 1679 fieldBuilder1.setField(subFieldDescriptor1, 1); 1680 builder1.addRepeatedField(fieldDescriptor, fieldBuilder1.build()); 1681 1682 // Mutate foreign message 1683 Message.Builder foreignFieldBuilder1 = builder1.newBuilderForField(foreignFieldDescriptor); 1684 FieldDescriptor subForeignFieldDescriptor1 = 1685 foreignFieldBuilder1.getDescriptorForType().findFieldByName("c"); 1686 foreignFieldBuilder1.setField(subForeignFieldDescriptor1, 2); 1687 builder1.addRepeatedField(foreignFieldDescriptor, foreignFieldBuilder1.build()); 1688 1689 // Mutate import message 1690 Message.Builder importFieldBuilder1 = builder1.newBuilderForField(importFieldDescriptor); 1691 FieldDescriptor subImportFieldDescriptor1 = 1692 importFieldBuilder1.getDescriptorForType().findFieldByName("d"); 1693 importFieldBuilder1.setField(subImportFieldDescriptor1, 3); 1694 builder1.addRepeatedField(importFieldDescriptor, importFieldBuilder1.build()); 1695 1696 Message newMessage1 = builder1.build(); 1697 1698 // Mutate the message with existing field builder 1699 // Mutate nested message 1700 TestAllTypes.Builder builder2 = TestAllTypes.newBuilder(); 1701 builder2.addRepeatedNestedMessageBuilder(); 1702 Message.Builder fieldBuilder2 = builder2.getRepeatedFieldBuilder(fieldDescriptor, 0); 1703 FieldDescriptor subFieldDescriptor2 = 1704 fieldBuilder2.getDescriptorForType().findFieldByName("bb"); 1705 fieldBuilder2.setField(subFieldDescriptor2, 1); 1706 1707 // Mutate foreign message 1708 Message.Builder foreignFieldBuilder2 = builder2.newBuilderForField(foreignFieldDescriptor); 1709 FieldDescriptor subForeignFieldDescriptor2 = 1710 foreignFieldBuilder2.getDescriptorForType().findFieldByName("c"); 1711 foreignFieldBuilder2.setField(subForeignFieldDescriptor2, 2); 1712 builder2.addRepeatedField(foreignFieldDescriptor, foreignFieldBuilder2.build()); 1713 1714 // Mutate import message 1715 Message.Builder importFieldBuilder2 = builder2.newBuilderForField(importFieldDescriptor); 1716 FieldDescriptor subImportFieldDescriptor2 = 1717 importFieldBuilder2.getDescriptorForType().findFieldByName("d"); 1718 importFieldBuilder2.setField(subImportFieldDescriptor2, 3); 1719 builder2.addRepeatedField(importFieldDescriptor, importFieldBuilder2.build()); 1720 1721 Message newMessage2 = builder2.build(); 1722 1723 // These two messages should be equal. 1724 assertEquals(newMessage1, newMessage2); 1725 } 1726 testGetRepeatedFieldBuilderWithInitializedValue()1727 public void testGetRepeatedFieldBuilderWithInitializedValue() { 1728 Descriptor descriptor = TestAllTypes.getDescriptor(); 1729 FieldDescriptor fieldDescriptor = descriptor.findFieldByName("repeated_nested_message"); 1730 1731 // Before setting field, builder is initialized by default value. 1732 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 1733 builder.addRepeatedNestedMessageBuilder(); 1734 NestedMessage.Builder fieldBuilder = 1735 (NestedMessage.Builder) builder.getRepeatedFieldBuilder(fieldDescriptor, 0); 1736 assertEquals(0, fieldBuilder.getBb()); 1737 1738 // Setting field value with new field builder instance. 1739 builder = TestAllTypes.newBuilder(); 1740 NestedMessage.Builder newFieldBuilder = builder.addRepeatedNestedMessageBuilder(); 1741 newFieldBuilder.setBb(2); 1742 // Then get the field builder instance by getRepeatedFieldBuilder(). 1743 fieldBuilder = (NestedMessage.Builder) builder.getRepeatedFieldBuilder(fieldDescriptor, 0); 1744 // It should contain new value. 1745 assertEquals(2, fieldBuilder.getBb()); 1746 // These two builder should be equal. 1747 assertSame(fieldBuilder, newFieldBuilder); 1748 } 1749 testGetRepeatedFieldBuilderNotSupportedException()1750 public void testGetRepeatedFieldBuilderNotSupportedException() { 1751 Descriptor descriptor = TestAllTypes.getDescriptor(); 1752 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 1753 try { 1754 builder.getRepeatedFieldBuilder(descriptor.findFieldByName("repeated_int32"), 0); 1755 fail("Exception was not thrown"); 1756 } catch (UnsupportedOperationException e) { 1757 // We expect this exception. 1758 } 1759 try { 1760 builder.getRepeatedFieldBuilder(descriptor.findFieldByName("repeated_nested_enum"), 0); 1761 fail("Exception was not thrown"); 1762 } catch (UnsupportedOperationException e) { 1763 // We expect this exception. 1764 } 1765 try { 1766 builder.getRepeatedFieldBuilder(descriptor.findFieldByName("optional_int32"), 0); 1767 fail("Exception was not thrown"); 1768 } catch (UnsupportedOperationException e) { 1769 // We expect this exception. 1770 } 1771 try { 1772 builder.getRepeatedFieldBuilder(descriptor.findFieldByName("optional_nested_enum"), 0); 1773 fail("Exception was not thrown"); 1774 } catch (UnsupportedOperationException e) { 1775 // We expect this exception. 1776 } 1777 try { 1778 builder.getRepeatedFieldBuilder(descriptor.findFieldByName("optional_nested_message"), 0); 1779 fail("Exception was not thrown"); 1780 } catch (UnsupportedOperationException e) { 1781 // We expect this exception. 1782 } 1783 } 1784 } 1785