diff options
Diffstat (limited to 'third_party/protobuf/3.6.0/objectivec/Tests/GPBCodedInputStreamTests.m')
-rw-r--r-- | third_party/protobuf/3.6.0/objectivec/Tests/GPBCodedInputStreamTests.m | 460 |
1 files changed, 460 insertions, 0 deletions
diff --git a/third_party/protobuf/3.6.0/objectivec/Tests/GPBCodedInputStreamTests.m b/third_party/protobuf/3.6.0/objectivec/Tests/GPBCodedInputStreamTests.m new file mode 100644 index 0000000000..f5aa69038f --- /dev/null +++ b/third_party/protobuf/3.6.0/objectivec/Tests/GPBCodedInputStreamTests.m @@ -0,0 +1,460 @@ +// 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 "GPBCodedInputStream.h" +#import "GPBCodedOutputStream.h" +#import "GPBUnknownFieldSet_PackagePrivate.h" +#import "GPBUtilities_PackagePrivate.h" +#import "google/protobuf/Unittest.pbobjc.h" + +@interface CodedInputStreamTests : GPBTestCase +@end + +@implementation CodedInputStreamTests + +- (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)testDecodeZigZag { + [self assertReadZigZag32:bytes(0x0) value:0]; + [self assertReadZigZag32:bytes(0x1) value:-1]; + [self assertReadZigZag32:bytes(0x2) value:1]; + [self assertReadZigZag32:bytes(0x3) value:-2]; + + [self assertReadZigZag32:bytes(0xFE, 0xFF, 0xFF, 0xFF, 0x07) value:(int32_t)0x3FFFFFFF]; + [self assertReadZigZag32:bytes(0xFF, 0xFF, 0xFF, 0xFF, 0x07) value:(int32_t)0xC0000000]; + [self assertReadZigZag32:bytes(0xFE, 0xFF, 0xFF, 0xFF, 0x0F) value:(int32_t)0x7FFFFFFF]; + [self assertReadZigZag32:bytes(0xFF, 0xFF, 0xFF, 0xFF, 0x0F) value:(int32_t)0x80000000]; + + [self assertReadZigZag64:bytes(0x0) value:0]; + [self assertReadZigZag64:bytes(0x1) value:-1]; + [self assertReadZigZag64:bytes(0x2) value:1]; + [self assertReadZigZag64:bytes(0x3) value:-2]; + + [self assertReadZigZag64:bytes(0xFE, 0xFF, 0xFF, 0xFF, 0x07) value:(int32_t)0x3FFFFFFF]; + [self assertReadZigZag64:bytes(0xFF, 0xFF, 0xFF, 0xFF, 0x07) value:(int32_t)0xC0000000]; + [self assertReadZigZag64:bytes(0xFE, 0xFF, 0xFF, 0xFF, 0x0F) value:(int32_t)0x7FFFFFFF]; + [self assertReadZigZag64:bytes(0xFF, 0xFF, 0xFF, 0xFF, 0x0F) value:(int32_t)0x80000000]; + + [self assertReadZigZag64:bytes(0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01) value:0x7FFFFFFFFFFFFFFFL]; + [self assertReadZigZag64:bytes(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01) value:0x8000000000000000L]; +} + +- (void)assertReadVarint:(NSData*)data value:(int64_t)value { + if (value <= INT32_MAX && value >= INT32_MIN) { + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual((int32_t)value, [input readInt32]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual((int32_t)value, [input readEnum]); + } + } + if (value <= UINT32_MAX && value >= 0) { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual((uint32_t)value, [input readUInt32]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value, [input readInt64]); + } + if (value >= 0) { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual((uint64_t)value, [input readUInt64]); + } +} + +- (void)assertReadLittleEndian32:(NSData*)data value:(int32_t)value { + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value, [input readSFixed32]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(GPBConvertInt32ToFloat(value), [input readFloat]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual((uint32_t)value, [input readFixed32]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value, [input readSFixed32]); + } +} + +- (void)assertReadLittleEndian64:(NSData*)data value:(int64_t)value { + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value, [input readSFixed64]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(GPBConvertInt64ToDouble(value), [input readDouble]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual((uint64_t)value, [input readFixed64]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value, [input readSFixed64]); + } +} + +- (void)assertReadZigZag32:(NSData*)data value:(int64_t)value { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual((int32_t)value, [input readSInt32]); +} + +- (void)assertReadZigZag64:(NSData*)data value:(int64_t)value { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value, [input readSInt64]); +} + +- (void)assertReadVarintFailure:(NSData*)data { + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertThrows([input readInt32]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertThrows([input readInt64]); + } +} + +- (void)testBytes { + NSData* data = bytes(0xa2, 0x74); + XCTAssertEqual(data.length, (NSUInteger)2); + XCTAssertEqual(((uint8_t*)data.bytes)[0], (uint8_t)0xa2); + XCTAssertEqual(((uint8_t*)data.bytes)[1], (uint8_t)0x74); +} + +- (void)testReadBool { + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:bytes(0x00)]; + XCTAssertEqual(NO, [input readBool]); + } + { + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:bytes(0x01)]; + XCTAssertEqual(YES, [input readBool]); + } +} + +- (void)testReadVarint { + [self assertReadVarint:bytes(0x00) value:0]; + [self assertReadVarint:bytes(0x01) value:1]; + [self assertReadVarint:bytes(0x7f) value:127]; + // 14882 + [self assertReadVarint:bytes(0xa2, 0x74) value:(0x22 << 0) | (0x74 << 7)]; + // 1904930 + [self assertReadVarint:bytes(0xa2, 0xa2, 0x74) value:(0x22 << 0) | (0x22 << 7) | (0x74 << 14)]; + // 243831074 + [self assertReadVarint:bytes(0xa2, 0xa2, 0xa2, 0x74) + value:(0x22 << 0) | (0x22 << 7) | (0x22 << 14) | (0x74 << 21)]; + // 2961488830 + [self assertReadVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b) + value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | + (0x04 << 21) | (0x0bLL << 28)]; + + // 64-bit + // 7256456126 + [self assertReadVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b) + value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | + (0x04 << 21) | (0x1bLL << 28)]; + // 41256202580718336 + [self assertReadVarint: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)]; + // 11964378330978735131 + [self + assertReadVarint: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)]; + + // Failures + [self assertReadVarintFailure:bytes(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x00)]; + [self assertReadVarintFailure:bytes(0x80)]; +} + +- (void)testReadVarint32FromVarint64 { + { + // Turn on lower 31 bits of the upper half on a 64 bit varint. + NSData* data = bytes(0x80, 0x80, 0x80, 0x80, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E); + + int32_t value32 = 0x0; + GPBCodedInputStream* input32 = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value32, [input32 readInt32]); + + int64_t value64 = INT64_MAX & 0xFFFFFFFF00000000; + GPBCodedInputStream* input64 = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value64, [input64 readInt64]); + } + { + // Turn on lower 31 bits and lower 31 bits on upper half on a 64 bit varint. + NSData* data = bytes(0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E); + + int32_t value32 = INT32_MAX; + GPBCodedInputStream* input32 = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value32, [input32 readInt32]); + + int64_t value64 = INT64_MAX & 0xFFFFFFFF7FFFFFFF; + GPBCodedInputStream* input64 = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value64, [input64 readInt64]); + } + { + // Turn on bits 32 and 64 bit on a 64 bit varint. + NSData* data = bytes(0x80, 0x80, 0x80, 0x80, 0x88, 0x80, 0x80, 0x80, 0x80, 0x01); + + int32_t value32 = INT32_MIN; + GPBCodedInputStream* input32 = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value32, [input32 readInt32]); + + int64_t value64 = INT64_MIN | (0x01LL << 31); + GPBCodedInputStream* input64 = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqual(value64, [input64 readInt64]); + } +} + +- (void)testReadLittleEndian { + [self assertReadLittleEndian32:bytes(0x78, 0x56, 0x34, 0x12) + value:0x12345678]; + [self assertReadLittleEndian32:bytes(0xf0, 0xde, 0xbc, 0x9a) + value:0x9abcdef0]; + + [self assertReadLittleEndian64:bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, + 0x12) + value:0x123456789abcdef0LL]; + [self assertReadLittleEndian64:bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, + 0x9a) + value:0x9abcdef012345678LL]; +} + +- (void)testReadWholeMessage { + TestAllTypes* message = [self allSetRepeatedCount:kGPBDefaultRepeatCount]; + + NSData* rawBytes = message.data; + XCTAssertEqual(message.serializedSize, (size_t)rawBytes.length); + + TestAllTypes* message2 = + [TestAllTypes parseFromData:rawBytes extensionRegistry:nil error:NULL]; + [self assertAllFieldsSet:message2 repeatedCount:kGPBDefaultRepeatCount]; +} + +- (void)testSkipWholeMessage { + TestAllTypes* message = [self allSetRepeatedCount:kGPBDefaultRepeatCount]; + NSData* rawBytes = message.data; + + // Create two parallel inputs. Parse one as unknown fields while using + // skipField() to skip each field on the other. Expect the same tags. + GPBCodedInputStream* input1 = [GPBCodedInputStream streamWithData:rawBytes]; + GPBCodedInputStream* input2 = [GPBCodedInputStream streamWithData:rawBytes]; + GPBUnknownFieldSet* unknownFields = + [[[GPBUnknownFieldSet alloc] init] autorelease]; + + while (YES) { + int32_t tag = [input1 readTag]; + XCTAssertEqual(tag, [input2 readTag]); + if (tag == 0) { + break; + } + [unknownFields mergeFieldFrom:tag input:input1]; + [input2 skipField:tag]; + } +} + +- (void)testReadHugeBlob { + // Allocate and initialize a 1MB blob. + NSMutableData* blob = [NSMutableData dataWithLength:1 << 20]; + for (NSUInteger i = 0; i < blob.length; i++) { + ((uint8_t*)blob.mutableBytes)[i] = (uint8_t)i; + } + + // Make a message containing it. + TestAllTypes* message = [TestAllTypes message]; + [self setAllFields:message repeatedCount:kGPBDefaultRepeatCount]; + [message setOptionalBytes:blob]; + + // Serialize and parse it. Make sure to parse from an InputStream, not + // directly from a ByteString, so that CodedInputStream uses buffered + // reading. + NSData *messageData = message.data; + XCTAssertNotNil(messageData); + GPBCodedInputStream* stream = + [GPBCodedInputStream streamWithData:messageData]; + TestAllTypes* message2 = [TestAllTypes parseFromCodedInputStream:stream + extensionRegistry:nil + error:NULL]; + + XCTAssertEqualObjects(message.optionalBytes, message2.optionalBytes); + + // Make sure all the other fields were parsed correctly. + TestAllTypes* message3 = [[message2 copy] autorelease]; + TestAllTypes* types = [self allSetRepeatedCount:kGPBDefaultRepeatCount]; + NSData* data = [types optionalBytes]; + [message3 setOptionalBytes:data]; + + [self assertAllFieldsSet:message3 repeatedCount:kGPBDefaultRepeatCount]; +} + +- (void)testReadMaliciouslyLargeBlob { + NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; + GPBCodedOutputStream* output = + [GPBCodedOutputStream streamWithOutputStream:rawOutput]; + + int32_t tag = GPBWireFormatMakeTag(1, GPBWireFormatLengthDelimited); + [output writeRawVarint32:tag]; + [output writeRawVarint32:0x7FFFFFFF]; + uint8_t bytes[32] = {0}; + [output writeRawData:[NSData dataWithBytes:bytes length:32]]; + [output flush]; + + NSData* data = + [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; + GPBCodedInputStream* input = + [GPBCodedInputStream streamWithData:[NSMutableData dataWithData:data]]; + XCTAssertEqual(tag, [input readTag]); + + XCTAssertThrows([input readBytes]); +} + +- (void)testReadEmptyString { + NSData *data = bytes(0x00); + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertEqualObjects(@"", [input readString]); +} + +- (void)testInvalidGroupEndTagThrows { + NSData *data = bytes(0x0B, 0x1A, 0x02, 0x4B, 0x50, 0x14); + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + XCTAssertThrowsSpecificNamed([input skipMessage], + NSException, + GPBCodedInputStreamException, + @"should throw a GPBCodedInputStreamException exception "); +} + +- (void)testBytesWithNegativeSize { + NSData *data = bytes(0xFF, 0xFF, 0xFF, 0xFF, 0x0F); + GPBCodedInputStream *input = [GPBCodedInputStream streamWithData:data]; + XCTAssertNil([input readBytes]); +} + +// Verifies fix for b/10315336. +// Note: Now that there isn't a custom string class under the hood, this test +// isn't as critical, but it does cover bad input and if a custom class is added +// again, it will help validate that class' handing of bad utf8. +- (void)testReadMalformedString { + NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; + GPBCodedOutputStream* output = + [GPBCodedOutputStream streamWithOutputStream:rawOutput]; + + int32_t tag = GPBWireFormatMakeTag(TestAllTypes_FieldNumber_DefaultString, + GPBWireFormatLengthDelimited); + [output writeRawVarint32:tag]; + [output writeRawVarint32:5]; + // Create an invalid utf-8 byte array. + uint8_t bytes[] = {0xc2, 0xf2, 0x0, 0x0, 0x0}; + [output writeRawData:[NSData dataWithBytes:bytes length:sizeof(bytes)]]; + [output flush]; + + NSData *data = + [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + NSError *error = nil; + TestAllTypes* message = [TestAllTypes parseFromCodedInputStream:input + extensionRegistry:nil + error:&error]; + XCTAssertNotNil(error); + XCTAssertNil(message); +} + +- (void)testBOMWithinStrings { + // We've seen servers that end up with BOMs within strings (not always at the + // start, and sometimes in multiple places), make sure they always parse + // correctly. (Again, this is inpart incase a custom string class is ever + // used again.) + const char* strs[] = { + "\xEF\xBB\xBF String with BOM", + "String with \xEF\xBB\xBF in middle", + "String with end bom \xEF\xBB\xBF", + "\xEF\xBB\xBF\xe2\x99\xa1", // BOM White Heart + "\xEF\xBB\xBF\xEF\xBB\xBF String with Two BOM", + }; + for (size_t i = 0; i < GPBARRAYSIZE(strs); ++i) { + NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory]; + GPBCodedOutputStream* output = + [GPBCodedOutputStream streamWithOutputStream:rawOutput]; + + int32_t tag = GPBWireFormatMakeTag(TestAllTypes_FieldNumber_DefaultString, + GPBWireFormatLengthDelimited); + [output writeRawVarint32:tag]; + size_t length = strlen(strs[i]); + [output writeRawVarint32:(int32_t)length]; + [output writeRawData:[NSData dataWithBytes:strs[i] length:length]]; + [output flush]; + + NSData* data = + [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey]; + GPBCodedInputStream* input = [GPBCodedInputStream streamWithData:data]; + TestAllTypes* message = [TestAllTypes parseFromCodedInputStream:input + extensionRegistry:nil + error:NULL]; + XCTAssertNotNil(message, @"Loop %zd", i); + // Ensure the string is there. NSString can consume the BOM in some + // cases, so don't actually check the string for exact equality. + XCTAssertTrue(message.defaultString.length > 0, @"Loop %zd", i); + } +} + +@end |