Support managed delegates wrapped in PyObjects

Add more unit tests

Author: jhonabreul

src/embed_tests/TestMethodBinder.cs

@@ -67,7 +67,7 @@ def TestEnumerable(self):
         public static dynamic Numpy;
 
         [OneTimeSetUp]
-        public void SetUp()
+        public void OneTimeSetUp()
         {
             PythonEngine.Initialize();
             using var _ = Py.GIL();
@@ -89,6 +89,14 @@ public void Dispose()
             PythonEngine.Shutdown();
         }
 
+        [SetUp]
+        public void SetUp()
+        {
+            CSharpModel.LastDelegateCalled = null;
+            CSharpModel.LastFuncCalled = null;
+            CSharpModel.MethodCalled = null;
+        }
+
         [Test]
         public void MethodCalledList()
         {
@@ -1152,8 +1160,13 @@ def call_method():
             Assert.AreEqual("MethodWithEnumParam With Enum", result.As<string>());
         }
 
-        [Test]
-        public void BindsPythonToCSharpFuncDelegates()
+        [TestCase("call_method_with_func1", "MethodWithFunc1", "func1")]
+        [TestCase("call_method_with_func2", "MethodWithFunc2", "func2")]
+        [TestCase("call_method_with_func3", "MethodWithFunc3", "func3")]
+        [TestCase("call_method_with_func1_lambda", "MethodWithFunc1", "func1")]
+        [TestCase("call_method_with_func2_lambda", "MethodWithFunc2", "func2")]
+        [TestCase("call_method_with_func3_lambda", "MethodWithFunc3", "func3")]
+        public void BindsPythonToCSharpFuncDelegates(string pythonFuncToCall, string expectedCSharpMethodCalled, string expectedPythonFuncCalled)
         {
             using var _ = Py.GIL();
 
@@ -1202,61 +1215,28 @@ def call_method_with_func3_lambda():
     return TestMethodBinder.CSharpModel.MethodWithFunc3(lambda model1, model2: func3(model1, model2))
 ");
 
-            using var pythonModel = module.GetAttr("PythonModel");
-
-            var assertCalledMethods = (string csharpCalledMethod, string pythonCalledMethod) =>
-            {
-                Assert.AreEqual(csharpCalledMethod, CSharpModel.LastDelegateCalled);
-                var lastDelegateCalled = pythonModel.GetAttr("last_delegate_called");
-                Assert.AreEqual(pythonCalledMethod, lastDelegateCalled.As<string>());
-                lastDelegateCalled.Dispose();
-            };
-
+            CSharpModel managedResult = null;
             Assert.DoesNotThrow(() =>
             {
-                using var result = module.GetAttr("call_method_with_func1").Invoke();
-                var managedResult = result.As<CSharpModel>();
+                using var result = module.GetAttr(pythonFuncToCall).Invoke();
+                managedResult = result.As<CSharpModel>();
             });
-            assertCalledMethods("MethodWithFunc1", "func1");
 
-            Assert.DoesNotThrow(() =>
-            {
-                using var result = module.GetAttr("call_method_with_func2").Invoke();
-                var managedResult = result.As<CSharpModel>();
-            });
-            assertCalledMethods("MethodWithFunc2", "func2");
-
-            Assert.DoesNotThrow(() =>
-            {
-                using var result = module.GetAttr("call_method_with_func3").Invoke();
-                var managedResult = result.As<CSharpModel>();
-            });
-            assertCalledMethods("MethodWithFunc3", "func3");
-
-            Assert.DoesNotThrow(() =>
-            {
-                using var result = module.GetAttr("call_method_with_func1_lambda").Invoke();
-                var managedResult = result.As<CSharpModel>();
-            });
-            assertCalledMethods("MethodWithFunc1", "func1");
-
-            Assert.DoesNotThrow(() =>
-            {
-                using var result = module.GetAttr("call_method_with_func2_lambda").Invoke();
-                var managedResult = result.As<CSharpModel>();
-            });
-            assertCalledMethods("MethodWithFunc2", "func2");
+            Assert.IsNotNull(managedResult);
+            Assert.AreEqual(expectedCSharpMethodCalled, CSharpModel.LastDelegateCalled);
 
-            Assert.DoesNotThrow(() =>
-            {
-                using var result = module.GetAttr("call_method_with_func3_lambda").Invoke();
-                var managedResult = result.As<CSharpModel>();
-            });
-            assertCalledMethods("MethodWithFunc3", "func3");
+            using var pythonModel = module.GetAttr("PythonModel");
+            using var lastDelegateCalled = pythonModel.GetAttr("last_delegate_called");
+            Assert.AreEqual(expectedPythonFuncCalled, lastDelegateCalled.As<string>());
         }
 
-        [Test]
-        public void BindsPythonToCSharpActionDelegates()
+        [TestCase("call_method_with_action1", "MethodWithAction1", "action1")]
+        [TestCase("call_method_with_action2", "MethodWithAction2", "action2")]
+        [TestCase("call_method_with_action3", "MethodWithAction3", "action3")]
+        [TestCase("call_method_with_action1_lambda", "MethodWithAction1", "action1")]
+        [TestCase("call_method_with_action2_lambda", "MethodWithAction2", "action2")]
+        [TestCase("call_method_with_action3_lambda", "MethodWithAction3", "action3")]
+        public void BindsPythonToCSharpActionDelegates(string pythonFuncToCall, string expectedCSharpMethodCalled, string expectedPythonFuncCalled)
         {
             using var _ = Py.GIL();
 
@@ -1305,51 +1285,79 @@ def call_method_with_action3_lambda():
     return TestMethodBinder.CSharpModel.MethodWithAction3(lambda model1, model2: action3(model1, model2))
 ");
 
-            using var pythonModel = module.GetAttr("PythonModel");
-
-            var assertCalledMethods = (string csharpCalledMethod, string pythonCalledMethod) =>
-            {
-                Assert.AreEqual(csharpCalledMethod, CSharpModel.LastDelegateCalled);
-                var lastDelegateCalled = pythonModel.GetAttr("last_delegate_called");
-                Assert.AreEqual(pythonCalledMethod, lastDelegateCalled.As<string>());
-                lastDelegateCalled.Dispose();
-            };
-
             Assert.DoesNotThrow(() =>
             {
-                using var result = module.GetAttr("call_method_with_action1").Invoke();
+                using var result = module.GetAttr(pythonFuncToCall).Invoke();
             });
-            assertCalledMethods("MethodWithAction1", "action1");
 
-            Assert.DoesNotThrow(() =>
-            {
-                using var result = module.GetAttr("call_method_with_action2").Invoke();
-            });
-            assertCalledMethods("MethodWithAction2", "action2");
+            Assert.AreEqual(expectedCSharpMethodCalled, CSharpModel.LastDelegateCalled);
 
-            Assert.DoesNotThrow(() =>
-            {
-                using var result = module.GetAttr("call_method_with_action3").Invoke();
-            });
-            assertCalledMethods("MethodWithAction3", "action3");
+            using var pythonModel = module.GetAttr("PythonModel");
+            using var lastDelegateCalled = pythonModel.GetAttr("last_delegate_called");
+            Assert.AreEqual(expectedPythonFuncCalled, lastDelegateCalled.As<string>());
+        }
 
-            Assert.DoesNotThrow(() =>
-            {
-                using var result = module.GetAttr("call_method_with_action1_lambda").Invoke();
-            });
-            assertCalledMethods("MethodWithAction1", "action1");
+        [TestCase("call_method_with_func1", "MethodWithFunc1", "TestFunc1")]
+        [TestCase("call_method_with_func2", "MethodWithFunc2", "TestFunc2")]
+        [TestCase("call_method_with_func3", "MethodWithFunc3", "TestFunc3")]
+        public void BindsCSharpFuncFromPythonToCSharpFuncDelegates(string pythonFuncToCall, string expectedMethodCalled, string expectedInnerMethodCalled)
+        {
+            using var _ = Py.GIL();
 
+            var module = PyModule.FromString("BindsCSharpFuncFromPythonToCSharpFuncDelegates", @$"
+from clr import AddReference
+AddReference(""System"")
+from Python.EmbeddingTest import *
+
+def call_method_with_func1():
+    return TestMethodBinder.CSharpModel.MethodWithFunc1(TestMethodBinder.CSharpModel.TestFunc1)
+
+def call_method_with_func2():
+    return TestMethodBinder.CSharpModel.MethodWithFunc2(TestMethodBinder.CSharpModel.TestFunc2)
+
+def call_method_with_func3():
+    return TestMethodBinder.CSharpModel.MethodWithFunc3(TestMethodBinder.CSharpModel.TestFunc3)
+");
+
+            CSharpModel managedResult = null;
             Assert.DoesNotThrow(() =>
             {
-                using var result = module.GetAttr("call_method_with_action2_lambda").Invoke();
+                using var result = module.GetAttr(pythonFuncToCall).Invoke();
+                managedResult = result.As<CSharpModel>();
             });
-            assertCalledMethods("MethodWithAction2", "action2");
+            Assert.IsNotNull(managedResult);
+            Assert.AreEqual(expectedMethodCalled, CSharpModel.LastDelegateCalled);
+            Assert.AreEqual(expectedInnerMethodCalled, CSharpModel.LastFuncCalled);
+        }
+
+        [TestCase("call_method_with_action1", "MethodWithAction1", "TestAction1")]
+        [TestCase("call_method_with_action2", "MethodWithAction2", "TestAction2")]
+        [TestCase("call_method_with_action3", "MethodWithAction3", "TestAction3")]
+        public void BindsCSharpActionFromPythonToCSharpActionDelegates(string pythonFuncToCall, string expectedMethodCalled, string expectedInnerMethodCalled)
+        {
+            using var _ = Py.GIL();
+
+            var module = PyModule.FromString("BindsCSharpActionFromPythonToCSharpActionDelegates", @$"
+from clr import AddReference
+AddReference(""System"")
+from Python.EmbeddingTest import *
+
+def call_method_with_action1():
+    return TestMethodBinder.CSharpModel.MethodWithAction1(TestMethodBinder.CSharpModel.TestAction1)
+
+def call_method_with_action2():
+    return TestMethodBinder.CSharpModel.MethodWithAction2(TestMethodBinder.CSharpModel.TestAction2)
+
+def call_method_with_action3():
+    return TestMethodBinder.CSharpModel.MethodWithAction3(TestMethodBinder.CSharpModel.TestAction3)
+");
 
             Assert.DoesNotThrow(() =>
             {
-                using var result = module.GetAttr("call_method_with_action3_lambda").Invoke();
+                using var result = module.GetAttr(pythonFuncToCall).Invoke();
             });
-            assertCalledMethods("MethodWithAction3", "action3");
+            Assert.AreEqual(expectedMethodCalled, CSharpModel.LastDelegateCalled);
+            Assert.AreEqual(expectedInnerMethodCalled, CSharpModel.LastFuncCalled);
         }
 
         // Used to test that we match this function with Py DateTime & Date Objects
@@ -1489,7 +1497,8 @@ public static void MethodDateTimeAndTimeSpan(CSharpModel pepe, Func<DateTime, Da
                 AssertErrorNotOccurred();
             }
 
-            public static string LastDelegateCalled { get; private set; }
+            public static string LastDelegateCalled { get; set; }
+            public static string LastFuncCalled { get; set; }
 
             public static CSharpModel MethodWithFunc1(Func<CSharpModel> func)
             {
@@ -1532,6 +1541,55 @@ public static void MethodWithAction3(Action<CSharpModel, CSharpModel> action)
                 LastDelegateCalled = "MethodWithAction3";
                 action(new CSharpModel(), new CSharpModel());
             }
+
+            public static CSharpModel TestFunc1()
+            {
+                LastFuncCalled = "TestFunc1";
+                return new CSharpModel();
+            }
+
+            public static CSharpModel TestFunc2(CSharpModel model)
+            {
+                if (model == null)
+                {
+                    throw new ArgumentNullException(nameof(model));
+                }
+                LastFuncCalled = "TestFunc2";
+                return model;
+            }
+
+            public static CSharpModel TestFunc3(CSharpModel model1, CSharpModel model2)
+            {
+                if (model1 == null || model2 == null)
+                {
+                    throw new ArgumentNullException(model1 == null ? nameof(model1) : nameof(model2));
+                }
+                LastFuncCalled = "TestFunc3";
+                return model1;
+            }
+
+            public static void TestAction1()
+            {
+                LastFuncCalled = "TestAction1";
+            }
+
+            public static void TestAction2(CSharpModel model)
+            {
+                if (model == null)
+                {
+                    throw new ArgumentNullException(nameof(model));
+                }
+                LastFuncCalled = "TestAction2";
+            }
+
+            public static void TestAction3(CSharpModel model1, CSharpModel model2)
+            {
+                if (model1 == null || model2 == null)
+                {
+                    throw new ArgumentNullException(model1 == null ? nameof(model1) : nameof(model2));
+                }
+                LastFuncCalled = "TestAction3";
+            }
         }
 
         public class TestImplicitConversion

src/runtime/Converter.cs

@@ -505,8 +505,12 @@ internal static bool ToManagedValue(BorrowedReference value, Type obType,
                     result = cb.type.Value;
                     return true;
                 }
-                // shouldn't happen
-                return false;
+                // Method bindings will be handled below along with actual Python callables
+                if (mt is not MethodBinding)
+                {
+                    // shouldn't happen
+                    return false;
+                }
             }
 
             if (value == Runtime.PyNone && !obType.IsValueType)
@@ -515,12 +519,6 @@ internal static bool ToManagedValue(BorrowedReference value, Type obType,
                 return true;
             }
 
-            if (typeof(MulticastDelegate).IsAssignableFrom(obType) && Runtime.PyCallable_Check(value) != 0 &&
-                TryConvertToDelegate(value, obType, out result))
-            {
-                return true;
-            }
-
             if (obType.IsGenericType && obType.GetGenericTypeDefinition() == typeof(Nullable<>))
             {
                 if (value == Runtime.PyNone)
@@ -551,6 +549,11 @@ internal static bool ToManagedValue(BorrowedReference value, Type obType,
                 return ToEnum(value, obType, out result, setError, out usedImplicit);
             }
 
+            if (Runtime.PyCallable_Check(value) != 0 && TryConvertToDelegate(value, obType, out result))
+            {
+                return true;
+            }
+
             // Conversion to 'Object' is done based on some reasonable default
             // conversions (Python string -> managed string, Python int -> Int32 etc.).
             if (obType == objectType)
@@ -768,13 +771,13 @@ internal static bool TryConvertToDelegate(BorrowedReference pyValue, Type delega
 
                 if (types.Length > 0)
                 {
-                    var name = delegateType.FullName.Substring(0, delegateType.FullName.IndexOf('`'));
-                    code = $"import System; delegate = {name}[{code.Substring(1)}](pyCallable)";
+                    var name = delegateType.Name.Substring(0, delegateType.Name.IndexOf('`'));
+                    code = $"from System import {name}; delegate = {name}[{code.Substring(1)}](pyCallable)";
                 }
                 else
                 {
-                    var name = delegateType.FullName;
-                    code = $"import System; delegate = {name}(pyCallable)";
+                    var name = delegateType.Name;
+                    code = $"from System import {name}; delegate = {name}(pyCallable)";
                 }
 
                 PythonEngine.Exec(code, null, locals);