/core/externals/update-engine/externals/google-toolbox-for-mac/Foundation/GTMNSData+zlibTest.m

http://macfuse.googlecode.com/ · Objective C · 526 lines · 426 code · 41 blank · 59 comment · 11 complexity · bab536d0d57d3e9c02972132f3e9f2a1 MD5 · raw file

  1. //
  2. // GTMNSData+zlibTest.m
  3. //
  4. // Copyright 2007-2008 Google Inc.
  5. //
  6. // Licensed under the Apache License, Version 2.0 (the "License"); you may not
  7. // use this file except in compliance with the License. You may obtain a copy
  8. // of the License at
  9. //
  10. // http://www.apache.org/licenses/LICENSE-2.0
  11. //
  12. // Unless required by applicable law or agreed to in writing, software
  13. // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  14. // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  15. // License for the specific language governing permissions and limitations under
  16. // the License.
  17. //
  18. #import "GTMSenTestCase.h"
  19. #import "GTMUnitTestDevLog.h"
  20. #import "GTMNSData+zlib.h"
  21. #import <stdlib.h> // for randiom/srandomdev
  22. #import <zlib.h>
  23. @interface GTMNSData_zlibTest : GTMTestCase
  24. @end
  25. // NOTE: we don't need to test the actually compressor/inflation (we're using
  26. // zlib, it works), we just need to test our wrapper. So we can use canned
  27. // data, etc. (and yes, when using random data, things once failed because
  28. // we generated a random block of data that was valid compressed data?!)
  29. static unsigned char randomDataLarge[] = {
  30. // openssl rand -rand /dev/random 512 | xxd -i
  31. 0xe1, 0xa6, 0xe2, 0xa2, 0x0b, 0xf7, 0x8d, 0x6b, 0x31, 0xfe, 0xaa, 0x64,
  32. 0x50, 0xbe, 0x52, 0x7e, 0x83, 0x74, 0x00, 0x8f, 0x62, 0x96, 0xc7, 0xe9,
  33. 0x20, 0x59, 0x78, 0xc6, 0xea, 0x10, 0xd5, 0xdb, 0x3f, 0x6b, 0x13, 0xd9,
  34. 0x44, 0x18, 0x24, 0x17, 0x63, 0xc8, 0x74, 0xa5, 0x37, 0x6c, 0x9c, 0x00,
  35. 0xe5, 0xcf, 0x0a, 0xdf, 0xb9, 0x66, 0xb1, 0xbd, 0x04, 0x8f, 0x55, 0x9e,
  36. 0xb0, 0x24, 0x4e, 0xf0, 0xc4, 0x69, 0x2c, 0x1f, 0x63, 0x9f, 0x41, 0xa8,
  37. 0x89, 0x9b, 0x98, 0x00, 0xb6, 0x78, 0xf7, 0xe4, 0x4c, 0x72, 0x14, 0x84,
  38. 0xaa, 0x3d, 0xc1, 0x42, 0x9f, 0x12, 0x85, 0xdd, 0x16, 0x8b, 0x8f, 0x67,
  39. 0xe0, 0x26, 0x5b, 0x5e, 0xaa, 0xe7, 0xd3, 0x67, 0xfe, 0x21, 0x77, 0xa6,
  40. 0x52, 0xde, 0x33, 0x8b, 0x96, 0x49, 0x6a, 0xd6, 0x58, 0x58, 0x36, 0x00,
  41. 0x23, 0xd2, 0x45, 0x13, 0x9f, 0xd9, 0xc7, 0x2d, 0x55, 0x12, 0xb4, 0xfe,
  42. 0x53, 0x27, 0x1f, 0x14, 0x71, 0x9b, 0x7e, 0xcc, 0x5e, 0x8c, 0x59, 0xef,
  43. 0x80, 0xac, 0x89, 0xf4, 0x45, 0x8d, 0x98, 0x6d, 0x97, 0xfd, 0x53, 0x5f,
  44. 0x19, 0xd6, 0x11, 0xf7, 0xcb, 0x5d, 0xca, 0xab, 0xe1, 0x01, 0xf1, 0xe9,
  45. 0x1f, 0x1f, 0xf3, 0x53, 0x76, 0xa2, 0x59, 0x8e, 0xb3, 0x91, 0xff, 0xe8,
  46. 0x1b, 0xc0, 0xc0, 0xda, 0xdd, 0x93, 0xb5, 0x9d, 0x62, 0x13, 0xb8, 0x07,
  47. 0xf2, 0xf5, 0xb9, 0x4b, 0xe1, 0x09, 0xed, 0xdb, 0xe6, 0xd9, 0x2d, 0xc4,
  48. 0x0d, 0xb6, 0xbd, 0xfc, 0xdb, 0x5c, 0xcc, 0xf6, 0x53, 0x4e, 0x01, 0xa4,
  49. 0x03, 0x95, 0x4a, 0xa4, 0xaa, 0x4f, 0x45, 0xaf, 0xbf, 0xf1, 0x7e, 0x60,
  50. 0x1d, 0x86, 0x93, 0x65, 0x7b, 0x24, 0x0c, 0x09, 0xe0, 0xd1, 0xd8, 0x60,
  51. 0xd9, 0xd9, 0x55, 0x2a, 0xec, 0xd5, 0xdc, 0xd0, 0xc6, 0x5e, 0x2c, 0x22,
  52. 0xf5, 0x19, 0x0b, 0xc3, 0xa1, 0x38, 0x11, 0x67, 0x6f, 0x6c, 0x0e, 0x34,
  53. 0x44, 0x83, 0xee, 0xd3, 0xf2, 0x4b, 0x7b, 0x03, 0x68, 0xfe, 0xc5, 0x76,
  54. 0xb2, 0x2e, 0x26, 0xeb, 0x1f, 0x66, 0x02, 0xa4, 0xd9, 0xda, 0x28, 0x3a,
  55. 0xc3, 0x94, 0x03, 0xe8, 0x29, 0x7e, 0xfe, 0x3d, 0xc8, 0xc1, 0x0a, 0x74,
  56. 0xc7, 0xaf, 0xa6, 0x84, 0x86, 0x85, 0xc3, 0x8c, 0x00, 0x38, 0xd4, 0xb5,
  57. 0xb2, 0xe0, 0xf0, 0xc4, 0x8d, 0x10, 0x0d, 0xf1, 0xcd, 0x05, 0xdb, 0xd0,
  58. 0xcf, 0x17, 0x4f, 0xa8, 0xe5, 0xf0, 0x53, 0x55, 0x62, 0xc7, 0x55, 0xe5,
  59. 0xbe, 0x18, 0x2f, 0xda, 0x48, 0xf1, 0xaa, 0x85, 0x46, 0x80, 0x15, 0x70,
  60. 0x82, 0xd2, 0xa6, 0xb0, 0x3d, 0x31, 0xb5, 0xcc, 0x23, 0x95, 0x5e, 0x15,
  61. 0x35, 0x32, 0xd0, 0x86, 0xd1, 0x6e, 0x2d, 0xc0, 0xfe, 0x45, 0xae, 0x28,
  62. 0x24, 0xa7, 0x14, 0xf4, 0xe9, 0xb5, 0x6f, 0xac, 0x25, 0xf9, 0x88, 0xf6,
  63. 0x60, 0x5d, 0x6b, 0x5c, 0xf2, 0x38, 0xe8, 0xdc, 0xbd, 0xa6, 0x13, 0xc0,
  64. 0xa4, 0xc8, 0xe9, 0x7a, 0xc6, 0xb6, 0x88, 0x26, 0x98, 0x9f, 0xe3, 0x9a,
  65. 0xd9, 0x5b, 0xd4, 0xd0, 0x02, 0x1f, 0x55, 0x30, 0xbe, 0xde, 0x9c, 0xd1,
  66. 0x53, 0x93, 0x72, 0xe6, 0x19, 0x79, 0xe9, 0xf1, 0x70, 0x78, 0x92, 0x31,
  67. 0xf6, 0x17, 0xc0, 0xdd, 0x99, 0xc8, 0x97, 0x67, 0xdc, 0xf6, 0x67, 0x6b,
  68. 0x9b, 0x1c, 0x90, 0xea, 0x1a, 0x9e, 0x26, 0x68, 0xc2, 0x13, 0x94, 0x3a,
  69. 0x3e, 0x73, 0x61, 0x4e, 0x37, 0xa8, 0xa1, 0xfa, 0xf8, 0x22, 0xdd, 0x20,
  70. 0x40, 0xc6, 0x52, 0x27, 0x47, 0x1a, 0x79, 0xfa, 0x40, 0xa6, 0x62, 0x6b,
  71. 0xe6, 0xc7, 0x67, 0xb7, 0xa8, 0x2d, 0xd1, 0x9f, 0x17, 0xb8, 0x77, 0x5e,
  72. 0x97, 0x1e, 0x92, 0xd7, 0xd2, 0x25, 0x04, 0x92, 0xf9, 0x41, 0x70, 0x93,
  73. 0xe1, 0x13, 0x07, 0x94, 0x8e, 0x0b, 0x82, 0x98
  74. };
  75. static unsigned char randomDataSmall[] = {
  76. // openssl rand -rand /dev/random 24 | xxd -i
  77. 0xd1, 0xec, 0x35, 0xc3, 0xa0, 0x4c, 0x73, 0x37, 0x2f, 0x5a, 0x12, 0x44,
  78. 0xee, 0xe4, 0x22, 0x07, 0x29, 0xa8, 0x4a, 0xde, 0xc8, 0xbb, 0xe7, 0xdb
  79. };
  80. static BOOL HasGzipHeader(NSData *data) {
  81. // very simple check
  82. const unsigned char *bytes = [data bytes];
  83. return ([data length] > 2) &&
  84. ((bytes[0] == 0x1f) && (bytes[1] == 0x8b));
  85. }
  86. @implementation GTMNSData_zlibTest
  87. - (void)testBoundryValues {
  88. // build some test data
  89. NSData *data = [NSData dataWithBytes:randomDataLarge
  90. length:sizeof(randomDataLarge)];
  91. STAssertNotNil(data, @"failed to alloc data block");
  92. // bogus args to start
  93. STAssertNil([NSData gtm_dataByDeflatingData:nil], nil);
  94. STAssertNil([NSData gtm_dataByDeflatingBytes:nil length:666], nil);
  95. STAssertNil([NSData gtm_dataByDeflatingBytes:[data bytes] length:0], nil);
  96. STAssertNil([NSData gtm_dataByGzippingData:nil], nil);
  97. STAssertNil([NSData gtm_dataByGzippingBytes:nil length:666], nil);
  98. STAssertNil([NSData gtm_dataByGzippingBytes:[data bytes] length:0], nil);
  99. STAssertNil([NSData gtm_dataByInflatingData:nil], nil);
  100. STAssertNil([NSData gtm_dataByInflatingBytes:nil length:666], nil);
  101. STAssertNil([NSData gtm_dataByInflatingBytes:[data bytes] length:0], nil);
  102. STAssertNil([NSData gtm_dataByRawDeflatingData:nil], nil);
  103. STAssertNil([NSData gtm_dataByRawDeflatingBytes:nil length:666], nil);
  104. STAssertNil([NSData gtm_dataByRawDeflatingBytes:[data bytes] length:0], nil);
  105. STAssertNil([NSData gtm_dataByRawInflatingData:nil], nil);
  106. STAssertNil([NSData gtm_dataByRawInflatingBytes:nil length:666], nil);
  107. STAssertNil([NSData gtm_dataByRawInflatingBytes:[data bytes] length:0], nil);
  108. // test deflate w/ compression levels out of range
  109. NSData *deflated = [NSData gtm_dataByDeflatingData:data
  110. compressionLevel:-4];
  111. STAssertNotNil(deflated, nil);
  112. STAssertFalse(HasGzipHeader(deflated), nil);
  113. NSData *dataPrime = [NSData gtm_dataByInflatingData:deflated];
  114. STAssertNotNil(dataPrime, nil);
  115. STAssertEqualObjects(data, dataPrime, nil);
  116. deflated = [NSData gtm_dataByDeflatingData:data
  117. compressionLevel:20];
  118. STAssertNotNil(deflated, nil);
  119. STAssertFalse(HasGzipHeader(deflated), nil);
  120. dataPrime = [NSData gtm_dataByInflatingData:deflated];
  121. STAssertNotNil(dataPrime, nil);
  122. STAssertEqualObjects(data, dataPrime, nil);
  123. // test gzip w/ compression levels out of range
  124. NSData *gzipped = [NSData gtm_dataByGzippingData:data
  125. compressionLevel:-4];
  126. STAssertNotNil(gzipped, nil);
  127. STAssertTrue(HasGzipHeader(gzipped), nil);
  128. dataPrime = [NSData gtm_dataByInflatingData:gzipped];
  129. STAssertNotNil(dataPrime, nil);
  130. STAssertEqualObjects(data, dataPrime, nil);
  131. gzipped = [NSData gtm_dataByGzippingData:data
  132. compressionLevel:20];
  133. STAssertNotNil(gzipped, nil);
  134. STAssertTrue(HasGzipHeader(gzipped), nil);
  135. dataPrime = [NSData gtm_dataByInflatingData:gzipped];
  136. STAssertNotNil(dataPrime, nil);
  137. STAssertEqualObjects(data, dataPrime, nil);
  138. // test raw deflate w/ compression levels out of range
  139. NSData *rawDeflated = [NSData gtm_dataByRawDeflatingData:data
  140. compressionLevel:-4];
  141. STAssertNotNil(rawDeflated, nil);
  142. STAssertFalse(HasGzipHeader(rawDeflated), nil);
  143. dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated];
  144. STAssertNotNil(dataPrime, nil);
  145. STAssertEqualObjects(data, dataPrime, nil);
  146. rawDeflated = [NSData gtm_dataByRawDeflatingData:data
  147. compressionLevel:20];
  148. STAssertNotNil(rawDeflated, nil);
  149. STAssertFalse(HasGzipHeader(rawDeflated), nil);
  150. dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated];
  151. STAssertNotNil(dataPrime, nil);
  152. STAssertEqualObjects(data, dataPrime, nil);
  153. // test non-compressed data data itself
  154. [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
  155. @"payload, error -3: incorrect header check"];
  156. STAssertNil([NSData gtm_dataByInflatingData:data], nil);
  157. // test deflated data runs that end before they are done
  158. [GTMUnitTestDevLog expect:([deflated length] / 11) + 1
  159. casesOfString:@"Error trying to inflate some of the payload, "
  160. @"error -5: (null)"];
  161. for (NSUInteger x = 1 ; x < [deflated length] ; x += 11) {
  162. STAssertNil([NSData gtm_dataByInflatingBytes:[deflated bytes]
  163. length:x], nil);
  164. }
  165. // test gzipped data runs that end before they are done
  166. [GTMUnitTestDevLog expect:([gzipped length] / 11) + 1
  167. casesOfString:@"Error trying to inflate some of the payload, "
  168. @"error -5: (null)"];
  169. for (NSUInteger x = 1 ; x < [gzipped length] ; x += 11) {
  170. STAssertNil([NSData gtm_dataByInflatingBytes:[gzipped bytes]
  171. length:x], nil);
  172. }
  173. // test raw deflated data runs that end before they are done
  174. [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
  175. @"payload, error -5: (null)"];
  176. [GTMUnitTestDevLog expect:([rawDeflated length] / 11) - 1
  177. casesOfString:@"Error trying to inflate some of the payload, "
  178. @"error -3: incorrect header check"];
  179. for (NSUInteger x = 1 ; x < [rawDeflated length] ; x += 11) {
  180. STAssertNil([NSData gtm_dataByInflatingBytes:[rawDeflated bytes]
  181. length:x], nil);
  182. }
  183. // test extra data before the deflated/gzipped data (just to make sure we
  184. // don't seek to the "real" data)
  185. NSMutableData *prefixedDeflated =
  186. [NSMutableData dataWithBytes:randomDataSmall length:sizeof(randomDataSmall)];
  187. STAssertNotNil(prefixedDeflated, @"failed to alloc data block");
  188. [prefixedDeflated appendData:deflated];
  189. [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
  190. @"payload, error -3: incorrect header check"];
  191. STAssertNil([NSData gtm_dataByInflatingData:prefixedDeflated], nil);
  192. [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
  193. @"payload, error -3: incorrect header check"];
  194. STAssertNil([NSData gtm_dataByInflatingBytes:[prefixedDeflated bytes]
  195. length:[prefixedDeflated length]],
  196. nil);
  197. NSMutableData *prefixedGzipped =
  198. [NSMutableData dataWithBytes:randomDataSmall length:sizeof(randomDataSmall)];
  199. STAssertNotNil(prefixedDeflated, @"failed to alloc data block");
  200. [prefixedGzipped appendData:gzipped];
  201. [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
  202. @"payload, error -3: incorrect header check"];
  203. STAssertNil([NSData gtm_dataByInflatingData:prefixedGzipped], nil);
  204. [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
  205. @"payload, error -3: incorrect header check"];
  206. STAssertNil([NSData gtm_dataByInflatingBytes:[prefixedGzipped bytes]
  207. length:[prefixedGzipped length]],
  208. nil);
  209. NSMutableData *prefixedRawDeflated =
  210. [NSMutableData dataWithBytes:randomDataSmall length:sizeof(randomDataSmall)];
  211. STAssertNotNil(prefixedRawDeflated, @"failed to alloc data block");
  212. [prefixedRawDeflated appendData:rawDeflated];
  213. [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
  214. @"payload, error -3: invalid stored block lengths"];
  215. STAssertNil([NSData gtm_dataByRawInflatingData:prefixedRawDeflated], nil);
  216. [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
  217. @"payload, error -3: invalid stored block lengths"];
  218. STAssertNil([NSData gtm_dataByRawInflatingBytes:[prefixedRawDeflated bytes]
  219. length:[prefixedRawDeflated length]],
  220. nil);
  221. // test extra data after the deflated/gzipped data (just to make sure we
  222. // don't ignore some of the data)
  223. NSMutableData *suffixedDeflated = [NSMutableData data];
  224. STAssertNotNil(suffixedDeflated, @"failed to alloc data block");
  225. [suffixedDeflated appendData:deflated];
  226. [suffixedDeflated appendBytes:[data bytes] length:20];
  227. [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
  228. @"all input, 20 bytes left"];
  229. STAssertNil([NSData gtm_dataByInflatingData:suffixedDeflated], nil);
  230. [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
  231. @"all input, 20 bytes left"];
  232. STAssertNil([NSData gtm_dataByInflatingBytes:[suffixedDeflated bytes]
  233. length:[suffixedDeflated length]],
  234. nil);
  235. NSMutableData *suffixedGZipped = [NSMutableData data];
  236. STAssertNotNil(suffixedGZipped, @"failed to alloc data block");
  237. [suffixedGZipped appendData:gzipped];
  238. [suffixedGZipped appendBytes:[data bytes] length:20];
  239. [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
  240. @"all input, 20 bytes left"];
  241. STAssertNil([NSData gtm_dataByInflatingData:suffixedGZipped], nil);
  242. [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
  243. @"all input, 20 bytes left"];
  244. STAssertNil([NSData gtm_dataByInflatingBytes:[suffixedGZipped bytes]
  245. length:[suffixedGZipped length]],
  246. nil);
  247. NSMutableData *suffixedRawDeflated = [NSMutableData data];
  248. STAssertNotNil(suffixedRawDeflated, @"failed to alloc data block");
  249. [suffixedRawDeflated appendData:rawDeflated];
  250. [suffixedRawDeflated appendBytes:[data bytes] length:20];
  251. [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
  252. @"all input, 20 bytes left"];
  253. STAssertNil([NSData gtm_dataByRawInflatingData:suffixedRawDeflated], nil);
  254. [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
  255. @"all input, 20 bytes left"];
  256. STAssertNil([NSData gtm_dataByRawInflatingBytes:[suffixedRawDeflated bytes]
  257. length:[suffixedRawDeflated length]],
  258. nil);
  259. }
  260. - (void)testInflateDeflate {
  261. NSData *data = [NSData dataWithBytes:randomDataLarge
  262. length:sizeof(randomDataLarge)];
  263. STAssertNotNil(data, @"failed to alloc data block");
  264. // w/ *Bytes apis, default level
  265. NSData *deflated = [NSData gtm_dataByDeflatingBytes:[data bytes]
  266. length:[data length]];
  267. STAssertNotNil(deflated, @"failed to deflate data block");
  268. STAssertGreaterThan([deflated length],
  269. (NSUInteger)0, @"failed to deflate data block");
  270. STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
  271. NSData *dataPrime = [NSData gtm_dataByInflatingBytes:[deflated bytes]
  272. length:[deflated length]];
  273. STAssertNotNil(dataPrime, @"failed to inflate data block");
  274. STAssertGreaterThan([dataPrime length],
  275. (NSUInteger)0, @"failed to inflate data block");
  276. STAssertEqualObjects(data,
  277. dataPrime, @"failed to round trip via *Bytes apis");
  278. // w/ *Data apis, default level
  279. deflated = [NSData gtm_dataByDeflatingData:data];
  280. STAssertNotNil(deflated, @"failed to deflate data block");
  281. STAssertGreaterThan([deflated length],
  282. (NSUInteger)0, @"failed to deflate data block");
  283. STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
  284. dataPrime = [NSData gtm_dataByInflatingData:deflated];
  285. STAssertNotNil(dataPrime, @"failed to inflate data block");
  286. STAssertGreaterThan([dataPrime length],
  287. (NSUInteger)0, @"failed to inflate data block");
  288. STAssertEqualObjects(data,
  289. dataPrime, @"failed to round trip via *Data apis");
  290. // loop over the compression levels
  291. for (int level = 1 ; level <= 9 ; ++level) {
  292. // w/ *Bytes apis, using our level
  293. deflated = [NSData gtm_dataByDeflatingBytes:[data bytes]
  294. length:[data length]
  295. compressionLevel:level];
  296. STAssertNotNil(deflated, @"failed to deflate data block");
  297. STAssertGreaterThan([deflated length],
  298. (NSUInteger)0, @"failed to deflate data block");
  299. STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
  300. dataPrime = [NSData gtm_dataByInflatingBytes:[deflated bytes]
  301. length:[deflated length]];
  302. STAssertNotNil(dataPrime, @"failed to inflate data block");
  303. STAssertGreaterThan([dataPrime length],
  304. (NSUInteger)0, @"failed to inflate data block");
  305. STAssertEqualObjects(data,
  306. dataPrime, @"failed to round trip via *Bytes apis");
  307. // w/ *Data apis, using our level
  308. deflated = [NSData gtm_dataByDeflatingData:data compressionLevel:level];
  309. STAssertNotNil(deflated, @"failed to deflate data block");
  310. STAssertGreaterThan([deflated length],
  311. (NSUInteger)0, @"failed to deflate data block");
  312. STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
  313. dataPrime = [NSData gtm_dataByInflatingData:deflated];
  314. STAssertNotNil(dataPrime, @"failed to inflate data block");
  315. STAssertGreaterThan([dataPrime length],
  316. (NSUInteger)0, @"failed to inflate data block");
  317. STAssertEqualObjects(data,
  318. dataPrime, @"failed to round trip via *Data apis");
  319. }
  320. }
  321. - (void)testInflateGzip {
  322. NSData *data = [NSData dataWithBytes:randomDataLarge
  323. length:sizeof(randomDataLarge)];
  324. STAssertNotNil(data, @"failed to alloc data block");
  325. // w/ *Bytes apis, default level
  326. NSData *gzipped = [NSData gtm_dataByGzippingBytes:[data bytes]
  327. length:[data length]];
  328. STAssertNotNil(gzipped, @"failed to gzip data block");
  329. STAssertGreaterThan([gzipped length],
  330. (NSUInteger)0, @"failed to gzip data block");
  331. STAssertTrue(HasGzipHeader(gzipped),
  332. @"doesn't have gzip header on gzipped data");
  333. NSData *dataPrime = [NSData gtm_dataByInflatingBytes:[gzipped bytes]
  334. length:[gzipped length]];
  335. STAssertNotNil(dataPrime, @"failed to inflate data block");
  336. STAssertGreaterThan([dataPrime length],
  337. (NSUInteger)0, @"failed to inflate data block");
  338. STAssertEqualObjects(data,
  339. dataPrime, @"failed to round trip via *Bytes apis");
  340. // w/ *Data apis, default level
  341. gzipped = [NSData gtm_dataByGzippingData:data];
  342. STAssertNotNil(gzipped, @"failed to gzip data block");
  343. STAssertGreaterThan([gzipped length],
  344. (NSUInteger)0, @"failed to gzip data block");
  345. STAssertTrue(HasGzipHeader(gzipped),
  346. @"doesn't have gzip header on gzipped data");
  347. dataPrime = [NSData gtm_dataByInflatingData:gzipped];
  348. STAssertNotNil(dataPrime, @"failed to inflate data block");
  349. STAssertGreaterThan([dataPrime length],
  350. (NSUInteger)0, @"failed to inflate data block");
  351. STAssertEqualObjects(data, dataPrime,
  352. @"failed to round trip via *Data apis");
  353. // loop over the compression levels
  354. for (int level = 1 ; level <= 9 ; ++level) {
  355. // w/ *Bytes apis, using our level
  356. gzipped = [NSData gtm_dataByGzippingBytes:[data bytes]
  357. length:[data length]
  358. compressionLevel:level];
  359. STAssertNotNil(gzipped, @"failed to gzip data block");
  360. STAssertGreaterThan([gzipped length],
  361. (NSUInteger)0, @"failed to gzip data block");
  362. STAssertTrue(HasGzipHeader(gzipped),
  363. @"doesn't have gzip header on gzipped data");
  364. dataPrime = [NSData gtm_dataByInflatingBytes:[gzipped bytes]
  365. length:[gzipped length]];
  366. STAssertNotNil(dataPrime, @"failed to inflate data block");
  367. STAssertGreaterThan([dataPrime length],
  368. (NSUInteger)0, @"failed to inflate data block");
  369. STAssertEqualObjects(data, dataPrime,
  370. @"failed to round trip via *Bytes apis");
  371. // w/ *Data apis, using our level
  372. gzipped = [NSData gtm_dataByGzippingData:data compressionLevel:level];
  373. STAssertNotNil(gzipped, @"failed to gzip data block");
  374. STAssertGreaterThan([gzipped length],
  375. (NSUInteger)0, @"failed to gzip data block");
  376. STAssertTrue(HasGzipHeader(gzipped),
  377. @"doesn't have gzip header on gzipped data");
  378. dataPrime = [NSData gtm_dataByInflatingData:gzipped];
  379. STAssertNotNil(dataPrime, @"failed to inflate data block");
  380. STAssertGreaterThan([dataPrime length],
  381. (NSUInteger)0, @"failed to inflate data block");
  382. STAssertEqualObjects(data,
  383. dataPrime, @"failed to round trip via *Data apis");
  384. }
  385. }
  386. - (void)testRawtInflateRawDeflate {
  387. NSData *data = [NSData dataWithBytes:randomDataLarge
  388. length:sizeof(randomDataLarge)];
  389. STAssertNotNil(data, @"failed to alloc data block");
  390. // w/ *Bytes apis, default level
  391. NSData *rawDeflated = [NSData gtm_dataByRawDeflatingBytes:[data bytes]
  392. length:[data length]];
  393. STAssertNotNil(rawDeflated, @"failed to raw deflate data block");
  394. STAssertGreaterThan([rawDeflated length],
  395. (NSUInteger)0, @"failed to raw deflate data block");
  396. STAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
  397. NSData *dataPrime = [NSData gtm_dataByRawInflatingBytes:[rawDeflated bytes]
  398. length:[rawDeflated length]];
  399. STAssertNotNil(dataPrime, @"failed to raw inflate data block");
  400. STAssertGreaterThan([dataPrime length],
  401. (NSUInteger)0, @"failed to raw inflate data block");
  402. STAssertEqualObjects(data,
  403. dataPrime, @"failed to round trip via *Bytes apis");
  404. // w/ *Data apis, default level
  405. rawDeflated = [NSData gtm_dataByRawDeflatingData:data];
  406. STAssertNotNil(rawDeflated, @"failed to raw deflate data block");
  407. STAssertGreaterThan([rawDeflated length],
  408. (NSUInteger)0, @"failed to raw deflate data block");
  409. STAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
  410. dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated];
  411. STAssertNotNil(dataPrime, @"failed to raw inflate data block");
  412. STAssertGreaterThan([dataPrime length],
  413. (NSUInteger)0, @"failed to raw inflate data block");
  414. STAssertEqualObjects(data,
  415. dataPrime, @"failed to round trip via *Data apis");
  416. // loop over the compression levels
  417. for (int level = 1 ; level <= 9 ; ++level) {
  418. // w/ *Bytes apis, using our level
  419. rawDeflated = [NSData gtm_dataByRawDeflatingBytes:[data bytes]
  420. length:[data length]
  421. compressionLevel:level];
  422. STAssertNotNil(rawDeflated, @"failed to rawDeflate data block");
  423. STAssertGreaterThan([rawDeflated length],
  424. (NSUInteger)0, @"failed to raw deflate data block");
  425. STAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
  426. dataPrime = [NSData gtm_dataByRawInflatingBytes:[rawDeflated bytes]
  427. length:[rawDeflated length]];
  428. STAssertNotNil(dataPrime, @"failed to raw inflate data block");
  429. STAssertGreaterThan([dataPrime length],
  430. (NSUInteger)0, @"failed to raw inflate data block");
  431. STAssertEqualObjects(data,
  432. dataPrime, @"failed to round trip via *Bytes apis");
  433. // w/ *Data apis, using our level
  434. rawDeflated = [NSData gtm_dataByRawDeflatingData:data
  435. compressionLevel:level];
  436. STAssertNotNil(rawDeflated, @"failed to deflate data block");
  437. STAssertGreaterThan([rawDeflated length],
  438. (NSUInteger)0, @"failed to raw deflate data block");
  439. STAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
  440. dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated];
  441. STAssertNotNil(dataPrime, @"failed to raw inflate data block");
  442. STAssertGreaterThan([dataPrime length],
  443. (NSUInteger)0, @"failed to raw inflate data block");
  444. STAssertEqualObjects(data,
  445. dataPrime, @"failed to round trip via *Data apis");
  446. }
  447. }
  448. - (void)testLargeData {
  449. // Generate some large data out of the random chunk by xoring over it
  450. // to make sure it changes and isn't too repeated.
  451. NSData *data = [NSData dataWithBytes:randomDataLarge
  452. length:sizeof(randomDataLarge)];
  453. STAssertNotNil(data, @"failed to alloc data block");
  454. const uint8_t *dataBytes = [data bytes];
  455. NSMutableData *scratch = [NSMutableData dataWithLength:[data length]];
  456. STAssertNotNil(scratch, @"failed to alloc data block");
  457. uint8_t *scratchBytes = [scratch mutableBytes];
  458. NSMutableData *input = [NSMutableData dataWithCapacity:200 * [data length]];
  459. for (NSUInteger i = 0; i < 200; ++i) {
  460. for (NSUInteger j = 0; j < [data length]; ++j) {
  461. scratchBytes[j] = dataBytes[j] ^ i;
  462. }
  463. [input appendData:scratch];
  464. }
  465. // The internal buffer size for GTM's deflate/inflate is 1024.
  466. NSUInteger internalBufferSize = 1024;
  467. // Should deflate to more then one buffer size to make sure the internal loop
  468. // is working.
  469. NSData *compressed = [NSData gtm_dataByDeflatingData:input
  470. compressionLevel:9];
  471. STAssertNotNil(compressed, @"failed to deflate");
  472. STAssertGreaterThan([compressed length], internalBufferSize,
  473. @"should have been more then %d bytes",
  474. (int)internalBufferSize);
  475. // Should inflate to more then one buffer size to make sure the internal loop
  476. // is working.
  477. NSData *uncompressed = [NSData gtm_dataByInflatingData:compressed];
  478. STAssertNotNil(uncompressed, @"fail to inflate");
  479. STAssertGreaterThan([uncompressed length], internalBufferSize,
  480. @"should have been more then %d bytes",
  481. (int)internalBufferSize);
  482. STAssertEqualObjects(uncompressed, input,
  483. @"didn't get the same thing back");
  484. }
  485. @end