// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #import "GPBTestUtilities.h" #import "GPBCodedOutputStream_PackagePrivate.h" #import "GPBCodedInputStream.h" #import "GPBUtilities_PackagePrivate.h" #import "google/protobuf/Unittest.pbobjc.h" @interface GPBCodedOutputStream (InternalMethods) // Declared in the .m file, expose for testing. - (instancetype)initWithOutputStream:(NSOutputStream *)output data:(NSMutableData *)data; @end @interface GPBCodedOutputStream (Helper) + (instancetype)streamWithOutputStream:(NSOutputStream *)output bufferSize:(size_t)bufferSize; @end @implementation GPBCodedOutputStream (Helper) + (instancetype)streamWithOutputStream:(NSOutputStream *)output bufferSize:(size_t)bufferSize { NSMutableData *data = [NSMutableData dataWithLength:bufferSize]; return [[[self alloc] initWithOutputStream:output data:data] autorelease]; } @end @interface CodedOutputStreamTests : GPBTestCase @end @implementation CodedOutputStreamTests - (NSData*)bytes_with_sentinel:(int32_t)unused, ... { va_list list; va_start(list, unused); NSMutableData* values = [NSMutableData dataWithCapacity:0]; int32_t i; while ((i = va_arg(list, int32_t)) != 256) { NSAssert(i >= 0 && i < 256, @""); uint8_t u = (uint8_t)i; [values appendBytes:&u length:1]; } va_end(list); return values; } #define bytes(...) [self bytes_with_sentinel:0, __VA_ARGS__, 256] - (void)assertWriteLittleEndian32:(NSData*)data value:(int32_t)value { NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; [output writeRawLittleEndian32:(int32_t)value]; [output flush]; NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual); // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { rawOutput = [NSOutputStream outputStreamToMemory]; output = [GPBCodedOutputStream streamWithOutputStream:rawOutput bufferSize:blockSize]; [output writeRawLittleEndian32:(int32_t)value]; [output flush]; actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual); } } - (void)assertWriteLittleEndian64:(NSData*)data value:(int64_t)value { NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; [output writeRawLittleEndian64:value]; [output flush]; NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual); // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { rawOutput = [NSOutputStream outputStreamToMemory]; output = [GPBCodedOutputStream streamWithOutputStream:rawOutput bufferSize:blockSize]; [output writeRawLittleEndian64:value]; [output flush]; actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual); } } - (void)assertWriteVarint:(NSData*)data value:(int64_t)value { // Only do 32-bit write if the value fits in 32 bits. if (GPBLogicalRightShift64(value, 32) == 0) { NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; [output writeRawVarint32:(int32_t)value]; [output flush]; NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual); // Also try computing size. XCTAssertEqual(GPBComputeRawVarint32Size((int32_t)value), (size_t)data.length); } { NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; [output writeRawVarint64:value]; [output flush]; NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual); // Also try computing size. XCTAssertEqual(GPBComputeRawVarint64Size(value), (size_t)data.length); } // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { // Only do 32-bit write if the value fits in 32 bits. if (GPBLogicalRightShift64(value, 32) == 0) { NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput bufferSize:blockSize]; [output writeRawVarint32:(int32_t)value]; [output flush]; NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual); } { NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput bufferSize:blockSize]; [output writeRawVarint64:value]; [output flush]; NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual); } } } - (void)assertWriteStringNoTag:(NSData*)data value:(NSString *)value context:(NSString *)contextMessage { NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput]; [output writeStringNoTag:value]; [output flush]; NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual, @"%@", contextMessage); // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { rawOutput = [NSOutputStream outputStreamToMemory]; output = [GPBCodedOutputStream streamWithOutputStream:rawOutput bufferSize:blockSize]; [output writeStringNoTag:value]; [output flush]; actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(data, actual, @"%@", contextMessage); } } - (void)testWriteVarint1 { [self assertWriteVarint:bytes(0x00) value:0]; } - (void)testWriteVarint2 { [self assertWriteVarint:bytes(0x01) value:1]; } - (void)testWriteVarint3 { [self assertWriteVarint:bytes(0x7f) value:127]; } - (void)testWriteVarint4 { // 14882 [self assertWriteVarint:bytes(0xa2, 0x74) value:(0x22 << 0) | (0x74 << 7)]; } - (void)testWriteVarint5 { // The sign/nosign distinction is done here because normally varints are // around 64bit values, but for some cases a 32bit value is forced with // with the sign bit (tags, uint32, etc.) // 1887747006 (no sign bit) [self assertWriteVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x07) value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | (0x07LL << 28)]; // 2961488830 (sign bit) [self assertWriteVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b) value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | (0x0bLL << 28)]; } - (void)testWriteVarint6 { // 64-bit // 7256456126 [self assertWriteVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b) value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | (0x1bLL << 28)]; } - (void)testWriteVarint7 { // 41256202580718336 [self assertWriteVarint:bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49) value:(0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) | (0x43LL << 28) | (0x49LL << 35) | (0x24LL << 42) | (0x49LL << 49)]; } - (void)testWriteVarint8 { // 11964378330978735131 [self assertWriteVarint:bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01) value:(0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) | (0x3bLL << 28) | (0x56LL << 35) | (0x00LL << 42) | (0x05LL << 49) | (0x26LL << 56) | (0x01ULL << 63)]; } - (void)testWriteLittleEndian { [self assertWriteLittleEndian32:bytes(0x78, 0x56, 0x34, 0x12) value:0x12345678]; [self assertWriteLittleEndian32:bytes(0xf0, 0xde, 0xbc, 0x9a) value:0x9abcdef0]; [self assertWriteLittleEndian64:bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12) value:0x123456789abcdef0LL]; [self assertWriteLittleEndian64:bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a) value:0x9abcdef012345678LL]; } - (void)testEncodeZigZag { XCTAssertEqual(0U, GPBEncodeZigZag32(0)); XCTAssertEqual(1U, GPBEncodeZigZag32(-1)); XCTAssertEqual(2U, GPBEncodeZigZag32(1)); XCTAssertEqual(3U, GPBEncodeZigZag32(-2)); XCTAssertEqual(0x7FFFFFFEU, GPBEncodeZigZag32(0x3FFFFFFF)); XCTAssertEqual(0x7FFFFFFFU, GPBEncodeZigZag32(0xC0000000)); XCTAssertEqual(0xFFFFFFFEU, GPBEncodeZigZag32(0x7FFFFFFF)); XCTAssertEqual(0xFFFFFFFFU, GPBEncodeZigZag32(0x80000000)); XCTAssertEqual(0ULL, GPBEncodeZigZag64(0)); XCTAssertEqual(1ULL, GPBEncodeZigZag64(-1)); XCTAssertEqual(2ULL, GPBEncodeZigZag64(1)); XCTAssertEqual(3ULL, GPBEncodeZigZag64(-2)); XCTAssertEqual(0x000000007FFFFFFEULL, GPBEncodeZigZag64(0x000000003FFFFFFFLL)); XCTAssertEqual(0x000000007FFFFFFFULL, GPBEncodeZigZag64(0xFFFFFFFFC0000000LL)); XCTAssertEqual(0x00000000FFFFFFFEULL, GPBEncodeZigZag64(0x000000007FFFFFFFLL)); XCTAssertEqual(0x00000000FFFFFFFFULL, GPBEncodeZigZag64(0xFFFFFFFF80000000LL)); XCTAssertEqual(0xFFFFFFFFFFFFFFFEULL, GPBEncodeZigZag64(0x7FFFFFFFFFFFFFFFLL)); XCTAssertEqual(0xFFFFFFFFFFFFFFFFULL, GPBEncodeZigZag64(0x8000000000000000LL)); // Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1) // were chosen semi-randomly via keyboard bashing. XCTAssertEqual(0U, GPBEncodeZigZag32(GPBDecodeZigZag32(0))); XCTAssertEqual(1U, GPBEncodeZigZag32(GPBDecodeZigZag32(1))); XCTAssertEqual(-1U, GPBEncodeZigZag32(GPBDecodeZigZag32(-1))); XCTAssertEqual(14927U, GPBEncodeZigZag32(GPBDecodeZigZag32(14927))); XCTAssertEqual(-3612U, GPBEncodeZigZag32(GPBDecodeZigZag32(-3612))); XCTAssertEqual(0ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(0))); XCTAssertEqual(1ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(1))); XCTAssertEqual(-1ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(-1))); XCTAssertEqual(14927ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(14927))); XCTAssertEqual(-3612ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(-3612))); XCTAssertEqual(856912304801416ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(856912304801416LL))); XCTAssertEqual(-75123905439571256ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(-75123905439571256LL))); } - (void)testWriteWholeMessage { // Not kGPBDefaultRepeatCount because we are comparing to a golden master file // that was generated with 2. TestAllTypes* message = [self allSetRepeatedCount:2]; NSData* rawBytes = message.data; NSData* goldenData = [self getDataFileNamed:@"golden_message" dataToWrite:rawBytes]; XCTAssertEqualObjects(rawBytes, goldenData); // Try different block sizes. for (int blockSize = 1; blockSize < 256; blockSize *= 2) { NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; GPBCodedOutputStream* output = [GPBCodedOutputStream streamWithOutputStream:rawOutput bufferSize:blockSize]; [message writeToCodedOutputStream:output]; [output flush]; NSData* actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; XCTAssertEqualObjects(rawBytes, actual); } // Not kGPBDefaultRepeatCount because we are comparing to a golden master file // that was generated with 2. TestAllExtensions* extensions = [self allExtensionsSetRepeatedCount:2]; rawBytes = extensions.data; goldenData = [self getDataFileNamed:@"golden_packed_fields_message" dataToWrite:rawBytes]; XCTAssertEqualObjects(rawBytes, goldenData); } - (void)testCFStringGetCStringPtrAndStringsWithNullChars { // This test exists to verify that CFStrings with embedded NULLs still expose // their raw buffer if they are backed by UTF8 storage. If this fails, the // quick/direct access paths in GPBCodedOutputStream that depend on // CFStringGetCStringPtr need to be re-evalutated (maybe just removed). // And yes, we do get NULLs in strings from some servers. char zeroTest[] = "\0Test\0String"; // Note: there is a \0 at the end of this since it is a c-string. NSString *asNSString = [[NSString alloc] initWithBytes:zeroTest length:sizeof(zeroTest) encoding:NSUTF8StringEncoding]; const char *cString = CFStringGetCStringPtr((CFStringRef)asNSString, kCFStringEncodingUTF8); XCTAssertTrue(cString != NULL); // Again, if the above assert fails, then it means NSString no longer exposes // the raw utf8 storage of a string created from utf8 input, so the code using // CFStringGetCStringPtr in GPBCodedOutputStream will still work (it will take // a different code path); but the optimizations for when // CFStringGetCStringPtr does work could possibly go away. XCTAssertEqual(sizeof(zeroTest), [asNSString lengthOfBytesUsingEncoding:NSUTF8StringEncoding]); XCTAssertTrue(0 == memcmp(cString, zeroTest, sizeof(zeroTest))); [asNSString release]; } - (void)testWriteStringsWithZeroChar { // Unicode allows `\0` as a character, and NSString is a class cluster, so // there are a few different classes that could end up behind a given string. // Historically, we've seen differences based on constant strings in code and // strings built via the NSString apis. So this round trips them to ensure // they are acting as expected. NSArray *strs = @[ @"\0at start", @"in\0middle", @"at end\0", ]; int i = 0; for (NSString *str in strs) { NSData *asUTF8 = [str dataUsingEncoding:NSUTF8StringEncoding]; NSMutableData *expected = [NSMutableData data]; uint8_t lengthByte = (uint8_t)asUTF8.length; [expected appendBytes:&lengthByte length:1]; [expected appendData:asUTF8]; NSString *context = [NSString stringWithFormat:@"Loop %d - Literal", i]; [self assertWriteStringNoTag:expected value:str context:context]; // Force a new string to be built which gets a different class from the // NSString class cluster than the literal did. NSString *str2 = [NSString stringWithFormat:@"%@", str]; context = [NSString stringWithFormat:@"Loop %d - Built", i]; [self assertWriteStringNoTag:expected value:str2 context:context]; ++i; } } - (void)testThatItThrowsWhenWriteRawPtrFails { NSOutputStream *output = [NSOutputStream outputStreamToMemory]; GPBCodedOutputStream *codedOutput = [GPBCodedOutputStream streamWithOutputStream:output bufferSize:0]; // Skip buffering. [output close]; // Close the output stream to force failure on write. const char *cString = "raw"; XCTAssertThrowsSpecificNamed([codedOutput writeRawPtr:cString offset:0 length:strlen(cString)], NSException, GPBCodedOutputStreamException_WriteFailed); } @end