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/MapProto2Unittest.pbobjc.h" 13#import "objectivec/Tests/MapUnittest.pbobjc.h" 14#import "objectivec/Tests/Unittest.pbobjc.h" 15#import "objectivec/Tests/UnittestPreserveUnknownEnum.pbobjc.h" 16#import "objectivec/Tests/UnittestRuntimeProto2.pbobjc.h" 17#import "objectivec/Tests/UnittestRuntimeProto3.pbobjc.h" 18 19@interface MessageSerializationTests : GPBTestCase 20@end 21 22@implementation MessageSerializationTests 23 24// TODO: Pull tests over from GPBMessageTests that are serialization 25// specific. 26 27- (void)testProto3SerializationHandlingDefaults { 28 // Proto2 covered in other tests. 29 30 Message3 *msg = [[Message3 alloc] init]; 31 32 // Add defaults, no output. 33 34 NSData *data = [msg data]; 35 XCTAssertEqual([data length], 0U); 36 37 // All zeros, still nothing. 38 39 msg.optionalInt32 = 0; 40 msg.optionalInt64 = 0; 41 msg.optionalUint32 = 0; 42 msg.optionalUint64 = 0; 43 msg.optionalSint32 = 0; 44 msg.optionalSint64 = 0; 45 msg.optionalFixed32 = 0; 46 msg.optionalFixed64 = 0; 47 msg.optionalSfixed32 = 0; 48 msg.optionalSfixed64 = 0; 49 msg.optionalFloat = 0.0f; 50 msg.optionalDouble = 0.0; 51 msg.optionalBool = NO; 52 msg.optionalString = @""; 53 msg.optionalBytes = [NSData data]; 54 msg.optionalEnum = Message3_Enum_Foo; // first value 55 56 data = [msg data]; 57 XCTAssertEqual([data length], 0U); 58 59 // The two that also take nil as nothing. 60 61 msg.optionalString = nil; 62 msg.optionalBytes = nil; 63 64 data = [msg data]; 65 XCTAssertEqual([data length], 0U); 66 67 // Set one field... 68 69 msg.optionalInt32 = 1; 70 71 data = [msg data]; 72 const uint8_t expectedBytes[] = {0x08, 0x01}; 73 NSData *expected = [NSData dataWithBytes:expectedBytes length:2]; 74 XCTAssertEqualObjects(data, expected); 75 76 // Back to zero... 77 78 msg.optionalInt32 = 0; 79 80 data = [msg data]; 81 XCTAssertEqual([data length], 0U); 82 83 [msg release]; 84} 85 86- (void)testProto3SerializationHandlingOptionals { 87 // 88 // Proto3 optionals should be just like proto2, zero values also get serialized. 89 // 90 91 // Disable clang-format for the macros. 92 // clang-format off 93 94//%PDDM-DEFINE PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(FIELD, ZERO_VALUE, EXPECTED_LEN) 95//% { // optional##FIELD 96//% Message3Optional *msg = [[Message3Optional alloc] init]; 97//% NSData *data = [msg data]; 98//% XCTAssertEqual([data length], 0U); 99//% msg.optional##FIELD = ZERO_VALUE; 100//% data = [msg data]; 101//% XCTAssertEqual(data.length, EXPECTED_LEN); 102//% NSError *err = nil; 103//% Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 104//% XCTAssertNotNil(msg2); 105//% XCTAssertNil(err); 106//% XCTAssertTrue(msg2.hasOptional##FIELD); 107//% XCTAssertEqualObjects(msg, msg2); 108//% [msg release]; 109//% } 110//% 111//%PDDM-DEFINE PROTO3_TEST_SERIALIZE_OPTIONAL_FIELDS() 112//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Int32, 0, 2) 113//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Int64, 0, 2) 114//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Uint32, 0, 2) 115//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Uint64, 0, 2) 116//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Sint32, 0, 2) 117//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Sint64, 0, 2) 118//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Fixed32, 0, 5) 119//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Fixed64, 0, 9) 120//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Sfixed32, 0, 5) 121//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Sfixed64, 0, 9) 122//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Float, 0.0f, 5) 123//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Double, 0.0, 9) 124//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Bool, NO, 2) 125//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(String, @"", 2) 126//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Bytes, [NSData data], 2) 127//% // 128//% // Test doesn't apply to optionalMessage (no groups in proto3). 129//% // 130//% 131//%PROTO3_TEST_SERIALIZE_OPTIONAL_FIELD(Enum, Message3Optional_Enum_Foo, 3) 132//%PDDM-EXPAND PROTO3_TEST_SERIALIZE_OPTIONAL_FIELDS() 133// This block of code is generated, do not edit it directly. 134 135 { // optionalInt32 136 Message3Optional *msg = [[Message3Optional alloc] init]; 137 NSData *data = [msg data]; 138 XCTAssertEqual([data length], 0U); 139 msg.optionalInt32 = 0; 140 data = [msg data]; 141 XCTAssertEqual(data.length, 2); 142 NSError *err = nil; 143 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 144 XCTAssertNotNil(msg2); 145 XCTAssertNil(err); 146 XCTAssertTrue(msg2.hasOptionalInt32); 147 XCTAssertEqualObjects(msg, msg2); 148 [msg release]; 149 } 150 151 { // optionalInt64 152 Message3Optional *msg = [[Message3Optional alloc] init]; 153 NSData *data = [msg data]; 154 XCTAssertEqual([data length], 0U); 155 msg.optionalInt64 = 0; 156 data = [msg data]; 157 XCTAssertEqual(data.length, 2); 158 NSError *err = nil; 159 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 160 XCTAssertNotNil(msg2); 161 XCTAssertNil(err); 162 XCTAssertTrue(msg2.hasOptionalInt64); 163 XCTAssertEqualObjects(msg, msg2); 164 [msg release]; 165 } 166 167 { // optionalUint32 168 Message3Optional *msg = [[Message3Optional alloc] init]; 169 NSData *data = [msg data]; 170 XCTAssertEqual([data length], 0U); 171 msg.optionalUint32 = 0; 172 data = [msg data]; 173 XCTAssertEqual(data.length, 2); 174 NSError *err = nil; 175 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 176 XCTAssertNotNil(msg2); 177 XCTAssertNil(err); 178 XCTAssertTrue(msg2.hasOptionalUint32); 179 XCTAssertEqualObjects(msg, msg2); 180 [msg release]; 181 } 182 183 { // optionalUint64 184 Message3Optional *msg = [[Message3Optional alloc] init]; 185 NSData *data = [msg data]; 186 XCTAssertEqual([data length], 0U); 187 msg.optionalUint64 = 0; 188 data = [msg data]; 189 XCTAssertEqual(data.length, 2); 190 NSError *err = nil; 191 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 192 XCTAssertNotNil(msg2); 193 XCTAssertNil(err); 194 XCTAssertTrue(msg2.hasOptionalUint64); 195 XCTAssertEqualObjects(msg, msg2); 196 [msg release]; 197 } 198 199 { // optionalSint32 200 Message3Optional *msg = [[Message3Optional alloc] init]; 201 NSData *data = [msg data]; 202 XCTAssertEqual([data length], 0U); 203 msg.optionalSint32 = 0; 204 data = [msg data]; 205 XCTAssertEqual(data.length, 2); 206 NSError *err = nil; 207 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 208 XCTAssertNotNil(msg2); 209 XCTAssertNil(err); 210 XCTAssertTrue(msg2.hasOptionalSint32); 211 XCTAssertEqualObjects(msg, msg2); 212 [msg release]; 213 } 214 215 { // optionalSint64 216 Message3Optional *msg = [[Message3Optional alloc] init]; 217 NSData *data = [msg data]; 218 XCTAssertEqual([data length], 0U); 219 msg.optionalSint64 = 0; 220 data = [msg data]; 221 XCTAssertEqual(data.length, 2); 222 NSError *err = nil; 223 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 224 XCTAssertNotNil(msg2); 225 XCTAssertNil(err); 226 XCTAssertTrue(msg2.hasOptionalSint64); 227 XCTAssertEqualObjects(msg, msg2); 228 [msg release]; 229 } 230 231 { // optionalFixed32 232 Message3Optional *msg = [[Message3Optional alloc] init]; 233 NSData *data = [msg data]; 234 XCTAssertEqual([data length], 0U); 235 msg.optionalFixed32 = 0; 236 data = [msg data]; 237 XCTAssertEqual(data.length, 5); 238 NSError *err = nil; 239 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 240 XCTAssertNotNil(msg2); 241 XCTAssertNil(err); 242 XCTAssertTrue(msg2.hasOptionalFixed32); 243 XCTAssertEqualObjects(msg, msg2); 244 [msg release]; 245 } 246 247 { // optionalFixed64 248 Message3Optional *msg = [[Message3Optional alloc] init]; 249 NSData *data = [msg data]; 250 XCTAssertEqual([data length], 0U); 251 msg.optionalFixed64 = 0; 252 data = [msg data]; 253 XCTAssertEqual(data.length, 9); 254 NSError *err = nil; 255 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 256 XCTAssertNotNil(msg2); 257 XCTAssertNil(err); 258 XCTAssertTrue(msg2.hasOptionalFixed64); 259 XCTAssertEqualObjects(msg, msg2); 260 [msg release]; 261 } 262 263 { // optionalSfixed32 264 Message3Optional *msg = [[Message3Optional alloc] init]; 265 NSData *data = [msg data]; 266 XCTAssertEqual([data length], 0U); 267 msg.optionalSfixed32 = 0; 268 data = [msg data]; 269 XCTAssertEqual(data.length, 5); 270 NSError *err = nil; 271 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 272 XCTAssertNotNil(msg2); 273 XCTAssertNil(err); 274 XCTAssertTrue(msg2.hasOptionalSfixed32); 275 XCTAssertEqualObjects(msg, msg2); 276 [msg release]; 277 } 278 279 { // optionalSfixed64 280 Message3Optional *msg = [[Message3Optional alloc] init]; 281 NSData *data = [msg data]; 282 XCTAssertEqual([data length], 0U); 283 msg.optionalSfixed64 = 0; 284 data = [msg data]; 285 XCTAssertEqual(data.length, 9); 286 NSError *err = nil; 287 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 288 XCTAssertNotNil(msg2); 289 XCTAssertNil(err); 290 XCTAssertTrue(msg2.hasOptionalSfixed64); 291 XCTAssertEqualObjects(msg, msg2); 292 [msg release]; 293 } 294 295 { // optionalFloat 296 Message3Optional *msg = [[Message3Optional alloc] init]; 297 NSData *data = [msg data]; 298 XCTAssertEqual([data length], 0U); 299 msg.optionalFloat = 0.0f; 300 data = [msg data]; 301 XCTAssertEqual(data.length, 5); 302 NSError *err = nil; 303 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 304 XCTAssertNotNil(msg2); 305 XCTAssertNil(err); 306 XCTAssertTrue(msg2.hasOptionalFloat); 307 XCTAssertEqualObjects(msg, msg2); 308 [msg release]; 309 } 310 311 { // optionalDouble 312 Message3Optional *msg = [[Message3Optional alloc] init]; 313 NSData *data = [msg data]; 314 XCTAssertEqual([data length], 0U); 315 msg.optionalDouble = 0.0; 316 data = [msg data]; 317 XCTAssertEqual(data.length, 9); 318 NSError *err = nil; 319 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 320 XCTAssertNotNil(msg2); 321 XCTAssertNil(err); 322 XCTAssertTrue(msg2.hasOptionalDouble); 323 XCTAssertEqualObjects(msg, msg2); 324 [msg release]; 325 } 326 327 { // optionalBool 328 Message3Optional *msg = [[Message3Optional alloc] init]; 329 NSData *data = [msg data]; 330 XCTAssertEqual([data length], 0U); 331 msg.optionalBool = NO; 332 data = [msg data]; 333 XCTAssertEqual(data.length, 2); 334 NSError *err = nil; 335 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 336 XCTAssertNotNil(msg2); 337 XCTAssertNil(err); 338 XCTAssertTrue(msg2.hasOptionalBool); 339 XCTAssertEqualObjects(msg, msg2); 340 [msg release]; 341 } 342 343 { // optionalString 344 Message3Optional *msg = [[Message3Optional alloc] init]; 345 NSData *data = [msg data]; 346 XCTAssertEqual([data length], 0U); 347 msg.optionalString = @""; 348 data = [msg data]; 349 XCTAssertEqual(data.length, 2); 350 NSError *err = nil; 351 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 352 XCTAssertNotNil(msg2); 353 XCTAssertNil(err); 354 XCTAssertTrue(msg2.hasOptionalString); 355 XCTAssertEqualObjects(msg, msg2); 356 [msg release]; 357 } 358 359 { // optionalBytes 360 Message3Optional *msg = [[Message3Optional alloc] init]; 361 NSData *data = [msg data]; 362 XCTAssertEqual([data length], 0U); 363 msg.optionalBytes = [NSData data]; 364 data = [msg data]; 365 XCTAssertEqual(data.length, 2); 366 NSError *err = nil; 367 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 368 XCTAssertNotNil(msg2); 369 XCTAssertNil(err); 370 XCTAssertTrue(msg2.hasOptionalBytes); 371 XCTAssertEqualObjects(msg, msg2); 372 [msg release]; 373 } 374 375 // 376 // Test doesn't apply to optionalMessage (no groups in proto3). 377 // 378 379 { // optionalEnum 380 Message3Optional *msg = [[Message3Optional alloc] init]; 381 NSData *data = [msg data]; 382 XCTAssertEqual([data length], 0U); 383 msg.optionalEnum = Message3Optional_Enum_Foo; 384 data = [msg data]; 385 XCTAssertEqual(data.length, 3); 386 NSError *err = nil; 387 Message3Optional *msg2 = [Message3Optional parseFromData:data error:&err]; 388 XCTAssertNotNil(msg2); 389 XCTAssertNil(err); 390 XCTAssertTrue(msg2.hasOptionalEnum); 391 XCTAssertEqualObjects(msg, msg2); 392 [msg release]; 393 } 394 395//%PDDM-EXPAND-END PROTO3_TEST_SERIALIZE_OPTIONAL_FIELDS() 396 397 // clang-format on 398} 399 400- (void)testProto2UnknownEnumToUnknownField { 401 Message3 *orig = [[Message3 alloc] init]; 402 403 orig.optionalEnum = Message3_Enum_Extra3; 404 orig.repeatedEnumArray = [GPBEnumArray arrayWithValidationFunction:Message3_Enum_IsValidValue 405 rawValue:Message3_Enum_Extra3]; 406 orig.oneofEnum = Message3_Enum_Extra3; 407 408 NSData *data = [orig data]; 409 XCTAssertNotNil(data); 410 Message2 *msg = [[Message2 alloc] initWithData:data error:NULL]; 411 412 // None of the fields should be set. 413 414 XCTAssertFalse(msg.hasOptionalEnum); 415 XCTAssertEqual(msg.repeatedEnumArray.count, 0U); 416 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase); 417 418 // All the values should be in unknown fields. 419 420 GPBUnknownFields *ufs = [[GPBUnknownFields alloc] initFromMessage:msg]; 421 XCTAssertEqual(ufs.count, 3U); 422 uint64_t varint; 423 XCTAssertTrue([ufs getFirst:Message2_FieldNumber_OptionalEnum varint:&varint]); 424 XCTAssertEqual(varint, (uint64_t)Message3_Enum_Extra3); 425 XCTAssertTrue([ufs getFirst:Message2_FieldNumber_RepeatedEnumArray varint:&varint]); 426 XCTAssertEqual(varint, (uint64_t)Message3_Enum_Extra3); 427 XCTAssertTrue([ufs getFirst:Message2_FieldNumber_OneofEnum varint:&varint]); 428 XCTAssertEqual(varint, (uint64_t)Message3_Enum_Extra3); 429 [ufs release]; 430 431#pragma clang diagnostic push 432#pragma clang diagnostic ignored "-Wdeprecated-declarations" 433 434 GPBUnknownFieldSet *unknownFields = msg.unknownFields; 435 436 XCTAssertEqual([unknownFields countOfFields], 3U); 437 XCTAssertTrue([unknownFields hasField:Message2_FieldNumber_OptionalEnum]); 438 XCTAssertTrue([unknownFields hasField:Message2_FieldNumber_RepeatedEnumArray]); 439 XCTAssertTrue([unknownFields hasField:Message2_FieldNumber_OneofEnum]); 440 441 GPBUnknownField *field = [unknownFields getField:Message2_FieldNumber_OptionalEnum]; 442 XCTAssertEqual(field.varintList.count, 1U); 443 XCTAssertEqual([field.varintList valueAtIndex:0], (uint64_t)Message3_Enum_Extra3); 444 445 field = [unknownFields getField:Message2_FieldNumber_RepeatedEnumArray]; 446 XCTAssertEqual(field.varintList.count, 1U); 447 XCTAssertEqual([field.varintList valueAtIndex:0], (uint64_t)Message3_Enum_Extra3); 448 449 field = [unknownFields getField:Message2_FieldNumber_OneofEnum]; 450 XCTAssertEqual(field.varintList.count, 1U); 451 XCTAssertEqual([field.varintList valueAtIndex:0], (uint64_t)Message3_Enum_Extra3); 452 453#pragma clang diagnostic pop 454 455 [msg release]; 456 [orig release]; 457} 458 459- (void)testProto3UnknownEnumPreserving { 460 UnknownEnumsMyMessagePlusExtra *orig = [UnknownEnumsMyMessagePlusExtra message]; 461 462 orig.e = UnknownEnumsMyEnumPlusExtra_EExtra; 463 orig.repeatedEArray = 464 [GPBEnumArray arrayWithValidationFunction:UnknownEnumsMyEnumPlusExtra_IsValidValue 465 rawValue:UnknownEnumsMyEnumPlusExtra_EExtra]; 466 orig.repeatedPackedEArray = 467 [GPBEnumArray arrayWithValidationFunction:UnknownEnumsMyEnumPlusExtra_IsValidValue 468 rawValue:UnknownEnumsMyEnumPlusExtra_EExtra]; 469 orig.oneofE1 = UnknownEnumsMyEnumPlusExtra_EExtra; 470 471 // Everything should be there via raw values. 472 473 NSData *data = [orig data]; 474 XCTAssertNotNil(data); 475 UnknownEnumsMyMessage *msg = [UnknownEnumsMyMessage parseFromData:data error:NULL]; 476 477 XCTAssertEqual(msg.e, UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); 478 XCTAssertEqual(UnknownEnumsMyMessage_E_RawValue(msg), UnknownEnumsMyEnumPlusExtra_EExtra); 479 XCTAssertEqual(msg.repeatedEArray.count, 1U); 480 XCTAssertEqual([msg.repeatedEArray valueAtIndex:0], 481 UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); 482 XCTAssertEqual([msg.repeatedEArray rawValueAtIndex:0], 483 (UnknownEnumsMyEnum)UnknownEnumsMyEnumPlusExtra_EExtra); 484 XCTAssertEqual(msg.repeatedPackedEArray.count, 1U); 485 XCTAssertEqual([msg.repeatedPackedEArray valueAtIndex:0], 486 UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); 487 XCTAssertEqual([msg.repeatedPackedEArray rawValueAtIndex:0], 488 (UnknownEnumsMyEnum)UnknownEnumsMyEnumPlusExtra_EExtra); 489 XCTAssertEqual(msg.oneofE1, UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); 490 XCTAssertEqual(UnknownEnumsMyMessage_OneofE1_RawValue(msg), UnknownEnumsMyEnumPlusExtra_EExtra); 491 492 // Everything should go out and come back. 493 494 data = [msg data]; 495 orig = [UnknownEnumsMyMessagePlusExtra parseFromData:data error:NULL]; 496 497 XCTAssertEqual(orig.e, UnknownEnumsMyEnumPlusExtra_EExtra); 498 XCTAssertEqual(orig.repeatedEArray.count, 1U); 499 XCTAssertEqual([orig.repeatedEArray valueAtIndex:0], UnknownEnumsMyEnumPlusExtra_EExtra); 500 XCTAssertEqual(orig.repeatedPackedEArray.count, 1U); 501 XCTAssertEqual([orig.repeatedPackedEArray valueAtIndex:0], UnknownEnumsMyEnumPlusExtra_EExtra); 502 XCTAssertEqual(orig.oneofE1, UnknownEnumsMyEnumPlusExtra_EExtra); 503} 504 505// Disable clang-format for the macros. 506// clang-format off 507 508//%PDDM-DEFINE TEST_ROUNDTRIP_ONEOF(MESSAGE, FIELD, VALUE) 509//%TEST_ROUNDTRIP_ONEOF_ADV(MESSAGE, FIELD, VALUE, ) 510//%PDDM-DEFINE TEST_ROUNDTRIP_ONEOF_ADV(MESSAGE, FIELD, VALUE, EQ_SUFFIX) 511//% { // oneof##FIELD 512//% MESSAGE *orig = [[MESSAGE alloc] init]; 513//% orig.oneof##FIELD = VALUE; 514//% XCTAssertEqual(orig.oOneOfCase, MESSAGE##_O_OneOfCase_Oneof##FIELD); 515//% NSData *data = [orig data]; 516//% XCTAssertNotNil(data); 517//% MESSAGE *msg = [MESSAGE parseFromData:data error:NULL]; 518//% XCTAssertEqual(msg.oOneOfCase, MESSAGE##_O_OneOfCase_Oneof##FIELD); 519//% XCTAssertEqual##EQ_SUFFIX(msg.oneof##FIELD, VALUE); 520//% [orig release]; 521//% } 522//% 523//%PDDM-DEFINE TEST_ROUNDTRIP_ONEOFS(SYNTAX, BOOL_NON_DEFAULT) 524//%- (void)testProto##SYNTAX##RoundTripOneof { 525//% 526//%GROUP_INIT##SYNTAX() Message##SYNTAX *subMessage = [[Message##SYNTAX alloc] init]; 527//% XCTAssertNotNil(subMessage); 528//% subMessage.optionalInt32 = 666; 529//% 530//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Int32, 1) 531//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Int64, 2) 532//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Uint32, 3U) 533//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Uint64, 4U) 534//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sint32, 5) 535//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sint64, 6) 536//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Fixed32, 7U) 537//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Fixed64, 8U) 538//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sfixed32, 9) 539//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sfixed64, 10) 540//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Float, 11.0f) 541//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Double, 12.0) 542//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Bool, BOOL_NON_DEFAULT) 543//%TEST_ROUNDTRIP_ONEOF_ADV(Message##SYNTAX, String, @"foo", Objects) 544//%TEST_ROUNDTRIP_ONEOF_ADV(Message##SYNTAX, Bytes, [@"bar" dataUsingEncoding:NSUTF8StringEncoding], Objects) 545//%GROUP_TEST##SYNTAX()TEST_ROUNDTRIP_ONEOF_ADV(Message##SYNTAX, Message, subMessage, Objects) 546//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Enum, Message##SYNTAX##_Enum_Bar) 547//%GROUP_CLEANUP##SYNTAX() [subMessage release]; 548//%} 549//% 550//%PDDM-DEFINE GROUP_INIT2() 551//% Message2_OneofGroup *group = [[Message2_OneofGroup alloc] init]; 552//% XCTAssertNotNil(group); 553//% group.a = 777; 554//% 555//%PDDM-DEFINE GROUP_CLEANUP2() 556//% [group release]; 557//% 558//%PDDM-DEFINE GROUP_TEST2() 559//%TEST_ROUNDTRIP_ONEOF_ADV(Message2, Group, group, Objects) 560//% 561//%PDDM-DEFINE GROUP_INIT3() 562// Empty 563//%PDDM-DEFINE GROUP_CLEANUP3() 564// Empty 565//%PDDM-DEFINE GROUP_TEST3() 566//% // Not "group" in proto3. 567//% 568//% 569//%PDDM-EXPAND TEST_ROUNDTRIP_ONEOFS(2, NO) 570// This block of code is generated, do not edit it directly. 571 572- (void)testProto2RoundTripOneof { 573 574 Message2_OneofGroup *group = [[Message2_OneofGroup alloc] init]; 575 XCTAssertNotNil(group); 576 group.a = 777; 577 Message2 *subMessage = [[Message2 alloc] init]; 578 XCTAssertNotNil(subMessage); 579 subMessage.optionalInt32 = 666; 580 581 { // oneofInt32 582 Message2 *orig = [[Message2 alloc] init]; 583 orig.oneofInt32 = 1; 584 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofInt32); 585 NSData *data = [orig data]; 586 XCTAssertNotNil(data); 587 Message2 *msg = [Message2 parseFromData:data error:NULL]; 588 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32); 589 XCTAssertEqual(msg.oneofInt32, 1); 590 [orig release]; 591 } 592 593 { // oneofInt64 594 Message2 *orig = [[Message2 alloc] init]; 595 orig.oneofInt64 = 2; 596 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofInt64); 597 NSData *data = [orig data]; 598 XCTAssertNotNil(data); 599 Message2 *msg = [Message2 parseFromData:data error:NULL]; 600 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64); 601 XCTAssertEqual(msg.oneofInt64, 2); 602 [orig release]; 603 } 604 605 { // oneofUint32 606 Message2 *orig = [[Message2 alloc] init]; 607 orig.oneofUint32 = 3U; 608 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofUint32); 609 NSData *data = [orig data]; 610 XCTAssertNotNil(data); 611 Message2 *msg = [Message2 parseFromData:data error:NULL]; 612 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32); 613 XCTAssertEqual(msg.oneofUint32, 3U); 614 [orig release]; 615 } 616 617 { // oneofUint64 618 Message2 *orig = [[Message2 alloc] init]; 619 orig.oneofUint64 = 4U; 620 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofUint64); 621 NSData *data = [orig data]; 622 XCTAssertNotNil(data); 623 Message2 *msg = [Message2 parseFromData:data error:NULL]; 624 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64); 625 XCTAssertEqual(msg.oneofUint64, 4U); 626 [orig release]; 627 } 628 629 { // oneofSint32 630 Message2 *orig = [[Message2 alloc] init]; 631 orig.oneofSint32 = 5; 632 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSint32); 633 NSData *data = [orig data]; 634 XCTAssertNotNil(data); 635 Message2 *msg = [Message2 parseFromData:data error:NULL]; 636 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32); 637 XCTAssertEqual(msg.oneofSint32, 5); 638 [orig release]; 639 } 640 641 { // oneofSint64 642 Message2 *orig = [[Message2 alloc] init]; 643 orig.oneofSint64 = 6; 644 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSint64); 645 NSData *data = [orig data]; 646 XCTAssertNotNil(data); 647 Message2 *msg = [Message2 parseFromData:data error:NULL]; 648 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64); 649 XCTAssertEqual(msg.oneofSint64, 6); 650 [orig release]; 651 } 652 653 { // oneofFixed32 654 Message2 *orig = [[Message2 alloc] init]; 655 orig.oneofFixed32 = 7U; 656 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofFixed32); 657 NSData *data = [orig data]; 658 XCTAssertNotNil(data); 659 Message2 *msg = [Message2 parseFromData:data error:NULL]; 660 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32); 661 XCTAssertEqual(msg.oneofFixed32, 7U); 662 [orig release]; 663 } 664 665 { // oneofFixed64 666 Message2 *orig = [[Message2 alloc] init]; 667 orig.oneofFixed64 = 8U; 668 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofFixed64); 669 NSData *data = [orig data]; 670 XCTAssertNotNil(data); 671 Message2 *msg = [Message2 parseFromData:data error:NULL]; 672 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64); 673 XCTAssertEqual(msg.oneofFixed64, 8U); 674 [orig release]; 675 } 676 677 { // oneofSfixed32 678 Message2 *orig = [[Message2 alloc] init]; 679 orig.oneofSfixed32 = 9; 680 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32); 681 NSData *data = [orig data]; 682 XCTAssertNotNil(data); 683 Message2 *msg = [Message2 parseFromData:data error:NULL]; 684 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32); 685 XCTAssertEqual(msg.oneofSfixed32, 9); 686 [orig release]; 687 } 688 689 { // oneofSfixed64 690 Message2 *orig = [[Message2 alloc] init]; 691 orig.oneofSfixed64 = 10; 692 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64); 693 NSData *data = [orig data]; 694 XCTAssertNotNil(data); 695 Message2 *msg = [Message2 parseFromData:data error:NULL]; 696 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64); 697 XCTAssertEqual(msg.oneofSfixed64, 10); 698 [orig release]; 699 } 700 701 { // oneofFloat 702 Message2 *orig = [[Message2 alloc] init]; 703 orig.oneofFloat = 11.0f; 704 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofFloat); 705 NSData *data = [orig data]; 706 XCTAssertNotNil(data); 707 Message2 *msg = [Message2 parseFromData:data error:NULL]; 708 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat); 709 XCTAssertEqual(msg.oneofFloat, 11.0f); 710 [orig release]; 711 } 712 713 { // oneofDouble 714 Message2 *orig = [[Message2 alloc] init]; 715 orig.oneofDouble = 12.0; 716 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofDouble); 717 NSData *data = [orig data]; 718 XCTAssertNotNil(data); 719 Message2 *msg = [Message2 parseFromData:data error:NULL]; 720 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble); 721 XCTAssertEqual(msg.oneofDouble, 12.0); 722 [orig release]; 723 } 724 725 { // oneofBool 726 Message2 *orig = [[Message2 alloc] init]; 727 orig.oneofBool = NO; 728 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofBool); 729 NSData *data = [orig data]; 730 XCTAssertNotNil(data); 731 Message2 *msg = [Message2 parseFromData:data error:NULL]; 732 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool); 733 XCTAssertEqual(msg.oneofBool, NO); 734 [orig release]; 735 } 736 737 { // oneofString 738 Message2 *orig = [[Message2 alloc] init]; 739 orig.oneofString = @"foo"; 740 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofString); 741 NSData *data = [orig data]; 742 XCTAssertNotNil(data); 743 Message2 *msg = [Message2 parseFromData:data error:NULL]; 744 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString); 745 XCTAssertEqualObjects(msg.oneofString, @"foo"); 746 [orig release]; 747 } 748 749 { // oneofBytes 750 Message2 *orig = [[Message2 alloc] init]; 751 orig.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; 752 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofBytes); 753 NSData *data = [orig data]; 754 XCTAssertNotNil(data); 755 Message2 *msg = [Message2 parseFromData:data error:NULL]; 756 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes); 757 XCTAssertEqualObjects(msg.oneofBytes, [@"bar" dataUsingEncoding:NSUTF8StringEncoding]); 758 [orig release]; 759 } 760 761 { // oneofGroup 762 Message2 *orig = [[Message2 alloc] init]; 763 orig.oneofGroup = group; 764 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofGroup); 765 NSData *data = [orig data]; 766 XCTAssertNotNil(data); 767 Message2 *msg = [Message2 parseFromData:data error:NULL]; 768 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup); 769 XCTAssertEqualObjects(msg.oneofGroup, group); 770 [orig release]; 771 } 772 773 { // oneofMessage 774 Message2 *orig = [[Message2 alloc] init]; 775 orig.oneofMessage = subMessage; 776 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofMessage); 777 NSData *data = [orig data]; 778 XCTAssertNotNil(data); 779 Message2 *msg = [Message2 parseFromData:data error:NULL]; 780 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage); 781 XCTAssertEqualObjects(msg.oneofMessage, subMessage); 782 [orig release]; 783 } 784 785 { // oneofEnum 786 Message2 *orig = [[Message2 alloc] init]; 787 orig.oneofEnum = Message2_Enum_Bar; 788 XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofEnum); 789 NSData *data = [orig data]; 790 XCTAssertNotNil(data); 791 Message2 *msg = [Message2 parseFromData:data error:NULL]; 792 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum); 793 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar); 794 [orig release]; 795 } 796 797 [group release]; 798 [subMessage release]; 799} 800 801//%PDDM-EXPAND TEST_ROUNDTRIP_ONEOFS(3, YES) 802// This block of code is generated, do not edit it directly. 803 804- (void)testProto3RoundTripOneof { 805 806 Message3 *subMessage = [[Message3 alloc] init]; 807 XCTAssertNotNil(subMessage); 808 subMessage.optionalInt32 = 666; 809 810 { // oneofInt32 811 Message3 *orig = [[Message3 alloc] init]; 812 orig.oneofInt32 = 1; 813 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofInt32); 814 NSData *data = [orig data]; 815 XCTAssertNotNil(data); 816 Message3 *msg = [Message3 parseFromData:data error:NULL]; 817 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32); 818 XCTAssertEqual(msg.oneofInt32, 1); 819 [orig release]; 820 } 821 822 { // oneofInt64 823 Message3 *orig = [[Message3 alloc] init]; 824 orig.oneofInt64 = 2; 825 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofInt64); 826 NSData *data = [orig data]; 827 XCTAssertNotNil(data); 828 Message3 *msg = [Message3 parseFromData:data error:NULL]; 829 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64); 830 XCTAssertEqual(msg.oneofInt64, 2); 831 [orig release]; 832 } 833 834 { // oneofUint32 835 Message3 *orig = [[Message3 alloc] init]; 836 orig.oneofUint32 = 3U; 837 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofUint32); 838 NSData *data = [orig data]; 839 XCTAssertNotNil(data); 840 Message3 *msg = [Message3 parseFromData:data error:NULL]; 841 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32); 842 XCTAssertEqual(msg.oneofUint32, 3U); 843 [orig release]; 844 } 845 846 { // oneofUint64 847 Message3 *orig = [[Message3 alloc] init]; 848 orig.oneofUint64 = 4U; 849 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofUint64); 850 NSData *data = [orig data]; 851 XCTAssertNotNil(data); 852 Message3 *msg = [Message3 parseFromData:data error:NULL]; 853 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64); 854 XCTAssertEqual(msg.oneofUint64, 4U); 855 [orig release]; 856 } 857 858 { // oneofSint32 859 Message3 *orig = [[Message3 alloc] init]; 860 orig.oneofSint32 = 5; 861 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSint32); 862 NSData *data = [orig data]; 863 XCTAssertNotNil(data); 864 Message3 *msg = [Message3 parseFromData:data error:NULL]; 865 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32); 866 XCTAssertEqual(msg.oneofSint32, 5); 867 [orig release]; 868 } 869 870 { // oneofSint64 871 Message3 *orig = [[Message3 alloc] init]; 872 orig.oneofSint64 = 6; 873 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSint64); 874 NSData *data = [orig data]; 875 XCTAssertNotNil(data); 876 Message3 *msg = [Message3 parseFromData:data error:NULL]; 877 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64); 878 XCTAssertEqual(msg.oneofSint64, 6); 879 [orig release]; 880 } 881 882 { // oneofFixed32 883 Message3 *orig = [[Message3 alloc] init]; 884 orig.oneofFixed32 = 7U; 885 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofFixed32); 886 NSData *data = [orig data]; 887 XCTAssertNotNil(data); 888 Message3 *msg = [Message3 parseFromData:data error:NULL]; 889 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32); 890 XCTAssertEqual(msg.oneofFixed32, 7U); 891 [orig release]; 892 } 893 894 { // oneofFixed64 895 Message3 *orig = [[Message3 alloc] init]; 896 orig.oneofFixed64 = 8U; 897 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofFixed64); 898 NSData *data = [orig data]; 899 XCTAssertNotNil(data); 900 Message3 *msg = [Message3 parseFromData:data error:NULL]; 901 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64); 902 XCTAssertEqual(msg.oneofFixed64, 8U); 903 [orig release]; 904 } 905 906 { // oneofSfixed32 907 Message3 *orig = [[Message3 alloc] init]; 908 orig.oneofSfixed32 = 9; 909 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32); 910 NSData *data = [orig data]; 911 XCTAssertNotNil(data); 912 Message3 *msg = [Message3 parseFromData:data error:NULL]; 913 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32); 914 XCTAssertEqual(msg.oneofSfixed32, 9); 915 [orig release]; 916 } 917 918 { // oneofSfixed64 919 Message3 *orig = [[Message3 alloc] init]; 920 orig.oneofSfixed64 = 10; 921 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64); 922 NSData *data = [orig data]; 923 XCTAssertNotNil(data); 924 Message3 *msg = [Message3 parseFromData:data error:NULL]; 925 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64); 926 XCTAssertEqual(msg.oneofSfixed64, 10); 927 [orig release]; 928 } 929 930 { // oneofFloat 931 Message3 *orig = [[Message3 alloc] init]; 932 orig.oneofFloat = 11.0f; 933 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofFloat); 934 NSData *data = [orig data]; 935 XCTAssertNotNil(data); 936 Message3 *msg = [Message3 parseFromData:data error:NULL]; 937 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat); 938 XCTAssertEqual(msg.oneofFloat, 11.0f); 939 [orig release]; 940 } 941 942 { // oneofDouble 943 Message3 *orig = [[Message3 alloc] init]; 944 orig.oneofDouble = 12.0; 945 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofDouble); 946 NSData *data = [orig data]; 947 XCTAssertNotNil(data); 948 Message3 *msg = [Message3 parseFromData:data error:NULL]; 949 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble); 950 XCTAssertEqual(msg.oneofDouble, 12.0); 951 [orig release]; 952 } 953 954 { // oneofBool 955 Message3 *orig = [[Message3 alloc] init]; 956 orig.oneofBool = YES; 957 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofBool); 958 NSData *data = [orig data]; 959 XCTAssertNotNil(data); 960 Message3 *msg = [Message3 parseFromData:data error:NULL]; 961 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool); 962 XCTAssertEqual(msg.oneofBool, YES); 963 [orig release]; 964 } 965 966 { // oneofString 967 Message3 *orig = [[Message3 alloc] init]; 968 orig.oneofString = @"foo"; 969 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofString); 970 NSData *data = [orig data]; 971 XCTAssertNotNil(data); 972 Message3 *msg = [Message3 parseFromData:data error:NULL]; 973 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString); 974 XCTAssertEqualObjects(msg.oneofString, @"foo"); 975 [orig release]; 976 } 977 978 { // oneofBytes 979 Message3 *orig = [[Message3 alloc] init]; 980 orig.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; 981 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofBytes); 982 NSData *data = [orig data]; 983 XCTAssertNotNil(data); 984 Message3 *msg = [Message3 parseFromData:data error:NULL]; 985 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes); 986 XCTAssertEqualObjects(msg.oneofBytes, [@"bar" dataUsingEncoding:NSUTF8StringEncoding]); 987 [orig release]; 988 } 989 990 // Not "group" in proto3. 991 992 { // oneofMessage 993 Message3 *orig = [[Message3 alloc] init]; 994 orig.oneofMessage = subMessage; 995 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofMessage); 996 NSData *data = [orig data]; 997 XCTAssertNotNil(data); 998 Message3 *msg = [Message3 parseFromData:data error:NULL]; 999 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage); 1000 XCTAssertEqualObjects(msg.oneofMessage, subMessage); 1001 [orig release]; 1002 } 1003 1004 { // oneofEnum 1005 Message3 *orig = [[Message3 alloc] init]; 1006 orig.oneofEnum = Message3_Enum_Bar; 1007 XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofEnum); 1008 NSData *data = [orig data]; 1009 XCTAssertNotNil(data); 1010 Message3 *msg = [Message3 parseFromData:data error:NULL]; 1011 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum); 1012 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Bar); 1013 [orig release]; 1014 } 1015 1016 [subMessage release]; 1017} 1018 1019//%PDDM-EXPAND-END (2 expansions) 1020 1021// clang-format on 1022 1023- (void)testPackedUnpackedMessageParsing { 1024 // packed is optional, a repeated field should parse when packed or unpacked. 1025 1026 TestPackedTypes *packedOrig = [TestPackedTypes message]; 1027 TestUnpackedTypes *unpackedOrig = [TestUnpackedTypes message]; 1028 [self setPackedFields:packedOrig repeatedCount:4]; 1029 [self setUnpackedFields:unpackedOrig repeatedCount:4]; 1030 1031 NSData *packedData = [packedOrig data]; 1032 NSData *unpackedData = [unpackedOrig data]; 1033 XCTAssertNotNil(packedData); 1034 XCTAssertNotNil(unpackedData); 1035 XCTAssertNotEqualObjects(packedData, unpackedData, 1036 @"Data should differ (packed vs unpacked) use"); 1037 1038 NSError *error = nil; 1039 TestPackedTypes *packedParse = [TestPackedTypes parseFromData:unpackedData error:&error]; 1040 XCTAssertNotNil(packedParse); 1041 XCTAssertNil(error); 1042 XCTAssertEqualObjects(packedParse, packedOrig); 1043 1044 error = nil; 1045 TestUnpackedTypes *unpackedParsed = [TestUnpackedTypes parseFromData:packedData error:&error]; 1046 XCTAssertNotNil(unpackedParsed); 1047 XCTAssertNil(error); 1048 XCTAssertEqualObjects(unpackedParsed, unpackedOrig); 1049} 1050 1051- (void)testPackedUnpackedExtensionParsing { 1052 // packed is optional, a repeated extension should parse when packed or 1053 // unpacked. 1054 1055 TestPackedExtensions *packedOrig = [TestPackedExtensions message]; 1056 TestUnpackedExtensions *unpackedOrig = [TestUnpackedExtensions message]; 1057 [self setPackedExtensions:packedOrig repeatedCount:kGPBDefaultRepeatCount]; 1058 [self setUnpackedExtensions:unpackedOrig repeatedCount:kGPBDefaultRepeatCount]; 1059 1060 NSData *packedData = [packedOrig data]; 1061 NSData *unpackedData = [unpackedOrig data]; 1062 XCTAssertNotNil(packedData); 1063 XCTAssertNotNil(unpackedData); 1064 XCTAssertNotEqualObjects(packedData, unpackedData, 1065 @"Data should differ (packed vs unpacked) use"); 1066 1067 NSError *error = nil; 1068 TestPackedExtensions *packedParse = 1069 [TestPackedExtensions parseFromData:unpackedData 1070 extensionRegistry:[UnittestRoot extensionRegistry] 1071 error:&error]; 1072 XCTAssertNotNil(packedParse); 1073 XCTAssertNil(error); 1074 XCTAssertEqualObjects(packedParse, packedOrig); 1075 1076 error = nil; 1077 TestUnpackedExtensions *unpackedParsed = 1078 [TestUnpackedExtensions parseFromData:packedData 1079 extensionRegistry:[UnittestRoot extensionRegistry] 1080 error:&error]; 1081 XCTAssertNotNil(unpackedParsed); 1082 XCTAssertNil(error); 1083 XCTAssertEqualObjects(unpackedParsed, unpackedOrig); 1084} 1085 1086- (void)testPackedExtensionVsFieldParsing { 1087 // Extensions and fields end up on the wire the same way, so they can parse 1088 // each other. 1089 1090 TestPackedTypes *fieldsOrig = [TestPackedTypes message]; 1091 TestPackedExtensions *extsOrig = [TestPackedExtensions message]; 1092 [self setPackedFields:fieldsOrig repeatedCount:kGPBDefaultRepeatCount]; 1093 [self setPackedExtensions:extsOrig repeatedCount:kGPBDefaultRepeatCount]; 1094 1095 NSData *fieldsData = [fieldsOrig data]; 1096 NSData *extsData = [extsOrig data]; 1097 XCTAssertNotNil(fieldsData); 1098 XCTAssertNotNil(extsData); 1099 XCTAssertEqualObjects(fieldsData, extsData); 1100 1101 NSError *error = nil; 1102 TestPackedTypes *fieldsParse = [TestPackedTypes parseFromData:extsData error:&error]; 1103 XCTAssertNotNil(fieldsParse); 1104 XCTAssertNil(error); 1105 XCTAssertEqualObjects(fieldsParse, fieldsOrig); 1106 1107 error = nil; 1108 TestPackedExtensions *extsParse = 1109 [TestPackedExtensions parseFromData:fieldsData 1110 extensionRegistry:[UnittestRoot extensionRegistry] 1111 error:&error]; 1112 XCTAssertNotNil(extsParse); 1113 XCTAssertNil(error); 1114 XCTAssertEqualObjects(extsParse, extsOrig); 1115} 1116 1117- (void)testUnpackedExtensionVsFieldParsing { 1118 // Extensions and fields end up on the wire the same way, so they can parse 1119 // each other. 1120 1121 TestUnpackedTypes *fieldsOrig = [TestUnpackedTypes message]; 1122 TestUnpackedExtensions *extsOrig = [TestUnpackedExtensions message]; 1123 [self setUnpackedFields:fieldsOrig repeatedCount:3]; 1124 [self setUnpackedExtensions:extsOrig repeatedCount:3]; 1125 1126 NSData *fieldsData = [fieldsOrig data]; 1127 NSData *extsData = [extsOrig data]; 1128 XCTAssertNotNil(fieldsData); 1129 XCTAssertNotNil(extsData); 1130 XCTAssertEqualObjects(fieldsData, extsData); 1131 1132 TestUnpackedTypes *fieldsParse = [TestUnpackedTypes parseFromData:extsData error:NULL]; 1133 XCTAssertNotNil(fieldsParse); 1134 XCTAssertEqualObjects(fieldsParse, fieldsOrig); 1135 1136 TestUnpackedExtensions *extsParse = 1137 [TestUnpackedExtensions parseFromData:fieldsData 1138 extensionRegistry:[UnittestRoot extensionRegistry] 1139 error:NULL]; 1140 XCTAssertNotNil(extsParse); 1141 XCTAssertEqualObjects(extsParse, extsOrig); 1142} 1143 1144- (void)testErrorSubsectionInvalidLimit { 1145 NSData *data = DataFromCStr("\x0A\x08\x0A\x07\x12\x04\x72\x02\x4B\x50\x12\x04\x72\x02\x4B\x50"); 1146 NSError *error = nil; 1147 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data error:&error]; 1148 XCTAssertNil(msg); 1149 XCTAssertNotNil(error); 1150 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); 1151 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSubsectionLimit); 1152} 1153 1154- (void)testErrorSubsectionLimitReached { 1155 NSData *data = DataFromCStr("\x0A\x06\x12\x03\x72\x02\x4B\x50"); 1156 NSError *error = nil; 1157 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data error:&error]; 1158 XCTAssertNil(msg); 1159 XCTAssertNotNil(error); 1160 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); 1161 XCTAssertEqual(error.code, GPBCodedInputStreamErrorSubsectionLimitReached); 1162} 1163 1164- (void)testErrorInvalidVarint { 1165 NSData *data = DataFromCStr("\x72\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); 1166 NSError *error = nil; 1167 TestAllTypes *msg = [TestAllTypes parseFromData:data error:&error]; 1168 XCTAssertNil(msg); 1169 XCTAssertNotNil(error); 1170 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); 1171 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidVarInt); 1172} 1173 1174- (void)testErrorInvalidUTF8 { 1175 NSData *data = DataFromCStr("\x72\x04\xF4\xFF\xFF\xFF"); 1176 NSError *error = nil; 1177 TestAllTypes *msg = [TestAllTypes parseFromData:data error:&error]; 1178 XCTAssertNil(msg); 1179 XCTAssertNotNil(error); 1180 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); 1181 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidUTF8); 1182} 1183 1184- (void)testErrorInvalidSize { 1185 NSData *data = DataFromCStr("\x72\x03\x4B\x50"); 1186 NSError *error = nil; 1187 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data error:&error]; 1188 XCTAssertNil(msg); 1189 XCTAssertNotNil(error); 1190 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); 1191 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSize); 1192} 1193 1194- (void)testErrorInvalidTag { 1195 NSData *data = DataFromCStr("\x0F"); 1196 NSError *error = nil; 1197 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data error:&error]; 1198 XCTAssertNil(msg); 1199 XCTAssertNotNil(error); 1200 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); 1201 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidTag); 1202} 1203 1204- (void)testZeroFieldNum { 1205 // These are ConformanceTestSuite::TestIllegalTags. 1206 1207 const char *tests[] = {"\1DEADBEEF", "\2\1\1", "\3\4", "\5DEAD"}; 1208 1209 for (size_t i = 0; i < GPBARRAYSIZE(tests); ++i) { 1210 NSData *data = DataFromCStr(tests[i]); 1211 1212 { 1213 // Message from proto2 syntax file 1214 NSError *error = nil; 1215 Message2 *msg = [Message2 parseFromData:data error:&error]; 1216 XCTAssertNil(msg, @"i = %zd", i); 1217 XCTAssertNotNil(error, @"i = %zd", i); 1218 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain, @"i = %zd", i); 1219 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidTag, @"i = %zd", i); 1220 } 1221 1222 { 1223 // Message from proto3 syntax file 1224 NSError *error = nil; 1225 Message3 *msg = [Message3 parseFromData:data error:&error]; 1226 XCTAssertNil(msg, @"i = %zd", i); 1227 XCTAssertNotNil(error, @"i = %zd", i); 1228 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain, @"i = %zd", i); 1229 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidTag, @"i = %zd", i); 1230 } 1231 } 1232} 1233 1234- (void)testErrorRecursionDepthReached { 1235 NSData *data = DataFromCStr("\x0A\xF2\x01\x0A\xEF\x01\x0A\xEC\x01\x0A\xE9\x01\x0A\xE6\x01" 1236 "\x0A\xE3\x01\x0A\xE0\x01\x0A\xDD\x01\x0A\xDA\x01\x0A\xD7\x01" 1237 "\x0A\xD4\x01\x0A\xD1\x01\x0A\xCE\x01\x0A\xCB\x01\x0A\xC8\x01" 1238 "\x0A\xC5\x01\x0A\xC2\x01\x0A\xBF\x01\x0A\xBC\x01\x0A\xB9\x01" 1239 "\x0A\xB6\x01\x0A\xB3\x01\x0A\xB0\x01\x0A\xAD\x01\x0A\xAA\x01" 1240 "\x0A\xA7\x01\x0A\xA4\x01\x0A\xA1\x01\x0A\x9E\x01\x0A\x9B\x01" 1241 "\x0A\x98\x01\x0A\x95\x01\x0A\x92\x01\x0A\x8F\x01\x0A\x8C\x01" 1242 "\x0A\x89\x01\x0A\x86\x01\x0A\x83\x01\x0A\x80\x01\x0A\x7E" 1243 "\x0A\x7C\x0A\x7A\x0A\x78\x0A\x76\x0A\x74\x0A\x72\x0A\x70" 1244 "\x0A\x6E\x0A\x6C\x0A\x6A\x0A\x68\x0A\x66\x0A\x64\x0A\x62" 1245 "\x0A\x60\x0A\x5E\x0A\x5C\x0A\x5A\x0A\x58\x0A\x56\x0A\x54" 1246 "\x0A\x52\x0A\x50\x0A\x4E\x0A\x4C\x0A\x4A\x0A\x48\x0A\x46" 1247 "\x0A\x44\x0A\x42\x0A\x40\x0A\x3E\x0A\x3C\x0A\x3A\x0A\x38" 1248 "\x0A\x36\x0A\x34\x0A\x32\x0A\x30\x0A\x2E\x0A\x2C\x0A\x2A" 1249 "\x0A\x28\x0A\x26\x0A\x24\x0A\x22\x0A\x20\x0A\x1E\x0A\x1C" 1250 "\x0A\x1A\x0A\x18\x0A\x16\x0A\x14\x0A\x12\x0A\x10\x0A\x0E" 1251 "\x0A\x0C\x0A\x0A\x0A\x08\x0A\x06\x12\x04\x72\x02\x4B\x50"); 1252 NSError *error = nil; 1253 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data error:&error]; 1254 XCTAssertNil(msg); 1255 XCTAssertNotNil(error); 1256 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); 1257 XCTAssertEqual(error.code, GPBCodedInputStreamErrorRecursionDepthExceeded); 1258} 1259 1260- (void)testParseDelimitedDataOver2GB { 1261 NSData *data = DataFromCStr("\xFF\xFF\xFF\xFF\x0F\x01\x02\0x3"); // Don't need all the bytes 1262 GPBCodedInputStream *input = [GPBCodedInputStream streamWithData:data]; 1263 NSError *error; 1264 GPBMessage *result = [GPBMessage parseDelimitedFromCodedInputStream:input 1265 extensionRegistry:nil 1266 error:&error]; 1267 XCTAssertNil(result); 1268 XCTAssertNotNil(error); 1269 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); 1270 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSize); 1271} 1272 1273#ifdef DEBUG 1274- (void)testErrorMissingRequiredField { 1275 NSData *data = DataFromCStr(""); 1276 NSError *error = nil; 1277 TestRequired *msg = [TestRequired parseFromData:data error:&error]; 1278 XCTAssertNil(msg); 1279 XCTAssertNotNil(error); 1280 XCTAssertEqualObjects(error.domain, GPBMessageErrorDomain); 1281 XCTAssertEqual(error.code, GPBMessageErrorCodeMissingRequiredField); 1282} 1283#endif 1284 1285#pragma mark - Subset from from map_tests.cc 1286 1287// TEST(GeneratedMapFieldTest, StandardWireFormat) 1288- (void)testMap_StandardWireFormat { 1289 NSData *data = DataFromCStr("\x0A\x04\x08\x01\x10\x01"); 1290 1291 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; 1292 XCTAssertEqual(msg.mapInt32Int32.count, 1U); 1293 int32_t val = 666; 1294 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]); 1295 XCTAssertEqual(val, 1); 1296 1297 [msg release]; 1298} 1299 1300// TEST(GeneratedMapFieldTest, UnorderedWireFormat) 1301- (void)testMap_UnorderedWireFormat { 1302 // put value before key in wire format 1303 NSData *data = DataFromCStr("\x0A\x04\x10\x01\x08\x02"); 1304 1305 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; 1306 XCTAssertEqual(msg.mapInt32Int32.count, 1U); 1307 int32_t val = 666; 1308 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]); 1309 XCTAssertEqual(val, 1); 1310 1311 [msg release]; 1312} 1313 1314// TEST(GeneratedMapFieldTest, DuplicatedKeyWireFormat) 1315- (void)testMap_DuplicatedKeyWireFormat { 1316 // Two key fields in wire format 1317 NSData *data = DataFromCStr("\x0A\x06\x08\x01\x08\x02\x10\x01"); 1318 1319 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; 1320 XCTAssertEqual(msg.mapInt32Int32.count, 1U); 1321 int32_t val = 666; 1322 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]); 1323 XCTAssertEqual(val, 1); 1324 1325 [msg release]; 1326} 1327 1328// TEST(GeneratedMapFieldTest, DuplicatedValueWireFormat) 1329- (void)testMap_DuplicatedValueWireFormat { 1330 // Two value fields in wire format 1331 NSData *data = DataFromCStr("\x0A\x06\x08\x01\x10\x01\x10\x02"); 1332 1333 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; 1334 XCTAssertEqual(msg.mapInt32Int32.count, 1U); 1335 int32_t val = 666; 1336 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]); 1337 XCTAssertEqual(val, 2); 1338 1339 [msg release]; 1340} 1341 1342// TEST(GeneratedMapFieldTest, MissedKeyWireFormat) 1343- (void)testMap_MissedKeyWireFormat { 1344 // No key field in wire format 1345 NSData *data = DataFromCStr("\x0A\x02\x10\x01"); 1346 1347 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; 1348 XCTAssertEqual(msg.mapInt32Int32.count, 1U); 1349 int32_t val = 666; 1350 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:0]); 1351 XCTAssertEqual(val, 1); 1352 1353 [msg release]; 1354} 1355 1356// TEST(GeneratedMapFieldTest, MissedValueWireFormat) 1357- (void)testMap_MissedValueWireFormat { 1358 // No value field in wire format 1359 NSData *data = DataFromCStr("\x0A\x02\x08\x01"); 1360 1361 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; 1362 XCTAssertEqual(msg.mapInt32Int32.count, 1U); 1363 int32_t val = 666; 1364 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]); 1365 XCTAssertEqual(val, 0); 1366 1367 [msg release]; 1368} 1369 1370// TEST(GeneratedMapFieldTest, UnknownFieldWireFormat) 1371- (void)testMap_UnknownFieldWireFormat { 1372 // Unknown field in wire format 1373 NSData *data = DataFromCStr("\x0A\x06\x08\x02\x10\x03\x18\x01"); 1374 1375 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; 1376 XCTAssertEqual(msg.mapInt32Int32.count, 1U); 1377 int32_t val = 666; 1378 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]); 1379 XCTAssertEqual(val, 3); 1380 1381 [msg release]; 1382} 1383 1384// TEST(GeneratedMapFieldTest, CorruptedWireFormat) 1385- (void)testMap_CorruptedWireFormat { 1386 // corrupted data in wire format 1387 NSData *data = DataFromCStr("\x0A\x06\x08\x02\x11\x03"); 1388 1389 NSError *error = nil; 1390 TestMap *msg = [TestMap parseFromData:data error:&error]; 1391 XCTAssertNil(msg); 1392 XCTAssertNotNil(error); 1393 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); 1394 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSubsectionLimit); 1395} 1396 1397// TEST(GeneratedMapFieldTest, Proto2UnknownEnum) 1398- (void)testMap_Proto2UnknownEnum { 1399 TestEnumMapPlusExtra *orig = [[TestEnumMapPlusExtra alloc] init]; 1400 1401 orig.knownMapField = [[[GPBInt32EnumDictionary alloc] 1402 initWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue] autorelease]; 1403 orig.unknownMapField = [[[GPBInt32EnumDictionary alloc] 1404 initWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue] autorelease]; 1405 [orig.knownMapField setEnum:Proto2MapEnumPlusExtra_EProto2MapEnumFoo forKey:0]; 1406 [orig.unknownMapField setEnum:Proto2MapEnumPlusExtra_EProto2MapEnumExtra forKey:0]; 1407 1408 NSData *data = [orig data]; 1409 XCTAssertNotNil(data); 1410 TestEnumMap *msg1 = [TestEnumMap parseFromData:data error:NULL]; 1411 XCTAssertEqual(msg1.knownMapField.count, 1U); 1412 int32_t val = -1; 1413 XCTAssertTrue([msg1.knownMapField getEnum:&val forKey:0]); 1414 XCTAssertEqual(val, Proto2MapEnum_Proto2MapEnumFoo); 1415 GPBUnknownFields *ufs = [[GPBUnknownFields alloc] initFromMessage:msg1]; 1416 XCTAssertEqual(ufs.count, 1U); 1417 [ufs release]; 1418#pragma clang diagnostic push 1419#pragma clang diagnostic ignored "-Wdeprecated-declarations" 1420 XCTAssertEqual(msg1.unknownFields.countOfFields, 1U); 1421#pragma clang diagnostic pop 1422 1423 data = [msg1 data]; 1424 TestEnumMapPlusExtra *msg2 = [TestEnumMapPlusExtra parseFromData:data error:NULL]; 1425 val = -1; 1426 XCTAssertEqual(msg2.knownMapField.count, 1U); 1427 XCTAssertTrue([msg2.knownMapField getEnum:&val forKey:0]); 1428 XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumFoo); 1429 val = -1; 1430 XCTAssertEqual(msg2.unknownMapField.count, 1U); 1431 XCTAssertTrue([msg2.unknownMapField getEnum:&val forKey:0]); 1432 XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumExtra); 1433 ufs = [[GPBUnknownFields alloc] initFromMessage:msg2]; 1434 XCTAssertTrue(ufs.empty); 1435 [ufs release]; 1436#pragma clang diagnostic push 1437#pragma clang diagnostic ignored "-Wdeprecated-declarations" 1438 XCTAssertEqual(msg2.unknownFields.countOfFields, 0U); 1439#pragma clang diagnostic pop 1440 1441 XCTAssertEqualObjects(orig, msg2); 1442 1443 [orig release]; 1444} 1445 1446#pragma mark - Map Round Tripping 1447 1448- (void)testProto2MapRoundTripping { 1449 Message2 *msg = [[Message2 alloc] init]; 1450 1451 // Key/Value data should result in different byte lengths on wire to ensure 1452 // everything is right. 1453 [msg.mapInt32Int32 setInt32:1000 forKey:200]; 1454 [msg.mapInt32Int32 setInt32:101 forKey:2001]; 1455 [msg.mapInt64Int64 setInt64:1002 forKey:202]; 1456 [msg.mapInt64Int64 setInt64:103 forKey:2003]; 1457 [msg.mapInt64Int64 setInt64:4294967296 forKey:4294967297]; 1458 [msg.mapUint32Uint32 setUInt32:1004 forKey:204]; 1459 [msg.mapUint32Uint32 setUInt32:105 forKey:2005]; 1460 [msg.mapUint64Uint64 setUInt64:1006 forKey:206]; 1461 [msg.mapUint64Uint64 setUInt64:107 forKey:2007]; 1462 [msg.mapUint64Uint64 setUInt64:4294967298 forKey:4294967299]; 1463 [msg.mapSint32Sint32 setInt32:1008 forKey:208]; 1464 [msg.mapSint32Sint32 setInt32:109 forKey:2009]; 1465 [msg.mapSint64Sint64 setInt64:1010 forKey:210]; 1466 [msg.mapSint64Sint64 setInt64:111 forKey:2011]; 1467 [msg.mapSint64Sint64 setInt64:4294967300 forKey:4294967301]; 1468 [msg.mapFixed32Fixed32 setUInt32:1012 forKey:212]; 1469 [msg.mapFixed32Fixed32 setUInt32:113 forKey:2013]; 1470 [msg.mapFixed64Fixed64 setUInt64:1014 forKey:214]; 1471 [msg.mapFixed64Fixed64 setUInt64:115 forKey:2015]; 1472 [msg.mapFixed64Fixed64 setUInt64:4294967302 forKey:4294967303]; 1473 [msg.mapSfixed32Sfixed32 setInt32:1016 forKey:216]; 1474 [msg.mapSfixed32Sfixed32 setInt32:117 forKey:2017]; 1475 [msg.mapSfixed64Sfixed64 setInt64:1018 forKey:218]; 1476 [msg.mapSfixed64Sfixed64 setInt64:119 forKey:2019]; 1477 [msg.mapSfixed64Sfixed64 setInt64:4294967304 forKey:4294967305]; 1478 [msg.mapInt32Float setFloat:1020.f forKey:220]; 1479 [msg.mapInt32Float setFloat:121.f forKey:2021]; 1480 [msg.mapInt32Double setDouble:1022. forKey:222]; 1481 [msg.mapInt32Double setDouble:123. forKey:2023]; 1482 [msg.mapBoolBool setBool:false forKey:true]; 1483 [msg.mapBoolBool setBool:true forKey:false]; 1484 msg.mapStringString[@"224"] = @"1024"; 1485 msg.mapStringString[@"2025"] = @"125"; 1486 msg.mapStringBytes[@"226"] = DataFromCStr("1026"); 1487 msg.mapStringBytes[@"2027"] = DataFromCStr("127"); 1488 Message2 *val1 = [[Message2 alloc] init]; 1489 val1.optionalInt32 = 1028; 1490 Message2 *val2 = [[Message2 alloc] init]; 1491 val2.optionalInt32 = 129; 1492 [msg.mapStringMessage setObject:val1 forKey:@"228"]; 1493 [msg.mapStringMessage setObject:val2 forKey:@"2029"]; 1494 [msg.mapInt32Bytes setObject:DataFromCStr("1030 bytes") forKey:230]; 1495 [msg.mapInt32Bytes setObject:DataFromCStr("131") forKey:2031]; 1496 [msg.mapInt32Enum setEnum:Message2_Enum_Bar forKey:232]; 1497 [msg.mapInt32Enum setEnum:Message2_Enum_Baz forKey:2033]; 1498 Message2 *val3 = [[Message2 alloc] init]; 1499 val3.optionalInt32 = 1034; 1500 Message2 *val4 = [[Message2 alloc] init]; 1501 val4.optionalInt32 = 135; 1502 [msg.mapInt32Message setObject:val3 forKey:234]; 1503 [msg.mapInt32Message setObject:val4 forKey:2035]; 1504 1505 NSData *data = [msg data]; 1506 XCTAssertNotNil(data); 1507 Message2 *msg2 = [[Message2 alloc] initWithData:data error:NULL]; 1508 1509 XCTAssertNotEqual(msg2, msg); // Pointer comparison 1510 XCTAssertEqualObjects(msg2, msg); 1511 1512 [val4 release]; 1513 [val3 release]; 1514 [val2 release]; 1515 [val1 release]; 1516 [msg2 release]; 1517 [msg release]; 1518} 1519 1520@end 1521