@react-native-firebase/app 26.3.3 → 27.0.0

package/ios/RNFBAppUnitTests/RNFBAppUnitTests.xcodeproj/xcshareddata/xcschemes/RNFBAppUnitTests.xcscheme

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "2600"
+   version = "1.7">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "A10000000000000000000002"
+               BuildableName = "RNFBAppUnitTests.xctest"
+               BlueprintName = "RNFBAppUnitTests"
+               ReferencedContainer = "container:RNFBAppUnitTests.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      codeCoverageEnabled = "YES">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "A10000000000000000000002"
+               BuildableName = "RNFBAppUnitTests.xctest"
+               BlueprintName = "RNFBAppUnitTests"
+               ReferencedContainer = "container:RNFBAppUnitTests.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

package/ios/RNFBAppUnitTests/RNFBFirebaseAppClientTests.swift

@@ -0,0 +1,165 @@
+/**
+ * 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 FirebaseCore
+import Foundation
+import RNFBFirebase
+import XCTest
+
+@_silgen_name("RNFBFirebaseInstallationsLinked")
+private func RNFBFirebaseInstallationsLinked() -> ObjCBool
+
+final class RNFBFirebaseAppClientTests: XCTestCase {
+  override func tearDown() {
+    FirebaseApp.resetRegistryForTesting()
+    FirebaseConfiguration.resetForTesting()
+    super.tearDown()
+  }
+
+  func testInstallationsLinkageAnchorIsDistinctFromNSObject() {
+    XCTAssertTrue(RNFBFirebaseInstallationsLinked().boolValue)
+  }
+
+  func testCreateOptionsPreservesNilIdentifiersAndDeallocates() {
+    weak var released: FirebaseOptions?
+    autoreleasepool {
+      let created = RNFBFirebaseOptionsClient.create(googleAppID: nil, gcmSenderID: nil)
+      let options = created as! FirebaseOptions
+      released = options
+      XCTAssertNil(options.googleAppID)
+      XCTAssertNil(options.gcmSenderID)
+    }
+    XCTAssertNil(released)
+  }
+
+  func testOptionsClientRoundTripsMutableFields() {
+    let created = RNFBFirebaseOptionsClient.create(googleAppID: "app-id", gcmSenderID: "sender-id")
+    let createdOptions = created as! FirebaseOptions
+    XCTAssertEqual(createdOptions.googleAppID, "app-id")
+    XCTAssertEqual(createdOptions.gcmSenderID, "sender-id")
+
+    RNFBFirebaseOptionsClient.setAPIKey("api-key", on: created)
+    RNFBFirebaseOptionsClient.setProjectID("project-id", on: created)
+    RNFBFirebaseOptionsClient.setClientID("client-id", on: created)
+    RNFBFirebaseOptionsClient.setDatabaseURL("https://example.firebaseio.com", on: created)
+    RNFBFirebaseOptionsClient.setStorageBucket("example.appspot.com", on: created)
+    RNFBFirebaseOptionsClient.setBundleID("com.example.app", on: created)
+    RNFBFirebaseOptionsClient.setAppGroupID("group.com.example", on: created)
+
+    XCTAssertEqual(RNFBFirebaseOptionsClient.apiKey(created), "api-key")
+    XCTAssertEqual(RNFBFirebaseOptionsClient.projectID(created), "project-id")
+    XCTAssertEqual(RNFBFirebaseOptionsClient.clientID(created), "client-id")
+    XCTAssertEqual(RNFBFirebaseOptionsClient.databaseURL(created), "https://example.firebaseio.com")
+    XCTAssertEqual(RNFBFirebaseOptionsClient.storageBucket(created), "example.appspot.com")
+    XCTAssertEqual(RNFBFirebaseOptionsClient.bundleID(created), "com.example.app")
+    XCTAssertEqual(RNFBFirebaseOptionsClient.appGroupID(created), "group.com.example")
+
+    // Pre-port `options.bundleID = nil` removed the key. nil must reach the SDK setter.
+    RNFBFirebaseOptionsClient.setBundleID(nil, on: created)
+    RNFBFirebaseOptionsClient.setAppGroupID(nil, on: created)
+    XCTAssertNil(createdOptions.bundleID)
+    XCTAssertNil(RNFBFirebaseOptionsClient.bundleID(created))
+    XCTAssertNil(RNFBFirebaseOptionsClient.appGroupID(created))
+  }
+
+  func testAppLookupConfigureSnapshotAndAllApps() {
+    XCTAssertNil(RNFBFirebaseAppClient.defaultApp())
+    XCTAssertNil(RNFBFirebaseAppClient.app(named: "missing"))
+    XCTAssertNil(RNFBFirebaseAppClient.allApps())
+
+    let options = RNFBFirebaseOptionsClient.create(googleAppID: "app-id", gcmSenderID: "sender-id")
+    RNFBFirebaseOptionsClient.setAPIKey("api-key", on: options)
+    RNFBFirebaseOptionsClient.setProjectID("project-id", on: options)
+    RNFBFirebaseOptionsClient.setClientID("client-id", on: options)
+    RNFBFirebaseOptionsClient.setDatabaseURL("https://example.firebaseio.com", on: options)
+    RNFBFirebaseOptionsClient.setStorageBucket("example.appspot.com", on: options)
+
+    RNFBFirebaseAppClient.configure(options: options)
+    let defaultApp = RNFBFirebaseAppClient.defaultApp()
+    XCTAssertNotNil(defaultApp)
+
+    let namedOptions = RNFBFirebaseOptionsClient.create(googleAppID: "named-app", gcmSenderID: "named-sender")
+    RNFBFirebaseAppClient.configure(name: "secondary", options: namedOptions)
+    let named = RNFBFirebaseAppClient.app(named: "secondary")
+    XCTAssertNotNil(named)
+
+    let apps = RNFBFirebaseAppClient.allApps()
+    XCTAssertEqual(apps?.count, 2)
+
+    let snapshot = RNFBFirebaseAppClient.snapshot(of: defaultApp!)
+    XCTAssertEqual(snapshot.name, "__FIRAPP_DEFAULT")
+    XCTAssertEqual(snapshot.googleAppID, "app-id")
+    XCTAssertEqual(snapshot.gcmSenderID, "sender-id")
+    XCTAssertEqual(snapshot.apiKey, "api-key")
+    XCTAssertEqual(snapshot.projectID, "project-id")
+    XCTAssertEqual(snapshot.clientID, "client-id")
+    XCTAssertEqual(snapshot.databaseURL, "https://example.firebaseio.com")
+    XCTAssertEqual(snapshot.storageBucket, "example.appspot.com")
+    XCTAssertFalse(snapshot.isDataCollectionDefaultEnabled)
+
+    XCTAssertFalse(RNFBFirebaseAppClient.setDataCollectionDefaultEnabled(true, forApp: NSObject()))
+    XCTAssertTrue(RNFBFirebaseAppClient.setDataCollectionDefaultEnabled(true, forApp: defaultApp!))
+    XCTAssertTrue(RNFBFirebaseAppClient.snapshot(of: defaultApp!).isDataCollectionDefaultEnabled)
+  }
+
+  func testDefaultPlistConfigureCreatesDefaultApp() {
+    // The dynamic probe app (test-rn-bare) calls this overload from its AppDelegate.
+    XCTAssertNil(RNFBFirebaseAppClient.defaultApp())
+    RNFBFirebaseAppClient.configure()
+    XCTAssertNotNil(RNFBFirebaseAppClient.defaultApp())
+  }
+
+  func testDeleteAppRejectsNonFirebaseAndRemovesLiveApp() {
+    var completionCalled = false
+    XCTAssertFalse(
+      RNFBFirebaseAppClient.deleteApp(NSObject()) { _ in
+        completionCalled = true
+      }
+    )
+    XCTAssertFalse(completionCalled)
+
+    let options = RNFBFirebaseOptionsClient.create(googleAppID: "app-id", gcmSenderID: "sender")
+    RNFBFirebaseAppClient.configure(name: "secondary", options: options)
+    let app = RNFBFirebaseAppClient.app(named: "secondary")!
+    let expectation = expectation(description: "delete")
+    XCTAssertTrue(
+      RNFBFirebaseAppClient.deleteApp(app) { success in
+        XCTAssertTrue(success)
+        expectation.fulfill()
+      }
+    )
+    waitForExpectations(timeout: 1)
+    XCTAssertNil(RNFBFirebaseAppClient.app(named: "secondary"))
+  }
+
+  func testLoggerLevelPassesThroughKnownAndUnknownValues() {
+    RNFBFirebaseAppClient.setLoggerLevel(7)
+    XCTAssertEqual(FirebaseConfiguration.shared.loggerLevel, unsafeBitCast(7, to: FirebaseLoggerLevel.self))
+    RNFBFirebaseAppClient.setLoggerLevel(99)
+    XCTAssertEqual(FirebaseConfiguration.shared.loggerLevel, unsafeBitCast(99, to: FirebaseLoggerLevel.self))
+  }
+
+  func testRegisterLibrarySkipsMissingSelectorAndRecordsWhenPresent() {
+    FirebaseApp.setRegisterLibraryAvailableForTesting(false)
+    RNFBFirebaseAppClient.registerLibrary(name: "skipped-c", version: "0")
+    XCTAssertNil(FirebaseApp.lastRegisteredLibraryNameForTesting())
+    FirebaseApp.setRegisterLibraryAvailableForTesting(true)
+
+    RNFBFirebaseAppClient.registerLibrary(name: "react-native-firebase", version: "9.9.9")
+    XCTAssertEqual(FirebaseApp.lastRegisteredLibraryNameForTesting(), "react-native-firebase")
+    XCTAssertEqual(FirebaseApp.lastRegisteredLibraryVersionForTesting(), "9.9.9")
+  }
+}

package/ios/RNFBAppUnitTests/RNFBHandleMapStorageTests.swift

@@ -0,0 +1,121 @@
+/**
+ * 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 Foundation
+import XCTest
+
+final class RNFBHandleMapStorageTests: XCTestCase {
+  private var storage: RNFBHandleMapStorage!
+
+  override func setUp() {
+    super.setUp()
+    storage = RNFBHandleMapStorage()
+  }
+
+  func testStorageOperationsPreserveExactPointers() {
+    let first = NSMutableString(string: "equal")
+    let equalButDistinct = NSMutableString(string: "equal")
+    let replacement = NSObject()
+
+    XCTAssertEqual(first, equalButDistinct)
+    XCTAssertFalse(first === equalButDistinct)
+
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: first))
+    XCTAssertFalse(storage.putIfAbsent(1 as NSNumber, value: replacement))
+    XCTAssertTrue(storage.get(1 as NSNumber) === first)
+
+    XCTAssertTrue(storage.putIfAbsentOrSame(1 as NSNumber, value: first))
+    XCTAssertFalse(storage.putIfAbsentOrSame(1 as NSNumber, value: equalButDistinct))
+    XCTAssertTrue(storage.get(1 as NSNumber) === first)
+
+    XCTAssertTrue(storage.putIfAbsentOrSame(2 as NSNumber, value: equalButDistinct))
+    XCTAssertTrue(storage.get(2 as NSNumber) === equalButDistinct)
+
+    XCTAssertNil(storage.putReplacing(3 as NSNumber, value: first))
+    XCTAssertTrue(storage.putReplacing(3 as NSNumber, value: replacement) === first)
+    XCTAssertTrue(storage.take(3 as NSNumber) === replacement)
+    XCTAssertNil(storage.take(3 as NSNumber))
+  }
+
+  func testTakeIfMissingDoesNotCallConditionAndFalseLeavesValue() {
+    var conditionCalled = false
+    XCTAssertNil(storage.takeIf(1 as NSNumber) { _ in
+      conditionCalled = true
+      return true
+    })
+    XCTAssertFalse(conditionCalled)
+
+    let value = NSObject()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: value))
+    XCTAssertNil(storage.takeIf(1 as NSNumber) { candidate in
+      conditionCalled = true
+      XCTAssertTrue(candidate === value)
+      return false
+    })
+    XCTAssertTrue(conditionCalled)
+    XCTAssertTrue(storage.get(1 as NSNumber) === value)
+  }
+
+  func testTakeIfConditionRunsUnderRecursiveLock() {
+    let value = NSObject()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: value))
+
+    let conditionEntered = DispatchSemaphore(value: 0)
+    let releaseCondition = DispatchSemaphore(value: 0)
+    let takeIfDone = DispatchSemaphore(value: 0)
+    let competingTakeDone = DispatchSemaphore(value: 0)
+    var taken: AnyObject?
+    var competingTake: AnyObject?
+
+    DispatchQueue.global().async {
+      taken = self.storage.takeIf(1 as NSNumber) { candidate in
+        XCTAssertTrue(candidate === value)
+        XCTAssertTrue(self.storage.get(1 as NSNumber) === value)
+        conditionEntered.signal()
+        XCTAssertEqual(releaseCondition.wait(timeout: .now() + 5), .success)
+        return true
+      }
+      takeIfDone.signal()
+    }
+
+    XCTAssertEqual(conditionEntered.wait(timeout: .now() + 5), .success)
+    DispatchQueue.global().async {
+      competingTake = self.storage.take(1 as NSNumber)
+      competingTakeDone.signal()
+    }
+
+    XCTAssertEqual(competingTakeDone.wait(timeout: .now() + 0.1), .timedOut)
+    releaseCondition.signal()
+    XCTAssertEqual(takeIfDone.wait(timeout: .now() + 5), .success)
+    XCTAssertEqual(competingTakeDone.wait(timeout: .now() + 5), .success)
+    XCTAssertTrue(taken === value)
+    XCTAssertNil(competingTake)
+  }
+
+  func testTakeAllReturnsSnapshotThenClears() {
+    let first = NSObject()
+    let second = NSObject()
+    XCTAssertTrue(storage.putIfAbsent(1 as NSNumber, value: first))
+    XCTAssertTrue(storage.putIfAbsent(2 as NSNumber, value: second))
+
+    let values = storage.takeAll()
+
+    XCTAssertEqual(values.count, 2)
+    XCTAssertTrue(values.contains { $0 === first })
+    XCTAssertTrue(values.contains { $0 === second })
+    XCTAssertTrue(storage.takeAll().isEmpty)
+  }
+}

package/ios/RNFBAppUnitTests/RNFBHandleMapTests.m

@@ -0,0 +1,238 @@
+/**
+ * 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 "RNFBHandleMap.h"
+
+/**
+ * XCTest coverage for RNFBHandleMap. Tests must not invoke methods on stored values — the map only
+ * moves pointers.
+ */
+@interface RNFBHandleMapTests : XCTestCase
+@property(nonatomic, strong) RNFBHandleMap *map;
+@end
+
+@implementation RNFBHandleMapTests
+
+- (void)setUp {
+  [super setUp];
+  self.map = [[RNFBHandleMap alloc] init];
+}
+
+- (void)testPutGetTake_happyPath {
+  NSObject *handle = [[NSObject alloc] init];
+  NSError *error = nil;
+  XCTAssertTrue([self.map put:@1 value:handle error:&error]);
+  XCTAssertNil(error);
+
+  XCTAssertEqual(handle, [self.map get:@1]);
+  XCTAssertEqual(handle, [self.map take:@1]);
+  XCTAssertNil([self.map get:@1]);
+}
+
+- (void)testTake_missingKey_returnsNil {
+  XCTAssertNil([self.map take:@99]);
+  XCTAssertNil([self.map get:@99]);
+}
+
+- (void)testTakeAll_returnsSnapshotAndLeavesMapEmpty {
+  NSObject *a = [[NSObject alloc] init];
+  NSObject *b = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:a error:nil]);
+  XCTAssertTrue([self.map put:@2 value:b error:nil]);
+
+  NSArray *snapshot = [self.map takeAll];
+
+  XCTAssertEqual(snapshot.count, 2u);
+  XCTAssertTrue([snapshot containsObject:a]);
+  XCTAssertTrue([snapshot containsObject:b]);
+  XCTAssertNil([self.map get:@1]);
+  XCTAssertNil([self.map get:@2]);
+  XCTAssertEqual([self.map takeAll].count, 0u);
+}
+
+- (void)testPut_occupiedId_returnsCollision {
+  NSObject *first = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+
+  NSError *error = nil;
+  XCTAssertFalse([self.map put:@1 value:[[NSObject alloc] init] error:&error]);
+  XCTAssertNotNil(error);
+  XCTAssertEqualObjects(error.domain, RNFBHandleMapErrorDomain);
+  XCTAssertEqual(error.code, RNFBHandleMapErrorCollision);
+  XCTAssertTrue([error.localizedDescription containsString:@"1"]);
+  XCTAssertEqual(first, [self.map get:@1]);
+
+  XCTAssertFalse([self.map put:@1 value:[[NSObject alloc] init] error:nil]);
+  XCTAssertEqual(first, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsent_whenFree_storesAndReturnsYes {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map putIfAbsent:@1 value:handle]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsent_whenOccupied_keepsExistingAndReturnsNo {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+  XCTAssertFalse([self.map putIfAbsent:@1 value:second]);
+  XCTAssertEqual(first, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsentOrSame_whenAbsent_storesAndReturnsYes {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map putIfAbsentOrSame:@1 value:handle]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsentOrSame_whenSameInstance_returnsYes {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:handle error:nil]);
+  XCTAssertTrue([self.map putIfAbsentOrSame:@1 value:handle]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsentOrSame_whenDifferent_returnsNo {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+  XCTAssertFalse([self.map putIfAbsentOrSame:@1 value:second]);
+  XCTAssertEqual(first, [self.map get:@1]);
+}
+
+- (void)testPutReplacing_whenFree_storesAndReturnsNil {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertNil([self.map putReplacing:@1 value:handle]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testPutReplacing_whenOccupied_replacesLastWins {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+  XCTAssertEqual(first, [self.map putReplacing:@1 value:second]);
+  XCTAssertEqual(second, [self.map get:@1]);
+}
+
+- (void)testPut_afterTake_allowsReuse {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+  XCTAssertEqual(first, [self.map take:@1]);
+  XCTAssertTrue([self.map put:@1 value:second error:nil]);
+  XCTAssertEqual(second, [self.map get:@1]);
+}
+
+- (void)testTakeIf_whenConditionYes_removesAndReturns {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:handle error:nil]);
+  XCTAssertEqual(handle, [self.map takeIf:@1
+                                     when:^BOOL(id value) {
+                                       return value == handle;
+                                     }]);
+  XCTAssertNil([self.map get:@1]);
+}
+
+- (void)testTakeIf_whenConditionNo_leavesMapping {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:handle error:nil]);
+  XCTAssertNil([self.map takeIf:@1
+                           when:^BOOL(id value) {
+                             return NO;
+                           }]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testTakeIf_whenMissing_returnsNil {
+  XCTAssertNil([self.map takeIf:@99
+                           when:^BOOL(id value) {
+                             return YES;
+                           }]);
+}
+
+- (void)testTake_sameIdFromTwoThreads_onlyOneReturnsNonNull {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:handle error:nil]);
+
+  dispatch_semaphore_t start = dispatch_semaphore_create(0);
+  dispatch_semaphore_t done = dispatch_semaphore_create(0);
+  __block id first = [NSNull null];
+  __block id second = [NSNull null];
+
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    dispatch_semaphore_wait(start, DISPATCH_TIME_FOREVER);
+    first = [self.map take:@1];
+    dispatch_semaphore_signal(done);
+  });
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    dispatch_semaphore_wait(start, DISPATCH_TIME_FOREVER);
+    second = [self.map take:@1];
+    dispatch_semaphore_signal(done);
+  });
+
+  dispatch_semaphore_signal(start);
+  dispatch_semaphore_signal(start);
+  XCTAssertEqual(dispatch_semaphore_wait(done, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)),
+                 0);
+  XCTAssertEqual(dispatch_semaphore_wait(done, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)),
+                 0);
+
+  BOOL onlyFirst = first == handle && second == nil;
+  BOOL onlySecond = second == handle && first == nil;
+  XCTAssertTrue(onlyFirst || onlySecond);
+  XCTAssertNil([self.map get:@1]);
+}
+
+- (void)testPutReplacing_sameIdFromTwoThreads_lastWins {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  NSObject *third = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+
+  dispatch_semaphore_t start = dispatch_semaphore_create(0);
+  dispatch_semaphore_t done = dispatch_semaphore_create(0);
+  __block id prevA = [NSNull null];
+  __block id prevB = [NSNull null];
+
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    dispatch_semaphore_wait(start, DISPATCH_TIME_FOREVER);
+    prevA = [self.map putReplacing:@1 value:second];
+    dispatch_semaphore_signal(done);
+  });
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    dispatch_semaphore_wait(start, DISPATCH_TIME_FOREVER);
+    prevB = [self.map putReplacing:@1 value:third];
+    dispatch_semaphore_signal(done);
+  });
+
+  dispatch_semaphore_signal(start);
+  dispatch_semaphore_signal(start);
+  XCTAssertEqual(dispatch_semaphore_wait(done, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)),
+                 0);
+  XCTAssertEqual(dispatch_semaphore_wait(done, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)),
+                 0);
+
+  id winner = [self.map get:@1];
+  XCTAssertTrue(winner == second || winner == third);
+  id returnedFirst = prevA == first ? prevA : prevB;
+  XCTAssertEqual(first, returnedFirst);
+}
+
+@end