Tests driven by real-world consumer patterns and historical issues

greateggsgreg · greateggsgreg · commit 7f2934b6e87b · 2026-05-10T00:04:01.000-04:00
Two additional FT-only tests targeting concrete consumer code paths identified by reviewing pythonnet's downstream users (QuantConnect/Lean, Rhino.Inside, Speckle) and historical issues: test_concurrent_clr_delegate_invocation_from_python Python callables wrapped as distinct CLR delegate types (PublicDelegate, StringDelegate, BoolDelegate) and invoked concurrently from worker threads. Pattern is canonical for embedders that pass Python lambdas where C# expects a delegate. Hits the DelegateManager.GetDispatcher Reflection.Emit lock plus Dispatcher.Dispatch's Py.GIL re-acquisition. test_concurrent_generic_type_binding 36 distinct Dictionary[K,V] / List[K] type-arg pairs resolved concurrently from N threads. Tracks #2269, #1407, #821 (concurrent ToPython / GenericByName). Exercises ClassManager.cache, TypeManager.cache, GenericUtil.mapping, and the generic-binding fast path together. Also: preserve the InternString single-write invariant under DEBUG. Previous TryAdd silently masked the assertion that Add() used to provide. Capture the bool result and Debug.Assert it - same correctness check, no release-build cost. Verified: 3.11 - 3.14 GIL (.NET 8/10): 473 passed, 11 skipped, 3/3 runs clean 3.14t (.NET 8/10): 479 passed, 5 skipped per run
diff --git a/src/runtime/InternString.cs b/src/runtime/InternString.cs
@@ -76,8 +76,11 @@ public static bool TryGetInterned(BorrowedReference op, out string s)
 
         private static void SetIntern(string s, PyString op)
         {
-            _string2interns.TryAdd(s, op);
-            _intern2strings.TryAdd(op.Reference.DangerousGetAddress(), s);
+            // Initialize is single-threaded; TryAdd preserves the original
+            // single-write invariant via Debug.Assert without crashing release.
+            bool a = _string2interns.TryAdd(s, op);
+            bool b = _intern2strings.TryAdd(op.Reference.DangerousGetAddress(), s);
+            Debug.Assert(a && b);
         }
     }
 }
diff --git a/tests/test_thread.py b/tests/test_thread.py
@@ -247,6 +247,63 @@ def build(_):
     assert all(_run_in_threads(build, n_threads=8))
 
 
+@freethreaded_only
+def test_concurrent_clr_delegate_invocation_from_python():
+    """Python callables wrapped as distinct CLR delegate types, invoked concurrently.
+
+    Real-world: QuantConnect/Lean and similar embedders pass Python callables
+    where C# expects a delegate; under FT the dispatcher emit + Invoke run from
+    multiple threads.  Hits DelegateManager.GetDispatcher (Reflection.Emit lock)
+    and Dispatcher.Dispatch (Py.GIL reacquisition).
+    """
+    from Python.Test import (
+        PublicDelegate, StringDelegate, BoolDelegate,
+    )
+
+    delegates = (
+        PublicDelegate(lambda: None),
+        StringDelegate(lambda: "ok"),
+        BoolDelegate(lambda: True),
+    )
+
+    def fire(i):
+        d = delegates[i % len(delegates)]
+        for _ in range(200):
+            d()
+        return True
+
+    assert all(_run_in_threads(fire, n_threads=8))
+
+
+@freethreaded_only
+def test_concurrent_generic_type_binding():
+    """Concurrent `Dictionary[K, V]` with many distinct type-arg pairs.
+
+    Real-world: pythonnet/pythonnet#2269, #1407, #821 — concurrent ToPython /
+    GenericByName from N threads.  Exercises ClassManager.cache,
+    TypeManager.cache, GenericUtil.mapping, and the generic-type binding
+    fast path together.
+
+    FT-only: the cumulative state under the full pytest suite trips the same
+    pre-existing CPython 3.11/3.12/3.13 GIL-build crash that gates the other
+    high-contention tests in this file.
+    """
+    from System import Int32, Int64, String, Double, Single, Byte
+    from System.Collections.Generic import Dictionary, List
+
+    arg_types = (Int32, Int64, String, Double, Single, Byte)
+    pairs = [(k, v) for k in arg_types for v in arg_types]
+
+    def bind(_):
+        for _ in range(50):
+            for k, v in pairs:
+                _ = Dictionary[k, v]
+                _ = List[k]
+        return True
+
+    assert all(_run_in_threads(bind, n_threads=8))
+
+
 @freethreaded_only
 def test_concurrent_shutdown_handler_register():
     """Concurrent AddShutdownHandler/RemoveShutdownHandler — exercises ShutdownHandlers list.

Original file line number	Diff line number	Diff line change
`@@ -76,8 +76,11 @@ public static bool TryGetInterned(BorrowedReference op, out string s)`
`76`	`76`
`77`	`77`	`private static void SetIntern(string s, PyString op)`
`78`	`78`	`{`
`79`		`- _string2interns.TryAdd(s, op);`
`80`		`- _intern2strings.TryAdd(op.Reference.DangerousGetAddress(), s);`
	`79`	`+ // Initialize is single-threaded; TryAdd preserves the original`
	`80`	`+ // single-write invariant via Debug.Assert without crashing release.`
	`81`	`+ bool a = _string2interns.TryAdd(s, op);`
	`82`	`+ bool b = _intern2strings.TryAdd(op.Reference.DangerousGetAddress(), s);`
	`83`	`+ Debug.Assert(a && b);`
`81`	`84`	`}`
`82`	`85`	`}`
`83`	`86`	`}`