@react-native-firebase/crashlytics 26.4.0 → 27.1.0

package/ios/RNFBCrashlyticsUnitTests/HostStubs/Firebase/FIRCrashlyticsHostStub.m

@@ -0,0 +1,273 @@
+/**
+ * Host-only stub for macOS XCTest. Not shipped in the production pod.
+ */
+#import <Firebase/Firebase.h>
+#import <stdatomic.h>
+
+@implementation FIRStackFrame {
+  NSString *_symbol;
+  NSString *_file;
+  uint32_t _line;
+}
+
++ (instancetype)stackFrameWithSymbol:(NSString *)symbol file:(NSString *)file line:(uint32_t)line {
+  FIRStackFrame *frame = [[FIRStackFrame alloc] init];
+  frame->_symbol = [symbol copy];
+  frame->_file = [file copy];
+  frame->_line = line;
+  return frame;
+}
+
+- (NSString *)symbol {
+  return _symbol;
+}
+
+- (NSString *)file {
+  return _file;
+}
+
+- (uint32_t)line {
+  return _line;
+}
+
+@end
+
+@implementation FIRExceptionModel {
+  NSString *_name;
+  NSString *_reason;
+}
+
++ (instancetype)exceptionModelWithName:(NSString *)name reason:(NSString *)reason {
+  FIRExceptionModel *model = [[FIRExceptionModel alloc] init];
+  model->_name = [name copy];
+  model->_reason = [reason copy];
+  return model;
+}
+
+- (NSString *)name {
+  return _name;
+}
+
+- (NSString *)reason {
+  return _reason;
+}
+
+@end
+
+@implementation FIRCrashlytics
+
+static BOOL sDidCrashDuringPreviousExecutionValue;
+static BOOL sCheckForUnsentReportsValue;
+static NSMutableArray<NSString *> *sLoggedMessages;
+static NSMutableDictionary *sCustomValues;
+static NSString *sUserIDValue;
+static NSUInteger sDeleteUnsentReportsCallCount;
+static NSUInteger sSendUnsentReportsCallCount;
+static FIRExceptionModel *sLastRecordedExceptionModel;
+static NSMutableArray<FIRExceptionModel *> *sSavedExceptionModels;
+static void (^sOnExceptionModelSaved)(FIRExceptionModel *);
+static BOOL sContextInitPending;
+static NSMutableArray<dispatch_block_t> *sPendingSaves;
+// Bumped by resetTestState so saves enqueued by an earlier test are dropped.
+static atomic_uint_fast64_t sSaveGeneration;
+
++ (void)initialize {
+  if (self == [FIRCrashlytics class]) {
+    sLoggedMessages = [NSMutableArray new];
+    sCustomValues = [NSMutableDictionary new];
+    sSavedExceptionModels = [NSMutableArray new];
+    sPendingSaves = [NSMutableArray new];
+  }
+}
+
++ (instancetype)crashlytics {
+  static FIRCrashlytics *shared;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    shared = [[FIRCrashlytics alloc] init];
+  });
+  return shared;
+}
+
++ (BOOL)didCrashDuringPreviousExecutionValue {
+  return sDidCrashDuringPreviousExecutionValue;
+}
+
++ (void)setDidCrashDuringPreviousExecutionValue:(BOOL)didCrashDuringPreviousExecutionValue {
+  sDidCrashDuringPreviousExecutionValue = didCrashDuringPreviousExecutionValue;
+}
+
++ (BOOL)checkForUnsentReportsValue {
+  return sCheckForUnsentReportsValue;
+}
+
++ (void)setCheckForUnsentReportsValue:(BOOL)checkForUnsentReportsValue {
+  sCheckForUnsentReportsValue = checkForUnsentReportsValue;
+}
+
++ (NSArray<NSString *> *)loggedMessages {
+  return [sLoggedMessages copy];
+}
+
++ (void)setLoggedMessages:(NSArray<NSString *> *)loggedMessages {
+  [sLoggedMessages removeAllObjects];
+  if (loggedMessages != nil) {
+    [sLoggedMessages addObjectsFromArray:loggedMessages];
+  }
+}
+
++ (NSDictionary *)customValues {
+  return [sCustomValues copy];
+}
+
++ (void)setCustomValues:(NSDictionary *)customValues {
+  [sCustomValues removeAllObjects];
+  if (customValues != nil) {
+    [sCustomValues addEntriesFromDictionary:customValues];
+  }
+}
+
++ (NSString *)userIDValue {
+  return sUserIDValue;
+}
+
++ (void)setUserIDValue:(NSString *)userIDValue {
+  sUserIDValue = [userIDValue copy];
+}
+
++ (NSUInteger)deleteUnsentReportsCallCount {
+  return sDeleteUnsentReportsCallCount;
+}
+
++ (void)setDeleteUnsentReportsCallCount:(NSUInteger)deleteUnsentReportsCallCount {
+  sDeleteUnsentReportsCallCount = deleteUnsentReportsCallCount;
+}
+
++ (NSUInteger)sendUnsentReportsCallCount {
+  return sSendUnsentReportsCallCount;
+}
+
++ (void)setSendUnsentReportsCallCount:(NSUInteger)sendUnsentReportsCallCount {
+  sSendUnsentReportsCallCount = sendUnsentReportsCallCount;
+}
+
++ (FIRExceptionModel *)lastRecordedExceptionModel {
+  return sLastRecordedExceptionModel;
+}
+
++ (void)setLastRecordedExceptionModel:(FIRExceptionModel *)lastRecordedExceptionModel {
+  sLastRecordedExceptionModel = lastRecordedExceptionModel;
+}
+
++ (NSArray<FIRExceptionModel *> *)savedExceptionModels {
+  return [sSavedExceptionModels copy];
+}
+
++ (void (^)(FIRExceptionModel *))onExceptionModelSaved {
+  return sOnExceptionModelSaved;
+}
+
++ (void)setOnExceptionModelSaved:(void (^)(FIRExceptionModel *))onExceptionModelSaved {
+  sOnExceptionModelSaved = [onExceptionModelSaved copy];
+}
+
++ (void)holdContextInit {
+  @synchronized(sPendingSaves) {
+    sContextInitPending = YES;
+  }
+}
+
++ (void)fulfillContextInit {
+  NSArray<dispatch_block_t> *saves;
+  @synchronized(sPendingSaves) {
+    sContextInitPending = NO;
+    saves = [sPendingSaves copy];
+    [sPendingSaves removeAllObjects];
+  }
+  for (dispatch_block_t save in saves) {
+    dispatch_async(dispatch_get_main_queue(), save);
+  }
+}
+
++ (void)resetTestState {
+  sDidCrashDuringPreviousExecutionValue = NO;
+  sCheckForUnsentReportsValue = NO;
+  [sLoggedMessages removeAllObjects];
+  [sCustomValues removeAllObjects];
+  sUserIDValue = nil;
+  sDeleteUnsentReportsCallCount = 0;
+  sSendUnsentReportsCallCount = 0;
+  sLastRecordedExceptionModel = nil;
+  [sSavedExceptionModels removeAllObjects];
+  sOnExceptionModelSaved = nil;
+  @synchronized(sPendingSaves) {
+    sContextInitPending = NO;
+    [sPendingSaves removeAllObjects];
+  }
+  atomic_fetch_add(&sSaveGeneration, 1);
+}
+
+- (void)checkForUnsentReportsWithCompletion:(void (^)(BOOL unsentReports))completion {
+  if (completion != nil) {
+    completion(sCheckForUnsentReportsValue);
+  }
+}
+
+- (void)deleteUnsentReports {
+  sDeleteUnsentReportsCallCount += 1;
+}
+
+- (BOOL)didCrashDuringPreviousExecution {
+  return sDidCrashDuringPreviousExecutionValue;
+}
+
+- (void)log:(NSString *)message {
+  if (message != nil) {
+    [sLoggedMessages addObject:message];
+  }
+}
+
+- (void)sendUnsentReports {
+  sSendUnsentReportsCallCount += 1;
+}
+
+- (void)setCustomValue:(id)value forKey:(NSString *)key {
+  if (key == nil) {
+    return;
+  }
+  if (value == nil) {
+    [sCustomValues removeObjectForKey:key];
+  } else {
+    sCustomValues[key] = value;
+  }
+}
+
+- (void)setUserID:(NSString *)userID {
+  sUserIDValue = [userID copy];
+}
+
+- (void)recordExceptionModel:(FIRExceptionModel *)exceptionModel {
+  sLastRecordedExceptionModel = exceptionModel;
+  // Mirrors FirebaseCrashlytics: once context init is fulfilled, the save block is dispatched to
+  // the main queue and writes synchronously when it runs. While init is pending, FBLPromise holds
+  // the block as an observer and dispatches it to the main queue only when the promise fulfills.
+  uint_fast64_t generation = atomic_load(&sSaveGeneration);
+  dispatch_block_t save = ^{
+    if (generation != atomic_load(&sSaveGeneration)) {
+      return;
+    }
+    [sSavedExceptionModels addObject:exceptionModel];
+    if (sOnExceptionModelSaved != nil) {
+      sOnExceptionModelSaved(exceptionModel);
+    }
+  };
+  @synchronized(sPendingSaves) {
+    if (sContextInitPending) {
+      [sPendingSaves addObject:save];
+      return;
+    }
+  }
+  dispatch_async(dispatch_get_main_queue(), save);
+}
+
+@end

package/ios/RNFBCrashlyticsUnitTests/HostStubs/Firebase/Firebase.h

@@ -0,0 +1,56 @@
+/**
+ * Host-only stub for macOS XCTest. Not shipped in the production pod.
+ * Enough of Firebase Crashlytics for compiling RNFBCrashlyticsHelper.m
+ * and asserting SDK call wiring without linking the real SDK.
+ */
+#import <Foundation/Foundation.h>
+
+@interface FIRStackFrame : NSObject
+@property(nonatomic, readonly, copy) NSString *symbol;
+@property(nonatomic, readonly, copy) NSString *file;
+@property(nonatomic, readonly, assign) uint32_t line;
++ (instancetype)stackFrameWithSymbol:(NSString *)symbol file:(NSString *)file line:(uint32_t)line;
+@end
+
+@interface FIRExceptionModel : NSObject
+@property(nonatomic, readonly, copy) NSString *name;
+@property(nonatomic, readonly, copy) NSString *reason;
+@property(nonatomic, copy, nullable) NSArray<FIRStackFrame *> *stackTrace;
++ (instancetype)exceptionModelWithName:(NSString *)name reason:(NSString *)reason;
+@end
+
+@interface FIRCrashlytics : NSObject
+
++ (instancetype)crashlytics;
+
+- (void)checkForUnsentReportsWithCompletion:(void (^)(BOOL unsentReports))completion;
+- (void)deleteUnsentReports;
+- (BOOL)didCrashDuringPreviousExecution;
+- (void)log:(NSString *)message;
+- (void)sendUnsentReports;
+- (void)setCustomValue:(nullable id)value forKey:(NSString *)key;
+- (void)setUserID:(NSString *)userID;
+- (void)recordExceptionModel:(FIRExceptionModel *)exceptionModel;
+
+/** Test seams */
+@property(class, nonatomic, assign) BOOL didCrashDuringPreviousExecutionValue;
+@property(class, nonatomic, assign) BOOL checkForUnsentReportsValue;
+@property(class, nonatomic, copy, nullable) NSArray<NSString *> *loggedMessages;
+@property(class, nonatomic, copy, nullable) NSDictionary *customValues;
+@property(class, nonatomic, copy, nullable) NSString *userIDValue;
+@property(class, nonatomic, assign) NSUInteger deleteUnsentReportsCallCount;
+@property(class, nonatomic, assign) NSUInteger sendUnsentReportsCallCount;
+@property(class, nonatomic, copy, nullable) FIRExceptionModel *lastRecordedExceptionModel;
+/** Models whose main-queue save block has run (see recordExceptionModel:). */
+@property(class, nonatomic, readonly, copy) NSArray<FIRExceptionModel *> *savedExceptionModels;
+/** Called on the main queue right after a save block runs. */
+@property(class, nonatomic, copy, nullable) void (^onExceptionModelSaved)(FIRExceptionModel *model);
+/** Holds later saves like observers of a pending context-init promise, until fulfillContextInit. */
++ (void)holdContextInit;
+
+/** Dispatches the held saves to the main queue and stops holding new ones. */
++ (void)fulfillContextInit;
+
++ (void)resetTestState;
+
+@end

package/ios/RNFBCrashlyticsUnitTests/RNFBCrashlyticsDebuggerProbeTests.swift

@@ -0,0 +1,112 @@
+/**
+ * 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 Darwin
+import XCTest
+
+final class RNFBCrashlyticsDebuggerProbeTests: XCTestCase {
+
+  override func setUp() {
+    super.setUp()
+    RNFBCrashlyticsDebuggerProbe.resetForTesting()
+  }
+
+  override func tearDown() {
+    RNFBCrashlyticsDebuggerProbe.resetForTesting()
+    super.tearDown()
+  }
+
+  /// Writes a `kinfo_proc` with the given `p_flag` and returns 0 (success).
+  private func successProbe(pFlag: Int32) -> RNFBCrashlyticsDebuggerProbe.SysctlProbe {
+    { name, namelen, oldp, oldlenp, _, _ in
+      XCTAssertEqual(namelen, 4)
+      XCTAssertEqual(name[0], CTL_KERN)
+      XCTAssertEqual(name[1], KERN_PROC)
+      XCTAssertEqual(name[2], KERN_PROC_PID)
+      XCTAssertEqual(name[3], getpid())
+      guard let oldp else {
+        return -1
+      }
+      var info = kinfo_proc()
+      info.kp_proc.p_flag = pFlag
+      oldp.assumingMemoryBound(to: kinfo_proc.self).pointee = info
+      oldlenp.pointee = MemoryLayout<kinfo_proc>.size
+      return 0
+    }
+  }
+
+  /// Returns -1 after setting `errno` (sysctl failure path).
+  private func failureProbe(errnoValue: Int32, pFlag: Int32 = 0) -> RNFBCrashlyticsDebuggerProbe
+    .SysctlProbe
+  {
+    { _, _, oldp, oldlenp, _, _ in
+      if let oldp {
+        var info = kinfo_proc()
+        info.kp_proc.p_flag = pFlag
+        oldp.assumingMemoryBound(to: kinfo_proc.self).pointee = info
+        oldlenp.pointee = MemoryLayout<kinfo_proc>.size
+      }
+      errno = errnoValue
+      return -1
+    }
+  }
+
+  func testPublicPath_liveSysctl_returnsBoolWithoutCrash() {
+    // Exercises default Darwin.sysctl + once-cache. Under LLDB this may be true;
+    // on a non-debugged CI host it is typically false — do not assert the value.
+    _ = RNFBCrashlyticsDebuggerProbe.isDebuggerAttached()
+    // Second call must hit the once-cache return path.
+    _ = RNFBCrashlyticsDebuggerProbe.isDebuggerAttached()
+  }
+
+  func testEvaluate_notTraced_returnsFalse() {
+    let result = RNFBCrashlyticsDebuggerProbe.evaluateUncachedForTesting(
+      using: successProbe(pFlag: 0))
+    XCTAssertFalse(result)
+  }
+
+  func testEvaluate_pTraced_returnsTrue() {
+    let result = RNFBCrashlyticsDebuggerProbe.evaluateUncachedForTesting(
+      using: successProbe(pFlag: P_TRACED))
+    XCTAssertTrue(result)
+  }
+
+  func testEvaluate_sysctlFailure_logsAndReturnsFalse() {
+    let result = RNFBCrashlyticsDebuggerProbe.evaluateUncachedForTesting(
+      using: failureProbe(errnoValue: EINVAL, pFlag: 0))
+    XCTAssertFalse(result)
+  }
+
+  func testEvaluate_sysctlFailureWithTracedBit_stillTrueMatchingPrePortFallthrough() {
+    // Pre-port control flow still inspects P_TRACED after a failed sysctl.
+    let result = RNFBCrashlyticsDebuggerProbe.evaluateUncachedForTesting(
+      using: failureProbe(errnoValue: EFAULT, pFlag: P_TRACED))
+    XCTAssertTrue(result)
+  }
+
+  func testOnceCache_secondCallSkipsProbe() {
+    var probeCount = 0
+    let counting: RNFBCrashlyticsDebuggerProbe.SysctlProbe = { name, namelen, oldp, oldlenp, newp,
+      newlen in
+      probeCount += 1
+      return self.successProbe(pFlag: 0)(name, namelen, oldp, oldlenp, newp, newlen)
+    }
+    RNFBCrashlyticsDebuggerProbe.sysctlImpl = counting
+    XCTAssertFalse(RNFBCrashlyticsDebuggerProbe.isDebuggerAttached())
+    XCTAssertFalse(RNFBCrashlyticsDebuggerProbe.isDebuggerAttached())
+    XCTAssertEqual(probeCount, 1)
+  }
+}

package/ios/RNFBCrashlyticsUnitTests/RNFBCrashlyticsFatalExitTests.m

@@ -0,0 +1,268 @@
+/**
+ * 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 <Firebase/Firebase.h>
+#import "RNFBCrashlyticsHelper.h"
+
+@interface RNFBCrashlyticsFatalExitTests : XCTestCase
+@end
+
+@implementation RNFBCrashlyticsFatalExitTests {
+  NSMutableArray<NSString *> *_events;
+}
+
+- (void)setUp {
+  [super setUp];
+  [FIRCrashlytics resetTestState];
+  _events = [NSMutableArray new];
+}
+
+- (void)tearDown {
+  [FIRCrashlytics resetTestState];
+  [super tearDown];
+}
+
+- (void)appendEvent:(NSString *)event {
+  @synchronized(_events) {
+    [_events addObject:event];
+  }
+}
+
+- (NSArray<NSString *> *)eventsSnapshot {
+  @synchronized(_events) {
+    return [_events copy];
+  }
+}
+
+- (void)recordFatal {
+  [RNFBCrashlyticsHelper recordJavaScriptErrorWithMessage:@"fatal"
+                                                   frames:@[]
+                              isUnhandledPromiseRejection:NO];
+}
+
+/** Lets late watchdog / queue blocks run so "at most once" assertions are meaningful. */
+- (void)drainFor:(NSTimeInterval)seconds {
+  XCTestExpectation *drained = [self expectationWithDescription:@"drained"];
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(seconds * NSEC_PER_SEC)),
+                 dispatch_get_main_queue(), ^{
+                   [drained fulfill];
+                 });
+  [self waitForExpectations:@[ drained ] timeout:seconds + 5];
+}
+
+/** Returns once every block already enqueued on serial `queue` has run (a happens-before edge). */
+- (void)drainQueue:(dispatch_queue_t)queue {
+  dispatch_block_t noop = ^{
+  };
+  dispatch_sync(queue, noop);
+}
+
+- (void)testShared_isProductionSingleton {
+  XCTAssertNotNil([RNFBCrashlyticsFatalExit shared]);
+  XCTAssertEqual([RNFBCrashlyticsFatalExit shared], [RNFBCrashlyticsFatalExit shared]);
+  XCTAssertEqualWithAccuracy(RNFBCrashlyticsFatalExitWatchdogTimeout, 2.0, 0.0001);
+}
+
+- (void)testRecordThenTerminate_savesOnMainBeforeTerminatorRuns {
+  FIRCrashlytics.onExceptionModelSaved = ^(FIRExceptionModel *model) {
+    [self appendEvent:[@"save:" stringByAppendingString:model.reason]];
+  };
+  XCTestExpectation *terminated = [self expectationWithDescription:@"terminated"];
+  __block NSUInteger terminations = 0;
+  // Held suspended until the main-queue terminate has run, so the watchdog cannot win under load.
+  dispatch_queue_t watchdogQueue =
+      dispatch_queue_create("rnfb.crashlytics.test.watchdog", DISPATCH_QUEUE_SERIAL);
+  dispatch_suspend(watchdogQueue);
+  RNFBCrashlyticsFatalExit *fatalExit = [[RNFBCrashlyticsFatalExit alloc]
+      initWithTerminator:^{
+        terminations += 1;
+        [self appendEvent:@"exit"];
+        XCTAssertTrue([NSThread isMainThread]);
+        [terminated fulfill];
+      }
+          terminateQueue:dispatch_get_main_queue()
+           watchdogQueue:watchdogQueue
+         watchdogTimeout:0.2];
+
+  // Production calls in on the module's own (non-main) method queue.
+  __block BOOL started = NO;
+  dispatch_queue_t moduleQueue =
+      dispatch_queue_create("rnfb.crashlytics.test.module", DISPATCH_QUEUE_SERIAL);
+  dispatch_async(moduleQueue, ^{
+    started = [fatalExit recordThenTerminate:^{
+      [self recordFatal];
+    }];
+  });
+
+  [self waitForExpectations:@[ terminated ] timeout:5];
+  dispatch_resume(watchdogQueue);
+  [self drainFor:0.4];  // past the watchdog, which must not terminate again
+  [self drainQueue:watchdogQueue];
+  [self drainQueue:moduleQueue];  // `started` is written on moduleQueue
+
+  XCTAssertTrue(started);
+  XCTAssertEqual(terminations, 1u);
+  NSArray *expected = @[ @"save:fatal", @"exit" ];
+  XCTAssertEqualObjects([self eventsSnapshot], expected);
+  XCTAssertEqual(FIRCrashlytics.savedExceptionModels.count, 1u);
+  XCTAssertEqualObjects(FIRCrashlytics.savedExceptionModels.firstObject.name, @"JavaScriptError");
+}
+
+- (void)testRecordThenTerminate_contextInitPending_terminatesBeforeSave {
+  [FIRCrashlytics holdContextInit];
+  FIRCrashlytics.onExceptionModelSaved = ^(FIRExceptionModel *model) {
+    [self appendEvent:[@"save:" stringByAppendingString:model.reason]];
+  };
+  XCTestExpectation *terminated = [self expectationWithDescription:@"terminated"];
+  __block NSUInteger terminations = 0;
+  __block NSUInteger savedAtExit = NSUIntegerMax;
+  __block BOOL recordedAtExit = NO;
+  dispatch_queue_t watchdogQueue =
+      dispatch_queue_create("rnfb.crashlytics.test.watchdog", DISPATCH_QUEUE_SERIAL);
+  dispatch_suspend(watchdogQueue);
+  RNFBCrashlyticsFatalExit *fatalExit = [[RNFBCrashlyticsFatalExit alloc]
+      initWithTerminator:^{
+        terminations += 1;
+        savedAtExit = FIRCrashlytics.savedExceptionModels.count;
+        recordedAtExit = FIRCrashlytics.lastRecordedExceptionModel != nil;
+        [self appendEvent:@"exit"];
+        [FIRCrashlytics fulfillContextInit];
+        [terminated fulfill];
+      }
+          terminateQueue:dispatch_get_main_queue()
+           watchdogQueue:watchdogQueue
+         watchdogTimeout:0.2];
+
+  __block BOOL started = NO;
+  dispatch_queue_t moduleQueue =
+      dispatch_queue_create("rnfb.crashlytics.test.module", DISPATCH_QUEUE_SERIAL);
+  dispatch_async(moduleQueue, ^{
+    started = [fatalExit recordThenTerminate:^{
+      [self recordFatal];
+    }];
+  });
+
+  [self waitForExpectations:@[ terminated ] timeout:5];
+  dispatch_resume(watchdogQueue);
+  [self drainFor:0.4];
+  [self drainQueue:watchdogQueue];
+  [self drainQueue:moduleQueue];
+
+  XCTAssertTrue(started);
+  XCTAssertEqual(terminations, 1u);
+  XCTAssertTrue(recordedAtExit);
+  XCTAssertEqual(savedAtExit, 0u);
+  NSArray *expected = @[ @"exit", @"save:fatal" ];
+  XCTAssertEqualObjects([self eventsSnapshot], expected);
+}
+
+- (void)testWatchdog_terminatesWhenTerminateQueueIsHung {
+  dispatch_queue_t hungQueue = dispatch_queue_create("rnfb.crashlytics.test.hung", 0);
+  dispatch_semaphore_t release = dispatch_semaphore_create(0);
+  dispatch_async(hungQueue, ^{
+    dispatch_semaphore_wait(release, DISPATCH_TIME_FOREVER);
+  });
+
+  XCTestExpectation *terminated = [self expectationWithDescription:@"terminated"];
+  __block NSUInteger terminations = 0;
+  __block BOOL terminatedWhileHung = NO;
+  __block BOOL hung = YES;
+  RNFBCrashlyticsFatalExit *fatalExit = [[RNFBCrashlyticsFatalExit alloc]
+      initWithTerminator:^{
+        terminations += 1;
+        terminatedWhileHung = hung;
+        [terminated fulfill];
+      }
+          terminateQueue:hungQueue
+           watchdogQueue:dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)
+         watchdogTimeout:0.1];
+
+  XCTAssertTrue([fatalExit recordThenTerminate:^{
+    [self recordFatal];
+  }]);
+  [self waitForExpectations:@[ terminated ] timeout:5];
+
+  hung = NO;
+  dispatch_semaphore_signal(release);
+  [self drainQueue:hungQueue];  // the queued terminate block has now run
+
+  XCTAssertTrue(terminatedWhileHung);
+  XCTAssertEqual(terminations, 1u);
+}
+
+- (void)testRecordRaises_stillTerminatesAndIgnoresLaterFatals {
+  XCTestExpectation *terminated = [self expectationWithDescription:@"terminated"];
+  __block NSUInteger terminations = 0;
+  RNFBCrashlyticsFatalExit *fatalExit = [[RNFBCrashlyticsFatalExit alloc]
+      initWithTerminator:^{
+        terminations += 1;
+        [terminated fulfill];
+      }
+          terminateQueue:dispatch_get_main_queue()
+           watchdogQueue:dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)
+         watchdogTimeout:0.1];
+
+  BOOL first = [fatalExit recordThenTerminate:^{
+    [NSException raise:NSInternalInconsistencyException format:@"record failed"];
+  }];
+  BOOL second = [fatalExit recordThenTerminate:^{
+    [self recordFatal];
+  }];
+
+  [self waitForExpectations:@[ terminated ] timeout:5];
+  [self drainFor:0.3];
+
+  XCTAssertTrue(first);
+  XCTAssertFalse(second);
+  XCTAssertEqual(terminations, 1u);
+  XCTAssertEqual(FIRCrashlytics.savedExceptionModels.count, 0u);
+}
+
+- (void)testSecondFatalWhileTerminating_isIgnored {
+  XCTestExpectation *terminated = [self expectationWithDescription:@"terminated"];
+  __block NSUInteger terminations = 0;
+  __block NSUInteger records = 0;
+  RNFBCrashlyticsFatalExit *fatalExit = [[RNFBCrashlyticsFatalExit alloc]
+      initWithTerminator:^{
+        terminations += 1;
+        [terminated fulfill];
+      }
+          terminateQueue:dispatch_get_main_queue()
+           watchdogQueue:dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)
+         watchdogTimeout:0.1];
+
+  BOOL first = [fatalExit recordThenTerminate:^{
+    records += 1;
+    [self recordFatal];
+  }];
+  BOOL second = [fatalExit recordThenTerminate:^{
+    records += 1;
+    [self recordFatal];
+  }];
+
+  [self waitForExpectations:@[ terminated ] timeout:5];
+  [self drainFor:0.3];
+
+  XCTAssertTrue(first);
+  XCTAssertFalse(second);
+  XCTAssertEqual(records, 1u);
+  XCTAssertEqual(terminations, 1u);
+  XCTAssertEqual(FIRCrashlytics.savedExceptionModels.count, 1u);
+}
+
+@end