[Author: thomasvl]

Add test to make sure we exercise the codes paths that require more then
  on loop to deflate/inflate.

R=dmaclach
DELTA=33  (33 added, 0 deleted, 0 changed)

1 files changed, 84 insertions, 51 deletions

diff --git a/Foundation/GTMNSData+zlibTest.m b/Foundation/GTMNSData+zlibTest.m
index 0d86886..830f4d0 100644
--- a/Foundation/GTMNSData+zlibTest.m
+++ b/Foundation/GTMNSData+zlibTest.m
@@ -6,9 +6,9 @@
 //  Licensed under the Apache License, Version 2.0 (the "License"); you may not
 //  use this file except in compliance with the License.  You may obtain a copy
 //  of the License at
-// 
+//
 //  http://www.apache.org/licenses/LICENSE-2.0
-// 
+//
 //  Unless required by applicable law or agreed to in writing, software
 //  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 //  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
@@ -110,7 +110,7 @@ static BOOL HasGzipHeader(NSData *data) {
   STAssertNil([NSData gtm_dataByInflatingData:nil], nil);
   STAssertNil([NSData gtm_dataByInflatingBytes:nil length:666], nil);
   STAssertNil([NSData gtm_dataByInflatingBytes:[data bytes] length:0], nil);
-  
+
   // test deflate w/ compression levels out of range
   NSData *deflated = [NSData gtm_dataByDeflatingData:data
                                     compressionLevel:-4];
@@ -142,30 +142,30 @@ static BOOL HasGzipHeader(NSData *data) {
   dataPrime = [NSData gtm_dataByInflatingData:gzipped];
   STAssertNotNil(dataPrime, nil);
   STAssertEqualObjects(data, dataPrime, nil);
-  
+
   // test non-compressed data data itself
   [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
    "payload, error -3"];
   STAssertNil([NSData gtm_dataByInflatingData:data], nil);
-  
+
   // test deflated data runs that end before they are done
   [GTMUnitTestDevLog expect:([deflated length] / 11) + 1
               casesOfString:@"Error trying to inflate some of the payload, "
    "error -5"];
   for (NSUInteger x = 1 ; x < [deflated length] ; x += 11) {
-    STAssertNil([NSData gtm_dataByInflatingBytes:[deflated bytes] 
+    STAssertNil([NSData gtm_dataByInflatingBytes:[deflated bytes]
                                           length:x], nil);
   }
-  
+
   // test gzipped data runs that end before they are done
   [GTMUnitTestDevLog expect:([gzipped length] / 11) + 1
               casesOfString:@"Error trying to inflate some of the payload, "
    "error -5"];
   for (NSUInteger x = 1 ; x < [gzipped length] ; x += 11) {
-    STAssertNil([NSData gtm_dataByInflatingBytes:[gzipped bytes] 
+    STAssertNil([NSData gtm_dataByInflatingBytes:[gzipped bytes]
                                           length:x], nil);
   }
-  
+
   // test extra data before the deflated/gzipped data (just to make sure we
   // don't seek to the "real" data)
   NSMutableData *prefixedDeflated =
@@ -225,35 +225,35 @@ static BOOL HasGzipHeader(NSData *data) {
   NSData *data = [NSData dataWithBytes:randomDataLarge
                                 length:sizeof(randomDataLarge)];
   STAssertNotNil(data, @"failed to alloc data block");
-  
+
   // w/ *Bytes apis, default level
-  NSData *deflated = [NSData gtm_dataByDeflatingBytes:[data bytes] 
+  NSData *deflated = [NSData gtm_dataByDeflatingBytes:[data bytes]
                                                length:[data length]];
   STAssertNotNil(deflated, @"failed to deflate data block");
-  STAssertGreaterThan([deflated length], 
+  STAssertGreaterThan([deflated length],
                       (NSUInteger)0, @"failed to deflate data block");
   STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
-  NSData *dataPrime = [NSData gtm_dataByInflatingBytes:[deflated bytes] 
+  NSData *dataPrime = [NSData gtm_dataByInflatingBytes:[deflated bytes]
                                                 length:[deflated length]];
   STAssertNotNil(dataPrime, @"failed to inflate data block");
-  STAssertGreaterThan([dataPrime length], 
+  STAssertGreaterThan([dataPrime length],
                       (NSUInteger)0, @"failed to inflate data block");
-  STAssertEqualObjects(data, 
+  STAssertEqualObjects(data,
                        dataPrime, @"failed to round trip via *Bytes apis");
-  
+
   // w/ *Data apis, default level
   deflated = [NSData gtm_dataByDeflatingData:data];
   STAssertNotNil(deflated, @"failed to deflate data block");
-  STAssertGreaterThan([deflated length], 
+  STAssertGreaterThan([deflated length],
                       (NSUInteger)0, @"failed to deflate data block");
   STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
   dataPrime = [NSData gtm_dataByInflatingData:deflated];
   STAssertNotNil(dataPrime, @"failed to inflate data block");
-  STAssertGreaterThan([dataPrime length], 
+  STAssertGreaterThan([dataPrime length],
                       (NSUInteger)0, @"failed to inflate data block");
-  STAssertEqualObjects(data, 
+  STAssertEqualObjects(data,
                        dataPrime, @"failed to round trip via *Data apis");
-  
+
   // loop over the compression levels
   for (int level = 1 ; level < 9 ; ++level) {
     // w/ *Bytes apis, using our level
@@ -261,28 +261,28 @@ static BOOL HasGzipHeader(NSData *data) {
                                          length:[data length]
                                compressionLevel:level];
     STAssertNotNil(deflated, @"failed to deflate data block");
-    STAssertGreaterThan([deflated length], 
+    STAssertGreaterThan([deflated length],
                         (NSUInteger)0, @"failed to deflate data block");
     STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
-    dataPrime = [NSData gtm_dataByInflatingBytes:[deflated bytes] 
+    dataPrime = [NSData gtm_dataByInflatingBytes:[deflated bytes]
                                           length:[deflated length]];
     STAssertNotNil(dataPrime, @"failed to inflate data block");
-    STAssertGreaterThan([dataPrime length], 
+    STAssertGreaterThan([dataPrime length],
                         (NSUInteger)0, @"failed to inflate data block");
-    STAssertEqualObjects(data, 
+    STAssertEqualObjects(data,
                          dataPrime, @"failed to round trip via *Bytes apis");
-    
+
     // w/ *Data apis, using our level
     deflated = [NSData gtm_dataByDeflatingData:data compressionLevel:level];
     STAssertNotNil(deflated, @"failed to deflate data block");
-    STAssertGreaterThan([deflated length], 
+    STAssertGreaterThan([deflated length],
                         (NSUInteger)0, @"failed to deflate data block");
     STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
     dataPrime = [NSData gtm_dataByInflatingData:deflated];
     STAssertNotNil(dataPrime, @"failed to inflate data block");
-    STAssertGreaterThan([dataPrime length], 
+    STAssertGreaterThan([dataPrime length],
                         (NSUInteger)0, @"failed to inflate data block");
-    STAssertEqualObjects(data, 
+    STAssertEqualObjects(data,
                          dataPrime, @"failed to round trip via *Data apis");
   }
 }
@@ -291,37 +291,37 @@ static BOOL HasGzipHeader(NSData *data) {
   NSData *data = [NSData dataWithBytes:randomDataLarge
                                 length:sizeof(randomDataLarge)];
   STAssertNotNil(data, @"failed to alloc data block");
-  
+
   // w/ *Bytes apis, default level
-  NSData *gzipped = [NSData gtm_dataByGzippingBytes:[data bytes] 
+  NSData *gzipped = [NSData gtm_dataByGzippingBytes:[data bytes]
                                              length:[data length]];
   STAssertNotNil(gzipped, @"failed to gzip data block");
-  STAssertGreaterThan([gzipped length], 
+  STAssertGreaterThan([gzipped length],
                       (NSUInteger)0, @"failed to gzip data block");
-  STAssertTrue(HasGzipHeader(gzipped), 
+  STAssertTrue(HasGzipHeader(gzipped),
                @"doesn't have gzip header on gzipped data");
-  NSData *dataPrime = [NSData gtm_dataByInflatingBytes:[gzipped bytes] 
+  NSData *dataPrime = [NSData gtm_dataByInflatingBytes:[gzipped bytes]
                                                 length:[gzipped length]];
   STAssertNotNil(dataPrime, @"failed to inflate data block");
-  STAssertGreaterThan([dataPrime length], 
+  STAssertGreaterThan([dataPrime length],
                       (NSUInteger)0, @"failed to inflate data block");
-  STAssertEqualObjects(data, 
+  STAssertEqualObjects(data,
                        dataPrime, @"failed to round trip via *Bytes apis");
-  
+
   // w/ *Data apis, default level
   gzipped = [NSData gtm_dataByGzippingData:data];
   STAssertNotNil(gzipped, @"failed to gzip data block");
-  STAssertGreaterThan([gzipped length], 
+  STAssertGreaterThan([gzipped length],
                       (NSUInteger)0, @"failed to gzip data block");
-  STAssertTrue(HasGzipHeader(gzipped), 
+  STAssertTrue(HasGzipHeader(gzipped),
                @"doesn't have gzip header on gzipped data");
   dataPrime = [NSData gtm_dataByInflatingData:gzipped];
   STAssertNotNil(dataPrime, @"failed to inflate data block");
-  STAssertGreaterThan([dataPrime length], 
+  STAssertGreaterThan([dataPrime length],
                       (NSUInteger)0, @"failed to inflate data block");
-  STAssertEqualObjects(data, dataPrime, 
+  STAssertEqualObjects(data, dataPrime,
                        @"failed to round trip via *Data apis");
-  
+
   // loop over the compression levels
   for (int level = 1 ; level < 9 ; ++level) {
     // w/ *Bytes apis, using our level
@@ -329,32 +329,65 @@ static BOOL HasGzipHeader(NSData *data) {
                                        length:[data length]
                              compressionLevel:level];
     STAssertNotNil(gzipped, @"failed to gzip data block");
-    STAssertGreaterThan([gzipped length], 
+    STAssertGreaterThan([gzipped length],
                         (NSUInteger)0, @"failed to gzip data block");
-    STAssertTrue(HasGzipHeader(gzipped), 
+    STAssertTrue(HasGzipHeader(gzipped),
                  @"doesn't have gzip header on gzipped data");
-    dataPrime = [NSData gtm_dataByInflatingBytes:[gzipped bytes] 
+    dataPrime = [NSData gtm_dataByInflatingBytes:[gzipped bytes]
                                           length:[gzipped length]];
     STAssertNotNil(dataPrime, @"failed to inflate data block");
-    STAssertGreaterThan([dataPrime length], 
+    STAssertGreaterThan([dataPrime length],
                         (NSUInteger)0, @"failed to inflate data block");
-    STAssertEqualObjects(data, dataPrime, 
+    STAssertEqualObjects(data, dataPrime,
                          @"failed to round trip via *Bytes apis");
-    
+
     // w/ *Data apis, using our level
     gzipped = [NSData gtm_dataByGzippingData:data compressionLevel:level];
     STAssertNotNil(gzipped, @"failed to gzip data block");
-    STAssertGreaterThan([gzipped length], 
+    STAssertGreaterThan([gzipped length],
                         (NSUInteger)0, @"failed to gzip data block");
-    STAssertTrue(HasGzipHeader(gzipped), 
+    STAssertTrue(HasGzipHeader(gzipped),
                  @"doesn't have gzip header on gzipped data");
     dataPrime = [NSData gtm_dataByInflatingData:gzipped];
     STAssertNotNil(dataPrime, @"failed to inflate data block");
-    STAssertGreaterThan([dataPrime length], 
+    STAssertGreaterThan([dataPrime length],
                         (NSUInteger)0, @"failed to inflate data block");
-    STAssertEqualObjects(data, 
+    STAssertEqualObjects(data,
                          dataPrime, @"failed to round trip via *Data apis");
   }
 }
 
+- (void)testLargeData {
+  NSData *data1 = [NSData dataWithBytes:randomDataLarge
+                                 length:sizeof(randomDataLarge)];
+  STAssertNotNil(data1, @"failed to alloc data block");
+  NSData *data2 = [NSData dataWithBytes:randomDataSmall
+                                 length:sizeof(randomDataSmall)];
+  STAssertNotNil(data2, @"failed to alloc data block");
+
+  NSMutableData *input = [NSMutableData data];
+  for (NSUInteger i = 0; i < 200; ++i) {
+    [input appendData:data1];
+    for (NSUInteger j = 0; j < i; ++ j) {
+      [input appendData:data2];
+    }
+  }
+
+  // Should deflate to > 2048 bytes to take multiple loops during deflation.
+  NSData *compressed = [NSData gtm_dataByDeflatingData:input
+                                      compressionLevel:9];
+  STAssertNotNil(compressed, @"failed to deflate");
+  STAssertGreaterThan([compressed length], (NSUInteger)2048,
+                      @"should have been more then 2048 bytes");
+
+  // Should inflate to > 2048 bytes to take multiple loops during inflation.
+  NSData *uncompressed = [NSData gtm_dataByInflatingData:compressed];
+  STAssertNotNil(uncompressed, @"fail to inflate");
+  STAssertGreaterThan([uncompressed length], (NSUInteger)2048,
+                      @"should have been more then 2048 bytes");
+
+  STAssertEqualObjects(uncompressed, input,
+                       @"didn't get the same thing back");
+}
+
 @end