self = <test_013_SqlHandle_free_shutdown.TestHandleFreeShutdown object at 0x5508161110>
conn_str = 'Server=172.17.0.4;Database=TestDB;Uid=SA;Pwd=Azure@123!;TrustServerCertificate=yes'

    def test_cleanup_connections_weakset_modification_during_iteration(self, conn_str):
        """
        Test that list copy prevents RuntimeError when WeakSet is modified during iteration.
    
        This is a more aggressive test of the connections_to_close = list(_active_connections) line.
    
        Validates that:
        1. Without the list copy, iterating WeakSet directly would fail if modified
        2. With the list copy, iteration is safe even if WeakSet shrinks due to GC
        3. The pattern prevents "dictionary changed size during iteration" type errors
        """
        script = textwrap.dedent(f"""
            import mssql_python
            import weakref
            import gc
    
            class TestConnection:
                def __init__(self, conn_id):
                    self.conn_id = conn_id
                    self._closed = False
    
                def close(self):
                    self._closed = True
    
            # Create connections with only weak references so they can be GC'd easily
            weak_refs = []
            for i in range(10):
                conn = TestConnection(i)
                mssql_python._register_connection(conn)
                weak_refs.append(weakref.ref(conn))
                # Don't keep strong reference - only weak_refs list has refs
    
            initial_size = len(mssql_python._active_connections)
            print(f"Initial WeakSet size: {{initial_size}}")
    
            # TEST 1: Demonstrate that direct iteration would be unsafe
            # (We can't actually do this in the real code, but we can show the principle)
            print("TEST 1: Verifying list copy is necessary...")
    
            # Force some garbage collection
            gc.collect()
            after_gc_size = len(mssql_python._active_connections)
            print(f"WeakSet size after GC: {{after_gc_size}}")
    
            # TEST 2: Verify list copy allows safe iteration
            print("TEST 2: Testing list copy creates stable snapshot...")
    
            # This is what _cleanup_connections does - creates a list copy
            with mssql_python._connections_lock:
                connections_to_close = list(mssql_python._active_connections)
    
            snapshot_size = len(connections_to_close)
            print(f"Snapshot list size: {{snapshot_size}}")
    
            # Now cause more GC while we iterate the snapshot
            gc.collect()
    
            # Iterate the snapshot - this should work even though WeakSet may have changed
            processed = 0
            for conn in connections_to_close:
                try:
                    if hasattr(conn, "_closed") and not conn._closed:
                        conn.close()
                    processed += 1
                except Exception:
                    # Connection may have been GC'd, that's OK
                    pass
    
            final_size = len(mssql_python._active_connections)
            print(f"Final WeakSet size: {{final_size}}")
            print(f"Processed {{processed}} connections from snapshot")
    
            # Key assertion: We could iterate the full snapshot even if WeakSet changed
            assert processed == snapshot_size, f"Should process all snapshot items: {{processed}} == {{snapshot_size}}"
    
            print("WeakSet modification during iteration: PASSED")
            print("[OK] list() copy prevents 'set changed size during iteration' errors")
        """)
    
        result = subprocess.run(
            [sys.executable, "-c", script], capture_output=True, text=True, timeout=15
        )
    
>      
... [The stack trace has been truncated as it exceeded the maximum allowed size. Please refer to the complete log available in the Test Run attachments for full details.]