Property wrapper (#19)

1. Мигрировал тесты на Swift Testing
2. Добавил property wrapper для более удобного использования

Author: denis-egaluev

Sources/DBThreadSafe/ThreadSafe.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+@propertyWrapper
+public final class ThreadSafe<T> {
+    private let container: DBThreadSafeContainer<T>
+
+    public init(wrappedValue: T) {
+        self.container = DBThreadSafeContainer(wrappedValue)
+    }
+
+    public var wrappedValue: T {
+        get {
+            container.read()
+        }
+        @available(
+            *,
+             unavailable,
+             message: "Use $property.write { } to modify the value"
+        )
+        set {
+            container.write(newValue)
+        }
+    }
+
+    public var projectedValue: DBThreadSafeContainer<T> {
+        container
+    }
+}

Tests/DBThreadSafeTests/DBThreadSafeContainerTests.swift

@@ -1,119 +1,129 @@
 import DBThreadSafe
-import XCTest
+import Foundation
+import Testing
 
-class DBThreadSafeContainerTests: XCTestCase {
+@Suite("DBThreadSafeContainer Tests")
+struct DBThreadSafeContainerTests {
     let iterations = 100000
-    
-    func testConcurrentGet() {
+
+    @Test("Concurrent reads return correct value")
+    func concurrentGet() {
         let container = DBThreadSafeContainer(0)
-        
+
         DispatchQueue.concurrentPerform(iterations: iterations) { _ in
             _ = container.read()
         }
-        
-        XCTAssertEqual(container.read(), 0)
+
+        #expect(container.read() == 0)
     }
-    
-    func testRead() {
+
+    @Test("Read with closure")
+    func read() {
         let container = DBThreadSafeContainer("Hello, World!")
-        
+
         enum TestError: Error {
             case someError
         }
-        
+
         // Test case 1: Read value successfully
         let expectedValue1 = "Hello, World!"
         container.read { value in
-            XCTAssertEqual(value, expectedValue1)
+            #expect(value == expectedValue1)
         }
-        
+
         // Test case 2: Read value with throwing closure
-        XCTAssertThrowsError(try container.read { _ in
-            throw TestError.someError
-        }) { error in
-            XCTAssertEqual(error as? TestError, TestError.someError)
+        #expect(throws: TestError.self) {
+            try container.read { _ in
+                throw TestError.someError
+            }
         }
     }
-    
-    func testReadClosureReturnValue() {
+
+    @Test("Read closure with return value")
+    func readClosureReturnValue() {
         let container = DBThreadSafeContainer("Hello, World!")
-        
+
         let result = container.read { $0.count }
-        
-        XCTAssertEqual(result, 13)
+
+        #expect(result == 13)
     }
 
-    
-    func testConcurrentSet() {
+
+    @Test("Concurrent writes increment correctly")
+    func concurrentSet() {
         let container = DBThreadSafeContainer(0)
-        
+
         DispatchQueue.concurrentPerform(iterations: iterations) { _ in
             container.write { value in
                 let newValue = value + 1
                 value = newValue
             }
         }
-        
-        XCTAssertEqual(container.read(), iterations)
+
+        #expect(container.read() == iterations)
     }
-    
-    func testConcurrentGetArray() {
+
+    @Test("Concurrent array reads return correct value")
+    func concurrentGetArray() {
         let container = DBThreadSafeContainer([1, 2, 3])
-        
+
         DispatchQueue.concurrentPerform(iterations: iterations) { _ in
             _ = container.read()
         }
-        
-        XCTAssertEqual(container.read(), [1, 2, 3])
+
+        #expect(container.read() == [1, 2, 3])
     }
-    
-    func testConcurrentSetArray() throws {
+
+    @Test("Concurrent array appends")
+    func concurrentSetArray() throws {
         let container = DBThreadSafeContainer([0])
-        
+
         DispatchQueue.concurrentPerform(iterations: iterations) { _ in
             container.write { value in
                 let lastValue = value.last!
                 value.append(lastValue + 1)
             }
         }
-        
-        XCTAssertEqual(container.read().last, iterations)
+
+        #expect(container.read().last == iterations)
     }
-    
-    func testConcurrentGetDictionary() {
+
+    @Test("Concurrent dictionary reads return correct value")
+    func concurrentGetDictionary() {
         let container = DBThreadSafeContainer(["key1": "value1", "key2": "value2"])
-        
+
         DispatchQueue.concurrentPerform(iterations: iterations) { _ in
             _ = container.read()
         }
-        
-        XCTAssertEqual(container.read(), ["key1": "value1", "key2": "value2"])
+
+        #expect(container.read() == ["key1": "value1", "key2": "value2"])
     }
-    
-    func testConcurrentSetDictionary() {
+
+    @Test("Concurrent dictionary operations")
+    func concurrentSetDictionary() {
         let container = DBThreadSafeContainer(["key": 0])
-        
+
         DispatchQueue.concurrentPerform(iterations: iterations) { _ in
             container.write { dict in
                 let value = dict["key"]
                 dict["key"] = value! + 1
             }
         }
-        
+
         DispatchQueue.concurrentPerform(iterations: iterations) { i in
             container.write { dict in
                 let key = "key\(i)"
                 dict[key] = i
             }
         }
-        
+
         DispatchQueue.concurrentPerform(iterations: iterations) { i in
             container.write { dict in
                 let key = "key\(i)"
                 dict.removeValue(forKey: key)
             }
         }
-        
-        XCTAssertEqual(container.read(), ["key": iterations])
+
+        #expect(container.read() == ["key": iterations])
     }
 }

Tests/DBThreadSafeTests/ThreadSafeTests.swift

@@ -0,0 +1,188 @@
+import DBThreadSafe
+import Foundation
+import Testing
+
+@Suite("ThreadSafe Property Wrapper Tests")
+struct ThreadSafeTests {
+    let iterations = 100000
+
+    @Test("Reading wrappedValue returns correct value")
+    func readWrappedValue() {
+        @ThreadSafe var counter = 42
+
+        #expect(counter == 42)
+    }
+
+    @Test("Writing with write closure updates value")
+    func writeWithClosure() {
+        @ThreadSafe var counter = 0
+
+        $counter.write { value in
+            value = 100
+        }
+
+        #expect(counter == 100)
+    }
+
+    @Test("Concurrent reads via wrappedValue")
+    func concurrentReads() {
+        @ThreadSafe var value = 42
+
+        DispatchQueue.concurrentPerform(iterations: iterations) { _ in
+            _ = value
+        }
+
+        #expect(value == 42)
+    }
+
+    @Test("Concurrent writes with write closure")
+    func concurrentWrites() {
+        @ThreadSafe var counter = 0
+
+        DispatchQueue.concurrentPerform(iterations: iterations) { _ in
+            $counter.write { value in
+                value += 1
+            }
+        }
+
+        #expect(counter == iterations)
+    }
+
+    @Test("Projected value provides access to container")
+    func projectedValue() {
+        @ThreadSafe var counter = 0
+
+        $counter.write { value in
+            value = 100
+        }
+
+        #expect(counter == 100)
+    }
+
+    @Test("Concurrent writes using projected value write closure")
+    func concurrentWritesWithClosure() {
+        @ThreadSafe var counter = 0
+
+        DispatchQueue.concurrentPerform(iterations: iterations) { _ in
+            $counter.write { value in
+                value += 1
+            }
+        }
+
+        #expect(counter == iterations)
+    }
+
+    @Test("Reading with projected value read method")
+    func readWithProjectedValue() {
+        @ThreadSafe var text = "Hello, World!"
+
+        let length = $text.read { $0.count }
+
+        #expect(length == 13)
+    }
+
+    @Test("Concurrent array operations via projected value")
+    func concurrentArrayOperations() {
+        @ThreadSafe var numbers = [0]
+
+        DispatchQueue.concurrentPerform(iterations: iterations) { _ in
+            $numbers.write { value in
+                let lastValue = value.last!
+                value.append(lastValue + 1)
+            }
+        }
+
+        #expect(numbers.last == iterations)
+    }
+
+    @Test("Concurrent dictionary operations via projected value")
+    func concurrentDictionaryOperations() {
+        @ThreadSafe var dict = ["key": 0]
+
+        DispatchQueue.concurrentPerform(iterations: iterations) { _ in
+            $dict.write { dict in
+                let value = dict["key"]
+                dict["key"] = value! + 1
+            }
+        }
+
+        #expect(dict["key"] == iterations)
+    }
+
+    @Test("Struct property with ThreadSafe wrapper")
+    func structProperty() {
+        struct Counter {
+            @ThreadSafe var value = 0
+        }
+
+        let counter = Counter()
+        counter.$value.write { value in
+            value = 50
+        }
+
+        #expect(counter.value == 50)
+    }
+
+    @Test("Class property with ThreadSafe wrapper")
+    func classProperty() {
+        class Counter {
+            @ThreadSafe var value = 0
+        }
+
+        let counter = Counter()
+        counter.$value.write { value in
+            value = 75
+        }
+
+        #expect(counter.value == 75)
+
+        counter.$value.write { value in
+            value = 100
+        }
+
+        #expect(counter.value == 100)
+    }
+
+    @Test("write method with throwing closure")
+    func writeThrowing() {
+        @ThreadSafe var counter = 0
+
+        enum TestError: Error {
+            case someError
+        }
+
+        #expect(throws: TestError.self) {
+            try $counter.write { _ in
+                throw TestError.someError
+            }
+        }
+    }
+
+    @Test("Concurrent array operations via write closure")
+    func concurrentArrayWithWrite() {
+        @ThreadSafe var numbers = [0]
+
+        DispatchQueue.concurrentPerform(iterations: iterations) { _ in
+            $numbers.write { value in
+                let lastValue = value.last!
+                value.append(lastValue + 1)
+            }
+        }
+
+        #expect(numbers.last == iterations)
+    }
+
+    @Test("Concurrent dictionary operations via write closure")
+    func concurrentDictionaryWithWrite() {
+        @ThreadSafe var dict = ["key": 0]
+
+        DispatchQueue.concurrentPerform(iterations: iterations) { _ in
+            $dict.write { dict in
+                let value = dict["key"]
+                dict["key"] = value! + 1
+            }
+        }
+
+        #expect(dict["key"] == iterations)
+    }
+}