| // 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)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 { |
| // 2961488830 |
| [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) | |
| (0x01LL << 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); |
| } |
| |
| @end |