@react-native-firebase/app 26.4.0 → 27.1.0

package/ios/RNFBAppUnitTests/RNFBNullSentinelInterceptorTests.m

@@ -0,0 +1,312 @@
+/**
+ * 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 <objc/runtime.h>
+
+#import "RNFBNullSentinelInterceptor.h"
+
+/** Set by the original (pre-swizzle) IMPs of every runtime-created stand-in class. */
+static id gLastJsonSeenByOriginalIMP = nil;
+
+static NSString *const kSpecSelector = @"JS_NativeRNFBTurboFunctions_SpecHttpsCallableData:";
+/** Prefix matches JS_NativeRNFBTurbo* but lacks _Spec: must not be wrapped. */
+static NSString *const kNotASpecSelector = @"JS_NativeRNFBTurboFunctions_NotASpecMethod:";
+static NSString *const kUnrelatedSelector = @"unrelatedConverter:";
+static NSString *const kCxxConvertSpecSelector = @"JS_NativeRNFBTurboApp_SpecData:";
+static NSString *const kCxxConvertClassName = @"RCTCxxConvert";
+
+@interface RNFBNullSentinelInterceptorTests : XCTestCase
+@end
+
+/**
+ * Each test that needs a class builds its own uniquely named one at runtime and disposes of it in
+ * tearDown, so no test observes IMP wrapping or a global RCTCxxConvert registered by another test.
+ * That makes the suite independent of XCTest execution order and safe to run singly.
+ */
+@implementation RNFBNullSentinelInterceptorTests {
+  // Class pointers are stored as NSValue so ARC never retains/releases a class after disposal.
+  // Per-test stand-ins: scheduled blocks may capture these, so tearDown spares them on a drain
+  // timeout.
+  NSMutableArray<NSValue *> *_standInClasses;
+  // Fake global RCTCxxConvert: nothing queued captures it, so tearDown always disposes it.
+  NSMutableArray<NSValue *> *_globalClasses;
+  // Class pointer -> the IMPs of the block-backed methods this test added to it.
+  NSMutableDictionary<NSValue *, NSArray<NSValue *> *> *_originalIMPsByClass;
+  // Heap-allocated dispatch_once_t storage (see -newOnceToken), freed in tearDown.
+  NSMutableArray<NSValue *> *_onceTokens;
+}
+
+- (void)setUp {
+  [super setUp];
+  gLastJsonSeenByOriginalIMP = nil;
+  _standInClasses = [NSMutableArray array];
+  _globalClasses = [NSMutableArray array];
+  _originalIMPsByClass = [NSMutableDictionary dictionary];
+  _onceTokens = [NSMutableArray array];
+}
+
+- (void)tearDown {
+  // schedule...WithOnceToken: dispatches a block to the main queue that captures the once token
+  // pointer and the stand-in class. Drain the main queue (FIFO, so every block queued by the test
+  // has run once the drain block does) before disposing those or freeing the token. If the drain
+  // times out, leak them instead of risking a use-after-free in a late block. The global
+  // RCTCxxConvert is never captured by a queued block, so it is always disposed; otherwise a
+  // leaked registration would fail every later RCTCxxConvert test.
+  BOOL drained = [self drainMainQueue];
+  [self disposeClasses:_globalClasses];
+  if (drained) {
+    [self disposeClasses:_standInClasses];
+    for (NSValue *tokenValue in _onceTokens) {
+      free(tokenValue.pointerValue);
+    }
+  }
+  [_standInClasses removeAllObjects];
+  [_globalClasses removeAllObjects];
+  [_originalIMPsByClass removeAllObjects];
+  [_onceTokens removeAllObjects];
+  gLastJsonSeenByOriginalIMP = nil;
+  [super tearDown];
+}
+
+/**
+ * Disposes of the given classes and removes their block-backed IMPs. Each block IMP must be
+ * removed exactly once (a second imp_removeBlock crashes), so gather the unique set per class: the
+ * original stand-in IMPs plus any wrapper IMPs the interceptor swizzled in.
+ */
+- (void)disposeClasses:(NSArray<NSValue *> *)classValues {
+  for (NSValue *classValue in classValues) {
+    __unsafe_unretained Class cls = (__bridge Class)classValue.pointerValue;
+    NSMutableSet<NSValue *> *blockIMPs =
+        [NSMutableSet setWithArray:_originalIMPsByClass[classValue] ?: @[]];
+    unsigned int count = 0;
+    Method *methods = class_copyMethodList(object_getClass(cls), &count);
+    for (unsigned int i = 0; i < count; i++) {
+      [blockIMPs
+          addObject:[NSValue valueWithPointer:(const void *)method_getImplementation(methods[i])]];
+    }
+    free(methods);
+    objc_disposeClassPair(cls);
+    for (NSValue *value in blockIMPs) {
+      imp_removeBlock((IMP)value.pointerValue);
+    }
+  }
+}
+
+/**
+ * Creates and registers a class named `name` whose class methods (one per selector name) record
+ * the received json in gLastJsonSeenByOriginalIMP and return it. Disposed in tearDown. `global`
+ * marks a class registered under a well-known global name (RCTCxxConvert).
+ */
+- (Class)registerClassNamed:(NSString *)name
+              selectorNames:(NSArray<NSString *> *)selectorNames
+                     global:(BOOL)global {
+  Class cls = objc_allocateClassPair([NSObject class], name.UTF8String, 0);
+  XCTAssertTrue(cls != Nil, @"could not allocate class %@", name);
+  if (cls == Nil) {
+    return Nil;
+  }
+  Class meta = object_getClass(cls);
+  NSMutableArray<NSValue *> *imps = [NSMutableArray array];
+  for (NSString *selectorName in selectorNames) {
+    IMP imp = imp_implementationWithBlock(^id(__unused id receiver, id json) {
+      gLastJsonSeenByOriginalIMP = json;
+      return json;
+    });
+    BOOL added = class_addMethod(meta, NSSelectorFromString(selectorName), imp, "@@:@");
+    XCTAssertTrue(added, @"could not add class method %@ to %@", selectorName, name);
+    [imps addObject:[NSValue valueWithPointer:(const void *)imp]];
+  }
+  objc_registerClassPair(cls);
+  NSValue *classValue = [NSValue valueWithPointer:(__bridge const void *)cls];
+  _originalIMPsByClass[classValue] = imps;
+  [global ? _globalClasses : _standInClasses addObject:classValue];
+  return cls;
+}
+
+/** Stand-in for RCTCxxConvert codegen categories, uniquely named per call. */
+- (Class)makeStandInConvertClass {
+  static NSUInteger counter = 0;  // XCTest runs test methods serially on one thread.
+  NSString *name =
+      [NSString stringWithFormat:@"RNFBNullSentinelStandInConvert_%lu", (unsigned long)++counter];
+  return [self registerClassNamed:name
+                    selectorNames:@[ kSpecSelector, kNotASpecSelector, kUnrelatedSelector ]
+                           global:NO];
+}
+
+- (NSDictionary *)nullSentinel {
+  return @{@"__rnfbNull" : @YES};
+}
+
+- (NSDictionary *)unrelatedOneKeyDictionary {
+  return @{@".sv" : @"timestamp"};
+}
+
+- (IMP)classMethodIMP:(Class)cls selector:(SEL)selector {
+  Method method = class_getClassMethod(cls, selector);
+  XCTAssertTrue(method != NULL, @"missing class method %@", NSStringFromSelector(selector));
+  return method_getImplementation(method);
+}
+
+/** Invokes the class method's current IMP, so swizzled wrappers are exercised. */
+- (id)callConvert:(Class)cls selectorName:(NSString *)selectorName json:(id)json {
+  typedef id (*ConvertFunc)(id, SEL, id);
+  SEL selector = NSSelectorFromString(selectorName);
+  ConvertFunc convert = (ConvertFunc)[self classMethodIMP:cls selector:selector];
+  return convert(cls, selector, json);
+}
+
+/**
+ * Heap-allocated once token. A stack token would dangle if a dispatched block ran after the test
+ * method returned. Freed in tearDown, after the main queue is drained.
+ */
+- (dispatch_once_t *)newOnceToken {
+  dispatch_once_t *token = calloc(1, sizeof(dispatch_once_t));
+  [_onceTokens addObject:[NSValue valueWithPointer:token]];
+  return token;
+}
+
+/** Returns YES once every main-queue block queued before this call has run. */
+- (BOOL)drainMainQueue {
+  XCTestExpectation *drained = [self expectationWithDescription:@"main queue drained"];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [drained fulfill];
+  });
+  XCTWaiterResult result = [XCTWaiter waitForExpectations:@[ drained ] timeout:2.0];
+  XCTAssertEqual(result, XCTWaiterResultCompleted, @"main queue did not drain in time");
+  return result == XCTWaiterResultCompleted;
+}
+
+- (void)testSwizzleTurboModuleConversions_nullSentinel_handsNSNullToOriginalIMP {
+  Class standIn = [self makeStandInConvertClass];
+  SEL selector = NSSelectorFromString(kSpecSelector);
+  IMP before = [self classMethodIMP:standIn selector:selector];
+
+  [RNFBNullSentinelInterceptor swizzleTurboModuleConversions:standIn];
+
+  IMP after = [self classMethodIMP:standIn selector:selector];
+  XCTAssertNotEqual(before, after);
+
+  gLastJsonSeenByOriginalIMP = nil;
+  id result = [self callConvert:standIn selectorName:kSpecSelector json:[self nullSentinel]];
+  XCTAssertEqualObjects(gLastJsonSeenByOriginalIMP, [NSNull null]);
+  XCTAssertEqualObjects(result, [NSNull null]);
+}
+
+- (void)testSwizzleTurboModuleConversions_unrelatedOneKeyDictionary_unchanged {
+  Class standIn = [self makeStandInConvertClass];
+  [RNFBNullSentinelInterceptor swizzleTurboModuleConversions:standIn];
+
+  gLastJsonSeenByOriginalIMP = nil;
+  NSDictionary *payload = [self unrelatedOneKeyDictionary];
+  id result = [self callConvert:standIn selectorName:kSpecSelector json:payload];
+
+  XCTAssertEqualObjects(gLastJsonSeenByOriginalIMP, payload);
+  XCTAssertEqualObjects(result, payload);
+}
+
+- (void)testScheduleSwizzle_doesNotSwizzleUntilMainQueueRuns {
+  Class standIn = [self makeStandInConvertClass];
+  SEL selector = NSSelectorFromString(kSpecSelector);
+  IMP before = [self classMethodIMP:standIn selector:selector];
+
+  dispatch_once_t *onceToken = [self newOnceToken];
+  [RNFBNullSentinelInterceptor scheduleSwizzleOnMainQueueWithOnceToken:onceToken
+                                                     turboConvertClass:standIn];
+
+  IMP afterSchedule = [self classMethodIMP:standIn selector:selector];
+  XCTAssertEqual(before, afterSchedule, @"swizzle must not run synchronously from schedule");
+
+  [self drainMainQueue];
+
+  IMP afterDrain = [self classMethodIMP:standIn selector:selector];
+  XCTAssertNotEqual(before, afterDrain, @"swizzle must run once the main queue drains");
+
+  gLastJsonSeenByOriginalIMP = nil;
+  [self callConvert:standIn selectorName:kSpecSelector json:[self nullSentinel]];
+  XCTAssertEqualObjects(gLastJsonSeenByOriginalIMP, [NSNull null]);
+}
+
+- (void)testScheduleSwizzle_secondCallDoesNotDoubleWrap {
+  Class standIn = [self makeStandInConvertClass];
+  SEL selector = NSSelectorFromString(kSpecSelector);
+
+  dispatch_once_t *onceToken = [self newOnceToken];
+  [RNFBNullSentinelInterceptor scheduleSwizzleOnMainQueueWithOnceToken:onceToken
+                                                     turboConvertClass:standIn];
+  [self drainMainQueue];
+  IMP afterFirst = [self classMethodIMP:standIn selector:selector];
+
+  [RNFBNullSentinelInterceptor scheduleSwizzleOnMainQueueWithOnceToken:onceToken
+                                                     turboConvertClass:standIn];
+  [self drainMainQueue];
+  IMP afterSecond = [self classMethodIMP:standIn selector:selector];
+
+  XCTAssertEqual(afterFirst, afterSecond, @"dispatch_once must prevent a second IMP wrap");
+}
+
+// Nil arm of `if (cxxConvertClass)`.
+// Precondition: the unit host has no React runtime (RNFBAppUnitTests.xcodeproj links no React), so
+// RCTCxxConvert is absent. The original missing-case test made the same assumption. The only test
+// that registers a global RCTCxxConvert (the "present" test) disposes of it in tearDown, so the
+// class is also absent here regardless of which test ran first.
+- (void)testSwizzleRCTConvertMethods_missingRCTCxxConvert_isNoOp {
+  XCTAssertNil(NSClassFromString(kCxxConvertClassName));
+  XCTAssertNoThrow([RNFBNullSentinelInterceptor swizzleRCTConvertMethods]);
+}
+
+// Non-nil arm of `if (cxxConvertClass)`. Registers a global RCTCxxConvert stand-in (disposed in
+// tearDown). Same no-React-in-the-host precondition as the missing-class test above.
+- (void)testSwizzleRCTConvertMethods_whenRCTCxxConvertPresent_swizzlesSpecMethods {
+  XCTAssertNil(NSClassFromString(kCxxConvertClassName),
+               @"no RCTCxxConvert may exist before this test registers its stand-in");
+  Class convertClass = [self registerClassNamed:kCxxConvertClassName
+                                  selectorNames:@[ kCxxConvertSpecSelector ]
+                                         global:YES];
+  XCTAssertNotNil(convertClass);
+  if (convertClass == Nil) {
+    return;
+  }
+
+  SEL selector = NSSelectorFromString(kCxxConvertSpecSelector);
+  IMP before = [self classMethodIMP:convertClass selector:selector];
+  [RNFBNullSentinelInterceptor swizzleRCTConvertMethods];
+  IMP after = [self classMethodIMP:convertClass selector:selector];
+  XCTAssertNotEqual(before, after);
+
+  gLastJsonSeenByOriginalIMP = nil;
+  id result = [self callConvert:convertClass
+                   selectorName:kCxxConvertSpecSelector
+                           json:[self nullSentinel]];
+  XCTAssertEqualObjects(gLastJsonSeenByOriginalIMP, [NSNull null]);
+  XCTAssertEqualObjects(result, [NSNull null]);
+}
+
+- (void)testSwizzleTurboModuleConversions_prefixWithoutSpec_leavesIMPUnchanged {
+  Class standIn = [self makeStandInConvertClass];
+  SEL notASpec = NSSelectorFromString(kNotASpecSelector);
+  SEL unrelated = NSSelectorFromString(kUnrelatedSelector);
+  IMP notASpecBefore = [self classMethodIMP:standIn selector:notASpec];
+  IMP unrelatedBefore = [self classMethodIMP:standIn selector:unrelated];
+
+  [RNFBNullSentinelInterceptor swizzleTurboModuleConversions:standIn];
+
+  XCTAssertEqual(notASpecBefore, [self classMethodIMP:standIn selector:notASpec]);
+  XCTAssertEqual(unrelatedBefore, [self classMethodIMP:standIn selector:unrelated]);
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBPreferencesStorageTests.swift

@@ -0,0 +1,105 @@
+/**
+ * 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 RNFBPreferencesStorageTests: XCTestCase {
+  private var domainIdentifier: String!
+  private var userDefaults: UserDefaults!
+  private var storage: RNFBPreferencesStorage!
+
+  override func setUp() {
+    super.setUp()
+    domainIdentifier = "io.invertase.firebase.tests.\(UUID().uuidString)"
+    userDefaults = UserDefaults(suiteName: domainIdentifier)
+    userDefaults.removePersistentDomain(forName: domainIdentifier)
+    storage = RNFBPreferencesStorage(
+      userDefaults: userDefaults,
+      domainIdentifier: domainIdentifier
+    )
+  }
+
+  override func tearDown() {
+    userDefaults.removePersistentDomain(forName: domainIdentifier)
+    storage = nil
+    userDefaults = nil
+    domainIdentifier = nil
+    super.tearDown()
+  }
+
+  func testMissingKeysUseDefaultsAndAreNotContained() {
+    XCTAssertFalse(storage.contains("missing"))
+    XCTAssertTrue(storage.getBooleanValue("missing", defaultValue: true))
+    XCTAssertEqual(storage.getIntegerValue("missing", defaultValue: Int.max), Int.max)
+    XCTAssertEqual(storage.getStringValue("missing", defaultValue: "fallback"), "fallback")
+  }
+
+  func testSettersAndGettersPreserveValuesAndDictionaryRepresentation() {
+    storage.setBooleanValue("bool", boolValue: true)
+    storage.setIntegerValue("integer", integerValue: Int.max)
+    storage.setStringValue("string", stringValue: "value")
+
+    XCTAssertTrue(storage.contains("bool"))
+    XCTAssertTrue(storage.getBooleanValue("bool", defaultValue: false))
+    XCTAssertEqual(storage.getIntegerValue("integer", defaultValue: 0), Int.max)
+    XCTAssertEqual(storage.getStringValue("string", defaultValue: "fallback"), "value")
+
+    let all = storage.getAll()
+    XCTAssertEqual(all["bool"] as? Bool, true)
+    XCTAssertEqual(all["integer"] as? Int, Int.max)
+    XCTAssertEqual(all["string"] as? String, "value")
+  }
+
+  func testStringForPresentNonStringValueMatchesNSUserDefaults() {
+    userDefaults.set(["value"], forKey: "notString")
+
+    XCTAssertTrue(storage.contains("notString"))
+    XCTAssertNil(storage.getStringValue("notString", defaultValue: "fallback"))
+  }
+
+  func testRemoveAndClearAllUseTheConfiguredPersistentDomain() {
+    storage.setStringValue("first", stringValue: "one")
+    storage.setStringValue("second", stringValue: "two")
+
+    storage.remove("first")
+    XCTAssertFalse(storage.contains("first"))
+    XCTAssertTrue(storage.contains("second"))
+
+    storage.clearAll()
+    XCTAssertFalse(storage.contains("second"))
+    let clearedDomain = userDefaults.persistentDomain(forName: domainIdentifier)
+    XCTAssertTrue(
+      clearedDomain == nil || clearedDomain?.isEmpty == true,
+      "clearAll must leave the persistent domain nil or empty; got \(String(describing: clearedDomain))"
+    )
+  }
+
+  func testDefaultInitializerUsesRNFBPreferencesSuite() {
+    let suiteName = "io.invertase.firebase"
+    let productionDefaults = UserDefaults(suiteName: suiteName)!
+    let key = "RNFBPreferencesStorageTests.\(UUID().uuidString)"
+    productionDefaults.removeObject(forKey: key)
+    defer {
+      productionDefaults.removeObject(forKey: key)
+    }
+
+    let productionStorage = RNFBPreferencesStorage()
+    productionStorage.setStringValue(key, stringValue: "suite-value")
+
+    XCTAssertEqual(productionDefaults.string(forKey: key), "suite-value")
+  }
+}

package/ios/RNFBAppUnitTests/RNFBPreferencesTests.m

@@ -0,0 +1,110 @@
+/**
+ * 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"
+#import "RNFBPreferences.h"
+
+@interface RNFBPreferencesTests : XCTestCase
+@property(nonatomic, strong) NSString *domainIdentifier;
+@property(nonatomic, strong) NSUserDefaults *userDefaults;
+@property(nonatomic, strong) RNFBPreferences *preferences;
+@end
+
+@implementation RNFBPreferencesTests
+
+- (void)setUp {
+  [super setUp];
+  self.domainIdentifier =
+      [@"io.invertase.firebase.tests." stringByAppendingString:NSUUID.UUID.UUIDString];
+  self.userDefaults = [[NSUserDefaults alloc] initWithSuiteName:self.domainIdentifier];
+  [self.userDefaults removePersistentDomainForName:self.domainIdentifier];
+  RNFBPreferencesStorage *storage =
+      [[RNFBPreferencesStorage alloc] initWithUserDefaults:self.userDefaults
+                                          domainIdentifier:self.domainIdentifier];
+  self.preferences = [[RNFBPreferences alloc] init];
+  [self.preferences setValue:storage forKey:@"storage"];
+}
+
+- (void)tearDown {
+  [self.userDefaults removePersistentDomainForName:self.domainIdentifier];
+  self.preferences = nil;
+  self.userDefaults = nil;
+  self.domainIdentifier = nil;
+  [super tearDown];
+}
+
+- (void)testSharedIsAvailableAndStable {
+  XCTAssertNotNil(RNFBPreferences.shared);
+  XCTAssertIdentical(RNFBPreferences.shared, RNFBPreferences.shared);
+}
+
+- (void)testPublicSelectorsAndIntegerWidthsAreUnchanged {
+  NSArray<NSString *> *selectorNames = @[
+    @"contains:",
+    @"getBooleanValue:defaultValue:",
+    @"setBooleanValue:boolValue:",
+    @"setIntegerValue:integerValue:",
+    @"setStringValue:stringValue:",
+    @"getStringValue:defaultValue:",
+    @"getIntegerValue:defaultValue:",
+    @"getAll",
+    @"clearAll",
+    @"remove:",
+  ];
+  for (NSString *selectorName in selectorNames) {
+    XCTAssertTrue([self.preferences respondsToSelector:NSSelectorFromString(selectorName)]);
+  }
+
+  NSMethodSignature *setter =
+      [RNFBPreferences instanceMethodSignatureForSelector:@selector(setIntegerValue:integerValue:)];
+  XCTAssertEqual(strcmp([setter getArgumentTypeAtIndex:3], @encode(NSInteger)), 0);
+
+  NSMethodSignature *getter =
+      [RNFBPreferences instanceMethodSignatureForSelector:@selector(getIntegerValue:defaultValue:)];
+  XCTAssertEqual(strcmp(getter.methodReturnType, @encode(NSInteger)), 0);
+  XCTAssertEqual(strcmp([getter getArgumentTypeAtIndex:3], @encode(NSInteger)), 0);
+}
+
+- (void)testFacadeForwardsEveryPreferenceOperation {
+  XCTAssertFalse([self.preferences contains:@"missing"]);
+  XCTAssertTrue([self.preferences getBooleanValue:@"missing" defaultValue:YES]);
+  XCTAssertEqual([self.preferences getIntegerValue:@"missing" defaultValue:NSIntegerMax],
+                 NSIntegerMax);
+  XCTAssertEqualObjects([self.preferences getStringValue:@"missing" defaultValue:@"fallback"],
+                        @"fallback");
+
+  [self.preferences setBooleanValue:@"bool" boolValue:YES];
+  [self.preferences setIntegerValue:@"integer" integerValue:NSIntegerMax];
+  [self.preferences setStringValue:@"string" stringValue:@"value"];
+
+  XCTAssertTrue([self.preferences contains:@"bool"]);
+  XCTAssertTrue([self.preferences getBooleanValue:@"bool" defaultValue:NO]);
+  XCTAssertEqual([self.preferences getIntegerValue:@"integer" defaultValue:0], NSIntegerMax);
+  XCTAssertEqualObjects([self.preferences getStringValue:@"string" defaultValue:@"fallback"],
+                        @"value");
+  XCTAssertEqualObjects([self.preferences getAll][@"string"], @"value");
+
+  [self.preferences remove:@"bool"];
+  XCTAssertFalse([self.preferences contains:@"bool"]);
+
+  [self.preferences clearAll];
+  XCTAssertFalse([self.preferences contains:@"integer"]);
+  XCTAssertFalse([self.preferences contains:@"string"]);
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBRCTEventEmitterCoreTests.swift

@@ -0,0 +1,163 @@
+/**
+ * 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 RNFBRCTEventEmitterCoreTests: XCTestCase {
+  private var bridgePresent = false
+  private var emitted: [(String, Any?)] = []
+  private var core: RNFBRCTEventEmitterCore!
+
+  override func setUp() {
+    super.setUp()
+    bridgePresent = false
+    emitted = []
+    core = RNFBRCTEventEmitterCore(
+      isBridgePresent: { [unowned self] in self.bridgePresent },
+      emitHandler: { [unowned self] name, body in
+        self.emitted.append((name, body))
+      }
+    )
+  }
+
+  override func tearDown() {
+    core = nil
+    super.tearDown()
+  }
+
+  func testInvalidateResetsState() {
+    core.sendEvent(name: "a", body: ["x": 1])
+    core.addListener("a")
+    core.notifyJsReady(true)
+
+    core.invalidate()
+
+    let dict = core.getListenersDictionary()
+    XCTAssertEqual(dict["listeners"] as? Int, 0)
+    XCTAssertEqual(dict["queued"] as? Int, 0)
+    XCTAssertEqual((dict["events"] as? NSDictionary)?.count, 0)
+  }
+
+  func testSendEventQueuesWhenNotReadyToEmit() {
+    core.sendEvent(name: "evt", body: ["k": "v"])
+
+    let dict = core.getListenersDictionary()
+    XCTAssertEqual(dict["queued"] as? Int, 1)
+    XCTAssertTrue(emitted.isEmpty)
+  }
+
+  func testSendEventEmitsWhenBridgeObservingAndRegistered() {
+    bridgePresent = true
+    core.notifyJsReady(true)
+    core.addListener("evt")
+    emitted = []
+
+    core.sendEvent(name: "evt", body: ["k": "v"])
+
+    XCTAssertEqual(emitted.count, 1)
+    XCTAssertEqual(emitted[0].0, "evt")
+    XCTAssertEqual((emitted[0].1 as? NSDictionary)?["k"] as? String, "v")
+    XCTAssertEqual(core.getListenersDictionary()["queued"] as? Int, 0)
+  }
+
+  func testNotifyJsReadyFlushesQueue() {
+    bridgePresent = true
+    core.addListener("evt")
+    core.sendEvent(name: "evt", body: ["k": 1])
+    emitted = []
+
+    core.notifyJsReady(true)
+
+    XCTAssertEqual(emitted.count, 1)
+    XCTAssertEqual(emitted[0].0, "evt")
+    XCTAssertEqual(core.getListenersDictionary()["queued"] as? Int, 0)
+  }
+
+  func testAddListenerFlushesMatchingQueuedEvents() {
+    bridgePresent = true
+    core.notifyJsReady(true)
+    core.sendEvent(name: "evt", body: ["k": 1])
+    core.sendEvent(name: "other", body: ["k": 2])
+    emitted = []
+
+    core.addListener("evt")
+
+    XCTAssertEqual(emitted.count, 1)
+    XCTAssertEqual(emitted[0].0, "evt")
+    XCTAssertEqual(core.getListenersDictionary()["queued"] as? Int, 1)
+  }
+
+  func testAddListenerIncrementsCounts() {
+    core.addListener("evt")
+    core.addListener("evt")
+
+    let dict = core.getListenersDictionary()
+    XCTAssertEqual(dict["listeners"] as? Int, 2)
+    XCTAssertEqual((dict["events"] as? NSDictionary)?["evt"] as? Int, 2)
+  }
+
+  func testRemoveListenersDecrementsAndRemoves() {
+    core.addListener("evt")
+    core.addListener("evt")
+
+    core.removeListeners("evt", all: false)
+    XCTAssertEqual((core.getListenersDictionary()["events"] as? NSDictionary)?["evt"] as? Int, 1)
+    XCTAssertEqual(core.getListenersDictionary()["listeners"] as? Int, 1)
+
+    core.removeListeners("evt", all: false)
+    XCTAssertNil((core.getListenersDictionary()["events"] as? NSDictionary)?["evt"])
+    XCTAssertEqual(core.getListenersDictionary()["listeners"] as? Int, 0)
+  }
+
+  func testRemoveListenersAllRemovesEntireCount() {
+    core.addListener("evt")
+    core.addListener("evt")
+    core.addListener("evt")
+
+    core.removeListeners("evt", all: true)
+
+    XCTAssertNil((core.getListenersDictionary()["events"] as? NSDictionary)?["evt"])
+    XCTAssertEqual(core.getListenersDictionary()["listeners"] as? Int, 0)
+  }
+
+  func testRemoveListenersNoOpWhenMissing() {
+    core.removeListeners("missing", all: true)
+    XCTAssertEqual(core.getListenersDictionary()["listeners"] as? Int, 0)
+  }
+
+  func testSendEventWithNilBodyWhenEmitting() {
+    bridgePresent = true
+    core.notifyJsReady(true)
+    core.addListener("evt")
+    emitted = []
+
+    core.sendEvent(name: "evt", body: nil)
+
+    XCTAssertEqual(emitted.count, 1)
+    XCTAssertEqual(emitted[0].0, "evt")
+    XCTAssertNil(emitted[0].1)
+  }
+
+  func testIsObservingRequiresJsReady() {
+    bridgePresent = true
+    core.addListener("evt")
+    core.sendEvent(name: "evt", body: ["k": 1])
+
+    XCTAssertTrue(emitted.isEmpty)
+    XCTAssertEqual(core.getListenersDictionary()["queued"] as? Int, 1)
+  }
+}