Debian Codegraph @

Lib/test/test_genericclass.py

raw
1 import unittest
2 from test import support
3 from test.support.import_helper import import_module
4
5
6 class TestMROEntry(unittest.TestCase):
7 def test_mro_entry_signature(self):
8 tested = []
9 class B: ...
10 class C:
11 def __mro_entries__(self, *args, **kwargs):
12 tested.extend([args, kwargs])
13 return (C,)
14 c = C()
15 self.assertEqual(tested, [])
16 class D(B, c): ...
17 self.assertEqual(tested[0], ((B, c),))
18 self.assertEqual(tested[1], {})
19
20 def test_mro_entry(self):
21 tested = []
22 class A: ...
23 class B: ...
24 class C:
25 def __mro_entries__(self, bases):
26 tested.append(bases)
27 return (self.__class__,)
28 c = C()
29 self.assertEqual(tested, [])
30 class D(A, c, B): ...
31 self.assertEqual(tested[-1], (A, c, B))
32 self.assertEqual(D.__bases__, (A, C, B))
33 self.assertEqual(D.__orig_bases__, (A, c, B))
34 self.assertEqual(D.__mro__, (D, A, C, B, object))
35 d = D()
36 class E(d): ...
37 self.assertEqual(tested[-1], (d,))
38 self.assertEqual(E.__bases__, (D,))
39
40 def test_mro_entry_none(self):
41 tested = []
42 class A: ...
43 class B: ...
44 class C:
45 def __mro_entries__(self, bases):
46 tested.append(bases)
47 return ()
48 c = C()
49 self.assertEqual(tested, [])
50 class D(A, c, B): ...
51 self.assertEqual(tested[-1], (A, c, B))
52 self.assertEqual(D.__bases__, (A, B))
53 self.assertEqual(D.__orig_bases__, (A, c, B))
54 self.assertEqual(D.__mro__, (D, A, B, object))
55 class E(c): ...
56 self.assertEqual(tested[-1], (c,))
57 self.assertEqual(E.__bases__, (object,))
58 self.assertEqual(E.__orig_bases__, (c,))
59 self.assertEqual(E.__mro__, (E, object))
60
61 def test_mro_entry_with_builtins(self):
62 tested = []
63 class A: ...
64 class C:
65 def __mro_entries__(self, bases):
66 tested.append(bases)
67 return (dict,)
68 c = C()
69 self.assertEqual(tested, [])
70 class D(A, c): ...
71 self.assertEqual(tested[-1], (A, c))
72 self.assertEqual(D.__bases__, (A, dict))
73 self.assertEqual(D.__orig_bases__, (A, c))
74 self.assertEqual(D.__mro__, (D, A, dict, object))
75
76 def test_mro_entry_with_builtins_2(self):
77 tested = []
78 class C:
79 def __mro_entries__(self, bases):
80 tested.append(bases)
81 return (C,)
82 c = C()
83 self.assertEqual(tested, [])
84 class D(c, dict): ...
85 self.assertEqual(tested[-1], (c, dict))
86 self.assertEqual(D.__bases__, (C, dict))
87 self.assertEqual(D.__orig_bases__, (c, dict))
88 self.assertEqual(D.__mro__, (D, C, dict, object))
89
90 def test_mro_entry_errors(self):
91 class C_too_many:
92 def __mro_entries__(self, bases, something, other):
93 return ()
94 c = C_too_many()
95 with self.assertRaises(TypeError):
96 class D(c): ...
97 class C_too_few:
98 def __mro_entries__(self):
99 return ()
100 d = C_too_few()
101 with self.assertRaises(TypeError):
102 class E(d): ...
103
104 def test_mro_entry_errors_2(self):
105 class C_not_callable:
106 __mro_entries__ = "Surprise!"
107 c = C_not_callable()
108 with self.assertRaises(TypeError):
109 class D(c): ...
110 class C_not_tuple:
111 def __mro_entries__(self):
112 return object
113 c = C_not_tuple()
114 with self.assertRaises(TypeError):
115 class E(c): ...
116
117 def test_mro_entry_metaclass(self):
118 meta_args = []
119 class Meta(type):
120 def __new__(mcls, name, bases, ns):
121 meta_args.extend([mcls, name, bases, ns])
122 return super().__new__(mcls, name, bases, ns)
123 class A: ...
124 class C:
125 def __mro_entries__(self, bases):
126 return (A,)
127 c = C()
128 class D(c, metaclass=Meta):
129 x = 1
130 self.assertEqual(meta_args[0], Meta)
131 self.assertEqual(meta_args[1], 'D')
132 self.assertEqual(meta_args[2], (A,))
133 self.assertEqual(meta_args[3]['x'], 1)
134 self.assertEqual(D.__bases__, (A,))
135 self.assertEqual(D.__orig_bases__, (c,))
136 self.assertEqual(D.__mro__, (D, A, object))
137 self.assertEqual(D.__class__, Meta)
138
139 def test_mro_entry_type_call(self):
140 # Substitution should _not_ happen in direct type call
141 class C:
142 def __mro_entries__(self, bases):
143 return ()
144 c = C()
145 with self.assertRaisesRegex(TypeError,
146 "MRO entry resolution; "
147 "use types.new_class()"):
148 type('Bad', (c,), {})
149
150
151 class TestClassGetitem(unittest.TestCase):
152 def test_class_getitem(self):
153 getitem_args = []
154 class C:
155 def __class_getitem__(*args, **kwargs):
156 getitem_args.extend([args, kwargs])
157 return None
158 C[int, str]
159 self.assertEqual(getitem_args[0], (C, (int, str)))
160 self.assertEqual(getitem_args[1], {})
161
162 def test_class_getitem_format(self):
163 class C:
164 def __class_getitem__(cls, item):
165 return f'C[{item.__name__}]'
166 self.assertEqual(C[int], 'C[int]')
167 self.assertEqual(C[C], 'C[C]')
168
169 def test_class_getitem_inheritance(self):
170 class C:
171 def __class_getitem__(cls, item):
172 return f'{cls.__name__}[{item.__name__}]'
173 class D(C): ...
174 self.assertEqual(D[int], 'D[int]')
175 self.assertEqual(D[D], 'D[D]')
176
177 def test_class_getitem_inheritance_2(self):
178 class C:
179 def __class_getitem__(cls, item):
180 return 'Should not see this'
181 class D(C):
182 def __class_getitem__(cls, item):
183 return f'{cls.__name__}[{item.__name__}]'
184 self.assertEqual(D[int], 'D[int]')
185 self.assertEqual(D[D], 'D[D]')
186
187 def test_class_getitem_classmethod(self):
188 class C:
189 @classmethod
190 def __class_getitem__(cls, item):
191 return f'{cls.__name__}[{item.__name__}]'
192 class D(C): ...
193 self.assertEqual(D[int], 'D[int]')
194 self.assertEqual(D[D], 'D[D]')
195
196 def test_class_getitem_patched(self):
197 class C:
198 def __init_subclass__(cls):
199 def __class_getitem__(cls, item):
200 return f'{cls.__name__}[{item.__name__}]'
201 cls.__class_getitem__ = classmethod(__class_getitem__)
202 class D(C): ...
203 self.assertEqual(D[int], 'D[int]')
204 self.assertEqual(D[D], 'D[D]')
205
206 def test_class_getitem_with_builtins(self):
207 class A(dict):
208 called_with = None
209
210 def __class_getitem__(cls, item):
211 cls.called_with = item
212 class B(A):
213 pass
214 self.assertIs(B.called_with, None)
215 B[int]
216 self.assertIs(B.called_with, int)
217
218 def test_class_getitem_errors(self):
219 class C_too_few:
220 def __class_getitem__(cls):
221 return None
222 with self.assertRaises(TypeError):
223 C_too_few[int]
224
225 class C_too_many:
226 def __class_getitem__(cls, one, two):
227 return None
228 with self.assertRaises(TypeError):
229 C_too_many[int]
230
231 def test_class_getitem_errors_2(self):
232 class C:
233 def __class_getitem__(cls, item):
234 return None
235 with self.assertRaises(TypeError):
236 C()[int]
237
238 class E: ...
239 e = E()
240 e.__class_getitem__ = lambda cls, item: 'This will not work'
241 with self.assertRaises(TypeError):
242 e[int]
243
244 class C_not_callable:
245 __class_getitem__ = "Surprise!"
246 with self.assertRaises(TypeError):
247 C_not_callable[int]
248
249 class C_is_none(tuple):
250 __class_getitem__ = None
251 with self.assertRaisesRegex(TypeError, "C_is_none"):
252 C_is_none[int]
253
254 def test_class_getitem_metaclass(self):
255 class Meta(type):
256 def __class_getitem__(cls, item):
257 return f'{cls.__name__}[{item.__name__}]'
258 self.assertEqual(Meta[int], 'Meta[int]')
259
260 def test_class_getitem_with_metaclass(self):
261 class Meta(type): pass
262 class C(metaclass=Meta):
263 def __class_getitem__(cls, item):
264 return f'{cls.__name__}[{item.__name__}]'
265 self.assertEqual(C[int], 'C[int]')
266
267 def test_class_getitem_metaclass_first(self):
268 class Meta(type):
269 def __getitem__(cls, item):
270 return 'from metaclass'
271 class C(metaclass=Meta):
272 def __class_getitem__(cls, item):
273 return 'from __class_getitem__'
274 self.assertEqual(C[int], 'from metaclass')
275
276
277 @support.cpython_only
278 class CAPITest(unittest.TestCase):
279
280 def test_c_class(self):
281 _testcapi = import_module("_testcapi")
282 Generic = _testcapi.Generic
283 GenericAlias = _testcapi.GenericAlias
284 self.assertIsInstance(Generic.__class_getitem__(int), GenericAlias)
285
286 IntGeneric = Generic[int]
287 self.assertIs(type(IntGeneric), GenericAlias)
288 self.assertEqual(IntGeneric.__mro_entries__(()), (int,))
289 class C(IntGeneric):
290 pass
291 self.assertEqual(C.__bases__, (int,))
292 self.assertEqual(C.__orig_bases__, (IntGeneric,))
293 self.assertEqual(C.__mro__, (C, int, object))
294
295
296 if __name__ == "__main__":
297 unittest.main()