@react-native-firebase/storage 26.3.3 → 27.0.0

package/ios/RNFBStorageUnitTests/RNFBStorageErrorCodeMapperFacadeTests.m

@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <XCTest/XCTest.h>
+
+#import "RNFBHandleMapStorage-Swift.inc"
+
+@interface RNFBStorageErrorCodeMapperFacadeTests : XCTestCase
+@end
+
+@implementation RNFBStorageErrorCodeMapperFacadeTests
+
+- (NSError *)errorWithCode:(NSInteger)code description:(NSString *)description {
+  return [NSError errorWithDomain:@"FIRStorageErrorDomain"
+                             code:code
+                         userInfo:@{NSLocalizedDescriptionKey : description}];
+}
+
+- (void)testObjCSelectorNilAndKnownCodes {
+  NSArray *nilPair = [RNFBStorageErrorCodeMapper codeAndMessageForError:nil];
+  XCTAssertEqualObjects(nilPair[0], @"unknown");
+  XCTAssertEqualObjects(nilPair[1], @"An unknown error has occurred.");
+
+  // FIRStorageErrorCodeObjectNotFound
+  NSArray *notFound = [RNFBStorageErrorCodeMapper codeAndMessageForError:[self errorWithCode:-13010
+                                                                                 description:@"x"]];
+  XCTAssertEqualObjects(notFound[0], @"object-not-found");
+  XCTAssertEqualObjects(notFound[1], @"No object exists at the desired reference.");
+
+  // FIRStorageErrorCodeCancelled
+  NSArray *cancelled = [RNFBStorageErrorCodeMapper
+      codeAndMessageForError:[self errorWithCode:-13040 description:@"x"]];
+  XCTAssertEqualObjects(cancelled[0], @"cancelled");
+  XCTAssertEqualObjects(cancelled[1], @"User cancelled the operation.");
+}
+
+- (void)testObjCSelectorUnknownPermissionAndResponseBody {
+  // Permission-denied underlying → invalid-device-file-path
+  NSError *underlying = [NSError
+      errorWithDomain:NSPOSIXErrorDomain
+                 code:1
+             userInfo:@{
+               NSLocalizedDescriptionKey : @"The operation couldn’t be completed. Permission denied"
+             }];
+  NSError *permissionError = [NSError errorWithDomain:@"FIRStorageErrorDomain"
+                                                 code:-13000
+                                             userInfo:@{NSUnderlyingErrorKey : underlying}];
+  NSArray *permissionPair = [RNFBStorageErrorCodeMapper codeAndMessageForError:permissionError];
+  XCTAssertEqualObjects(permissionPair[0], @"invalid-device-file-path");
+  XCTAssertEqualObjects(permissionPair[1],
+                        @"The specified device file path is invalid or is restricted.");
+
+  // ResponseBody → formatted unknown message
+  NSError *bodyError = [NSError errorWithDomain:@"FIRStorageErrorDomain"
+                                           code:-13000
+                                       userInfo:@{@"ResponseBody" : @"backend detail"}];
+  NSArray *bodyPair = [RNFBStorageErrorCodeMapper codeAndMessageForError:bodyError];
+  XCTAssertEqualObjects(bodyPair[0], @"unknown");
+  XCTAssertEqualObjects(bodyPair[1],
+                        @"An unknown error has occurred. (underlying reason 'backend detail')");
+}
+
+- (void)testObjCSelectorDefaultKeepsLocalizedDescription {
+  // FIRStorageErrorCodeInvalidArgument
+  NSArray *pair = [RNFBStorageErrorCodeMapper
+      codeAndMessageForError:[self errorWithCode:-13050 description:@"keep me"]];
+  XCTAssertEqualObjects(pair[0], @"unknown");
+  XCTAssertEqualObjects(pair[1], @"keep me");
+}
+
+- (void)testFacadePublicSelectorUnchanged {
+  XCTAssertTrue([RNFBStorageErrorCodeMapper respondsToSelector:@selector(codeAndMessageForError:)]);
+  NSMethodSignature *signature =
+      [RNFBStorageErrorCodeMapper methodSignatureForSelector:@selector(codeAndMessageForError:)];
+  XCTAssertEqual(strcmp(signature.methodReturnType, @encode(id)), 0);
+}
+
+@end

package/ios/RNFBStorageUnitTests/RNFBStorageErrorCodeMapperTests.swift

@@ -0,0 +1,211 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import XCTest
+
+final class RNFBStorageErrorCodeMapperTests: XCTestCase {
+  /// `FIRStorageErrorCodeUnknown`
+  private let codeUnknown = -13000
+  /// `FIRStorageErrorCodeObjectNotFound`
+  private let codeObjectNotFound = -13010
+  /// `FIRStorageErrorCodeBucketNotFound`
+  private let codeBucketNotFound = -13011
+  /// `FIRStorageErrorCodeProjectNotFound`
+  private let codeProjectNotFound = -13012
+  /// `FIRStorageErrorCodeQuotaExceeded`
+  private let codeQuotaExceeded = -13013
+  /// `FIRStorageErrorCodeUnauthenticated`
+  private let codeUnauthenticated = -13020
+  /// `FIRStorageErrorCodeUnauthorized`
+  private let codeUnauthorized = -13021
+  /// `FIRStorageErrorCodeRetryLimitExceeded`
+  private let codeRetryLimitExceeded = -13030
+  /// `FIRStorageErrorCodeNonMatchingChecksum`
+  private let codeNonMatchingChecksum = -13031
+  /// `FIRStorageErrorCodeDownloadSizeExceeded`
+  private let codeDownloadSizeExceeded = -13032
+  /// `FIRStorageErrorCodeCancelled`
+  private let codeCancelled = -13040
+
+  private func makeError(code: Int, description: String = "native", userInfo: [String: Any] = [:])
+    -> NSError
+  {
+    var info = userInfo
+    if info[NSLocalizedDescriptionKey] == nil {
+      info[NSLocalizedDescriptionKey] = description
+    }
+    return NSError(domain: "FIRStorageErrorDomain", code: code, userInfo: info)
+  }
+
+  func testNilErrorReturnsUnknownPair() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(for: nil)
+    XCTAssertEqual(result, ["unknown", "An unknown error has occurred."])
+  }
+
+  func testObjectNotFound() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeObjectNotFound)
+    )
+    XCTAssertEqual(result, ["object-not-found", "No object exists at the desired reference."])
+  }
+
+  func testBucketNotFound() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeBucketNotFound)
+    )
+    XCTAssertEqual(
+      result,
+      ["bucket-not-found", "No bucket is configured for Firebase Storage."]
+    )
+  }
+
+  func testProjectNotFound() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeProjectNotFound)
+    )
+    XCTAssertEqual(
+      result,
+      ["project-not-found", "No project is configured for Firebase Storage."]
+    )
+  }
+
+  func testQuotaExceeded() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeQuotaExceeded)
+    )
+    XCTAssertEqual(
+      result,
+      ["quota-exceeded", "Quota on your Firebase Storage bucket has been exceeded."]
+    )
+  }
+
+  func testUnauthenticated() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeUnauthenticated)
+    )
+    XCTAssertEqual(
+      result,
+      ["unauthenticated", "User is unauthenticated. Authenticate and try again."]
+    )
+  }
+
+  func testUnauthorized() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeUnauthorized)
+    )
+    XCTAssertEqual(
+      result,
+      ["unauthorized", "User is not authorized to perform the desired action."]
+    )
+  }
+
+  func testRetryLimitExceeded() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeRetryLimitExceeded)
+    )
+    XCTAssertEqual(
+      result,
+      [
+        "retry-limit-exceeded",
+        "The maximum time limit on an operation (upload, download, delete, etc.) has been exceeded.",
+      ]
+    )
+  }
+
+  func testNonMatchingChecksum() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeNonMatchingChecksum)
+    )
+    XCTAssertEqual(
+      result,
+      [
+        "non-matching-checksum",
+        "File on the client does not match the checksum of the file received by the server.",
+      ]
+    )
+  }
+
+  func testDownloadSizeExceeded() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeDownloadSizeExceeded)
+    )
+    XCTAssertEqual(
+      result,
+      [
+        "download-size-exceeded",
+        "Size of the downloaded file exceeds the amount of memory allocated for the download.",
+      ]
+    )
+  }
+
+  func testCancelled() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeCancelled)
+    )
+    XCTAssertEqual(result, ["cancelled", "User cancelled the operation."])
+  }
+
+  func testUnknownWithoutExtras() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: codeUnknown, description: "should be replaced")
+    )
+    XCTAssertEqual(result, ["unknown", "An unknown error has occurred."])
+  }
+
+  func testUnknownPermissionDeniedOverride() {
+    let underlying = NSError(
+      domain: NSPOSIXErrorDomain,
+      code: 1,
+      userInfo: [
+        NSLocalizedDescriptionKey: "The operation couldn’t be completed. Permission denied",
+      ]
+    )
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(
+        code: codeUnknown,
+        userInfo: [NSUnderlyingErrorKey: underlying]
+      )
+    )
+    XCTAssertEqual(
+      result,
+      [
+        "invalid-device-file-path",
+        "The specified device file path is invalid or is restricted.",
+      ]
+    )
+  }
+
+  func testUnknownResponseBodyMessage() {
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(
+        code: codeUnknown,
+        userInfo: ["ResponseBody": "quota soft limit"]
+      )
+    )
+    XCTAssertEqual(
+      result,
+      ["unknown", "An unknown error has occurred. (underlying reason 'quota soft limit')"]
+    )
+  }
+
+  func testDefaultKeepsLocalizedDescription() {
+    // FIRStorageErrorCodeInvalidArgument (-13050) and any unmapped code
+    let result = RNFBStorageErrorCodeMapper.codeAndMessage(
+      for: makeError(code: -13050, description: "Invalid argument from SDK")
+    )
+    XCTAssertEqual(result, ["unknown", "Invalid argument from SDK"])
+  }
+}

package/ios/RNFBStorageUnitTests/RNFBStorageErrorSnapshotDictBuilderFacadeTests.m

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <XCTest/XCTest.h>
+
+#import "RNFBHandleMapStorage-Swift.inc"
+
+@interface RNFBStorageErrorSnapshotDictBuilderFacadeTests : XCTestCase
+@end
+
+@implementation RNFBStorageErrorSnapshotDictBuilderFacadeTests
+
+- (NSError *)errorWithCode:(NSInteger)code description:(NSString *)description {
+  return [NSError errorWithDomain:@"FIRStorageErrorDomain"
+                             code:code
+                         userInfo:@{NSLocalizedDescriptionKey : description}];
+}
+
+- (void)testFullBuilderSetsCodeMessageAndNativeErrorMessage {
+  NSMutableDictionary *snapshot = [@{@"status" : @"error"} mutableCopy];
+  // FIRStorageErrorCodeObjectNotFound
+  NSError *error = [self errorWithCode:-13010 description:@"native detail"];
+
+  NSDictionary *result = [RNFBStorageErrorSnapshotDictBuilder buildErrorSnapshotDict:error
+                                                                    taskSnapshotDict:snapshot];
+
+  XCTAssertTrue(result == snapshot, @"must mutate in place and return same dict");
+  NSDictionary *errorDict = snapshot[@"error"];
+  XCTAssertEqualObjects(errorDict[@"code"], @"object-not-found");
+  XCTAssertEqualObjects(errorDict[@"message"], @"No object exists at the desired reference.");
+  XCTAssertEqualObjects(errorDict[@"nativeErrorMessage"], @"native detail");
+  XCTAssertEqual(errorDict.count, 3u);
+}
+
+- (void)testFromCodeAndMessageSetsCodeAndMessageOnly {
+  NSMutableDictionary *snapshot = [@{@"status" : @"error"} mutableCopy];
+  NSArray *pair = @[ @"unauthorized", @"User is not authorized to perform the desired action." ];
+
+  NSDictionary *result =
+      [RNFBStorageErrorSnapshotDictBuilder buildErrorSnapshotDictFromCodeAndMessage:pair
+                                                                   taskSnapshotDict:snapshot];
+
+  XCTAssertTrue(result == snapshot, @"must mutate in place and return same dict");
+  NSDictionary *errorDict = snapshot[@"error"];
+  XCTAssertEqualObjects(errorDict[@"code"], @"unauthorized");
+  XCTAssertEqualObjects(errorDict[@"message"],
+                        @"User is not authorized to perform the desired action.");
+  XCTAssertNil(errorDict[@"nativeErrorMessage"]);
+  XCTAssertEqual(errorDict.count, 2u);
+}
+
+- (void)testNilSnapshotDictReturnsNil {
+  NSError *error = [self errorWithCode:-13040 description:@"cancelled native"];
+  NSDictionary *fullNil = [RNFBStorageErrorSnapshotDictBuilder buildErrorSnapshotDict:error
+                                                                     taskSnapshotDict:nil];
+  XCTAssertNil(fullNil);
+
+  NSArray *pair = @[ @"cancelled", @"User cancelled the operation." ];
+  NSDictionary *codeNil =
+      [RNFBStorageErrorSnapshotDictBuilder buildErrorSnapshotDictFromCodeAndMessage:pair
+                                                                   taskSnapshotDict:nil];
+  XCTAssertNil(codeNil);
+}
+
+- (void)testFullBuilderNilErrorUsesNullNativeMessage {
+  NSMutableDictionary *snapshot = [NSMutableDictionary dictionary];
+  NSDictionary *result = [RNFBStorageErrorSnapshotDictBuilder buildErrorSnapshotDict:nil
+                                                                    taskSnapshotDict:snapshot];
+  XCTAssertTrue(result == snapshot);
+  NSDictionary *errorDict = snapshot[@"error"];
+  XCTAssertEqualObjects(errorDict[@"code"], @"unknown");
+  XCTAssertEqualObjects(errorDict[@"message"], @"An unknown error has occurred.");
+  XCTAssertEqualObjects(errorDict[@"nativeErrorMessage"], [NSNull null]);
+}
+
+- (void)testEmptySnapshotDictMutatedInPlace {
+  NSMutableDictionary *empty = [NSMutableDictionary dictionary];
+  NSError *error = [self errorWithCode:-13040 description:@"cancelled native"];
+
+  NSDictionary *fullResult = [RNFBStorageErrorSnapshotDictBuilder buildErrorSnapshotDict:error
+                                                                        taskSnapshotDict:empty];
+  XCTAssertTrue(fullResult == empty);
+  XCTAssertEqualObjects(empty[@"error"][@"code"], @"cancelled");
+  XCTAssertEqualObjects(empty[@"error"][@"nativeErrorMessage"], @"cancelled native");
+
+  NSMutableDictionary *empty2 = [NSMutableDictionary dictionary];
+  NSArray *pair = @[ @"unknown", @"An unknown error has occurred." ];
+  NSDictionary *codeResult =
+      [RNFBStorageErrorSnapshotDictBuilder buildErrorSnapshotDictFromCodeAndMessage:pair
+                                                                   taskSnapshotDict:empty2];
+  XCTAssertTrue(codeResult == empty2);
+  XCTAssertEqualObjects(empty2[@"error"][@"code"], @"unknown");
+  XCTAssertNil(empty2[@"error"][@"nativeErrorMessage"]);
+}
+
+- (void)testFacadePublicSelectorsUnchanged {
+  SEL fullSel = @selector(buildErrorSnapshotDict:taskSnapshotDict:);
+  SEL fromCodeSel = @selector(buildErrorSnapshotDictFromCodeAndMessage:taskSnapshotDict:);
+
+  XCTAssertTrue([RNFBStorageErrorSnapshotDictBuilder respondsToSelector:fullSel]);
+  XCTAssertTrue([RNFBStorageErrorSnapshotDictBuilder respondsToSelector:fromCodeSel]);
+
+  NSMethodSignature *fullSig =
+      [RNFBStorageErrorSnapshotDictBuilder methodSignatureForSelector:fullSel];
+  XCTAssertEqual(strcmp(fullSig.methodReturnType, @encode(id)), 0);
+
+  NSMethodSignature *codeSig =
+      [RNFBStorageErrorSnapshotDictBuilder methodSignatureForSelector:fromCodeSel];
+  XCTAssertEqual(strcmp(codeSig.methodReturnType, @encode(id)), 0);
+}
+
+@end

package/ios/RNFBStorageUnitTests/RNFBStorageTaskRegistryStorageTests.swift

@@ -0,0 +1,154 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import XCTest
+
+private final class FakeCancellableHandle: NSObject {
+  private(set) var cancelCount = 0
+  var onCancel: (() -> Void)?
+
+  @objc func cancel() {
+    cancelCount += 1
+    onCancel?()
+  }
+}
+
+final class RNFBStorageTaskRegistryStorageTests: XCTestCase {
+  private var storage: RNFBStorageTaskRegistryStorage!
+
+  override func setUp() {
+    super.setUp()
+    storage = RNFBStorageTaskRegistryStorage()
+  }
+
+  func testPutIfAbsent_storesWhenFree() {
+    let handle = FakeCancellableHandle()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: handle))
+    XCTAssertTrue(storage.get(1 as NSNumber) === handle)
+    XCTAssertEqual(handle.cancelCount, 0)
+  }
+
+  func testPutIfAbsent_collision_keepsExistingWithoutCancel() {
+    let first = FakeCancellableHandle()
+    let second = FakeCancellableHandle()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: first))
+    XCTAssertFalse(storage.putIfAbsent(1 as NSNumber, value: second))
+    XCTAssertTrue(storage.get(1 as NSNumber) === first)
+    XCTAssertEqual(first.cancelCount, 0)
+    XCTAssertEqual(second.cancelCount, 0)
+  }
+
+  func testPutOrDiscard_storesWhenFree() {
+    let handle = FakeCancellableHandle()
+    XCTAssertTrue(storage.putOrDiscard(1 as NSNumber, value: handle))
+    XCTAssertTrue(storage.get(1 as NSNumber) === handle)
+    XCTAssertEqual(handle.cancelCount, 0)
+  }
+
+  func testPutOrDiscard_collision_cancelsIncoming() {
+    let first = FakeCancellableHandle()
+    let duplicate = FakeCancellableHandle()
+    XCTAssertTrue(storage.putOrDiscard(1 as NSNumber, value: first))
+    XCTAssertFalse(storage.putOrDiscard(1 as NSNumber, value: duplicate))
+    XCTAssertEqual(duplicate.cancelCount, 1)
+    XCTAssertEqual(first.cancelCount, 0)
+    XCTAssertTrue(storage.get(1 as NSNumber) === first)
+  }
+
+  func testGet_whenFree_isNil() {
+    XCTAssertNil(storage.get(99 as NSNumber))
+  }
+
+  func testTake_removesAndReturnsWithoutCallingCancel() {
+    let handle = FakeCancellableHandle()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: handle))
+    XCTAssertTrue(storage.take(1 as NSNumber) === handle)
+    XCTAssertNil(storage.get(1 as NSNumber))
+    XCTAssertEqual(handle.cancelCount, 0)
+  }
+
+  func testTake_whenFree_isNil() {
+    XCTAssertNil(storage.take(99 as NSNumber))
+  }
+
+  func testTakeIf_whenIdentityMatches_takes() {
+    let handle = FakeCancellableHandle()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: handle))
+    XCTAssertTrue(storage.takeIf(1 as NSNumber, when: { $0 === handle }) === handle)
+    XCTAssertNil(storage.get(1 as NSNumber))
+  }
+
+  func testTakeIf_whenIdentityMismatch_leavesMapping() {
+    let mapped = FakeCancellableHandle()
+    let other = FakeCancellableHandle()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: mapped))
+    XCTAssertNil(storage.takeIf(1 as NSNumber, when: { $0 === other }))
+    XCTAssertTrue(storage.get(1 as NSNumber) === mapped)
+  }
+
+  func testTakeAndCancel_cancelsAndRemoves() {
+    let handle = FakeCancellableHandle()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: handle))
+    XCTAssertTrue(storage.takeAndCancel(1 as NSNumber))
+    XCTAssertEqual(handle.cancelCount, 1)
+    XCTAssertNil(storage.get(1 as NSNumber))
+  }
+
+  func testTakeAndCancel_missingKey_returnsFalse() {
+    XCTAssertFalse(storage.takeAndCancel(99 as NSNumber))
+  }
+
+  func testTakeAndCancel_replacementDuringCancel_leavesReplacement() {
+    let original = FakeCancellableHandle()
+    let replacement = FakeCancellableHandle()
+    original.onCancel = { [weak self] in
+      guard let self = self else { return }
+      _ = self.storage.take(11 as NSNumber)
+      _ = self.storage.putIfAbsent(11 as NSNumber, value: replacement)
+    }
+    XCTAssertTrue(storage.putIfAbsent(11 as NSNumber, value: original))
+    XCTAssertTrue(storage.takeAndCancel(11 as NSNumber))
+    XCTAssertEqual(original.cancelCount, 1)
+    XCTAssertTrue(storage.get(11 as NSNumber) === replacement)
+    XCTAssertEqual(replacement.cancelCount, 0)
+  }
+
+  func testTakeAndCancel_objectWithoutCancel_doesNotCrash() {
+    let plain = NSObject()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: plain))
+    XCTAssertTrue(storage.takeAndCancel(1 as NSNumber))
+    XCTAssertNil(storage.get(1 as NSNumber))
+  }
+
+  func testCancelAll_cancelsSnapshotAndLeavesEmpty() {
+    let a = FakeCancellableHandle()
+    let b = FakeCancellableHandle()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: a))
+    XCTAssertTrue(storage.putIfAbsent(2 as NSNumber, value: b))
+    storage.cancelAll()
+    XCTAssertEqual(a.cancelCount, 1)
+    XCTAssertEqual(b.cancelCount, 1)
+    XCTAssertNil(storage.get(1 as NSNumber))
+    XCTAssertNil(storage.get(2 as NSNumber))
+  }
+
+  func testCancelAll_objectWithoutCancel_doesNotCrash() {
+    let plain = NSObject()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: plain))
+    storage.cancelAll()
+    XCTAssertNil(storage.get(1 as NSNumber))
+  }
+}