Fix test cases

Sources/SentryCrash/Recording/Tools/SentryCrashJSONCodec.c

@@ -1256,7 +1256,7 @@ decodeElement(const char *const name, SentryCrashJSONDecodeContext *context)
             SENTRY_ASYNC_SAFE_LOG_DEBUG("Number is too long.");
             return SentryCrashJSON_ERROR_DATA_TOO_LONG;
         }
-        strlcpy(context->stringBuffer, start, len);
+        strncpy(context->stringBuffer, start, len);
 
         sscanf(context->stringBuffer, "%lg", &value);
 

Tests/SentryTests/Recording/SentryCrashCTests.swift

@@ -134,6 +134,71 @@ class SentryCrashCTests: XCTestCase {
         )
     }
 
+    func testOnCrash_crashedDuringCrashHandling_shouldRewriteOldCrashAsRecrashReportToDisk() throws {
+        // -- Arrange --
+        var appName = "SentryCrashCTests"
+            .cString(using: .utf8)!
+        let workDir = URL(fileURLWithPath: NSTemporaryDirectory())
+            .appendingPathComponent("SentryCrashCTests-\(UUID().uuidString)")
+        var installPath = workDir
+            .path
+            .cString(using: .utf8)!
+        let expectedReportsDir = workDir
+            .appendingPathComponent("Reports")
+
+        // Smoke test the existence of the directory
+        XCTAssertFalse(FileManager.default.fileExists(
+            atPath: expectedReportsDir.path
+        ))
+
+        // Installing the sentrycrash will setup the exception handler
+        sentrycrash_uninstall()
+        sentrycrash_install(&appName, &installPath)
+
+        // Initial Crash Context
+        var initialMonitorContext = SentryCrash_MonitorContext()
+        initialMonitorContext.crashedDuringCrashHandling = false // the first context simulates the initial crash
+
+        // Re-created Crash
+        // The following crash context is a minimal version of the crash context created in the `SentryCrashMonitor_NSException`
+        var recrashMachineContext = SentryCrashMachineContext()
+        sentrycrashmc_getContextForThread(
+            sentrycrashthread_self(),
+            &recrashMachineContext,
+            true
+        )
+        var cursor = SentryCrashStackCursor()
+        let callstack = UnsafeMutablePointer<UInt>.allocate(capacity: 0)
+        sentrycrashsc_initWithBacktrace(&cursor, callstack, 0, 0)
+
+        var recrashMonitorContext = SentryCrash_MonitorContext()
+        recrashMonitorContext.crashedDuringCrashHandling = true
+        recrashMonitorContext.crashType = SentryCrashMonitorTypeNSException
+        withUnsafeMutablePointer(to: &recrashMachineContext) { ptr in
+            recrashMonitorContext.offendingMachineContext = ptr
+        }
+        withUnsafeMutablePointer(to: &cursor) { ptr in
+            recrashMonitorContext.stackCursor = UnsafeMutableRawPointer(ptr)
+        }
+
+        // -- Act --
+        // Calling the handle exception will trigger the onCrash handler
+        sentrycrashcm_handleException(&initialMonitorContext)
+
+        // After the first handler, the report will be written to disk.
+        // Read it to memory now, as the next handler will edit the file.
+        let decodedReport = try readFirstReportFromDisk(reportsDir: expectedReportsDir)
+
+        // Calling the handler again with 'crashedDuringCrashHandling' will rewrite the crash report
+        sentrycrashcm_handleException(&recrashMonitorContext)
+
+        // -- Assert --
+        let decodedRecrashReport = try readFirstReportFromDisk(reportsDir: expectedReportsDir)
+
+        let recrashReport = decodedRecrashReport["recrash_report"] as! NSDictionary
+        XCTAssertEqual(recrashReport, decodedReport)
+    }
+
     func testOnCrash_crashedDuringCrashHandling_installFilePathTooLong_shouldNotWriteToDisk() throws {
         // -- Arrange --
         var appName = "SentryCrashCTests"
@@ -174,6 +239,7 @@ class SentryCrashCTests: XCTestCase {
         sentrycrashsc_initWithBacktrace(&cursor, callstack, 0, 0)
 
         var recrashMonitorContext = SentryCrash_MonitorContext()
+        recrashMonitorContext.crashedDuringCrashHandling = true
         recrashMonitorContext.crashType = SentryCrashMonitorTypeNSException
         withUnsafeMutablePointer(to: &recrashMachineContext) { ptr in
             recrashMonitorContext.offendingMachineContext = ptr
@@ -195,4 +261,22 @@ class SentryCrashCTests: XCTestCase {
             atPath: expectedReportsDir.path
         ))
     }
+
+    // MARK: - Helper
+
+    func readFirstReportFromDisk(reportsDir: URL) throws -> NSDictionary {
+        let reportUrls = try FileManager.default
+            .contentsOfDirectory(atPath: reportsDir.path)
+        XCTAssertEqual(            reportUrls.count, 1)
+        XCTAssertTrue(reportUrls[0].hasPrefix("SentryCrashCTests-report-"))
+        XCTAssertTrue(reportUrls[0].hasSuffix(".json"))
+
+        let reportData = try Data(contentsOf: reportsDir.appendingPathComponent(reportUrls[0]))
+        let decodedReport = try SentryCrashJSONCodec.decode(
+            reportData,
+            options: SentryCrashJSONDecodeOptionNone
+        ) as! NSDictionary
+
+        return decodedReport
+    }
 }

Tests/SentryTests/SentryCrash/SentryCrashMonitor_CppException_Tests.mm

@@ -67,53 +67,36 @@
 - (void)testCallHandler_shouldCaptureExceptionDescription
 {
     // -- Arrange --
-    waitHandleExceptionHandlerExpectation =
-        [self expectationWithDescription:@"Wait for C++ exception"];
-
     sentrycrashcm_setEventCallback(testHandleExceptionHandler);
     SentryCrashMonitorAPI *api = sentrycrashcm_cppexception_getAPI();
 
-    const char *errorMessage = "Example Error";
+    NSString *errorMessage = @"Example Error";
 
     // -- Act --
-    // Create a thread that will throw an uncaught exception
-    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-        api->setEnabled(true);
-        try {
-            throw std::runtime_error(errorMessage);
-        } catch (...) {
-            // Rethrowing without catching will trigger std::terminate()
-            std::rethrow_exception(std::current_exception());
-        }
-    });
+    api->setEnabled(true);
+    try {
+        throw std::runtime_error(errorMessage.UTF8String);
+    } catch (...) {
+        // This exception handler sets the error context of the termination handler
+        // Instead of rethrowing, directly call the termination handler
+        std::get_terminate()();
+    }
 
     // -- Assert --
-    [self waitForExpectationsWithTimeout:5
-                                 handler:^(NSError *_Nullable error) {
-                                     SentryCrash_MonitorContext *context
-                                         = capturedHandleExceptionContext;
-
-                                     // Cleanup
-                                     api->setEnabled(false);
-                                     sentrycrashcm_setEventCallback(NULL);
-                                     capturedHandleExceptionContext = NULL;
-
-                                     // Check for expectation failures
-                                     if (error) {
-                                         XCTFail(@"Expectation failed with error: %@", error);
-                                     }
-
-                                     // Assertions
-                                     XCTAssertTrue(strcmp(context->crashReason, errorMessage));
-                                 }];
+    SentryCrash_MonitorContext *context = capturedHandleExceptionContext;
+
+    // Cleanup
+    api->setEnabled(false);
+    sentrycrashcm_setEventCallback(NULL);
+    capturedHandleExceptionContext = NULL;
+
+    NSString *crashReason = [[NSString alloc] initWithUTF8String:context->crashReason];
+    XCTAssertEqualObjects(crashReason, errorMessage);
 }
 
 - (void)testCallHandler_descriptionLongerThanBuffer_shouldCaptureTruncatedExceptionDescription
 {
     // -- Arrange --
-    waitHandleExceptionHandlerExpectation =
-        [self expectationWithDescription:@"Wait for C++ exception"];
-
     sentrycrashcm_setEventCallback(testHandleExceptionHandler);
     SentryCrashMonitorAPI *api = sentrycrashcm_cppexception_getAPI();
 
@@ -124,38 +107,28 @@
 
     // -- Act --
     // Create a thread that will throw an uncaught exception
-    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-        api->setEnabled(true);
-        try {
-            throw std::runtime_error(errorMessage.UTF8String);
-        } catch (...) {
-            // Rethrowing without catching will trigger std::terminate()
-            std::rethrow_exception(std::current_exception());
-        }
-    });
+    api->setEnabled(true);
+    try {
+        throw std::runtime_error(errorMessage.UTF8String);
+    } catch (...) {
+        // This exception handler sets the error context of the termination handler
+        // Instead of rethrowing, directly call the termination handler
+        std::get_terminate()();
+    }
 
     // -- Assert --
     NSString *truncatedErrorMessage = [@"" stringByPaddingToLength:1000
                                                         withString:@"A"
                                                    startingAtIndex:0];
-    [self waitForExpectationsWithTimeout:5
-                                 handler:^(NSError *_Nullable error) {
-                                     SentryCrash_MonitorContext *context
-                                         = capturedHandleExceptionContext;
-
-                                     // Cleanup
-                                     api->setEnabled(false);
-                                     sentrycrashcm_setEventCallback(NULL);
-                                     capturedHandleExceptionContext = NULL;
-
-                                     // Check for expectation failures
-                                     if (error) {
-                                         XCTFail(@"Expectation failed with error: %@", error);
-                                     }
-
-                                     // Assertions
-                                     XCTAssertTrue(strcmp(
-                                         context->crashReason, truncatedErrorMessage.UTF8String));
-                                 }];
+    SentryCrash_MonitorContext *context = capturedHandleExceptionContext;
+
+    // Cleanup
+    api->setEnabled(false);
+    sentrycrashcm_setEventCallback(NULL);
+    capturedHandleExceptionContext = NULL;
+
+    // Assertions
+    NSString *crashReason = [[NSString alloc] initWithUTF8String:context->crashReason];
+    XCTAssertEqualObjects(crashReason, truncatedErrorMessage);
 }
 @end

scripts/.clang-format-version

@@ -1 +1 @@
-19.1.5
+19.1.6