1// Protocol Buffers - Google's data interchange format 2// Copyright 2015 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#import "GPBTestUtilities.h" 32 33#import <objc/runtime.h> 34 35#import "GPBMessage.h" 36 37#import "google/protobuf/MapUnittest.pbobjc.h" 38#import "google/protobuf/Unittest.pbobjc.h" 39#import "google/protobuf/UnittestCycle.pbobjc.h" 40#import "google/protobuf/UnittestObjcStartup.pbobjc.h" 41#import "google/protobuf/UnittestRuntimeProto2.pbobjc.h" 42#import "google/protobuf/UnittestRuntimeProto3.pbobjc.h" 43 44@interface MessageRuntimeTests : GPBTestCase 45@end 46 47@implementation MessageRuntimeTests 48 49// TODO(thomasvl): Pull tests over from GPBMessageTests that are runtime 50// specific. 51 52- (void)testStartupOrdering { 53 // Message class/Root class initialization is a little tricky, so these just 54 // create some possible patterns that can be a problem. The messages don't 55 // have to be exercised, just creating them is enough to test. If there 56 // is a problem, the runtime should assert or hang. 57 // 58 // Note: the messages from these proto files should not be used in any other 59 // tests, that way when they are referenced here it will be the first use and 60 // initialization will take place now. 61 62 TestObjCStartupMessage *message = [TestObjCStartupMessage message]; 63 XCTAssertNotNil(message); 64 65 CycleBaz *baz = [CycleBaz message]; 66 CycleBar *bar = [CycleBar message]; 67 CycleFoo *foo = [CycleFoo message]; 68 XCTAssertNotNil(baz); 69 XCTAssertNotNil(bar); 70 XCTAssertNotNil(foo); 71} 72 73- (void)testProto2HasMethodSupport { 74 NSArray *names = @[ 75 @"Int32", 76 @"Int64", 77 @"Uint32", 78 @"Uint64", 79 @"Sint32", 80 @"Sint64", 81 @"Fixed32", 82 @"Fixed64", 83 @"Sfixed32", 84 @"Sfixed64", 85 @"Float", 86 @"Double", 87 @"Bool", 88 @"String", 89 @"Bytes", 90 @"Group", 91 @"Message", 92 @"Enum", 93 ]; 94 95 // Proto2 gets: 96 97 // Single fields - has*/setHas* is valid. 98 99 for (NSString *name in names) { 100 // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32: 101 SEL hasSel = NSSelectorFromString( 102 [NSString stringWithFormat:@"hasOptional%@", name]); 103 SEL setHasSel = NSSelectorFromString( 104 [NSString stringWithFormat:@"setHasOptional%@:", name]); 105 XCTAssertTrue([Message2 instancesRespondToSelector:hasSel], @"field: %@", 106 name); 107 XCTAssertTrue([Message2 instancesRespondToSelector:setHasSel], @"field: %@", 108 name); 109 } 110 111 // Repeated fields 112 // - no has*/setHas* 113 // - *Count 114 115 for (NSString *name in names) { 116 // build the selector, i.e. - hasRepeatedInt32Array/setHasRepeatedInt32Array: 117 SEL hasSel = NSSelectorFromString( 118 [NSString stringWithFormat:@"hasRepeated%@Array", name]); 119 SEL setHasSel = NSSelectorFromString( 120 [NSString stringWithFormat:@"setHasRepeated%@Array:", name]); 121 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@", 122 name); 123 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel], 124 @"field: %@", name); 125 // build the selector, i.e. - repeatedInt32Array_Count 126 SEL countSel = NSSelectorFromString( 127 [NSString stringWithFormat:@"repeated%@Array_Count", name]); 128 XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@", 129 name); 130 } 131 132 // OneOf fields - no has*/setHas* 133 134 for (NSString *name in names) { 135 // build the selector, i.e. - hasOneofInt32/setHasOneofInt32: 136 SEL hasSel = 137 NSSelectorFromString([NSString stringWithFormat:@"hasOneof%@", name]); 138 SEL setHasSel = NSSelectorFromString( 139 [NSString stringWithFormat:@"setHasOneof%@:", name]); 140 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@", 141 name); 142 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel], 143 @"field: %@", name); 144 } 145 146 // map<> fields 147 // - no has*/setHas* 148 // - *Count 149 150 NSArray *mapNames = @[ 151 @"Int32Int32", 152 @"Int64Int64", 153 @"Uint32Uint32", 154 @"Uint64Uint64", 155 @"Sint32Sint32", 156 @"Sint64Sint64", 157 @"Fixed32Fixed32", 158 @"Fixed64Fixed64", 159 @"Sfixed32Sfixed32", 160 @"Sfixed64Sfixed64", 161 @"Int32Float", 162 @"Int32Double", 163 @"BoolBool", 164 @"StringString", 165 @"StringBytes", 166 @"StringMessage", 167 @"Int32Bytes", 168 @"Int32Enum", 169 @"Int32Message", 170 ]; 171 172 for (NSString *name in mapNames) { 173 // build the selector, i.e. - hasMapInt32Int32/setHasMapInt32Int32: 174 SEL hasSel = NSSelectorFromString( 175 [NSString stringWithFormat:@"hasMap%@", name]); 176 SEL setHasSel = NSSelectorFromString( 177 [NSString stringWithFormat:@"setHasMap%@:", name]); 178 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@", 179 name); 180 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel], 181 @"field: %@", name); 182 // build the selector, i.e. - mapInt32Int32Count 183 SEL countSel = NSSelectorFromString( 184 [NSString stringWithFormat:@"map%@_Count", name]); 185 XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@", 186 name); 187 } 188 189} 190 191- (void)testProto3HasMethodSupport { 192 NSArray *names = @[ 193 @"Int32", 194 @"Int64", 195 @"Uint32", 196 @"Uint64", 197 @"Sint32", 198 @"Sint64", 199 @"Fixed32", 200 @"Fixed64", 201 @"Sfixed32", 202 @"Sfixed64", 203 @"Float", 204 @"Double", 205 @"Bool", 206 @"String", 207 @"Bytes", 208 @"Message", 209 @"Enum", 210 ]; 211 212 // Proto3 gets: 213 214 // Single fields 215 // - has*/setHas* invalid for primitive types. 216 // - has*/setHas* valid for Message. 217 218 for (NSString *name in names) { 219 // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32: 220 SEL hasSel = NSSelectorFromString( 221 [NSString stringWithFormat:@"hasOptional%@", name]); 222 SEL setHasSel = NSSelectorFromString( 223 [NSString stringWithFormat:@"setHasOptional%@:", name]); 224 if ([name isEqual:@"Message"]) { 225 // Sub messages/groups are the exception. 226 XCTAssertTrue([Message3 instancesRespondToSelector:hasSel], @"field: %@", 227 name); 228 XCTAssertTrue([Message3 instancesRespondToSelector:setHasSel], 229 @"field: %@", name); 230 } else { 231 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@", 232 name); 233 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel], 234 @"field: %@", name); 235 } 236 } 237 238 // Repeated fields 239 // - no has*/setHas* 240 // - *Count 241 242 for (NSString *name in names) { 243 // build the selector, i.e. - hasRepeatedInt32Array/setHasRepeatedInt32Array: 244 SEL hasSel = NSSelectorFromString( 245 [NSString stringWithFormat:@"hasRepeated%@Array", name]); 246 SEL setHasSel = NSSelectorFromString( 247 [NSString stringWithFormat:@"setHasRepeated%@Array:", name]); 248 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@", 249 name); 250 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel], 251 @"field: %@", name); 252 // build the selector, i.e. - repeatedInt32Array_Count 253 SEL countSel = NSSelectorFromString( 254 [NSString stringWithFormat:@"repeated%@Array_Count", name]); 255 XCTAssertTrue([Message3 instancesRespondToSelector:countSel], @"field: %@", 256 name); 257 } 258 259 // OneOf fields - no has*/setHas* 260 261 for (NSString *name in names) { 262 // build the selector, i.e. - hasOneofInt32/setHasOneofInt32: 263 SEL hasSel = 264 NSSelectorFromString([NSString stringWithFormat:@"hasOneof%@", name]); 265 SEL setHasSel = NSSelectorFromString( 266 [NSString stringWithFormat:@"setHasOneof%@:", name]); 267 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@", 268 name); 269 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel], 270 @"field: %@", name); 271 } 272 273 // Single Optional fields 274 // - has*/setHas* thanks to the optional keyword in proto3, they exist 275 // for primitive types. 276 // - has*/setHas* valid for Message. 277 278 for (NSString *name in names) { 279 // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32: 280 SEL hasSel = NSSelectorFromString( 281 [NSString stringWithFormat:@"hasOptional%@", name]); 282 SEL setHasSel = NSSelectorFromString( 283 [NSString stringWithFormat:@"setHasOptional%@:", name]); 284 XCTAssertTrue([Message3Optional instancesRespondToSelector:hasSel], @"field: %@", 285 name); 286 XCTAssertTrue([Message3Optional instancesRespondToSelector:setHasSel], 287 @"field: %@", name); 288 } 289 290 // map<> fields 291 // - no has*/setHas* 292 // - *Count 293 294 NSArray *mapNames = @[ 295 @"Int32Int32", 296 @"Int64Int64", 297 @"Uint32Uint32", 298 @"Uint64Uint64", 299 @"Sint32Sint32", 300 @"Sint64Sint64", 301 @"Fixed32Fixed32", 302 @"Fixed64Fixed64", 303 @"Sfixed32Sfixed32", 304 @"Sfixed64Sfixed64", 305 @"Int32Float", 306 @"Int32Double", 307 @"BoolBool", 308 @"StringString", 309 @"StringBytes", 310 @"StringMessage", 311 @"Int32Bytes", 312 @"Int32Enum", 313 @"Int32Message", 314 ]; 315 316 for (NSString *name in mapNames) { 317 // build the selector, i.e. - hasMapInt32Int32/setHasMapInt32Int32: 318 SEL hasSel = NSSelectorFromString( 319 [NSString stringWithFormat:@"hasMap%@", name]); 320 SEL setHasSel = NSSelectorFromString( 321 [NSString stringWithFormat:@"setHasMap%@:", name]); 322 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@", 323 name); 324 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel], 325 @"field: %@", name); 326 // build the selector, i.e. - mapInt32Int32Count 327 SEL countSel = NSSelectorFromString( 328 [NSString stringWithFormat:@"map%@_Count", name]); 329 XCTAssertTrue([Message3 instancesRespondToSelector:countSel], @"field: %@", 330 name); 331 } 332} 333 334- (void)testProto2SingleFieldHasBehavior { 335 // 336 // Setting to any value including the default value (0) should result has* 337 // being true. 338 // 339 340//%PDDM-DEFINE PROTO2_TEST_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE) 341//% { // optional##FIELD :: NON_ZERO_VALUE 342//% Message2 *msg = [[Message2 alloc] init]; 343//% XCTAssertFalse(msg.hasOptional##FIELD); 344//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD)); 345//% msg.optional##FIELD = NON_ZERO_VALUE; 346//% XCTAssertTrue(msg.hasOptional##FIELD); 347//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD)); 348//% [msg release]; 349//% } 350//% { // optional##FIELD :: ZERO_VALUE 351//% Message2 *msg = [[Message2 alloc] init]; 352//% XCTAssertFalse(msg.hasOptional##FIELD); 353//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD)); 354//% msg.optional##FIELD = ZERO_VALUE; 355//% XCTAssertTrue(msg.hasOptional##FIELD); 356//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD)); 357//% [msg release]; 358//% } 359//% 360//%PDDM-DEFINE PROTO2_TEST_CLEAR_FIELD_WITH_NIL(FIELD, VALUE) 361//% { // optional##FIELD 362//% Message2 *msg = [[Message2 alloc] init]; 363//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD)); 364//% msg.optional##FIELD = VALUE; 365//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD)); 366//% msg.optional##FIELD = nil; 367//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD)); 368//% [msg release]; 369//% } 370//% 371//%PDDM-DEFINE PROTO2_TEST_HAS_FIELDS() 372//%PROTO2_TEST_HAS_FIELD(Int32, 1, 0) 373//%PROTO2_TEST_HAS_FIELD(Int64, 1, 0) 374//%PROTO2_TEST_HAS_FIELD(Uint32, 1, 0) 375//%PROTO2_TEST_HAS_FIELD(Uint64, 1, 0) 376//%PROTO2_TEST_HAS_FIELD(Sint32, 1, 0) 377//%PROTO2_TEST_HAS_FIELD(Sint64, 1, 0) 378//%PROTO2_TEST_HAS_FIELD(Fixed32, 1, 0) 379//%PROTO2_TEST_HAS_FIELD(Fixed64, 1, 0) 380//%PROTO2_TEST_HAS_FIELD(Sfixed32, 1, 0) 381//%PROTO2_TEST_HAS_FIELD(Sfixed64, 1, 0) 382//%PROTO2_TEST_HAS_FIELD(Float, 1.0f, 0.0f) 383//%PROTO2_TEST_HAS_FIELD(Double, 1.0, 0.0) 384//%PROTO2_TEST_HAS_FIELD(Bool, YES, NO) 385//%PROTO2_TEST_HAS_FIELD(String, @"foo", @"") 386//%PROTO2_TEST_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data]) 387//% // 388//% // Test doesn't apply to optionalGroup/optionalMessage. 389//% // 390//% 391//%PROTO2_TEST_HAS_FIELD(Enum, Message2_Enum_Bar, Message2_Enum_Foo) 392//% // 393//% // Nil can also be used to clear strings, bytes, groups, and messages. 394//% // 395//% 396//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(String, @"foo") 397//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding]) 398//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(Group, [Message2_OptionalGroup message]) 399//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(Message, [Message2 message]) 400//%PDDM-EXPAND PROTO2_TEST_HAS_FIELDS() 401// This block of code is generated, do not edit it directly. 402// clang-format off 403 404 { // optionalInt32 :: 1 405 Message2 *msg = [[Message2 alloc] init]; 406 XCTAssertFalse(msg.hasOptionalInt32); 407 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32)); 408 msg.optionalInt32 = 1; 409 XCTAssertTrue(msg.hasOptionalInt32); 410 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32)); 411 [msg release]; 412 } 413 { // optionalInt32 :: 0 414 Message2 *msg = [[Message2 alloc] init]; 415 XCTAssertFalse(msg.hasOptionalInt32); 416 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32)); 417 msg.optionalInt32 = 0; 418 XCTAssertTrue(msg.hasOptionalInt32); 419 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32)); 420 [msg release]; 421 } 422 423 { // optionalInt64 :: 1 424 Message2 *msg = [[Message2 alloc] init]; 425 XCTAssertFalse(msg.hasOptionalInt64); 426 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64)); 427 msg.optionalInt64 = 1; 428 XCTAssertTrue(msg.hasOptionalInt64); 429 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64)); 430 [msg release]; 431 } 432 { // optionalInt64 :: 0 433 Message2 *msg = [[Message2 alloc] init]; 434 XCTAssertFalse(msg.hasOptionalInt64); 435 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64)); 436 msg.optionalInt64 = 0; 437 XCTAssertTrue(msg.hasOptionalInt64); 438 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64)); 439 [msg release]; 440 } 441 442 { // optionalUint32 :: 1 443 Message2 *msg = [[Message2 alloc] init]; 444 XCTAssertFalse(msg.hasOptionalUint32); 445 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32)); 446 msg.optionalUint32 = 1; 447 XCTAssertTrue(msg.hasOptionalUint32); 448 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32)); 449 [msg release]; 450 } 451 { // optionalUint32 :: 0 452 Message2 *msg = [[Message2 alloc] init]; 453 XCTAssertFalse(msg.hasOptionalUint32); 454 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32)); 455 msg.optionalUint32 = 0; 456 XCTAssertTrue(msg.hasOptionalUint32); 457 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32)); 458 [msg release]; 459 } 460 461 { // optionalUint64 :: 1 462 Message2 *msg = [[Message2 alloc] init]; 463 XCTAssertFalse(msg.hasOptionalUint64); 464 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64)); 465 msg.optionalUint64 = 1; 466 XCTAssertTrue(msg.hasOptionalUint64); 467 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64)); 468 [msg release]; 469 } 470 { // optionalUint64 :: 0 471 Message2 *msg = [[Message2 alloc] init]; 472 XCTAssertFalse(msg.hasOptionalUint64); 473 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64)); 474 msg.optionalUint64 = 0; 475 XCTAssertTrue(msg.hasOptionalUint64); 476 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64)); 477 [msg release]; 478 } 479 480 { // optionalSint32 :: 1 481 Message2 *msg = [[Message2 alloc] init]; 482 XCTAssertFalse(msg.hasOptionalSint32); 483 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32)); 484 msg.optionalSint32 = 1; 485 XCTAssertTrue(msg.hasOptionalSint32); 486 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32)); 487 [msg release]; 488 } 489 { // optionalSint32 :: 0 490 Message2 *msg = [[Message2 alloc] init]; 491 XCTAssertFalse(msg.hasOptionalSint32); 492 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32)); 493 msg.optionalSint32 = 0; 494 XCTAssertTrue(msg.hasOptionalSint32); 495 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32)); 496 [msg release]; 497 } 498 499 { // optionalSint64 :: 1 500 Message2 *msg = [[Message2 alloc] init]; 501 XCTAssertFalse(msg.hasOptionalSint64); 502 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64)); 503 msg.optionalSint64 = 1; 504 XCTAssertTrue(msg.hasOptionalSint64); 505 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64)); 506 [msg release]; 507 } 508 { // optionalSint64 :: 0 509 Message2 *msg = [[Message2 alloc] init]; 510 XCTAssertFalse(msg.hasOptionalSint64); 511 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64)); 512 msg.optionalSint64 = 0; 513 XCTAssertTrue(msg.hasOptionalSint64); 514 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64)); 515 [msg release]; 516 } 517 518 { // optionalFixed32 :: 1 519 Message2 *msg = [[Message2 alloc] init]; 520 XCTAssertFalse(msg.hasOptionalFixed32); 521 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32)); 522 msg.optionalFixed32 = 1; 523 XCTAssertTrue(msg.hasOptionalFixed32); 524 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32)); 525 [msg release]; 526 } 527 { // optionalFixed32 :: 0 528 Message2 *msg = [[Message2 alloc] init]; 529 XCTAssertFalse(msg.hasOptionalFixed32); 530 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32)); 531 msg.optionalFixed32 = 0; 532 XCTAssertTrue(msg.hasOptionalFixed32); 533 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32)); 534 [msg release]; 535 } 536 537 { // optionalFixed64 :: 1 538 Message2 *msg = [[Message2 alloc] init]; 539 XCTAssertFalse(msg.hasOptionalFixed64); 540 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64)); 541 msg.optionalFixed64 = 1; 542 XCTAssertTrue(msg.hasOptionalFixed64); 543 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64)); 544 [msg release]; 545 } 546 { // optionalFixed64 :: 0 547 Message2 *msg = [[Message2 alloc] init]; 548 XCTAssertFalse(msg.hasOptionalFixed64); 549 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64)); 550 msg.optionalFixed64 = 0; 551 XCTAssertTrue(msg.hasOptionalFixed64); 552 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64)); 553 [msg release]; 554 } 555 556 { // optionalSfixed32 :: 1 557 Message2 *msg = [[Message2 alloc] init]; 558 XCTAssertFalse(msg.hasOptionalSfixed32); 559 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32)); 560 msg.optionalSfixed32 = 1; 561 XCTAssertTrue(msg.hasOptionalSfixed32); 562 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32)); 563 [msg release]; 564 } 565 { // optionalSfixed32 :: 0 566 Message2 *msg = [[Message2 alloc] init]; 567 XCTAssertFalse(msg.hasOptionalSfixed32); 568 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32)); 569 msg.optionalSfixed32 = 0; 570 XCTAssertTrue(msg.hasOptionalSfixed32); 571 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32)); 572 [msg release]; 573 } 574 575 { // optionalSfixed64 :: 1 576 Message2 *msg = [[Message2 alloc] init]; 577 XCTAssertFalse(msg.hasOptionalSfixed64); 578 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64)); 579 msg.optionalSfixed64 = 1; 580 XCTAssertTrue(msg.hasOptionalSfixed64); 581 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64)); 582 [msg release]; 583 } 584 { // optionalSfixed64 :: 0 585 Message2 *msg = [[Message2 alloc] init]; 586 XCTAssertFalse(msg.hasOptionalSfixed64); 587 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64)); 588 msg.optionalSfixed64 = 0; 589 XCTAssertTrue(msg.hasOptionalSfixed64); 590 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64)); 591 [msg release]; 592 } 593 594 { // optionalFloat :: 1.0f 595 Message2 *msg = [[Message2 alloc] init]; 596 XCTAssertFalse(msg.hasOptionalFloat); 597 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat)); 598 msg.optionalFloat = 1.0f; 599 XCTAssertTrue(msg.hasOptionalFloat); 600 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat)); 601 [msg release]; 602 } 603 { // optionalFloat :: 0.0f 604 Message2 *msg = [[Message2 alloc] init]; 605 XCTAssertFalse(msg.hasOptionalFloat); 606 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat)); 607 msg.optionalFloat = 0.0f; 608 XCTAssertTrue(msg.hasOptionalFloat); 609 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat)); 610 [msg release]; 611 } 612 613 { // optionalDouble :: 1.0 614 Message2 *msg = [[Message2 alloc] init]; 615 XCTAssertFalse(msg.hasOptionalDouble); 616 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble)); 617 msg.optionalDouble = 1.0; 618 XCTAssertTrue(msg.hasOptionalDouble); 619 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble)); 620 [msg release]; 621 } 622 { // optionalDouble :: 0.0 623 Message2 *msg = [[Message2 alloc] init]; 624 XCTAssertFalse(msg.hasOptionalDouble); 625 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble)); 626 msg.optionalDouble = 0.0; 627 XCTAssertTrue(msg.hasOptionalDouble); 628 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble)); 629 [msg release]; 630 } 631 632 { // optionalBool :: YES 633 Message2 *msg = [[Message2 alloc] init]; 634 XCTAssertFalse(msg.hasOptionalBool); 635 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool)); 636 msg.optionalBool = YES; 637 XCTAssertTrue(msg.hasOptionalBool); 638 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool)); 639 [msg release]; 640 } 641 { // optionalBool :: NO 642 Message2 *msg = [[Message2 alloc] init]; 643 XCTAssertFalse(msg.hasOptionalBool); 644 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool)); 645 msg.optionalBool = NO; 646 XCTAssertTrue(msg.hasOptionalBool); 647 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool)); 648 [msg release]; 649 } 650 651 { // optionalString :: @"foo" 652 Message2 *msg = [[Message2 alloc] init]; 653 XCTAssertFalse(msg.hasOptionalString); 654 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString)); 655 msg.optionalString = @"foo"; 656 XCTAssertTrue(msg.hasOptionalString); 657 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString)); 658 [msg release]; 659 } 660 { // optionalString :: @"" 661 Message2 *msg = [[Message2 alloc] init]; 662 XCTAssertFalse(msg.hasOptionalString); 663 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString)); 664 msg.optionalString = @""; 665 XCTAssertTrue(msg.hasOptionalString); 666 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString)); 667 [msg release]; 668 } 669 670 { // optionalBytes :: [@"foo" dataUsingEncoding:NSUTF8StringEncoding] 671 Message2 *msg = [[Message2 alloc] init]; 672 XCTAssertFalse(msg.hasOptionalBytes); 673 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes)); 674 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding]; 675 XCTAssertTrue(msg.hasOptionalBytes); 676 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes)); 677 [msg release]; 678 } 679 { // optionalBytes :: [NSData data] 680 Message2 *msg = [[Message2 alloc] init]; 681 XCTAssertFalse(msg.hasOptionalBytes); 682 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes)); 683 msg.optionalBytes = [NSData data]; 684 XCTAssertTrue(msg.hasOptionalBytes); 685 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes)); 686 [msg release]; 687 } 688 689 // 690 // Test doesn't apply to optionalGroup/optionalMessage. 691 // 692 693 { // optionalEnum :: Message2_Enum_Bar 694 Message2 *msg = [[Message2 alloc] init]; 695 XCTAssertFalse(msg.hasOptionalEnum); 696 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum)); 697 msg.optionalEnum = Message2_Enum_Bar; 698 XCTAssertTrue(msg.hasOptionalEnum); 699 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum)); 700 [msg release]; 701 } 702 { // optionalEnum :: Message2_Enum_Foo 703 Message2 *msg = [[Message2 alloc] init]; 704 XCTAssertFalse(msg.hasOptionalEnum); 705 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum)); 706 msg.optionalEnum = Message2_Enum_Foo; 707 XCTAssertTrue(msg.hasOptionalEnum); 708 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum)); 709 [msg release]; 710 } 711 712 // 713 // Nil can also be used to clear strings, bytes, groups, and messages. 714 // 715 716 { // optionalString 717 Message2 *msg = [[Message2 alloc] init]; 718 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString)); 719 msg.optionalString = @"foo"; 720 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString)); 721 msg.optionalString = nil; 722 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString)); 723 [msg release]; 724 } 725 726 { // optionalBytes 727 Message2 *msg = [[Message2 alloc] init]; 728 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes)); 729 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding]; 730 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes)); 731 msg.optionalBytes = nil; 732 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes)); 733 [msg release]; 734 } 735 736 { // optionalGroup 737 Message2 *msg = [[Message2 alloc] init]; 738 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalGroup)); 739 msg.optionalGroup = [Message2_OptionalGroup message]; 740 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalGroup)); 741 msg.optionalGroup = nil; 742 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalGroup)); 743 [msg release]; 744 } 745 746 { // optionalMessage 747 Message2 *msg = [[Message2 alloc] init]; 748 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalMessage)); 749 msg.optionalMessage = [Message2 message]; 750 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalMessage)); 751 msg.optionalMessage = nil; 752 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalMessage)); 753 [msg release]; 754 } 755 756// clang-format on 757//%PDDM-EXPAND-END PROTO2_TEST_HAS_FIELDS() 758} 759 760- (void)testProto3SingleFieldHasBehavior { 761 // 762 // Setting to any value but the default value (0) should result has* 763 // being true. When set to the default, shouldn't be true. 764 // 765 766//%PDDM-DEFINE PROTO3_TEST_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE) 767//% { // optional##FIELD 768//% Message3 *msg = [[Message3 alloc] init]; 769//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD)); 770//% msg.optional##FIELD = NON_ZERO_VALUE; 771//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD)); 772//% msg.optional##FIELD = ZERO_VALUE; 773//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD)); 774//% [msg release]; 775//% } 776//% 777//%PDDM-DEFINE PROTO3_TEST_CLEAR_FIELD_WITH_NIL(FIELD, VALUE) 778//% { // optional##FIELD 779//% Message3 *msg = [[Message3 alloc] init]; 780//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD)); 781//% msg.optional##FIELD = VALUE; 782//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD)); 783//% msg.optional##FIELD = nil; 784//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD)); 785//% [msg release]; 786//% } 787//% 788//%PDDM-DEFINE PROTO3_TEST_HAS_FIELDS() 789//%PROTO3_TEST_HAS_FIELD(Int32, 1, 0) 790//%PROTO3_TEST_HAS_FIELD(Int64, 1, 0) 791//%PROTO3_TEST_HAS_FIELD(Uint32, 1, 0) 792//%PROTO3_TEST_HAS_FIELD(Uint64, 1, 0) 793//%PROTO3_TEST_HAS_FIELD(Sint32, 1, 0) 794//%PROTO3_TEST_HAS_FIELD(Sint64, 1, 0) 795//%PROTO3_TEST_HAS_FIELD(Fixed32, 1, 0) 796//%PROTO3_TEST_HAS_FIELD(Fixed64, 1, 0) 797//%PROTO3_TEST_HAS_FIELD(Sfixed32, 1, 0) 798//%PROTO3_TEST_HAS_FIELD(Sfixed64, 1, 0) 799//%PROTO3_TEST_HAS_FIELD(Float, 1.0f, 0.0f) 800//%PROTO3_TEST_HAS_FIELD(Double, 1.0, 0.0) 801//%PROTO3_TEST_HAS_FIELD(Bool, YES, NO) 802//%PROTO3_TEST_HAS_FIELD(String, @"foo", @"") 803//%PROTO3_TEST_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data]) 804//% // 805//% // Test doesn't apply to optionalMessage (no groups in proto3). 806//% // 807//% 808//%PROTO3_TEST_HAS_FIELD(Enum, Message3_Enum_Bar, Message3_Enum_Foo) 809//% // 810//% // Nil can also be used to clear strings, bytes, and messages (no groups in proto3). 811//% // 812//% 813//%PROTO3_TEST_CLEAR_FIELD_WITH_NIL(String, @"foo") 814//%PROTO3_TEST_CLEAR_FIELD_WITH_NIL(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding]) 815//%PROTO3_TEST_CLEAR_FIELD_WITH_NIL(Message, [Message3 message]) 816//%PDDM-EXPAND PROTO3_TEST_HAS_FIELDS() 817// This block of code is generated, do not edit it directly. 818// clang-format off 819 820 { // optionalInt32 821 Message3 *msg = [[Message3 alloc] init]; 822 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt32)); 823 msg.optionalInt32 = 1; 824 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt32)); 825 msg.optionalInt32 = 0; 826 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt32)); 827 [msg release]; 828 } 829 830 { // optionalInt64 831 Message3 *msg = [[Message3 alloc] init]; 832 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt64)); 833 msg.optionalInt64 = 1; 834 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt64)); 835 msg.optionalInt64 = 0; 836 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt64)); 837 [msg release]; 838 } 839 840 { // optionalUint32 841 Message3 *msg = [[Message3 alloc] init]; 842 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint32)); 843 msg.optionalUint32 = 1; 844 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint32)); 845 msg.optionalUint32 = 0; 846 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint32)); 847 [msg release]; 848 } 849 850 { // optionalUint64 851 Message3 *msg = [[Message3 alloc] init]; 852 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint64)); 853 msg.optionalUint64 = 1; 854 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint64)); 855 msg.optionalUint64 = 0; 856 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint64)); 857 [msg release]; 858 } 859 860 { // optionalSint32 861 Message3 *msg = [[Message3 alloc] init]; 862 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint32)); 863 msg.optionalSint32 = 1; 864 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint32)); 865 msg.optionalSint32 = 0; 866 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint32)); 867 [msg release]; 868 } 869 870 { // optionalSint64 871 Message3 *msg = [[Message3 alloc] init]; 872 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint64)); 873 msg.optionalSint64 = 1; 874 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint64)); 875 msg.optionalSint64 = 0; 876 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint64)); 877 [msg release]; 878 } 879 880 { // optionalFixed32 881 Message3 *msg = [[Message3 alloc] init]; 882 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed32)); 883 msg.optionalFixed32 = 1; 884 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed32)); 885 msg.optionalFixed32 = 0; 886 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed32)); 887 [msg release]; 888 } 889 890 { // optionalFixed64 891 Message3 *msg = [[Message3 alloc] init]; 892 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed64)); 893 msg.optionalFixed64 = 1; 894 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed64)); 895 msg.optionalFixed64 = 0; 896 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed64)); 897 [msg release]; 898 } 899 900 { // optionalSfixed32 901 Message3 *msg = [[Message3 alloc] init]; 902 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed32)); 903 msg.optionalSfixed32 = 1; 904 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed32)); 905 msg.optionalSfixed32 = 0; 906 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed32)); 907 [msg release]; 908 } 909 910 { // optionalSfixed64 911 Message3 *msg = [[Message3 alloc] init]; 912 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed64)); 913 msg.optionalSfixed64 = 1; 914 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed64)); 915 msg.optionalSfixed64 = 0; 916 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed64)); 917 [msg release]; 918 } 919 920 { // optionalFloat 921 Message3 *msg = [[Message3 alloc] init]; 922 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFloat)); 923 msg.optionalFloat = 1.0f; 924 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFloat)); 925 msg.optionalFloat = 0.0f; 926 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFloat)); 927 [msg release]; 928 } 929 930 { // optionalDouble 931 Message3 *msg = [[Message3 alloc] init]; 932 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalDouble)); 933 msg.optionalDouble = 1.0; 934 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalDouble)); 935 msg.optionalDouble = 0.0; 936 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalDouble)); 937 [msg release]; 938 } 939 940 { // optionalBool 941 Message3 *msg = [[Message3 alloc] init]; 942 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBool)); 943 msg.optionalBool = YES; 944 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBool)); 945 msg.optionalBool = NO; 946 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBool)); 947 [msg release]; 948 } 949 950 { // optionalString 951 Message3 *msg = [[Message3 alloc] init]; 952 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString)); 953 msg.optionalString = @"foo"; 954 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString)); 955 msg.optionalString = @""; 956 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString)); 957 [msg release]; 958 } 959 960 { // optionalBytes 961 Message3 *msg = [[Message3 alloc] init]; 962 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes)); 963 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding]; 964 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes)); 965 msg.optionalBytes = [NSData data]; 966 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes)); 967 [msg release]; 968 } 969 970 // 971 // Test doesn't apply to optionalMessage (no groups in proto3). 972 // 973 974 { // optionalEnum 975 Message3 *msg = [[Message3 alloc] init]; 976 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalEnum)); 977 msg.optionalEnum = Message3_Enum_Bar; 978 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalEnum)); 979 msg.optionalEnum = Message3_Enum_Foo; 980 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalEnum)); 981 [msg release]; 982 } 983 984 // 985 // Nil can also be used to clear strings, bytes, and messages (no groups in proto3). 986 // 987 988 { // optionalString 989 Message3 *msg = [[Message3 alloc] init]; 990 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString)); 991 msg.optionalString = @"foo"; 992 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString)); 993 msg.optionalString = nil; 994 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString)); 995 [msg release]; 996 } 997 998 { // optionalBytes 999 Message3 *msg = [[Message3 alloc] init]; 1000 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes)); 1001 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding]; 1002 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes)); 1003 msg.optionalBytes = nil; 1004 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes)); 1005 [msg release]; 1006 } 1007 1008 { // optionalMessage 1009 Message3 *msg = [[Message3 alloc] init]; 1010 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalMessage)); 1011 msg.optionalMessage = [Message3 message]; 1012 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalMessage)); 1013 msg.optionalMessage = nil; 1014 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalMessage)); 1015 [msg release]; 1016 } 1017 1018// clang-format on 1019//%PDDM-EXPAND-END PROTO3_TEST_HAS_FIELDS() 1020} 1021 1022- (void)testProto3SingleOptionalFieldHasBehavior { 1023 // 1024 // Setting to any value including the default (0) should result in true. 1025 // 1026 1027//%PDDM-DEFINE PROTO3_TEST_OPTIONAL_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE) 1028//% { // optional##FIELD 1029//% Message3Optional *msg = [[Message3Optional alloc] init]; 1030//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_Optional##FIELD)); 1031//% msg.optional##FIELD = NON_ZERO_VALUE; 1032//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_Optional##FIELD)); 1033//% msg.hasOptional##FIELD = NO; 1034//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_Optional##FIELD)); 1035//% msg.optional##FIELD = ZERO_VALUE; 1036//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_Optional##FIELD)); 1037//% [msg release]; 1038//% } 1039//% 1040//%PDDM-DEFINE PROTO3_TEST_OPTIONAL_HAS_FIELDS() 1041//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Int32, 1, 0) 1042//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Int64, 1, 0) 1043//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Uint32, 1, 0) 1044//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Uint64, 1, 0) 1045//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Sint32, 1, 0) 1046//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Sint64, 1, 0) 1047//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Fixed32, 1, 0) 1048//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Fixed64, 1, 0) 1049//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Sfixed32, 1, 0) 1050//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Sfixed64, 1, 0) 1051//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Float, 1.0f, 0.0f) 1052//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Double, 1.0, 0.0) 1053//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Bool, YES, NO) 1054//%PROTO3_TEST_OPTIONAL_HAS_FIELD(String, @"foo", @"") 1055//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data]) 1056//% // 1057//% // Test doesn't apply to optionalMessage (no groups in proto3). 1058//% // 1059//% 1060//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Enum, Message3Optional_Enum_Bar, Message3Optional_Enum_Foo) 1061//%PDDM-EXPAND PROTO3_TEST_OPTIONAL_HAS_FIELDS() 1062// This block of code is generated, do not edit it directly. 1063// clang-format off 1064 1065 { // optionalInt32 1066 Message3Optional *msg = [[Message3Optional alloc] init]; 1067 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt32)); 1068 msg.optionalInt32 = 1; 1069 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt32)); 1070 msg.hasOptionalInt32 = NO; 1071 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt32)); 1072 msg.optionalInt32 = 0; 1073 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt32)); 1074 [msg release]; 1075 } 1076 1077 { // optionalInt64 1078 Message3Optional *msg = [[Message3Optional alloc] init]; 1079 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt64)); 1080 msg.optionalInt64 = 1; 1081 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt64)); 1082 msg.hasOptionalInt64 = NO; 1083 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt64)); 1084 msg.optionalInt64 = 0; 1085 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt64)); 1086 [msg release]; 1087 } 1088 1089 { // optionalUint32 1090 Message3Optional *msg = [[Message3Optional alloc] init]; 1091 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint32)); 1092 msg.optionalUint32 = 1; 1093 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint32)); 1094 msg.hasOptionalUint32 = NO; 1095 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint32)); 1096 msg.optionalUint32 = 0; 1097 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint32)); 1098 [msg release]; 1099 } 1100 1101 { // optionalUint64 1102 Message3Optional *msg = [[Message3Optional alloc] init]; 1103 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint64)); 1104 msg.optionalUint64 = 1; 1105 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint64)); 1106 msg.hasOptionalUint64 = NO; 1107 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint64)); 1108 msg.optionalUint64 = 0; 1109 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint64)); 1110 [msg release]; 1111 } 1112 1113 { // optionalSint32 1114 Message3Optional *msg = [[Message3Optional alloc] init]; 1115 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint32)); 1116 msg.optionalSint32 = 1; 1117 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint32)); 1118 msg.hasOptionalSint32 = NO; 1119 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint32)); 1120 msg.optionalSint32 = 0; 1121 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint32)); 1122 [msg release]; 1123 } 1124 1125 { // optionalSint64 1126 Message3Optional *msg = [[Message3Optional alloc] init]; 1127 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint64)); 1128 msg.optionalSint64 = 1; 1129 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint64)); 1130 msg.hasOptionalSint64 = NO; 1131 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint64)); 1132 msg.optionalSint64 = 0; 1133 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint64)); 1134 [msg release]; 1135 } 1136 1137 { // optionalFixed32 1138 Message3Optional *msg = [[Message3Optional alloc] init]; 1139 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed32)); 1140 msg.optionalFixed32 = 1; 1141 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed32)); 1142 msg.hasOptionalFixed32 = NO; 1143 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed32)); 1144 msg.optionalFixed32 = 0; 1145 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed32)); 1146 [msg release]; 1147 } 1148 1149 { // optionalFixed64 1150 Message3Optional *msg = [[Message3Optional alloc] init]; 1151 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed64)); 1152 msg.optionalFixed64 = 1; 1153 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed64)); 1154 msg.hasOptionalFixed64 = NO; 1155 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed64)); 1156 msg.optionalFixed64 = 0; 1157 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed64)); 1158 [msg release]; 1159 } 1160 1161 { // optionalSfixed32 1162 Message3Optional *msg = [[Message3Optional alloc] init]; 1163 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed32)); 1164 msg.optionalSfixed32 = 1; 1165 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed32)); 1166 msg.hasOptionalSfixed32 = NO; 1167 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed32)); 1168 msg.optionalSfixed32 = 0; 1169 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed32)); 1170 [msg release]; 1171 } 1172 1173 { // optionalSfixed64 1174 Message3Optional *msg = [[Message3Optional alloc] init]; 1175 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed64)); 1176 msg.optionalSfixed64 = 1; 1177 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed64)); 1178 msg.hasOptionalSfixed64 = NO; 1179 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed64)); 1180 msg.optionalSfixed64 = 0; 1181 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed64)); 1182 [msg release]; 1183 } 1184 1185 { // optionalFloat 1186 Message3Optional *msg = [[Message3Optional alloc] init]; 1187 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFloat)); 1188 msg.optionalFloat = 1.0f; 1189 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFloat)); 1190 msg.hasOptionalFloat = NO; 1191 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFloat)); 1192 msg.optionalFloat = 0.0f; 1193 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFloat)); 1194 [msg release]; 1195 } 1196 1197 { // optionalDouble 1198 Message3Optional *msg = [[Message3Optional alloc] init]; 1199 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalDouble)); 1200 msg.optionalDouble = 1.0; 1201 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalDouble)); 1202 msg.hasOptionalDouble = NO; 1203 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalDouble)); 1204 msg.optionalDouble = 0.0; 1205 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalDouble)); 1206 [msg release]; 1207 } 1208 1209 { // optionalBool 1210 Message3Optional *msg = [[Message3Optional alloc] init]; 1211 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBool)); 1212 msg.optionalBool = YES; 1213 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBool)); 1214 msg.hasOptionalBool = NO; 1215 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBool)); 1216 msg.optionalBool = NO; 1217 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBool)); 1218 [msg release]; 1219 } 1220 1221 { // optionalString 1222 Message3Optional *msg = [[Message3Optional alloc] init]; 1223 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalString)); 1224 msg.optionalString = @"foo"; 1225 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalString)); 1226 msg.hasOptionalString = NO; 1227 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalString)); 1228 msg.optionalString = @""; 1229 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalString)); 1230 [msg release]; 1231 } 1232 1233 { // optionalBytes 1234 Message3Optional *msg = [[Message3Optional alloc] init]; 1235 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBytes)); 1236 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding]; 1237 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBytes)); 1238 msg.hasOptionalBytes = NO; 1239 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBytes)); 1240 msg.optionalBytes = [NSData data]; 1241 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBytes)); 1242 [msg release]; 1243 } 1244 1245 // 1246 // Test doesn't apply to optionalMessage (no groups in proto3). 1247 // 1248 1249 { // optionalEnum 1250 Message3Optional *msg = [[Message3Optional alloc] init]; 1251 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalEnum)); 1252 msg.optionalEnum = Message3Optional_Enum_Bar; 1253 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalEnum)); 1254 msg.hasOptionalEnum = NO; 1255 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalEnum)); 1256 msg.optionalEnum = Message3Optional_Enum_Foo; 1257 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalEnum)); 1258 [msg release]; 1259 } 1260 1261// clang-format on 1262//%PDDM-EXPAND-END PROTO3_TEST_OPTIONAL_HAS_FIELDS() 1263} 1264 1265- (void)testAccessingProto2UnknownEnumValues { 1266 Message2 *msg = [[Message2 alloc] init]; 1267 1268 // Set it to something non zero, try and confirm it doesn't change. 1269 1270 msg.optionalEnum = Message2_Enum_Bar; 1271 XCTAssertThrowsSpecificNamed(msg.optionalEnum = 666, NSException, 1272 NSInvalidArgumentException); 1273 XCTAssertEqual(msg.optionalEnum, Message2_Enum_Bar); 1274 1275 msg.oneofEnum = Message2_Enum_Bar; 1276 XCTAssertThrowsSpecificNamed(msg.oneofEnum = 666, NSException, 1277 NSInvalidArgumentException); 1278 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar); 1279 1280 [msg release]; 1281} 1282 1283- (void)testAccessingProto3UnknownEnumValues { 1284 Message3 *msg = [[Message3 alloc] init]; 1285 1286 // Set it to something non zero, try and confirm it doesn't change. 1287 1288 msg.optionalEnum = Message3_Enum_Bar; 1289 XCTAssertThrowsSpecificNamed(msg.optionalEnum = 666, NSException, 1290 NSInvalidArgumentException); 1291 XCTAssertEqual(msg.optionalEnum, Message3_Enum_Bar); 1292 1293 msg.oneofEnum = Message3_Enum_Bar; 1294 XCTAssertThrowsSpecificNamed(msg.oneofEnum = 666, NSException, 1295 NSInvalidArgumentException); 1296 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Bar); 1297 1298 // Set via raw api to confirm it works. 1299 1300 SetMessage3_OptionalEnum_RawValue(msg, 666); 1301 XCTAssertEqual(msg.optionalEnum, 1302 Message3_Enum_GPBUnrecognizedEnumeratorValue); 1303 XCTAssertEqual(Message3_OptionalEnum_RawValue(msg), 666); 1304 1305 SetMessage3_OneofEnum_RawValue(msg, 666); 1306 XCTAssertEqual(msg.oneofEnum, Message3_Enum_GPBUnrecognizedEnumeratorValue); 1307 XCTAssertEqual(Message3_OneofEnum_RawValue(msg), 666); 1308 1309 [msg release]; 1310} 1311 1312- (void)testProto2OneofBasicBehaviors { 1313 Message2 *msg = [[Message2 alloc] init]; 1314 1315 NSString *oneofStringDefault = @"string"; 1316 NSData *oneofBytesDefault = [@"data" dataUsingEncoding:NSUTF8StringEncoding]; 1317 1318 // Nothing set. 1319 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase); 1320 XCTAssertEqual(msg.oneofInt32, 100); 1321 XCTAssertEqual(msg.oneofInt64, 101); 1322 XCTAssertEqual(msg.oneofUint32, 102U); 1323 XCTAssertEqual(msg.oneofUint64, 103U); 1324 XCTAssertEqual(msg.oneofSint32, 104); 1325 XCTAssertEqual(msg.oneofSint64, 105); 1326 XCTAssertEqual(msg.oneofFixed32, 106U); 1327 XCTAssertEqual(msg.oneofFixed64, 107U); 1328 XCTAssertEqual(msg.oneofSfixed32, 108); 1329 XCTAssertEqual(msg.oneofSfixed64, 109); 1330 XCTAssertEqual(msg.oneofFloat, 110.0f); 1331 XCTAssertEqual(msg.oneofDouble, 111.0); 1332 XCTAssertEqual(msg.oneofBool, YES); 1333 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1334 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1335 XCTAssertNotNil(msg.oneofGroup); 1336 XCTAssertNotNil(msg.oneofMessage); 1337 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1338 1339 // Set, check the case, check everyone has default but the one, confirm case 1340 // didn't change. 1341 1342 msg.oneofInt32 = 1; 1343 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32); 1344 XCTAssertEqual(msg.oneofInt32, 1); 1345 XCTAssertEqual(msg.oneofInt64, 101); 1346 XCTAssertEqual(msg.oneofUint32, 102U); 1347 XCTAssertEqual(msg.oneofUint64, 103U); 1348 XCTAssertEqual(msg.oneofSint32, 104); 1349 XCTAssertEqual(msg.oneofSint64, 105); 1350 XCTAssertEqual(msg.oneofFixed32, 106U); 1351 XCTAssertEqual(msg.oneofFixed64, 107U); 1352 XCTAssertEqual(msg.oneofSfixed32, 108); 1353 XCTAssertEqual(msg.oneofSfixed64, 109); 1354 XCTAssertEqual(msg.oneofFloat, 110.0f); 1355 XCTAssertEqual(msg.oneofDouble, 111.0); 1356 XCTAssertEqual(msg.oneofBool, YES); 1357 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1358 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1359 XCTAssertNotNil(msg.oneofGroup); 1360 XCTAssertNotNil(msg.oneofMessage); 1361 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1362 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32); 1363 1364 msg.oneofInt64 = 2; 1365 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64); 1366 XCTAssertEqual(msg.oneofInt32, 100); 1367 XCTAssertEqual(msg.oneofInt64, 2); 1368 XCTAssertEqual(msg.oneofUint32, 102U); 1369 XCTAssertEqual(msg.oneofUint64, 103U); 1370 XCTAssertEqual(msg.oneofSint32, 104); 1371 XCTAssertEqual(msg.oneofSint64, 105); 1372 XCTAssertEqual(msg.oneofFixed32, 106U); 1373 XCTAssertEqual(msg.oneofFixed64, 107U); 1374 XCTAssertEqual(msg.oneofSfixed32, 108); 1375 XCTAssertEqual(msg.oneofSfixed64, 109); 1376 XCTAssertEqual(msg.oneofFloat, 110.0f); 1377 XCTAssertEqual(msg.oneofDouble, 111.0); 1378 XCTAssertEqual(msg.oneofBool, YES); 1379 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1380 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1381 XCTAssertNotNil(msg.oneofGroup); 1382 XCTAssertNotNil(msg.oneofMessage); 1383 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1384 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64); 1385 1386 msg.oneofUint32 = 3; 1387 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32); 1388 XCTAssertEqual(msg.oneofInt32, 100); 1389 XCTAssertEqual(msg.oneofInt64, 101); 1390 XCTAssertEqual(msg.oneofUint32, 3U); 1391 XCTAssertEqual(msg.oneofUint64, 103U); 1392 XCTAssertEqual(msg.oneofSint32, 104); 1393 XCTAssertEqual(msg.oneofSint64, 105); 1394 XCTAssertEqual(msg.oneofFixed32, 106U); 1395 XCTAssertEqual(msg.oneofFixed64, 107U); 1396 XCTAssertEqual(msg.oneofSfixed32, 108); 1397 XCTAssertEqual(msg.oneofSfixed64, 109); 1398 XCTAssertEqual(msg.oneofFloat, 110.0f); 1399 XCTAssertEqual(msg.oneofDouble, 111.0); 1400 XCTAssertEqual(msg.oneofBool, YES); 1401 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1402 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1403 XCTAssertNotNil(msg.oneofGroup); 1404 XCTAssertNotNil(msg.oneofMessage); 1405 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1406 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32); 1407 1408 msg.oneofUint64 = 4; 1409 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64); 1410 XCTAssertEqual(msg.oneofInt32, 100); 1411 XCTAssertEqual(msg.oneofInt64, 101); 1412 XCTAssertEqual(msg.oneofUint32, 102U); 1413 XCTAssertEqual(msg.oneofUint64, 4U); 1414 XCTAssertEqual(msg.oneofSint32, 104); 1415 XCTAssertEqual(msg.oneofSint64, 105); 1416 XCTAssertEqual(msg.oneofFixed32, 106U); 1417 XCTAssertEqual(msg.oneofFixed64, 107U); 1418 XCTAssertEqual(msg.oneofSfixed32, 108); 1419 XCTAssertEqual(msg.oneofSfixed64, 109); 1420 XCTAssertEqual(msg.oneofFloat, 110.0f); 1421 XCTAssertEqual(msg.oneofDouble, 111.0); 1422 XCTAssertEqual(msg.oneofBool, YES); 1423 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1424 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1425 XCTAssertNotNil(msg.oneofGroup); 1426 XCTAssertNotNil(msg.oneofMessage); 1427 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1428 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64); 1429 1430 msg.oneofSint32 = 5; 1431 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32); 1432 XCTAssertEqual(msg.oneofInt32, 100); 1433 XCTAssertEqual(msg.oneofInt64, 101); 1434 XCTAssertEqual(msg.oneofUint32, 102U); 1435 XCTAssertEqual(msg.oneofUint64, 103U); 1436 XCTAssertEqual(msg.oneofSint32, 5); 1437 XCTAssertEqual(msg.oneofSint64, 105); 1438 XCTAssertEqual(msg.oneofFixed32, 106U); 1439 XCTAssertEqual(msg.oneofFixed64, 107U); 1440 XCTAssertEqual(msg.oneofSfixed32, 108); 1441 XCTAssertEqual(msg.oneofSfixed64, 109); 1442 XCTAssertEqual(msg.oneofFloat, 110.0f); 1443 XCTAssertEqual(msg.oneofDouble, 111.0); 1444 XCTAssertEqual(msg.oneofBool, YES); 1445 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1446 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1447 XCTAssertNotNil(msg.oneofGroup); 1448 XCTAssertNotNil(msg.oneofMessage); 1449 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1450 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32); 1451 1452 msg.oneofSint64 = 6; 1453 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64); 1454 XCTAssertEqual(msg.oneofInt32, 100); 1455 XCTAssertEqual(msg.oneofInt64, 101); 1456 XCTAssertEqual(msg.oneofUint32, 102U); 1457 XCTAssertEqual(msg.oneofUint64, 103U); 1458 XCTAssertEqual(msg.oneofSint32, 104); 1459 XCTAssertEqual(msg.oneofSint64, 6); 1460 XCTAssertEqual(msg.oneofFixed32, 106U); 1461 XCTAssertEqual(msg.oneofFixed64, 107U); 1462 XCTAssertEqual(msg.oneofSfixed32, 108); 1463 XCTAssertEqual(msg.oneofSfixed64, 109); 1464 XCTAssertEqual(msg.oneofFloat, 110.0f); 1465 XCTAssertEqual(msg.oneofDouble, 111.0); 1466 XCTAssertEqual(msg.oneofBool, YES); 1467 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1468 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1469 XCTAssertNotNil(msg.oneofGroup); 1470 XCTAssertNotNil(msg.oneofMessage); 1471 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1472 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64); 1473 1474 msg.oneofFixed32 = 7; 1475 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32); 1476 XCTAssertEqual(msg.oneofInt32, 100); 1477 XCTAssertEqual(msg.oneofInt64, 101); 1478 XCTAssertEqual(msg.oneofUint32, 102U); 1479 XCTAssertEqual(msg.oneofUint64, 103U); 1480 XCTAssertEqual(msg.oneofSint32, 104); 1481 XCTAssertEqual(msg.oneofSint64, 105); 1482 XCTAssertEqual(msg.oneofFixed32, 7U); 1483 XCTAssertEqual(msg.oneofFixed64, 107U); 1484 XCTAssertEqual(msg.oneofSfixed32, 108); 1485 XCTAssertEqual(msg.oneofSfixed64, 109); 1486 XCTAssertEqual(msg.oneofFloat, 110.0f); 1487 XCTAssertEqual(msg.oneofDouble, 111.0); 1488 XCTAssertEqual(msg.oneofBool, YES); 1489 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1490 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1491 XCTAssertNotNil(msg.oneofGroup); 1492 XCTAssertNotNil(msg.oneofMessage); 1493 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1494 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32); 1495 1496 msg.oneofFixed64 = 8; 1497 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64); 1498 XCTAssertEqual(msg.oneofInt32, 100); 1499 XCTAssertEqual(msg.oneofInt64, 101); 1500 XCTAssertEqual(msg.oneofUint32, 102U); 1501 XCTAssertEqual(msg.oneofUint64, 103U); 1502 XCTAssertEqual(msg.oneofSint32, 104); 1503 XCTAssertEqual(msg.oneofSint64, 105); 1504 XCTAssertEqual(msg.oneofFixed32, 106U); 1505 XCTAssertEqual(msg.oneofFixed64, 8U); 1506 XCTAssertEqual(msg.oneofSfixed32, 108); 1507 XCTAssertEqual(msg.oneofSfixed64, 109); 1508 XCTAssertEqual(msg.oneofFloat, 110.0f); 1509 XCTAssertEqual(msg.oneofDouble, 111.0); 1510 XCTAssertEqual(msg.oneofBool, YES); 1511 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1512 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1513 XCTAssertNotNil(msg.oneofGroup); 1514 XCTAssertNotNil(msg.oneofMessage); 1515 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1516 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64); 1517 1518 msg.oneofSfixed32 = 9; 1519 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32); 1520 XCTAssertEqual(msg.oneofInt32, 100); 1521 XCTAssertEqual(msg.oneofInt64, 101); 1522 XCTAssertEqual(msg.oneofUint32, 102U); 1523 XCTAssertEqual(msg.oneofUint64, 103U); 1524 XCTAssertEqual(msg.oneofSint32, 104); 1525 XCTAssertEqual(msg.oneofSint64, 105); 1526 XCTAssertEqual(msg.oneofFixed32, 106U); 1527 XCTAssertEqual(msg.oneofFixed64, 107U); 1528 XCTAssertEqual(msg.oneofSfixed32, 9); 1529 XCTAssertEqual(msg.oneofSfixed64, 109); 1530 XCTAssertEqual(msg.oneofFloat, 110.0f); 1531 XCTAssertEqual(msg.oneofDouble, 111.0); 1532 XCTAssertEqual(msg.oneofBool, YES); 1533 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1534 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1535 XCTAssertNotNil(msg.oneofGroup); 1536 XCTAssertNotNil(msg.oneofMessage); 1537 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1538 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32); 1539 1540 msg.oneofSfixed64 = 10; 1541 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64); 1542 XCTAssertEqual(msg.oneofInt32, 100); 1543 XCTAssertEqual(msg.oneofInt64, 101); 1544 XCTAssertEqual(msg.oneofUint32, 102U); 1545 XCTAssertEqual(msg.oneofUint64, 103U); 1546 XCTAssertEqual(msg.oneofSint32, 104); 1547 XCTAssertEqual(msg.oneofSint64, 105); 1548 XCTAssertEqual(msg.oneofFixed32, 106U); 1549 XCTAssertEqual(msg.oneofFixed64, 107U); 1550 XCTAssertEqual(msg.oneofSfixed32, 108); 1551 XCTAssertEqual(msg.oneofSfixed64, 10); 1552 XCTAssertEqual(msg.oneofFloat, 110.0f); 1553 XCTAssertEqual(msg.oneofDouble, 111.0); 1554 XCTAssertEqual(msg.oneofBool, YES); 1555 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1556 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1557 XCTAssertNotNil(msg.oneofGroup); 1558 XCTAssertNotNil(msg.oneofMessage); 1559 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1560 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64); 1561 1562 msg.oneofFloat = 11.0f; 1563 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat); 1564 XCTAssertEqual(msg.oneofInt32, 100); 1565 XCTAssertEqual(msg.oneofInt64, 101); 1566 XCTAssertEqual(msg.oneofUint32, 102U); 1567 XCTAssertEqual(msg.oneofUint64, 103U); 1568 XCTAssertEqual(msg.oneofSint32, 104); 1569 XCTAssertEqual(msg.oneofSint64, 105); 1570 XCTAssertEqual(msg.oneofFixed32, 106U); 1571 XCTAssertEqual(msg.oneofFixed64, 107U); 1572 XCTAssertEqual(msg.oneofSfixed32, 108); 1573 XCTAssertEqual(msg.oneofSfixed64, 109); 1574 XCTAssertEqual(msg.oneofFloat, 11.0f); 1575 XCTAssertEqual(msg.oneofDouble, 111.0); 1576 XCTAssertEqual(msg.oneofBool, YES); 1577 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1578 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1579 XCTAssertNotNil(msg.oneofGroup); 1580 XCTAssertNotNil(msg.oneofMessage); 1581 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1582 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat); 1583 1584 msg.oneofDouble = 12.0; 1585 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble); 1586 XCTAssertEqual(msg.oneofInt32, 100); 1587 XCTAssertEqual(msg.oneofInt64, 101); 1588 XCTAssertEqual(msg.oneofUint32, 102U); 1589 XCTAssertEqual(msg.oneofUint64, 103U); 1590 XCTAssertEqual(msg.oneofSint32, 104); 1591 XCTAssertEqual(msg.oneofSint64, 105); 1592 XCTAssertEqual(msg.oneofFixed32, 106U); 1593 XCTAssertEqual(msg.oneofFixed64, 107U); 1594 XCTAssertEqual(msg.oneofSfixed32, 108); 1595 XCTAssertEqual(msg.oneofSfixed64, 109); 1596 XCTAssertEqual(msg.oneofFloat, 110.0f); 1597 XCTAssertEqual(msg.oneofDouble, 12.0); 1598 XCTAssertEqual(msg.oneofBool, YES); 1599 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1600 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1601 XCTAssertNotNil(msg.oneofGroup); 1602 XCTAssertNotNil(msg.oneofMessage); 1603 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1604 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble); 1605 1606 msg.oneofBool = NO; 1607 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool); 1608 XCTAssertEqual(msg.oneofInt32, 100); 1609 XCTAssertEqual(msg.oneofInt64, 101); 1610 XCTAssertEqual(msg.oneofUint32, 102U); 1611 XCTAssertEqual(msg.oneofUint64, 103U); 1612 XCTAssertEqual(msg.oneofSint32, 104); 1613 XCTAssertEqual(msg.oneofSint64, 105); 1614 XCTAssertEqual(msg.oneofFixed32, 106U); 1615 XCTAssertEqual(msg.oneofFixed64, 107U); 1616 XCTAssertEqual(msg.oneofSfixed32, 108); 1617 XCTAssertEqual(msg.oneofSfixed64, 109); 1618 XCTAssertEqual(msg.oneofFloat, 110.0f); 1619 XCTAssertEqual(msg.oneofDouble, 111.0); 1620 XCTAssertEqual(msg.oneofBool, NO); 1621 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1622 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1623 XCTAssertNotNil(msg.oneofGroup); 1624 XCTAssertNotNil(msg.oneofMessage); 1625 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1626 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool); 1627 1628 msg.oneofString = @"foo"; 1629 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString); 1630 XCTAssertEqual(msg.oneofInt32, 100); 1631 XCTAssertEqual(msg.oneofInt64, 101); 1632 XCTAssertEqual(msg.oneofUint32, 102U); 1633 XCTAssertEqual(msg.oneofUint64, 103U); 1634 XCTAssertEqual(msg.oneofSint32, 104); 1635 XCTAssertEqual(msg.oneofSint64, 105); 1636 XCTAssertEqual(msg.oneofFixed32, 106U); 1637 XCTAssertEqual(msg.oneofFixed64, 107U); 1638 XCTAssertEqual(msg.oneofSfixed32, 108); 1639 XCTAssertEqual(msg.oneofSfixed64, 109); 1640 XCTAssertEqual(msg.oneofFloat, 110.0f); 1641 XCTAssertEqual(msg.oneofDouble, 111.0); 1642 XCTAssertEqual(msg.oneofBool, YES); 1643 XCTAssertEqualObjects(msg.oneofString, @"foo"); 1644 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1645 XCTAssertNotNil(msg.oneofGroup); 1646 XCTAssertNotNil(msg.oneofMessage); 1647 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1648 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString); 1649 1650 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; 1651 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes); 1652 XCTAssertEqual(msg.oneofInt32, 100); 1653 XCTAssertEqual(msg.oneofInt64, 101); 1654 XCTAssertEqual(msg.oneofUint32, 102U); 1655 XCTAssertEqual(msg.oneofUint64, 103U); 1656 XCTAssertEqual(msg.oneofSint32, 104); 1657 XCTAssertEqual(msg.oneofSint64, 105); 1658 XCTAssertEqual(msg.oneofFixed32, 106U); 1659 XCTAssertEqual(msg.oneofFixed64, 107U); 1660 XCTAssertEqual(msg.oneofSfixed32, 108); 1661 XCTAssertEqual(msg.oneofSfixed64, 109); 1662 XCTAssertEqual(msg.oneofFloat, 110.0f); 1663 XCTAssertEqual(msg.oneofDouble, 111.0); 1664 XCTAssertEqual(msg.oneofBool, YES); 1665 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1666 XCTAssertEqualObjects(msg.oneofBytes, 1667 [@"bar" dataUsingEncoding:NSUTF8StringEncoding]); 1668 XCTAssertNotNil(msg.oneofGroup); 1669 XCTAssertNotNil(msg.oneofMessage); 1670 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1671 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes); 1672 1673 Message2_OneofGroup *group = [Message2_OneofGroup message]; 1674 msg.oneofGroup = group; 1675 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup); 1676 XCTAssertEqual(msg.oneofInt32, 100); 1677 XCTAssertEqual(msg.oneofInt64, 101); 1678 XCTAssertEqual(msg.oneofUint32, 102U); 1679 XCTAssertEqual(msg.oneofUint64, 103U); 1680 XCTAssertEqual(msg.oneofSint32, 104); 1681 XCTAssertEqual(msg.oneofSint64, 105); 1682 XCTAssertEqual(msg.oneofFixed32, 106U); 1683 XCTAssertEqual(msg.oneofFixed64, 107U); 1684 XCTAssertEqual(msg.oneofSfixed32, 108); 1685 XCTAssertEqual(msg.oneofSfixed64, 109); 1686 XCTAssertEqual(msg.oneofFloat, 110.0f); 1687 XCTAssertEqual(msg.oneofDouble, 111.0); 1688 XCTAssertEqual(msg.oneofBool, YES); 1689 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1690 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1691 XCTAssertEqual(msg.oneofGroup, group); // Pointer compare. 1692 XCTAssertNotNil(msg.oneofMessage); 1693 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1694 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup); 1695 1696 Message2 *subMessage = [Message2 message]; 1697 msg.oneofMessage = subMessage; 1698 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage); 1699 XCTAssertEqual(msg.oneofInt32, 100); 1700 XCTAssertEqual(msg.oneofInt64, 101); 1701 XCTAssertEqual(msg.oneofUint32, 102U); 1702 XCTAssertEqual(msg.oneofUint64, 103U); 1703 XCTAssertEqual(msg.oneofSint32, 104); 1704 XCTAssertEqual(msg.oneofSint64, 105); 1705 XCTAssertEqual(msg.oneofFixed32, 106U); 1706 XCTAssertEqual(msg.oneofFixed64, 107U); 1707 XCTAssertEqual(msg.oneofSfixed32, 108); 1708 XCTAssertEqual(msg.oneofSfixed64, 109); 1709 XCTAssertEqual(msg.oneofFloat, 110.0f); 1710 XCTAssertEqual(msg.oneofDouble, 111.0); 1711 XCTAssertEqual(msg.oneofBool, YES); 1712 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1713 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1714 XCTAssertNotNil(msg.oneofGroup); 1715 XCTAssertNotEqual(msg.oneofGroup, group); // Pointer compare. 1716 XCTAssertEqual(msg.oneofMessage, subMessage); // Pointer compare. 1717 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz); 1718 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage); 1719 1720 msg.oneofEnum = Message2_Enum_Bar; 1721 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum); 1722 XCTAssertEqual(msg.oneofInt32, 100); 1723 XCTAssertEqual(msg.oneofInt64, 101); 1724 XCTAssertEqual(msg.oneofUint32, 102U); 1725 XCTAssertEqual(msg.oneofUint64, 103U); 1726 XCTAssertEqual(msg.oneofSint32, 104); 1727 XCTAssertEqual(msg.oneofSint64, 105); 1728 XCTAssertEqual(msg.oneofFixed32, 106U); 1729 XCTAssertEqual(msg.oneofFixed64, 107U); 1730 XCTAssertEqual(msg.oneofSfixed32, 108); 1731 XCTAssertEqual(msg.oneofSfixed64, 109); 1732 XCTAssertEqual(msg.oneofFloat, 110.0f); 1733 XCTAssertEqual(msg.oneofDouble, 111.0); 1734 XCTAssertEqual(msg.oneofBool, YES); 1735 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1736 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1737 XCTAssertNotNil(msg.oneofGroup); 1738 XCTAssertNotEqual(msg.oneofGroup, group); // Pointer compare. 1739 XCTAssertNotNil(msg.oneofMessage); 1740 XCTAssertNotEqual(msg.oneofMessage, subMessage); // Pointer compare. 1741 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar); 1742 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum); 1743 1744 // Test setting/calling clear clearing. 1745 1746 [msg release]; 1747 msg = [[Message2 alloc] init]; 1748 1749 int32_t values[] = { 1750 Message2_O_OneOfCase_OneofInt32, 1751 Message2_O_OneOfCase_OneofInt64, 1752 Message2_O_OneOfCase_OneofUint32, 1753 Message2_O_OneOfCase_OneofUint64, 1754 Message2_O_OneOfCase_OneofSint32, 1755 Message2_O_OneOfCase_OneofSint64, 1756 Message2_O_OneOfCase_OneofFixed32, 1757 Message2_O_OneOfCase_OneofFixed64, 1758 Message2_O_OneOfCase_OneofSfixed32, 1759 Message2_O_OneOfCase_OneofSfixed64, 1760 Message2_O_OneOfCase_OneofFloat, 1761 Message2_O_OneOfCase_OneofDouble, 1762 Message2_O_OneOfCase_OneofBool, 1763 Message2_O_OneOfCase_OneofString, 1764 Message2_O_OneOfCase_OneofBytes, 1765 Message2_O_OneOfCase_OneofGroup, 1766 Message2_O_OneOfCase_OneofMessage, 1767 Message2_O_OneOfCase_OneofEnum, 1768 }; 1769 1770 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) { 1771 switch (values[i]) { 1772 case Message2_O_OneOfCase_OneofInt32: 1773 msg.oneofInt32 = 1; 1774 break; 1775 case Message2_O_OneOfCase_OneofInt64: 1776 msg.oneofInt64 = 2; 1777 break; 1778 case Message2_O_OneOfCase_OneofUint32: 1779 msg.oneofUint32 = 3; 1780 break; 1781 case Message2_O_OneOfCase_OneofUint64: 1782 msg.oneofUint64 = 4; 1783 break; 1784 case Message2_O_OneOfCase_OneofSint32: 1785 msg.oneofSint32 = 5; 1786 break; 1787 case Message2_O_OneOfCase_OneofSint64: 1788 msg.oneofSint64 = 6; 1789 break; 1790 case Message2_O_OneOfCase_OneofFixed32: 1791 msg.oneofFixed32 = 7; 1792 break; 1793 case Message2_O_OneOfCase_OneofFixed64: 1794 msg.oneofFixed64 = 8; 1795 break; 1796 case Message2_O_OneOfCase_OneofSfixed32: 1797 msg.oneofSfixed32 = 9; 1798 break; 1799 case Message2_O_OneOfCase_OneofSfixed64: 1800 msg.oneofSfixed64 = 10; 1801 break; 1802 case Message2_O_OneOfCase_OneofFloat: 1803 msg.oneofFloat = 11.0f; 1804 break; 1805 case Message2_O_OneOfCase_OneofDouble: 1806 msg.oneofDouble = 12.0; 1807 break; 1808 case Message2_O_OneOfCase_OneofBool: 1809 msg.oneofBool = YES; 1810 break; 1811 case Message2_O_OneOfCase_OneofString: 1812 msg.oneofString = @"foo"; 1813 break; 1814 case Message2_O_OneOfCase_OneofBytes: 1815 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; 1816 break; 1817 case Message2_O_OneOfCase_OneofGroup: 1818 msg.oneofGroup = group; 1819 break; 1820 case Message2_O_OneOfCase_OneofMessage: 1821 msg.oneofMessage = subMessage; 1822 break; 1823 case Message2_O_OneOfCase_OneofEnum: 1824 msg.oneofEnum = Message2_Enum_Bar; 1825 break; 1826 default: 1827 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]); 1828 break; 1829 } 1830 1831 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i); 1832 // No need to check the value was set, the above tests did that. 1833 Message2_ClearOOneOfCase(msg); 1834 // Nothing in the case. 1835 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase, 1836 "Loop: %zd", i); 1837 // Confirm everything is back to defaults after a clear. 1838 XCTAssertEqual(msg.oneofInt32, 100, "Loop: %zd", i); 1839 XCTAssertEqual(msg.oneofInt64, 101, "Loop: %zd", i); 1840 XCTAssertEqual(msg.oneofUint32, 102U, "Loop: %zd", i); 1841 XCTAssertEqual(msg.oneofUint64, 103U, "Loop: %zd", i); 1842 XCTAssertEqual(msg.oneofSint32, 104, "Loop: %zd", i); 1843 XCTAssertEqual(msg.oneofSint64, 105, "Loop: %zd", i); 1844 XCTAssertEqual(msg.oneofFixed32, 106U, "Loop: %zd", i); 1845 XCTAssertEqual(msg.oneofFixed64, 107U, "Loop: %zd", i); 1846 XCTAssertEqual(msg.oneofSfixed32, 108, "Loop: %zd", i); 1847 XCTAssertEqual(msg.oneofSfixed64, 109, "Loop: %zd", i); 1848 XCTAssertEqual(msg.oneofFloat, 110.0f, "Loop: %zd", i); 1849 XCTAssertEqual(msg.oneofDouble, 111.0, "Loop: %zd", i); 1850 XCTAssertEqual(msg.oneofBool, YES, "Loop: %zd", i); 1851 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i); 1852 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i); 1853 XCTAssertNotNil(msg.oneofGroup, "Loop: %zd", i); 1854 XCTAssertNotEqual(msg.oneofGroup, group, "Loop: %zd", 1855 i); // Pointer compare. 1856 XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i); 1857 XCTAssertNotEqual(msg.oneofMessage, subMessage, "Loop: %zd", 1858 i); // Pointer compare. 1859 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz, "Loop: %zd", i); 1860 } 1861 1862 [msg release]; 1863} 1864 1865- (void)testProto3OneofBasicBehaviors { 1866 Message3 *msg = [[Message3 alloc] init]; 1867 1868 NSString *oneofStringDefault = @""; 1869 NSData *oneofBytesDefault = [NSData data]; 1870 1871 // Nothing set. 1872 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase); 1873 XCTAssertEqual(msg.oneofInt32, 0); 1874 XCTAssertEqual(msg.oneofInt64, 0); 1875 XCTAssertEqual(msg.oneofUint32, 0U); 1876 XCTAssertEqual(msg.oneofUint64, 0U); 1877 XCTAssertEqual(msg.oneofSint32, 0); 1878 XCTAssertEqual(msg.oneofSint64, 0); 1879 XCTAssertEqual(msg.oneofFixed32, 0U); 1880 XCTAssertEqual(msg.oneofFixed64, 0U); 1881 XCTAssertEqual(msg.oneofSfixed32, 0); 1882 XCTAssertEqual(msg.oneofSfixed64, 0); 1883 XCTAssertEqual(msg.oneofFloat, 0.0f); 1884 XCTAssertEqual(msg.oneofDouble, 0.0); 1885 XCTAssertEqual(msg.oneofBool, NO); 1886 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1887 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1888 XCTAssertNotNil(msg.oneofMessage); 1889 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 1890 1891 // Set, check the case, check everyone has default but the one, confirm case 1892 // didn't change. 1893 1894 msg.oneofInt32 = 1; 1895 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32); 1896 XCTAssertEqual(msg.oneofInt32, 1); 1897 XCTAssertEqual(msg.oneofInt64, 0); 1898 XCTAssertEqual(msg.oneofUint32, 0U); 1899 XCTAssertEqual(msg.oneofUint64, 0U); 1900 XCTAssertEqual(msg.oneofSint32, 0); 1901 XCTAssertEqual(msg.oneofSint64, 0); 1902 XCTAssertEqual(msg.oneofFixed32, 0U); 1903 XCTAssertEqual(msg.oneofFixed64, 0U); 1904 XCTAssertEqual(msg.oneofSfixed32, 0); 1905 XCTAssertEqual(msg.oneofSfixed64, 0); 1906 XCTAssertEqual(msg.oneofFloat, 0.0f); 1907 XCTAssertEqual(msg.oneofDouble, 0.0); 1908 XCTAssertEqual(msg.oneofBool, NO); 1909 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1910 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1911 XCTAssertNotNil(msg.oneofMessage); 1912 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 1913 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32); 1914 1915 msg.oneofInt64 = 2; 1916 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64); 1917 XCTAssertEqual(msg.oneofInt32, 0); 1918 XCTAssertEqual(msg.oneofInt64, 2); 1919 XCTAssertEqual(msg.oneofUint32, 0U); 1920 XCTAssertEqual(msg.oneofUint64, 0U); 1921 XCTAssertEqual(msg.oneofSint32, 0); 1922 XCTAssertEqual(msg.oneofSint64, 0); 1923 XCTAssertEqual(msg.oneofFixed32, 0U); 1924 XCTAssertEqual(msg.oneofFixed64, 0U); 1925 XCTAssertEqual(msg.oneofSfixed32, 0); 1926 XCTAssertEqual(msg.oneofSfixed64, 0); 1927 XCTAssertEqual(msg.oneofFloat, 0.0f); 1928 XCTAssertEqual(msg.oneofDouble, 0.0); 1929 XCTAssertEqual(msg.oneofBool, NO); 1930 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1931 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1932 XCTAssertNotNil(msg.oneofMessage); 1933 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 1934 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64); 1935 1936 msg.oneofUint32 = 3; 1937 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32); 1938 XCTAssertEqual(msg.oneofInt32, 0); 1939 XCTAssertEqual(msg.oneofInt64, 0); 1940 XCTAssertEqual(msg.oneofUint32, 3U); 1941 XCTAssertEqual(msg.oneofUint64, 0U); 1942 XCTAssertEqual(msg.oneofSint32, 0); 1943 XCTAssertEqual(msg.oneofSint64, 0); 1944 XCTAssertEqual(msg.oneofFixed32, 0U); 1945 XCTAssertEqual(msg.oneofFixed64, 0U); 1946 XCTAssertEqual(msg.oneofSfixed32, 0); 1947 XCTAssertEqual(msg.oneofSfixed64, 0); 1948 XCTAssertEqual(msg.oneofFloat, 0.0f); 1949 XCTAssertEqual(msg.oneofDouble, 0.0); 1950 XCTAssertEqual(msg.oneofBool, NO); 1951 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1952 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1953 XCTAssertNotNil(msg.oneofMessage); 1954 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 1955 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32); 1956 1957 msg.oneofUint64 = 4; 1958 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64); 1959 XCTAssertEqual(msg.oneofInt32, 0); 1960 XCTAssertEqual(msg.oneofInt64, 0); 1961 XCTAssertEqual(msg.oneofUint32, 0U); 1962 XCTAssertEqual(msg.oneofUint64, 4U); 1963 XCTAssertEqual(msg.oneofSint32, 0); 1964 XCTAssertEqual(msg.oneofSint64, 0); 1965 XCTAssertEqual(msg.oneofFixed32, 0U); 1966 XCTAssertEqual(msg.oneofFixed64, 0U); 1967 XCTAssertEqual(msg.oneofSfixed32, 0); 1968 XCTAssertEqual(msg.oneofSfixed64, 0); 1969 XCTAssertEqual(msg.oneofFloat, 0.0f); 1970 XCTAssertEqual(msg.oneofDouble, 0.0); 1971 XCTAssertEqual(msg.oneofBool, NO); 1972 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1973 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1974 XCTAssertNotNil(msg.oneofMessage); 1975 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 1976 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64); 1977 1978 msg.oneofSint32 = 5; 1979 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32); 1980 XCTAssertEqual(msg.oneofInt32, 0); 1981 XCTAssertEqual(msg.oneofInt64, 0); 1982 XCTAssertEqual(msg.oneofUint32, 0U); 1983 XCTAssertEqual(msg.oneofUint64, 0U); 1984 XCTAssertEqual(msg.oneofSint32, 5); 1985 XCTAssertEqual(msg.oneofSint64, 0); 1986 XCTAssertEqual(msg.oneofFixed32, 0U); 1987 XCTAssertEqual(msg.oneofFixed64, 0U); 1988 XCTAssertEqual(msg.oneofSfixed32, 0); 1989 XCTAssertEqual(msg.oneofSfixed64, 0); 1990 XCTAssertEqual(msg.oneofFloat, 0.0f); 1991 XCTAssertEqual(msg.oneofDouble, 0.0); 1992 XCTAssertEqual(msg.oneofBool, NO); 1993 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 1994 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 1995 XCTAssertNotNil(msg.oneofMessage); 1996 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 1997 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32); 1998 1999 msg.oneofSint64 = 6; 2000 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64); 2001 XCTAssertEqual(msg.oneofInt32, 0); 2002 XCTAssertEqual(msg.oneofInt64, 0); 2003 XCTAssertEqual(msg.oneofUint32, 0U); 2004 XCTAssertEqual(msg.oneofUint64, 0U); 2005 XCTAssertEqual(msg.oneofSint32, 0); 2006 XCTAssertEqual(msg.oneofSint64, 6); 2007 XCTAssertEqual(msg.oneofFixed32, 0U); 2008 XCTAssertEqual(msg.oneofFixed64, 0U); 2009 XCTAssertEqual(msg.oneofSfixed32, 0); 2010 XCTAssertEqual(msg.oneofSfixed64, 0); 2011 XCTAssertEqual(msg.oneofFloat, 0.0f); 2012 XCTAssertEqual(msg.oneofDouble, 0.0); 2013 XCTAssertEqual(msg.oneofBool, NO); 2014 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2015 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2016 XCTAssertNotNil(msg.oneofMessage); 2017 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2018 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64); 2019 2020 msg.oneofFixed32 = 7; 2021 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32); 2022 XCTAssertEqual(msg.oneofInt32, 0); 2023 XCTAssertEqual(msg.oneofInt64, 0); 2024 XCTAssertEqual(msg.oneofUint32, 0U); 2025 XCTAssertEqual(msg.oneofUint64, 0U); 2026 XCTAssertEqual(msg.oneofSint32, 0); 2027 XCTAssertEqual(msg.oneofSint64, 0); 2028 XCTAssertEqual(msg.oneofFixed32, 7U); 2029 XCTAssertEqual(msg.oneofFixed64, 0U); 2030 XCTAssertEqual(msg.oneofSfixed32, 0); 2031 XCTAssertEqual(msg.oneofSfixed64, 0); 2032 XCTAssertEqual(msg.oneofFloat, 0.0f); 2033 XCTAssertEqual(msg.oneofDouble, 0.0); 2034 XCTAssertEqual(msg.oneofBool, NO); 2035 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2036 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2037 XCTAssertNotNil(msg.oneofMessage); 2038 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2039 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32); 2040 2041 msg.oneofFixed64 = 8; 2042 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64); 2043 XCTAssertEqual(msg.oneofInt32, 0); 2044 XCTAssertEqual(msg.oneofInt64, 0); 2045 XCTAssertEqual(msg.oneofUint32, 0U); 2046 XCTAssertEqual(msg.oneofUint64, 0U); 2047 XCTAssertEqual(msg.oneofSint32, 0); 2048 XCTAssertEqual(msg.oneofSint64, 0); 2049 XCTAssertEqual(msg.oneofFixed32, 0U); 2050 XCTAssertEqual(msg.oneofFixed64, 8U); 2051 XCTAssertEqual(msg.oneofSfixed32, 0); 2052 XCTAssertEqual(msg.oneofSfixed64, 0); 2053 XCTAssertEqual(msg.oneofFloat, 0.0f); 2054 XCTAssertEqual(msg.oneofDouble, 0.0); 2055 XCTAssertEqual(msg.oneofBool, NO); 2056 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2057 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2058 XCTAssertNotNil(msg.oneofMessage); 2059 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2060 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64); 2061 2062 msg.oneofSfixed32 = 9; 2063 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32); 2064 XCTAssertEqual(msg.oneofInt32, 0); 2065 XCTAssertEqual(msg.oneofInt64, 0); 2066 XCTAssertEqual(msg.oneofUint32, 0U); 2067 XCTAssertEqual(msg.oneofUint64, 0U); 2068 XCTAssertEqual(msg.oneofSint32, 0); 2069 XCTAssertEqual(msg.oneofSint64, 0); 2070 XCTAssertEqual(msg.oneofFixed32, 0U); 2071 XCTAssertEqual(msg.oneofFixed64, 0U); 2072 XCTAssertEqual(msg.oneofSfixed32, 9); 2073 XCTAssertEqual(msg.oneofSfixed64, 0); 2074 XCTAssertEqual(msg.oneofFloat, 0.0f); 2075 XCTAssertEqual(msg.oneofDouble, 0.0); 2076 XCTAssertEqual(msg.oneofBool, NO); 2077 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2078 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2079 XCTAssertNotNil(msg.oneofMessage); 2080 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2081 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32); 2082 2083 msg.oneofSfixed64 = 10; 2084 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64); 2085 XCTAssertEqual(msg.oneofInt32, 0); 2086 XCTAssertEqual(msg.oneofInt64, 0); 2087 XCTAssertEqual(msg.oneofUint32, 0U); 2088 XCTAssertEqual(msg.oneofUint64, 0U); 2089 XCTAssertEqual(msg.oneofSint32, 0); 2090 XCTAssertEqual(msg.oneofSint64, 0); 2091 XCTAssertEqual(msg.oneofFixed32, 0U); 2092 XCTAssertEqual(msg.oneofFixed64, 0U); 2093 XCTAssertEqual(msg.oneofSfixed32, 0); 2094 XCTAssertEqual(msg.oneofSfixed64, 10); 2095 XCTAssertEqual(msg.oneofFloat, 0.0f); 2096 XCTAssertEqual(msg.oneofDouble, 0.0); 2097 XCTAssertEqual(msg.oneofBool, NO); 2098 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2099 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2100 XCTAssertNotNil(msg.oneofMessage); 2101 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2102 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64); 2103 2104 msg.oneofFloat = 11.0f; 2105 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat); 2106 XCTAssertEqual(msg.oneofInt32, 0); 2107 XCTAssertEqual(msg.oneofInt64, 0); 2108 XCTAssertEqual(msg.oneofUint32, 0U); 2109 XCTAssertEqual(msg.oneofUint64, 0U); 2110 XCTAssertEqual(msg.oneofSint32, 0); 2111 XCTAssertEqual(msg.oneofSint64, 0); 2112 XCTAssertEqual(msg.oneofFixed32, 0U); 2113 XCTAssertEqual(msg.oneofFixed64, 0U); 2114 XCTAssertEqual(msg.oneofSfixed32, 0); 2115 XCTAssertEqual(msg.oneofSfixed64, 0); 2116 XCTAssertEqual(msg.oneofFloat, 11.0f); 2117 XCTAssertEqual(msg.oneofDouble, 0.0); 2118 XCTAssertEqual(msg.oneofBool, NO); 2119 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2120 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2121 XCTAssertNotNil(msg.oneofMessage); 2122 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2123 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat); 2124 2125 msg.oneofDouble = 12.0; 2126 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble); 2127 XCTAssertEqual(msg.oneofInt32, 0); 2128 XCTAssertEqual(msg.oneofInt64, 0); 2129 XCTAssertEqual(msg.oneofUint32, 0U); 2130 XCTAssertEqual(msg.oneofUint64, 0U); 2131 XCTAssertEqual(msg.oneofSint32, 0); 2132 XCTAssertEqual(msg.oneofSint64, 0); 2133 XCTAssertEqual(msg.oneofFixed32, 0U); 2134 XCTAssertEqual(msg.oneofFixed64, 0U); 2135 XCTAssertEqual(msg.oneofSfixed32, 0); 2136 XCTAssertEqual(msg.oneofSfixed64, 0); 2137 XCTAssertEqual(msg.oneofFloat, 0.0f); 2138 XCTAssertEqual(msg.oneofDouble, 12.0); 2139 XCTAssertEqual(msg.oneofBool, NO); 2140 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2141 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2142 XCTAssertNotNil(msg.oneofMessage); 2143 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2144 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble); 2145 2146 msg.oneofBool = YES; 2147 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool); 2148 XCTAssertEqual(msg.oneofInt32, 0); 2149 XCTAssertEqual(msg.oneofInt64, 0); 2150 XCTAssertEqual(msg.oneofUint32, 0U); 2151 XCTAssertEqual(msg.oneofUint64, 0U); 2152 XCTAssertEqual(msg.oneofSint32, 0); 2153 XCTAssertEqual(msg.oneofSint64, 0); 2154 XCTAssertEqual(msg.oneofFixed32, 0U); 2155 XCTAssertEqual(msg.oneofFixed64, 0U); 2156 XCTAssertEqual(msg.oneofSfixed32, 0); 2157 XCTAssertEqual(msg.oneofSfixed64, 0); 2158 XCTAssertEqual(msg.oneofFloat, 0.0f); 2159 XCTAssertEqual(msg.oneofDouble, 0.0); 2160 XCTAssertEqual(msg.oneofBool, YES); 2161 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2162 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2163 XCTAssertNotNil(msg.oneofMessage); 2164 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2165 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool); 2166 2167 msg.oneofString = @"foo"; 2168 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString); 2169 XCTAssertEqual(msg.oneofInt32, 0); 2170 XCTAssertEqual(msg.oneofInt64, 0); 2171 XCTAssertEqual(msg.oneofUint32, 0U); 2172 XCTAssertEqual(msg.oneofUint64, 0U); 2173 XCTAssertEqual(msg.oneofSint32, 0); 2174 XCTAssertEqual(msg.oneofSint64, 0); 2175 XCTAssertEqual(msg.oneofFixed32, 0U); 2176 XCTAssertEqual(msg.oneofFixed64, 0U); 2177 XCTAssertEqual(msg.oneofSfixed32, 0); 2178 XCTAssertEqual(msg.oneofSfixed64, 0); 2179 XCTAssertEqual(msg.oneofFloat, 0.0f); 2180 XCTAssertEqual(msg.oneofDouble, 0.0); 2181 XCTAssertEqual(msg.oneofBool, NO); 2182 XCTAssertEqualObjects(msg.oneofString, @"foo"); 2183 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2184 XCTAssertNotNil(msg.oneofMessage); 2185 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2186 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString); 2187 2188 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; 2189 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes); 2190 XCTAssertEqual(msg.oneofInt32, 0); 2191 XCTAssertEqual(msg.oneofInt64, 0); 2192 XCTAssertEqual(msg.oneofUint32, 0U); 2193 XCTAssertEqual(msg.oneofUint64, 0U); 2194 XCTAssertEqual(msg.oneofSint32, 0); 2195 XCTAssertEqual(msg.oneofSint64, 0); 2196 XCTAssertEqual(msg.oneofFixed32, 0U); 2197 XCTAssertEqual(msg.oneofFixed64, 0U); 2198 XCTAssertEqual(msg.oneofSfixed32, 0); 2199 XCTAssertEqual(msg.oneofSfixed64, 0); 2200 XCTAssertEqual(msg.oneofFloat, 0.0f); 2201 XCTAssertEqual(msg.oneofDouble, 0.0); 2202 XCTAssertEqual(msg.oneofBool, NO); 2203 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2204 XCTAssertEqualObjects(msg.oneofBytes, 2205 [@"bar" dataUsingEncoding:NSUTF8StringEncoding]); 2206 XCTAssertNotNil(msg.oneofMessage); 2207 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2208 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes); 2209 2210 Message3 *subMessage = [Message3 message]; 2211 msg.oneofMessage = subMessage; 2212 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage); 2213 XCTAssertEqual(msg.oneofInt32, 0); 2214 XCTAssertEqual(msg.oneofInt64, 0); 2215 XCTAssertEqual(msg.oneofUint32, 0U); 2216 XCTAssertEqual(msg.oneofUint64, 0U); 2217 XCTAssertEqual(msg.oneofSint32, 0); 2218 XCTAssertEqual(msg.oneofSint64, 0); 2219 XCTAssertEqual(msg.oneofFixed32, 0U); 2220 XCTAssertEqual(msg.oneofFixed64, 0U); 2221 XCTAssertEqual(msg.oneofSfixed32, 0); 2222 XCTAssertEqual(msg.oneofSfixed64, 0); 2223 XCTAssertEqual(msg.oneofFloat, 0.0f); 2224 XCTAssertEqual(msg.oneofDouble, 0.0); 2225 XCTAssertEqual(msg.oneofBool, NO); 2226 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2227 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2228 XCTAssertEqual(msg.oneofMessage, subMessage); // Pointer compare. 2229 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo); 2230 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage); 2231 2232 msg.oneofEnum = Message3_Enum_Bar; 2233 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum); 2234 XCTAssertEqual(msg.oneofInt32, 0); 2235 XCTAssertEqual(msg.oneofInt64, 0); 2236 XCTAssertEqual(msg.oneofUint32, 0U); 2237 XCTAssertEqual(msg.oneofUint64, 0U); 2238 XCTAssertEqual(msg.oneofSint32, 0); 2239 XCTAssertEqual(msg.oneofSint64, 0); 2240 XCTAssertEqual(msg.oneofFixed32, 0U); 2241 XCTAssertEqual(msg.oneofFixed64, 0U); 2242 XCTAssertEqual(msg.oneofSfixed32, 0); 2243 XCTAssertEqual(msg.oneofSfixed64, 0); 2244 XCTAssertEqual(msg.oneofFloat, 0.0f); 2245 XCTAssertEqual(msg.oneofDouble, 0.0); 2246 XCTAssertEqual(msg.oneofBool, NO); 2247 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2248 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2249 XCTAssertNotNil(msg.oneofMessage); 2250 XCTAssertNotEqual(msg.oneofMessage, subMessage); // Pointer compare. 2251 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Bar); 2252 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum); 2253 2254 // Test setting/calling clear clearing. 2255 2256 [msg release]; 2257 msg = [[Message3 alloc] init]; 2258 2259 int32_t values[] = { 2260 Message3_O_OneOfCase_OneofInt32, 2261 Message3_O_OneOfCase_OneofInt64, 2262 Message3_O_OneOfCase_OneofUint32, 2263 Message3_O_OneOfCase_OneofUint64, 2264 Message3_O_OneOfCase_OneofSint32, 2265 Message3_O_OneOfCase_OneofSint64, 2266 Message3_O_OneOfCase_OneofFixed32, 2267 Message3_O_OneOfCase_OneofFixed64, 2268 Message3_O_OneOfCase_OneofSfixed32, 2269 Message3_O_OneOfCase_OneofSfixed64, 2270 Message3_O_OneOfCase_OneofFloat, 2271 Message3_O_OneOfCase_OneofDouble, 2272 Message3_O_OneOfCase_OneofBool, 2273 Message3_O_OneOfCase_OneofString, 2274 Message3_O_OneOfCase_OneofBytes, 2275 Message3_O_OneOfCase_OneofMessage, 2276 Message3_O_OneOfCase_OneofEnum, 2277 }; 2278 2279 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) { 2280 switch (values[i]) { 2281 case Message3_O_OneOfCase_OneofInt32: 2282 msg.oneofInt32 = 1; 2283 break; 2284 case Message3_O_OneOfCase_OneofInt64: 2285 msg.oneofInt64 = 2; 2286 break; 2287 case Message3_O_OneOfCase_OneofUint32: 2288 msg.oneofUint32 = 3; 2289 break; 2290 case Message3_O_OneOfCase_OneofUint64: 2291 msg.oneofUint64 = 4; 2292 break; 2293 case Message3_O_OneOfCase_OneofSint32: 2294 msg.oneofSint32 = 5; 2295 break; 2296 case Message3_O_OneOfCase_OneofSint64: 2297 msg.oneofSint64 = 6; 2298 break; 2299 case Message3_O_OneOfCase_OneofFixed32: 2300 msg.oneofFixed32 = 7; 2301 break; 2302 case Message3_O_OneOfCase_OneofFixed64: 2303 msg.oneofFixed64 = 8; 2304 break; 2305 case Message3_O_OneOfCase_OneofSfixed32: 2306 msg.oneofSfixed32 = 9; 2307 break; 2308 case Message3_O_OneOfCase_OneofSfixed64: 2309 msg.oneofSfixed64 = 10; 2310 break; 2311 case Message3_O_OneOfCase_OneofFloat: 2312 msg.oneofFloat = 11.0f; 2313 break; 2314 case Message3_O_OneOfCase_OneofDouble: 2315 msg.oneofDouble = 12.0; 2316 break; 2317 case Message3_O_OneOfCase_OneofBool: 2318 msg.oneofBool = YES; 2319 break; 2320 case Message3_O_OneOfCase_OneofString: 2321 msg.oneofString = @"foo"; 2322 break; 2323 case Message3_O_OneOfCase_OneofBytes: 2324 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; 2325 break; 2326 case Message3_O_OneOfCase_OneofMessage: 2327 msg.oneofMessage = subMessage; 2328 break; 2329 case Message3_O_OneOfCase_OneofEnum: 2330 msg.oneofEnum = Message3_Enum_Baz; 2331 break; 2332 default: 2333 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]); 2334 break; 2335 } 2336 2337 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i); 2338 // No need to check the value was set, the above tests did that. 2339 Message3_ClearOOneOfCase(msg); 2340 // Nothing in the case. 2341 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase, 2342 "Loop: %zd", i); 2343 // Confirm everything is back to defaults after a clear. 2344 XCTAssertEqual(msg.oneofInt32, 0, "Loop: %zd", i); 2345 XCTAssertEqual(msg.oneofInt64, 0, "Loop: %zd", i); 2346 XCTAssertEqual(msg.oneofUint32, 0U, "Loop: %zd", i); 2347 XCTAssertEqual(msg.oneofUint64, 0U, "Loop: %zd", i); 2348 XCTAssertEqual(msg.oneofSint32, 0, "Loop: %zd", i); 2349 XCTAssertEqual(msg.oneofSint64, 0, "Loop: %zd", i); 2350 XCTAssertEqual(msg.oneofFixed32, 0U, "Loop: %zd", i); 2351 XCTAssertEqual(msg.oneofFixed64, 0U, "Loop: %zd", i); 2352 XCTAssertEqual(msg.oneofSfixed32, 0, "Loop: %zd", i); 2353 XCTAssertEqual(msg.oneofSfixed64, 0, "Loop: %zd", i); 2354 XCTAssertEqual(msg.oneofFloat, 0.0f, "Loop: %zd", i); 2355 XCTAssertEqual(msg.oneofDouble, 0.0, "Loop: %zd", i); 2356 XCTAssertEqual(msg.oneofBool, NO, "Loop: %zd", i); 2357 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i); 2358 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i); 2359 XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i); 2360 XCTAssertNotEqual(msg.oneofMessage, subMessage, "Loop: %zd", 2361 i); // Pointer compare. 2362 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo, "Loop: %zd", i); 2363 } 2364 2365 [msg release]; 2366} 2367 2368- (void)testProto2OneofSetToDefault { 2369 2370 // proto3 doesn't normally write out zero (default) fields, but if they are 2371 // in a oneof it does. proto2 doesn't have this special behavior, but we 2372 // still confirm setting to the explicit default does set the case to be 2373 // sure the runtime is working correctly. 2374 2375 NSString *oneofStringDefault = @"string"; 2376 NSData *oneofBytesDefault = [@"data" dataUsingEncoding:NSUTF8StringEncoding]; 2377 2378 Message2 *msg = [[Message2 alloc] init]; 2379 2380 int32_t values[] = { 2381 Message2_O_OneOfCase_OneofInt32, 2382 Message2_O_OneOfCase_OneofInt64, 2383 Message2_O_OneOfCase_OneofUint32, 2384 Message2_O_OneOfCase_OneofUint64, 2385 Message2_O_OneOfCase_OneofSint32, 2386 Message2_O_OneOfCase_OneofSint64, 2387 Message2_O_OneOfCase_OneofFixed32, 2388 Message2_O_OneOfCase_OneofFixed64, 2389 Message2_O_OneOfCase_OneofSfixed32, 2390 Message2_O_OneOfCase_OneofSfixed64, 2391 Message2_O_OneOfCase_OneofFloat, 2392 Message2_O_OneOfCase_OneofDouble, 2393 Message2_O_OneOfCase_OneofBool, 2394 Message2_O_OneOfCase_OneofString, 2395 Message2_O_OneOfCase_OneofBytes, 2396 // Skip group 2397 // Skip message 2398 Message2_O_OneOfCase_OneofEnum, 2399 }; 2400 2401 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) { 2402 switch (values[i]) { 2403 case Message2_O_OneOfCase_OneofInt32: 2404 msg.oneofInt32 = 100; 2405 break; 2406 case Message2_O_OneOfCase_OneofInt64: 2407 msg.oneofInt64 = 101; 2408 break; 2409 case Message2_O_OneOfCase_OneofUint32: 2410 msg.oneofUint32 = 102; 2411 break; 2412 case Message2_O_OneOfCase_OneofUint64: 2413 msg.oneofUint64 = 103; 2414 break; 2415 case Message2_O_OneOfCase_OneofSint32: 2416 msg.oneofSint32 = 104; 2417 break; 2418 case Message2_O_OneOfCase_OneofSint64: 2419 msg.oneofSint64 = 105; 2420 break; 2421 case Message2_O_OneOfCase_OneofFixed32: 2422 msg.oneofFixed32 = 106; 2423 break; 2424 case Message2_O_OneOfCase_OneofFixed64: 2425 msg.oneofFixed64 = 107; 2426 break; 2427 case Message2_O_OneOfCase_OneofSfixed32: 2428 msg.oneofSfixed32 = 108; 2429 break; 2430 case Message2_O_OneOfCase_OneofSfixed64: 2431 msg.oneofSfixed64 = 109; 2432 break; 2433 case Message2_O_OneOfCase_OneofFloat: 2434 msg.oneofFloat = 110.0f; 2435 break; 2436 case Message2_O_OneOfCase_OneofDouble: 2437 msg.oneofDouble = 111.0; 2438 break; 2439 case Message2_O_OneOfCase_OneofBool: 2440 msg.oneofBool = YES; 2441 break; 2442 case Message2_O_OneOfCase_OneofString: 2443 msg.oneofString = oneofStringDefault; 2444 break; 2445 case Message2_O_OneOfCase_OneofBytes: 2446 msg.oneofBytes = oneofBytesDefault; 2447 break; 2448 case Message2_O_OneOfCase_OneofEnum: 2449 msg.oneofEnum = Message3_Enum_Baz; 2450 break; 2451 default: 2452 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]); 2453 break; 2454 } 2455 2456 // Should be set to the correct case. 2457 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i); 2458 2459 // Confirm everything is the defaults. 2460 XCTAssertEqual(msg.oneofInt32, 100, "Loop: %zd", i); 2461 XCTAssertEqual(msg.oneofInt64, 101, "Loop: %zd", i); 2462 XCTAssertEqual(msg.oneofUint32, 102U, "Loop: %zd", i); 2463 XCTAssertEqual(msg.oneofUint64, 103U, "Loop: %zd", i); 2464 XCTAssertEqual(msg.oneofSint32, 104, "Loop: %zd", i); 2465 XCTAssertEqual(msg.oneofSint64, 105, "Loop: %zd", i); 2466 XCTAssertEqual(msg.oneofFixed32, 106U, "Loop: %zd", i); 2467 XCTAssertEqual(msg.oneofFixed64, 107U, "Loop: %zd", i); 2468 XCTAssertEqual(msg.oneofSfixed32, 108, "Loop: %zd", i); 2469 XCTAssertEqual(msg.oneofSfixed64, 109, "Loop: %zd", i); 2470 XCTAssertEqual(msg.oneofFloat, 110.0f, "Loop: %zd", i); 2471 XCTAssertEqual(msg.oneofDouble, 111.0, "Loop: %zd", i); 2472 XCTAssertEqual(msg.oneofBool, YES, "Loop: %zd", i); 2473 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i); 2474 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i); 2475 // Skip group, no default to consider. 2476 // Skip message, no default to consider. 2477 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz, "Loop: %zd", i); 2478 } 2479 2480 // We special case nil on string, data, group, and message, ensure they work 2481 // as expected. i.e. - it clears the case. 2482 msg.oneofString = nil; 2483 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2484 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase); 2485 msg.oneofBytes = nil; 2486 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase); 2487 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2488 msg.oneofGroup = nil; 2489 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase); 2490 XCTAssertNotNil(msg.oneofGroup); 2491 msg.oneofMessage = nil; 2492 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase); 2493 XCTAssertNotNil(msg.oneofMessage); 2494 2495 [msg release]; 2496} 2497 2498- (void)testProto3OneofSetToZero { 2499 2500 // Normally setting a proto3 field to the zero value should result in it being 2501 // reset/cleared. But in a oneof, it still gets recorded so it can go out 2502 // over the wire and the other side can see what was set in the oneof. 2503 2504 NSString *oneofStringDefault = @""; 2505 NSData *oneofBytesDefault = [NSData data]; 2506 2507 Message3 *msg = [[Message3 alloc] init]; 2508 2509 int32_t values[] = { 2510 Message3_O_OneOfCase_OneofInt32, 2511 Message3_O_OneOfCase_OneofInt64, 2512 Message3_O_OneOfCase_OneofUint32, 2513 Message3_O_OneOfCase_OneofUint64, 2514 Message3_O_OneOfCase_OneofSint32, 2515 Message3_O_OneOfCase_OneofSint64, 2516 Message3_O_OneOfCase_OneofFixed32, 2517 Message3_O_OneOfCase_OneofFixed64, 2518 Message3_O_OneOfCase_OneofSfixed32, 2519 Message3_O_OneOfCase_OneofSfixed64, 2520 Message3_O_OneOfCase_OneofFloat, 2521 Message3_O_OneOfCase_OneofDouble, 2522 Message3_O_OneOfCase_OneofBool, 2523 Message3_O_OneOfCase_OneofString, 2524 Message3_O_OneOfCase_OneofBytes, 2525 Message3_O_OneOfCase_OneofMessage, 2526 Message3_O_OneOfCase_OneofEnum, 2527 }; 2528 2529 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) { 2530 switch (values[i]) { 2531 case Message3_O_OneOfCase_OneofInt32: 2532 msg.oneofInt32 = 0; 2533 break; 2534 case Message3_O_OneOfCase_OneofInt64: 2535 msg.oneofInt64 = 0; 2536 break; 2537 case Message3_O_OneOfCase_OneofUint32: 2538 msg.oneofUint32 = 0; 2539 break; 2540 case Message3_O_OneOfCase_OneofUint64: 2541 msg.oneofUint64 = 0; 2542 break; 2543 case Message3_O_OneOfCase_OneofSint32: 2544 msg.oneofSint32 = 0; 2545 break; 2546 case Message3_O_OneOfCase_OneofSint64: 2547 msg.oneofSint64 = 0; 2548 break; 2549 case Message3_O_OneOfCase_OneofFixed32: 2550 msg.oneofFixed32 = 0; 2551 break; 2552 case Message3_O_OneOfCase_OneofFixed64: 2553 msg.oneofFixed64 = 0; 2554 break; 2555 case Message3_O_OneOfCase_OneofSfixed32: 2556 msg.oneofSfixed32 = 0; 2557 break; 2558 case Message3_O_OneOfCase_OneofSfixed64: 2559 msg.oneofSfixed64 = 0; 2560 break; 2561 case Message3_O_OneOfCase_OneofFloat: 2562 msg.oneofFloat = 0.0f; 2563 break; 2564 case Message3_O_OneOfCase_OneofDouble: 2565 msg.oneofDouble = 0.0; 2566 break; 2567 case Message3_O_OneOfCase_OneofBool: 2568 msg.oneofBool = NO; 2569 break; 2570 case Message3_O_OneOfCase_OneofString: 2571 msg.oneofString = oneofStringDefault; 2572 break; 2573 case Message3_O_OneOfCase_OneofBytes: 2574 msg.oneofBytes = oneofBytesDefault; 2575 break; 2576 case Message3_O_OneOfCase_OneofMessage: 2577 msg.oneofMessage.optionalInt32 = 0; 2578 break; 2579 case Message3_O_OneOfCase_OneofEnum: 2580 msg.oneofEnum = Message3_Enum_Foo; 2581 break; 2582 default: 2583 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]); 2584 break; 2585 } 2586 2587 // Should be set to the correct case. 2588 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i); 2589 2590 // Confirm everything is still zeros. 2591 XCTAssertEqual(msg.oneofInt32, 0, "Loop: %zd", i); 2592 XCTAssertEqual(msg.oneofInt64, 0, "Loop: %zd", i); 2593 XCTAssertEqual(msg.oneofUint32, 0U, "Loop: %zd", i); 2594 XCTAssertEqual(msg.oneofUint64, 0U, "Loop: %zd", i); 2595 XCTAssertEqual(msg.oneofSint32, 0, "Loop: %zd", i); 2596 XCTAssertEqual(msg.oneofSint64, 0, "Loop: %zd", i); 2597 XCTAssertEqual(msg.oneofFixed32, 0U, "Loop: %zd", i); 2598 XCTAssertEqual(msg.oneofFixed64, 0U, "Loop: %zd", i); 2599 XCTAssertEqual(msg.oneofSfixed32, 0, "Loop: %zd", i); 2600 XCTAssertEqual(msg.oneofSfixed64, 0, "Loop: %zd", i); 2601 XCTAssertEqual(msg.oneofFloat, 0.0f, "Loop: %zd", i); 2602 XCTAssertEqual(msg.oneofDouble, 0.0, "Loop: %zd", i); 2603 XCTAssertEqual(msg.oneofBool, NO, "Loop: %zd", i); 2604 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i); 2605 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i); 2606 XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i); 2607 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo, "Loop: %zd", i); 2608 } 2609 2610 // We special case nil on string, data, message, ensure they work as expected. 2611 msg.oneofString = nil; 2612 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase); 2613 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault); 2614 msg.oneofBytes = nil; 2615 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase); 2616 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault); 2617 msg.oneofMessage = nil; 2618 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase); 2619 XCTAssertNotNil(msg.oneofMessage); 2620 2621 [msg release]; 2622} 2623 2624- (void)testCopyingMakesUniqueObjects { 2625 const int repeatCount = 5; 2626 TestAllTypes *msg1 = [TestAllTypes message]; 2627 [self setAllFields:msg1 repeatedCount:repeatCount]; 2628 2629 TestAllTypes *msg2 = [[msg1 copy] autorelease]; 2630 2631 XCTAssertNotEqual(msg1, msg2); // Ptr compare, new object. 2632 XCTAssertEqualObjects(msg1, msg2); // Equal values. 2633 2634 // Pointer comparisons, different objects. 2635 2636 XCTAssertNotEqual(msg1.optionalGroup, msg2.optionalGroup); 2637 XCTAssertNotEqual(msg1.optionalNestedMessage, msg2.optionalNestedMessage); 2638 XCTAssertNotEqual(msg1.optionalForeignMessage, msg2.optionalForeignMessage); 2639 XCTAssertNotEqual(msg1.optionalImportMessage, msg2.optionalImportMessage); 2640 2641 XCTAssertNotEqual(msg1.repeatedInt32Array, msg2.repeatedInt32Array); 2642 XCTAssertNotEqual(msg1.repeatedInt64Array, msg2.repeatedInt64Array); 2643 XCTAssertNotEqual(msg1.repeatedUint32Array, msg2.repeatedUint32Array); 2644 XCTAssertNotEqual(msg1.repeatedUint64Array, msg2.repeatedUint64Array); 2645 XCTAssertNotEqual(msg1.repeatedSint32Array, msg2.repeatedSint32Array); 2646 XCTAssertNotEqual(msg1.repeatedSint64Array, msg2.repeatedSint64Array); 2647 XCTAssertNotEqual(msg1.repeatedFixed32Array, msg2.repeatedFixed32Array); 2648 XCTAssertNotEqual(msg1.repeatedFixed64Array, msg2.repeatedFixed64Array); 2649 XCTAssertNotEqual(msg1.repeatedSfixed32Array, msg2.repeatedSfixed32Array); 2650 XCTAssertNotEqual(msg1.repeatedSfixed64Array, msg2.repeatedSfixed64Array); 2651 XCTAssertNotEqual(msg1.repeatedFloatArray, msg2.repeatedFloatArray); 2652 XCTAssertNotEqual(msg1.repeatedDoubleArray, msg2.repeatedDoubleArray); 2653 XCTAssertNotEqual(msg1.repeatedBoolArray, msg2.repeatedBoolArray); 2654 XCTAssertNotEqual(msg1.repeatedStringArray, msg2.repeatedStringArray); 2655 XCTAssertNotEqual(msg1.repeatedBytesArray, msg2.repeatedBytesArray); 2656 XCTAssertNotEqual(msg1.repeatedGroupArray, msg2.repeatedGroupArray); 2657 XCTAssertNotEqual(msg1.repeatedNestedMessageArray, 2658 msg2.repeatedNestedMessageArray); 2659 XCTAssertNotEqual(msg1.repeatedForeignMessageArray, 2660 msg2.repeatedForeignMessageArray); 2661 XCTAssertNotEqual(msg1.repeatedImportMessageArray, 2662 msg2.repeatedImportMessageArray); 2663 XCTAssertNotEqual(msg1.repeatedNestedEnumArray, msg2.repeatedNestedEnumArray); 2664 XCTAssertNotEqual(msg1.repeatedForeignEnumArray, 2665 msg2.repeatedForeignEnumArray); 2666 XCTAssertNotEqual(msg1.repeatedImportEnumArray, msg2.repeatedImportEnumArray); 2667 XCTAssertNotEqual(msg1.repeatedStringPieceArray, 2668 msg2.repeatedStringPieceArray); 2669 XCTAssertNotEqual(msg1.repeatedCordArray, msg2.repeatedCordArray); 2670 2671 for (int i = 0; i < repeatCount; i++) { 2672 XCTAssertNotEqual(msg1.repeatedNestedMessageArray[i], 2673 msg2.repeatedNestedMessageArray[i]); 2674 XCTAssertNotEqual(msg1.repeatedForeignMessageArray[i], 2675 msg2.repeatedForeignMessageArray[i]); 2676 XCTAssertNotEqual(msg1.repeatedImportMessageArray[i], 2677 msg2.repeatedImportMessageArray[i]); 2678 } 2679} 2680 2681- (void)testCopyingMapsMakesUniqueObjects { 2682 TestMap *msg1 = [TestMap message]; 2683 [self setAllMapFields:msg1 numEntries:5]; 2684 2685 TestMap *msg2 = [[msg1 copy] autorelease]; 2686 2687 XCTAssertNotEqual(msg1, msg2); // Ptr compare, new object. 2688 XCTAssertEqualObjects(msg1, msg2); // Equal values. 2689 2690 // Pointer comparisons, different objects. 2691 XCTAssertNotEqual(msg1.mapInt32Int32, msg2.mapInt32Int32); 2692 XCTAssertNotEqual(msg1.mapInt64Int64, msg2.mapInt64Int64); 2693 XCTAssertNotEqual(msg1.mapUint32Uint32, msg2.mapUint32Uint32); 2694 XCTAssertNotEqual(msg1.mapUint64Uint64, msg2.mapUint64Uint64); 2695 XCTAssertNotEqual(msg1.mapSint32Sint32, msg2.mapSint32Sint32); 2696 XCTAssertNotEqual(msg1.mapSint64Sint64, msg2.mapSint64Sint64); 2697 XCTAssertNotEqual(msg1.mapFixed32Fixed32, msg2.mapFixed32Fixed32); 2698 XCTAssertNotEqual(msg1.mapFixed64Fixed64, msg2.mapFixed64Fixed64); 2699 XCTAssertNotEqual(msg1.mapSfixed32Sfixed32, msg2.mapSfixed32Sfixed32); 2700 XCTAssertNotEqual(msg1.mapSfixed64Sfixed64, msg2.mapSfixed64Sfixed64); 2701 XCTAssertNotEqual(msg1.mapInt32Float, msg2.mapInt32Float); 2702 XCTAssertNotEqual(msg1.mapInt32Double, msg2.mapInt32Double); 2703 XCTAssertNotEqual(msg1.mapBoolBool, msg2.mapBoolBool); 2704 XCTAssertNotEqual(msg1.mapStringString, msg2.mapStringString); 2705 XCTAssertNotEqual(msg1.mapInt32Bytes, msg2.mapInt32Bytes); 2706 XCTAssertNotEqual(msg1.mapInt32Enum, msg2.mapInt32Enum); 2707 XCTAssertNotEqual(msg1.mapInt32ForeignMessage, msg2.mapInt32ForeignMessage); 2708 2709 // Ensure the messages are unique per map. 2710 [msg1.mapInt32ForeignMessage 2711 enumerateKeysAndObjectsUsingBlock:^(int32_t key, id value, BOOL *stop) { 2712#pragma unused(stop) 2713 ForeignMessage *subMsg2 = [msg2.mapInt32ForeignMessage objectForKey:key]; 2714 XCTAssertNotEqual(value, subMsg2); // Ptr compare, new object. 2715 }]; 2716} 2717 2718- (void)test_GPBGetMessageRepeatedField { 2719 TestAllTypes *message = [TestAllTypes message]; 2720 GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"repeatedStringArray"]; 2721 XCTAssertNotNil(fieldDescriptor); 2722 NSMutableArray *fieldArray = GPBGetMessageRepeatedField(message, fieldDescriptor); 2723 XCTAssertNotNil(fieldArray); // Should have autocreated. 2724 XCTAssertTrue(fieldArray == message.repeatedStringArray); // Same pointer 2725} 2726 2727- (void)test_GPBSetMessageRepeatedField { 2728 TestAllTypes *message = [TestAllTypes message]; 2729 GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"repeatedStringArray"]; 2730 XCTAssertNotNil(fieldDescriptor); 2731 2732 NSMutableArray *fieldArray = [NSMutableArray arrayWithObject:@"foo"]; 2733 GPBSetMessageRepeatedField(message, fieldDescriptor, fieldArray); 2734 XCTAssertTrue(fieldArray == message.repeatedStringArray); // Same pointer 2735 XCTAssertEqualObjects(@"foo", message.repeatedStringArray.firstObject); 2736} 2737 2738- (void)test_GPBGetMessageMapField { 2739 TestMap *message = [TestMap message]; 2740 GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"mapStringString"]; 2741 XCTAssertNotNil(fieldDescriptor); 2742 NSMutableDictionary *fieldMap = GPBGetMessageMapField(message, fieldDescriptor); 2743 XCTAssertNotNil(fieldMap); // Should have autocreated. 2744 XCTAssertTrue(fieldMap == message.mapStringString); // Same pointer 2745} 2746 2747- (void)test_GPBSetMessageMapField { 2748 TestMap *message = [TestMap message]; 2749 GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"mapStringString"]; 2750 XCTAssertNotNil(fieldDescriptor); 2751 2752 NSMutableDictionary *fieldMap = [NSMutableDictionary dictionaryWithObject:@"bar" forKey:@"foo"]; 2753 GPBSetMessageMapField(message, fieldDescriptor, fieldMap); 2754 XCTAssertTrue(fieldMap == message.mapStringString); // Same pointer 2755 XCTAssertEqualObjects(@"bar", message.mapStringString[@"foo"]); 2756} 2757 2758- (void)test_StringFieldsCopy { 2759 // ObjC conventions call for NSString properties to be copy, ensure 2760 // that is done correctly and the string isn't simply retained. 2761 2762 Message2 *msg1 = [Message2 message]; 2763 Message2 *msg2 = [Message2 message]; 2764 2765 GPBFieldDescriptor *fieldDesc = 2766 [[Message2 descriptor] fieldWithNumber:Message2_FieldNumber_OptionalString]; 2767 NSMutableString *mutableStr = [NSMutableString stringWithString:@"foo"]; 2768 2769 msg1.optionalString = mutableStr; 2770 GPBSetMessageStringField(msg2, fieldDesc, mutableStr); 2771 2772 XCTAssertEqualObjects(msg1.optionalString, mutableStr); 2773 XCTAssertEqualObjects(msg1.optionalString, @"foo"); 2774 XCTAssertTrue(msg1.optionalString != mutableStr); // Ptr comparison. 2775 2776 XCTAssertEqualObjects(msg2.optionalString, mutableStr); 2777 XCTAssertEqualObjects(msg2.optionalString, @"foo"); 2778 XCTAssertTrue(msg2.optionalString != mutableStr); // Ptr comparison. 2779 2780 [mutableStr appendString:@"bar"]; 2781 2782 XCTAssertNotEqualObjects(msg1.optionalString, mutableStr); 2783 XCTAssertEqualObjects(msg1.optionalString, @"foo"); 2784 XCTAssertTrue(msg1.optionalString != mutableStr); // Ptr comparison. 2785 2786 XCTAssertNotEqualObjects(msg2.optionalString, mutableStr); 2787 XCTAssertEqualObjects(msg2.optionalString, @"foo"); 2788 XCTAssertTrue(msg2.optionalString != mutableStr); // Ptr comparison. 2789} 2790 2791- (void)test_BytesFieldsCopy { 2792 // ObjC conventions call for NSData properties to be copy, ensure 2793 // that is done correctly and the data isn't simply retained. 2794 2795 Message2 *msg1 = [Message2 message]; 2796 Message2 *msg2 = [Message2 message]; 2797 2798 GPBFieldDescriptor *fieldDesc = 2799 [[Message2 descriptor] fieldWithNumber:Message2_FieldNumber_OptionalBytes]; 2800 NSMutableData *mutableData = [NSMutableData dataWithData:DataFromCStr("abc")]; 2801 2802 msg1.optionalBytes = mutableData; 2803 GPBSetMessageBytesField(msg2, fieldDesc, mutableData); 2804 2805 XCTAssertEqualObjects(msg1.optionalBytes, mutableData); 2806 XCTAssertEqualObjects(msg1.optionalBytes, DataFromCStr("abc")); 2807 XCTAssertTrue(msg1.optionalBytes != mutableData); // Ptr comparison. 2808 2809 XCTAssertEqualObjects(msg2.optionalBytes, mutableData); 2810 XCTAssertEqualObjects(msg2.optionalBytes, DataFromCStr("abc")); 2811 XCTAssertTrue(msg2.optionalBytes != mutableData); // Ptr comparison. 2812 2813 [mutableData appendData:DataFromCStr("123")]; 2814 2815 XCTAssertNotEqualObjects(msg1.optionalBytes, mutableData); 2816 XCTAssertEqualObjects(msg1.optionalBytes, DataFromCStr("abc")); 2817 XCTAssertTrue(msg1.optionalBytes != mutableData); // Ptr comparison. 2818 2819 XCTAssertNotEqualObjects(msg2.optionalBytes, mutableData); 2820 XCTAssertEqualObjects(msg2.optionalBytes, DataFromCStr("abc")); 2821 XCTAssertTrue(msg2.optionalBytes != mutableData); // Ptr comparison. 2822} 2823 2824#pragma mark - Subset from from map_tests.cc 2825 2826// TEST(GeneratedMapFieldTest, IsInitialized) 2827- (void)testMap_IsInitialized { 2828 TestRequiredMessageMap *msg = [[TestRequiredMessageMap alloc] init]; 2829 2830 // Add an uninitialized message. 2831 TestRequired *subMsg = [[TestRequired alloc] init]; 2832 [msg.mapField setObject:subMsg forKey:0]; 2833 XCTAssertFalse(msg.initialized); 2834 2835 // Initialize uninitialized message 2836 subMsg.a = 0; 2837 subMsg.b = 0; 2838 subMsg.c = 0; 2839 XCTAssertTrue(msg.initialized); 2840 2841 [subMsg release]; 2842 [msg release]; 2843} 2844 2845@end 2846