Account for possible data races when evaluating Assert expressions when throwing an error to be compatible with Swift 6.0

Author: angu

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## HEAD
 
+## 1.1.0
+
+* Ensure compatibility with Swift 6.0
+* Account for possible data races when evaluating expressions in case they throwing an error to be 
+
 ## 1.0.1
 
 * Fixed `AsyncAssertThrowsError(_:_:_:)` would not execute the error handler closure in case the evaluated expression throws an error.

Sources/SwiftAsyncAssert/AssertExpressionEvaluator.swift

@@ -8,23 +8,21 @@
 import XCTest
 
 enum AssertExpressionEvaluator {
-
-    /// Evaluated in case an evaluated expression throws an error
-    static var failurePrompt: (String, StaticString, UInt) -> Void = { XCTFail($0, file: $1, line: $2) }
-
+    
     static func evaluate(_ expression: () async throws -> Void,
-                  _ message: @autoclosure () -> String = "",
-                  function: StaticString = #function,
-                  file: StaticString = #filePath,
-                  line: UInt = #line) async {
+                         _ message: @autoclosure () -> String = "",
+                         function: StaticString = #function,
+                         file: StaticString = #filePath,
+                         line: UInt = #line,
+                         failureEvaluation: (String, StaticString, UInt) -> Void = { XCTFail($0, file: $1, line: $2) }) async {
         do {
             try await expression()
         } catch {
-            Self.failurePrompt(ThrownErrorFormatter.formattedStringForThrownError(error,
-                                                                                  in: "\(function)",
-                                                                                  message: message()),
-                               file,
-                               line)
+            failureEvaluation(ThrownErrorFormatter.formattedStringForThrownError(error,
+                                                                                 in: "\(function)",
+                                                                                 message: message()),
+                              file,
+                              line)
         }
     }
 }

Tests/SwiftAsyncAssertTests/AssertExpressionEvaluatorTest.swift

@@ -11,29 +11,23 @@ import XCTest
 
 final class AssertExpressionEvaluatorTest: XCTestCase {
 
-    func test_should_succeed_when_evaluated_expression_executes_successfully() async throws {
-        var isFailurePromptCalled = false
-
-        AssertExpressionEvaluator.failurePrompt = { _, _, _ in
-            isFailurePromptCalled = true
-        }
+    private var isFailurePromptCalled = false
 
+    func test_should_succeed_when_evaluated_expression_executes_successfully() async throws {
         await AssertExpressionEvaluator.evaluate({
             // Here gets code executed that does not throw an error
+        }, failureEvaluation: { _, _, _ in
+            self.isFailurePromptCalled = true
         })
 
         XCTAssertFalse(isFailurePromptCalled)
     }
 
     func test_should_fail_when_evaluated_expression_throws_error() async throws {
-        var isFailurePromptCalled = false
-
-        AssertExpressionEvaluator.failurePrompt = { _, _, _ in
-            isFailurePromptCalled = true
-        }
-
         await AssertExpressionEvaluator.evaluate({
             throw TestingError.systemFailedToWork
+        }, failureEvaluation: { _, _, _ in
+            self.isFailurePromptCalled = true
         })
 
         XCTAssertTrue(isFailurePromptCalled)