feat: Add tests for ThreadSafeArray, ThreadSafeDictionary, and Registry

Author: rickhohler

Tests/DesignAlgorithmsKitTests/Core/GenericRegistryTests.swift

@@ -0,0 +1,68 @@
+import XCTest
+@testable import DesignAlgorithmsKit
+
+final class GenericRegistryTests: XCTestCase {
+    
+    func testRegistration() {
+        let registry = Registry<String, Int>()
+        
+        registry.register(1, for: "one")
+        XCTAssertEqual(registry.get("one"), 1)
+        
+        registry.register(2, for: "two")
+        XCTAssertEqual(registry.get("two"), 2)
+    }
+    
+    func testOverwrite() {
+        let registry = Registry<String, Int>()
+        
+        registry.register(1, for: "key")
+        XCTAssertEqual(registry.get("key"), 1)
+        
+        registry.register(2, for: "key")
+        XCTAssertEqual(registry.get("key"), 2)
+    }
+    
+    func testRemoval() {
+        let registry = Registry<String, Int>()
+        registry.register(1, for: "one")
+        
+        registry.unregister("one")
+        XCTAssertNil(registry.get("one"))
+        
+        registry.register(2, for: "two")
+        registry.removeAll()
+        XCTAssertNil(registry.get("two"))
+    }
+    
+    func testAll() {
+        let registry = Registry<String, Int>()
+        registry.register(1, for: "one")
+        registry.register(2, for: "two")
+        
+        let allValues = registry.all()
+        XCTAssertEqual(allValues.count, 2)
+        XCTAssertTrue(allValues.contains(1))
+        XCTAssertTrue(allValues.contains(2))
+    }
+    
+    func testConcurrency() {
+        let registry = Registry<Int, Int>()
+        let iterations = 1000
+        let expectation = self.expectation(description: "Concurrent registry access")
+        expectation.expectedFulfillmentCount = iterations
+        
+        DispatchQueue.concurrentPerform(iterations: iterations) { i in
+            registry.register(i, for: i)
+            expectation.fulfill()
+        }
+        
+        waitForExpectations(timeout: 5.0)
+        
+        // Count via iteration or if there is a count property (Registry usually doesn't expose count directly but has all().count)
+        XCTAssertEqual(registry.all().count, iterations)
+        
+        // Verify random element
+        XCTAssertEqual(registry.get(500), 500)
+    }
+}

Tests/DesignAlgorithmsKitTests/Structural/ThreadSafeArrayTests.swift

@@ -0,0 +1,110 @@
+import XCTest
+@testable import DesignAlgorithmsKit
+
+final class ThreadSafeArrayTests: XCTestCase {
+    
+    func testInitialization() {
+        let array = ThreadSafeArray<Int>()
+        XCTAssertTrue(array.isEmpty)
+        XCTAssertEqual(array.count, 0)
+        
+        let arrayWithItems = ThreadSafeArray([1, 2, 3])
+        XCTAssertFalse(arrayWithItems.isEmpty)
+        XCTAssertEqual(arrayWithItems.count, 3)
+    }
+    
+    func testAppend() {
+        let array = ThreadSafeArray<Int>()
+        array.append(1)
+        XCTAssertEqual(array.count, 1)
+        XCTAssertEqual(array[0], 1)
+        
+        array.append(contentsOf: [2, 3])
+        XCTAssertEqual(array.count, 3)
+        XCTAssertEqual(array.allElements, [1, 2, 3])
+    }
+    
+    func testRemove() {
+        let array = ThreadSafeArray([1, 2, 3])
+        
+        let removed = array.remove(at: 1)
+        XCTAssertEqual(removed, 2)
+        XCTAssertEqual(array.count, 2)
+        XCTAssertEqual(array.allElements, [1, 3])
+        
+        array.removeAll()
+        XCTAssertTrue(array.isEmpty)
+    }
+    
+    func testSubscript() {
+        let array = ThreadSafeArray([1, 2, 3])
+        XCTAssertEqual(array[0], 1)
+        
+        array[0] = 10
+        XCTAssertEqual(array[0], 10)
+    }
+    
+    func testFunctionalMethods() {
+        let array = ThreadSafeArray([1, 2, 3, 4, 5])
+        
+        // Map
+        let stringArray = array.map { String($0) }
+        XCTAssertEqual(stringArray, ["1", "2", "3", "4", "5"])
+        
+        // Filter
+        let evenArray = array.filter { $0 % 2 == 0 }
+        XCTAssertEqual(evenArray, [2, 4])
+        
+        // CompactMap
+        let optionalArray = ThreadSafeArray(["1", "2", "NaN", "4"])
+        let numbers = optionalArray.compactMap { Int($0) }
+        XCTAssertEqual(numbers, [1, 2, 4])
+        
+        // First(where:)
+        let firstEven = array.first { $0 % 2 == 0 }
+        XCTAssertEqual(firstEven, 2)
+        
+        // Contains(where:)
+        XCTAssertTrue(array.contains { $0 == 3 })
+        XCTAssertFalse(array.contains { $0 == 6 })
+    }
+    
+    func testConcurrency() {
+        let array = ThreadSafeArray<Int>()
+        let iterations = 1000
+        let expectation = self.expectation(description: "Concurrent append")
+        expectation.expectedFulfillmentCount = iterations
+        
+        DispatchQueue.concurrentPerform(iterations: iterations) { i in
+            array.append(i)
+            expectation.fulfill()
+        }
+        
+        waitForExpectations(timeout: 5.0)
+        
+        // Should have all elements
+        XCTAssertEqual(array.count, iterations)
+        
+        // Count should match manual counting via read
+        let count = array.read { $0.count }
+        XCTAssertEqual(count, iterations)
+    }
+    
+    func testReadWriteBlock() {
+        let array = ThreadSafeArray([1, 2, 3])
+        
+        // Write block
+        array.write { elements in
+            elements.append(4)
+        }
+        
+        XCTAssertEqual(array.count, 4)
+        
+        // Read block
+        let sum = array.read { elements in
+            return elements.reduce(0, +)
+        }
+        
+        XCTAssertEqual(sum, 10)
+    }
+}

Tests/DesignAlgorithmsKitTests/Structural/ThreadSafeDictionaryTests.swift

@@ -0,0 +1,111 @@
+import XCTest
+@testable import DesignAlgorithmsKit
+
+final class ThreadSafeDictionaryTests: XCTestCase {
+    
+    func testInitialization() {
+        let dict = ThreadSafeDictionary<String, Int>()
+        XCTAssertTrue(dict.isEmpty)
+        XCTAssertEqual(dict.count, 0)
+        
+        let dictWithItems = ThreadSafeDictionary(["a": 1, "b": 2])
+        XCTAssertFalse(dictWithItems.isEmpty)
+        XCTAssertEqual(dictWithItems.count, 2)
+    }
+    
+    func testSubscript() {
+        let dict = ThreadSafeDictionary<String, Int>()
+        
+        // Write
+        dict["a"] = 1
+        XCTAssertEqual(dict["a"], 1)
+        XCTAssertEqual(dict.count, 1)
+        
+        // Update
+        dict["a"] = 2
+        XCTAssertEqual(dict["a"], 2)
+        
+        // Remove via subscript
+        dict["a"] = nil
+        XCTAssertNil(dict["a"])
+        XCTAssertTrue(dict.isEmpty)
+    }
+    
+    func testDefaultSubscript() {
+        let dict = ThreadSafeDictionary<String, Int>()
+        
+        // Read with default
+        XCTAssertEqual(dict["a", default: 0], 0)
+        
+        // Write with default (modify)
+        dict["a", default: 0] += 1
+        XCTAssertEqual(dict["a"], 1)
+    }
+    
+    func testUpdateValue() {
+        let dict = ThreadSafeDictionary<String, Int>()
+        
+        // Insert new
+        let oldVal1 = dict.updateValue(1, forKey: "a")
+        XCTAssertNil(oldVal1)
+        XCTAssertEqual(dict["a"], 1)
+        
+        // Update existing
+        let oldVal2 = dict.updateValue(2, forKey: "a")
+        XCTAssertEqual(oldVal2, 1)
+        XCTAssertEqual(dict["a"], 2)
+    }
+    
+    func testRemoveValue() {
+        let dict = ThreadSafeDictionary(["a": 1])
+        
+        let removed = dict.removeValue(forKey: "a")
+        XCTAssertEqual(removed, 1)
+        XCTAssertTrue(dict.isEmpty)
+        
+        let notFound = dict.removeValue(forKey: "b")
+        XCTAssertNil(notFound)
+    }
+    
+    func testProperties() {
+        let dict = ThreadSafeDictionary(["a": 1, "b": 2])
+        
+        XCTAssertEqual(dict.all.count, 2)
+        XCTAssertEqual(dict.keys.sorted(), ["a", "b"])
+        XCTAssertEqual(dict.values.sorted(), [1, 2])
+        
+        dict.removeAll()
+        XCTAssertTrue(dict.isEmpty)
+    }
+    
+    func testConcurrency() {
+        let dict = ThreadSafeDictionary<Int, Int>()
+        let iterations = 1000
+        let expectation = self.expectation(description: "Concurrent dictionary access")
+        expectation.expectedFulfillmentCount = iterations
+        
+        DispatchQueue.concurrentPerform(iterations: iterations) { i in
+            dict[i] = i
+            expectation.fulfill()
+        }
+        
+        waitForExpectations(timeout: 5.0)
+        
+        XCTAssertEqual(dict.count, iterations)
+    }
+    
+    func testReadWriteBlock() {
+        let dict = ThreadSafeDictionary(["a": 1, "b": 2])
+        
+        // Write block
+        dict.write { items in
+            items["c"] = 3
+        }
+        
+        XCTAssertEqual(dict.count, 3)
+        
+        // Read block
+        let keys = dict.read { Array($0.keys).sorted() }
+        XCTAssertEqual(keys, ["a", "b", "c"])
+    }
+}

Tests/DesignAlgorithmsKitTests/Structural/ThreadSafeTests.swift

@@ -0,0 +1,39 @@
+import XCTest
+@testable import DesignAlgorithmsKit
+
+final class ThreadSafeTests: XCTestCase {
+    
+    func testInitialization() {
+        let safeInt = ThreadSafe(0)
+        XCTAssertEqual(safeInt.read { $0 }, 0)
+    }
+    
+    func testReadWrite() {
+        let safeInt = ThreadSafe(0)
+        
+        // Write
+        safeInt.write { $0 = 10 }
+        
+        // Read
+        let val = safeInt.read { $0 }
+        XCTAssertEqual(val, 10)
+    }
+    
+    func testConcurrency() {
+        let safeCounter = ThreadSafe(0)
+        let iterations = 1000
+        let expectation = self.expectation(description: "Concurrent increment")
+        expectation.expectedFulfillmentCount = iterations
+        
+        DispatchQueue.concurrentPerform(iterations: iterations) { i in
+            safeCounter.write { $0 += 1 }
+            expectation.fulfill()
+        }
+        
+        waitForExpectations(timeout: 5.0)
+        
+        XCTAssertEqual(safeCounter.read { $0 }, iterations)
+    }
+    
+
+}