1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 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 "GPBTestUtilities.h" 9#import "GPBUnknownFieldSet.h" 10#import "GPBUnknownFieldSet_PackagePrivate.h" 11#import "GPBUnknownField_PackagePrivate.h" 12#import "objectivec/Tests/Unittest.pbobjc.h" 13 14#pragma clang diagnostic push 15#pragma clang diagnostic ignored "-Wdeprecated-declarations" 16 17@interface GPBUnknownFieldSet (GPBUnknownFieldSetTest) 18- (void)getTags:(int32_t*)tags; 19@end 20 21@interface UnknownFieldSetTest : GPBTestCase { 22 @private 23 TestAllTypes* allFields_; 24 NSData* allFieldsData_; 25 26 // An empty message that has been parsed from allFieldsData. So, it has 27 // unknown fields of every type. 28 TestEmptyMessage* emptyMessage_; 29 GPBUnknownFieldSet* unknownFields_; 30} 31 32@end 33 34@implementation UnknownFieldSetTest 35 36- (void)setUp { 37 allFields_ = [self allSetRepeatedCount:kGPBDefaultRepeatCount]; 38 allFieldsData_ = [allFields_ data]; 39 emptyMessage_ = [TestEmptyMessage parseFromData:allFieldsData_ error:NULL]; 40 unknownFields_ = emptyMessage_.unknownFields; 41} 42 43- (void)testInvalidFieldNumber { 44 GPBUnknownFieldSet* set = [[[GPBUnknownFieldSet alloc] init] autorelease]; 45 GPBUnknownField* field = [[[GPBUnknownField alloc] initWithNumber:0] autorelease]; 46 XCTAssertThrowsSpecificNamed([set addField:field], NSException, NSInvalidArgumentException); 47} 48 49- (void)testEqualityAndHash { 50 // Empty 51 52 GPBUnknownFieldSet* set1 = [[[GPBUnknownFieldSet alloc] init] autorelease]; 53 XCTAssertTrue([set1 isEqual:set1]); 54 XCTAssertFalse([set1 isEqual:@"foo"]); 55 GPBUnknownFieldSet* set2 = [[[GPBUnknownFieldSet alloc] init] autorelease]; 56 XCTAssertEqualObjects(set1, set2); 57 XCTAssertEqual([set1 hash], [set2 hash]); 58 59 // Varint 60 61 GPBUnknownField* field1 = [[[GPBUnknownField alloc] initWithNumber:1] autorelease]; 62 [field1 addVarint:1]; 63 [set1 addField:field1]; 64 XCTAssertNotEqualObjects(set1, set2); 65 GPBUnknownField* field2 = [[[GPBUnknownField alloc] initWithNumber:1] autorelease]; 66 [field2 addVarint:1]; 67 [set2 addField:field2]; 68 XCTAssertEqualObjects(set1, set2); 69 XCTAssertEqual([set1 hash], [set2 hash]); 70 71 // Fixed32 72 73 field1 = [[[GPBUnknownField alloc] initWithNumber:2] autorelease]; 74 [field1 addFixed32:2]; 75 [set1 addField:field1]; 76 XCTAssertNotEqualObjects(set1, set2); 77 field2 = [[[GPBUnknownField alloc] initWithNumber:2] autorelease]; 78 [field2 addFixed32:2]; 79 [set2 addField:field2]; 80 XCTAssertEqualObjects(set1, set2); 81 XCTAssertEqual([set1 hash], [set2 hash]); 82 83 // Fixed64 84 85 field1 = [[[GPBUnknownField alloc] initWithNumber:3] autorelease]; 86 [field1 addFixed64:3]; 87 [set1 addField:field1]; 88 XCTAssertNotEqualObjects(set1, set2); 89 field2 = [[[GPBUnknownField alloc] initWithNumber:3] autorelease]; 90 [field2 addFixed64:3]; 91 [set2 addField:field2]; 92 XCTAssertEqualObjects(set1, set2); 93 XCTAssertEqual([set1 hash], [set2 hash]); 94 95 // LengthDelimited 96 97 field1 = [[[GPBUnknownField alloc] initWithNumber:4] autorelease]; 98 [field1 addLengthDelimited:DataFromCStr("foo")]; 99 [set1 addField:field1]; 100 XCTAssertNotEqualObjects(set1, set2); 101 field2 = [[[GPBUnknownField alloc] initWithNumber:4] autorelease]; 102 [field2 addLengthDelimited:DataFromCStr("foo")]; 103 [set2 addField:field2]; 104 XCTAssertEqualObjects(set1, set2); 105 XCTAssertEqual([set1 hash], [set2 hash]); 106 107 // Group 108 109 GPBUnknownFieldSet* group1 = [[[GPBUnknownFieldSet alloc] init] autorelease]; 110 GPBUnknownField* fieldGroup1 = [[[GPBUnknownField alloc] initWithNumber:10] autorelease]; 111 [fieldGroup1 addVarint:1]; 112 [group1 addField:fieldGroup1]; 113 GPBUnknownFieldSet* group2 = [[[GPBUnknownFieldSet alloc] init] autorelease]; 114 GPBUnknownField* fieldGroup2 = [[[GPBUnknownField alloc] initWithNumber:10] autorelease]; 115 [fieldGroup2 addVarint:1]; 116 [group2 addField:fieldGroup2]; 117 118 field1 = [[[GPBUnknownField alloc] initWithNumber:5] autorelease]; 119 [field1 addGroup:group1]; 120 [set1 addField:field1]; 121 XCTAssertNotEqualObjects(set1, set2); 122 field2 = [[[GPBUnknownField alloc] initWithNumber:5] autorelease]; 123 [field2 addGroup:group2]; 124 [set2 addField:field2]; 125 XCTAssertEqualObjects(set1, set2); 126 XCTAssertEqual([set1 hash], [set2 hash]); 127 128 // Exercise description for completeness. 129 XCTAssertTrue(set1.description.length > 10); 130} 131 132// Constructs a protocol buffer which contains fields with all the same 133// numbers as allFieldsData except that each field is some other wire 134// type. 135- (NSData*)getBizarroData { 136 GPBUnknownFieldSet* bizarroFields = [[[GPBUnknownFieldSet alloc] init] autorelease]; 137 NSUInteger count = [unknownFields_ countOfFields]; 138 int32_t* tags = malloc(count * sizeof(int32_t)); 139 if (!tags) { 140 XCTFail(@"Failed to make scratch buffer for testing"); 141 return [NSData data]; 142 } 143 @try { 144 [unknownFields_ getTags:tags]; 145 for (NSUInteger i = 0; i < count; ++i) { 146 int32_t tag = tags[i]; 147 GPBUnknownField* field = [unknownFields_ getField:tag]; 148 if (field.varintList.count == 0) { 149 // Original field is not a varint, so use a varint. 150 GPBUnknownField* varintField = [[[GPBUnknownField alloc] initWithNumber:tag] autorelease]; 151 [varintField addVarint:1]; 152 [bizarroFields addField:varintField]; 153 } else { 154 // Original field *is* a varint, so use something else. 155 GPBUnknownField* fixed32Field = [[[GPBUnknownField alloc] initWithNumber:tag] autorelease]; 156 [fixed32Field addFixed32:1]; 157 [bizarroFields addField:fixed32Field]; 158 } 159 } 160 } @finally { 161 free(tags); 162 } 163 164 return [bizarroFields data]; 165} 166 167- (void)testSerialize { 168 // Check that serializing the UnknownFieldSet produces the original data 169 // again. 170 NSData* data = [emptyMessage_ data]; 171 XCTAssertEqualObjects(allFieldsData_, data); 172} 173 174- (void)testCopyFrom { 175 TestEmptyMessage* message = [TestEmptyMessage message]; 176 [message mergeFrom:emptyMessage_]; 177 178 XCTAssertEqualObjects(emptyMessage_.data, message.data); 179} 180 181- (void)testMergeFrom { 182 GPBUnknownFieldSet* set1 = [[[GPBUnknownFieldSet alloc] init] autorelease]; 183 GPBUnknownField* field = [[[GPBUnknownField alloc] initWithNumber:2] autorelease]; 184 [field addVarint:2]; 185 [set1 addField:field]; 186 field = [[[GPBUnknownField alloc] initWithNumber:3] autorelease]; 187 [field addVarint:4]; 188 [set1 addField:field]; 189 field = [[[GPBUnknownField alloc] initWithNumber:4] autorelease]; 190 [field addFixed32:6]; 191 [set1 addField:field]; 192 field = [[[GPBUnknownField alloc] initWithNumber:5] autorelease]; 193 [field addFixed64:20]; 194 [set1 addField:field]; 195 field = [[[GPBUnknownField alloc] initWithNumber:10] autorelease]; 196 [field addLengthDelimited:DataFromCStr("data1")]; 197 [set1 addField:field]; 198 199 GPBUnknownFieldSet* group1 = [[[GPBUnknownFieldSet alloc] init] autorelease]; 200 GPBUnknownField* fieldGroup1 = [[[GPBUnknownField alloc] initWithNumber:200] autorelease]; 201 [fieldGroup1 addVarint:100]; 202 [group1 addField:fieldGroup1]; 203 204 field = [[[GPBUnknownField alloc] initWithNumber:11] autorelease]; 205 [field addGroup:group1]; 206 [set1 addField:field]; 207 208 GPBUnknownFieldSet* set2 = [[[GPBUnknownFieldSet alloc] init] autorelease]; 209 field = [[[GPBUnknownField alloc] initWithNumber:1] autorelease]; 210 [field addVarint:1]; 211 [set2 addField:field]; 212 field = [[[GPBUnknownField alloc] initWithNumber:3] autorelease]; 213 [field addVarint:3]; 214 [set2 addField:field]; 215 field = [[[GPBUnknownField alloc] initWithNumber:4] autorelease]; 216 [field addFixed32:7]; 217 [set2 addField:field]; 218 field = [[[GPBUnknownField alloc] initWithNumber:5] autorelease]; 219 [field addFixed64:30]; 220 [set2 addField:field]; 221 field = [[[GPBUnknownField alloc] initWithNumber:10] autorelease]; 222 [field addLengthDelimited:DataFromCStr("data2")]; 223 [set2 addField:field]; 224 225 GPBUnknownFieldSet* group2 = [[[GPBUnknownFieldSet alloc] init] autorelease]; 226 GPBUnknownField* fieldGroup2 = [[[GPBUnknownField alloc] initWithNumber:201] autorelease]; 227 [fieldGroup2 addVarint:99]; 228 [group2 addField:fieldGroup2]; 229 230 field = [[[GPBUnknownField alloc] initWithNumber:11] autorelease]; 231 [field addGroup:group2]; 232 [set2 addField:field]; 233 234 GPBUnknownFieldSet* set3 = [[[GPBUnknownFieldSet alloc] init] autorelease]; 235 field = [[[GPBUnknownField alloc] initWithNumber:1] autorelease]; 236 [field addVarint:1]; 237 [set3 addField:field]; 238 field = [[[GPBUnknownField alloc] initWithNumber:2] autorelease]; 239 [field addVarint:2]; 240 [set3 addField:field]; 241 field = [[[GPBUnknownField alloc] initWithNumber:3] autorelease]; 242 [field addVarint:4]; 243 [set3 addField:field]; 244 [field addVarint:3]; 245 [set3 addField:field]; 246 field = [[[GPBUnknownField alloc] initWithNumber:4] autorelease]; 247 [field addFixed32:6]; 248 [field addFixed32:7]; 249 [set3 addField:field]; 250 field = [[[GPBUnknownField alloc] initWithNumber:5] autorelease]; 251 [field addFixed64:20]; 252 [field addFixed64:30]; 253 [set3 addField:field]; 254 field = [[[GPBUnknownField alloc] initWithNumber:10] autorelease]; 255 [field addLengthDelimited:DataFromCStr("data1")]; 256 [field addLengthDelimited:DataFromCStr("data2")]; 257 [set3 addField:field]; 258 259 GPBUnknownFieldSet* group3a = [[[GPBUnknownFieldSet alloc] init] autorelease]; 260 GPBUnknownField* fieldGroup3a1 = [[[GPBUnknownField alloc] initWithNumber:200] autorelease]; 261 [fieldGroup3a1 addVarint:100]; 262 [group3a addField:fieldGroup3a1]; 263 GPBUnknownFieldSet* group3b = [[[GPBUnknownFieldSet alloc] init] autorelease]; 264 GPBUnknownField* fieldGroup3b2 = [[[GPBUnknownField alloc] initWithNumber:201] autorelease]; 265 [fieldGroup3b2 addVarint:99]; 266 [group3b addField:fieldGroup3b2]; 267 268 field = [[[GPBUnknownField alloc] initWithNumber:11] autorelease]; 269 [field addGroup:group1]; 270 [field addGroup:group3b]; 271 [set3 addField:field]; 272 273 TestEmptyMessage* source1 = [TestEmptyMessage message]; 274 [source1 setUnknownFields:set1]; 275 TestEmptyMessage* source2 = [TestEmptyMessage message]; 276 [source2 setUnknownFields:set2]; 277 TestEmptyMessage* source3 = [TestEmptyMessage message]; 278 [source3 setUnknownFields:set3]; 279 280 TestEmptyMessage* destination1 = [TestEmptyMessage message]; 281 [destination1 mergeFrom:source1]; 282 [destination1 mergeFrom:source2]; 283 284 TestEmptyMessage* destination2 = [TestEmptyMessage message]; 285 [destination2 mergeFrom:source3]; 286 287 XCTAssertEqualObjects(destination1.unknownFields, destination2.unknownFields); 288 XCTAssertEqualObjects(destination1.unknownFields, source3.unknownFields); 289 XCTAssertEqualObjects(destination2.unknownFields, source3.unknownFields); 290 291 XCTAssertEqualObjects(destination1.data, destination2.data); 292 XCTAssertEqualObjects(destination1.data, source3.data); 293 XCTAssertEqualObjects(destination2.data, source3.data); 294} 295 296- (void)testClearMessage { 297 TestEmptyMessage* message = [TestEmptyMessage message]; 298 [message mergeFrom:emptyMessage_]; 299 [message clear]; 300 XCTAssertEqual(message.serializedSize, (size_t)0); 301} 302 303- (void)testParseKnownAndUnknown { 304 // Test mixing known and unknown fields when parsing. 305 GPBUnknownFieldSet* fields = [[unknownFields_ copy] autorelease]; 306 GPBUnknownField* field = [[[GPBUnknownField alloc] initWithNumber:123456] autorelease]; 307 [field addVarint:654321]; 308 [fields addField:field]; 309 310 NSData* data = fields.data; 311 TestAllTypes* destination = [TestAllTypes parseFromData:data error:NULL]; 312 313 [self assertAllFieldsSet:destination repeatedCount:kGPBDefaultRepeatCount]; 314 XCTAssertEqual(destination.unknownFields.countOfFields, (NSUInteger)1); 315 316 GPBUnknownField* field2 = [destination.unknownFields getField:123456]; 317 XCTAssertEqual(field2.varintList.count, (NSUInteger)1); 318 XCTAssertEqual(654321ULL, [field2.varintList valueAtIndex:0]); 319} 320 321- (void)testWrongTypeTreatedAsUnknown { 322 // Test that fields of the wrong wire type are treated like unknown fields 323 // when parsing. 324 325 NSData* bizarroData = [self getBizarroData]; 326 TestAllTypes* allTypesMessage = [TestAllTypes parseFromData:bizarroData error:NULL]; 327 TestEmptyMessage* emptyMessage = [TestEmptyMessage parseFromData:bizarroData error:NULL]; 328 329 // All fields should have been interpreted as unknown, so the debug strings 330 // should be the same. 331 XCTAssertEqualObjects(emptyMessage.data, allTypesMessage.data); 332} 333 334- (void)testUnknownExtensions { 335 // Make sure fields are properly parsed to the UnknownFieldSet even when 336 // they are declared as extension numbers. 337 338 TestEmptyMessageWithExtensions* message = 339 [TestEmptyMessageWithExtensions parseFromData:allFieldsData_ error:NULL]; 340 341 XCTAssertEqual(unknownFields_.countOfFields, message.unknownFields.countOfFields); 342 XCTAssertEqualObjects(allFieldsData_, message.data); 343 344 // Just confirm as known extensions, they don't go into unknown data and end up in the 345 // extensions dictionary. 346 TestAllExtensions* allExtensionsMessage = 347 [TestAllExtensions parseFromData:allFieldsData_ 348 extensionRegistry:[UnittestRoot extensionRegistry] 349 error:NULL]; 350 XCTAssertEqual(allExtensionsMessage.unknownFields.countOfFields, (NSUInteger)0); 351 XCTAssertEqualObjects([allExtensionsMessage data], allFieldsData_); 352} 353 354- (void)testWrongExtensionTypeTreatedAsUnknown { 355 // Test that fields of the wrong wire type are treated like unknown fields 356 // when parsing extensions. 357 358 NSData* bizarroData = [self getBizarroData]; 359 TestAllExtensions* allExtensionsMessage = 360 [TestAllExtensions parseFromData:bizarroData 361 extensionRegistry:[UnittestRoot extensionRegistry] 362 error:NULL]; 363 TestEmptyMessage* emptyMessage = [TestEmptyMessage parseFromData:bizarroData error:NULL]; 364 365 // All fields should have been interpreted as unknown, so the debug strings 366 // should be the same. 367 XCTAssertEqualObjects(emptyMessage.data, allExtensionsMessage.data); 368} 369 370- (void)testLargeVarint { 371 GPBUnknownFieldSet* fields = [[unknownFields_ copy] autorelease]; 372 GPBUnknownField* field = [[[GPBUnknownField alloc] initWithNumber:1] autorelease]; 373 [field addVarint:0x7FFFFFFFFFFFFFFFL]; 374 [fields addField:field]; 375 376 NSData* data = [fields data]; 377 378 GPBUnknownFieldSet* parsed = [[[GPBUnknownFieldSet alloc] init] autorelease]; 379 GPBCodedInputStream* input = [[[GPBCodedInputStream alloc] initWithData:data] autorelease]; 380 [parsed mergeFromCodedInputStream:input]; 381 GPBUnknownField* field2 = [parsed getField:1]; 382 XCTAssertEqual(field2.varintList.count, (NSUInteger)1); 383 XCTAssertEqual(0x7FFFFFFFFFFFFFFFULL, [field2.varintList valueAtIndex:0]); 384} 385 386static NSData* DataForGroupsOfDepth(NSUInteger depth) { 387 NSMutableData* data = [NSMutableData dataWithCapacity:0]; 388 389 uint32_t byte = 35; // 35 = 0b100011 -> field 4/start group 390 for (NSUInteger i = 0; i < depth; ++i) { 391 [data appendBytes:&byte length:1]; 392 } 393 394 byte = 8; // 8 = 0b1000, -> field 1/varint 395 [data appendBytes:&byte length:1]; 396 byte = 1; // 1 -> varint value of 1 397 [data appendBytes:&byte length:1]; 398 399 byte = 36; // 36 = 0b100100 -> field 4/end group 400 for (NSUInteger i = 0; i < depth; ++i) { 401 [data appendBytes:&byte length:1]; 402 } 403 return data; 404} 405 406- (void)testParsingNestingGroupData { 407 // 35 = 0b100011 -> field 4/start group 408 // 36 = 0b100100 -> field 4/end group 409 // 43 = 0b101011 -> field 5/end group 410 // 44 = 0b101100 -> field 5/end group 411 // 8 = 0b1000, 1 -> field 1/varint, value of 1 412 // 21 = 0b10101, 0x78, 0x56, 0x34, 0x12 -> field 2/fixed32, value of 0x12345678 413 // 25 = 0b11001, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12 -> field 3/fixed64, 414 // value of 0x123456789abcdef0LL 415 // 50 = 0b110010, 0x0 -> field 6/length delimited, length 0 416 // 50 = 0b110010, 0x1, 42 -> field 6/length delimited, length 1, byte 42 417 // 0 -> field 0 which is invalid/varint 418 // 15 = 0b1111 -> field 1, wire type 7 which is invalid 419 420 TestEmptyMessage* m = [TestEmptyMessage parseFromData:DataFromBytes(35, 36) 421 error:NULL]; // empty group 422 XCTAssertEqual(m.unknownFields.countOfFields, (NSUInteger)1); 423 GPBUnknownField* field = [m.unknownFields getField:4]; 424 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 425 GPBUnknownFieldSet* group = field.groupList[0]; 426 XCTAssertEqual(group.countOfFields, (NSUInteger)0); 427 428 m = [TestEmptyMessage parseFromData:DataFromBytes(35, 8, 1, 36) error:NULL]; // varint 429 XCTAssertEqual(m.unknownFields.countOfFields, (NSUInteger)1); 430 field = [m.unknownFields getField:4]; 431 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 432 group = field.groupList[0]; 433 field = [group getField:1]; 434 XCTAssertEqual(field.varintList.count, (NSUInteger)1); 435 XCTAssertEqual([field.varintList valueAtIndex:0], 1); 436 437 m = [TestEmptyMessage parseFromData:DataFromBytes(35, 21, 0x78, 0x56, 0x34, 0x12, 36) 438 error:NULL]; // fixed32 439 XCTAssertEqual(m.unknownFields.countOfFields, (NSUInteger)1); 440 field = [m.unknownFields getField:4]; 441 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 442 group = field.groupList[0]; 443 field = [group getField:2]; 444 XCTAssertEqual(field.fixed32List.count, (NSUInteger)1); 445 XCTAssertEqual([field.fixed32List valueAtIndex:0], 0x12345678); 446 447 m = [TestEmptyMessage 448 parseFromData:DataFromBytes(35, 25, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12, 449 36) 450 error:NULL]; // fixed64 451 XCTAssertEqual(m.unknownFields.countOfFields, (NSUInteger)1); 452 field = [m.unknownFields getField:4]; 453 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 454 group = field.groupList[0]; 455 field = [group getField:3]; 456 XCTAssertEqual(field.fixed64List.count, (NSUInteger)1); 457 XCTAssertEqual([field.fixed64List valueAtIndex:0], 0x123456789abcdef0LL); 458 459 m = [TestEmptyMessage parseFromData:DataFromBytes(35, 50, 0, 36) 460 error:NULL]; // length delimited, length 0 461 XCTAssertEqual(m.unknownFields.countOfFields, (NSUInteger)1); 462 field = [m.unknownFields getField:4]; 463 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 464 group = field.groupList[0]; 465 field = [group getField:6]; 466 XCTAssertEqual(field.lengthDelimitedList.count, (NSUInteger)1); 467 XCTAssertEqualObjects(field.lengthDelimitedList[0], [NSData data]); 468 469 m = [TestEmptyMessage parseFromData:DataFromBytes(35, 50, 1, 42, 36) 470 error:NULL]; // length delimited, length 1, byte 42 471 XCTAssertEqual(m.unknownFields.countOfFields, (NSUInteger)1); 472 field = [m.unknownFields getField:4]; 473 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 474 group = field.groupList[0]; 475 field = [group getField:6]; 476 XCTAssertEqual(field.lengthDelimitedList.count, (NSUInteger)1); 477 XCTAssertEqualObjects(field.lengthDelimitedList[0], DataFromBytes(42)); 478 479 m = [TestEmptyMessage parseFromData:DataFromBytes(35, 43, 44, 36) error:NULL]; // Sub group 480 field = [m.unknownFields getField:4]; 481 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 482 group = field.groupList[0]; 483 XCTAssertEqual(group.countOfFields, (NSUInteger)1); 484 field = [group getField:5]; 485 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 486 group = field.groupList[0]; 487 XCTAssertEqual(group.countOfFields, (NSUInteger)0); 488 489 m = [TestEmptyMessage parseFromData:DataFromBytes(35, 8, 1, 43, 8, 2, 44, 36) 490 error:NULL]; // varint and sub group with varint 491 XCTAssertEqual(m.unknownFields.countOfFields, (NSUInteger)1); 492 field = [m.unknownFields getField:4]; 493 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 494 group = field.groupList[0]; 495 XCTAssertEqual(group.countOfFields, (NSUInteger)2); 496 field = [group getField:1]; 497 XCTAssertEqual(field.varintList.count, (NSUInteger)1); 498 XCTAssertEqual([field.varintList valueAtIndex:0], 1); 499 field = [group getField:5]; 500 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 501 group = field.groupList[0]; 502 field = [group getField:1]; 503 XCTAssertEqual(field.varintList.count, (NSUInteger)1); 504 XCTAssertEqual([field.varintList valueAtIndex:0], 2); 505 506 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 0, 36) 507 error:NULL]); // Invalid field number 508 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 15, 36) 509 error:NULL]); // Invalid wire type 510 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 21, 0x78, 0x56, 0x34) 511 error:NULL]); // truncated fixed32 512 XCTAssertNil([TestEmptyMessage 513 parseFromData:DataFromBytes(35, 25, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 514 0x34) 515 error:NULL]); // truncated fixed64 516 517 // Missing end group 518 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35) error:NULL]); 519 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 8, 1) error:NULL]); 520 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 43) error:NULL]); 521 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 43, 8, 1) error:NULL]); 522 523 // Wrong end group 524 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 44) error:NULL]); 525 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 8, 1, 44) error:NULL]); 526 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 43, 36) error:NULL]); 527 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 43, 8, 1, 36) error:NULL]); 528 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 43, 44, 44) error:NULL]); 529 XCTAssertNil([TestEmptyMessage parseFromData:DataFromBytes(35, 43, 8, 1, 44, 44) error:NULL]); 530 531 // This is the same limit as within GPBCodedInputStream. 532 const NSUInteger kDefaultRecursionLimit = 100; 533 // That depth parses. 534 NSData* testData = DataForGroupsOfDepth(kDefaultRecursionLimit); 535 m = [TestEmptyMessage parseFromData:testData error:NULL]; 536 XCTAssertEqual(m.unknownFields.countOfFields, (NSUInteger)1); 537 field = [m.unknownFields getField:4]; 538 for (NSUInteger i = 0; i < kDefaultRecursionLimit; ++i) { 539 XCTAssertEqual(field.varintList.count, (NSUInteger)0); 540 XCTAssertEqual(field.fixed32List.count, (NSUInteger)0); 541 XCTAssertEqual(field.fixed64List.count, (NSUInteger)0); 542 XCTAssertEqual(field.lengthDelimitedList.count, (NSUInteger)0); 543 XCTAssertEqual(field.groupList.count, (NSUInteger)1); 544 group = field.groupList[0]; 545 XCTAssertEqual(group.countOfFields, (NSUInteger)1); 546 field = [group getField:(i < (kDefaultRecursionLimit - 1) ? 4 : 1)]; 547 } 548 // field is of the inner most group 549 XCTAssertEqual(field.varintList.count, (NSUInteger)1); 550 XCTAssertEqual([field.varintList valueAtIndex:0], (NSUInteger)1); 551 XCTAssertEqual(field.fixed32List.count, (NSUInteger)0); 552 XCTAssertEqual(field.fixed64List.count, (NSUInteger)0); 553 XCTAssertEqual(field.lengthDelimitedList.count, (NSUInteger)0); 554 XCTAssertEqual(field.groupList.count, (NSUInteger)0); 555 // One more level deep fails. 556 testData = DataForGroupsOfDepth(kDefaultRecursionLimit + 1); 557 XCTAssertNil([TestEmptyMessage parseFromData:testData error:NULL]); 558} 559 560#pragma mark - Field tests 561// Some tests directly on fields since the dictionary in FieldSet can gate 562// testing some of these. 563 564- (void)testFieldEqualityAndHash { 565 GPBUnknownField* field1 = [[[GPBUnknownField alloc] initWithNumber:1] autorelease]; 566 XCTAssertTrue([field1 isEqual:field1]); 567 XCTAssertFalse([field1 isEqual:@"foo"]); 568 GPBUnknownField* field2 = [[[GPBUnknownField alloc] initWithNumber:2] autorelease]; 569 XCTAssertNotEqualObjects(field1, field2); 570 571 field2 = [[[GPBUnknownField alloc] initWithNumber:1] autorelease]; 572 XCTAssertEqualObjects(field1, field2); 573 XCTAssertEqual([field1 hash], [field2 hash]); 574 575 // Varint 576 577 [field1 addVarint:10]; 578 XCTAssertNotEqualObjects(field1, field2); 579 [field2 addVarint:10]; 580 XCTAssertEqualObjects(field1, field2); 581 XCTAssertEqual([field1 hash], [field2 hash]); 582 [field1 addVarint:11]; 583 XCTAssertNotEqualObjects(field1, field2); 584 [field2 addVarint:11]; 585 XCTAssertEqualObjects(field1, field2); 586 XCTAssertEqual([field1 hash], [field2 hash]); 587 588 // Fixed32 589 590 [field1 addFixed32:20]; 591 XCTAssertNotEqualObjects(field1, field2); 592 [field2 addFixed32:20]; 593 XCTAssertEqualObjects(field1, field2); 594 XCTAssertEqual([field1 hash], [field2 hash]); 595 [field1 addFixed32:21]; 596 XCTAssertNotEqualObjects(field1, field2); 597 [field2 addFixed32:21]; 598 XCTAssertEqualObjects(field1, field2); 599 XCTAssertEqual([field1 hash], [field2 hash]); 600 601 // Fixed64 602 603 [field1 addFixed64:30]; 604 XCTAssertNotEqualObjects(field1, field2); 605 [field2 addFixed64:30]; 606 XCTAssertEqualObjects(field1, field2); 607 XCTAssertEqual([field1 hash], [field2 hash]); 608 [field1 addFixed64:31]; 609 XCTAssertNotEqualObjects(field1, field2); 610 [field2 addFixed64:31]; 611 XCTAssertEqualObjects(field1, field2); 612 XCTAssertEqual([field1 hash], [field2 hash]); 613 614 // LengthDelimited 615 616 [field1 addLengthDelimited:DataFromCStr("foo")]; 617 XCTAssertNotEqualObjects(field1, field2); 618 [field2 addLengthDelimited:DataFromCStr("foo")]; 619 XCTAssertEqualObjects(field1, field2); 620 XCTAssertEqual([field1 hash], [field2 hash]); 621 [field1 addLengthDelimited:DataFromCStr("bar")]; 622 XCTAssertNotEqualObjects(field1, field2); 623 [field2 addLengthDelimited:DataFromCStr("bar")]; 624 XCTAssertEqualObjects(field1, field2); 625 XCTAssertEqual([field1 hash], [field2 hash]); 626 627 // Group 628 629 GPBUnknownFieldSet* group = [[[GPBUnknownFieldSet alloc] init] autorelease]; 630 GPBUnknownField* fieldGroup = [[[GPBUnknownField alloc] initWithNumber:100] autorelease]; 631 [fieldGroup addVarint:100]; 632 [group addField:fieldGroup]; 633 [field1 addGroup:group]; 634 XCTAssertNotEqualObjects(field1, field2); 635 group = [[[GPBUnknownFieldSet alloc] init] autorelease]; 636 fieldGroup = [[[GPBUnknownField alloc] initWithNumber:100] autorelease]; 637 [fieldGroup addVarint:100]; 638 [group addField:fieldGroup]; 639 [field2 addGroup:group]; 640 XCTAssertEqualObjects(field1, field2); 641 XCTAssertEqual([field1 hash], [field2 hash]); 642 643 group = [[[GPBUnknownFieldSet alloc] init] autorelease]; 644 fieldGroup = [[[GPBUnknownField alloc] initWithNumber:101] autorelease]; 645 [fieldGroup addVarint:101]; 646 [group addField:fieldGroup]; 647 [field1 addGroup:group]; 648 XCTAssertNotEqualObjects(field1, field2); 649 group = [[[GPBUnknownFieldSet alloc] init] autorelease]; 650 fieldGroup = [[[GPBUnknownField alloc] initWithNumber:101] autorelease]; 651 [fieldGroup addVarint:101]; 652 [group addField:fieldGroup]; 653 [field2 addGroup:group]; 654 XCTAssertEqualObjects(field1, field2); 655 XCTAssertEqual([field1 hash], [field2 hash]); 656 657 // Exercise description for completeness. 658 XCTAssertTrue(field1.description.length > 10); 659} 660 661- (void)testMergingFields { 662 GPBUnknownField* field1 = [[[GPBUnknownField alloc] initWithNumber:1] autorelease]; 663 [field1 addVarint:1]; 664 [field1 addFixed32:2]; 665 [field1 addFixed64:3]; 666 [field1 addLengthDelimited:[NSData dataWithBytes:"hello" length:5]]; 667 [field1 addGroup:[[unknownFields_ copy] autorelease]]; 668 GPBUnknownField* field2 = [[[GPBUnknownField alloc] initWithNumber:1] autorelease]; 669 [field2 mergeFromField:field1]; 670} 671 672@end 673 674#pragma clang diagnostic pop 675