Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 1 | """Unit tests for new super() implementation.""" |
| 2 | |
| 3 | import sys |
| 4 | import unittest |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 5 | from test import support |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 6 | |
| 7 | |
| 8 | class A: |
| 9 | def f(self): |
| 10 | return 'A' |
| 11 | @classmethod |
| 12 | def cm(cls): |
| 13 | return (cls, 'A') |
| 14 | |
| 15 | class B(A): |
| 16 | def f(self): |
| 17 | return super().f() + 'B' |
| 18 | @classmethod |
| 19 | def cm(cls): |
| 20 | return (cls, super().cm(), 'B') |
| 21 | |
| 22 | class C(A): |
| 23 | def f(self): |
| 24 | return super().f() + 'C' |
| 25 | @classmethod |
| 26 | def cm(cls): |
| 27 | return (cls, super().cm(), 'C') |
| 28 | |
| 29 | class D(C, B): |
| 30 | def f(self): |
| 31 | return super().f() + 'D' |
| 32 | def cm(cls): |
| 33 | return (cls, super().cm(), 'D') |
| 34 | |
| 35 | class E(D): |
| 36 | pass |
| 37 | |
| 38 | class F(E): |
| 39 | f = E.f |
| 40 | |
| 41 | class G(A): |
| 42 | pass |
| 43 | |
| 44 | |
| 45 | class TestSuper(unittest.TestCase): |
| 46 | |
Benjamin Peterson | a29ac45 | 2013-05-17 11:33:26 -0500 | [diff] [blame] | 47 | def tearDown(self): |
| 48 | # This fixes the damage that test_various___class___pathologies does. |
| 49 | nonlocal __class__ |
| 50 | __class__ = TestSuper |
| 51 | |
Benjamin Peterson | 206cd1c | 2011-06-19 17:49:13 -0500 | [diff] [blame] | 52 | def test_basics_working(self): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 53 | self.assertEqual(D().f(), 'ABCD') |
| 54 | |
Benjamin Peterson | 206cd1c | 2011-06-19 17:49:13 -0500 | [diff] [blame] | 55 | def test_class_getattr_working(self): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 56 | self.assertEqual(D.f(D()), 'ABCD') |
| 57 | |
Benjamin Peterson | 206cd1c | 2011-06-19 17:49:13 -0500 | [diff] [blame] | 58 | def test_subclass_no_override_working(self): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 59 | self.assertEqual(E().f(), 'ABCD') |
| 60 | self.assertEqual(E.f(E()), 'ABCD') |
| 61 | |
Benjamin Peterson | 206cd1c | 2011-06-19 17:49:13 -0500 | [diff] [blame] | 62 | def test_unbound_method_transfer_working(self): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 63 | self.assertEqual(F().f(), 'ABCD') |
| 64 | self.assertEqual(F.f(F()), 'ABCD') |
| 65 | |
Benjamin Peterson | 206cd1c | 2011-06-19 17:49:13 -0500 | [diff] [blame] | 66 | def test_class_methods_still_working(self): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 67 | self.assertEqual(A.cm(), (A, 'A')) |
| 68 | self.assertEqual(A().cm(), (A, 'A')) |
| 69 | self.assertEqual(G.cm(), (G, 'A')) |
| 70 | self.assertEqual(G().cm(), (G, 'A')) |
| 71 | |
Benjamin Peterson | 206cd1c | 2011-06-19 17:49:13 -0500 | [diff] [blame] | 72 | def test_super_in_class_methods_working(self): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 73 | d = D() |
| 74 | self.assertEqual(d.cm(), (d, (D, (D, (D, 'A'), 'B'), 'C'), 'D')) |
| 75 | e = E() |
| 76 | self.assertEqual(e.cm(), (e, (E, (E, (E, 'A'), 'B'), 'C'), 'D')) |
| 77 | |
Benjamin Peterson | 206cd1c | 2011-06-19 17:49:13 -0500 | [diff] [blame] | 78 | def test_super_with_closure(self): |
Barry Warsaw | 91cc8fb | 2008-11-20 20:01:57 +0000 | [diff] [blame] | 79 | # Issue4360: super() did not work in a function that |
| 80 | # contains a closure |
| 81 | class E(A): |
| 82 | def f(self): |
| 83 | def nested(): |
| 84 | self |
| 85 | return super().f() + 'E' |
| 86 | |
| 87 | self.assertEqual(E().f(), 'AE') |
| 88 | |
Benjamin Peterson | 312595c | 2013-05-15 15:26:42 -0500 | [diff] [blame] | 89 | def test_various___class___pathologies(self): |
Benjamin Peterson | f5ff223 | 2011-06-19 19:42:22 -0500 | [diff] [blame] | 90 | # See issue #12370 |
| 91 | class X(A): |
| 92 | def f(self): |
| 93 | return super().f() |
| 94 | __class__ = 413 |
| 95 | x = X() |
| 96 | self.assertEqual(x.f(), 'A') |
| 97 | self.assertEqual(x.__class__, 413) |
Benjamin Peterson | 312595c | 2013-05-15 15:26:42 -0500 | [diff] [blame] | 98 | class X: |
| 99 | x = __class__ |
| 100 | def f(): |
| 101 | __class__ |
| 102 | self.assertIs(X.x, type(self)) |
| 103 | with self.assertRaises(NameError) as e: |
| 104 | exec("""class X: |
| 105 | __class__ |
| 106 | def f(): |
| 107 | __class__""", globals(), {}) |
| 108 | self.assertIs(type(e.exception), NameError) # Not UnboundLocalError |
| 109 | class X: |
| 110 | global __class__ |
| 111 | __class__ = 42 |
| 112 | def f(): |
| 113 | __class__ |
| 114 | self.assertEqual(globals()["__class__"], 42) |
| 115 | del globals()["__class__"] |
| 116 | self.assertNotIn("__class__", X.__dict__) |
| 117 | class X: |
| 118 | nonlocal __class__ |
| 119 | __class__ = 42 |
| 120 | def f(): |
| 121 | __class__ |
| 122 | self.assertEqual(__class__, 42) |
Benjamin Peterson | f5ff223 | 2011-06-19 19:42:22 -0500 | [diff] [blame] | 123 | |
Nick Coghlan | 0b43bcf | 2012-05-27 18:17:07 +1000 | [diff] [blame] | 124 | def test___class___instancemethod(self): |
| 125 | # See issue #14857 |
| 126 | class X: |
| 127 | def f(self): |
| 128 | return __class__ |
| 129 | self.assertIs(X().f(), X) |
| 130 | |
| 131 | def test___class___classmethod(self): |
| 132 | # See issue #14857 |
| 133 | class X: |
| 134 | @classmethod |
| 135 | def f(cls): |
| 136 | return __class__ |
| 137 | self.assertIs(X.f(), X) |
| 138 | |
| 139 | def test___class___staticmethod(self): |
| 140 | # See issue #14857 |
| 141 | class X: |
| 142 | @staticmethod |
| 143 | def f(): |
| 144 | return __class__ |
| 145 | self.assertIs(X.f(), X) |
| 146 | |
Benjamin Peterson | 6a42bd6 | 2012-09-01 23:04:38 -0400 | [diff] [blame] | 147 | def test_obscure_super_errors(self): |
| 148 | def f(): |
| 149 | super() |
| 150 | self.assertRaises(RuntimeError, f) |
| 151 | def f(x): |
| 152 | del x |
| 153 | super() |
| 154 | self.assertRaises(RuntimeError, f, None) |
| 155 | class X: |
| 156 | def f(x): |
| 157 | nonlocal __class__ |
| 158 | del __class__ |
| 159 | super() |
| 160 | self.assertRaises(RuntimeError, X().f) |
| 161 | |
Benjamin Peterson | 159ae41 | 2013-05-12 18:16:06 -0500 | [diff] [blame] | 162 | def test_cell_as_self(self): |
| 163 | class X: |
| 164 | def meth(self): |
| 165 | super() |
| 166 | |
| 167 | def f(): |
| 168 | k = X() |
| 169 | def g(): |
| 170 | return k |
| 171 | return g |
| 172 | c = f().__closure__[0] |
| 173 | self.assertRaises(TypeError, X.meth, c) |
| 174 | |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 175 | |
| 176 | def test_main(): |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 177 | support.run_unittest(TestSuper) |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 178 | |
| 179 | |
| 180 | if __name__ == "__main__": |
| 181 | unittest.main() |