AuroraMiddleware/protobuf
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity
58d4420e2d
protobuf/objectivec/Tests/GPBCodedOuputStreamTests.m
Thomas Van Lenten b273cba192 Fix enum writing. 
Enums use varint, so if the value is negative it should end up being longer.

This was caught my new conformance test cases.
2019-08-26 17:17:32 -04:00

445 lines
17 KiB
Objective-C
Raw Blame History

// 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 beind 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<NSString *> *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
Reference in New Issue View Git Blame Copy Permalink