Add new tests for subclassing .net classes.

tonyroberts · tonyroberts · commit 30cc22a65909 · 2014-11-04T17:00:07.000Z
diff --git a/src/testing/Python.Test.csproj b/src/testing/Python.Test.csproj
@@ -120,6 +120,7 @@
     <Compile Include="propertytest.cs" />
     <Compile Include="threadtest.cs" />
     <Compile Include="doctest.cs" />
+    <Compile Include="subclasstest.cs" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System" />
diff --git a/src/testing/subclasstest.cs b/src/testing/subclasstest.cs
@@ -0,0 +1,79 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Python.Test
+{
+    public interface IInterfaceTest
+    {
+        // simple test with no arguments
+        string foo();
+
+        // test passing objects and boxing primitives
+        string bar(string s, int i);
+    }
+
+    public class SubClassTest : IInterfaceTest
+    {
+        public SubClassTest()
+        {
+        }
+
+        // simple test with no arguments
+        public virtual string foo()
+        {
+            return "foo";
+        }
+
+        // test passing objects and boxing primitives
+        public virtual string bar(string s, int i)
+        {
+            return s;
+        }
+
+        // virtual methods that aren't overriden in python still work
+        public virtual string not_overriden()
+        {
+            return "not_overriden";
+        }
+
+        public virtual IList<string> return_list()
+        {
+            return new List<string> { "a", "b", "c" };
+        }
+
+        public static IList<string> test_list(SubClassTest x)
+        {
+            // calls into python if return_list is overriden
+            return x.return_list();
+        }
+    }
+
+    public class TestFunctions
+    {
+        public static string test_foo(IInterfaceTest x)
+        {
+            // calls into python if foo is overriden
+            return x.foo();
+        }
+
+        public static string test_bar(IInterfaceTest x, string s, int i)
+        {
+            // calls into python if bar is overriden
+            return x.bar(s, i);
+        }
+
+        // test instances can be constructed in managed code
+        public static IInterfaceTest create_instance(Type t)
+        {
+            return (IInterfaceTest)t.GetConstructor(new Type[] {}).Invoke(new Object[] {});
+        }
+
+        // test instances pass through managed code unchanged
+        public static IInterfaceTest pass_through(IInterfaceTest s)
+        {
+            return s;
+        }
+    }
+}
diff --git a/src/tests/test_subclass.py b/src/tests/test_subclass.py
@@ -0,0 +1,119 @@
+# ===========================================================================
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# ===========================================================================
+import clr
+clr.AddReference('Python.Test')
+clr.AddReference('System')
+
+import sys, os, string, unittest, types
+from Python.Test import TestFunctions, SubClassTest, IInterfaceTest
+from System.Collections.Generic import List
+
+# class that implements the test interface
+class InterfaceTestClass(IInterfaceTest):
+    __namespace__ = "Python.Test"
+
+    def foo(self):
+        return "InterfaceTestClass"
+
+    def bar(self, x, i):
+        return "/".join([x] * i)
+
+# class that derives from a class deriving from IInterfaceTest
+class DerivedClass(SubClassTest):
+    __namespace__ = "Python.Test"
+
+    def foo(self):
+        return "DerivedClass"
+
+    def base_foo(self):
+        return SubClassTest.foo(self)
+
+    def super_foo(self):
+        return super(DerivedClass, self).foo()
+
+    def bar(self, x, i):
+        return "_".join([x] * i)
+
+    def return_list(self):
+        l = List[str]()
+        l.Add("A")
+        l.Add("B")
+        l.Add("C")
+        return l
+
+class SubClassTests(unittest.TestCase):
+    """Test subclassing managed types"""
+
+    def testBaseClass(self):
+        """Test base class managed type"""
+        object = SubClassTest()
+        self.assertEqual(object.foo(), "foo")
+        self.assertEqual(TestFunctions.test_foo(object), "foo")
+        self.assertEqual(object.bar("bar", 2), "bar")
+        self.assertEqual(TestFunctions.test_bar(object, "bar", 2), "bar")
+        self.assertEqual(object.not_overriden(), "not_overriden")
+        self.assertEqual(list(object.return_list()), ["a", "b", "c"])
+        self.assertEqual(list(SubClassTest.test_list(object)), ["a", "b", "c"])
+
+    def testInterface(self):
+        """Test python classes can derive from C# interfaces"""
+        object = InterfaceTestClass()
+        self.assertEqual(object.foo(), "InterfaceTestClass")
+        self.assertEqual(TestFunctions.test_foo(object), "InterfaceTestClass")
+        self.assertEqual(object.bar("bar", 2), "bar/bar")
+        self.assertEqual(TestFunctions.test_bar(object, "bar", 2), "bar/bar")
+
+        x = TestFunctions.pass_through(object)
+        self.assertEqual(id(x), id(object))
+
+    def testDerivedClass(self):
+        """Test python class derived from managed type"""
+        object = DerivedClass()
+        self.assertEqual(object.foo(), "DerivedClass")
+        self.assertEqual(object.base_foo(), "foo")
+        self.assertEqual(object.super_foo(), "foo")
+        self.assertEqual(TestFunctions.test_foo(object), "DerivedClass")
+        self.assertEqual(object.bar("bar", 2), "bar_bar")
+        self.assertEqual(TestFunctions.test_bar(object, "bar", 2), "bar_bar")
+        self.assertEqual(object.not_overriden(), "not_overriden")
+        self.assertEqual(list(object.return_list()), ["A", "B", "C"])
+        self.assertEqual(list(SubClassTest.test_list(object)), ["A", "B", "C"])
+
+        x = TestFunctions.pass_through(object)
+        self.assertEqual(id(x), id(object))
+
+    def testCreateInstance(self):
+        """Test derived instances can be created from managed code"""
+        object = TestFunctions.create_instance(DerivedClass)
+        self.assertEqual(object.foo(), "DerivedClass")
+        self.assertEqual(TestFunctions.test_foo(object), "DerivedClass")
+        self.assertEqual(object.bar("bar", 2), "bar_bar")
+        self.assertEqual(TestFunctions.test_bar(object, "bar", 2), "bar_bar")
+        self.assertEqual(object.not_overriden(), "not_overriden")
+
+        x = TestFunctions.pass_through(object)
+        self.assertEqual(id(x), id(object))
+
+        object2 = TestFunctions.create_instance(InterfaceTestClass)
+        self.assertEqual(object2.foo(), "InterfaceTestClass")
+        self.assertEqual(TestFunctions.test_foo(object2), "InterfaceTestClass")
+        self.assertEqual(object2.bar("bar", 2), "bar/bar")
+        self.assertEqual(TestFunctions.test_bar(object2, "bar", 2), "bar/bar")
+
+        y = TestFunctions.pass_through(object2)
+        self.assertEqual(id(y), id(object2))
+
+def test_suite():
+    return unittest.makeSuite(SubClassTests)
+
+def main():
+    unittest.TextTestRunner().run(test_suite())
+
+if __name__ == '__main__':
+    main()
