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