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 "GPBCodedInputStream.h" 9#import "GPBCodedOutputStream.h" 10#import "GPBCodedOutputStream_PackagePrivate.h" 11#import "GPBTestUtilities.h" 12#import "GPBUtilities.h" 13#import "GPBUtilities_PackagePrivate.h" 14#import "objectivec/Tests/Unittest.pbobjc.h" 15 16@interface GPBCodedOutputStream (InternalMethods) 17// Declared in the .m file, expose for testing. 18- (instancetype)initWithOutputStream:(NSOutputStream*)output data:(NSMutableData*)data; 19@end 20 21@interface GPBCodedOutputStream (Helper) 22+ (instancetype)streamWithOutputStream:(NSOutputStream*)output bufferSize:(size_t)bufferSize; 23@end 24 25@implementation GPBCodedOutputStream (Helper) 26+ (instancetype)streamWithOutputStream:(NSOutputStream*)output bufferSize:(size_t)bufferSize { 27 NSMutableData* data = [NSMutableData dataWithLength:bufferSize]; 28 return [[[self alloc] initWithOutputStream:output data:data] autorelease]; 29} 30@end 31 32@interface CodedOutputStreamTests : GPBTestCase 33@end 34 35@implementation CodedOutputStreamTests 36 37- (NSData*)bytes_with_sentinel:(int32_t)unused, ... { 38 va_list list; 39 va_start(list, unused); 40 41 NSMutableData* values = [NSMutableData dataWithCapacity:0]; 42 int32_t i; 43 44 while ((i = va_arg(list, int32_t)) != 256) { 45 NSAssert(i >= 0 && i < 256, @""); 46 uint8_t u = (uint8_t)i; 47 [values appendBytes:&u length:1]; 48 } 49 50 va_end(list); 51 52 return values; 53} 54 55#define bytes(...) [self bytes_with_sentinel:0, __VA_ARGS__, 256] 56 57- (void)assertWriteLittleEndian32:(NSData*)data value:(int32_t)value { 58 NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; 59 GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; 60 [output writeRawLittleEndian32:(int32_t)value]; 61 XCTAssertEqual(output.bytesWritten, data.length); 62 [output flush]; 63 XCTAssertEqual(output.bytesWritten, data.length); 64 65 NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 66 XCTAssertEqualObjects(data, actual); 67 68 // Try different block sizes. 69 for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { 70 rawOutput = [NSOutputStream outputStreamToMemory]; 71 output = [GPBCodedOutputStream streamWithOutputStream:rawOutput bufferSize:blockSize]; 72 [output writeRawLittleEndian32:(int32_t)value]; 73 XCTAssertEqual(output.bytesWritten, data.length); 74 [output flush]; 75 XCTAssertEqual(output.bytesWritten, data.length); 76 77 actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 78 XCTAssertEqualObjects(data, actual); 79 } 80} 81 82- (void)assertWriteLittleEndian64:(NSData*)data value:(int64_t)value { 83 NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; 84 GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; 85 [output writeRawLittleEndian64:value]; 86 XCTAssertEqual(output.bytesWritten, data.length); 87 [output flush]; 88 XCTAssertEqual(output.bytesWritten, data.length); 89 90 NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 91 XCTAssertEqualObjects(data, actual); 92 93 // Try different block sizes. 94 for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { 95 rawOutput = [NSOutputStream outputStreamToMemory]; 96 output = [GPBCodedOutputStream streamWithOutputStream:rawOutput bufferSize:blockSize]; 97 [output writeRawLittleEndian64:value]; 98 XCTAssertEqual(output.bytesWritten, data.length); 99 [output flush]; 100 XCTAssertEqual(output.bytesWritten, data.length); 101 102 actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 103 XCTAssertEqualObjects(data, actual); 104 } 105} 106 107- (void)assertWriteVarint:(NSData*)data value:(int64_t)value { 108 // Only do 32-bit write if the value fits in 32 bits. 109 if (GPBLogicalRightShift64(value, 32) == 0) { 110 NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; 111 GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; 112 [output writeRawVarint32:(int32_t)value]; 113 XCTAssertEqual(output.bytesWritten, data.length); 114 [output flush]; 115 XCTAssertEqual(output.bytesWritten, data.length); 116 117 NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 118 XCTAssertEqualObjects(data, actual); 119 120 // Also try computing size. 121 XCTAssertEqual(GPBComputeRawVarint32Size((int32_t)value), (size_t)data.length); 122 } 123 124 { 125 NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; 126 GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; 127 [output writeRawVarint64:value]; 128 XCTAssertEqual(output.bytesWritten, data.length); 129 [output flush]; 130 XCTAssertEqual(output.bytesWritten, data.length); 131 132 NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 133 XCTAssertEqualObjects(data, actual); 134 135 // Also try computing size. 136 XCTAssertEqual(GPBComputeRawVarint64Size(value), (size_t)data.length); 137 } 138 139 // Try different block sizes. 140 for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { 141 // Only do 32-bit write if the value fits in 32 bits. 142 if (GPBLogicalRightShift64(value, 32) == 0) { 143 NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; 144 GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput 145 bufferSize:blockSize]; 146 147 [output writeRawVarint32:(int32_t)value]; 148 XCTAssertEqual(output.bytesWritten, data.length); 149 [output flush]; 150 XCTAssertEqual(output.bytesWritten, data.length); 151 152 NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 153 XCTAssertEqualObjects(data, actual); 154 } 155 156 { 157 NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; 158 GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput 159 bufferSize:blockSize]; 160 161 [output writeRawVarint64:value]; 162 XCTAssertEqual(output.bytesWritten, data.length); 163 [output flush]; 164 XCTAssertEqual(output.bytesWritten, data.length); 165 166 NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 167 XCTAssertEqualObjects(data, actual); 168 } 169 } 170} 171 172- (void)assertWriteStringNoTag:(NSData*)data 173 value:(NSString*)value 174 context:(NSString*)contextMessage { 175 NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; 176 GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; 177 [output writeStringNoTag:value]; 178 XCTAssertEqual(output.bytesWritten, data.length); 179 [output flush]; 180 XCTAssertEqual(output.bytesWritten, data.length); 181 182 NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 183 XCTAssertEqualObjects(data, actual, @"%@", contextMessage); 184 185 // Try different block sizes. 186 for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { 187 rawOutput = [NSOutputStream outputStreamToMemory]; 188 output = [GPBCodedOutputStream streamWithOutputStream:rawOutput bufferSize:blockSize]; 189 [output writeStringNoTag:value]; 190 XCTAssertEqual(output.bytesWritten, data.length); 191 [output flush]; 192 XCTAssertEqual(output.bytesWritten, data.length); 193 194 actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 195 XCTAssertEqualObjects(data, actual, @"%@", contextMessage); 196 } 197} 198 199- (void)testWriteVarint1 { 200 [self assertWriteVarint:bytes(0x00) value:0]; 201} 202 203- (void)testWriteVarint2 { 204 [self assertWriteVarint:bytes(0x01) value:1]; 205} 206 207- (void)testWriteVarint3 { 208 [self assertWriteVarint:bytes(0x7f) value:127]; 209} 210 211- (void)testWriteVarint4 { 212 // 14882 213 [self assertWriteVarint:bytes(0xa2, 0x74) value:(0x22 << 0) | (0x74 << 7)]; 214} 215 216- (void)testWriteVarint5 { 217 // The sign/nosign distinction is done here because normally varints are 218 // around 64bit values, but for some cases a 32bit value is forced with 219 // with the sign bit (tags, uint32, etc.) 220 221 // 1887747006 (no sign bit) 222 [self assertWriteVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x07) 223 value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | (0x07LL << 28)]; 224 // 2961488830 (sign bit) 225 [self assertWriteVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b) 226 value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | (0x0bLL << 28)]; 227} 228 229- (void)testWriteVarint6 { 230 // 64-bit 231 // 7256456126 232 [self assertWriteVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b) 233 value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | (0x1bLL << 28)]; 234} 235 236- (void)testWriteVarint7 { 237 // 41256202580718336 238 [self assertWriteVarint:bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49) 239 value:(0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) | (0x43LL << 28) | 240 (0x49LL << 35) | (0x24LL << 42) | (0x49LL << 49)]; 241} 242 243- (void)testWriteVarint8 { 244 // 11964378330978735131 245 [self assertWriteVarint:bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01) 246 value:(0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) | (0x3bLL << 28) | 247 (0x56LL << 35) | (0x00LL << 42) | (0x05LL << 49) | (0x26LL << 56) | 248 (0x01ULL << 63)]; 249} 250 251- (void)testWriteLittleEndian { 252 [self assertWriteLittleEndian32:bytes(0x78, 0x56, 0x34, 0x12) value:0x12345678]; 253 [self assertWriteLittleEndian32:bytes(0xf0, 0xde, 0xbc, 0x9a) value:0x9abcdef0]; 254 255 [self assertWriteLittleEndian64:bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12) 256 value:0x123456789abcdef0LL]; 257 [self assertWriteLittleEndian64:bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a) 258 value:0x9abcdef012345678LL]; 259} 260 261- (void)testEncodeZigZag { 262 XCTAssertEqual(0U, GPBEncodeZigZag32(0)); 263 XCTAssertEqual(1U, GPBEncodeZigZag32(-1)); 264 XCTAssertEqual(2U, GPBEncodeZigZag32(1)); 265 XCTAssertEqual(3U, GPBEncodeZigZag32(-2)); 266 XCTAssertEqual(0x7FFFFFFEU, GPBEncodeZigZag32(0x3FFFFFFF)); 267 XCTAssertEqual(0x7FFFFFFFU, GPBEncodeZigZag32(0xC0000000)); 268 XCTAssertEqual(0xFFFFFFFEU, GPBEncodeZigZag32(0x7FFFFFFF)); 269 XCTAssertEqual(0xFFFFFFFFU, GPBEncodeZigZag32(0x80000000)); 270 271 XCTAssertEqual(0ULL, GPBEncodeZigZag64(0)); 272 XCTAssertEqual(1ULL, GPBEncodeZigZag64(-1)); 273 XCTAssertEqual(2ULL, GPBEncodeZigZag64(1)); 274 XCTAssertEqual(3ULL, GPBEncodeZigZag64(-2)); 275 XCTAssertEqual(0x000000007FFFFFFEULL, GPBEncodeZigZag64(0x000000003FFFFFFFLL)); 276 XCTAssertEqual(0x000000007FFFFFFFULL, GPBEncodeZigZag64(0xFFFFFFFFC0000000LL)); 277 XCTAssertEqual(0x00000000FFFFFFFEULL, GPBEncodeZigZag64(0x000000007FFFFFFFLL)); 278 XCTAssertEqual(0x00000000FFFFFFFFULL, GPBEncodeZigZag64(0xFFFFFFFF80000000LL)); 279 XCTAssertEqual(0xFFFFFFFFFFFFFFFEULL, GPBEncodeZigZag64(0x7FFFFFFFFFFFFFFFLL)); 280 XCTAssertEqual(0xFFFFFFFFFFFFFFFFULL, GPBEncodeZigZag64(0x8000000000000000LL)); 281 282 // Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1) 283 // were chosen semi-randomly via keyboard bashing. 284 XCTAssertEqual(0U, GPBEncodeZigZag32(GPBDecodeZigZag32(0))); 285 XCTAssertEqual(1U, GPBEncodeZigZag32(GPBDecodeZigZag32(1))); 286 XCTAssertEqual(-1U, GPBEncodeZigZag32(GPBDecodeZigZag32(-1))); 287 XCTAssertEqual(14927U, GPBEncodeZigZag32(GPBDecodeZigZag32(14927))); 288 XCTAssertEqual(-3612U, GPBEncodeZigZag32(GPBDecodeZigZag32(-3612))); 289 290 XCTAssertEqual(0ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(0))); 291 XCTAssertEqual(1ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(1))); 292 XCTAssertEqual(-1ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(-1))); 293 XCTAssertEqual(14927ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(14927))); 294 XCTAssertEqual(-3612ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(-3612))); 295 296 XCTAssertEqual(856912304801416ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(856912304801416LL))); 297 XCTAssertEqual(-75123905439571256ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(-75123905439571256LL))); 298} 299 300- (void)testWriteWholeMessage { 301 // Not kGPBDefaultRepeatCount because we are comparing to a golden master file 302 // that was generated with 2. 303 TestAllTypes* message = [self allSetRepeatedCount:2]; 304 305 NSData* rawBytes = message.data; 306 NSData* goldenData = [self getDataFileNamed:@"golden_message" dataToWrite:rawBytes]; 307 XCTAssertEqualObjects(rawBytes, goldenData); 308 309 // Try different block sizes. 310 for (int blockSize = 1; blockSize < 256; blockSize *= 2) { 311 NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; 312 GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput 313 bufferSize:blockSize]; 314 [message writeToCodedOutputStream:output]; 315 [output flush]; 316 317 NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; 318 XCTAssertEqualObjects(rawBytes, actual); 319 } 320 321 // Not kGPBDefaultRepeatCount because we are comparing to a golden master file 322 // that was generated with 2. 323 TestAllExtensions* extensions = [self allExtensionsSetRepeatedCount:2]; 324 rawBytes = extensions.data; 325 goldenData = [self getDataFileNamed:@"golden_packed_fields_message" dataToWrite:rawBytes]; 326 XCTAssertEqualObjects(rawBytes, goldenData); 327} 328 329- (void)testCFStringGetCStringPtrAndStringsWithNullChars { 330 // This test exists to verify that CFStrings with embedded NULLs still expose 331 // their raw buffer if they are backed by UTF8 storage. If this fails, the 332 // quick/direct access paths in GPBCodedOutputStream that depend on 333 // CFStringGetCStringPtr need to be re-evaluated (maybe just removed). 334 // And yes, we do get NULLs in strings from some servers. 335 336 char zeroTest[] = "\0Test\0String"; 337 // Note: there is a \0 at the end of this since it is a c-string. 338 NSString* asNSString = [[NSString alloc] initWithBytes:zeroTest 339 length:sizeof(zeroTest) 340 encoding:NSUTF8StringEncoding]; 341 const char* cString = CFStringGetCStringPtr((CFStringRef)asNSString, kCFStringEncodingUTF8); 342 XCTAssertTrue(cString != NULL); 343 // Again, if the above assert fails, then it means NSString no longer exposes 344 // the raw utf8 storage of a string created from utf8 input, so the code using 345 // CFStringGetCStringPtr in GPBCodedOutputStream will still work (it will take 346 // a different code path); but the optimizations for when 347 // CFStringGetCStringPtr does work could possibly go away. 348 349 XCTAssertEqual(sizeof(zeroTest), [asNSString lengthOfBytesUsingEncoding:NSUTF8StringEncoding]); 350 XCTAssertTrue(0 == memcmp(cString, zeroTest, sizeof(zeroTest))); 351 [asNSString release]; 352} 353 354- (void)testWriteStringsWithZeroChar { 355 // Unicode allows `\0` as a character, and NSString is a class cluster, so 356 // there are a few different classes that could end up behind a given string. 357 // Historically, we've seen differences based on constant strings in code and 358 // strings built via the NSString apis. So this round trips them to ensure 359 // they are acting as expected. 360 361 NSArray<NSString*>* strs = @[ 362 @"\0at start", 363 @"in\0middle", 364 @"at end\0", 365 ]; 366 int i = 0; 367 for (NSString* str in strs) { 368 NSData* asUTF8 = [str dataUsingEncoding:NSUTF8StringEncoding]; 369 NSMutableData* expected = [NSMutableData data]; 370 uint8_t lengthByte = (uint8_t)asUTF8.length; 371 [expected appendBytes:&lengthByte length:1]; 372 [expected appendData:asUTF8]; 373 374 NSString* context = [NSString stringWithFormat:@"Loop %d - Literal", i]; 375 [self assertWriteStringNoTag:expected value:str context:context]; 376 377 // Force a new string to be built which gets a different class from the 378 // NSString class cluster than the literal did. 379 NSString* str2 = [NSString stringWithFormat:@"%@", str]; 380 context = [NSString stringWithFormat:@"Loop %d - Built", i]; 381 [self assertWriteStringNoTag:expected value:str2 context:context]; 382 383 ++i; 384 } 385} 386 387- (void)testThatItThrowsWhenWriteRawPtrFails { 388 NSOutputStream* output = [NSOutputStream outputStreamToMemory]; 389 GPBCodedOutputStream* codedOutput = 390 [GPBCodedOutputStream streamWithOutputStream:output bufferSize:0]; // Skip buffering. 391 [output close]; // Close the output stream to force failure on write. 392 const char* cString = "raw"; 393 XCTAssertThrowsSpecificNamed([codedOutput writeRawPtr:cString offset:0 length:strlen(cString)], 394 NSException, GPBCodedOutputStreamException_WriteFailed); 395} 396 397- (void)testThatDeallocNeverThrows { 398 uint8_t buffer[1] = {0}; 399 400 // Output stream which can write precisely 1 byte of data before it's full. 401 NSOutputStream* output = [[[NSOutputStream alloc] initToBuffer:buffer 402 capacity:sizeof(buffer)] autorelease]; 403 404 NSMutableData* outputBuffer = [NSMutableData data]; 405 GPBCodedOutputStream* codedOutput = 406 [[GPBCodedOutputStream alloc] initWithOutputStream:output data:outputBuffer]; 407 408 [codedOutput writeRawByte:0x23]; 409 [codedOutput flush]; 410 411 // Put one more byte in the output buffer. 412 [codedOutput writeRawByte:0x42]; 413 XCTAssertThrowsSpecificNamed([codedOutput flush], NSException, 414 GPBCodedOutputStreamException_WriteFailed); 415 416 // -dealloc must not throw when it flushes, even if a previous flush failed. 417 XCTAssertNoThrow([codedOutput release]); 418} 419 420@end 421