Update AppStateTests.swift

Author: 0xLeif

Tests/AppStateTests/AppStateTests.swift

@@ -190,108 +190,4 @@ final class AppStateTests: XCTestCase {
         XCTAssertTrue(Application.isLoggingEnabled)
         Application.logger.debug("This should be logged again from testLoggingToggle.")
     }
-
-    @MainActor
-    func testConcurrentWrites() async {
-        let iterations = 1000
-        let concurrentWriters = 5
-        let keyPath = \Application.count
-        let targetValueBase = 999
-
-        // Since testConcurrentWrites is @MainActor, `Application.state(keyPath)` is a synchronous call.
-        var countState = Application.state(keyPath)
-        countState.value = 0 // This is also synchronous as countState is a local var.
-
-        await withTaskGroup(of: Void.self) { group in
-            for writerId in 0..<concurrentWriters {
-                group.addTask { // These tasks are nonisolated
-                    for i in 0..<iterations {
-                        let valueToWrite = targetValueBase + writerId
-                        // Perform state mutation on the MainActor
-                        await MainActor.run {
-                            var state = Application.state(keyPath) // Accessing @MainActor static var
-                            state.value = valueToWrite             // Accessing @MainActor .value
-                        }
-
-                        if i % 10 == 0 { await Task.yield() }
-                    }
-                }
-            }
-        }
-
-        // After all writes, the value should be one of the values written by the writers.
-        // Accessing state and its value on the MainActor.
-        let finalValue = await MainActor.run { Application.state(keyPath).value }
-        let possibleValues = (0..<concurrentWriters).map { targetValueBase + $0 }
-        XCTAssertTrue(possibleValues.contains(finalValue), "Final value \(finalValue) is not one of the expected written values \(possibleValues). This might indicate a race condition in the set operation or the test logic itself.")
-    }
-
-    @MainActor
-    func testConcurrentReadsAndWrites() async {
-        let keyPath = \Application.username
-        let writeValuePrefix = "ConsistentValue"
-        let iterations = 1000
-        let numReaders = 5
-
-        // Since test function is @MainActor, these are synchronous calls.
-        var usernameState = Application.state(keyPath)
-        usernameState.value = "Initial"
-
-        await withTaskGroup(of: Void.self) { group in
-            // Writer Task
-            group.addTask { // nonisolated task
-                for i in 0..<iterations {
-                    await MainActor.run {
-                        var state = Application.state(keyPath)
-                        state.value = "\(writeValuePrefix)_\(i)"
-                    }
-                    if i % 10 == 0 { await Task.yield() }
-                }
-                await MainActor.run {
-                    var finalState = Application.state(keyPath)
-                    finalState.value = "FinalStableValue"
-                }
-            }
-
-            // Reader Tasks
-            for readerId in 0..<numReaders {
-                group.addTask { // nonisolated task
-                    var reads = 0
-                    var sawFinal = false
-                    while reads < iterations {
-                        let currentValue = await MainActor.run { Application.state(keyPath).value }
-                        XCTAssertNotNil(currentValue, "Reader \(readerId) read a nil value unexpectedly.")
-                        if currentValue == "FinalStableValue" {
-                            sawFinal = true
-                            break
-                        }
-                        reads += 1
-                        await Task.yield()
-                    }
-
-                    if !sawFinal {
-                        for _ in 0..<20 {
-                            let valueOnMain = await MainActor.run { Application.state(keyPath).value }
-                            if valueOnMain == "FinalStableValue" {
-                                sawFinal = true
-                                break
-                            }
-                            do {
-                                try await Task.sleep(nanoseconds: 20_000_000)
-                            } catch {
-                                XCTFail("Task.sleep threw an error in reader \(readerId): \(error)")
-                            }
-                        }
-                    }
-                    await MainActor.run {
-                        XCTAssertEqual(Application.state(keyPath).value, "FinalStableValue", "Reader \(readerId) did not observe 'FinalStableValue' as the final state.")
-                    }
-                }
-            }
-        }
-
-        // Final assertion after task group completion, already on MainActor.
-        let finalValue = Application.state(keyPath).value
-        XCTAssertEqual(finalValue, "FinalStableValue", "The final state was not the expected 'FinalStableValue'.")
-    }
 }