1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc.  All rights reserved.
3// https://developers.google.com/protocol-buffers/
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions are
7// met:
8//
9//     * Redistributions of source code must retain the above copyright
10// notice, this list of conditions and the following disclaimer.
11//     * Redistributions in binary form must reproduce the above
12// copyright notice, this list of conditions and the following disclaimer
13// in the documentation and/or other materials provided with the
14// distribution.
15//     * Neither the name of Google Inc. nor the names of its
16// contributors may be used to endorse or promote products derived from
17// this software without specific prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31#import "GPBTestUtilities.h"
32
33#import "GPBCodedOutputStream_PackagePrivate.h"
34#import "GPBCodedInputStream.h"
35#import "GPBUtilities_PackagePrivate.h"
36#import "google/protobuf/Unittest.pbobjc.h"
37
38@interface GPBCodedOutputStream (InternalMethods)
39// Declared in the .m file, expose for testing.
40- (instancetype)initWithOutputStream:(NSOutputStream *)output
41                                data:(NSMutableData *)data;
42@end
43
44@interface GPBCodedOutputStream (Helper)
45+ (instancetype)streamWithOutputStream:(NSOutputStream *)output
46                            bufferSize:(size_t)bufferSize;
47@end
48
49@implementation GPBCodedOutputStream (Helper)
50+ (instancetype)streamWithOutputStream:(NSOutputStream *)output
51                            bufferSize:(size_t)bufferSize {
52  NSMutableData *data = [NSMutableData dataWithLength:bufferSize];
53  return [[[self alloc] initWithOutputStream:output data:data] autorelease];
54}
55@end
56
57@interface CodedOutputStreamTests : GPBTestCase
58@end
59
60@implementation CodedOutputStreamTests
61
62- (NSData*)bytes_with_sentinel:(int32_t)unused, ... {
63  va_list list;
64  va_start(list, unused);
65
66  NSMutableData* values = [NSMutableData dataWithCapacity:0];
67  int32_t i;
68
69  while ((i = va_arg(list, int32_t)) != 256) {
70    NSAssert(i >= 0 && i < 256, @"");
71    uint8_t u = (uint8_t)i;
72    [values appendBytes:&u length:1];
73  }
74
75  va_end(list);
76
77  return values;
78}
79
80#define bytes(...) [self bytes_with_sentinel:0, __VA_ARGS__, 256]
81
82- (void)assertWriteLittleEndian32:(NSData*)data value:(int32_t)value {
83  NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory];
84  GPBCodedOutputStream* output =
85      [GPBCodedOutputStream streamWithOutputStream:rawOutput];
86  [output writeRawLittleEndian32:(int32_t)value];
87  [output flush];
88
89  NSData* actual =
90      [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
97                                               bufferSize:blockSize];
98    [output writeRawLittleEndian32:(int32_t)value];
99    [output flush];
100
101    actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey];
102    XCTAssertEqualObjects(data, actual);
103  }
104}
105
106- (void)assertWriteLittleEndian64:(NSData*)data value:(int64_t)value {
107  NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory];
108  GPBCodedOutputStream* output =
109      [GPBCodedOutputStream streamWithOutputStream:rawOutput];
110  [output writeRawLittleEndian64:value];
111  [output flush];
112
113  NSData* actual =
114      [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey];
115  XCTAssertEqualObjects(data, actual);
116
117  // Try different block sizes.
118  for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
119    rawOutput = [NSOutputStream outputStreamToMemory];
120    output = [GPBCodedOutputStream streamWithOutputStream:rawOutput
121                                               bufferSize:blockSize];
122    [output writeRawLittleEndian64:value];
123    [output flush];
124
125    actual = [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey];
126    XCTAssertEqualObjects(data, actual);
127  }
128}
129
130- (void)assertWriteVarint:(NSData*)data value:(int64_t)value {
131  // Only do 32-bit write if the value fits in 32 bits.
132  if (GPBLogicalRightShift64(value, 32) == 0) {
133    NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory];
134    GPBCodedOutputStream* output =
135        [GPBCodedOutputStream streamWithOutputStream:rawOutput];
136    [output writeRawVarint32:(int32_t)value];
137    [output flush];
138
139    NSData* actual =
140        [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey];
141    XCTAssertEqualObjects(data, actual);
142
143    // Also try computing size.
144    XCTAssertEqual(GPBComputeRawVarint32Size((int32_t)value),
145                   (size_t)data.length);
146  }
147
148  {
149    NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory];
150    GPBCodedOutputStream* output =
151        [GPBCodedOutputStream streamWithOutputStream:rawOutput];
152    [output writeRawVarint64:value];
153    [output flush];
154
155    NSData* actual =
156        [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey];
157    XCTAssertEqualObjects(data, actual);
158
159    // Also try computing size.
160    XCTAssertEqual(GPBComputeRawVarint64Size(value), (size_t)data.length);
161  }
162
163  // Try different block sizes.
164  for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
165    // Only do 32-bit write if the value fits in 32 bits.
166    if (GPBLogicalRightShift64(value, 32) == 0) {
167      NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory];
168      GPBCodedOutputStream* output =
169          [GPBCodedOutputStream streamWithOutputStream:rawOutput
170                                            bufferSize:blockSize];
171
172      [output writeRawVarint32:(int32_t)value];
173      [output flush];
174
175      NSData* actual =
176          [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey];
177      XCTAssertEqualObjects(data, actual);
178    }
179
180    {
181      NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory];
182      GPBCodedOutputStream* output =
183          [GPBCodedOutputStream streamWithOutputStream:rawOutput
184                                            bufferSize:blockSize];
185
186      [output writeRawVarint64:value];
187      [output flush];
188
189      NSData* actual =
190          [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey];
191      XCTAssertEqualObjects(data, actual);
192    }
193  }
194}
195
196- (void)testWriteVarint1 {
197  [self assertWriteVarint:bytes(0x00) value:0];
198}
199
200- (void)testWriteVarint2 {
201  [self assertWriteVarint:bytes(0x01) value:1];
202}
203
204- (void)testWriteVarint3 {
205  [self assertWriteVarint:bytes(0x7f) value:127];
206}
207
208- (void)testWriteVarint4 {
209  // 14882
210  [self assertWriteVarint:bytes(0xa2, 0x74) value:(0x22 << 0) | (0x74 << 7)];
211}
212
213- (void)testWriteVarint5 {
214  // 2961488830
215  [self assertWriteVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b)
216                    value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) |
217                          (0x04 << 21) | (0x0bLL << 28)];
218}
219
220- (void)testWriteVarint6 {
221  // 64-bit
222  // 7256456126
223  [self assertWriteVarint:bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b)
224                    value:(0x3e << 0) | (0x77 << 7) | (0x12 << 14) |
225                          (0x04 << 21) | (0x1bLL << 28)];
226}
227
228- (void)testWriteVarint7 {
229  // 41256202580718336
230  [self assertWriteVarint:bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49)
231                    value:(0x00 << 0) | (0x66 << 7) | (0x6b << 14) |
232                          (0x1c << 21) | (0x43LL << 28) | (0x49LL << 35) |
233                          (0x24LL << 42) | (0x49LL << 49)];
234}
235
236- (void)testWriteVarint8 {
237  // 11964378330978735131
238  [self assertWriteVarint:bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85,
239                                0xa6, 0x01)
240                    value:(0x1b << 0) | (0x28 << 7) | (0x79 << 14) |
241                          (0x42 << 21) | (0x3bLL << 28) | (0x56LL << 35) |
242                          (0x00LL << 42) | (0x05LL << 49) | (0x26LL << 56) |
243                          (0x01LL << 63)];
244}
245
246- (void)testWriteLittleEndian {
247  [self assertWriteLittleEndian32:bytes(0x78, 0x56, 0x34, 0x12)
248                            value:0x12345678];
249  [self assertWriteLittleEndian32:bytes(0xf0, 0xde, 0xbc, 0x9a)
250                            value:0x9abcdef0];
251
252  [self assertWriteLittleEndian64:bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56,
253                                        0x34, 0x12)
254                            value:0x123456789abcdef0LL];
255  [self assertWriteLittleEndian64:bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde,
256                                        0xbc, 0x9a)
257                            value:0x9abcdef012345678LL];
258}
259
260- (void)testEncodeZigZag {
261  XCTAssertEqual(0U, GPBEncodeZigZag32(0));
262  XCTAssertEqual(1U, GPBEncodeZigZag32(-1));
263  XCTAssertEqual(2U, GPBEncodeZigZag32(1));
264  XCTAssertEqual(3U, GPBEncodeZigZag32(-2));
265  XCTAssertEqual(0x7FFFFFFEU, GPBEncodeZigZag32(0x3FFFFFFF));
266  XCTAssertEqual(0x7FFFFFFFU, GPBEncodeZigZag32(0xC0000000));
267  XCTAssertEqual(0xFFFFFFFEU, GPBEncodeZigZag32(0x7FFFFFFF));
268  XCTAssertEqual(0xFFFFFFFFU, GPBEncodeZigZag32(0x80000000));
269
270  XCTAssertEqual(0ULL, GPBEncodeZigZag64(0));
271  XCTAssertEqual(1ULL, GPBEncodeZigZag64(-1));
272  XCTAssertEqual(2ULL, GPBEncodeZigZag64(1));
273  XCTAssertEqual(3ULL, GPBEncodeZigZag64(-2));
274  XCTAssertEqual(0x000000007FFFFFFEULL,
275                 GPBEncodeZigZag64(0x000000003FFFFFFFLL));
276  XCTAssertEqual(0x000000007FFFFFFFULL,
277                 GPBEncodeZigZag64(0xFFFFFFFFC0000000LL));
278  XCTAssertEqual(0x00000000FFFFFFFEULL,
279                 GPBEncodeZigZag64(0x000000007FFFFFFFLL));
280  XCTAssertEqual(0x00000000FFFFFFFFULL,
281                 GPBEncodeZigZag64(0xFFFFFFFF80000000LL));
282  XCTAssertEqual(0xFFFFFFFFFFFFFFFEULL,
283                 GPBEncodeZigZag64(0x7FFFFFFFFFFFFFFFLL));
284  XCTAssertEqual(0xFFFFFFFFFFFFFFFFULL,
285                 GPBEncodeZigZag64(0x8000000000000000LL));
286
287  // Some easier-to-verify round-trip tests.  The inputs (other than 0, 1, -1)
288  // were chosen semi-randomly via keyboard bashing.
289  XCTAssertEqual(0U, GPBEncodeZigZag32(GPBDecodeZigZag32(0)));
290  XCTAssertEqual(1U, GPBEncodeZigZag32(GPBDecodeZigZag32(1)));
291  XCTAssertEqual(-1U, GPBEncodeZigZag32(GPBDecodeZigZag32(-1)));
292  XCTAssertEqual(14927U, GPBEncodeZigZag32(GPBDecodeZigZag32(14927)));
293  XCTAssertEqual(-3612U, GPBEncodeZigZag32(GPBDecodeZigZag32(-3612)));
294
295  XCTAssertEqual(0ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(0)));
296  XCTAssertEqual(1ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(1)));
297  XCTAssertEqual(-1ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(-1)));
298  XCTAssertEqual(14927ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(14927)));
299  XCTAssertEqual(-3612ULL, GPBEncodeZigZag64(GPBDecodeZigZag64(-3612)));
300
301  XCTAssertEqual(856912304801416ULL,
302                 GPBEncodeZigZag64(GPBDecodeZigZag64(856912304801416LL)));
303  XCTAssertEqual(-75123905439571256ULL,
304                 GPBEncodeZigZag64(GPBDecodeZigZag64(-75123905439571256LL)));
305}
306
307- (void)testWriteWholeMessage {
308  // Not kGPBDefaultRepeatCount because we are comparing to a golden master file
309  // that was generated with 2.
310  TestAllTypes* message = [self allSetRepeatedCount:2];
311
312  NSData* rawBytes = message.data;
313  NSData* goldenData =
314      [self getDataFileNamed:@"golden_message" dataToWrite:rawBytes];
315  XCTAssertEqualObjects(rawBytes, goldenData);
316
317  // Try different block sizes.
318  for (int blockSize = 1; blockSize < 256; blockSize *= 2) {
319    NSOutputStream* rawOutput = [NSOutputStream outputStreamToMemory];
320    GPBCodedOutputStream* output =
321        [GPBCodedOutputStream streamWithOutputStream:rawOutput
322                                          bufferSize:blockSize];
323    [message writeToCodedOutputStream:output];
324    [output flush];
325
326    NSData* actual =
327        [rawOutput propertyForKey:NSStreamDataWrittenToMemoryStreamKey];
328    XCTAssertEqualObjects(rawBytes, actual);
329  }
330
331  // Not kGPBDefaultRepeatCount because we are comparing to a golden master file
332  // that was generated with 2.
333  TestAllExtensions* extensions = [self allExtensionsSetRepeatedCount:2];
334  rawBytes = extensions.data;
335  goldenData = [self getDataFileNamed:@"golden_packed_fields_message"
336                          dataToWrite:rawBytes];
337  XCTAssertEqualObjects(rawBytes, goldenData);
338}
339
340@end
341