Fix test_stdio_client_universal_cleanup for Windows

Replace platform-specific commands (ping/sleep) with a Python script
to ensure consistent behavior across all platforms. Also adjust timing
expectations to account for the full shutdown sequence on Windows:
- 2 seconds waiting for stdin closure response
- 2 seconds waiting for terminate() to complete
- Plus overhead

This prevents the test from timing out on Windows while still properly
testing the cleanup mechanism.

Author: felixweinberger

tests/client/test_stdio.py

@@ -105,42 +105,50 @@ async def test_stdio_client_universal_cleanup():
     even when connected to processes that exit slowly.
     """
 
-    # Use a simple sleep command that's available on all platforms
-    # This simulates a process that takes time to terminate
-    if sys.platform == "win32":
-        # Windows: use ping with timeout to simulate a running process
-        server_params = StdioServerParameters(
-            command="ping",
-            args=["127.0.0.1", "-n", "10"],  # Ping 10 times, takes ~10 seconds
-        )
-    else:
-        # Unix: use sleep command
-        server_params = StdioServerParameters(
-            command="sleep",
-            args=["10"],  # Sleep for 10 seconds
-        )
+    # Use a Python script that simulates a long-running process
+    # This ensures consistent behavior across platforms
+    long_running_script = textwrap.dedent(
+        """
+        import time
+        import sys
+        
+        # Simulate a long-running process
+        for i in range(100):
+            time.sleep(0.1)
+            # Flush to ensure output is visible
+            sys.stdout.flush()
+            sys.stderr.flush()
+        """
+    )
+    
+    server_params = StdioServerParameters(
+        command=sys.executable,
+        args=["-c", long_running_script],
+    )
 
     start_time = time.time()
 
     # Use move_on_after which is more reliable for cleanup scenarios
-    with anyio.move_on_after(6.0) as cancel_scope:
+    # Increased timeout to account for Windows process termination overhead
+    with anyio.move_on_after(8.0) as cancel_scope:
         async with stdio_client(server_params) as (read_stream, write_stream):
             # Immediately exit - this triggers cleanup while process is still running
             pass
 
         end_time = time.time()
         elapsed = end_time - start_time
 
-        # Key assertion: Should complete quickly due to timeout mechanism
-        assert elapsed < 5.0, (
-            f"stdio_client cleanup took {elapsed:.1f} seconds, expected < 5.0 seconds. "
+        # Key assertion: Should complete within reasonable time due to timeout mechanism
+        # On Windows: 2s (stdin wait) + 2s (terminate wait) + overhead = ~5s expected
+        assert elapsed < 6.0, (
+            f"stdio_client cleanup took {elapsed:.1f} seconds, expected < 6.0 seconds. "
             f"This suggests the timeout mechanism may not be working properly."
         )
 
     # Check if we timed out
     if cancel_scope.cancelled_caught:
         pytest.fail(
-            "stdio_client cleanup timed out after 6.0 seconds. "
+            "stdio_client cleanup timed out after 8.0 seconds. "
             "This indicates the cleanup mechanism is hanging and needs fixing."
         )