Add unit tests for Singleton, Adapter, Facade, and HashAlgorithm

- Add SingletonTests.swift with tests for ThreadSafeSingleton and ActorSingleton
- Add AdapterTests.swift with comprehensive adapter pattern tests
- Add FacadeTests.swift with facade pattern tests including async support
- Add HashAlgorithmTests.swift with SHA-256 hash algorithm tests

Author: rickhohler

Tests/DesignAlgorithmsKitTests/Algorithms/HashAlgorithmTests.swift

@@ -0,0 +1,167 @@
+//
+//  HashAlgorithmTests.swift
+//  DesignAlgorithmsKitTests
+//
+//  Unit tests for Hash Algorithm
+//
+
+import XCTest
+@testable import DesignAlgorithmsKit
+
+final class HashAlgorithmTests: XCTestCase {
+    
+    // MARK: - SHA256 Tests
+    
+    func testSHA256Name() {
+        // Then
+        XCTAssertEqual(SHA256.name, "SHA-256")
+    }
+    
+    func testSHA256HashData() {
+        // Given
+        let data = "Hello, World!".data(using: .utf8)!
+        
+        // When
+        let hash1 = SHA256.hash(data: data)
+        let hash2 = SHA256.hash(data: data)
+        
+        // Then
+        XCTAssertEqual(hash1.count, 32, "SHA-256 should produce 32 bytes")
+        XCTAssertEqual(hash2.count, 32, "SHA-256 should produce 32 bytes")
+        XCTAssertEqual(hash1, hash2, "Same input should produce same hash")
+    }
+    
+    func testSHA256HashString() {
+        // Given
+        let string = "Hello, World!"
+        
+        // When
+        let hash1 = SHA256.hash(string: string)
+        let hash2 = SHA256.hash(string: string)
+        
+        // Then
+        XCTAssertEqual(hash1.count, 32, "SHA-256 should produce 32 bytes")
+        XCTAssertEqual(hash2.count, 32, "SHA-256 should produce 32 bytes")
+        XCTAssertEqual(hash1, hash2, "Same input should produce same hash")
+    }
+    
+    func testSHA256HashDifferentInputs() {
+        // Given
+        let data1 = "Hello".data(using: .utf8)!
+        let data2 = "World".data(using: .utf8)!
+        
+        // When
+        let hash1 = SHA256.hash(data: data1)
+        let hash2 = SHA256.hash(data: data2)
+        
+        // Then
+        XCTAssertNotEqual(hash1, hash2, "Different inputs should produce different hashes")
+    }
+    
+    func testSHA256HashEmptyData() {
+        // Given
+        let emptyData = Data()
+        
+        // When
+        let hash = SHA256.hash(data: emptyData)
+        
+        // Then
+        XCTAssertEqual(hash.count, 32, "Empty data should still produce 32-byte hash")
+    }
+    
+    func testSHA256HashEmptyString() {
+        // Given
+        let emptyString = ""
+        
+        // When
+        let hash = SHA256.hash(string: emptyString)
+        
+        // Then
+        XCTAssertEqual(hash.count, 32, "Empty string should still produce 32-byte hash")
+    }
+    
+    func testSHA256HashLargeData() {
+        // Given
+        let largeData = Data(repeating: 0x42, count: 10000)
+        
+        // When
+        let hash = SHA256.hash(data: largeData)
+        
+        // Then
+        XCTAssertEqual(hash.count, 32, "Large data should produce 32-byte hash")
+    }
+    
+    func testSHA256HashConsistency() {
+        // Given
+        let testCases = [
+            "test",
+            "Hello, World!",
+            "1234567890",
+            "The quick brown fox jumps over the lazy dog",
+            "Special chars: !@#$%^&*()",
+            "Unicode: 🚀🌟✨",
+            "Multi\nline\nstring"
+        ]
+        
+        // When/Then
+        for testCase in testCases {
+            let hash1 = SHA256.hash(string: testCase)
+            let hash2 = SHA256.hash(string: testCase)
+            XCTAssertEqual(hash1, hash2, "Hash should be consistent for: \(testCase)")
+            XCTAssertEqual(hash1.count, 32, "Hash should be 32 bytes for: \(testCase)")
+        }
+    }
+    
+    func testSHA256HashUnicodeString() {
+        // Given
+        let unicodeStrings = [
+            "Hello, 世界",
+            "مرحبا",
+            "Здравствуй",
+            "こんにちは",
+            "🚀🌟✨"
+        ]
+        
+        // When/Then
+        for string in unicodeStrings {
+            let hash = SHA256.hash(string: string)
+            XCTAssertEqual(hash.count, 32, "Unicode string should produce 32-byte hash: \(string)")
+        }
+    }
+    
+    // MARK: - HashAlgorithm Protocol Tests
+    
+    func testHashAlgorithmProtocolConformance() {
+        // Then
+        XCTAssertEqual(SHA256.name, "SHA-256")
+        
+        let testData = "test".data(using: .utf8)!
+        let hash = SHA256.hash(data: testData)
+        XCTAssertEqual(hash.count, 32)
+    }
+    
+    func testHashAlgorithmStringExtension() {
+        // Given
+        let string = "test string"
+        
+        // When
+        let hashFromString = SHA256.hash(string: string)
+        let hashFromData = SHA256.hash(data: string.data(using: .utf8)!)
+        
+        // Then
+        XCTAssertEqual(hashFromString, hashFromData, "String extension should produce same hash as data")
+    }
+    
+    func testHashAlgorithmInvalidUTF8() {
+        // Given
+        // Create data that can't be converted to UTF-8 string
+        let invalidUTF8Data = Data([0xFF, 0xFE, 0xFD])
+        
+        // When
+        let hash = SHA256.hash(data: invalidUTF8Data)
+        
+        // Then
+        XCTAssertEqual(hash.count, 32, "Invalid UTF-8 data should still produce hash")
+    }
+}
+

Tests/DesignAlgorithmsKitTests/Creational/SingletonTests.swift

@@ -0,0 +1,206 @@
+//
+//  SingletonTests.swift
+//  DesignAlgorithmsKitTests
+//
+//  Unit tests for Singleton Pattern
+//
+
+import XCTest
+@testable import DesignAlgorithmsKit
+
+final class SingletonTests: XCTestCase {
+    
+    // MARK: - ThreadSafeSingleton Tests
+    
+    func testThreadSafeSingletonSingleInstance() {
+        // Given - Using a unique class name to avoid static storage conflicts
+        class UniqueTestSingleton1: ThreadSafeSingleton {
+            var value: String = "initial"
+            
+            private override init() {
+                super.init()
+            }
+            
+            override class func createShared() -> Self {
+                // Use a unique static storage per class
+                struct StaticStorage {
+                    static var instance: UniqueTestSingleton1?
+                }
+                if StaticStorage.instance == nil {
+                    StaticStorage.instance = UniqueTestSingleton1()
+                }
+                return StaticStorage.instance! as! Self
+            }
+        }
+        
+        // When
+        let instance1 = UniqueTestSingleton1.shared
+        let instance2 = UniqueTestSingleton1.shared
+        
+        // Then
+        XCTAssertTrue(instance1 === instance2, "Should return the same instance")
+        XCTAssertEqual(instance1.value, "initial")
+    }
+    
+    func testThreadSafeSingletonThreadSafety() {
+        // Given
+        class TestSingleton: ThreadSafeSingleton {
+            var counter: Int = 0
+            
+            private override init() {
+                super.init()
+            }
+            
+            override class func createShared() -> Self {
+                return TestSingleton() as! Self
+            }
+            
+            func increment() {
+                counter += 1
+            }
+        }
+        
+        // When - Access from multiple threads
+        let expectation = expectation(description: "Thread safety test")
+        expectation.expectedFulfillmentCount = 10
+        
+        for _ in 0..<10 {
+            DispatchQueue.global().async {
+                let instance = TestSingleton.shared
+                instance.increment()
+                expectation.fulfill()
+            }
+        }
+        
+        waitForExpectations(timeout: 2.0)
+        
+        // Then - Should still be the same instance
+        let instance1 = TestSingleton.shared
+        let instance2 = TestSingleton.shared
+        XCTAssertTrue(instance1 === instance2, "Should return the same instance across threads")
+    }
+    
+    func testThreadSafeSingletonState() {
+        // Given
+        class TestSingleton: ThreadSafeSingleton {
+            var state: String = "initial"
+            
+            private override init() {
+                super.init()
+            }
+            
+            override class func createShared() -> Self {
+                return TestSingleton() as! Self
+            }
+        }
+        
+        // When
+        let instance = TestSingleton.shared
+        instance.state = "modified"
+        
+        // Then
+        let instance2 = TestSingleton.shared
+        XCTAssertEqual(instance2.state, "modified", "State should persist across accesses")
+    }
+    
+    func testThreadSafeSingletonSubclass() {
+        // Given
+        class BaseSingleton: ThreadSafeSingleton {
+            var baseValue: String = "base"
+            
+            private override init() {
+                super.init()
+            }
+            
+            override class func createShared() -> Self {
+                return BaseSingleton() as! Self
+            }
+        }
+        
+        class DerivedSingleton: ThreadSafeSingleton {
+            var derivedValue: String = "derived"
+            
+            private override init() {
+                super.init()
+            }
+            
+            override class func createShared() -> Self {
+                return DerivedSingleton() as! Self
+            }
+        }
+        
+        // When
+        let base = BaseSingleton.shared
+        let derived = DerivedSingleton.shared
+        
+        // Then
+        XCTAssertNotNil(base)
+        XCTAssertNotNil(derived)
+        XCTAssertTrue(type(of: base) == BaseSingleton.self)
+        XCTAssertTrue(type(of: derived) == DerivedSingleton.self)
+    }
+    
+    // MARK: - Singleton Protocol Tests
+    
+    func testSingletonProtocol() {
+        // Given
+        class ProtocolSingleton: ThreadSafeSingleton, Singleton {
+            private override init() {
+                super.init()
+            }
+            
+            override class func createShared() -> Self {
+                return ProtocolSingleton() as! Self
+            }
+        }
+        
+        // When
+        let instance1 = ProtocolSingleton.shared
+        let instance2 = ProtocolSingleton.shared
+        
+        // Then
+        XCTAssertTrue(instance1 === instance2, "Should conform to Singleton protocol")
+    }
+    
+    // MARK: - ActorSingleton Protocol Tests
+    
+    @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+    func testActorSingletonProtocol() {
+        // Given
+        actor TestActorSingleton: ActorSingleton {
+            static let shared = TestActorSingleton()
+            
+            private init() {}
+            
+            var value: String = "initial"
+            
+            func setValue(_ newValue: String) {
+                value = newValue
+            }
+            
+            func getValue() -> String {
+                return value
+            }
+        }
+        
+        // When/Then
+        let expectation = expectation(description: "Actor singleton test")
+        
+        Task {
+            let instance1 = TestActorSingleton.shared
+            let instance2 = TestActorSingleton.shared
+            
+            await instance1.setValue("modified")
+            let value1 = await instance1.getValue()
+            let value2 = await instance2.getValue()
+            
+            XCTAssertEqual(value1, "modified")
+            XCTAssertEqual(value2, "modified", "Actor singleton should share state")
+            
+            expectation.fulfill()
+        }
+        
+        waitForExpectations(timeout: 2.0)
+    }
+}
+