Add test that crashes due to read and writes from multiple threads

Author: tboogh

Sources/MockingKit/Mock.swift

@@ -16,7 +16,7 @@ import Foundation
 ///
 /// Inherit this type instead of implementing the ``Mockable``
 /// protocol, to save some code for every mock you create.
-open class Mock: Mockable {
+open class Mock: Mockable, @unchecked Sendable {
 
     public init() {}
 

Sources/MockingKit/Mockable.swift

@@ -22,7 +22,7 @@ import Foundation
 ///
 /// Implement this protocol instead of inheriting the ``Mock``
 /// base class, to save some code for every mock you create.
-public protocol Mockable {
+public protocol Mockable: Sendable {
 
     typealias Function = Any
 

Sources/MockingKit/Mocks/MockPasteboard.swift

@@ -32,7 +32,7 @@ import AppKit
  This mock only mocks `setValue(_:forKey:)` for now, but you
  can subclass this class and mock more functionality.
  */
-public class MockPasteboard: NSPasteboard, Mockable {
+public class MockPasteboard: NSPasteboard, Mockable, @unchecked Sendable {
 
     public lazy var setValueForKeyRef = MockReference(setValueForKey)
 

Sources/MockingKit/Mocks/MockUserDefaults.swift

@@ -9,7 +9,7 @@
 import Foundation
 
 /// This class can be used to mock `UserDefaults`.
-open class MockUserDefaults: UserDefaults, Mockable {
+open class MockUserDefaults: UserDefaults, Mockable, @unchecked Sendable {
 
     public lazy var boolRef = MockReference(bool)
     public lazy var arrayRef = MockReference(array)

Tests/MockingKitTests/GenericTests.swift

@@ -21,7 +21,7 @@ final class GenericTests: XCTestCase {
     }
 }
 
-private class GenericMock<T>: Mock {
+private class GenericMock<T>: Mock, @unchecked Sendable {
 
     lazy var doitRef = MockReference(doit)
 

Tests/MockingKitTests/MockableAsyncTests.swift

@@ -252,11 +252,33 @@ class MockableAsyncTests: XCTestCase {
         XCTAssertFalse(mock.hasCalled(mock.functionWithIntResultRef))
         XCTAssertTrue(mock.hasCalled(\.functionWithStringResultRef))
     }
+
+    func testMultiThreadedAccess_doesNotCorruptState() async throws {
+        let expectation = XCTestExpectation()
+        expectation.expectedFulfillmentCount = 2
+        let mock = TestClass()
+
+        Task {
+            for index in 0..<100 {
+                await mock.functionWithVoidResult(arg1: "Test", arg2: index)
+            }
+            expectation.fulfill()
+        }
+
+        Task {
+            for _ in 0..<100 {
+                _ = mock.hasCalled(\.functionWithIntResultRef)
+            }
+            expectation.fulfill()
+        }
+
+        await fulfillment(of: [expectation])
+    }
 }
 
-private class TestClass: AsyncTestProtocol, Mockable {
+private final class TestClass: AsyncTestProtocol, Mockable, @unchecked Sendable {
 
-    var mock = Mock()
+    let mock = Mock()
 
     lazy var functionWithIntResultRef = AsyncMockReference(functionWithIntResult)
     lazy var functionWithStringResultRef = AsyncMockReference(functionWithStringResult)

Tests/MockingKitTests/MockableTests.swift

@@ -256,11 +256,30 @@ class MockableTests: XCTestCase {
         XCTAssertFalse(mock.hasCalled(mock.functionWithIntResultRef))
         XCTAssertTrue(mock.hasCalled(\.functionWithStringResultRef))
     }
+
+    func testMultiThreadedAccess_doesNotCorruptState() {
+        let queueA = DispatchQueue(label: "QueueA")
+        let queueB = DispatchQueue(label: "QueueB")
+
+        let mock = TestClass()
+
+        queueA.async {
+            for index in 0..<100 {
+                mock.functionWithVoidResult(arg1: "Something", arg2: index)
+            }
+        }
+
+        queueB.async {
+            for _ in 0..<100 {
+                _ = mock.hasCalled(\.functionWithIntResultRef)
+            }
+        }
+    }
 }
 
-private class TestClass: AsyncTestProtocol, Mockable {
+private final class TestClass: AsyncTestProtocol, Mockable, @unchecked Sendable {
 
-    var mock = Mock()
+    let mock = Mock()
 
     lazy var functionWithIntResultRef = MockReference(functionWithIntResult)
     lazy var functionWithStringResultRef = MockReference(functionWithStringResult)