From 560dd68c6bc32a0321597aca329d7a363858c343 Mon Sep 17 00:00:00 2001
From: Rick Hohler <rick.hohler@gmail.com>
Date: Fri, 12 Dec 2025 22:05:30 -0600
Subject: [PATCH 1/2] test: Deepen unit tests for Observer and Strategy
 patterns

---
 .../Behavioral/ObserverTests.swift            | 133 ++++++++++++++++--
 .../Behavioral/StrategyTests.swift            | 130 ++++++++---------
 2 files changed, 178 insertions(+), 85 deletions(-)

diff --git a/Tests/DesignAlgorithmsKitTests/Behavioral/ObserverTests.swift b/Tests/DesignAlgorithmsKitTests/Behavioral/ObserverTests.swift
index b6b5073..93aa426 100644
--- a/Tests/DesignAlgorithmsKitTests/Behavioral/ObserverTests.swift
+++ b/Tests/DesignAlgorithmsKitTests/Behavioral/ObserverTests.swift
@@ -1,14 +1,10 @@
-//
-//  ObserverTests.swift
-//  DesignAlgorithmsKitTests
-//
-//  Unit tests for Observer Pattern
-//
-
 import XCTest
 @testable import DesignAlgorithmsKit
 
 final class ObserverTests: XCTestCase {
+    
+    // MARK: - Basic Functionality
+    
     func testObserverPattern() {
         // Given
         class TestObservable: BaseObservable {}
@@ -66,9 +62,7 @@ final class ObserverTests: XCTestCase {
             let id: String
             var receivedEvents: [Any] = []
             
-            init(id: String) {
-                self.id = id
-            }
+            init(id: String) { self.id = id }
             
             func didReceiveNotification(from observable: any Observable, event: Any) {
                 receivedEvents.append(event)
@@ -88,5 +82,122 @@ final class ObserverTests: XCTestCase {
         XCTAssertEqual(observer1.receivedEvents.count, 1)
         XCTAssertEqual(observer2.receivedEvents.count, 1)
     }
+    
+    // MARK: - Weak Reference Tests
+    
+    func testWeakReference() {
+        class TestObservable: BaseObservable {}
+        class TestObserver: Observer {
+            func didReceiveNotification(from observable: any Observable, event: Any) {}
+        }
+        
+        let observable = TestObservable()
+        
+        // Create an observer in a local scope so it gets deallocated
+        var observer: TestObserver? = TestObserver()
+        weak var weakObserver = observer
+        
+        observable.addObserver(observer!)
+        XCTAssertNotNil(weakObserver)
+        
+        // Remove strong reference
+        observer = nil
+        
+        // Verify deallocation
+        XCTAssertNil(weakObserver, "Observer should have been deallocated")
+        
+        // Verify notification doesn't crash
+        observable.notifyObservers(event: "test")
+        
+        // Verify cleanup on next add
+        // The implementation cleans up on addObserver
+        observable.addObserver(TestObserver())
+        // Cannot easily inspect internal array count without reflection or subclassing exposing it,
+        // but 'addObserver' is the trigger for cleanup in BaseObservable.
+    }
+    
+    // MARK: - Reentrancy and Concurrency
+    
+    func testReentrancySafe() {
+        // Test removing self during notification
+        class TestObservable: BaseObservable {}
+        class TestObserver: Observer {
+            var observable: TestObservable?
+            var receivedCount = 0
+            
+            func didReceiveNotification(from observable: any Observable, event: Any) {
+                receivedCount += 1
+                if let obs = self.observable {
+                    obs.removeObserver(self)
+                }
+            }
+        }
+        
+        let observable = TestObservable()
+        let observer = TestObserver()
+        observer.observable = observable
+        
+        observable.addObserver(observer)
+        
+        // First notification triggers removal
+        observable.notifyObservers(event: "1")
+        XCTAssertEqual(observer.receivedCount, 1)
+        
+        // Second notification should not reach observer
+        observable.notifyObservers(event: "2")
+        XCTAssertEqual(observer.receivedCount, 1)
+    }
+    
+    func testConcurrentAccess() {
+        class TestObservable: BaseObservable {}
+        class TestObserver: Observer {
+            func didReceiveNotification(from observable: any Observable, event: Any) {
+                // Do work
+            }
+        }
+        
+        let observable = TestObservable()
+        let iterations = 1000
+        let expectation = self.expectation(description: "Concurrent observer access")
+        expectation.expectedFulfillmentCount = iterations
+        
+        DispatchQueue.concurrentPerform(iterations: iterations) { i in
+            let observer = TestObserver()
+            observable.addObserver(observer)
+            
+            if i % 2 == 0 {
+                observable.notifyObservers(event: i)
+            }
+            
+            if i % 3 == 0 {
+                observable.removeObserver(observer)
+            }
+            
+            expectation.fulfill()
+        }
+        
+        waitForExpectations(timeout: 5.0)
+    }
+    
+    func testDuplicateAddition() {
+        class TestObservable: BaseObservable {}
+        class TestObserver: Observer {
+            var count = 0
+            func didReceiveNotification(from observable: any Observable, event: Any) {
+                count += 1
+            }
+        }
+        
+        let observable = TestObservable()
+        let observer = TestObserver()
+        
+        // Add twice
+        observable.addObserver(observer)
+        observable.addObserver(observer)
+        
+        observable.notifyObservers(event: "test")
+        
+        // Should only be notified once
+        XCTAssertEqual(observer.count, 1)
+    }
 }
-
diff --git a/Tests/DesignAlgorithmsKitTests/Behavioral/StrategyTests.swift b/Tests/DesignAlgorithmsKitTests/Behavioral/StrategyTests.swift
index 1cb6c90..33157ac 100644
--- a/Tests/DesignAlgorithmsKitTests/Behavioral/StrategyTests.swift
+++ b/Tests/DesignAlgorithmsKitTests/Behavioral/StrategyTests.swift
@@ -1,30 +1,20 @@
-//
-//  StrategyTests.swift
-//  DesignAlgorithmsKitTests
-//
-//  Unit tests for Strategy Pattern
-//
-
 import XCTest
 @testable import DesignAlgorithmsKit
 
 final class StrategyTests: XCTestCase {
+    
+    // MARK: - Basic Implementation
+    
     func testStrategyPattern() {
         // Given
         struct AdditionStrategy: Strategy {
             let strategyID = "addition"
-            
-            func execute(_ a: Int, _ b: Int) -> Int {
-                return a + b
-            }
+            func execute(_ a: Int, _ b: Int) -> Int { return a + b }
         }
         
         struct MultiplicationStrategy: Strategy {
             let strategyID = "multiplication"
-            
-            func execute(_ a: Int, _ b: Int) -> Int {
-                return a * b
-            }
+            func execute(_ a: Int, _ b: Int) -> Int { return a * b }
         }
         
         // When
@@ -39,92 +29,84 @@ final class StrategyTests: XCTestCase {
         XCTAssertEqual(result2, 15)
     }
     
-    func testStrategyContext() {
-        // Given
-        struct TestStrategy: Strategy {
-            let strategyID = "test"
-        }
-        
-        // When
-        let context = StrategyContext(strategy: TestStrategy())
-        
-        // Then
-        XCTAssertEqual(context.getStrategy().strategyID, "test")
-    }
-    
-    func testStrategyContextSetStrategy() {
+    func testContextSwitching() {
         // Given
         struct TestStrategy: Strategy {
             let strategyID: String
+            let val: Int
         }
         
-        // When
-        let context = StrategyContext(strategy: TestStrategy(strategyID: "strategy1"))
-        XCTAssertEqual(context.getStrategy().strategyID, "strategy1")
+        let s1 = TestStrategy(strategyID: "s1", val: 1)
+        let s2 = TestStrategy(strategyID: "s2", val: 2)
         
-        context.setStrategy(TestStrategy(strategyID: "strategy2"))
+        let context = StrategyContext(strategy: s1)
+        XCTAssertEqual(context.getStrategy().val, 1)
         
-        // Then
-        XCTAssertEqual(context.getStrategy().strategyID, "strategy2")
+        context.setStrategy(s2)
+        XCTAssertEqual(context.getStrategy().val, 2)
+        
+        context.setStrategy(s1)
+        XCTAssertEqual(context.getStrategy().val, 1)
     }
     
+    // MARK: - Inheritance and Types
+    
     func testBaseStrategy() {
-        // Given
         let baseStrategy = BaseStrategy(strategyID: "base-test")
-        
-        // Then
         XCTAssertEqual(baseStrategy.strategyID, "base-test")
     }
     
     func testBaseStrategyInheritance() {
-        // Given
         class CustomStrategy: BaseStrategy {
-            init() {
-                super.init(strategyID: "custom")
-            }
+            init() { super.init(strategyID: "custom") }
+            func op() -> String { return "op" }
         }
         
-        // When
         let strategy = CustomStrategy()
-        
-        // Then
         XCTAssertEqual(strategy.strategyID, "custom")
+        XCTAssertEqual(strategy.op(), "op")
     }
     
-    func testStrategyContextGetStrategy() {
-        // Given
-        struct TestStrategy: Strategy {
-            let strategyID = "test"
-        }
-        
-        let context = StrategyContext(strategy: TestStrategy())
+    // MARK: - Polymorphism
+    
+    protocol MathStrategy: Strategy {
+        func calculate(_ a: Int, _ b: Int) -> Int
+    }
+    
+    struct Add: MathStrategy {
+        var strategyID = "add"
+        func calculate(_ a: Int, _ b: Int) -> Int { a + b }
+    }
+    
+    struct Subtract: MathStrategy {
+        var strategyID = "subtract"
+        func calculate(_ a: Int, _ b: Int) -> Int { a - b }
+    }
+    
+    func testPolymorphicContext() {
+        let context = StrategyContext<BoxedMathStrategy>(strategy: BoxedMathStrategy(Add()))
         
-        // When
-        let retrievedStrategy = context.getStrategy()
+        XCTAssertEqual(context.getStrategy().calculate(10, 5), 15)
         
-        // Then
-        XCTAssertEqual(retrievedStrategy.strategyID, "test")
+        context.setStrategy(BoxedMathStrategy(Subtract()))
+        XCTAssertEqual(context.getStrategy().calculate(10, 5), 5)
     }
     
-    func testStrategyContextMultipleStrategies() {
-        // Given
-        struct TestStrategy: Strategy {
-            let strategyID: String
+    // Type erasure wrapper for the test because StrategyContext is generic over a specific concrete type
+    // or a protocol if used as an existentials (but StrategyContext<P> requires P: Strategy).
+    // Protocols conforming to protocols don't satisfy P: Strategy for generic constraints in Swift 
+    // without `any` or box, testing here verifies the usage pattern.
+    struct BoxedMathStrategy: MathStrategy {
+        let strategyID: String
+        private let _calculate: (Int, Int) -> Int
+        
+        init<S: MathStrategy>(_ strategy: S) {
+            self.strategyID = strategy.strategyID
+            self._calculate = strategy.calculate
         }
         
-        // When
-        let context = StrategyContext(strategy: TestStrategy(strategyID: "strategy1"))
-        context.setStrategy(TestStrategy(strategyID: "strategy2"))
-        
-        // Then
-        XCTAssertEqual(context.getStrategy().strategyID, "strategy2")
-    }
-}
-
-// Extension to make strategies executable for testing
-extension Strategy {
-    func execute(_ a: Int, _ b: Int) -> Int {
-        return 0 // Default implementation
+        func calculate(_ a: Int, _ b: Int) -> Int {
+            _calculate(a, b)
+        }
     }
 }
-

From 4727b6ca2dbd88701f91b382b0884414af1bee6d Mon Sep 17 00:00:00 2001
From: Rick Hohler <rick.hohler@gmail.com>
Date: Fri, 12 Dec 2025 22:22:33 -0600
Subject: [PATCH 2/2] test: Enhance Builder, Factory, Adapter, and Facade unit
 tests

---
 .../Creational/BuilderTests.swift             | 385 ++++++------------
 .../Creational/FactoryTests.swift             | 111 ++---
 .../Structural/AdapterTests.swift             | 163 +++-----
 .../Structural/FacadeTests.swift              | 223 +++-------
 4 files changed, 255 insertions(+), 627 deletions(-)

diff --git a/Tests/DesignAlgorithmsKitTests/Creational/BuilderTests.swift b/Tests/DesignAlgorithmsKitTests/Creational/BuilderTests.swift
index abda4dd..432fe50 100644
--- a/Tests/DesignAlgorithmsKitTests/Creational/BuilderTests.swift
+++ b/Tests/DesignAlgorithmsKitTests/Creational/BuilderTests.swift
@@ -1,14 +1,10 @@
-//
-//  BuilderTests.swift
-//  DesignAlgorithmsKitTests
-//
-//  Unit tests for Builder Pattern
-//
-
 import XCTest
 @testable import DesignAlgorithmsKit
 
 final class BuilderTests: XCTestCase {
+    
+    // MARK: - Basic Builder Pattern
+    
     func testBuilderPattern() throws {
         // Given
         struct TestObject {
@@ -52,12 +48,11 @@ final class BuilderTests: XCTestCase {
         XCTAssertEqual(object.property2, 42)
     }
     
+    // MARK: - Error Handling
+    
     func testBuilderMissingProperty() {
         // Given
-        struct TestObject {
-            let property: String
-        }
-        
+        struct TestObject { let property: String }
         class TestObjectBuilder: BaseBuilder<TestObject> {
             override func build() throws -> TestObject {
                 throw BuilderError.missingRequiredProperty("property")
@@ -76,9 +71,7 @@ final class BuilderTests: XCTestCase {
     
     func testValidatingBuilder() throws {
         // Given
-        struct TestObject {
-            let value: Int
-        }
+        struct TestObject { let value: Int }
         
         class ValidatingBuilder: BaseBuilder<TestObject>, ValidatingBuilderProtocol {
             private var value: Int?
@@ -89,12 +82,8 @@ final class BuilderTests: XCTestCase {
             }
             
             func validate() throws {
-                guard let value = value else {
-                    throw BuilderError.missingRequiredProperty("value")
-                }
-                if value < 0 {
-                    throw BuilderError.invalidValue("value", "must be non-negative")
-                }
+                guard let value = value else { throw BuilderError.missingRequiredProperty("value") }
+                if value < 0 { throw BuilderError.invalidValue("value", "must be non-negative") }
             }
             
             override func build() throws -> TestObject {
@@ -103,30 +92,21 @@ final class BuilderTests: XCTestCase {
             }
         }
         
-        // When/Then - Valid value
-        let object = try ValidatingBuilder()
-            .setValue(42)
-            .build()
+        // When/Then - Valid
+        let object = try ValidatingBuilder().setValue(42).build()
         XCTAssertEqual(object.value, 42)
         
-        // When/Then - Invalid value
+        // When/Then - Invalid
         XCTAssertThrowsError(try ValidatingBuilder().setValue(-1).build())
     }
     
     func testBaseBuilderNotImplemented() {
-        // Given
-        struct TestObject {
-            let value: String
-        }
+        struct TestObject { let value: String }
+        class TestBuilder: BaseBuilder<TestObject> {}
         
-        class TestBuilder: BaseBuilder<TestObject> {
-            // Doesn't override build()
-        }
-        
-        // When/Then
         XCTAssertThrowsError(try TestBuilder().build()) { error in
             if case BuilderError.notImplemented = error {
-                // Expected error
+                // Expected
             } else {
                 XCTFail("Expected BuilderError.notImplemented, got \(error)")
             }
@@ -134,21 +114,32 @@ final class BuilderTests: XCTestCase {
     }
     
     func testBuilderErrorLocalizedDescription() {
-        // Test notImplemented
         let notImplemented = BuilderError.notImplemented
         XCTAssertEqual(notImplemented.localizedDescription, "Builder build() method not implemented")
         
-        // Test missingRequiredProperty
         let missing = BuilderError.missingRequiredProperty("testProperty")
         XCTAssertEqual(missing.localizedDescription, "Required property 'testProperty' is missing")
         
-        // Test invalidValue
         let invalid = BuilderError.invalidValue("testProperty", "must be positive")
         XCTAssertEqual(invalid.localizedDescription, "Invalid value for 'testProperty': must be positive")
     }
     
+    func testBuilderErrorEquality() {
+        // Test that error cases can be matched
+        let error1 = BuilderError.missingRequiredProperty("test")
+        let error2 = BuilderError.missingRequiredProperty("test")
+        
+        if case BuilderError.missingRequiredProperty(let prop1) = error1,
+           case BuilderError.missingRequiredProperty(let prop2) = error2 {
+            XCTAssertEqual(prop1, prop2)
+        } else {
+            XCTFail("Error pattern matching failed")
+        }
+    }
+
+    // MARK: - Advanced Usage
+    
     func testBuilderFluentAPI() throws {
-        // Given
         struct ComplexObject {
             let name: String
             let age: Int
@@ -162,38 +153,19 @@ final class BuilderTests: XCTestCase {
             private var email: String?
             private var tags: [String] = []
             
-            func setName(_ name: String) -> Self {
-                self.name = name
-                return self
-            }
-            
-            func setAge(_ age: Int) -> Self {
-                self.age = age
-                return self
-            }
-            
-            func setEmail(_ email: String?) -> Self {
-                self.email = email
-                return self
-            }
-            
-            func addTag(_ tag: String) -> Self {
-                self.tags.append(tag)
-                return self
-            }
+            func setName(_ name: String) -> Self { self.name = name; return self }
+            func setAge(_ age: Int) -> Self { self.age = age; return self }
+            func setEmail(_ email: String?) -> Self { self.email = email; return self }
+            func addTag(_ tag: String) -> Self { self.tags.append(tag); return self }
             
             override func build() throws -> ComplexObject {
-                guard let name = name else {
-                    throw BuilderError.missingRequiredProperty("name")
-                }
-                guard let age = age else {
-                    throw BuilderError.missingRequiredProperty("age")
-                }
+                guard let name = name else { throw BuilderError.missingRequiredProperty("name") }
+                guard let age = age else { throw BuilderError.missingRequiredProperty("age") }
                 return ComplexObject(name: name, age: age, email: email, tags: tags)
             }
         }
         
-        // When - Test fluent API chaining
+        // Use fluent API
         let object = try ComplexObjectBuilder()
             .setName("John Doe")
             .setAge(30)
@@ -202,15 +174,27 @@ final class BuilderTests: XCTestCase {
             .addTag("swift")
             .build()
         
-        // Then
         XCTAssertEqual(object.name, "John Doe")
         XCTAssertEqual(object.age, 30)
         XCTAssertEqual(object.email, "john@example.com")
         XCTAssertEqual(object.tags, ["developer", "swift"])
+        
+        // Partial configuration test
+        // Verify order independence and state retention
+        let builder = ComplexObjectBuilder()
+        builder.setName("Jane").setAge(25)
+        
+        let object1 = try builder.build()
+        XCTAssertEqual(object1.name, "Jane")
+        
+        // Modify state
+        builder.setName("Jane Doe")
+        let object2 = try builder.build()
+        XCTAssertEqual(object2.name, "Jane Doe")
+        XCTAssertEqual(object2.age, 25) // Age preserved
     }
     
     func testBuilderWithOptionalProperties() throws {
-        // Given
         struct OptionalObject {
             let required: String
             let optional: String?
@@ -220,175 +204,91 @@ final class BuilderTests: XCTestCase {
             private var required: String?
             private var optional: String?
             
-            func setRequired(_ value: String) -> Self {
-                self.required = value
-                return self
-            }
-            
-            func setOptional(_ value: String?) -> Self {
-                self.optional = value
-                return self
-            }
+            func setRequired(_ value: String) -> Self { self.required = value; return self }
+            func setOptional(_ value: String?) -> Self { self.optional = value; return self }
             
             override func build() throws -> OptionalObject {
-                guard let required = required else {
-                    throw BuilderError.missingRequiredProperty("required")
-                }
+                guard let required = required else { throw BuilderError.missingRequiredProperty("required") }
                 return OptionalObject(required: required, optional: optional)
             }
         }
         
-        // When/Then - With optional value
-        let object1 = try OptionalObjectBuilder()
-            .setRequired("required")
-            .setOptional("optional")
-            .build()
-        XCTAssertEqual(object1.required, "required")
-        XCTAssertEqual(object1.optional, "optional")
+        let object1 = try OptionalObjectBuilder().setRequired("req").setOptional("opt").build()
+        XCTAssertEqual(object1.optional, "opt")
         
-        // When/Then - Without optional value
-        let object2 = try OptionalObjectBuilder()
-            .setRequired("required")
-            .setOptional(nil)
-            .build()
-        XCTAssertEqual(object2.required, "required")
+        let object2 = try OptionalObjectBuilder().setRequired("req").setOptional(nil).build()
         XCTAssertNil(object2.optional)
     }
     
     func testBuilderMultipleInstances() throws {
-        // Given
-        struct SimpleObject {
-            let value: String
-        }
-        
+        struct SimpleObject { let value: String }
         class SimpleBuilder: BaseBuilder<SimpleObject> {
             private var value: String?
-            
-            func setValue(_ value: String) -> Self {
-                self.value = value
-                return self
-            }
-            
+            func setValue(_ value: String) -> Self { self.value = value; return self }
             override func build() throws -> SimpleObject {
-                guard let value = value else {
-                    throw BuilderError.missingRequiredProperty("value")
-                }
+                guard let value = value else { throw BuilderError.missingRequiredProperty("value") }
                 return SimpleObject(value: value)
             }
         }
         
-        // When - Create multiple instances
         let builder1 = SimpleBuilder()
         let builder2 = SimpleBuilder()
         
         let object1 = try builder1.setValue("value1").build()
         let object2 = try builder2.setValue("value2").build()
         
-        // Then - Each builder should be independent
         XCTAssertEqual(object1.value, "value1")
         XCTAssertEqual(object2.value, "value2")
     }
     
     func testValidatingBuilderProtocolDefault() throws {
-        // Given
-        struct TestObject {
-            let value: Int
-        }
-        
+        struct TestObject { let value: Int }
         class DefaultValidatingBuilder: BaseBuilder<TestObject>, ValidatingBuilderProtocol {
             private var value: Int?
-            
-            func setValue(_ value: Int) -> Self {
-                self.value = value
-                return self
-            }
-            
+            func setValue(_ value: Int) -> Self { self.value = value; return self }
             override func build() throws -> TestObject {
-                // Explicitly call validate() to ensure default implementation is covered
-                try validate()
-                guard let value = value else {
-                    throw BuilderError.missingRequiredProperty("value")
-                }
+                try validate() // Default does nothing
+                guard let value = value else { throw BuilderError.missingRequiredProperty("value") }
                 return TestObject(value: value)
             }
         }
         
-        // When/Then - Default validation should not throw
-        let object = try DefaultValidatingBuilder()
-            .setValue(42)
-            .build()
+        let object = try DefaultValidatingBuilder().setValue(42).build()
         XCTAssertEqual(object.value, 42)
     }
     
     func testValidatingBuilderProtocolDefaultImplementation() throws {
-        // Given - Test the default validate() implementation directly
-        struct TestObject {
-            let value: String
-        }
-        
+        // Direct test of default implementation
+        struct TestObject { let value: String }
         class DirectValidateBuilder: BaseBuilder<TestObject>, ValidatingBuilderProtocol {
             private var value: String?
-            
-            func setValue(_ value: String) -> Self {
-                self.value = value
-                return self
-            }
-            
+            func setValue(_ value: String) -> Self { self.value = value; return self }
             override func build() throws -> TestObject {
-                // Call validate() explicitly to test default implementation
-                try validate() // Default implementation does nothing
-                guard let value = value else {
-                    throw BuilderError.missingRequiredProperty("value")
-                }
+                try validate()
+                guard let value = value else { throw BuilderError.missingRequiredProperty("value") }
                 return TestObject(value: value)
             }
         }
         
-        // When/Then - Default validate() should not throw
-        let object = try DirectValidateBuilder()
-            .setValue("test")
-            .build()
+        let object = try DirectValidateBuilder().setValue("test").build()
         XCTAssertEqual(object.value, "test")
     }
     
     func testValidatingBuilderWithCustomValidation() throws {
-        // Given
-        struct User {
-            let username: String
-            let age: Int
-        }
+        struct User { let username: String; let age: Int }
         
         class UserBuilder: BaseBuilder<User>, ValidatingBuilderProtocol {
             private var username: String?
             private var age: Int?
             
-            func setUsername(_ username: String) -> Self {
-                self.username = username
-                return self
-            }
-            
-            func setAge(_ age: Int) -> Self {
-                self.age = age
-                return self
-            }
+            func setUsername(_ username: String) -> Self { self.username = username; return self }
+            func setAge(_ age: Int) -> Self { self.age = age; return self }
             
             func validate() throws {
-                guard let username = username else {
-                    throw BuilderError.missingRequiredProperty("username")
-                }
-                if username.count < 3 {
-                    throw BuilderError.invalidValue("username", "must be at least 3 characters")
-                }
-                
-                guard let age = age else {
-                    throw BuilderError.missingRequiredProperty("age")
-                }
-                if age < 0 {
-                    throw BuilderError.invalidValue("age", "must be non-negative")
-                }
-                if age > 150 {
-                    throw BuilderError.invalidValue("age", "must be less than 150")
-                }
+                guard let username = username else { throw BuilderError.missingRequiredProperty("username") }
+                if username.count < 3 { throw BuilderError.invalidValue("username", "curr too short") }
+                guard let age = age else { throw BuilderError.missingRequiredProperty("age") }
+                if age < 0 || age > 150 { throw BuilderError.invalidValue("age", "invalid age") }
             }
             
             override func build() throws -> User {
@@ -397,107 +297,64 @@ final class BuilderTests: XCTestCase {
             }
         }
         
-        // When/Then - Valid user
-        let validUser = try UserBuilder()
-            .setUsername("johndoe")
-            .setAge(30)
-            .build()
-        XCTAssertEqual(validUser.username, "johndoe")
-        XCTAssertEqual(validUser.age, 30)
+        // Happy path
+        let user = try UserBuilder().setUsername("john").setAge(30).build()
+        XCTAssertEqual(user.username, "john")
         
-        // When/Then - Invalid username (too short)
-        XCTAssertThrowsError(try UserBuilder().setUsername("ab").setAge(30).build()) { error in
-            if case BuilderError.invalidValue(let property, _) = error {
-                XCTAssertEqual(property, "username")
-            } else {
-                XCTFail("Expected invalidValue error for username")
-            }
-        }
-        
-        // When/Then - Invalid age (negative)
-        XCTAssertThrowsError(try UserBuilder().setUsername("johndoe").setAge(-1).build()) { error in
-            if case BuilderError.invalidValue(let property, _) = error {
-                XCTAssertEqual(property, "age")
-            } else {
-                XCTFail("Expected invalidValue error for age")
+        // Invalid checks
+        XCTAssertThrowsError(try UserBuilder().setUsername("a").setAge(30).build())
+        XCTAssertThrowsError(try UserBuilder().setUsername("john").setAge(-1).build())
+    }
+    
+    func testBuilderReuse() throws {
+        struct Config { let host: String; let port: Int }
+        class ConfigBuilder: BaseBuilder<Config> {
+            private var host: String?
+            private var port: Int?
+            func setHost(_ host: String) -> Self { self.host = host; return self }
+            func setPort(_ port: Int) -> Self { self.port = port; return self }
+            override func build() throws -> Config {
+                guard let h = host, let p = port else { throw BuilderError.missingRequiredProperty("config") }
+                return Config(host: h, port: p)
             }
         }
         
-        // When/Then - Invalid age (too high)
-        XCTAssertThrowsError(try UserBuilder().setUsername("johndoe").setAge(200).build()) { error in
-            if case BuilderError.invalidValue(let property, _) = error {
-                XCTAssertEqual(property, "age")
-            } else {
-                XCTFail("Expected invalidValue error for age")
-            }
-        }
-    }
-    
-    func testBuilderErrorEquality() {
-        // Test that error cases can be matched
-        let error1 = BuilderError.missingRequiredProperty("test")
-        let error2 = BuilderError.missingRequiredProperty("test")
+        let builder = ConfigBuilder()
+        let c1 = try builder.setHost("h1").setPort(1).build()
+        XCTAssertEqual(c1.host, "h1")
         
-        // Use pattern matching to verify
-        if case BuilderError.missingRequiredProperty(let prop1) = error1,
-           case BuilderError.missingRequiredProperty(let prop2) = error2 {
-            XCTAssertEqual(prop1, prop2)
-        } else {
-            XCTFail("Error pattern matching failed")
-        }
+        // Reuse
+        let c2 = try builder.setPort(2).build()
+        XCTAssertEqual(c2.host, "h1") // Host persisted
+        XCTAssertEqual(c2.port, 2)
     }
     
-    func testBuilderReuse() throws {
+    func testChainedOrderIndependence() throws {
         // Given
-        struct Config {
-            let host: String
-            let port: Int
+        struct Style {
+            let color: String
+            let size: Int
         }
         
-        class ConfigBuilder: BaseBuilder<Config> {
-            private var host: String?
-            private var port: Int?
+        class StyleBuilder: BaseBuilder<Style> {
+            private var color: String?
+            private var size: Int?
             
-            func setHost(_ host: String) -> Self {
-                self.host = host
-                return self
-            }
+            func setColor(_ c: String) -> Self { self.color = c; return self }
+            func setSize(_ s: Int) -> Self { self.size = s; return self }
             
-            func setPort(_ port: Int) -> Self {
-                self.port = port
-                return self
-            }
-            
-            override func build() throws -> Config {
-                guard let host = host else {
-                    throw BuilderError.missingRequiredProperty("host")
-                }
-                guard let port = port else {
-                    throw BuilderError.missingRequiredProperty("port")
-                }
-                return Config(host: host, port: port)
+            override func build() throws -> Style {
+                guard let c = color, let s = size else { throw BuilderError.missingRequiredProperty("style") }
+                return Style(color: c, size: s)
             }
         }
         
-        // When - Reuse builder instance
-        let builder = ConfigBuilder()
-        
-        let config1 = try builder
-            .setHost("localhost")
-            .setPort(8080)
-            .build()
-        
-        // Reset and build again
-        let config2 = try builder
-            .setHost("example.com")
-            .setPort(443)
-            .build()
+        // When
+        let s1 = try StyleBuilder().setColor("Red").setSize(10).build()
+        let s2 = try StyleBuilder().setSize(10).setColor("Red").build()
         
-        // Then - Last values should be used
-        XCTAssertEqual(config1.host, "localhost")
-        XCTAssertEqual(config1.port, 8080)
-        XCTAssertEqual(config2.host, "example.com")
-        XCTAssertEqual(config2.port, 443)
+        // Then
+        XCTAssertEqual(s1.color, s2.color)
+        XCTAssertEqual(s1.size, s2.size)
     }
 }
-
diff --git a/Tests/DesignAlgorithmsKitTests/Creational/FactoryTests.swift b/Tests/DesignAlgorithmsKitTests/Creational/FactoryTests.swift
index 7b352c3..28b31e1 100644
--- a/Tests/DesignAlgorithmsKitTests/Creational/FactoryTests.swift
+++ b/Tests/DesignAlgorithmsKitTests/Creational/FactoryTests.swift
@@ -1,10 +1,3 @@
-//
-//  FactoryTests.swift
-//  DesignAlgorithmsKitTests
-//
-//  Unit tests for Factory Pattern
-//
-
 import XCTest
 @testable import DesignAlgorithmsKit
 
@@ -22,47 +15,29 @@ final class FactoryTests: XCTestCase {
         super.tearDown()
     }
     
+    // MARK: - Registration and Creation
+    
     func testRegisterFactory() {
-        // Given
         let type = "test"
-        
-        // When
-        factory.register(type: type) { config in
-            return "created"
-        }
-        
-        // Then
+        factory.register(type: type) { _ in "created" }
         XCTAssertTrue(factory.isRegistered(type: type))
     }
     
     func testCreateObject() throws {
-        // Given
-        factory.register(type: "test") { config in
-            return "created"
-        }
-        
-        // When
+        factory.register(type: "test") { _ in "created" }
         let result = try factory.create(type: "test", configuration: [:])
-        
-        // Then
         XCTAssertEqual(result as? String, "created")
     }
     
     func testCreateWithConfiguration() throws {
-        // Given
         factory.register(type: "test") { config in
             return config["value"] as? String ?? "default"
         }
-        
-        // When
         let result = try factory.create(type: "test", configuration: ["value": "custom"])
-        
-        // Then
         XCTAssertEqual(result as? String, "custom")
     }
     
     func testCreateNonExistentType() {
-        // When/Then
         XCTAssertThrowsError(try factory.create(type: "nonexistent", configuration: [:])) { error in
             if case FactoryError.typeNotRegistered(let type) = error {
                 XCTAssertEqual(type, "nonexistent")
@@ -72,54 +47,44 @@ final class FactoryTests: XCTestCase {
         }
     }
     
+    // MARK: - FactoryProduct Protocol
+    
     func testRegisterFactoryProduct() throws {
-        // Given
         struct TestProduct: FactoryProduct {
             let value: String
-            
             init(configuration: [String: Any]) throws {
                 self.value = configuration["value"] as? String ?? "default"
             }
         }
         
-        // When
         factory.register(TestProduct.self, key: "test")
-        
-        // Then
         let result = try factory.create(type: "test", configuration: ["value": "custom"])
         XCTAssertTrue(result is TestProduct)
         XCTAssertEqual((result as? TestProduct)?.value, "custom")
     }
     
     func testRegisterFactoryProductWithoutKey() throws {
-        // Given
         struct TestProduct: FactoryProduct {
             let value: String
-            
             init(configuration: [String: Any]) throws {
                 self.value = configuration["value"] as? String ?? "default"
             }
         }
         
-        // When - Register without explicit key (uses type name)
         factory.register(TestProduct.self)
-        
-        // Then - Should be registered with type name
         let typeName = String(describing: TestProduct.self)
         XCTAssertTrue(factory.isRegistered(type: typeName))
         
-        // And should be able to create
         let result = try factory.create(type: typeName, configuration: ["value": "test"])
         XCTAssertTrue(result is TestProduct)
-        XCTAssertEqual((result as? TestProduct)?.value, "test")
     }
     
+    // MARK: - Errors
+    
     func testFactoryErrorLocalizedDescription() {
-        // Test typeNotRegistered
         let notRegistered = FactoryError.typeNotRegistered("testType")
         XCTAssertEqual(notRegistered.localizedDescription, "Factory type 'testType' is not registered")
         
-        // Test creationFailed
         let creationError = NSError(domain: "test", code: 1, userInfo: [NSLocalizedDescriptionKey: "Test error"])
         let creationFailed = FactoryError.creationFailed("testType", creationError)
         XCTAssertTrue(creationFailed.localizedDescription.contains("Failed to create 'testType'"))
@@ -127,7 +92,6 @@ final class FactoryTests: XCTestCase {
     }
     
     func testFactoryCreationFailed() {
-        // Given
         struct FailingProduct: FactoryProduct {
             init(configuration: [String: Any]) throws {
                 throw NSError(domain: "test", code: 1, userInfo: [NSLocalizedDescriptionKey: "Creation failed"])
@@ -135,52 +99,31 @@ final class FactoryTests: XCTestCase {
         }
         
         factory.register(FailingProduct.self, key: "failing")
-        
-        // When/Then
-        XCTAssertThrowsError(try factory.create(type: "failing", configuration: [:])) { error in
-            // The error should be the underlying error, not FactoryError.creationFailed
-            // because the factory doesn't wrap errors
-            XCTAssertNotNil(error)
-        }
+        XCTAssertThrowsError(try factory.create(type: "failing", configuration: [:]))
     }
     
     func testFactoryIsRegistered() {
-        // Given
         XCTAssertFalse(factory.isRegistered(type: "nonexistent"))
-        
-        // When
         factory.register(type: "test") { _ in "test" }
-        
-        // Then
         XCTAssertTrue(factory.isRegistered(type: "test"))
-        XCTAssertFalse(factory.isRegistered(type: "nonexistent"))
     }
     
     func testFactoryClear() {
-        // Given
         factory.register(type: "test1") { _ in "test1" }
         factory.register(type: "test2") { _ in "test2" }
-        XCTAssertTrue(factory.isRegistered(type: "test1"))
-        XCTAssertTrue(factory.isRegistered(type: "test2"))
-        
-        // When
         factory.clear()
-        
-        // Then
         XCTAssertFalse(factory.isRegistered(type: "test1"))
         XCTAssertFalse(factory.isRegistered(type: "test2"))
     }
     
+    // MARK: - Concurrency
+    
     @MainActor
-    func testFactoryThreadSafety() {
-        // Given
-        let expectation = expectation(description: "Thread safety test")
+    func testFactoryRegistrationThreadSafety() {
+        let expectation = expectation(description: "Registration thread safety")
         expectation.expectedFulfillmentCount = 10
-        
-        // Capture factory strongly to avoid capturing self in the closure
         let testFactory = self.factory!
         
-        // When - Register from multiple threads
         for i in 0..<10 {
             DispatchQueue.global().async {
                 testFactory.register(type: "type\(i)") { _ in "value\(i)" }
@@ -189,11 +132,33 @@ final class FactoryTests: XCTestCase {
         }
         
         waitForExpectations(timeout: 2.0)
-        
-        // Then - All should be registered
         for i in 0..<10 {
             XCTAssertTrue(factory.isRegistered(type: "type\(i)"))
         }
     }
+    
+    @MainActor
+    func testFactoryCreationThreadSafety() {
+        let expectation = expectation(description: "Creation thread safety")
+        expectation.expectedFulfillmentCount = 100
+        let testFactory = self.factory!
+        
+        // Register first
+        testFactory.register(type: "concurrent") { _ in "item" }
+        
+        // Create concurrently
+        for _ in 0..<100 {
+            DispatchQueue.global().async {
+                do {
+                    let item = try testFactory.create(type: "concurrent", configuration: [:])
+                    XCTAssertEqual(item as? String, "item")
+                } catch {
+                    XCTFail("Concurrent creation failed: \(error)")
+                }
+                expectation.fulfill()
+            }
+        }
+        
+        waitForExpectations(timeout: 2.0)
+    }
 }
-
diff --git a/Tests/DesignAlgorithmsKitTests/Structural/AdapterTests.swift b/Tests/DesignAlgorithmsKitTests/Structural/AdapterTests.swift
index fb09b19..f58cbcf 100644
--- a/Tests/DesignAlgorithmsKitTests/Structural/AdapterTests.swift
+++ b/Tests/DesignAlgorithmsKitTests/Structural/AdapterTests.swift
@@ -1,10 +1,3 @@
-//
-//  AdapterTests.swift
-//  DesignAlgorithmsKitTests
-//
-//  Unit tests for Adapter Pattern
-//
-
 import XCTest
 @testable import DesignAlgorithmsKit
 
@@ -13,21 +6,13 @@ final class AdapterTests: XCTestCase {
     // MARK: - BaseAdapter Tests
     
     func testBaseAdapterInitialization() {
-        // Given
         let adapterID = "testAdapter"
-        
-        // When
         let adapter = BaseAdapter(adapterID: adapterID)
-        
-        // Then
         XCTAssertEqual(adapter.adapterID, adapterID)
     }
     
     func testBaseAdapterCanHandleDefault() {
-        // Given
         let adapter = BaseAdapter(adapterID: "test")
-        
-        // When/Then
         XCTAssertFalse(adapter.canHandle("test"), "Base adapter should return false by default")
         XCTAssertFalse(adapter.canHandle(42), "Base adapter should return false by default")
     }
@@ -35,163 +20,107 @@ final class AdapterTests: XCTestCase {
     // MARK: - Adapter Pattern Implementation Tests
     
     func testAdapterPattern() {
-        // Given
-        protocol Target {
-            func request() -> String
-        }
-        
-        class Adaptee {
-            func specificRequest() -> String {
-                return "Adaptee"
-            }
-        }
+        protocol Target { func request() -> String }
+        class Adaptee { func specificRequest() -> String { return "Adaptee" } }
         
         class AdapteeAdapter: BaseAdapter, Target {
             private let adaptee: Adaptee
-            
             init(adaptee: Adaptee) {
                 self.adaptee = adaptee
                 super.init(adapterID: "adapteeAdapter")
             }
-            
-            func request() -> String {
-                return adaptee.specificRequest()
-            }
-            
-            override func canHandle(_ input: Any) -> Bool {
-                return input is Adaptee
-            }
+            func request() -> String { return adaptee.specificRequest() }
+            override func canHandle(_ input: Any) -> Bool { return input is Adaptee }
         }
         
-        // When
         let adaptee = Adaptee()
         let adapter = AdapteeAdapter(adaptee: adaptee)
         let target: Target = adapter
         
-        // Then
         XCTAssertEqual(target.request(), "Adaptee")
         XCTAssertTrue(adapter.canHandle(adaptee))
         XCTAssertFalse(adapter.canHandle("not an Adaptee"))
     }
     
     func testAdapterWithDifferentTypes() {
-        // Given
-        protocol StringTarget {
-            func getString() -> String
-        }
-        
+        protocol StringTarget { func getString() -> String }
         class IntAdaptee {
             let value: Int
-            
-            init(value: Int) {
-                self.value = value
-            }
+            init(value: Int) { self.value = value }
         }
         
         class IntToStringAdapter: BaseAdapter, StringTarget {
             private let adaptee: IntAdaptee
-            
             init(adaptee: IntAdaptee) {
                 self.adaptee = adaptee
                 super.init(adapterID: "intToStringAdapter")
             }
-            
-            func getString() -> String {
-                return String(adaptee.value)
-            }
-            
-            override func canHandle(_ input: Any) -> Bool {
-                return input is IntAdaptee
-            }
+            func getString() -> String { return String(adaptee.value) }
+            override func canHandle(_ input: Any) -> Bool { return input is IntAdaptee }
         }
         
-        // When
         let adaptee = IntAdaptee(value: 42)
         let adapter = IntToStringAdapter(adaptee: adaptee)
         let target: StringTarget = adapter
         
-        // Then
         XCTAssertEqual(target.getString(), "42")
         XCTAssertTrue(adapter.canHandle(adaptee))
     }
     
-    func testMultipleAdapters() {
+    // MARK: - Inheritance Handling
+    
+    func testAdapterInheritanceHandling() {
         // Given
-        protocol Target {
-            func process() -> String
-        }
+        class Parent {}
+        class Child: Parent {}
         
-        class Adaptee1 {
-            func method1() -> String { return "Adaptee1" }
+        class ParentAdapter: BaseAdapter {
+            override func canHandle(_ input: Any) -> Bool {
+                return input is Parent
+            }
         }
         
-        class Adaptee2 {
-            func method2() -> String { return "Adaptee2" }
-        }
+        let adapter = ParentAdapter(adapterID: "parent")
+        
+        // Then - Should handle both parent and child
+        XCTAssertTrue(adapter.canHandle(Parent()))
+        XCTAssertTrue(adapter.canHandle(Child()))
+        XCTAssertFalse(adapter.canHandle("String"))
+    }
+    
+    func testMultipleAdapters() {
+        protocol Target { func process() -> String }
+        class Adaptee1 { func m1() -> String { return "1" } }
+        class Adaptee2 { func m2() -> String { return "2" } }
         
         class Adapter1: BaseAdapter, Target {
-            private let adaptee: Adaptee1
-            
-            init(adaptee: Adaptee1) {
-                self.adaptee = adaptee
-                super.init(adapterID: "adapter1")
-            }
-            
-            func process() -> String {
-                return adaptee.method1()
-            }
-            
-            override func canHandle(_ input: Any) -> Bool {
-                return input is Adaptee1
-            }
+            let a: Adaptee1
+            init(a: Adaptee1) { self.a = a; super.init(adapterID: "1") }
+            func process() -> String { a.m1() }
+            override func canHandle(_ input: Any) -> Bool { input is Adaptee1 }
         }
         
         class Adapter2: BaseAdapter, Target {
-            private let adaptee: Adaptee2
-            
-            init(adaptee: Adaptee2) {
-                self.adaptee = adaptee
-                super.init(adapterID: "adapter2")
-            }
-            
-            func process() -> String {
-                return adaptee.method2()
-            }
-            
-            override func canHandle(_ input: Any) -> Bool {
-                return input is Adaptee2
-            }
+            let a: Adaptee2
+            init(a: Adaptee2) { self.a = a; super.init(adapterID: "2") }
+            func process() -> String { a.m2() }
+            override func canHandle(_ input: Any) -> Bool { input is Adaptee2 }
         }
         
-        // When
-        let adaptee1 = Adaptee1()
-        let adaptee2 = Adaptee2()
-        let adapter1 = Adapter1(adaptee: adaptee1)
-        let adapter2 = Adapter2(adaptee: adaptee2)
+        let a1 = Adaptee1()
+        let a2 = Adaptee2()
+        let ad1 = Adapter1(a: a1)
+        let ad2 = Adapter2(a: a2)
         
-        // Then
-        XCTAssertEqual(adapter1.process(), "Adaptee1")
-        XCTAssertEqual(adapter2.process(), "Adaptee2")
-        XCTAssertTrue(adapter1.canHandle(adaptee1))
-        XCTAssertTrue(adapter2.canHandle(adaptee2))
-        XCTAssertFalse(adapter1.canHandle(adaptee2))
-        XCTAssertFalse(adapter2.canHandle(adaptee1))
+        XCTAssertEqual(ad1.process(), "1")
+        XCTAssertEqual(ad2.process(), "2")
+        XCTAssertTrue(ad1.canHandle(a1))
+        XCTAssertFalse(ad1.canHandle(a2))
     }
     
     func testAdapterProtocolConformance() {
-        // Given
-        class TestAdapter: BaseAdapter {
-            override init(adapterID: String) {
-                super.init(adapterID: adapterID)
-            }
-        }
-        
-        // When
+        class TestAdapter: BaseAdapter {}
         let adapter: Adapter = TestAdapter(adapterID: "test")
-        
-        // Then
         XCTAssertEqual(adapter.adapterID, "test")
-        XCTAssertFalse(adapter.canHandle("test"))
     }
 }
-
diff --git a/Tests/DesignAlgorithmsKitTests/Structural/FacadeTests.swift b/Tests/DesignAlgorithmsKitTests/Structural/FacadeTests.swift
index 0982545..01da3ba 100644
--- a/Tests/DesignAlgorithmsKitTests/Structural/FacadeTests.swift
+++ b/Tests/DesignAlgorithmsKitTests/Structural/FacadeTests.swift
@@ -1,10 +1,3 @@
-//
-//  FacadeTests.swift
-//  DesignAlgorithmsKitTests
-//
-//  Unit tests for Facade Pattern
-//
-
 import XCTest
 @testable import DesignAlgorithmsKit
 
@@ -13,219 +6,103 @@ final class FacadeTests: XCTestCase {
     // MARK: - BaseFacade Tests
     
     func testBaseFacadeInitialization() {
-        // Given
         let facadeID = "testFacade"
-        
-        // When
         let facade = BaseFacade(facadeID: facadeID)
-        
-        // Then
         XCTAssertEqual(facade.facadeID, facadeID)
     }
     
-    // MARK: - Facade Pattern Implementation Tests
+    // MARK: - Facade Pattern Implementation
     
     func testFacadePattern() {
-        // Given
-        class SubsystemA {
-            func operationA() -> String {
-                return "A"
-            }
-        }
-        
-        class SubsystemB {
-            func operationB() -> String {
-                return "B"
-            }
-        }
-        
-        class SubsystemC {
-            func operationC() -> String {
-                return "C"
-            }
-        }
+        class SubsystemA { func opA() -> String { "A" } }
+        class SubsystemB { func opB() -> String { "B" } }
         
         class SystemFacade: BaseFacade {
-            private let subsystemA: SubsystemA
-            private let subsystemB: SubsystemB
-            private let subsystemC: SubsystemC
+            private let a = SubsystemA()
+            private let b = SubsystemB()
             
-            init() {
-                self.subsystemA = SubsystemA()
-                self.subsystemB = SubsystemB()
-                self.subsystemC = SubsystemC()
-                super.init(facadeID: "systemFacade")
-            }
+            init() { super.init(facadeID: "sys") }
             
-            func performOperation() -> String {
-                let resultA = subsystemA.operationA()
-                let resultB = subsystemB.operationB()
-                let resultC = subsystemC.operationC()
-                return "\(resultA)\(resultB)\(resultC)"
-            }
+            func op() -> String { a.opA() + b.opB() }
         }
         
-        // When
         let facade = SystemFacade()
-        
-        // Then
-        XCTAssertEqual(facade.facadeID, "systemFacade")
-        XCTAssertEqual(facade.performOperation(), "ABC")
+        XCTAssertEqual(facade.op(), "AB")
     }
     
     func testFacadeHidesComplexity() {
-        // Given
-        class ComplexSubsystem {
-            func step1() -> String { return "1" }
-            func step2() -> String { return "2" }
-            func step3() -> String { return "3" }
-            func step4() -> String { return "4" }
+        class Complex {
+            func s1() -> String { "1" }
+            func s2() -> String { "2" }
         }
         
         class SimpleFacade: BaseFacade {
-            private let subsystem: ComplexSubsystem
-            
-            init() {
-                self.subsystem = ComplexSubsystem()
-                super.init(facadeID: "simpleFacade")
-            }
-            
-            func doEverything() -> String {
-                return subsystem.step1() + subsystem.step2() + subsystem.step3() + subsystem.step4()
-            }
+            private let c = Complex()
+            init() { super.init(facadeID: "simple") }
+            func doAll() -> String { c.s1() + c.s2() }
         }
         
-        // When
-        let facade = SimpleFacade()
-        
-        // Then
-        XCTAssertEqual(facade.doEverything(), "1234")
+        XCTAssertEqual(SimpleFacade().doAll(), "12")
     }
     
-    @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+    @available(macOS 10.15, iOS 13.0, *)
     func testAsyncFacade() async throws {
-        // Given
-        class AsyncSubsystem {
-            func asyncOperation() async -> String {
-                try? await Task.sleep(nanoseconds: 10_000_000) // 10ms
-                return "async result"
-            }
+        class AsyncSub {
+            func run() async -> String { "async" }
         }
         
         class AsyncFacade: BaseFacade {
-            private let subsystem: AsyncSubsystem
-            
-            init() {
-                self.subsystem = AsyncSubsystem()
-                super.init(facadeID: "asyncFacade")
-            }
-            
-            func performAsyncOperation() async -> String {
-                return await subsystem.asyncOperation()
-            }
+            private let s = AsyncSub()
+            init() { super.init(facadeID: "async") }
+            func run() async -> String { await s.run() }
         }
         
-        // When
-        let facade = AsyncFacade()
-        let result = await facade.performAsyncOperation()
-        
-        // Then
-        XCTAssertEqual(result, "async result")
+        let res = await AsyncFacade().run()
+        XCTAssertEqual(res, "async")
     }
     
-    func testFacadeWithMultipleSubsystems() {
-        // Given
-        class NetworkSubsystem {
-            func fetch() -> String { return "network" }
-        }
-        
-        class CacheSubsystem {
-            func get() -> String { return "cache" }
+    // MARK: - Nested Facades (Structural Test)
+    
+    func testNestedFacades() {
+        // Given - Level 1 subsystems
+        class Audio { func initAudio() -> String { "Audio" } }
+        class Video { func initVideo() -> String { "Video" } }
+        
+        // Level 1 Facade
+        class MediaFacade: BaseFacade {
+            private let a = Audio()
+            private let v = Video()
+            init() { super.init(facadeID: "media") }
+            func initMedia() -> String { a.initAudio() + v.initVideo() }
         }
         
-        class DatabaseSubsystem {
-            func query() -> String { return "database" }
-        }
+        // Other subsystem
+        class Physics { func initPhysics() -> String { "Physics" } }
         
-        class DataFacade: BaseFacade {
-            private let network: NetworkSubsystem
-            private let cache: CacheSubsystem
-            private let database: DatabaseSubsystem
+        // Level 2 (Root) Facade
+        class GameEngineFacade: BaseFacade {
+            private let media = MediaFacade() // Nested facade
+            private let physics = Physics()
             
-            init() {
-                self.network = NetworkSubsystem()
-                self.cache = CacheSubsystem()
-                self.database = DatabaseSubsystem()
-                super.init(facadeID: "dataFacade")
-            }
+            init() { super.init(facadeID: "engine") }
             
-            func getData() -> String {
-                // Try cache first, then network, then database
-                let cached = cache.get()
-                if cached != "" {
-                    return cached
-                }
-                let networkData = network.fetch()
-                if networkData != "" {
-                    return networkData
-                }
-                return database.query()
+            func start() -> String {
+                return media.initMedia() + "-" + physics.initPhysics()
             }
         }
         
         // When
-        let facade = DataFacade()
+        let engine = GameEngineFacade()
         
         // Then
-        XCTAssertEqual(facade.getData(), "cache")
+        XCTAssertEqual(engine.start(), "AudioVideo-Physics")
     }
     
+    // MARK: - Protocol Conformance
+    
     func testFacadeProtocolConformance() {
-        // Given
-        class TestFacade: BaseFacade {
-            override init(facadeID: String) {
-                super.init(facadeID: facadeID)
-            }
-        }
-        
-        // When
+        class TestFacade: BaseFacade {}
         let facade: Facade = TestFacade(facadeID: "test")
-        
-        // Then
         XCTAssertEqual(facade.facadeID, "test")
     }
-    
-    func testMultipleFacades() {
-        // Given
-        class Facade1: BaseFacade {
-            init() {
-                super.init(facadeID: "facade1")
-            }
-            
-            func operation1() -> String {
-                return "facade1"
-            }
-        }
-        
-        class Facade2: BaseFacade {
-            init() {
-                super.init(facadeID: "facade2")
-            }
-            
-            func operation2() -> String {
-                return "facade2"
-            }
-        }
-        
-        // When
-        let facade1 = Facade1()
-        let facade2 = Facade2()
-        
-        // Then
-        XCTAssertEqual(facade1.facadeID, "facade1")
-        XCTAssertEqual(facade2.facadeID, "facade2")
-        XCTAssertEqual(facade1.operation1(), "facade1")
-        XCTAssertEqual(facade2.operation2(), "facade2")
-    }
 }
-