Add tests (#22)

Author: muukii

.gitignore

@@ -86,5 +86,5 @@ fastlane/test_output
 iOSInjectionProject/
 
 .DS_Store
-.swiftpm
+.swiftpm/xcode
 # End of https://www.toptal.com/developers/gitignore/api/swift

.swiftpm/swift-macro-state-struct.xctestplan

@@ -0,0 +1,31 @@
+{
+  "configurations" : [
+    {
+      "id" : "1194A67B-74F2-4259-BCF4-4C67B5C7FAE7",
+      "name" : "Test Scheme Action",
+      "options" : {
+
+      }
+    }
+  ],
+  "defaultOptions" : {
+
+  },
+  "testTargets" : [
+    {
+      "target" : {
+        "containerPath" : "container:",
+        "identifier" : "StateStructMacroTests",
+        "name" : "StateStructMacroTests"
+      }
+    },
+    {
+      "target" : {
+        "containerPath" : "container:",
+        "identifier" : "StateStructTests",
+        "name" : "StateStructTests"
+      }
+    }
+  ],
+  "version" : 1
+}

Tests/StateStructTests/BackingStorageTests.swift

@@ -0,0 +1,62 @@
+import Testing
+@testable import StateStruct
+
+@Suite("CopyOnWrite Tests")
+struct BackingStorageTests {
+  
+  @Test("Concurrent access should be thread-safe")
+  func testConcurrentAccess() async throws {
+    let storage = _BackingStorage(0)
+    let iterations = 1000
+    let taskCount = 10
+    
+    await withTaskGroup(of: Void.self) { group in
+      for taskCount in 0..<taskCount {
+        group.addTask {
+          for i in 0..<iterations {
+            print(i, taskCount)
+            storage.value += 1
+          }
+        }
+      }
+      await group.waitForAll()
+    }
+    
+    #expect(storage.value == iterations * taskCount)
+  }
+  
+  @Test("Concurrent read-write operations should be safe")
+  func testConcurrentReadWrite() async throws {
+    let storage = _BackingStorage(0)
+    let iterations = 1000
+    
+    async let writeTask: () = Task {
+      for i in 0..<iterations {
+        storage.value = i
+      }
+    }.value
+    
+    async let readTask: () = Task {
+      for _ in 0..<iterations {
+        #expect(storage.value >= 0)
+      }
+    }.value
+    
+    await writeTask
+    await readTask
+    
+    #expect(storage.value == iterations - 1)
+  }
+  
+  @Test("Copy on write behavior")
+  func testCopyOnWrite() {
+    let storage1 = _BackingStorage(42)
+    let storage2 = storage1.copy()
+    
+    #expect(storage1.value == storage2.value)
+    
+    storage2.value = 100
+    #expect(storage1.value == 42)
+    #expect(storage2.value == 100)
+  }
+}

Tests/StateStructTests/TrackingExistential.swift

@@ -0,0 +1,56 @@
+import Testing
+import StateStruct
+
+@Suite
+struct TrackingExistential {
+
+  @Tracking  
+  struct UI {
+    var count: Int
+    
+    init(count: Int) {
+      self.count = count
+    }
+  }
+  
+  @Tracking
+  struct Root {
+    
+    var _any: Any?
+    
+    var ui: UI? {
+      get {
+        _any as? UI
+      }
+      set {
+        _any = newValue
+      }
+    }
+    
+    init(ui: UI) {
+      self.ui = ui
+    }
+  }
+  
+  
+  @Test func tracking() {
+    
+    let original = Root(ui: UI(count: 1))
+    
+    let reading = original.tracking {
+      _ = original.ui?.count
+    }
+        
+    #expect(
+      reading.graph.prettyPrint() == """
+        StateStructTests.TrackingExistential.Root {
+          _any-(1) {
+            count-(1)
+          }
+        }
+        """
+    )
+
+  }
+  
+}