5
5
# Skip this test if the _testcapi module isn't available.
6
6
_testcapi = import_helper .import_module ('_testcapi' )
7
7
8
- class set_child (set ):
8
+ class set_subclass (set ):
9
9
pass
10
10
11
- class frozenset_child (frozenset ):
11
+ class frozenset_subclass (frozenset ):
12
12
pass
13
13
14
14
15
15
class TestSetCAPI (unittest .TestCase ):
16
16
def assertImmutable (self , action , * args ):
17
17
self .assertRaises (SystemError , action , frozenset (), * args )
18
18
self .assertRaises (SystemError , action , frozenset ({1 }), * args )
19
- self .assertRaises (SystemError , action , frozenset_child (), * args )
20
- self .assertRaises (SystemError , action , frozenset_child ({1 }), * args )
19
+ self .assertRaises (SystemError , action , frozenset_subclass (), * args )
20
+ self .assertRaises (SystemError , action , frozenset_subclass ({1 }), * args )
21
21
22
22
def test_set_check (self ):
23
23
check = _testcapi .set_check
24
24
self .assertTrue (check (set ()))
25
25
self .assertTrue (check ({1 , 2 }))
26
26
self .assertFalse (check (frozenset ()))
27
- self .assertTrue (check (set_child ()))
28
- self .assertFalse (check (frozenset_child ()))
27
+ self .assertTrue (check (set_subclass ()))
28
+ self .assertFalse (check (frozenset_subclass ()))
29
29
self .assertFalse (check (object ()))
30
+ # CRASHES: check(NULL)
30
31
31
32
def test_set_check_exact (self ):
32
33
check = _testcapi .set_checkexact
33
34
self .assertTrue (check (set ()))
34
35
self .assertTrue (check ({1 , 2 }))
35
36
self .assertFalse (check (frozenset ()))
36
- self .assertFalse (check (set_child ()))
37
- self .assertFalse (check (frozenset_child ()))
37
+ self .assertFalse (check (set_subclass ()))
38
+ self .assertFalse (check (frozenset_subclass ()))
38
39
self .assertFalse (check (object ()))
40
+ # CRASHES: check(NULL)
39
41
40
42
def test_frozenset_check (self ):
41
43
check = _testcapi .frozenset_check
42
44
self .assertFalse (check (set ()))
43
45
self .assertTrue (check (frozenset ()))
44
46
self .assertTrue (check (frozenset ({1 , 2 })))
45
- self .assertFalse (check (set_child ()))
46
- self .assertTrue (check (frozenset_child ()))
47
+ self .assertFalse (check (set_subclass ()))
48
+ self .assertTrue (check (frozenset_subclass ()))
47
49
self .assertFalse (check (object ()))
50
+ # CRASHES: check(NULL)
48
51
49
52
def test_frozenset_check_exact (self ):
50
53
check = _testcapi .frozenset_checkexact
51
54
self .assertFalse (check (set ()))
52
55
self .assertTrue (check (frozenset ()))
53
56
self .assertTrue (check (frozenset ({1 , 2 })))
54
- self .assertFalse (check (set_child ()))
55
- self .assertFalse (check (frozenset_child ()))
57
+ self .assertFalse (check (set_subclass ()))
58
+ self .assertFalse (check (frozenset_subclass ()))
56
59
self .assertFalse (check (object ()))
60
+ # CRASHES: check(NULL)
57
61
58
62
def test_anyset_check (self ):
59
63
check = _testcapi .anyset_check
60
64
self .assertTrue (check (set ()))
61
65
self .assertTrue (check ({1 , 2 }))
62
66
self .assertTrue (check (frozenset ()))
63
67
self .assertTrue (check (frozenset ({1 , 2 })))
64
- self .assertTrue (check (set_child ()))
65
- self .assertTrue (check (frozenset_child ()))
68
+ self .assertTrue (check (set_subclass ()))
69
+ self .assertTrue (check (frozenset_subclass ()))
66
70
self .assertFalse (check (object ()))
71
+ # CRASHES: check(NULL)
67
72
68
73
def test_anyset_check_exact (self ):
69
74
check = _testcapi .anyset_checkexact
70
75
self .assertTrue (check (set ()))
71
76
self .assertTrue (check ({1 , 2 }))
72
77
self .assertTrue (check (frozenset ()))
73
78
self .assertTrue (check (frozenset ({1 , 2 })))
74
- self .assertFalse (check (set_child ()))
75
- self .assertFalse (check (frozenset_child ()))
79
+ self .assertFalse (check (set_subclass ()))
80
+ self .assertFalse (check (frozenset_subclass ()))
76
81
self .assertFalse (check (object ()))
82
+ # CRASHES: check(NULL)
77
83
78
84
def test_set_new (self ):
79
- new = _testcapi .set_new
80
- self .assertEqual (new ().__class__ , set )
81
- self .assertEqual (new (), set ())
82
- self .assertEqual (new ((1 , 1 , 2 )), {1 , 2 })
85
+ set_new = _testcapi .set_new
86
+ self .assertEqual (set_new ().__class__ , set )
87
+ self .assertEqual (set_new (), set ())
88
+ self .assertEqual (set_new ((1 , 1 , 2 )), {1 , 2 })
83
89
with self .assertRaisesRegex (TypeError , 'object is not iterable' ):
84
- new (object ())
90
+ set_new (object ())
91
+ with self .assertRaisesRegex (TypeError , 'object is not iterable' ):
92
+ set_new (None )
85
93
with self .assertRaisesRegex (TypeError , "unhashable type: 'dict'" ):
86
- new ((1 , {}))
94
+ set_new ((1 , {}))
87
95
88
96
def test_frozenset_new (self ):
89
- new = _testcapi .frozenset_new
90
- self .assertEqual (new ().__class__ , frozenset )
91
- self .assertEqual (new (), frozenset ())
92
- self .assertEqual (new ((1 , 1 , 2 )), frozenset ({1 , 2 }))
97
+ frozenset_new = _testcapi .frozenset_new
98
+ self .assertEqual (frozenset_new ().__class__ , frozenset )
99
+ self .assertEqual (frozenset_new (), frozenset ())
100
+ self .assertEqual (frozenset_new ((1 , 1 , 2 )), frozenset ({1 , 2 }))
101
+ with self .assertRaisesRegex (TypeError , 'object is not iterable' ):
102
+ frozenset_new (object ())
93
103
with self .assertRaisesRegex (TypeError , 'object is not iterable' ):
94
- new ( object () )
104
+ frozenset_new ( None )
95
105
with self .assertRaisesRegex (TypeError , "unhashable type: 'dict'" ):
96
- new ((1 , {}))
106
+ frozenset_new ((1 , {}))
97
107
98
108
def test_set_size (self ):
99
- l = _testcapi .set_size
100
- self .assertEqual (l (set ()), 0 )
101
- self .assertEqual (l (frozenset ()), 0 )
102
- self .assertEqual (l ({1 , 1 , 2 }), 2 )
103
- self .assertEqual (l (frozenset ({1 , 1 , 2 })), 2 )
104
- self .assertEqual (l ( set_child ((1 , 2 , 3 ))), 3 )
105
- self .assertEqual (l ( frozenset_child ((1 , 2 , 3 ))), 3 )
109
+ get_size = _testcapi .set_size
110
+ self .assertEqual (get_size (set ()), 0 )
111
+ self .assertEqual (get_size (frozenset ()), 0 )
112
+ self .assertEqual (get_size ({1 , 1 , 2 }), 2 )
113
+ self .assertEqual (get_size (frozenset ({1 , 1 , 2 })), 2 )
114
+ self .assertEqual (get_size ( set_subclass ((1 , 2 , 3 ))), 3 )
115
+ self .assertEqual (get_size ( frozenset_subclass ((1 , 2 , 3 ))), 3 )
106
116
with self .assertRaises (SystemError ):
107
- l ([])
117
+ get_size ([])
118
+ # CRASHES: get_size(NULL)
108
119
109
120
def test_set_get_size (self ):
110
- l = _testcapi .set_get_size
111
- self .assertEqual (l (set ()), 0 )
112
- self .assertEqual (l (frozenset ()), 0 )
113
- self .assertEqual (l ({1 , 1 , 2 }), 2 )
114
- self .assertEqual (l (frozenset ({1 , 1 , 2 })), 2 )
115
- self .assertEqual (l (set_child ((1 , 2 , 3 ))), 3 )
116
- self .assertEqual (l (frozenset_child ((1 , 2 , 3 ))), 3 )
117
- # CRASHES: l([])
121
+ get_size = _testcapi .set_get_size
122
+ self .assertEqual (get_size (set ()), 0 )
123
+ self .assertEqual (get_size (frozenset ()), 0 )
124
+ self .assertEqual (get_size ({1 , 1 , 2 }), 2 )
125
+ self .assertEqual (get_size (frozenset ({1 , 1 , 2 })), 2 )
126
+ self .assertEqual (get_size (set_subclass ((1 , 2 , 3 ))), 3 )
127
+ self .assertEqual (get_size (frozenset_subclass ((1 , 2 , 3 ))), 3 )
128
+ # CRASHES: get_size(NULL)
129
+ # CRASHES: get_size(object())
118
130
119
131
def test_set_contains (self ):
120
- c = _testcapi .set_contains
121
- for cls in (set , frozenset , set_child , frozenset_child ):
132
+ contains = _testcapi .set_contains
133
+ for cls in (set , frozenset , set_subclass , frozenset_subclass ):
122
134
with self .subTest (cls = cls ):
123
135
instance = cls ((1 , 2 ))
124
- self .assertTrue (c (instance , 1 ))
125
- self .assertFalse (c (instance , 'missing' ))
136
+ self .assertTrue (contains (instance , 1 ))
137
+ self .assertFalse (contains (instance , 'missing' ))
138
+ with self .assertRaisesRegex (TypeError , "unhashable type: 'list'" ):
139
+ contains (instance , [])
140
+ # CRASHES: contains(instance, NULL)
141
+ # CRASHES: contains(NULL, object())
142
+ # CRASHES: contains(NULL, NULL)
126
143
127
144
def test_add (self ):
128
145
add = _testcapi .set_add
129
- for cls in (set , set_child ):
146
+ for cls in (set , set_subclass ):
130
147
with self .subTest (cls = cls ):
131
148
instance = cls ((1 , 2 ))
132
149
self .assertEqual (add (instance , 1 ), 0 )
133
150
self .assertEqual (instance , {1 , 2 })
134
151
self .assertEqual (add (instance , 3 ), 0 )
135
152
self .assertEqual (instance , {1 , 2 , 3 })
153
+ with self .assertRaisesRegex (TypeError , "unhashable type: 'list'" ):
154
+ add (instance , [])
155
+ # CRASHES: add(NULL, object())
156
+ # CRASHES: add(instance, NULL)
157
+ # CRASHES: add(NULL, NULL)
158
+ with self .assertRaises (SystemError ):
159
+ add (object (), 1 )
136
160
self .assertImmutable (add , 1 )
137
161
138
162
def test_discard (self ):
139
163
discard = _testcapi .set_discard
140
- for cls in (set , set_child ):
164
+ for cls in (set , set_subclass ):
141
165
with self .subTest (cls = cls ):
142
166
instance = cls ((1 , 2 ))
143
167
self .assertEqual (discard (instance , 3 ), 0 )
@@ -146,15 +170,21 @@ def test_discard(self):
146
170
self .assertEqual (instance , {2 })
147
171
self .assertEqual (discard (instance , 2 ), 1 )
148
172
self .assertEqual (instance , set ())
149
- # Discarding from empty set works
150
173
self .assertEqual (discard (instance , 2 ), 0 )
151
174
self .assertEqual (instance , set ())
175
+ with self .assertRaisesRegex (TypeError , "unhashable type: 'list'" ):
176
+ discard (instance , [])
177
+ # CRASHES: discard(NULL, object())
178
+ # CRASHES: discard(instance, NULL)
179
+ # CRASHES: discard(NULL, NULL)
180
+ with self .assertRaises (SystemError ):
181
+ discard (object (), 1 )
152
182
self .assertImmutable (discard , 1 )
153
183
154
184
def test_pop (self ):
155
185
pop = _testcapi .set_pop
156
186
orig = (1 , 2 )
157
- for cls in (set , set_child ):
187
+ for cls in (set , set_subclass ):
158
188
with self .subTest (cls = cls ):
159
189
instance = cls (orig )
160
190
self .assertIn (pop (instance ), orig )
@@ -163,13 +193,21 @@ def test_pop(self):
163
193
self .assertEqual (len (instance ), 0 )
164
194
with self .assertRaises (KeyError ):
165
195
pop (instance )
196
+ # CRASHES: pop(NULL)
197
+ with self .assertRaises (SystemError ):
198
+ pop (object ())
166
199
self .assertImmutable (pop )
167
200
168
201
def test_clear (self ):
169
202
clear = _testcapi .set_clear
170
- for cls in (set , set_child ):
203
+ for cls in (set , set_subclass ):
171
204
with self .subTest (cls = cls ):
172
205
instance = cls ((1 , 2 ))
173
206
self .assertEqual (clear (instance ), 0 )
174
207
self .assertEqual (instance , set ())
208
+ self .assertEqual (clear (instance ), 0 )
209
+ self .assertEqual (instance , set ())
210
+ # CRASHES: clear(NULL)
211
+ with self .assertRaises (SystemError ):
212
+ clear (object ())
175
213
self .assertImmutable (clear )
0 commit comments