Clang-formatting Storage

9 files changed, 469 insertions, 475 deletions

diff --git a/Example/Storage/Tests/Integration/FIRStorageIntegrationTests.m b/Example/Storage/Tests/Integration/FIRStorageIntegrationTests.m
index 0e07d97..8c7f972 100644
--- a/Example/Storage/Tests/Integration/FIRStorageIntegrationTests.m
+++ b/Example/Storage/Tests/Integration/FIRStorageIntegrationTests.m
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#import <math.h>
 #import <XCTest/XCTest.h>
+#import <math.h>
 
 #import "FirebaseStorage.h"
 
@@ -56,427 +56,428 @@ NSTimeInterval kFIRStorageIntegrationTestTimeout = 30;
 
 @implementation FIRStorageIntegrationTests
 
-
 + (void)setUp {
-    [FIRApp configure];
+  [FIRApp configure];
 }
 
 - (void)setUp {
-    [super setUp];
+  [super setUp];
 
-    self.app = [FIRApp defaultApp];
-    self.storage = [FIRStorage storageForApp:self.app];
+  self.app = [FIRApp defaultApp];
+  self.storage = [FIRStorage storageForApp:self.app];
 
-    static dispatch_once_t once;
-    dispatch_once(&once, ^{
-        XCTestExpectation *expectation = [self expectationWithDescription:@"setup"];
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    XCTestExpectation *expectation = [self expectationWithDescription:@"setup"];
 
-        FIRStorageReference *ref = [[FIRStorage storage].reference child:@"ios/public/1mb"];
-        NSData *data = [NSData dataWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"1mb" ofType:@"dat"]];
-        XCTAssertNotNil(data, "Could not load bundled file");
-        [ref putData:data metadata:nil completion:^(FIRStorageMetadata *metadata, NSError *error) {
-            XCTAssertNil(error);
-            [expectation fulfill];
+    FIRStorageReference *ref = [[FIRStorage storage].reference child:@"ios/public/1mb"];
+    NSData *data = [NSData
+        dataWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"1mb" ofType:@"dat"]];
+    XCTAssertNotNil(data, "Could not load bundled file");
+    [ref putData:data
+          metadata:nil
+        completion:^(FIRStorageMetadata *metadata, NSError *error) {
+          XCTAssertNil(error);
+          [expectation fulfill];
         }];
 
-        [self waitForExpectations];
-    });
+    [self waitForExpectations];
+  });
 }
 
 - (void)tearDown {
-    self.app = nil;
-    self.storage = nil;
+  self.app = nil;
+  self.storage = nil;
 
-    [super tearDown];
+  [super tearDown];
 }
 
 - (void)testName {
-    NSString *aGSURI = [NSString stringWithFormat:@"gs://%@.appspot.com/path/to", [[FIRApp defaultApp] options].projectID];
-    FIRStorageReference *ref = [self.storage referenceForURL:aGSURI];
-    XCTAssertEqualObjects(ref.description, aGSURI);
+  NSString *aGSURI = [NSString
+      stringWithFormat:@"gs://%@.appspot.com/path/to", [[FIRApp defaultApp] options].projectID];
+  FIRStorageReference *ref = [self.storage referenceForURL:aGSURI];
+  XCTAssertEqualObjects(ref.description, aGSURI);
 }
 
 - (void)testUnauthenticatedGetMetadata {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedGetMetadata"];
-    FIRStorageReference *ref = [self.storage.reference child:@"ios/public/1mb"];
+  FIRStorageReference *ref = [self.storage.reference child:@"ios/public/1mb"];
 
-    [ref metadataWithCompletion:^(FIRStorageMetadata *metadata, NSError *error) {
-        XCTAssertNotNil(metadata, "Metadata should not be nil");
-        XCTAssertNil(error, "Error should be nil");
-        [expectation fulfill];
-    }];
+  [ref metadataWithCompletion:^(FIRStorageMetadata *metadata, NSError *error) {
+    XCTAssertNotNil(metadata, "Metadata should not be nil");
+    XCTAssertNil(error, "Error should be nil");
+    [expectation fulfill];
+  }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedUpdateMetadata {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedUpdateMetadata"];
 
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
-
-    FIRStorageMetadata *meta = [[FIRStorageMetadata alloc] init];
-    [meta setContentType:@"lol/custom"];
-    [meta setCustomMetadata:@{
-                              @"lol" : @"custom metadata is neat",
-                              @"ちかてつ" : @"🚇",
-                              @"shinkansen" : @"新幹線"
-                              }];
-
-    [ref updateMetadata:meta
-             completion:^(FIRStorageMetadata *metadata, NSError *error) {
-                 XCTAssertEqualObjects(meta.contentType, metadata.contentType);
-                 XCTAssertEqualObjects(meta.customMetadata[@"lol"],
-                                       metadata.customMetadata[@"lol"]);
-                 XCTAssertEqualObjects(meta.customMetadata[@"ちかてつ"],
-                                       metadata.customMetadata[@"ちかてつ"]);
-                 XCTAssertEqualObjects(meta.customMetadata[@"shinkansen"],
-                                       metadata.customMetadata[@"shinkansen"]);
-                 XCTAssertNil(error, "Error should be nil");
-                 [expectation fulfill];
-             }];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
+
+  FIRStorageMetadata *meta = [[FIRStorageMetadata alloc] init];
+  [meta setContentType:@"lol/custom"];
+  [meta setCustomMetadata:@{
+    @"lol" : @"custom metadata is neat",
+    @"ちかてつ" : @"🚇",
+    @"shinkansen" : @"新幹線"
+  }];
+
+  [ref updateMetadata:meta
+           completion:^(FIRStorageMetadata *metadata, NSError *error) {
+             XCTAssertEqualObjects(meta.contentType, metadata.contentType);
+             XCTAssertEqualObjects(meta.customMetadata[@"lol"], metadata.customMetadata[@"lol"]);
+             XCTAssertEqualObjects(meta.customMetadata[@"ちかてつ"],
+                                   metadata.customMetadata[@"ちかてつ"]);
+             XCTAssertEqualObjects(meta.customMetadata[@"shinkansen"],
+                                   metadata.customMetadata[@"shinkansen"]);
+             XCTAssertNil(error, "Error should be nil");
+             [expectation fulfill];
+           }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedDelete {
-    XCTestExpectation *expectation = [self expectationWithDescription:@"testUnauthenticatedDelete"];
+  XCTestExpectation *expectation = [self expectationWithDescription:@"testUnauthenticatedDelete"];
 
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/fileToDelete"];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/fileToDelete"];
 
-    NSData *data = [@"Delete me!!!!!!!" dataUsingEncoding:NSUTF8StringEncoding];
+  NSData *data = [@"Delete me!!!!!!!" dataUsingEncoding:NSUTF8StringEncoding];
 
-    [ref putData:data
+  [ref putData:data
         metadata:nil
       completion:^(FIRStorageMetadata *metadata, NSError *error) {
-          XCTAssertNotNil(metadata, "Metadata should not be nil");
+        XCTAssertNotNil(metadata, "Metadata should not be nil");
+        XCTAssertNil(error, "Error should be nil");
+        [ref deleteWithCompletion:^(NSError *error) {
           XCTAssertNil(error, "Error should be nil");
-          [ref deleteWithCompletion:^(NSError *error) {
-              XCTAssertNil(error, "Error should be nil");
-              [expectation fulfill];
-          }];
+          [expectation fulfill];
+        }];
       }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testDeleteWithNilCompletion {
-    XCTestExpectation *expectation = [self expectationWithDescription:@"testDeleteWithNilCompletion"];
+  XCTestExpectation *expectation = [self expectationWithDescription:@"testDeleteWithNilCompletion"];
 
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/fileToDelete"];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/fileToDelete"];
 
-    NSData *data = [@"Delete me!!!!!!!" dataUsingEncoding:NSUTF8StringEncoding];
+  NSData *data = [@"Delete me!!!!!!!" dataUsingEncoding:NSUTF8StringEncoding];
 
-    [ref putData:data
+  [ref putData:data
         metadata:nil
       completion:^(FIRStorageMetadata *metadata, NSError *error) {
-          XCTAssertNotNil(metadata, "Metadata should not be nil");
-          XCTAssertNil(error, "Error should be nil");
-          [ref deleteWithCompletion:nil];
-          [expectation fulfill];
+        XCTAssertNotNil(metadata, "Metadata should not be nil");
+        XCTAssertNil(error, "Error should be nil");
+        [ref deleteWithCompletion:nil];
+        [expectation fulfill];
       }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedSimplePutData {
-    XCTestExpectation *expectation =
-    [self expectationWithDescription:@"testUnauthenticatedSimplePutData"];
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/testBytesUpload"];
+  XCTestExpectation *expectation =
+      [self expectationWithDescription:@"testUnauthenticatedSimplePutData"];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/testBytesUpload"];
 
-    NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
+  NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
 
-    [ref putData:data
+  [ref putData:data
         metadata:nil
       completion:^(FIRStorageMetadata *metadata, NSError *error) {
-          XCTAssertNotNil(metadata, "Metadata should not be nil");
-          XCTAssertNil(error, "Error should be nil");
-          [expectation fulfill];
+        XCTAssertNotNil(metadata, "Metadata should not be nil");
+        XCTAssertNil(error, "Error should be nil");
+        [expectation fulfill];
       }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedSimplePutEmptyData {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedSimplePutEmptyData"];
 
-    FIRStorageReference *ref =
+  FIRStorageReference *ref =
       [self.storage referenceWithPath:@"ios/public/testUnauthenticatedSimplePutEmptyData"];
 
-    NSData *data = [[NSData alloc] init];
+  NSData *data = [[NSData alloc] init];
 
-    [ref putData:data
+  [ref putData:data
         metadata:nil
       completion:^(FIRStorageMetadata *metadata, NSError *error) {
-          XCTAssertNotNil(metadata, "Metadata should not be nil");
-          XCTAssertNil(error, "Error should be nil");
-          [expectation fulfill];
+        XCTAssertNotNil(metadata, "Metadata should not be nil");
+        XCTAssertNil(error, "Error should be nil");
+        [expectation fulfill];
       }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedSimplePutDataUnauthorized {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedSimplePutDataUnauthorized"];
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/private/secretfile.txt"];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/private/secretfile.txt"];
 
-    NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
+  NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
 
-    [ref putData:data
+  [ref putData:data
         metadata:nil
       completion:^(FIRStorageMetadata *metadata, NSError *error) {
-          XCTAssertNil(metadata, "Metadata should be nil");
-          XCTAssertNotNil(error, "Error should not be nil");
-          XCTAssertEqual(error.code, FIRStorageErrorCodeUnauthorized);
-          [expectation fulfill];
+        XCTAssertNil(metadata, "Metadata should be nil");
+        XCTAssertNotNil(error, "Error should not be nil");
+        XCTAssertEqual(error.code, FIRStorageErrorCodeUnauthorized);
+        [expectation fulfill];
       }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedSimplePutFile {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedSimplePutFile"];
 
-    FIRStorageReference *ref =
+  FIRStorageReference *ref =
       [self.storage referenceWithPath:@"ios/public/testUnauthenticatedSimplePutFile"];
 
-    NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
-    NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
-    NSURL *fileURL =
-    [[tmpDirURL URLByAppendingPathComponent:@"hello"] URLByAppendingPathExtension:@"txt"];
-    [data writeToURL:fileURL atomically:YES];
-
-    FIRStorageUploadTask *task = [ref putFile:fileURL
-                                     metadata:nil
-                                   completion:^(FIRStorageMetadata *metadata, NSError *error) {
-                                       XCTAssertNotNil(metadata, "Metadata should not be nil");
-                                       XCTAssertNil(error, "Error should be nil");
-                                   }];
-
-    __block long uploadedBytes = -1;
-
-    [task observeStatus:FIRStorageTaskStatusSuccess
-                handler:^(FIRStorageTaskSnapshot *snapshot) {
-                    XCTAssertEqualObjects([snapshot description], @"<State: Success>");
-                    [expectation fulfill];
-                }];
-
-    [task observeStatus:FIRStorageTaskStatusProgress
-                handler:^(FIRStorageTaskSnapshot *_Nonnull snapshot) {
-                    XCTAssertTrue([[snapshot description] containsString:@"State: Progress"] ||
-                                  [[snapshot description] containsString:@"State: Resume"]);
-                    NSProgress *progress = snapshot.progress;
-                    XCTAssertGreaterThanOrEqual(progress.completedUnitCount, uploadedBytes);
-                    uploadedBytes = progress.completedUnitCount;
-                }];
+  NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
+  NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
+  NSURL *fileURL =
+      [[tmpDirURL URLByAppendingPathComponent:@"hello"] URLByAppendingPathExtension:@"txt"];
+  [data writeToURL:fileURL atomically:YES];
 
-    [self waitForExpectations];
+  FIRStorageUploadTask *task = [ref putFile:fileURL
+                                   metadata:nil
+                                 completion:^(FIRStorageMetadata *metadata, NSError *error) {
+                                   XCTAssertNotNil(metadata, "Metadata should not be nil");
+                                   XCTAssertNil(error, "Error should be nil");
+                                 }];
+
+  __block long uploadedBytes = -1;
+
+  [task observeStatus:FIRStorageTaskStatusSuccess
+              handler:^(FIRStorageTaskSnapshot *snapshot) {
+                XCTAssertEqualObjects([snapshot description], @"<State: Success>");
+                [expectation fulfill];
+              }];
+
+  [task observeStatus:FIRStorageTaskStatusProgress
+              handler:^(FIRStorageTaskSnapshot *_Nonnull snapshot) {
+                XCTAssertTrue([[snapshot description] containsString:@"State: Progress"] ||
+                              [[snapshot description] containsString:@"State: Resume"]);
+                NSProgress *progress = snapshot.progress;
+                XCTAssertGreaterThanOrEqual(progress.completedUnitCount, uploadedBytes);
+                uploadedBytes = progress.completedUnitCount;
+              }];
+
+  [self waitForExpectations];
 }
 
 - (void)testPutFileWithSpecialCharacters {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testPutFileWithSpecialCharacters"];
 
-    NSString *fileName = @"hello&+@_ .txt";
-    FIRStorageReference *ref =
-    [self.storage referenceWithPath:[@"ios/public/" stringByAppendingString:fileName]];
+  NSString *fileName = @"hello&+@_ .txt";
+  FIRStorageReference *ref =
+      [self.storage referenceWithPath:[@"ios/public/" stringByAppendingString:fileName]];
 
-    NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
-    NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
-    NSURL *fileURL = [tmpDirURL URLByAppendingPathComponent:fileName];
-    [data writeToURL:fileURL atomically:YES];
+  NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
+  NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
+  NSURL *fileURL = [tmpDirURL URLByAppendingPathComponent:fileName];
+  [data writeToURL:fileURL atomically:YES];
 
-    [ref putFile:fileURL
+  [ref putFile:fileURL
         metadata:nil
       completion:^(FIRStorageMetadata *metadata, NSError *error) {
+        XCTAssertNotNil(metadata, "Metadata should not be nil");
+        XCTAssertNil(error, "Error should be nil");
+        XCTAssertEqualObjects(fileName, metadata.name);
+        FIRStorageReference *download =
+            [self.storage referenceWithPath:[@"ios/public/" stringByAppendingString:fileName]];
+        [download metadataWithCompletion:^(FIRStorageMetadata *metadata, NSError *error) {
           XCTAssertNotNil(metadata, "Metadata should not be nil");
           XCTAssertNil(error, "Error should be nil");
           XCTAssertEqualObjects(fileName, metadata.name);
-          FIRStorageReference *download =
-          [self.storage referenceWithPath:[@"ios/public/" stringByAppendingString:fileName]];
-          [download metadataWithCompletion:^(FIRStorageMetadata *metadata, NSError *error) {
-              XCTAssertNotNil(metadata, "Metadata should not be nil");
-              XCTAssertNil(error, "Error should be nil");
-              XCTAssertEqualObjects(fileName, metadata.name);
-              [expectation fulfill];
-          }];
+          [expectation fulfill];
+        }];
       }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedSimplePutDataNoMetadata {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedSimplePutDataNoMetadata"];
 
-    FIRStorageReference *ref =
+  FIRStorageReference *ref =
       [self.storage referenceWithPath:@"ios/public/testUnauthenticatedSimplePutDataNoMetadata"];
 
-    NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
+  NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
 
-    [ref putData:data
+  [ref putData:data
         metadata:nil
       completion:^(FIRStorageMetadata *metadata, NSError *error) {
-          XCTAssertNotNil(metadata, "Metadata should not be nil");
-          XCTAssertNil(error, "Error should be nil");
-          [expectation fulfill];
+        XCTAssertNotNil(metadata, "Metadata should not be nil");
+        XCTAssertNil(error, "Error should be nil");
+        [expectation fulfill];
       }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedSimplePutFileNoMetadata {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedSimplePutFileNoMetadata"];
 
-    FIRStorageReference *ref =
+  FIRStorageReference *ref =
       [self.storage referenceWithPath:@"ios/public/testUnauthenticatedSimplePutFileNoMetadata"];
 
-    NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
-    NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
-    NSURL *fileURL =
-    [[tmpDirURL URLByAppendingPathComponent:@"hello"] URLByAppendingPathExtension:@"txt"];
-    [data writeToURL:fileURL atomically:YES];
+  NSData *data = [@"Hello World" dataUsingEncoding:NSUTF8StringEncoding];
+  NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
+  NSURL *fileURL =
+      [[tmpDirURL URLByAppendingPathComponent:@"hello"] URLByAppendingPathExtension:@"txt"];
+  [data writeToURL:fileURL atomically:YES];
 
-    [ref putFile:fileURL
+  [ref putFile:fileURL
         metadata:nil
       completion:^(FIRStorageMetadata *metadata, NSError *error) {
-          XCTAssertNotNil(metadata, "Metadata should not be nil");
-          XCTAssertNil(error, "Error should be nil");
-          [expectation fulfill];
+        XCTAssertNotNil(metadata, "Metadata should not be nil");
+        XCTAssertNil(error, "Error should be nil");
+        [expectation fulfill];
       }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedSimpleGetData {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedSimpleGetData"];
 
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
 
-    [ref dataWithMaxSize:1 * 1024 * 1024
-              completion:^(NSData *data, NSError *error) {
-                  XCTAssertNotNil(data, "Data should not be nil");
-                  XCTAssertNil(error, "Error should be nil");
-                  [expectation fulfill];
-              }];
+  [ref dataWithMaxSize:1 * 1024 * 1024
+            completion:^(NSData *data, NSError *error) {
+              XCTAssertNotNil(data, "Data should not be nil");
+              XCTAssertNil(error, "Error should be nil");
+              [expectation fulfill];
+            }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedSimpleGetDataTooSmall {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedSimpleGetDataTooSmall"];
 
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
 
-    /// Only allow 1kB size, which is smaller than our file
-    [ref dataWithMaxSize:1 * 1024
-              completion:^(NSData *data, NSError *error) {
-                  XCTAssertEqual(data, nil);
-                  XCTAssertEqual(error.code, FIRStorageErrorCodeDownloadSizeExceeded);
-                  [expectation fulfill];
-              }];
+  /// Only allow 1kB size, which is smaller than our file
+  [ref dataWithMaxSize:1 * 1024
+            completion:^(NSData *data, NSError *error) {
+              XCTAssertEqual(data, nil);
+              XCTAssertEqual(error.code, FIRStorageErrorCodeDownloadSizeExceeded);
+              [expectation fulfill];
+            }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedSimpleGetFile {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedSimpleGetData"];
 
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/helloworld"];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/helloworld"];
 
-    NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
-    NSURL *fileURL =
+  NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
+  NSURL *fileURL =
       [[tmpDirURL URLByAppendingPathComponent:@"hello"] URLByAppendingPathExtension:@"txt"];
 
-    [ref putData:[@"Hello World" dataUsingEncoding:NSUTF8StringEncoding] metadata:nil
-      completion:^(FIRStorageMetadata *metadata, NSError *error)
-    {
+  [ref putData:[@"Hello World" dataUsingEncoding:NSUTF8StringEncoding]
+        metadata:nil
+      completion:^(FIRStorageMetadata *metadata, NSError *error) {
         FIRStorageDownloadTask *task = [ref writeToFile:fileURL];
 
         [task observeStatus:FIRStorageTaskStatusSuccess
                     handler:^(FIRStorageTaskSnapshot *snapshot) {
-                        NSString *data = [NSString stringWithContentsOfURL:fileURL
-                                                                  encoding:NSUTF8StringEncoding
-                                                                     error:NULL];
-                        NSString *expectedData = @"Hello World";
-                        XCTAssertEqualObjects(data, expectedData);
-                        XCTAssertEqualObjects([snapshot description], @"<State: Success>");
-                        [expectation fulfill];
+                      NSString *data = [NSString stringWithContentsOfURL:fileURL
+                                                                encoding:NSUTF8StringEncoding
+                                                                   error:NULL];
+                      NSString *expectedData = @"Hello World";
+                      XCTAssertEqualObjects(data, expectedData);
+                      XCTAssertEqualObjects([snapshot description], @"<State: Success>");
+                      [expectation fulfill];
                     }];
 
         [task observeStatus:FIRStorageTaskStatusProgress
                     handler:^(FIRStorageTaskSnapshot *_Nonnull snapshot) {
-                        NSProgress *progress = snapshot.progress;
-                        NSLog(@"%lld of %lld", progress.completedUnitCount, progress.totalUnitCount);
+                      NSProgress *progress = snapshot.progress;
+                      NSLog(@"%lld of %lld", progress.completedUnitCount, progress.totalUnitCount);
                     }];
 
         [task observeStatus:FIRStorageTaskStatusFailure
                     handler:^(FIRStorageTaskSnapshot *snapshot) {
-                        XCTAssertNil(snapshot.error);
-                        [expectation fulfill];
+                      XCTAssertNil(snapshot.error);
+                      [expectation fulfill];
                     }];
-    }];
+      }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
 - (void)testCancelDownload {
-    XCTestExpectation *expectation =
-      [self expectationWithDescription:@"testCancelDownload"];
+  XCTestExpectation *expectation = [self expectationWithDescription:@"testCancelDownload"];
 
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
 
-    NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
-    NSURL *fileURL =
-        [[tmpDirURL URLByAppendingPathComponent:@"hello"] URLByAppendingPathExtension:@"dat"];
+  NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
+  NSURL *fileURL =
+      [[tmpDirURL URLByAppendingPathComponent:@"hello"] URLByAppendingPathExtension:@"dat"];
 
-    FIRStorageDownloadTask *task = [ref writeToFile:fileURL];
+  FIRStorageDownloadTask *task = [ref writeToFile:fileURL];
 
-    [task observeStatus:FIRStorageTaskStatusFailure
-                handler:^(FIRStorageTaskSnapshot *snapshot) {
-                    XCTAssertTrue([[snapshot description] containsString:@"State: Failed"]);
-                    [expectation fulfill];
-                }];
+  [task observeStatus:FIRStorageTaskStatusFailure
+              handler:^(FIRStorageTaskSnapshot *snapshot) {
+                XCTAssertTrue([[snapshot description] containsString:@"State: Failed"]);
+                [expectation fulfill];
+              }];
 
-    [task observeStatus:FIRStorageTaskStatusProgress
-                handler:^(FIRStorageTaskSnapshot *_Nonnull snapshot) {
-                    [task cancel];
-                }];
+  [task observeStatus:FIRStorageTaskStatusProgress
+              handler:^(FIRStorageTaskSnapshot *_Nonnull snapshot) {
+                [task cancel];
+              }];
 
-    [self waitForExpectations];
+  [self waitForExpectations];
 }
 
-- (void)assertMetadata:(FIRStorageMetadata *) actualMetadata
-           contentType:(NSString *) expectedContentType
-        customMetadata:(NSDictionary *) expectedCustomMetadata {
+- (void)assertMetadata:(FIRStorageMetadata *)actualMetadata
+           contentType:(NSString *)expectedContentType
+        customMetadata:(NSDictionary *)expectedCustomMetadata {
   XCTAssertEqualObjects(actualMetadata.cacheControl, @"cache-control");
   XCTAssertEqualObjects(actualMetadata.contentDisposition, @"content-disposition");
   XCTAssertEqualObjects(actualMetadata.contentEncoding, @"gzip");
   XCTAssertEqualObjects(actualMetadata.contentLanguage, @"de");
   XCTAssertEqualObjects(actualMetadata.contentType, expectedContentType);
-  for (NSString* key in expectedCustomMetadata) {
+  for (NSString *key in expectedCustomMetadata) {
     XCTAssertEqualObjects([actualMetadata.customMetadata objectForKey:key],
                           [expectedCustomMetadata objectForKey:key]);
   }
 }
 
-- (void)assertMetadataNil:(FIRStorageMetadata *) actualMetadata {
-    XCTAssertNil(actualMetadata.cacheControl);
-    XCTAssertNil(actualMetadata.contentDisposition);
-    XCTAssertEqualObjects(actualMetadata.contentEncoding, @"identity");
-    XCTAssertNil(actualMetadata.contentLanguage);
-    XCTAssertNil(actualMetadata.contentType);
-    XCTAssertNil([actualMetadata.customMetadata objectForKey:@"a"]);
-    XCTAssertNil([actualMetadata.customMetadata objectForKey:@"c"]);
-    XCTAssertNil([actualMetadata.customMetadata objectForKey:@"f"]);
+- (void)assertMetadataNil:(FIRStorageMetadata *)actualMetadata {
+  XCTAssertNil(actualMetadata.cacheControl);
+  XCTAssertNil(actualMetadata.contentDisposition);
+  XCTAssertEqualObjects(actualMetadata.contentEncoding, @"identity");
+  XCTAssertNil(actualMetadata.contentLanguage);
+  XCTAssertNil(actualMetadata.contentType);
+  XCTAssertNil([actualMetadata.customMetadata objectForKey:@"a"]);
+  XCTAssertNil([actualMetadata.customMetadata objectForKey:@"c"]);
+  XCTAssertNil([actualMetadata.customMetadata objectForKey:@"f"]);
 }
 
 - (void)testUpdateMetadata {
@@ -493,100 +494,107 @@ NSTimeInterval kFIRStorageIntegrationTestTimeout = 30;
   metadata.contentType = @"content-type-a";
   metadata.customMetadata = @{@"a" : @"b"};
 
-  [ref updateMetadata:metadata completion:^(FIRStorageMetadata *updatedMetadata, NSError *error) {
-      XCTAssertNil(error);
-      [self assertMetadata:updatedMetadata contentType:@"content-type-a" customMetadata:@{@"a" : @"b"}];
-
-      // Update a subset of the metadata using the existing object.
-      FIRStorageMetadata *metadata = updatedMetadata;
-      metadata.contentType = @"content-type-b";
-      metadata.customMetadata = @{@"a" : @"b", @"c" : @"d"};
-
-      [ref updateMetadata:metadata completion:^(FIRStorageMetadata *updatedMetadata, NSError *error) {
-          XCTAssertNil(error);
-          [self assertMetadata:updatedMetadata contentType:@"content-type-b" customMetadata: @{@"a" : @"b", @"c" : @"d"}];
-
-          // Clear all metadata.
-          FIRStorageMetadata *metadata = updatedMetadata;
-          metadata.cacheControl = nil;
-          metadata.contentDisposition = nil;
-          metadata.contentEncoding = nil;
-          metadata.contentLanguage = nil;
-          metadata.contentType = nil;
-          metadata.customMetadata = [NSDictionary dictionary];
-
-          [ref updateMetadata:metadata completion:^(FIRStorageMetadata *updatedMetadata, NSError *error) {
-              XCTAssertNil(error);
-              [self assertMetadataNil:updatedMetadata];
-              [expectation fulfill];
-          }];
-      }];
-   }];
+  [ref updateMetadata:metadata
+           completion:^(FIRStorageMetadata *updatedMetadata, NSError *error) {
+             XCTAssertNil(error);
+             [self assertMetadata:updatedMetadata
+                      contentType:@"content-type-a"
+                   customMetadata:@{@"a" : @"b"}];
+
+             // Update a subset of the metadata using the existing object.
+             FIRStorageMetadata *metadata = updatedMetadata;
+             metadata.contentType = @"content-type-b";
+             metadata.customMetadata = @{@"a" : @"b", @"c" : @"d"};
+
+             [ref updateMetadata:metadata
+                      completion:^(FIRStorageMetadata *updatedMetadata, NSError *error) {
+                        XCTAssertNil(error);
+                        [self assertMetadata:updatedMetadata
+                                 contentType:@"content-type-b"
+                              customMetadata:@{@"a" : @"b", @"c" : @"d"}];
+
+                        // Clear all metadata.
+                        FIRStorageMetadata *metadata = updatedMetadata;
+                        metadata.cacheControl = nil;
+                        metadata.contentDisposition = nil;
+                        metadata.contentEncoding = nil;
+                        metadata.contentLanguage = nil;
+                        metadata.contentType = nil;
+                        metadata.customMetadata = [NSDictionary dictionary];
+
+                        [ref updateMetadata:metadata
+                                 completion:^(FIRStorageMetadata *updatedMetadata, NSError *error) {
+                                   XCTAssertNil(error);
+                                   [self assertMetadataNil:updatedMetadata];
+                                   [expectation fulfill];
+                                 }];
+                      }];
+           }];
 
   [self waitForExpectations];
 }
 
 - (void)testUnauthenticatedResumeGetFile {
-    XCTestExpectation *expectation =
+  XCTestExpectation *expectation =
       [self expectationWithDescription:@"testUnauthenticatedResumeGetFile"];
 
-    FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
-
-    NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
-    NSURL *fileURL =
-    [[tmpDirURL URLByAppendingPathComponent:@"hello"] URLByAppendingPathExtension:@"txt"];
-
-    __block long resumeAtBytes = 256 * 1024;
-    __block long downloadedBytes = 0;
-    __block double computationResult = 0;
-
-    FIRStorageDownloadTask *task = [ref writeToFile:fileURL];
-
-    [task observeStatus:FIRStorageTaskStatusSuccess
-                handler:^(FIRStorageTaskSnapshot *snapshot) {
-                    XCTAssertEqualObjects([snapshot description], @"<State: Success>");
-                    [expectation fulfill];
-                }];
-
-    [task observeStatus:FIRStorageTaskStatusProgress
-                handler:^(FIRStorageTaskSnapshot *_Nonnull snapshot) {
-                    XCTAssertTrue([[snapshot description] containsString:@"State: Progress"] ||
-                                  [[snapshot description] containsString:@"State: Resume"]);
-                    NSProgress *progress = snapshot.progress;
-                    XCTAssertGreaterThanOrEqual(progress.completedUnitCount, downloadedBytes);
-                    downloadedBytes = progress.completedUnitCount;
-                    if (progress.completedUnitCount > resumeAtBytes) {
-                        // Making sure the main run loop is busy.
-                        for (int i = 0; i < 500; ++i) {
-                            dispatch_async(dispatch_get_main_queue(), ^ {
-                                computationResult = sqrt(INT_MAX - i);
-                            });
-                        }
-                        NSLog(@"Pausing");
-                        [task pause];
-                        resumeAtBytes = INT_MAX;
-                    }
-                }];
-
-    [task observeStatus:FIRStorageTaskStatusPause
-                handler:^(FIRStorageTaskSnapshot *snapshot) {
-                    XCTAssertEqualObjects([snapshot description], @"<State: Paused>");
-                    NSLog(@"Resuming");
-                    [task resume];
-                }];
+  FIRStorageReference *ref = [self.storage referenceWithPath:@"ios/public/1mb"];
 
-    [self waitForExpectations];
-    XCTAssertEqual(INT_MAX, resumeAtBytes);
-    XCTAssertEqualWithAccuracy(sqrt(INT_MAX - 499), computationResult, 0.1);
+  NSURL *tmpDirURL = [NSURL fileURLWithPath:NSTemporaryDirectory()];
+  NSURL *fileURL =
+      [[tmpDirURL URLByAppendingPathComponent:@"hello"] URLByAppendingPathExtension:@"txt"];
+
+  __block long resumeAtBytes = 256 * 1024;
+  __block long downloadedBytes = 0;
+  __block double computationResult = 0;
+
+  FIRStorageDownloadTask *task = [ref writeToFile:fileURL];
+
+  [task observeStatus:FIRStorageTaskStatusSuccess
+              handler:^(FIRStorageTaskSnapshot *snapshot) {
+                XCTAssertEqualObjects([snapshot description], @"<State: Success>");
+                [expectation fulfill];
+              }];
+
+  [task observeStatus:FIRStorageTaskStatusProgress
+              handler:^(FIRStorageTaskSnapshot *_Nonnull snapshot) {
+                XCTAssertTrue([[snapshot description] containsString:@"State: Progress"] ||
+                              [[snapshot description] containsString:@"State: Resume"]);
+                NSProgress *progress = snapshot.progress;
+                XCTAssertGreaterThanOrEqual(progress.completedUnitCount, downloadedBytes);
+                downloadedBytes = progress.completedUnitCount;
+                if (progress.completedUnitCount > resumeAtBytes) {
+                  // Making sure the main run loop is busy.
+                  for (int i = 0; i < 500; ++i) {
+                    dispatch_async(dispatch_get_main_queue(), ^{
+                      computationResult = sqrt(INT_MAX - i);
+                    });
+                  }
+                  NSLog(@"Pausing");
+                  [task pause];
+                  resumeAtBytes = INT_MAX;
+                }
+              }];
+
+  [task observeStatus:FIRStorageTaskStatusPause
+              handler:^(FIRStorageTaskSnapshot *snapshot) {
+                XCTAssertEqualObjects([snapshot description], @"<State: Paused>");
+                NSLog(@"Resuming");
+                [task resume];
+              }];
+
+  [self waitForExpectations];
+  XCTAssertEqual(INT_MAX, resumeAtBytes);
+  XCTAssertEqualWithAccuracy(sqrt(INT_MAX - 499), computationResult, 0.1);
 }
 
 - (void)waitForExpectations {
-    [self waitForExpectationsWithTimeout:kFIRStorageIntegrationTestTimeout
-                                 handler:^(NSError *_Nullable error) {
-                                     if (error) {
-                                         NSLog(@"%@", error);
-                                     }
-                                 }];
+  [self waitForExpectationsWithTimeout:kFIRStorageIntegrationTestTimeout
+                               handler:^(NSError *_Nullable error) {
+                                 if (error) {
+                                   NSLog(@"%@", error);
+                                 }
+                               }];
 }
 
 @end
diff --git a/Example/Storage/Tests/Unit/FIRStorageDeleteTests.m b/Example/Storage/Tests/Unit/FIRStorageDeleteTests.m
index 42a3b1a..4311ab3 100644
--- a/Example/Storage/Tests/Unit/FIRStorageDeleteTests.m
+++ b/Example/Storage/Tests/Unit/FIRStorageDeleteTests.m
@@ -29,7 +29,7 @@
 - (void)setUp {
   [super setUp];
 
-  NSDictionary *metadataDict = @{ @"bucket" : @"bucket", @"name" : @"path/to/object" };
+  NSDictionary *metadataDict = @{@"bucket" : @"bucket", @"name" : @"path/to/object"};
   self.metadata = [[FIRStorageMetadata alloc] initWithDictionary:metadataDict];
 
   id mockOptions = OCMClassMock([FIROptions class]);
@@ -64,11 +64,10 @@
         XCTAssertEqualObjects(fetcher.request.URL, [FIRStorageTestHelpers objectURL]);
 #pragma clang diagnostic pop
         XCTAssertEqualObjects(fetcher.request.HTTPMethod, @"DELETE");
-        NSHTTPURLResponse *httpResponse =
-            [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                        statusCode:200
-                                       HTTPVersion:kHTTPVersion
-                                      headerFields:nil];
+        NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                      statusCode:200
+                                                                     HTTPVersion:kHTTPVersion
+                                                                    headerFields:nil];
         response(httpResponse, nil, nil);
       };
 
@@ -108,14 +107,13 @@
   self.fetcherService.testBlock = [FIRStorageTestHelpers unauthenticatedBlock];
   FIRStoragePath *path = [FIRStorageTestHelpers objectPath];
   FIRStorageReference *ref = [[FIRStorageReference alloc] initWithStorage:self.storage path:path];
-  FIRStorageDeleteTask *task =
-      [[FIRStorageDeleteTask alloc] initWithReference:ref
-                                       fetcherService:self.fetcherService
-                                           completion:^(NSError *error) {
-                                             XCTAssertEqual(error.code,
-                                                            FIRStorageErrorCodeUnauthenticated);
-                                             [expectation fulfill];
-                                           }];
+  FIRStorageDeleteTask *task = [[FIRStorageDeleteTask alloc]
+      initWithReference:ref
+         fetcherService:self.fetcherService
+             completion:^(NSError *error) {
+               XCTAssertEqual(error.code, FIRStorageErrorCodeUnauthenticated);
+               [expectation fulfill];
+             }];
   [task enqueue];
 
   [FIRStorageTestHelpers waitForExpectation:self];
@@ -128,14 +126,13 @@
   self.fetcherService.testBlock = [FIRStorageTestHelpers unauthorizedBlock];
   FIRStoragePath *path = [FIRStorageTestHelpers objectPath];
   FIRStorageReference *ref = [[FIRStorageReference alloc] initWithStorage:self.storage path:path];
-  FIRStorageDeleteTask *task =
-      [[FIRStorageDeleteTask alloc] initWithReference:ref
-                                       fetcherService:self.fetcherService
-                                           completion:^(NSError *error) {
-                                             XCTAssertEqual(error.code,
-                                                            FIRStorageErrorCodeUnauthorized);
-                                             [expectation fulfill];
-                                           }];
+  FIRStorageDeleteTask *task = [[FIRStorageDeleteTask alloc]
+      initWithReference:ref
+         fetcherService:self.fetcherService
+             completion:^(NSError *error) {
+               XCTAssertEqual(error.code, FIRStorageErrorCodeUnauthorized);
+               [expectation fulfill];
+             }];
   [task enqueue];
 
   [FIRStorageTestHelpers waitForExpectation:self];
@@ -148,14 +145,13 @@
   self.fetcherService.testBlock = [FIRStorageTestHelpers notFoundBlock];
   FIRStoragePath *path = [FIRStorageTestHelpers notFoundPath];
   FIRStorageReference *ref = [[FIRStorageReference alloc] initWithStorage:self.storage path:path];
-  FIRStorageDeleteTask *task =
-      [[FIRStorageDeleteTask alloc] initWithReference:ref
-                                       fetcherService:self.fetcherService
-                                           completion:^(NSError *error) {
-                                             XCTAssertEqual(error.code,
-                                                            FIRStorageErrorCodeObjectNotFound);
-                                             [expectation fulfill];
-                                           }];
+  FIRStorageDeleteTask *task = [[FIRStorageDeleteTask alloc]
+      initWithReference:ref
+         fetcherService:self.fetcherService
+             completion:^(NSError *error) {
+               XCTAssertEqual(error.code, FIRStorageErrorCodeObjectNotFound);
+               [expectation fulfill];
+             }];
   [task enqueue];
 
   [FIRStorageTestHelpers waitForExpectation:self];
diff --git a/Example/Storage/Tests/Unit/FIRStorageGetMetadataTests.m b/Example/Storage/Tests/Unit/FIRStorageGetMetadataTests.m
index 72a057d..1f19b00 100644
--- a/Example/Storage/Tests/Unit/FIRStorageGetMetadataTests.m
+++ b/Example/Storage/Tests/Unit/FIRStorageGetMetadataTests.m
@@ -29,7 +29,7 @@
 - (void)setUp {
   [super setUp];
 
-  NSDictionary *metadataDict = @{ @"bucket" : @"bucket", @"name" : @"path/to/object" };
+  NSDictionary *metadataDict = @{@"bucket" : @"bucket", @"name" : @"path/to/object"};
   self.metadata = [[FIRStorageMetadata alloc] initWithDictionary:metadataDict];
 
   id mockOptions = OCMClassMock([FIROptions class]);
@@ -64,11 +64,10 @@
         XCTAssertEqualObjects(fetcher.request.URL, [FIRStorageTestHelpers objectURL]);
 #pragma clang diagnostic pop
         XCTAssertEqualObjects(fetcher.request.HTTPMethod, @"GET");
-        NSHTTPURLResponse *httpResponse =
-            [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                        statusCode:200
-                                       HTTPVersion:kHTTPVersion
-                                      headerFields:nil];
+        NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                      statusCode:200
+                                                                     HTTPVersion:kHTTPVersion
+                                                                    headerFields:nil];
         response(httpResponse, nil, nil);
       };
 
diff --git a/Example/Storage/Tests/Unit/FIRStorageMetadataTests.m b/Example/Storage/Tests/Unit/FIRStorageMetadataTests.m
index e750bdf..d6a73e7 100644
--- a/Example/Storage/Tests/Unit/FIRStorageMetadataTests.m
+++ b/Example/Storage/Tests/Unit/FIRStorageMetadataTests.m
@@ -263,16 +263,16 @@
 }
 
 - (void)testUpdatedMetadataWithEmptyUpdate {
-    NSDictionary *oldMetadata = @{
-                                  kFIRStorageMetadataContentLanguage : @"old",
-                                  kFIRStorageMetadataCustomMetadata : @{@"foo" : @"old", @"bar" : @"old"}
-                                  };
-    FIRStorageMetadata *metadata = [[FIRStorageMetadata alloc] initWithDictionary:oldMetadata];
+  NSDictionary *oldMetadata = @{
+    kFIRStorageMetadataContentLanguage : @"old",
+    kFIRStorageMetadataCustomMetadata : @{@"foo" : @"old", @"bar" : @"old"}
+  };
+  FIRStorageMetadata *metadata = [[FIRStorageMetadata alloc] initWithDictionary:oldMetadata];
 
-    NSDictionary *update = [metadata updatedMetadata];
+  NSDictionary *update = [metadata updatedMetadata];
 
-    NSDictionary *expectedUpdate = @{ kFIRStorageMetadataCustomMetadata : @{} };
-    XCTAssertEqualObjects(update, expectedUpdate);
+  NSDictionary *expectedUpdate = @{ kFIRStorageMetadataCustomMetadata : @{} };
+  XCTAssertEqualObjects(update, expectedUpdate);
 }
 
 - (void)testUpdatedMetadataWithDelete {
@@ -305,31 +305,31 @@
 }
 
 - (void)testZuluTimeOffset {
-  NSDictionary *metaDict = @{ kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108Z" };
+  NSDictionary *metaDict = @{kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108Z"};
   FIRStorageMetadata *metadata = [[FIRStorageMetadata alloc] initWithDictionary:metaDict];
   XCTAssertNotNil(metadata.timeCreated);
 }
 
 - (void)testZuluZeroTimeOffset {
-  NSDictionary *metaDict = @{ kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108+0000" };
+  NSDictionary *metaDict = @{kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108+0000"};
   FIRStorageMetadata *metadata = [[FIRStorageMetadata alloc] initWithDictionary:metaDict];
   XCTAssertNotNil(metadata.timeCreated);
 }
 
 - (void)testGoogleStandardTimeOffset {
-  NSDictionary *metaDict = @{ kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108-0700" };
+  NSDictionary *metaDict = @{kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108-0700"};
   FIRStorageMetadata *metadata = [[FIRStorageMetadata alloc] initWithDictionary:metaDict];
   XCTAssertNotNil(metadata.timeCreated);
 }
 
 - (void)testUnspecifiedTimeOffset {
-  NSDictionary *metaDict = @{ kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108-0000" };
+  NSDictionary *metaDict = @{kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108-0000"};
   FIRStorageMetadata *metadata = [[FIRStorageMetadata alloc] initWithDictionary:metaDict];
   XCTAssertNotNil(metadata.timeCreated);
 }
 
 - (void)testNoTimeOffset {
-  NSDictionary *metaDict = @{ kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108" };
+  NSDictionary *metaDict = @{kFIRStorageMetadataTimeCreated : @"1992-08-07T17:22:53.108"};
   FIRStorageMetadata *metadata = [[FIRStorageMetadata alloc] initWithDictionary:metaDict];
   XCTAssertNil(metadata.timeCreated);
 }
diff --git a/Example/Storage/Tests/Unit/FIRStorageTestHelpers.m b/Example/Storage/Tests/Unit/FIRStorageTestHelpers.m
index fef67ef..2039f22 100644
--- a/Example/Storage/Tests/Unit/FIRStorageTestHelpers.m
+++ b/Example/Storage/Tests/Unit/FIRStorageTestHelpers.m
@@ -97,16 +97,15 @@ NSString *const kFIRStorageAppName = @"app";
 + (GTMSessionFetcherTestBlock)blockForData:(nullable NSData *)data statusCode:(NSInteger)code {
   GTMSessionFetcherTestBlock block =
       ^(GTMSessionFetcher *fetcher, GTMSessionFetcherTestResponse response) {
-        NSHTTPURLResponse *httpResponse =
-            [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                        statusCode:code
-                                       HTTPVersion:kHTTPVersion
-                                      headerFields:nil];
+        NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                      statusCode:code
+                                                                     HTTPVersion:kHTTPVersion
+                                                                    headerFields:nil];
         NSError *error;
         if (code >= 400) {
           NSDictionary *userInfo;
           if (data) {
-            userInfo = @{ @"data" : data };
+            userInfo = @{@"data" : data};
           }
           error = [NSError errorWithDomain:kGoogleHTTPErrorDomain code:code userInfo:userInfo];
         }
diff --git a/Example/Storage/Tests/Unit/FIRStorageTests.m b/Example/Storage/Tests/Unit/FIRStorageTests.m
index 1b45295..503ac94 100644
--- a/Example/Storage/Tests/Unit/FIRStorageTests.m
+++ b/Example/Storage/Tests/Unit/FIRStorageTests.m
@@ -43,7 +43,7 @@
 }
 
 - (void)testBucketNotEnforced {
-  FIROptions * mockOptions = OCMClassMock([FIROptions class]);
+  FIROptions *mockOptions = OCMClassMock([FIROptions class]);
   OCMStub([mockOptions storageBucket]).andReturn(@"");
   FIRApp *app = OCMClassMock([FIRApp class]);
   OCMStub([app name]).andReturn(kFIRStorageAppName);
@@ -55,40 +55,39 @@
 }
 
 - (void)testBucketEnforced {
-  FIRStorage *storage = [FIRStorage storageForApp:self.app
-                                              URL:@"gs://benwu-test1.storage.firebase.com"];
+  FIRStorage *storage =
+      [FIRStorage storageForApp:self.app URL:@"gs://benwu-test1.storage.firebase.com"];
   [storage referenceForURL:@"gs://benwu-test1.storage.firebase.com/child"];
   storage = [FIRStorage storageForApp:self.app URL:@"gs://benwu-test1.storage.firebase.com/"];
   [storage referenceForURL:@"gs://benwu-test1.storage.firebase.com/child"];
   XCTAssertThrows([storage referenceForURL:@"gs://benwu-test2.storage.firebase.com/child"]);
 }
 
-- (void) testInitWithCustomUrl {
+- (void)testInitWithCustomUrl {
   FIRStorage *storage = [FIRStorage storageForApp:self.app URL:@"gs://foo-bar.appspot.com"];
   XCTAssertEqualObjects(@"gs://foo-bar.appspot.com/", [[storage reference] description]);
   storage = [FIRStorage storageForApp:self.app URL:@"gs://foo-bar.appspot.com/"];
   XCTAssertEqualObjects(@"gs://foo-bar.appspot.com/", [[storage reference] description]);
 }
 
-- (void) testInitWithWrongScheme {
+- (void)testInitWithWrongScheme {
   XCTAssertThrows([FIRStorage storageForApp:self.app URL:@"http://foo-bar.appspot.com"]);
 }
 
-- (void) testInitWithNoScheme {
+- (void)testInitWithNoScheme {
   XCTAssertThrows([FIRStorage storageForApp:self.app URL:@"foo-bar.appspot.com"]);
 }
 
-- (void) testInitWithNilURL {
+- (void)testInitWithNilURL {
   XCTAssertThrows([FIRStorage storageForApp:self.app URL:nil]);
 }
 
-- (void) testInitWithPath {
+- (void)testInitWithPath {
   XCTAssertThrows([FIRStorage storageForApp:self.app URL:@"gs://foo-bar.appspot.com/child"]);
 }
 
-- (void) testInitWithDefaultAndCustomUrl {
-  FIRStorage *customInstance = [FIRStorage storageForApp:self.app
-                                                     URL:@"gs://foo-bar.appspot.com"];
+- (void)testInitWithDefaultAndCustomUrl {
+  FIRStorage *customInstance = [FIRStorage storageForApp:self.app URL:@"gs://foo-bar.appspot.com"];
   FIRStorage *defaultInstance = [FIRStorage storageForApp:self.app];
   XCTAssertEqualObjects(@"gs://foo-bar.appspot.com/", [[customInstance reference] description]);
   XCTAssertEqualObjects(@"gs://bucket/", [[defaultInstance reference] description]);
diff --git a/Example/Storage/Tests/Unit/FIRStorageTokenAuthorizerTests.m b/Example/Storage/Tests/Unit/FIRStorageTokenAuthorizerTests.m
index bc60fb4..26627b5 100644
--- a/Example/Storage/Tests/Unit/FIRStorageTokenAuthorizerTests.m
+++ b/Example/Storage/Tests/Unit/FIRStorageTokenAuthorizerTests.m
@@ -56,23 +56,22 @@
 #pragma clang diagnostic ignored "-Warc-retain-cycles"
     XCTAssertTrue([self.fetcher.authorizer isAuthorizedRequest:fetcher.request]);
 #pragma clang diagnostic pop
-    NSHTTPURLResponse *httpResponse =
-        [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                    statusCode:200
-                                   HTTPVersion:kHTTPVersion
-                                  headerFields:nil];
+    NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                  statusCode:200
+                                                                 HTTPVersion:kHTTPVersion
+                                                                headerFields:nil];
     response(httpResponse, nil, nil);
   };
 
-  [self.fetcher beginFetchWithCompletionHandler:^(NSData *_Nullable data,
-                                                  NSError *_Nullable error) {
-    NSDictionary<NSString *, NSString *> *headers = self.fetcher.request.allHTTPHeaderFields;
-    NSString *authHeader = [headers objectForKey:@"Authorization"];
-    NSString *firebaseToken =
-        [NSString stringWithFormat:kFIRStorageAuthTokenFormat, kFIRStorageTestAuthToken];
-    XCTAssertEqualObjects(authHeader, firebaseToken);
-    [expectation fulfill];
-  }];
+  [self.fetcher
+      beginFetchWithCompletionHandler:^(NSData *_Nullable data, NSError *_Nullable error) {
+        NSDictionary<NSString *, NSString *> *headers = self.fetcher.request.allHTTPHeaderFields;
+        NSString *authHeader = [headers objectForKey:@"Authorization"];
+        NSString *firebaseToken =
+            [NSString stringWithFormat:kFIRStorageAuthTokenFormat, kFIRStorageTestAuthToken];
+        XCTAssertEqualObjects(authHeader, firebaseToken);
+        [expectation fulfill];
+      }];
 
   [FIRStorageTestHelpers waitForExpectation:self];
 }
@@ -98,23 +97,22 @@
 #pragma clang diagnostic ignored "-Warc-retain-cycles"
     XCTAssertEqual([self.fetcher.authorizer isAuthorizedRequest:fetcher.request], NO);
 #pragma cland diagnostic pop
-    NSHTTPURLResponse *httpResponse =
-        [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                    statusCode:401
-                                   HTTPVersion:kHTTPVersion
-                                  headerFields:nil];
+    NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                  statusCode:401
+                                                                 HTTPVersion:kHTTPVersion
+                                                                headerFields:nil];
     response(httpResponse, nil, authError);
   };
 
-  [self.fetcher beginFetchWithCompletionHandler:^(NSData *_Nullable data,
-                                                  NSError *_Nullable error) {
-    NSDictionary<NSString *, NSString *> *headers = self.fetcher.request.allHTTPHeaderFields;
-    NSString *authHeader = [headers objectForKey:@"Authorization"];
-    XCTAssertNil(authHeader);
-    XCTAssertEqualObjects(error.domain, FIRStorageErrorDomain);
-    XCTAssertEqual(error.code, FIRStorageErrorCodeUnauthenticated);
-    [expectation fulfill];
-  }];
+  [self.fetcher
+      beginFetchWithCompletionHandler:^(NSData *_Nullable data, NSError *_Nullable error) {
+        NSDictionary<NSString *, NSString *> *headers = self.fetcher.request.allHTTPHeaderFields;
+        NSString *authHeader = [headers objectForKey:@"Authorization"];
+        XCTAssertNil(authHeader);
+        XCTAssertEqualObjects(error.domain, FIRStorageErrorDomain);
+        XCTAssertEqual(error.code, FIRStorageErrorCodeUnauthenticated);
+        [expectation fulfill];
+      }];
 
   [FIRStorageTestHelpers waitForExpectation:self];
 }
@@ -134,22 +132,21 @@
 #pragma clang diagnostic ignored "-Warc-retain-cycles"
     XCTAssertFalse([self.fetcher.authorizer isAuthorizedRequest:fetcher.request]);
 #pragma cland diagnostic pop
-    NSHTTPURLResponse *httpResponse =
-        [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                    statusCode:200
-                                   HTTPVersion:kHTTPVersion
-                                  headerFields:nil];
+    NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                  statusCode:200
+                                                                 HTTPVersion:kHTTPVersion
+                                                                headerFields:nil];
     response(httpResponse, nil, nil);
   };
 
-  [self.fetcher beginFetchWithCompletionHandler:^(NSData *_Nullable data,
-                                                  NSError *_Nullable error) {
-    NSDictionary<NSString *, NSString *> *headers = self.fetcher.request.allHTTPHeaderFields;
-    NSString *authHeader = [headers objectForKey:@"Authorization"];
-    XCTAssertNil(authHeader);
-    XCTAssertNil(error);
-    [expectation fulfill];
-  }];
+  [self.fetcher
+      beginFetchWithCompletionHandler:^(NSData *_Nullable data, NSError *_Nullable error) {
+        NSDictionary<NSString *, NSString *> *headers = self.fetcher.request.allHTTPHeaderFields;
+        NSString *authHeader = [headers objectForKey:@"Authorization"];
+        XCTAssertNil(authHeader);
+        XCTAssertNil(error);
+        [expectation fulfill];
+      }];
 
   [FIRStorageTestHelpers waitForExpectation:self];
 }
@@ -159,11 +156,10 @@
 
   self.fetcher.testBlock = ^(GTMSessionFetcher *fetcher, GTMSessionFetcherTestResponse response) {
     XCTAssertFalse([fetcher.authorizer isAuthorizingRequest:fetcher.request]);
-    NSHTTPURLResponse *httpResponse =
-        [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                    statusCode:200
-                                   HTTPVersion:kHTTPVersion
-                                  headerFields:nil];
+    NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                  statusCode:200
+                                                                 HTTPVersion:kHTTPVersion
+                                                                headerFields:nil];
     response(httpResponse, nil, nil);
   };
 
@@ -183,23 +179,22 @@
     // will still result in successful authentication
     [fetcher.authorizer stopAuthorization];
     [fetcher.authorizer stopAuthorizationForRequest:fetcher.request];
-    NSHTTPURLResponse *httpResponse =
-        [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                    statusCode:200
-                                   HTTPVersion:kHTTPVersion
-                                  headerFields:nil];
+    NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                  statusCode:200
+                                                                 HTTPVersion:kHTTPVersion
+                                                                headerFields:nil];
     response(httpResponse, nil, nil);
   };
 
-  [self.fetcher beginFetchWithCompletionHandler:^(NSData *_Nullable data,
-                                                  NSError *_Nullable error) {
-    NSDictionary<NSString *, NSString *> *headers = self.fetcher.request.allHTTPHeaderFields;
-    NSString *authHeader = [headers objectForKey:@"Authorization"];
-    NSString *firebaseToken =
-        [NSString stringWithFormat:kFIRStorageAuthTokenFormat, kFIRStorageTestAuthToken];
-    XCTAssertEqualObjects(authHeader, firebaseToken);
-    [expectation fulfill];
-  }];
+  [self.fetcher
+      beginFetchWithCompletionHandler:^(NSData *_Nullable data, NSError *_Nullable error) {
+        NSDictionary<NSString *, NSString *> *headers = self.fetcher.request.allHTTPHeaderFields;
+        NSString *authHeader = [headers objectForKey:@"Authorization"];
+        NSString *firebaseToken =
+            [NSString stringWithFormat:kFIRStorageAuthTokenFormat, kFIRStorageTestAuthToken];
+        XCTAssertEqualObjects(authHeader, firebaseToken);
+        [expectation fulfill];
+      }];
 
   [FIRStorageTestHelpers waitForExpectation:self];
 }
@@ -209,11 +204,10 @@
 
   self.fetcher.testBlock = ^(GTMSessionFetcher *fetcher, GTMSessionFetcherTestResponse response) {
     XCTAssertNil([fetcher.authorizer userEmail]);
-    NSHTTPURLResponse *httpResponse =
-        [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                    statusCode:200
-                                   HTTPVersion:kHTTPVersion
-                                  headerFields:nil];
+    NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                  statusCode:200
+                                                                 HTTPVersion:kHTTPVersion
+                                                                headerFields:nil];
     response(httpResponse, nil, nil);
   };
 
diff --git a/Example/Storage/Tests/Unit/FIRStorageUpdateMetadataTests.m b/Example/Storage/Tests/Unit/FIRStorageUpdateMetadataTests.m
index d2d2950..62ac6a5 100644
--- a/Example/Storage/Tests/Unit/FIRStorageUpdateMetadataTests.m
+++ b/Example/Storage/Tests/Unit/FIRStorageUpdateMetadataTests.m
@@ -30,7 +30,7 @@
 - (void)setUp {
   [super setUp];
 
-  NSDictionary *metadataDict = @{ @"bucket" : @"bucket", @"name" : @"path/to/object" };
+  NSDictionary *metadataDict = @{@"bucket" : @"bucket", @"name" : @"path/to/object"};
   self.metadata = [[FIRStorageMetadata alloc] initWithDictionary:metadataDict];
 
   id mockOptions = OCMClassMock([FIROptions class]);
@@ -58,26 +58,25 @@
 - (void)testFetcherConfiguration {
   XCTestExpectation *expectation = [self expectationWithDescription:@"testSuccessfulFetch"];
 
-  self.fetcherService.testBlock = ^(GTMSessionFetcher *fetcher,
-                                    GTMSessionFetcherTestResponse response) {
+  self.fetcherService.testBlock =
+      ^(GTMSessionFetcher *fetcher, GTMSessionFetcherTestResponse response) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Warc-retain-cycles"
-    XCTAssertEqualObjects(fetcher.request.URL, [FIRStorageTestHelpers objectURL]);
-    XCTAssertEqualObjects(fetcher.request.HTTPMethod, @"PATCH");
-    NSData *bodyData = [NSData frs_dataFromJSONDictionary:[self.metadata updatedMetadata]];
-    XCTAssertEqualObjects(fetcher.request.HTTPBody, bodyData);
-    NSDictionary *HTTPHeaders = fetcher.request.allHTTPHeaderFields;
-    XCTAssertEqualObjects(HTTPHeaders[@"Content-Type"], @"application/json; charset=UTF-8");
-    XCTAssertEqualObjects(HTTPHeaders[@"Content-Length"], [@(bodyData.length) stringValue]);
+        XCTAssertEqualObjects(fetcher.request.URL, [FIRStorageTestHelpers objectURL]);
+        XCTAssertEqualObjects(fetcher.request.HTTPMethod, @"PATCH");
+        NSData *bodyData = [NSData frs_dataFromJSONDictionary:[self.metadata updatedMetadata]];
+        XCTAssertEqualObjects(fetcher.request.HTTPBody, bodyData);
+        NSDictionary *HTTPHeaders = fetcher.request.allHTTPHeaderFields;
+        XCTAssertEqualObjects(HTTPHeaders[@"Content-Type"], @"application/json; charset=UTF-8");
+        XCTAssertEqualObjects(HTTPHeaders[@"Content-Length"], [@(bodyData.length) stringValue]);
 #pragma clang diagnostic pop
-    NSHTTPURLResponse *httpResponse =
-        [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
-                                    statusCode:200
-                                   HTTPVersion:kHTTPVersion
-                                  headerFields:nil];
-    response(httpResponse, nil, nil);
-    self.fetcherService.testBlock = nil;
-  };
+        NSHTTPURLResponse *httpResponse = [[NSHTTPURLResponse alloc] initWithURL:fetcher.request.URL
+                                                                      statusCode:200
+                                                                     HTTPVersion:kHTTPVersion
+                                                                    headerFields:nil];
+        response(httpResponse, nil, nil);
+        self.fetcherService.testBlock = nil;
+      };
 
   FIRStoragePath *path = [FIRStorageTestHelpers objectPath];
   FIRStorageReference *ref = [[FIRStorageReference alloc] initWithStorage:self.storage path:path];
diff --git a/Example/Storage/Tests/Unit/FIRStorageUtilsTests.m b/Example/Storage/Tests/Unit/FIRStorageUtilsTests.m
index 8bf4c7e..7e4a046 100644
--- a/Example/Storage/Tests/Unit/FIRStorageUtilsTests.m
+++ b/Example/Storage/Tests/Unit/FIRStorageUtilsTests.m
@@ -43,7 +43,7 @@
   NSString *JSONString = @"{\"hello\" : \"world\"}";
   NSData *JSONData = [JSONString dataUsingEncoding:NSUTF8StringEncoding];
   NSDictionary *JSONDictionary = [NSDictionary frs_dictionaryFromJSONData:JSONData];
-  NSDictionary *expectedDictionary = @{ @"hello" : @"world" };
+  NSDictionary *expectedDictionary = @{@"hello" : @"world"};
   XCTAssertEqualObjects(JSONDictionary, expectedDictionary);
 }
 
@@ -60,7 +60,7 @@
 }
 
 - (void)testParseGoodDictToData {
-  NSDictionary *JSONDictionary = @{ @"hello" : @"world" };
+  NSDictionary *JSONDictionary = @{@"hello" : @"world"};
   NSData *expectedData = [NSData frs_dataFromJSONDictionary:JSONDictionary];
   NSString *JSONString = [[NSString alloc] initWithData:expectedData encoding:NSUTF8StringEncoding];
   NSString *expectedString = @"{\"hello\":\"world\"}";
@@ -85,13 +85,13 @@
 }
 
 - (void)testSingleItemToQueryString {
-  NSDictionary *params = @{ @"foo" : @"bar" };
+  NSDictionary *params = @{@"foo" : @"bar"};
   NSString *queryString = [FIRStorageUtils queryStringForDictionary:params];
   XCTAssertEqualObjects(queryString, @"foo=bar");
 }
 
 - (void)testMultiItemDictToQueryString {
-  NSDictionary *params = @{ @"foo" : @"bar", @"baz" : @"qux" };
+  NSDictionary *params = @{@"foo" : @"bar", @"baz" : @"qux"};
   NSString *queryString = [FIRStorageUtils queryStringForDictionary:params];
   XCTAssertEqualObjects(queryString, @"foo=bar&baz=qux");
 }