Debian Codegraph @

Lib/test/test_capi/test_type.py

raw
1 from test.support import import_helper, Py_GIL_DISABLED, refleak_helper
2 import unittest
3
4 _testcapi = import_helper.import_module('_testcapi')
5
6
7 class BuiltinStaticTypesTests(unittest.TestCase):
8
9 TYPES = [
10 object,
11 type,
12 int,
13 str,
14 dict,
15 type(None),
16 bool,
17 BaseException,
18 Exception,
19 Warning,
20 DeprecationWarning, # Warning subclass
21 ]
22
23 def test_tp_bases_is_set(self):
24 # PyTypeObject.tp_bases is documented as public API.
25 # See https://github.com/python/cpython/issues/105020.
26 for typeobj in self.TYPES:
27 with self.subTest(typeobj):
28 bases = _testcapi.type_get_tp_bases(typeobj)
29 self.assertIsNot(bases, None)
30
31 def test_tp_mro_is_set(self):
32 # PyTypeObject.tp_bases is documented as public API.
33 # See https://github.com/python/cpython/issues/105020.
34 for typeobj in self.TYPES:
35 with self.subTest(typeobj):
36 mro = _testcapi.type_get_tp_mro(typeobj)
37 self.assertIsNot(mro, None)
38
39
40 class TypeTests(unittest.TestCase):
41 def test_get_type_name(self):
42 class MyType:
43 pass
44
45 from _testcapi import (
46 get_type_name, get_type_qualname,
47 get_type_fullyqualname, get_type_module_name)
48
49 from collections import OrderedDict
50 ht = _testcapi.get_heaptype_for_name()
51 for cls, fullname, modname, qualname, name in (
52 (int,
53 'int',
54 'builtins',
55 'int',
56 'int'),
57 (OrderedDict,
58 'collections.OrderedDict',
59 'collections',
60 'OrderedDict',
61 'OrderedDict'),
62 (ht,
63 '_testcapi.HeapTypeNameType',
64 '_testcapi',
65 'HeapTypeNameType',
66 'HeapTypeNameType'),
67 (MyType,
68 f'{__name__}.TypeTests.test_get_type_name.<locals>.MyType',
69 __name__,
70 'TypeTests.test_get_type_name.<locals>.MyType',
71 'MyType'),
72 ):
73 with self.subTest(cls=repr(cls)):
74 self.assertEqual(get_type_fullyqualname(cls), fullname)
75 self.assertEqual(get_type_module_name(cls), modname)
76 self.assertEqual(get_type_qualname(cls), qualname)
77 self.assertEqual(get_type_name(cls), name)
78
79 # override __module__
80 ht.__module__ = 'test_module'
81 self.assertEqual(get_type_fullyqualname(ht), 'test_module.HeapTypeNameType')
82 self.assertEqual(get_type_module_name(ht), 'test_module')
83 self.assertEqual(get_type_qualname(ht), 'HeapTypeNameType')
84 self.assertEqual(get_type_name(ht), 'HeapTypeNameType')
85
86 # override __name__ and __qualname__
87 MyType.__name__ = 'my_name'
88 MyType.__qualname__ = 'my_qualname'
89 self.assertEqual(get_type_fullyqualname(MyType), f'{__name__}.my_qualname')
90 self.assertEqual(get_type_module_name(MyType), __name__)
91 self.assertEqual(get_type_qualname(MyType), 'my_qualname')
92 self.assertEqual(get_type_name(MyType), 'my_name')
93
94 # override also __module__
95 MyType.__module__ = 'my_module'
96 self.assertEqual(get_type_fullyqualname(MyType), 'my_module.my_qualname')
97 self.assertEqual(get_type_module_name(MyType), 'my_module')
98 self.assertEqual(get_type_qualname(MyType), 'my_qualname')
99 self.assertEqual(get_type_name(MyType), 'my_name')
100
101 # PyType_GetFullyQualifiedName() ignores the module if it's "builtins"
102 # or "__main__" of it is not a string
103 MyType.__module__ = 'builtins'
104 self.assertEqual(get_type_fullyqualname(MyType), 'my_qualname')
105 MyType.__module__ = '__main__'
106 self.assertEqual(get_type_fullyqualname(MyType), 'my_qualname')
107 MyType.__module__ = 123
108 self.assertEqual(get_type_fullyqualname(MyType), 'my_qualname')
109
110 def test_get_base_by_token(self):
111 def get_base_by_token(src, key, comparable=True):
112 def run(use_mro):
113 find_first = _testcapi.pytype_getbasebytoken
114 ret1, result = find_first(src, key, use_mro, True)
115 ret2, no_result = find_first(src, key, use_mro, False)
116 self.assertIn(ret1, (0, 1))
117 self.assertEqual(ret1, result is not None)
118 self.assertEqual(ret1, ret2)
119 self.assertIsNone(no_result)
120 return result
121
122 found_in_mro = run(True)
123 found_in_bases = run(False)
124 if comparable:
125 self.assertIs(found_in_mro, found_in_bases)
126 return found_in_mro
127 return found_in_mro, found_in_bases
128
129 create_type = _testcapi.create_type_with_token
130 get_token = _testcapi.get_tp_token
131
132 Py_TP_USE_SPEC = _testcapi.Py_TP_USE_SPEC
133 self.assertEqual(Py_TP_USE_SPEC, 0)
134
135 A1 = create_type('_testcapi.A1', Py_TP_USE_SPEC)
136 self.assertTrue(get_token(A1) != Py_TP_USE_SPEC)
137
138 B1 = create_type('_testcapi.B1', id(self))
139 self.assertTrue(get_token(B1) == id(self))
140
141 tokenA1 = get_token(A1)
142 # find A1 from A1
143 found = get_base_by_token(A1, tokenA1)
144 self.assertIs(found, A1)
145
146 # no token in static types
147 STATIC = type(1)
148 self.assertEqual(get_token(STATIC), 0)
149 found = get_base_by_token(STATIC, tokenA1)
150 self.assertIs(found, None)
151
152 # no token in pure subtypes
153 class A2(A1): pass
154 self.assertEqual(get_token(A2), 0)
155 # find A1
156 class Z(STATIC, B1, A2): pass
157 found = get_base_by_token(Z, tokenA1)
158 self.assertIs(found, A1)
159
160 # searching for NULL token is an error
161 with self.assertRaises(SystemError):
162 get_base_by_token(Z, 0)
163 with self.assertRaises(SystemError):
164 get_base_by_token(STATIC, 0)
165
166 # share the token with A1
167 C1 = create_type('_testcapi.C1', tokenA1)
168 self.assertTrue(get_token(C1) == tokenA1)
169
170 # find C1 first by shared token
171 class Z(C1, A2): pass
172 found = get_base_by_token(Z, tokenA1)
173 self.assertIs(found, C1)
174 # B1 not found
175 found = get_base_by_token(Z, get_token(B1))
176 self.assertIs(found, None)
177
178 with self.assertRaises(TypeError):
179 _testcapi.pytype_getbasebytoken(
180 'not a type', id(self), True, False)
181
182 def test_get_module_by_def(self):
183 heaptype = _testcapi.create_type_with_token('_testcapi.H', 0)
184 mod = _testcapi.pytype_getmodulebydef(heaptype)
185 self.assertIs(mod, _testcapi)
186
187 class H1(heaptype): pass
188 mod = _testcapi.pytype_getmodulebydef(H1)
189 self.assertIs(mod, _testcapi)
190
191 with self.assertRaises(TypeError):
192 _testcapi.pytype_getmodulebydef(int)
193
194 class H2(int): pass
195 with self.assertRaises(TypeError):
196 _testcapi.pytype_getmodulebydef(H2)
197
198 def test_freeze(self):
199 # test PyType_Freeze()
200 type_freeze = _testcapi.type_freeze
201
202 # simple case, no inherante
203 class MyType:
204 pass
205 MyType.attr = "mutable"
206
207 type_freeze(MyType)
208 err_msg = "cannot set 'attr' attribute of immutable type 'MyType'"
209 with self.assertRaisesRegex(TypeError, err_msg):
210 # the class is now immutable
211 MyType.attr = "immutable"
212
213 # test MRO: PyType_Freeze() requires base classes to be immutable
214 class A: pass
215 class B: pass
216 class C(B): pass
217 class D(A, C): pass
218
219 self.assertEqual(D.mro(), [D, A, C, B, object])
220 with self.assertRaises(TypeError):
221 type_freeze(D)
222
223 type_freeze(A)
224 type_freeze(B)
225 type_freeze(C)
226 # all parent classes are now immutable, so D can be made immutable
227 # as well
228 type_freeze(D)
229
230 @unittest.skipIf(
231 Py_GIL_DISABLED and refleak_helper.hunting_for_refleaks(),
232 "Specialization failure triggers gh-127773")
233 def test_freeze_meta(self):
234 """test PyType_Freeze() with overridden MRO"""
235 type_freeze = _testcapi.type_freeze
236
237 class Base:
238 value = 1
239
240 class Meta(type):
241 def mro(cls):
242 return (cls, Base, object)
243
244 class FreezeThis(metaclass=Meta):
245 """This has `Base` in the MRO, but not tp_bases"""
246
247 self.assertEqual(FreezeThis.value, 1)
248
249 with self.assertRaises(TypeError):
250 type_freeze(FreezeThis)
251
252 Base.value = 2
253 self.assertEqual(FreezeThis.value, 2)
254
255 type_freeze(Base)
256 with self.assertRaises(TypeError):
257 Base.value = 3
258 type_freeze(FreezeThis)
259 self.assertEqual(FreezeThis.value, 2)
260
261 def test_manual_heap_type(self):
262 # gh-128923: test that a manually allocated and initailized heap type
263 # works correctly
264 ManualHeapType = _testcapi.ManualHeapType
265 for i in range(100):
266 self.assertIsInstance(ManualHeapType(), ManualHeapType)
267
268 def test_extension_managed_dict_type(self):
269 ManagedDictType = _testcapi.ManagedDictType
270 obj = ManagedDictType()
271 obj.foo = 42
272 self.assertEqual(obj.foo, 42)
273 self.assertEqual(obj.__dict__, {'foo': 42})
274 obj.__dict__ = {'bar': 3}
275 self.assertEqual(obj.__dict__, {'bar': 3})
276 self.assertEqual(obj.bar, 3)