First cut at pruning things/updating things.

Remove a bunch of code that Google stopped using/maintaining rather than trying
to update it it. Some would be hard to update, some actually has system provided
replacements; others are patterns that just don't seem as common now.

Prune out the code related to macOS <= 10.5, start pruning some of the really
old iOS support also.

Get the projects mostly limping again with modern Xcodes so tests can be run.

If someone ends up on this commit via history for something they still find
as useful, feel free to do a pull request to bring the snippet of code back to
life and update it for current SDKs.

1 files changed, 407 insertions, 282 deletions

diff --git a/Foundation/GTMNSData+zlibTest.m b/Foundation/GTMNSData+zlibTest.m
index 8a14919..4f3acc1 100644
--- a/Foundation/GTMNSData+zlibTest.m
+++ b/Foundation/GTMNSData+zlibTest.m
@@ -17,9 +17,8 @@
 //
 
 #import "GTMSenTestCase.h"
-#import "GTMUnitTestDevLog.h"
 #import "GTMNSData+zlib.h"
-#import <stdlib.h> // for randiom/srandomdev
+#import <stdlib.h> // for random/srandomdev
 #import <zlib.h>
 
 @interface GTMNSData_zlibTest : GTMTestCase
@@ -91,405 +90,526 @@ static BOOL HasGzipHeader(NSData *data) {
          ((bytes[0] == 0x1f) && (bytes[1] == 0x8b));
 }
 
+#define GTMCheckZLibError(error, errorCode) \
+  XCTAssertEqual([error code], GTMNSDataZlibErrorInternal); \
+  XCTAssertEqualObjects([error domain], GTMNSDataZlibErrorDomain); \
+  XCTAssertEqualObjects([[error userInfo] objectForKey:GTMNSDataZlibErrorKey], \
+                        [NSNumber numberWithInt:errorCode]); \
+  error = nil
+
+#define GTMCheckRemainingError(error, bytes) \
+  XCTAssertEqual([error code], GTMNSDataZlibErrorDataRemaining); \
+  XCTAssertEqualObjects([error domain], GTMNSDataZlibErrorDomain); \
+  XCTAssertEqualObjects([[error userInfo] objectForKey:GTMNSDataZlibRemainingBytesKey], \
+                        [NSNumber numberWithInt:bytes]); \
+  error = nil
 
 @implementation GTMNSData_zlibTest
 
-- (void)testBoundryValues {
+- (void)testBoundaryValues {
   // build some test data
   NSData *data = [NSData dataWithBytes:randomDataLarge
                                 length:sizeof(randomDataLarge)];
-  STAssertNotNil(data, @"failed to alloc data block");
+  XCTAssertNotNil(data, @"failed to alloc data block");
 
   // bogus args to start
-  STAssertNil([NSData gtm_dataByDeflatingData:nil], nil);
-  STAssertNil([NSData gtm_dataByDeflatingBytes:nil length:666], nil);
-  STAssertNil([NSData gtm_dataByDeflatingBytes:[data bytes] length:0], nil);
-  STAssertNil([NSData gtm_dataByGzippingData:nil], nil);
-  STAssertNil([NSData gtm_dataByGzippingBytes:nil length:666], nil);
-  STAssertNil([NSData gtm_dataByGzippingBytes:[data bytes] length:0], nil);
-  STAssertNil([NSData gtm_dataByInflatingData:nil], nil);
-  STAssertNil([NSData gtm_dataByInflatingBytes:nil length:666], nil);
-  STAssertNil([NSData gtm_dataByInflatingBytes:[data bytes] length:0], nil);
-  STAssertNil([NSData gtm_dataByRawDeflatingData:nil], nil);
-  STAssertNil([NSData gtm_dataByRawDeflatingBytes:nil length:666], nil);
-  STAssertNil([NSData gtm_dataByRawDeflatingBytes:[data bytes] length:0], nil);
-  STAssertNil([NSData gtm_dataByRawInflatingData:nil], nil);
-  STAssertNil([NSData gtm_dataByRawInflatingBytes:nil length:666], nil);
-  STAssertNil([NSData gtm_dataByRawInflatingBytes:[data bytes] length:0], nil);
+  NSError *error = nil;
+  XCTAssertNil([NSData gtm_dataByDeflatingData:nil error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByDeflatingBytes:nil length:666 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByDeflatingBytes:[data bytes] length:0 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByGzippingData:nil error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByGzippingBytes:nil length:666 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByGzippingBytes:[data bytes] length:0 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByInflatingData:nil error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByInflatingBytes:nil length:666 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByInflatingBytes:[data bytes] length:0 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByRawDeflatingData:nil error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByRawDeflatingBytes:nil length:666 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByRawDeflatingBytes:[data bytes] length:0 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByRawInflatingData:nil error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByRawInflatingBytes:nil length:666 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertNil([NSData gtm_dataByRawInflatingBytes:[data bytes] length:0 error:&error]);
+  XCTAssertNil(error);
+  error = nil;
 
   // test deflate w/ compression levels out of range
   NSData *deflated = [NSData gtm_dataByDeflatingData:data
-                                    compressionLevel:-4];
-  STAssertNotNil(deflated, nil);
-  STAssertFalse(HasGzipHeader(deflated), nil);
-  NSData *dataPrime = [NSData gtm_dataByInflatingData:deflated];
-  STAssertNotNil(dataPrime, nil);
-  STAssertEqualObjects(data, dataPrime, nil);
+                                    compressionLevel:-4
+                                               error:&error];
+  XCTAssertNotNil(deflated);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertFalse(HasGzipHeader(deflated));
+  NSData *dataPrime = [NSData gtm_dataByInflatingData:deflated error:&error];
+  XCTAssertNotNil(dataPrime);
+  XCTAssertEqualObjects(data, dataPrime);
+  XCTAssertNil(error);
+  error = nil;
   deflated = [NSData gtm_dataByDeflatingData:data
-                             compressionLevel:20];
-  STAssertNotNil(deflated, nil);
-  STAssertFalse(HasGzipHeader(deflated), nil);
-  dataPrime = [NSData gtm_dataByInflatingData:deflated];
-  STAssertNotNil(dataPrime, nil);
-  STAssertEqualObjects(data, dataPrime, nil);
+                             compressionLevel:20
+                                       error:&error];
+  XCTAssertNotNil(deflated);
+  XCTAssertFalse(HasGzipHeader(deflated));
+  XCTAssertNil(error);
+  error = nil;
+  dataPrime = [NSData gtm_dataByInflatingData:deflated error:&error];
+  XCTAssertNotNil(dataPrime);
+  XCTAssertEqualObjects(data, dataPrime);
+  XCTAssertNil(error);
+  error = nil;
 
   // test gzip w/ compression levels out of range
   NSData *gzipped = [NSData gtm_dataByGzippingData:data
-                                   compressionLevel:-4];
-  STAssertNotNil(gzipped, nil);
-  STAssertTrue(HasGzipHeader(gzipped), nil);
-  dataPrime = [NSData gtm_dataByInflatingData:gzipped];
-  STAssertNotNil(dataPrime, nil);
-  STAssertEqualObjects(data, dataPrime, nil);
+                                   compressionLevel:-4
+                                             error:&error];
+  XCTAssertNotNil(gzipped);
+  XCTAssertNil(error);
+  error = nil;
+  XCTAssertTrue(HasGzipHeader(gzipped));
+  dataPrime = [NSData gtm_dataByInflatingData:gzipped error:&error];
+  XCTAssertNotNil(dataPrime);
+  XCTAssertEqualObjects(data, dataPrime);
+  XCTAssertNil(error);
+  error = nil;
   gzipped = [NSData gtm_dataByGzippingData:data
-                           compressionLevel:20];
-  STAssertNotNil(gzipped, nil);
-  STAssertTrue(HasGzipHeader(gzipped), nil);
-  dataPrime = [NSData gtm_dataByInflatingData:gzipped];
-  STAssertNotNil(dataPrime, nil);
-  STAssertEqualObjects(data, dataPrime, nil);
+                           compressionLevel:20
+                                     error:&error];
+  XCTAssertNotNil(gzipped);
+  XCTAssertTrue(HasGzipHeader(gzipped));
+  XCTAssertNil(error);
+  error = nil;
+  dataPrime = [NSData gtm_dataByInflatingData:gzipped error:&error];
+  XCTAssertNotNil(dataPrime);
+  XCTAssertEqualObjects(data, dataPrime);
+  XCTAssertNil(error);
+  error = nil;
 
   // test raw deflate w/ compression levels out of range
   NSData *rawDeflated = [NSData gtm_dataByRawDeflatingData:data
-                                          compressionLevel:-4];
-  STAssertNotNil(rawDeflated, nil);
-  STAssertFalse(HasGzipHeader(rawDeflated), nil);
-  dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated];
-  STAssertNotNil(dataPrime, nil);
-  STAssertEqualObjects(data, dataPrime, nil);
+                                          compressionLevel:-4
+                                                     error:&error];
+  XCTAssertNotNil(rawDeflated);
+  XCTAssertFalse(HasGzipHeader(rawDeflated));
+  XCTAssertNil(error);
+  error = nil;
+  dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated error:&error];
+  XCTAssertNotNil(dataPrime);
+  XCTAssertEqualObjects(data, dataPrime);
+  XCTAssertNil(error);
+  error = nil;
   rawDeflated = [NSData gtm_dataByRawDeflatingData:data
-                                  compressionLevel:20];
-  STAssertNotNil(rawDeflated, nil);
-  STAssertFalse(HasGzipHeader(rawDeflated), nil);
-  dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated];
-  STAssertNotNil(dataPrime, nil);
-  STAssertEqualObjects(data, dataPrime, nil);
+                                  compressionLevel:20
+                                             error:&error];
+  XCTAssertNotNil(rawDeflated);
+  XCTAssertFalse(HasGzipHeader(rawDeflated));
+  XCTAssertNil(error);
+  error = nil;
+  dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated error:&error];
+  XCTAssertNotNil(dataPrime);
+  XCTAssertEqualObjects(data, dataPrime);
+  XCTAssertNil(error);
+  error = nil;
 
   // test non-compressed data data itself
-  [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
-   @"payload, error -3: incorrect header check"];
-  STAssertNil([NSData gtm_dataByInflatingData:data], nil);
-
+  XCTAssertNil([NSData gtm_dataByInflatingData:data error:&error]);
+  GTMCheckZLibError(error, -3);
   // 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: (null)"];
   for (NSUInteger x = 1 ; x < [deflated length] ; x += 11) {
-    STAssertNil([NSData gtm_dataByInflatingBytes:[deflated bytes]
-                                          length:x], nil);
+    XCTAssertNil([NSData gtm_dataByInflatingBytes:[deflated bytes]
+                                           length:x
+                                            error:&error]);
+    GTMCheckZLibError(error, -5);
   }
 
   // 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: (null)"];
   for (NSUInteger x = 1 ; x < [gzipped length] ; x += 11) {
-    STAssertNil([NSData gtm_dataByInflatingBytes:[gzipped bytes]
-                                          length:x], nil);
+    XCTAssertNil([NSData gtm_dataByInflatingBytes:[gzipped bytes]
+                                           length:x
+                                            error:&error]);
+    GTMCheckZLibError(error, -5);
   }
 
   // test raw deflated data runs that end before they are done
-  [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
-   @"payload, error -5: (null)"];
-  [GTMUnitTestDevLog expect:([rawDeflated length] / 11) - 1
-              casesOfString:@"Error trying to inflate some of the payload, "
-   @"error -3: incorrect header check"];
   for (NSUInteger x = 1 ; x < [rawDeflated length] ; x += 11) {
-    STAssertNil([NSData gtm_dataByInflatingBytes:[rawDeflated bytes]
-                                          length:x], nil);
+    XCTAssertNil([NSData gtm_dataByInflatingBytes:[rawDeflated bytes]
+                                           length:x
+                                            error:&error]);
+    int expectedError = (x == 1) ? -5 : -3;
+    GTMCheckZLibError(error, expectedError);
   }
 
   // test extra data before the deflated/gzipped data (just to make sure we
   // don't seek to the "real" data)
   NSMutableData *prefixedDeflated =
     [NSMutableData dataWithBytes:randomDataSmall length:sizeof(randomDataSmall)];
-  STAssertNotNil(prefixedDeflated, @"failed to alloc data block");
+  XCTAssertNotNil(prefixedDeflated, @"failed to alloc data block");
   [prefixedDeflated appendData:deflated];
-  [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
-   @"payload, error -3: incorrect header check"];
-  STAssertNil([NSData gtm_dataByInflatingData:prefixedDeflated], nil);
-  [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
-   @"payload, error -3: incorrect header check"];
-  STAssertNil([NSData gtm_dataByInflatingBytes:[prefixedDeflated bytes]
-                                        length:[prefixedDeflated length]],
-              nil);
+  XCTAssertNil([NSData gtm_dataByInflatingData:prefixedDeflated error:&error]);
+  GTMCheckZLibError(error, -3);
+  XCTAssertNil([NSData gtm_dataByInflatingBytes:[prefixedDeflated bytes]
+                                         length:[prefixedDeflated length]
+                                          error:&error]);
+  GTMCheckZLibError(error, -3);
   NSMutableData *prefixedGzipped =
     [NSMutableData dataWithBytes:randomDataSmall length:sizeof(randomDataSmall)];
-  STAssertNotNil(prefixedDeflated, @"failed to alloc data block");
+  XCTAssertNotNil(prefixedDeflated, @"failed to alloc data block");
   [prefixedGzipped appendData:gzipped];
-  [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
-   @"payload, error -3: incorrect header check"];
-  STAssertNil([NSData gtm_dataByInflatingData:prefixedGzipped], nil);
-  [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
-   @"payload, error -3: incorrect header check"];
-  STAssertNil([NSData gtm_dataByInflatingBytes:[prefixedGzipped bytes]
-                                        length:[prefixedGzipped length]],
-              nil);
+  XCTAssertNil([NSData gtm_dataByInflatingData:prefixedGzipped error:&error]);
+  GTMCheckZLibError(error, -3);
+  XCTAssertNil([NSData gtm_dataByInflatingBytes:[prefixedGzipped bytes]
+                                         length:[prefixedGzipped length]
+                                          error:&error]);
+  GTMCheckZLibError(error, -3);
   NSMutableData *prefixedRawDeflated =
     [NSMutableData dataWithBytes:randomDataSmall length:sizeof(randomDataSmall)];
-  STAssertNotNil(prefixedRawDeflated, @"failed to alloc data block");
+  XCTAssertNotNil(prefixedRawDeflated, @"failed to alloc data block");
   [prefixedRawDeflated appendData:rawDeflated];
-  [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
-   @"payload, error -3: invalid stored block lengths"];
-  STAssertNil([NSData gtm_dataByRawInflatingData:prefixedRawDeflated], nil);
-  [GTMUnitTestDevLog expectString:@"Error trying to inflate some of the "
-   @"payload, error -3: invalid stored block lengths"];
-  STAssertNil([NSData gtm_dataByRawInflatingBytes:[prefixedRawDeflated bytes]
-                                           length:[prefixedRawDeflated length]],
-              nil);
+  XCTAssertNil([NSData gtm_dataByRawInflatingData:prefixedRawDeflated error:&error]);
+  GTMCheckZLibError(error, -3);
+  XCTAssertNil([NSData gtm_dataByRawInflatingBytes:[prefixedRawDeflated bytes]
+                                            length:[prefixedRawDeflated length]
+                                             error:&error]);
+  GTMCheckZLibError(error, -3);
 
   // test extra data after the deflated/gzipped data (just to make sure we
   // don't ignore some of the data)
   NSMutableData *suffixedDeflated = [NSMutableData data];
-  STAssertNotNil(suffixedDeflated, @"failed to alloc data block");
+  XCTAssertNotNil(suffixedDeflated, @"failed to alloc data block");
   [suffixedDeflated appendData:deflated];
   [suffixedDeflated appendBytes:[data bytes] length:20];
-  [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
-   @"all input, 20 bytes left"];
-  STAssertNil([NSData gtm_dataByInflatingData:suffixedDeflated], nil);
-  [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
-   @"all input, 20 bytes left"];
-  STAssertNil([NSData gtm_dataByInflatingBytes:[suffixedDeflated bytes]
-                                        length:[suffixedDeflated length]],
-              nil);
+  XCTAssertNil([NSData gtm_dataByInflatingData:suffixedDeflated
+                                         error:&error]);
+  GTMCheckRemainingError(error, 20);
+  XCTAssertNil([NSData gtm_dataByInflatingBytes:[suffixedDeflated bytes]
+                                         length:[suffixedDeflated length]
+                                          error:&error]);
+  GTMCheckRemainingError(error, 20);
   NSMutableData *suffixedGZipped = [NSMutableData data];
-  STAssertNotNil(suffixedGZipped, @"failed to alloc data block");
+  XCTAssertNotNil(suffixedGZipped, @"failed to alloc data block");
   [suffixedGZipped appendData:gzipped];
   [suffixedGZipped appendBytes:[data bytes] length:20];
-  [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
-   @"all input, 20 bytes left"];
-  STAssertNil([NSData gtm_dataByInflatingData:suffixedGZipped], nil);
-  [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
-   @"all input, 20 bytes left"];
-  STAssertNil([NSData gtm_dataByInflatingBytes:[suffixedGZipped bytes]
-                                        length:[suffixedGZipped length]],
-              nil);
+  XCTAssertNil([NSData gtm_dataByInflatingData:suffixedGZipped error:&error]);
+  GTMCheckRemainingError(error, 20);
+  XCTAssertNil([NSData gtm_dataByInflatingBytes:[suffixedGZipped bytes]
+                                         length:[suffixedGZipped length]
+                                          error:&error]);
+  GTMCheckRemainingError(error, 20);
   NSMutableData *suffixedRawDeflated = [NSMutableData data];
-  STAssertNotNil(suffixedRawDeflated, @"failed to alloc data block");
+  XCTAssertNotNil(suffixedRawDeflated, @"failed to alloc data block");
   [suffixedRawDeflated appendData:rawDeflated];
   [suffixedRawDeflated appendBytes:[data bytes] length:20];
-  [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
-   @"all input, 20 bytes left"];
-  STAssertNil([NSData gtm_dataByRawInflatingData:suffixedRawDeflated], nil);
-  [GTMUnitTestDevLog expectString:@"thought we finished inflate w/o using "
-   @"all input, 20 bytes left"];
-  STAssertNil([NSData gtm_dataByRawInflatingBytes:[suffixedRawDeflated bytes]
-                                           length:[suffixedRawDeflated length]],
-              nil);
+  XCTAssertNil([NSData gtm_dataByRawInflatingData:suffixedRawDeflated  error:&error]);
+  GTMCheckRemainingError(error, 20);
+  XCTAssertNil([NSData gtm_dataByRawInflatingBytes:[suffixedRawDeflated bytes]
+                                            length:[suffixedRawDeflated length]
+                                             error:&error]);
+  GTMCheckRemainingError(error, 20);
 }
 
 - (void)testInflateDeflate {
   NSData *data = [NSData dataWithBytes:randomDataLarge
                                 length:sizeof(randomDataLarge)];
-  STAssertNotNil(data, @"failed to alloc data block");
+  XCTAssertNotNil(data, @"failed to alloc data block");
 
   // w/ *Bytes apis, default level
+  NSError *error = nil;
   NSData *deflated = [NSData gtm_dataByDeflatingBytes:[data bytes]
-                                               length:[data length]];
-  STAssertNotNil(deflated, @"failed to deflate data block");
-  STAssertGreaterThan([deflated length],
-                      (NSUInteger)0, @"failed to deflate data block");
-  STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
+                                               length:[data length]
+                                                error:&error];
+  XCTAssertNotNil(deflated, @"failed to deflate data block");
+  XCTAssertGreaterThan([deflated length], (NSUInteger)0,
+                       @"failed to deflate data block");
+  XCTAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
+  XCTAssertNil(error);
+  error = nil;
+
   NSData *dataPrime = [NSData gtm_dataByInflatingBytes:[deflated bytes]
-                                                length:[deflated length]];
-  STAssertNotNil(dataPrime, @"failed to inflate data block");
-  STAssertGreaterThan([dataPrime length],
-                      (NSUInteger)0, @"failed to inflate data block");
-  STAssertEqualObjects(data,
-                       dataPrime, @"failed to round trip via *Bytes apis");
+                                                length:[deflated length]
+                                                 error:&error];
+  XCTAssertNotNil(dataPrime, @"failed to inflate data block");
+  XCTAssertGreaterThan([dataPrime length], (NSUInteger)0,
+                       @"failed to inflate data block");
+  XCTAssertEqualObjects(data, dataPrime,
+                        @"failed to round trip via *Bytes apis");
+  XCTAssertNil(error);
+  error = nil;
 
   // w/ *Data apis, default level
-  deflated = [NSData gtm_dataByDeflatingData:data];
-  STAssertNotNil(deflated, @"failed to deflate data block");
-  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],
-                      (NSUInteger)0, @"failed to inflate data block");
-  STAssertEqualObjects(data,
-                       dataPrime, @"failed to round trip via *Data apis");
+  deflated = [NSData gtm_dataByDeflatingData:data  error:&error];
+  XCTAssertNotNil(deflated, @"failed to deflate data block");
+  XCTAssertGreaterThan([deflated length], (NSUInteger)0,
+                       @"failed to deflate data block");
+  XCTAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
+  XCTAssertNil(error);
+  error = nil;
+  dataPrime = [NSData gtm_dataByInflatingData:deflated error:&error];
+
+  XCTAssertNotNil(dataPrime, @"failed to inflate data block");
+  XCTAssertGreaterThan([dataPrime length], (NSUInteger)0,
+                       @"failed to inflate data block");
+  XCTAssertEqualObjects(data, dataPrime,
+                        @"failed to round trip via *Data apis");
+  XCTAssertNil(error);
+  error = nil;
 
   // loop over the compression levels
   for (int level = 1 ; level <= 9 ; ++level) {
     // w/ *Bytes apis, using our level
     deflated = [NSData gtm_dataByDeflatingBytes:[data bytes]
                                          length:[data length]
-                               compressionLevel:level];
-    STAssertNotNil(deflated, @"failed to deflate data block");
-    STAssertGreaterThan([deflated length],
-                        (NSUInteger)0, @"failed to deflate data block");
-    STAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
+                               compressionLevel:level
+                                          error:&error];
+    XCTAssertNotNil(deflated, @"failed to deflate data block");
+    XCTAssertGreaterThan([deflated length],
+                         (NSUInteger)0, @"failed to deflate data block");
+    XCTAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
+    XCTAssertNil(error);
+    error = nil;
     dataPrime = [NSData gtm_dataByInflatingBytes:[deflated bytes]
-                                          length:[deflated length]];
-    STAssertNotNil(dataPrime, @"failed to inflate data block");
-    STAssertGreaterThan([dataPrime length],
-                        (NSUInteger)0, @"failed to inflate data block");
-    STAssertEqualObjects(data,
-                         dataPrime, @"failed to round trip via *Bytes apis");
+                                          length:[deflated length]
+                                           error:&error];
+    XCTAssertNotNil(dataPrime, @"failed to inflate data block");
+    XCTAssertGreaterThan([dataPrime length],
+                         (NSUInteger)0, @"failed to inflate data block");
+    XCTAssertEqualObjects(data,
+                          dataPrime, @"failed to round trip via *Bytes apis");
+    XCTAssertNil(error);
+    error = nil;
 
     // w/ *Data apis, using our level
-    deflated = [NSData gtm_dataByDeflatingData:data compressionLevel:level];
-    STAssertNotNil(deflated, @"failed to deflate data block");
-    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],
-                        (NSUInteger)0, @"failed to inflate data block");
-    STAssertEqualObjects(data,
-                         dataPrime, @"failed to round trip via *Data apis");
+    deflated = [NSData gtm_dataByDeflatingData:data compressionLevel:level error:&error];
+    XCTAssertNotNil(deflated, @"failed to deflate data block");
+    XCTAssertGreaterThan([deflated length],
+                         (NSUInteger)0, @"failed to deflate data block");
+    XCTAssertFalse(HasGzipHeader(deflated), @"has gzip header on zlib data");
+    XCTAssertNil(error);
+    error = nil;
+    dataPrime = [NSData gtm_dataByInflatingData:deflated error:&error];
+    XCTAssertNotNil(dataPrime, @"failed to inflate data block");
+    XCTAssertGreaterThan([dataPrime length],
+                         (NSUInteger)0, @"failed to inflate data block");
+    XCTAssertEqualObjects(data,
+                          dataPrime, @"failed to round trip via *Data apis");
+    XCTAssertNil(error);
+    error = nil;
   }
 }
 
 - (void)testInflateGzip {
   NSData *data = [NSData dataWithBytes:randomDataLarge
                                 length:sizeof(randomDataLarge)];
-  STAssertNotNil(data, @"failed to alloc data block");
+  XCTAssertNotNil(data, @"failed to alloc data block");
 
   // w/ *Bytes apis, default level
+  NSError *error = nil;
   NSData *gzipped = [NSData gtm_dataByGzippingBytes:[data bytes]
                                              length:[data length]];
-  STAssertNotNil(gzipped, @"failed to gzip data block");
-  STAssertGreaterThan([gzipped length],
-                      (NSUInteger)0, @"failed to gzip data block");
-  STAssertTrue(HasGzipHeader(gzipped),
-               @"doesn't have gzip header on gzipped data");
+  XCTAssertNotNil(gzipped, @"failed to gzip data block");
+  XCTAssertGreaterThan([gzipped length],
+                       (NSUInteger)0, @"failed to gzip data block");
+  XCTAssertTrue(HasGzipHeader(gzipped),
+                @"doesn't have gzip header on gzipped data");
   NSData *dataPrime = [NSData gtm_dataByInflatingBytes:[gzipped bytes]
-                                                length:[gzipped length]];
-  STAssertNotNil(dataPrime, @"failed to inflate data block");
-  STAssertGreaterThan([dataPrime length],
-                      (NSUInteger)0, @"failed to inflate data block");
-  STAssertEqualObjects(data,
-                       dataPrime, @"failed to round trip via *Bytes apis");
+                                                length:[gzipped length]
+                                                 error:&error];
+  XCTAssertNotNil(dataPrime, @"failed to inflate data block");
+  XCTAssertGreaterThan([dataPrime length],
+                       (NSUInteger)0, @"failed to inflate data block");
+  XCTAssertEqualObjects(data,
+                        dataPrime, @"failed to round trip via *Bytes apis");
+  XCTAssertNil(error);
+  error = nil;
 
   // w/ *Data apis, default level
-  gzipped = [NSData gtm_dataByGzippingData:data];
-  STAssertNotNil(gzipped, @"failed to gzip data block");
-  STAssertGreaterThan([gzipped length],
+  gzipped = [NSData gtm_dataByGzippingData:data error:&error];
+  XCTAssertNotNil(gzipped, @"failed to gzip data block");
+  XCTAssertGreaterThan([gzipped length],
                       (NSUInteger)0, @"failed to gzip data block");
-  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],
-                      (NSUInteger)0, @"failed to inflate data block");
-  STAssertEqualObjects(data, dataPrime,
-                       @"failed to round trip via *Data apis");
+  XCTAssertTrue(HasGzipHeader(gzipped),
+                @"doesn't have gzip header on gzipped data");
+  XCTAssertNil(error);
+  error = nil;
+  dataPrime = [NSData gtm_dataByInflatingData:gzipped error:&error];
+  XCTAssertNotNil(dataPrime, @"failed to inflate data block");
+  XCTAssertGreaterThan([dataPrime length],
+                       (NSUInteger)0, @"failed to inflate data block");
+  XCTAssertEqualObjects(data, dataPrime,
+                        @"failed to round trip via *Data apis");
+  XCTAssertNil(error);
+  error = nil;
 
   // loop over the compression levels
   for (int level = 1 ; level <= 9 ; ++level) {
     // w/ *Bytes apis, using our level
     gzipped = [NSData gtm_dataByGzippingBytes:[data bytes]
                                        length:[data length]
-                             compressionLevel:level];
-    STAssertNotNil(gzipped, @"failed to gzip data block");
-    STAssertGreaterThan([gzipped length],
-                        (NSUInteger)0, @"failed to gzip data block");
-    STAssertTrue(HasGzipHeader(gzipped),
-                 @"doesn't have gzip header on gzipped data");
+                             compressionLevel:level
+                                        error:&error];
+    XCTAssertNotNil(gzipped, @"failed to gzip data block");
+    XCTAssertGreaterThan([gzipped length],
+                         (NSUInteger)0, @"failed to gzip data block");
+    XCTAssertTrue(HasGzipHeader(gzipped),
+                  @"doesn't have gzip header on gzipped data");
+    XCTAssertNil(error);
+    error = nil;
     dataPrime = [NSData gtm_dataByInflatingBytes:[gzipped bytes]
-                                          length:[gzipped length]];
-    STAssertNotNil(dataPrime, @"failed to inflate data block");
-    STAssertGreaterThan([dataPrime length],
-                        (NSUInteger)0, @"failed to inflate data block");
-    STAssertEqualObjects(data, dataPrime,
-                         @"failed to round trip via *Bytes apis");
+                                          length:[gzipped length]
+                                           error:&error];
+    XCTAssertNotNil(dataPrime, @"failed to inflate data block");
+    XCTAssertGreaterThan([dataPrime length],
+                         (NSUInteger)0, @"failed to inflate data block");
+    XCTAssertEqualObjects(data, dataPrime,
+                          @"failed to round trip via *Bytes apis");
+    XCTAssertNil(error);
+    error = nil;
 
     // w/ *Data apis, using our level
-    gzipped = [NSData gtm_dataByGzippingData:data compressionLevel:level];
-    STAssertNotNil(gzipped, @"failed to gzip data block");
-    STAssertGreaterThan([gzipped length],
-                        (NSUInteger)0, @"failed to gzip data block");
-    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],
-                        (NSUInteger)0, @"failed to inflate data block");
-    STAssertEqualObjects(data,
-                         dataPrime, @"failed to round trip via *Data apis");
+    gzipped = [NSData gtm_dataByGzippingData:data compressionLevel:level error:&error];
+    XCTAssertNotNil(gzipped, @"failed to gzip data block");
+    XCTAssertGreaterThan([gzipped length],
+                         (NSUInteger)0, @"failed to gzip data block");
+    XCTAssertTrue(HasGzipHeader(gzipped),
+                  @"doesn't have gzip header on gzipped data");
+    XCTAssertNil(error);
+    error = nil;
+    dataPrime = [NSData gtm_dataByInflatingData:gzipped error:&error];
+    XCTAssertNotNil(dataPrime, @"failed to inflate data block");
+    XCTAssertGreaterThan([dataPrime length],
+                         (NSUInteger)0, @"failed to inflate data block");
+    XCTAssertEqualObjects(data,
+                          dataPrime, @"failed to round trip via *Data apis");
+    XCTAssertNil(error);
+    error = nil;
   }
 }
 
 - (void)testRawtInflateRawDeflate {
+  NSError *error = nil;
   NSData *data = [NSData dataWithBytes:randomDataLarge
                                 length:sizeof(randomDataLarge)];
-  STAssertNotNil(data, @"failed to alloc data block");
+  XCTAssertNotNil(data, @"failed to alloc data block");
 
   // w/ *Bytes apis, default level
   NSData *rawDeflated = [NSData gtm_dataByRawDeflatingBytes:[data bytes]
-                                                     length:[data length]];
-  STAssertNotNil(rawDeflated, @"failed to raw deflate data block");
-  STAssertGreaterThan([rawDeflated length],
-                      (NSUInteger)0, @"failed to raw deflate data block");
-  STAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
+                                                     length:[data length]
+                                                      error:&error];
+  XCTAssertNotNil(rawDeflated, @"failed to raw deflate data block");
+  XCTAssertGreaterThan([rawDeflated length],
+                       (NSUInteger)0, @"failed to raw deflate data block");
+  XCTAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
+  XCTAssertNil(error);
+  error = nil;
   NSData *dataPrime = [NSData gtm_dataByRawInflatingBytes:[rawDeflated bytes]
-                                                   length:[rawDeflated length]];
-  STAssertNotNil(dataPrime, @"failed to raw inflate data block");
-  STAssertGreaterThan([dataPrime length],
-                      (NSUInteger)0, @"failed to raw inflate data block");
-  STAssertEqualObjects(data,
-                       dataPrime, @"failed to round trip via *Bytes apis");
+                                                   length:[rawDeflated length]
+                                                    error:&error];
+  XCTAssertNotNil(dataPrime, @"failed to raw inflate data block");
+  XCTAssertGreaterThan([dataPrime length],
+                       (NSUInteger)0, @"failed to raw inflate data block");
+  XCTAssertEqualObjects(data,
+                        dataPrime, @"failed to round trip via *Bytes apis");
+  XCTAssertNil(error);
+  error = nil;
 
   // w/ *Data apis, default level
-  rawDeflated = [NSData gtm_dataByRawDeflatingData:data];
-  STAssertNotNil(rawDeflated, @"failed to raw deflate data block");
-  STAssertGreaterThan([rawDeflated length],
-                      (NSUInteger)0, @"failed to raw deflate data block");
-  STAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
-  dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated];
-  STAssertNotNil(dataPrime, @"failed to raw inflate data block");
-  STAssertGreaterThan([dataPrime length],
-                      (NSUInteger)0, @"failed to raw inflate data block");
-  STAssertEqualObjects(data,
-                       dataPrime, @"failed to round trip via *Data apis");
+  rawDeflated = [NSData gtm_dataByRawDeflatingData:data error:&error];
+  XCTAssertNotNil(rawDeflated, @"failed to raw deflate data block");
+  XCTAssertGreaterThan([rawDeflated length],
+                       (NSUInteger)0, @"failed to raw deflate data block");
+  XCTAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
+  XCTAssertNil(error);
+  error = nil;
+  dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated error:&error];
+  XCTAssertNotNil(dataPrime, @"failed to raw inflate data block");
+  XCTAssertGreaterThan([dataPrime length],
+                       (NSUInteger)0, @"failed to raw inflate data block");
+  XCTAssertEqualObjects(data,
+                        dataPrime, @"failed to round trip via *Data apis");
+  XCTAssertNil(error);
+  error = nil;
 
   // loop over the compression levels
   for (int level = 1 ; level <= 9 ; ++level) {
     // w/ *Bytes apis, using our level
     rawDeflated = [NSData gtm_dataByRawDeflatingBytes:[data bytes]
                                                length:[data length]
-                                     compressionLevel:level];
-    STAssertNotNil(rawDeflated, @"failed to rawDeflate data block");
-    STAssertGreaterThan([rawDeflated length],
-                        (NSUInteger)0, @"failed to raw deflate data block");
-    STAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
+                                     compressionLevel:level
+                                                error:&error];
+    XCTAssertNotNil(rawDeflated, @"failed to rawDeflate data block");
+    XCTAssertGreaterThan([rawDeflated length],
+                         (NSUInteger)0, @"failed to raw deflate data block");
+    XCTAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
+    XCTAssertNil(error);
+    error = nil;
     dataPrime = [NSData gtm_dataByRawInflatingBytes:[rawDeflated bytes]
-                                             length:[rawDeflated length]];
-    STAssertNotNil(dataPrime, @"failed to raw inflate data block");
-    STAssertGreaterThan([dataPrime length],
-                        (NSUInteger)0, @"failed to raw inflate data block");
-    STAssertEqualObjects(data,
-                         dataPrime, @"failed to round trip via *Bytes apis");
+                                             length:[rawDeflated length]
+                                              error:&error];
+    XCTAssertNotNil(dataPrime, @"failed to raw inflate data block");
+    XCTAssertGreaterThan([dataPrime length],
+                         (NSUInteger)0, @"failed to raw inflate data block");
+    XCTAssertEqualObjects(data,
+                          dataPrime, @"failed to round trip via *Bytes apis");
+    XCTAssertNil(error);
+    error = nil;
 
     // w/ *Data apis, using our level
     rawDeflated = [NSData gtm_dataByRawDeflatingData:data
-                                    compressionLevel:level];
-    STAssertNotNil(rawDeflated, @"failed to deflate data block");
-    STAssertGreaterThan([rawDeflated length],
-                        (NSUInteger)0, @"failed to raw deflate data block");
-    STAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
-    dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated];
-    STAssertNotNil(dataPrime, @"failed to raw inflate data block");
-    STAssertGreaterThan([dataPrime length],
-                        (NSUInteger)0, @"failed to raw inflate data block");
-    STAssertEqualObjects(data,
-                         dataPrime, @"failed to round trip via *Data apis");
+                                    compressionLevel:level
+                                               error:&error];
+    XCTAssertNotNil(rawDeflated, @"failed to deflate data block");
+    XCTAssertGreaterThan([rawDeflated length],
+                         (NSUInteger)0, @"failed to raw deflate data block");
+    XCTAssertFalse(HasGzipHeader(rawDeflated), @"has gzip header on raw data");
+    XCTAssertNil(error);
+    error = nil;
+    dataPrime = [NSData gtm_dataByRawInflatingData:rawDeflated error:&error];
+    XCTAssertNotNil(dataPrime, @"failed to raw inflate data block");
+    XCTAssertGreaterThan([dataPrime length],
+                         (NSUInteger)0, @"failed to raw inflate data block");
+    XCTAssertEqualObjects(data,
+                          dataPrime, @"failed to round trip via *Data apis");
+    XCTAssertNil(error);
+    error = nil;
   }
 }
 
 - (void)testLargeData {
   // Generate some large data out of the random chunk by xoring over it
   // to make sure it changes and isn't too repeated.
+  NSError *error = nil;
   NSData *data = [NSData dataWithBytes:randomDataLarge
                                 length:sizeof(randomDataLarge)];
-  STAssertNotNil(data, @"failed to alloc data block");
+  XCTAssertNotNil(data, @"failed to alloc data block");
   const uint8_t *dataBytes = [data bytes];
   NSMutableData *scratch = [NSMutableData dataWithLength:[data length]];
-  STAssertNotNil(scratch, @"failed to alloc data block");
+  XCTAssertNotNil(scratch, @"failed to alloc data block");
   uint8_t *scratchBytes = [scratch mutableBytes];
   NSMutableData *input = [NSMutableData dataWithCapacity:200 * [data length]];
   for (NSUInteger i = 0; i < 200; ++i) {
@@ -505,22 +625,27 @@ static BOOL HasGzipHeader(NSData *data) {
   // Should deflate to more then one buffer size to make sure the internal loop
   // is working.
   NSData *compressed = [NSData gtm_dataByDeflatingData:input
-                                      compressionLevel:9];
-  STAssertNotNil(compressed, @"failed to deflate");
-  STAssertGreaterThan([compressed length], internalBufferSize,
-                      @"should have been more then %d bytes",
-                      (int)internalBufferSize);
+                                      compressionLevel:9
+                                                 error:&error];
+  XCTAssertNotNil(compressed, @"failed to deflate");
+  XCTAssertGreaterThan([compressed length], internalBufferSize,
+                       @"should have been more then %d bytes",
+                       (int)internalBufferSize);
+  XCTAssertNil(error);
+  error = nil;
 
   // Should inflate to more then one buffer size to make sure the internal loop
   // is working.
-  NSData *uncompressed = [NSData gtm_dataByInflatingData:compressed];
-  STAssertNotNil(uncompressed, @"fail to inflate");
-  STAssertGreaterThan([uncompressed length], internalBufferSize,
-                      @"should have been more then %d bytes",
-                      (int)internalBufferSize);
-
-  STAssertEqualObjects(uncompressed, input,
-                       @"didn't get the same thing back");
+  NSData *uncompressed = [NSData gtm_dataByInflatingData:compressed error:&error];
+  XCTAssertNotNil(uncompressed, @"fail to inflate");
+  XCTAssertGreaterThan([uncompressed length], internalBufferSize,
+                       @"should have been more then %d bytes",
+                       (int)internalBufferSize);
+
+  XCTAssertEqualObjects(uncompressed, input,
+                        @"didn't get the same thing back");
+  XCTAssertNil(error);
+  error = nil;
 }
 
 @end