Add super() tests from magicsuper and Py3.3

Author: edschofield

future/tests/test_magicsuper.py

@@ -0,0 +1,131 @@
+"""
+Tests for the super() function.
+
+Based on Ryan Kelly's magicsuper.tests
+"""
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+import future.builtins.newsuper
+from future.builtins import super
+from future.tests.base import unittest
+from future.utils import PY2
+
+
+class TestMagicSuper(unittest.TestCase):
+
+    def test_basic_diamond(self):
+        class Base(object):
+            def calc(self,value):
+                return 2 * value
+        class Sub1(Base):
+            def calc(self,value):
+                return 7 + super().calc(value)
+        class Sub2(Base):
+            def calc(self,value):
+                return super().calc(value) - 1
+        class Diamond(Sub1,Sub2):
+            def calc(self,value):
+                return 3 * super().calc(value)
+        b = Base()
+        s1 = Sub1()
+        s2 = Sub2()
+        d = Diamond()
+        for x in range(10):
+            self.assertEquals(b.calc(x),2*x)
+            self.assertEquals(s1.calc(x),7+(2*x))
+            self.assertEquals(s2.calc(x),(2*x)-1)
+            self.assertEquals(d.calc(x),3*(7+((2*x)-1)))
+
+    def test_with_unrelated_methods(self):
+        class Base(object):
+            def hello(self):
+                return "world"
+        class Sub(Base):
+            def hello(self):
+                return "hello " + super().hello()
+            def other(self):
+                pass
+        class SubSub(Sub):
+            def other(self):
+                return super().other()
+        ss = SubSub()
+        self.assertEquals(ss.hello(),"hello world")
+
+    def test_fails_for_oldstyle_class(self):
+        class OldStyle:
+            def testme(self):
+                return super().testme()
+        o = OldStyle()
+        self.assertRaises(RuntimeError,o.testme)
+
+    def test_fails_for_raw_functions(self):
+        def not_a_method():
+            super().not_a_method()
+        self.assertRaises(RuntimeError,not_a_method)
+        def not_a_method(self):
+            super().not_a_method()
+        self.assertRaises(RuntimeError,not_a_method,self)
+
+    def assertSuperEquals(self,sobj1,sobj2):
+        assert sobj1.__self__ is sobj2.__self__
+        assert sobj1.__self_class__ is sobj2.__self_class__
+        assert sobj1.__thisclass__ is sobj2.__thisclass__
+
+    def test_call_with_args_does_nothing(self):
+        if PY2:
+            from __builtin__ import super as builtin_super
+        else:
+            from builtins import super as builtin_super
+        class Base(object):
+            def calc(self,value):
+                return 2 * value
+        class Sub1(Base):
+            def calc(self,value):
+                return 7 + super().calc(value)
+        class Sub2(Base):
+            def calc(self,value):
+                return super().calc(value) - 1
+        class Diamond(Sub1,Sub2):
+            def calc(self,value):
+                return 3 * super().calc(value)
+        for cls in (Base,Sub1,Sub2,Diamond,):
+            obj = cls()
+            self.assertSuperEquals(builtin_super(cls), super(cls))
+            self.assertSuperEquals(builtin_super(cls,obj), super(cls,obj))
+
+    def test_superm(self):
+        class Base(object):
+            def getit(self):
+                return 2
+        class Sub(Base):
+            def getit(self):
+                return 10 * future.builtins.newsuper.superm()
+        s = Sub()
+        self.assertEquals(s.getit(),20)
+
+    def test_use_inside_dunder_new(self):
+        class Terminal(str):
+            def __new__(cls, value, token_type):
+                self = super().__new__(cls, value)
+                self.token_type = token_type
+                return self
+        DOT = Terminal(".", "dit")
+        self.assertTrue(isinstance(DOT, str))
+        self.assertTrue(isinstance(DOT, Terminal))
+
+    def test_use_inside_classmethod(self):
+        class Base(object):
+            @classmethod
+            def getit(cls):
+                return 42
+        class Singleton(Base):
+            @classmethod
+            def getit(cls):
+                print(super())
+                return super().getit() + 1
+        self.assertEquals(Singleton.getit(), 43)
+
+
+if __name__ == '__main__':
+    unittest.main()
+

future/tests/test_super.py

@@ -0,0 +1,152 @@
+"""Unit tests for new super() implementation."""
+
+import sys
+import unittest
+from test import support
+
+
+class A:
+    def f(self):
+        return 'A'
+    @classmethod
+    def cm(cls):
+        return (cls, 'A')
+
+class B(A):
+    def f(self):
+        return super().f() + 'B'
+    @classmethod
+    def cm(cls):
+        return (cls, super().cm(), 'B')
+
+class C(A):
+    def f(self):
+        return super().f() + 'C'
+    @classmethod
+    def cm(cls):
+        return (cls, super().cm(), 'C')
+
+class D(C, B):
+    def f(self):
+        return super().f() + 'D'
+    def cm(cls):
+        return (cls, super().cm(), 'D')
+
+class E(D):
+    pass
+
+class F(E):
+    f = E.f
+
+class G(A):
+    pass
+
+
+class TestSuper(unittest.TestCase):
+
+    def test_basics_working(self):
+        self.assertEqual(D().f(), 'ABCD')
+
+    def test_class_getattr_working(self):
+        self.assertEqual(D.f(D()), 'ABCD')
+
+    def test_subclass_no_override_working(self):
+        self.assertEqual(E().f(), 'ABCD')
+        self.assertEqual(E.f(E()), 'ABCD')
+
+    def test_unbound_method_transfer_working(self):
+        self.assertEqual(F().f(), 'ABCD')
+        self.assertEqual(F.f(F()), 'ABCD')
+
+    def test_class_methods_still_working(self):
+        self.assertEqual(A.cm(), (A, 'A'))
+        self.assertEqual(A().cm(), (A, 'A'))
+        self.assertEqual(G.cm(), (G, 'A'))
+        self.assertEqual(G().cm(), (G, 'A'))
+
+    def test_super_in_class_methods_working(self):
+        d = D()
+        self.assertEqual(d.cm(), (d, (D, (D, (D, 'A'), 'B'), 'C'), 'D'))
+        e = E()
+        self.assertEqual(e.cm(), (e, (E, (E, (E, 'A'), 'B'), 'C'), 'D'))
+
+    def test_super_with_closure(self):
+        # Issue4360: super() did not work in a function that
+        # contains a closure
+        class E(A):
+            def f(self):
+                def nested():
+                    self
+                return super().f() + 'E'
+
+        self.assertEqual(E().f(), 'AE')
+
+    @unittest.expectedFailure
+    def test___class___set(self):
+        # See issue #12370
+        class X(A):
+            def f(self):
+                return super().f()
+            __class__ = 413
+        x = X()
+        self.assertEqual(x.f(), 'A')
+        self.assertEqual(x.__class__, 413)
+
+    def test___class___instancemethod(self):
+        # See issue #14857
+        class X:
+            def f(self):
+                return __class__
+        self.assertIs(X().f(), X)
+
+    def test___class___classmethod(self):
+        # See issue #14857
+        class X:
+            @classmethod
+            def f(cls):
+                return __class__
+        self.assertIs(X.f(), X)
+
+    def test___class___staticmethod(self):
+        # See issue #14857
+        class X:
+            @staticmethod
+            def f():
+                return __class__
+        self.assertIs(X.f(), X)
+
+    def test_obscure_super_errors(self):
+        def f():
+            super()
+        self.assertRaises(RuntimeError, f)
+        def f(x):
+            del x
+            super()
+        self.assertRaises(RuntimeError, f, None)
+        class X:
+            def f(x):
+                nonlocal __class__
+                del __class__
+                super()
+        self.assertRaises(RuntimeError, X().f)
+
+    def test_cell_as_self(self):
+        class X:
+            def meth(self):
+                super()
+
+        def f():
+            k = X()
+            def g():
+                return k
+            return g
+        c = f().__closure__[0]
+        self.assertRaises(TypeError, X.meth, c)
+
+
+def test_main():
+    support.run_unittest(TestSuper)
+
+
+if __name__ == "__main__":
+    unittest.main()