Swift Testing

Author: swhitty

Tests/AllocatedLock+Unsafe.swift

@@ -0,0 +1,38 @@
+//
+//  AllocatedLock+Unsafe.swift
+//  swift-mutex
+//
+//  Created by Simon Whitty on 11/02/2025.
+//  Copyright 2025 Simon Whitty
+//
+//  Distributed under the permissive MIT license
+//  Get the latest version from here:
+//
+//  https://github.com/swhitty/swift-mutex
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+@testable import Mutex
+
+// sidestep warning: unavailable from asynchronous contexts
+extension AllocatedLock {
+    func unsafeLock() { storage.lock() }
+    func unsafeUnlock() { storage.unlock() }
+}

Tests/AllocatedLockTests.swift

@@ -29,12 +29,14 @@
 //  SOFTWARE.
 //
 
+#if canImport(Testing)
 @testable import Mutex
-import XCTest
+import Testing
 
-final class AllocatedLockTests: XCTestCase {
+struct AllocatedLockTests {
 
-    func testLockState_IsProtected() async {
+    @Test
+    func lockState_IsProtected() async {
         let state = AllocatedLock<Int>(initialState: 0)
 
         let total = await withTaskGroup(of: Void.self) { group in
@@ -47,17 +49,18 @@ final class AllocatedLockTests: XCTestCase {
             return state.withLock { $0 }
         }
 
-        XCTAssertEqual(total, 500500)
+        #expect(total == 500500)
     }
 
-    func testLock_ReturnsValue() async {
+    @Test
+    func lock_ReturnsValue() async {
         let lock = AllocatedLock()
         let value = lock.withLock { true }
-        XCTAssertTrue(value)
+        #expect(value)
     }
 
-
-    func testLock_Blocks() async {
+    @Test
+    func lock_Blocks() async {
         let lock = AllocatedLock()
         await MainActor.run {
             lock.unsafeLock()
@@ -82,99 +85,95 @@ final class AllocatedLockTests: XCTestCase {
             let second = await group.next()!
             return [first, second]
         }
-        XCTAssertEqual(results, [true, false])
+        #expect(results == [true, false])
     }
 
-    func testTryLock() {
+    @Test
+    func tryLock() {
         let lock = AllocatedLock()
         let value = lock.withLock { true }
-        XCTAssertTrue(value)
+        #expect(value)
     }
 
-    func testIfAvailable() {
+    @Test
+    func ifAvailable() {
         let lock = AllocatedLock(uncheckedState: 5)
-        XCTAssertEqual(
-            lock.withLock { _ in "fish" },
-            "fish"
+        #expect(
+            lock.withLock { _ in "fish" } == "fish"
         )
 
         lock.unsafeLock()
-        XCTAssertEqual(
-            lock.withLockIfAvailable { _ in "fish" },
-            String?.none
+        #expect(
+            lock.withLockIfAvailable { _ in "fish" } == nil
         )
 
         lock.unsafeUnlock()
-        XCTAssertEqual(
-            lock.withLockIfAvailable { _ in "fish" },
-            "fish"
+        #expect(
+            lock.withLockIfAvailable { _ in "fish" } == "fish"
         )
     }
 
-    func testIfAvailableUnchecked() {
+    @Test
+    func ifAvailableUnchecked() {
         let lock = AllocatedLock(uncheckedState: NonSendable("fish"))
-        XCTAssertEqual(
-            lock.withLockUnchecked { $0 }.name,
-            "fish"
+        #expect(
+            lock.withLockUnchecked { $0 }.name == "fish"
         )
 
         lock.unsafeLock()
-        XCTAssertNil(
-            lock.withLockIfAvailableUnchecked { $0 }?.name
+        #expect(
+            lock.withLockIfAvailableUnchecked { $0 }?.name == nil
         )
 
         lock.unsafeUnlock()
-        XCTAssertEqual(
-            lock.withLockIfAvailableUnchecked { $0 }?.name,
-            "fish"
+        #expect(
+            lock.withLockIfAvailableUnchecked { $0 }?.name == "fish"
         )
     }
 
-    func testVoidIfAvailable() {
+    @Test
+    func voidIfAvailable() {
         let lock = AllocatedLock()
-        XCTAssertEqual(
-            lock.withLock { "fish" },
-            "fish"
+        #expect(
+            lock.withLock { "fish" } == "fish"
         )
 
         lock.unsafeLock()
-        XCTAssertEqual(
-            lock.withLockIfAvailable { "fish" },
-            String?.none
+        #expect(
+            lock.withLockIfAvailable { "fish" } == nil
         )
 
         lock.unsafeUnlock()
-        XCTAssertEqual(
-            lock.withLockIfAvailable { "fish" },
-            "fish"
+        #expect(
+            lock.withLockIfAvailable { "fish" } == "fish"
         )
     }
 
-    func testVoidIfAvailableUnchecked() {
+    @Test
+    func voidIfAvailableUnchecked() {
         let lock = AllocatedLock()
-        XCTAssertEqual(
-            lock.withLockUnchecked { NonSendable("fish") }.name,
-            "fish"
+        #expect(
+            lock.withLockUnchecked { NonSendable("fish") }.name == "fish"
         )
 
         lock.lock()
-        XCTAssertNil(
-            lock.withLockIfAvailableUnchecked { NonSendable("fish") }
+        #expect(
+            lock.withLockIfAvailableUnchecked { NonSendable("fish") } == nil
         )
 
         lock.unlock()
-        XCTAssertEqual(
-            lock.withLockIfAvailableUnchecked { NonSendable("chips") }?.name,
-            "chips"
+        #expect(
+            lock.withLockIfAvailableUnchecked { NonSendable("chips") }?.name == "chips"
         )
     }
 
-    func testVoidLock() {
+    @Test
+    func voidLock() {
         let lock = AllocatedLock()
         lock.lock()
-        XCTAssertFalse(lock.lockIfAvailable())
+        #expect(lock.lockIfAvailable() == false)
         lock.unlock()
-        XCTAssertTrue(lock.lockIfAvailable())
+        #expect(lock.lockIfAvailable())
         lock.unlock()
     }
 }
@@ -187,9 +186,4 @@ public final class NonSendable {
         self.name = name
     }
 }
-
-// sidestep warning: unavailable from asynchronous contexts
-extension AllocatedLock {
-    func unsafeLock() { storage.lock() }
-    func unsafeUnlock() { storage.unlock() }
-}
+#endif