Debian Codegraph @

Lib/test/test_capi/test_set.py

raw
1 import unittest
2
3 from test.support import import_helper
4
5 # Skip this test if the _testcapi, _testlimitedcapi or _testinternalcapi
6 # modules aren't available.
7 _testcapi = import_helper.import_module('_testcapi')
8 _testlimitedcapi = import_helper.import_module('_testlimitedcapi')
9 _testinternalcapi = import_helper.import_module('_testinternalcapi')
10
11 class set_subclass(set):
12 pass
13
14 class frozenset_subclass(frozenset):
15 pass
16
17
18 class BaseSetTests:
19 def assertImmutable(self, action, *args):
20 self.assertRaises(SystemError, action, frozenset(), *args)
21 self.assertRaises(SystemError, action, frozenset({1}), *args)
22 self.assertRaises(SystemError, action, frozenset_subclass(), *args)
23 self.assertRaises(SystemError, action, frozenset_subclass({1}), *args)
24
25
26 class TestSetCAPI(BaseSetTests, unittest.TestCase):
27 def test_set_check(self):
28 check = _testlimitedcapi.set_check
29 self.assertTrue(check(set()))
30 self.assertTrue(check({1, 2}))
31 self.assertFalse(check(frozenset()))
32 self.assertTrue(check(set_subclass()))
33 self.assertFalse(check(frozenset_subclass()))
34 self.assertFalse(check(object()))
35 # CRASHES: check(NULL)
36
37 def test_set_check_exact(self):
38 check = _testlimitedcapi.set_checkexact
39 self.assertTrue(check(set()))
40 self.assertTrue(check({1, 2}))
41 self.assertFalse(check(frozenset()))
42 self.assertFalse(check(set_subclass()))
43 self.assertFalse(check(frozenset_subclass()))
44 self.assertFalse(check(object()))
45 # CRASHES: check(NULL)
46
47 def test_frozenset_check(self):
48 check = _testlimitedcapi.frozenset_check
49 self.assertFalse(check(set()))
50 self.assertTrue(check(frozenset()))
51 self.assertTrue(check(frozenset({1, 2})))
52 self.assertFalse(check(set_subclass()))
53 self.assertTrue(check(frozenset_subclass()))
54 self.assertFalse(check(object()))
55 # CRASHES: check(NULL)
56
57 def test_frozenset_check_exact(self):
58 check = _testlimitedcapi.frozenset_checkexact
59 self.assertFalse(check(set()))
60 self.assertTrue(check(frozenset()))
61 self.assertTrue(check(frozenset({1, 2})))
62 self.assertFalse(check(set_subclass()))
63 self.assertFalse(check(frozenset_subclass()))
64 self.assertFalse(check(object()))
65 # CRASHES: check(NULL)
66
67 def test_anyset_check(self):
68 check = _testlimitedcapi.anyset_check
69 self.assertTrue(check(set()))
70 self.assertTrue(check({1, 2}))
71 self.assertTrue(check(frozenset()))
72 self.assertTrue(check(frozenset({1, 2})))
73 self.assertTrue(check(set_subclass()))
74 self.assertTrue(check(frozenset_subclass()))
75 self.assertFalse(check(object()))
76 # CRASHES: check(NULL)
77
78 def test_anyset_check_exact(self):
79 check = _testlimitedcapi.anyset_checkexact
80 self.assertTrue(check(set()))
81 self.assertTrue(check({1, 2}))
82 self.assertTrue(check(frozenset()))
83 self.assertTrue(check(frozenset({1, 2})))
84 self.assertFalse(check(set_subclass()))
85 self.assertFalse(check(frozenset_subclass()))
86 self.assertFalse(check(object()))
87 # CRASHES: check(NULL)
88
89 def test_set_new(self):
90 set_new = _testlimitedcapi.set_new
91 self.assertEqual(set_new().__class__, set)
92 self.assertEqual(set_new(), set())
93 self.assertEqual(set_new((1, 1, 2)), {1, 2})
94 self.assertEqual(set_new([1, 1, 2]), {1, 2})
95 with self.assertRaisesRegex(TypeError, 'object is not iterable'):
96 set_new(object())
97 with self.assertRaisesRegex(TypeError, 'object is not iterable'):
98 set_new(1)
99 with self.assertRaisesRegex(TypeError, "unhashable type: 'dict'"):
100 set_new((1, {}))
101
102 def test_frozenset_new(self):
103 frozenset_new = _testlimitedcapi.frozenset_new
104 self.assertEqual(frozenset_new().__class__, frozenset)
105 self.assertEqual(frozenset_new(), frozenset())
106 self.assertEqual(frozenset_new((1, 1, 2)), frozenset({1, 2}))
107 self.assertEqual(frozenset_new([1, 1, 2]), frozenset({1, 2}))
108 with self.assertRaisesRegex(TypeError, 'object is not iterable'):
109 frozenset_new(object())
110 with self.assertRaisesRegex(TypeError, 'object is not iterable'):
111 frozenset_new(1)
112 with self.assertRaisesRegex(TypeError, "unhashable type: 'dict'"):
113 frozenset_new((1, {}))
114
115 def test_set_size(self):
116 get_size = _testlimitedcapi.set_size
117 self.assertEqual(get_size(set()), 0)
118 self.assertEqual(get_size(frozenset()), 0)
119 self.assertEqual(get_size({1, 1, 2}), 2)
120 self.assertEqual(get_size(frozenset({1, 1, 2})), 2)
121 self.assertEqual(get_size(set_subclass((1, 2, 3))), 3)
122 self.assertEqual(get_size(frozenset_subclass((1, 2, 3))), 3)
123 with self.assertRaises(SystemError):
124 get_size(object())
125 # CRASHES: get_size(NULL)
126
127 def test_set_get_size(self):
128 get_size = _testcapi.set_get_size
129 self.assertEqual(get_size(set()), 0)
130 self.assertEqual(get_size(frozenset()), 0)
131 self.assertEqual(get_size({1, 1, 2}), 2)
132 self.assertEqual(get_size(frozenset({1, 1, 2})), 2)
133 self.assertEqual(get_size(set_subclass((1, 2, 3))), 3)
134 self.assertEqual(get_size(frozenset_subclass((1, 2, 3))), 3)
135 # CRASHES: get_size(NULL)
136 # CRASHES: get_size(object())
137
138 def test_set_contains(self):
139 contains = _testlimitedcapi.set_contains
140 for cls in (set, frozenset, set_subclass, frozenset_subclass):
141 with self.subTest(cls=cls):
142 instance = cls((1, 2))
143 self.assertTrue(contains(instance, 1))
144 self.assertFalse(contains(instance, 'missing'))
145 with self.assertRaisesRegex(TypeError, "unhashable type: 'list'"):
146 contains(instance, [])
147 # CRASHES: contains(instance, NULL)
148 # CRASHES: contains(NULL, object())
149 # CRASHES: contains(NULL, NULL)
150
151 def test_add(self):
152 add = _testlimitedcapi.set_add
153 for cls in (set, set_subclass):
154 with self.subTest(cls=cls):
155 instance = cls((1, 2))
156 self.assertEqual(add(instance, 1), 0)
157 self.assertEqual(instance, {1, 2})
158 self.assertEqual(add(instance, 3), 0)
159 self.assertEqual(instance, {1, 2, 3})
160 with self.assertRaisesRegex(TypeError, "unhashable type: 'list'"):
161 add(instance, [])
162 with self.assertRaises(SystemError):
163 add(object(), 1)
164 self.assertImmutable(add, 1)
165 # CRASHES: add(NULL, object())
166 # CRASHES: add(instance, NULL)
167 # CRASHES: add(NULL, NULL)
168
169 def test_discard(self):
170 discard = _testlimitedcapi.set_discard
171 for cls in (set, set_subclass):
172 with self.subTest(cls=cls):
173 instance = cls((1, 2))
174 self.assertEqual(discard(instance, 3), 0)
175 self.assertEqual(instance, {1, 2})
176 self.assertEqual(discard(instance, 1), 1)
177 self.assertEqual(instance, {2})
178 self.assertEqual(discard(instance, 2), 1)
179 self.assertEqual(instance, set())
180 self.assertEqual(discard(instance, 2), 0)
181 self.assertEqual(instance, set())
182 with self.assertRaisesRegex(TypeError, "unhashable type: 'list'"):
183 discard(instance, [])
184 with self.assertRaises(SystemError):
185 discard(object(), 1)
186 self.assertImmutable(discard, 1)
187 # CRASHES: discard(NULL, object())
188 # CRASHES: discard(instance, NULL)
189 # CRASHES: discard(NULL, NULL)
190
191 def test_pop(self):
192 pop = _testlimitedcapi.set_pop
193 orig = (1, 2)
194 for cls in (set, set_subclass):
195 with self.subTest(cls=cls):
196 instance = cls(orig)
197 self.assertIn(pop(instance), orig)
198 self.assertEqual(len(instance), 1)
199 self.assertIn(pop(instance), orig)
200 self.assertEqual(len(instance), 0)
201 with self.assertRaises(KeyError):
202 pop(instance)
203 with self.assertRaises(SystemError):
204 pop(object())
205 self.assertImmutable(pop)
206 # CRASHES: pop(NULL)
207
208 def test_clear(self):
209 clear = _testlimitedcapi.set_clear
210 for cls in (set, set_subclass):
211 with self.subTest(cls=cls):
212 instance = cls((1, 2))
213 self.assertEqual(clear(instance), 0)
214 self.assertEqual(instance, set())
215 self.assertEqual(clear(instance), 0)
216 self.assertEqual(instance, set())
217 with self.assertRaises(SystemError):
218 clear(object())
219 self.assertImmutable(clear)
220 # CRASHES: clear(NULL)
221
222
223 class TestInternalCAPI(BaseSetTests, unittest.TestCase):
224 def test_set_update(self):
225 update = _testinternalcapi.set_update
226 for cls in (set, set_subclass):
227 for it in ('ab', ('a', 'b'), ['a', 'b'],
228 set('ab'), set_subclass('ab'),
229 frozenset('ab'), frozenset_subclass('ab')):
230 with self.subTest(cls=cls, it=it):
231 instance = cls()
232 self.assertEqual(update(instance, it), 0)
233 self.assertEqual(instance, {'a', 'b'})
234 instance = cls(it)
235 self.assertEqual(update(instance, it), 0)
236 self.assertEqual(instance, {'a', 'b'})
237 with self.assertRaisesRegex(TypeError, 'object is not iterable'):
238 update(cls(), 1)
239 with self.assertRaisesRegex(TypeError, "unhashable type: 'dict'"):
240 update(cls(), [{}])
241 with self.assertRaises(SystemError):
242 update(object(), 'ab')
243 self.assertImmutable(update, 'ab')
244 # CRASHES: update(NULL, object())
245 # CRASHES: update(instance, NULL)
246 # CRASHES: update(NULL, NULL)
247
248 def test_set_next_entry(self):
249 set_next = _testinternalcapi.set_next_entry
250 for cls in (set, set_subclass, frozenset, frozenset_subclass):
251 with self.subTest(cls=cls):
252 instance = cls('abc')
253 pos = 0
254 items = []
255 while True:
256 res = set_next(instance, pos)
257 if res is None:
258 break
259 rc, pos, hash_, item = res
260 items.append(item)
261 self.assertEqual(rc, 1)
262 self.assertIn(item, instance)
263 self.assertEqual(hash(item), hash_)
264 self.assertEqual(items, list(instance))
265 with self.assertRaises(SystemError):
266 set_next(object(), 0)
267 # CRASHES: set_next(NULL, 0)
268
269
270 if __name__ == "__main__":
271 unittest.main()