Add memory stress tests for JSObject and JSClosure

Tests/JavaScriptKitTests/StressTests.swift

@@ -0,0 +1,261 @@
+import JavaScriptKit
+import XCTest
+
+final class StressTests: XCTestCase {
+
+    func testJSObjectMemoryExhaustion() async throws {
+        guard let gc = JSObject.global.gc.function else {
+            throw XCTSkip("Missing --expose-gc flag")
+        }
+
+        // Push JSObject allocation to stress memory management
+        // This tests reference counting and cleanup under heavy load
+        let maxIterations = 25_000
+        var objects: [JSObject] = []
+        var lastSuccessfulCount = 0
+
+        do {
+            for i in 0..<maxIterations {
+                let obj = JSObject()
+                // Add properties to increase memory pressure
+                obj["index"] = JSValue.number(Double(i))
+                obj["data"] = JSValue.string(String(repeating: "x", count: 1000))  // 1KB string per object
+
+                // Create nested objects to stress the reference graph
+                let nested = JSObject()
+                nested["parent_ref"] = obj.jsValue  // Circular reference
+                obj["nested"] = nested.jsValue
+
+                objects.append(obj)
+                lastSuccessfulCount = i
+
+                // Aggressive GC every 1000 objects to test cleanup under pressure
+                if i % 1000 == 0 {
+                    gc()
+                    try await Task.sleep(for: .milliseconds(0))
+                }
+            }
+        } catch {
+            // Expected to eventually fail due to memory pressure
+            print("JSObject stress test stopped at \(lastSuccessfulCount) objects: \(error)")
+        }
+
+        // Verify objects are still accessible after memory pressure
+        let sampleCount = min(1000, objects.count)
+        for i in 0..<sampleCount {
+            XCTAssertEqual(objects[i]["index"], JSValue.number(Double(i)))
+            XCTAssertNotNil(objects[i]["nested"].object)
+        }
+
+        // Force cleanup
+        objects.removeAll()
+        for _ in 0..<20 {
+            gc()
+            try await Task.sleep(for: .milliseconds(10))
+        }
+    }
+
+    func testJSClosureMemoryPressureWithoutFinalizationRegistry() async throws {
+        guard let gc = JSObject.global.gc.function else {
+            throw XCTSkip("Missing --expose-gc flag")
+        }
+
+        // Test heavy closure allocation to stress Swift heap management
+        // Focus on scenarios where FinalizationRegistry is not used
+        let maxClosures = 15_000
+        var closures: [JSClosure] = []
+        var successCount = 0
+
+        do {
+            for i in 0..<maxClosures {
+                // Create closures that capture significant data
+                let capturedData = Array(0..<100).map { "item_\($0)_\(i)" }
+                let closure = JSClosure { arguments in
+                    // Force usage of captured data to prevent optimization
+                    let result = capturedData.count + Int(arguments.first?.number ?? 0)
+                    return JSValue.number(Double(result))
+                }
+
+                closures.append(closure)
+                successCount = i + 1
+
+                // Test closure immediately to ensure it works under memory pressure
+                let result = closure()
+                XCTAssertEqual(result.number, 100.0)  // capturedData.count
+
+                // More frequent GC to stress the system
+                if i % 500 == 0 {
+                    gc()
+                    try await Task.sleep(for: .milliseconds(0))
+                }
+            }
+        } catch {
+            print("JSClosure stress test stopped at \(successCount) closures: \(error)")
+        }
+
+        // Test random closures still work after extreme memory pressure
+        for _ in 0..<min(100, closures.count) {
+            let randomIndex = Int.random(in: 0..<closures.count)
+            let result = closures[randomIndex]()
+            XCTAssertEqual(result.number, 100.0)  // capturedData.count
+        }
+
+        #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+        for closure in closures {
+            closure.release()
+        }
+        #endif
+
+        closures.removeAll()
+        for _ in 0..<20 {
+            gc()
+            try await Task.sleep(for: .milliseconds(10))
+        }
+    }
+
+    func testMixedAllocationMemoryBoundaries() async throws {
+        guard let gc = JSObject.global.gc.function else {
+            throw XCTSkip("Missing --expose-gc flag")
+        }
+
+        // Test system behavior at memory boundaries with mixed object types
+        let cycles = 200
+        var totalObjects = 0
+        var totalClosures = 0
+
+        for cycle in 0..<cycles {
+            var cycleObjects: [JSObject] = []
+            var cycleClosure: [JSClosure] = []
+
+            // Exponentially increase allocation pressure each cycle
+            let objectsThisCycle = min(100 + cycle, 1000)
+            let closuresThisCycle = min(50 + cycle / 2, 500)
+
+            do {
+                // Allocate objects
+                for i in 0..<objectsThisCycle {
+                    let obj = JSObject()
+                    // Create memory-intensive properties
+                    obj["large_array"] =
+                        JSObject.global.Array.function!.from!(
+                            (0..<1000).map { JSValue.number(Double($0)) }.jsValue
+                        ).jsValue
+                    obj["metadata"] =
+                        [
+                            "cycle": cycle,
+                            "index": i,
+                            "timestamp": Int(Date().timeIntervalSince1970),
+                        ].jsValue
+
+                    cycleObjects.append(obj)
+                    totalObjects += 1
+                }
+
+                // Allocate closures with increasing complexity
+                for _ in 0..<closuresThisCycle {
+                    let heavyData = String(repeating: "data", count: cycle + 100)
+                    let closure = JSClosure { arguments in
+                        // Force retention of heavy data
+                        return JSValue.string(heavyData.prefix(10).description)
+                    }
+                    cycleClosure.append(closure)
+                    totalClosures += 1
+                }
+
+            } catch {
+                print("Memory boundary reached at cycle \(cycle): \(error)")
+                print("Total objects created: \(totalObjects), closures: \(totalClosures)")
+                break
+            }
+
+            // Test system still works under extreme pressure
+            if !cycleObjects.isEmpty {
+                XCTAssertNotNil(cycleObjects[0]["large_array"].object)
+            }
+            if !cycleClosure.isEmpty {
+                let result = cycleClosure[0]()
+                XCTAssertNotNil(result.string)
+            }
+
+            #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+            for closure in cycleClosure {
+                closure.release()
+            }
+            #endif
+
+            cycleObjects.removeAll()
+            cycleClosure.removeAll()
+
+            // Aggressive cleanup every 10 cycles
+            if cycle % 10 == 0 {
+                for _ in 0..<10 {
+                    gc()
+                    try await Task.sleep(for: .milliseconds(1))
+                }
+            }
+        }
+
+        print("Stress test completed: \(totalObjects) objects, \(totalClosures) closures allocated")
+    }
+
+    func testHeapFragmentationRecovery() async throws {
+        guard let gc = JSObject.global.gc.function else {
+            throw XCTSkip("Missing --expose-gc flag")
+        }
+
+        // Test system recovery from heap fragmentation by creating/destroying
+        // patterns that stress the memory allocator
+        let fragmentationCycles = 100
+
+        for cycle in 0..<fragmentationCycles {
+            var shortLivedObjects: [JSObject] = []
+            var longLivedObjects: [JSObject] = []
+
+            // Create fragmentation pattern: many short-lived, few long-lived
+            for i in 0..<1000 {
+                let obj = JSObject()
+                obj["data"] = JSValue.string(String(repeating: "fragment", count: 100))
+
+                if i % 10 == 0 {
+                    // Long-lived objects
+                    longLivedObjects.append(obj)
+                } else {
+                    // Short-lived objects
+                    shortLivedObjects.append(obj)
+                }
+            }
+
+            // Immediately release short-lived objects to create fragmentation
+            shortLivedObjects.removeAll()
+
+            // Force GC to reclaim fragmented memory
+            for _ in 0..<5 {
+                gc()
+                try await Task.sleep(for: .milliseconds(1))
+            }
+
+            // Test system can still allocate efficiently after fragmentation
+            var recoveryTest: [JSObject] = []
+            for i in 0..<500 {
+                let obj = JSObject()
+                obj["recovery_test"] = JSValue.number(Double(i))
+                recoveryTest.append(obj)
+            }
+
+            // Verify recovery objects work correctly
+            for (i, obj) in recoveryTest.enumerated() {
+                XCTAssertEqual(obj["recovery_test"], JSValue.number(Double(i)))
+            }
+
+            recoveryTest.removeAll()
+            longLivedObjects.removeAll()
+
+            if cycle % 20 == 0 {
+                for _ in 0..<10 {
+                    gc()
+                    try await Task.sleep(for: .milliseconds(5))
+                }
+            }
+        }
+    }
+}