From fd571a14e05bfe44e9b88d37329bc3db8f200afb Mon Sep 17 00:00:00 2001
From: Yuta Saito <kateinoigakukun@gmail.com>
Date: Sat, 9 Aug 2025 14:59:03 +0900
Subject: [PATCH 1/3] Add memory stress tests for JSObject and JSClosure

Tests memory exhaustion, heap fragmentation, and boundary conditions
without FinalizationRegistry to validate reference counting under
extreme allocation pressure.
---
 Tests/JavaScriptKitTests/StressTests.swift | 259 +++++++++++++++++++++
 1 file changed, 259 insertions(+)
 create mode 100644 Tests/JavaScriptKitTests/StressTests.swift

diff --git a/Tests/JavaScriptKitTests/StressTests.swift b/Tests/JavaScriptKitTests/StressTests.swift
new file mode 100644
index 00000000..1a428789
--- /dev/null
+++ b/Tests/JavaScriptKitTests/StressTests.swift
@@ -0,0 +1,259 @@
+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([JSValue.number(10)])
+                XCTAssertEqual(result.number, 110.0) // 100 (capturedData.count) + 10
+                
+                // 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]([JSValue.number(5)])
+            XCTAssertTrue(result.number! > 5) // Should be 5 + capturedData.count (100+)
+        }
+        
+        #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 i 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](arguments: [])
+                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))
+                }
+            }
+        }
+    }
+}
\ No newline at end of file

From 42e879f015e1ac5f05d2cafe36987b0c713b801c Mon Sep 17 00:00:00 2001
From: Yuta Saito <kateinoigakukun@gmail.com>
Date: Sat, 9 Aug 2025 15:32:32 +0900
Subject: [PATCH 2/3] Fix code formatting for StressTests.swift

---
 Tests/JavaScriptKitTests/StressTests.swift | 104 +++++++++++----------
 1 file changed, 53 insertions(+), 51 deletions(-)

diff --git a/Tests/JavaScriptKitTests/StressTests.swift b/Tests/JavaScriptKitTests/StressTests.swift
index 1a428789..ef986a11 100644
--- a/Tests/JavaScriptKitTests/StressTests.swift
+++ b/Tests/JavaScriptKitTests/StressTests.swift
@@ -2,7 +2,7 @@ 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")
@@ -13,22 +13,22 @@ final class StressTests: XCTestCase {
         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
-                
+                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
+                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()
@@ -39,14 +39,14 @@ final class StressTests: XCTestCase {
             // 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 {
@@ -54,18 +54,18 @@ final class StressTests: XCTestCase {
             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  
+        // 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
@@ -75,14 +75,14 @@ final class StressTests: XCTestCase {
                     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([JSValue.number(10)])
-                XCTAssertEqual(result.number, 110.0) // 100 (capturedData.count) + 10
-                
+                XCTAssertEqual(result.number, 110.0)  // 100 (capturedData.count) + 10
+
                 // More frequent GC to stress the system
                 if i % 500 == 0 {
                     gc()
@@ -92,27 +92,27 @@ final class StressTests: XCTestCase {
         } 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]([JSValue.number(5)])
-            XCTAssertTrue(result.number! > 5) // Should be 5 + capturedData.count (100+)
+            XCTAssertTrue(result.number! > 5)  // Should be 5 + capturedData.count (100+)
         }
-        
+
         #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")
@@ -122,33 +122,35 @@ final class StressTests: XCTestCase {
         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
-                    
+                    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 i in 0..<closuresThisCycle {
                     let heavyData = String(repeating: "data", count: cycle + 100)
@@ -159,13 +161,13 @@ final class StressTests: XCTestCase {
                     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)
@@ -174,16 +176,16 @@ final class StressTests: XCTestCase {
                 let result = cycleClosure[0](arguments: [])
                 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 {
@@ -192,10 +194,10 @@ final class StressTests: XCTestCase {
                 }
             }
         }
-        
+
         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")
@@ -204,16 +206,16 @@ final class StressTests: XCTestCase {
         // 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)
@@ -222,16 +224,16 @@ final class StressTests: XCTestCase {
                     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 {
@@ -239,15 +241,15 @@ final class StressTests: XCTestCase {
                 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()
@@ -256,4 +258,4 @@ final class StressTests: XCTestCase {
             }
         }
     }
-}
\ No newline at end of file
+}

From 19a417e074eee1dfa32f55216ebe6030bf0b4265 Mon Sep 17 00:00:00 2001
From: Yuta Saito <kateinoigakukun@gmail.com>
Date: Sat, 9 Aug 2025 15:48:20 +0900
Subject: [PATCH 3/3] Fix JSClosure calling syntax in stress tests

---
 Tests/JavaScriptKitTests/StressTests.swift | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Tests/JavaScriptKitTests/StressTests.swift b/Tests/JavaScriptKitTests/StressTests.swift
index ef986a11..73b302fd 100644
--- a/Tests/JavaScriptKitTests/StressTests.swift
+++ b/Tests/JavaScriptKitTests/StressTests.swift
@@ -80,8 +80,8 @@ final class StressTests: XCTestCase {
                 successCount = i + 1
 
                 // Test closure immediately to ensure it works under memory pressure
-                let result = closure([JSValue.number(10)])
-                XCTAssertEqual(result.number, 110.0)  // 100 (capturedData.count) + 10
+                let result = closure()
+                XCTAssertEqual(result.number, 100.0)  // capturedData.count
 
                 // More frequent GC to stress the system
                 if i % 500 == 0 {
@@ -96,8 +96,8 @@ final class StressTests: XCTestCase {
         // 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]([JSValue.number(5)])
-            XCTAssertTrue(result.number! > 5)  // Should be 5 + capturedData.count (100+)
+            let result = closures[randomIndex]()
+            XCTAssertEqual(result.number, 100.0)  // capturedData.count
         }
 
         #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
@@ -152,7 +152,7 @@ final class StressTests: XCTestCase {
                 }
 
                 // Allocate closures with increasing complexity
-                for i in 0..<closuresThisCycle {
+                for _ in 0..<closuresThisCycle {
                     let heavyData = String(repeating: "data", count: cycle + 100)
                     let closure = JSClosure { arguments in
                         // Force retention of heavy data
@@ -173,7 +173,7 @@ final class StressTests: XCTestCase {
                 XCTAssertNotNil(cycleObjects[0]["large_array"].object)
             }
             if !cycleClosure.isEmpty {
-                let result = cycleClosure[0](arguments: [])
+                let result = cycleClosure[0]()
                 XCTAssertNotNil(result.string)
             }