Debian Codegraph @

Lib/test/test_capi/test_bytes.py

raw
1 import unittest
2 from test.support import import_helper
3
4 _testlimitedcapi = import_helper.import_module('_testlimitedcapi')
5 _testcapi = import_helper.import_module('_testcapi')
6 from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
7
8 NULL = None
9
10 class BytesSubclass(bytes):
11 pass
12
13 class BytesLike:
14 def __init__(self, value):
15 self.value = value
16 def __bytes__(self):
17 return self.value
18
19
20 class CAPITest(unittest.TestCase):
21 def test_check(self):
22 # Test PyBytes_Check()
23 check = _testlimitedcapi.bytes_check
24 self.assertTrue(check(b'abc'))
25 self.assertTrue(check(b''))
26 self.assertFalse(check('abc'))
27 self.assertFalse(check(bytearray(b'abc')))
28 self.assertTrue(check(BytesSubclass(b'abc')))
29 self.assertFalse(check(BytesLike(b'abc')))
30 self.assertFalse(check(3))
31 self.assertFalse(check([]))
32 self.assertFalse(check(object()))
33
34 # CRASHES check(NULL)
35
36 def test_checkexact(self):
37 # Test PyBytes_CheckExact()
38 check = _testlimitedcapi.bytes_checkexact
39 self.assertTrue(check(b'abc'))
40 self.assertTrue(check(b''))
41 self.assertFalse(check('abc'))
42 self.assertFalse(check(bytearray(b'abc')))
43 self.assertFalse(check(BytesSubclass(b'abc')))
44 self.assertFalse(check(BytesLike(b'abc')))
45 self.assertFalse(check(3))
46 self.assertFalse(check([]))
47 self.assertFalse(check(object()))
48
49 # CRASHES check(NULL)
50
51 def test_fromstringandsize(self):
52 # Test PyBytes_FromStringAndSize()
53 fromstringandsize = _testlimitedcapi.bytes_fromstringandsize
54
55 self.assertEqual(fromstringandsize(b'abc'), b'abc')
56 self.assertEqual(fromstringandsize(b'abc', 2), b'ab')
57 self.assertEqual(fromstringandsize(b'abc\0def'), b'abc\0def')
58 self.assertEqual(fromstringandsize(b'a'), b'a')
59 self.assertEqual(fromstringandsize(b'a', 1), b'a')
60 self.assertEqual(fromstringandsize(b'', 0), b'')
61 self.assertEqual(fromstringandsize(NULL, 0), b'')
62 self.assertEqual(len(fromstringandsize(NULL, 3)), 3)
63 self.assertRaises((MemoryError, OverflowError),
64 fromstringandsize, NULL, PY_SSIZE_T_MAX)
65
66 self.assertRaises(SystemError, fromstringandsize, b'abc', -1)
67 self.assertRaises(SystemError, fromstringandsize, b'abc', PY_SSIZE_T_MIN)
68 self.assertRaises(SystemError, fromstringandsize, NULL, -1)
69 self.assertRaises(SystemError, fromstringandsize, NULL, PY_SSIZE_T_MIN)
70
71 def test_fromstring(self):
72 # Test PyBytes_FromString()
73 fromstring = _testlimitedcapi.bytes_fromstring
74
75 self.assertEqual(fromstring(b'abc\0def'), b'abc')
76 self.assertEqual(fromstring(b''), b'')
77
78 # CRASHES fromstring(NULL)
79
80 def test_fromobject(self):
81 # Test PyBytes_FromObject()
82 fromobject = _testlimitedcapi.bytes_fromobject
83
84 self.assertEqual(fromobject(b''), b'')
85 self.assertEqual(fromobject(b'abc'), b'abc')
86 self.assertEqual(fromobject(bytearray(b'abc')), b'abc')
87 self.assertEqual(fromobject(BytesSubclass(b'abc')), b'abc')
88 self.assertEqual(fromobject([97, 98, 99]), b'abc')
89 self.assertRaises(TypeError, fromobject, 3)
90 self.assertRaises(TypeError, fromobject, BytesLike(b'abc'))
91 self.assertRaises(TypeError, fromobject, 'abc')
92 self.assertRaises(TypeError, fromobject, object())
93 self.assertRaises(SystemError, fromobject, NULL)
94
95 def test_size(self):
96 # Test PyBytes_Size()
97 size = _testlimitedcapi.bytes_size
98
99 self.assertEqual(size(b''), 0)
100 self.assertEqual(size(b'abc'), 3)
101 self.assertEqual(size(BytesSubclass(b'abc')), 3)
102 self.assertRaises(TypeError, size, bytearray(b'abc'))
103 self.assertRaises(TypeError, size, 'abc')
104 self.assertRaises(TypeError, size, object())
105
106 # CRASHES size(NULL)
107
108 def test_asstring(self):
109 """Test PyBytes_AsString()"""
110 asstring = _testlimitedcapi.bytes_asstring
111
112 self.assertEqual(asstring(b'abc', 4), b'abc\0')
113 self.assertEqual(asstring(b'abc\0def', 8), b'abc\0def\0')
114 self.assertEqual(asstring(b'', 1), b'\0')
115 self.assertRaises(TypeError, asstring, 'abc', 0)
116 self.assertRaises(TypeError, asstring, object(), 0)
117
118 # CRASHES asstring(NULL, 0)
119
120 def test_asstringandsize(self):
121 """Test PyBytes_AsStringAndSize()"""
122 asstringandsize = _testlimitedcapi.bytes_asstringandsize
123 asstringandsize_null = _testlimitedcapi.bytes_asstringandsize_null
124
125 self.assertEqual(asstringandsize(b'abc', 4), (b'abc\0', 3))
126 self.assertEqual(asstringandsize(b'abc\0def', 8), (b'abc\0def\0', 7))
127 self.assertEqual(asstringandsize(b'', 1), (b'\0', 0))
128 self.assertEqual(asstringandsize_null(b'abc', 4), b'abc\0')
129 self.assertRaises(ValueError, asstringandsize_null, b'abc\0def', 8)
130 self.assertRaises(TypeError, asstringandsize, 'abc', 0)
131 self.assertRaises(TypeError, asstringandsize_null, 'abc', 0)
132 self.assertRaises(TypeError, asstringandsize, object(), 0)
133 self.assertRaises(TypeError, asstringandsize_null, object(), 0)
134
135 # CRASHES asstringandsize(NULL, 0)
136 # CRASHES asstringandsize_null(NULL, 0)
137
138 def test_repr(self):
139 # Test PyBytes_Repr()
140 bytes_repr = _testlimitedcapi.bytes_repr
141
142 self.assertEqual(bytes_repr(b'', 0), r"""b''""")
143 self.assertEqual(bytes_repr(b'''abc''', 0), r"""b'abc'""")
144 self.assertEqual(bytes_repr(b'''abc''', 1), r"""b'abc'""")
145 self.assertEqual(bytes_repr(b'''a'b"c"d''', 0), r"""b'a\'b"c"d'""")
146 self.assertEqual(bytes_repr(b'''a'b"c"d''', 1), r"""b'a\'b"c"d'""")
147 self.assertEqual(bytes_repr(b'''a'b"c''', 0), r"""b'a\'b"c'""")
148 self.assertEqual(bytes_repr(b'''a'b"c''', 1), r"""b'a\'b"c'""")
149 self.assertEqual(bytes_repr(b'''a'b'c"d''', 0), r"""b'a\'b\'c"d'""")
150 self.assertEqual(bytes_repr(b'''a'b'c"d''', 1), r"""b'a\'b\'c"d'""")
151 self.assertEqual(bytes_repr(b'''a'b'c'd''', 0), r"""b'a\'b\'c\'d'""")
152 self.assertEqual(bytes_repr(b'''a'b'c'd''', 1), r'''b"a'b'c'd"''')
153
154 self.assertEqual(bytes_repr(BytesSubclass(b'abc'), 0), r"""b'abc'""")
155
156 # UDEFINED bytes_repr(object(), 0)
157 # CRASHES bytes_repr(NULL, 0)
158
159 def test_concat(self, concat=None):
160 """Test PyBytes_Concat()"""
161 if concat is None:
162 concat = _testlimitedcapi.bytes_concat
163
164 self.assertEqual(concat(b'abc', b'def'), b'abcdef')
165 self.assertEqual(concat(b'a\0b', b'c\0d'), b'a\0bc\0d')
166 self.assertEqual(concat(bytearray(b'abc'), b'def'), b'abcdef')
167 self.assertEqual(concat(b'abc', bytearray(b'def')), b'abcdef')
168 self.assertEqual(concat(bytearray(b'abc'), b''), b'abc')
169 self.assertEqual(concat(b'', bytearray(b'def')), b'def')
170 self.assertEqual(concat(memoryview(b'xabcy')[1:4], b'def'), b'abcdef')
171 self.assertEqual(concat(b'abc', memoryview(b'xdefy')[1:4]), b'abcdef')
172 self.assertEqual(concat(b'', b''), b'')
173
174 self.assertEqual(concat(b'abc', b'def', True), b'abcdef')
175 self.assertEqual(concat(b'abc', bytearray(b'def'), True), b'abcdef')
176 # Check that it does not change the singleton
177 self.assertEqual(concat(bytes(), b'def', True), b'def')
178 self.assertEqual(len(bytes()), 0)
179
180 self.assertRaises(TypeError, concat, memoryview(b'axbycz')[::2], b'def')
181 self.assertRaises(TypeError, concat, b'abc', memoryview(b'dxeyfz')[::2])
182 self.assertRaises(TypeError, concat, b'abc', 'def')
183 self.assertRaises(TypeError, concat, 'abc', b'def')
184 self.assertRaises(TypeError, concat, 'abc', 'def')
185 self.assertRaises(TypeError, concat, [], b'def')
186 self.assertRaises(TypeError, concat, b'abc', [])
187 self.assertRaises(TypeError, concat, [], [])
188
189 self.assertEqual(concat(NULL, b'def'), NULL)
190 self.assertEqual(concat(b'abc', NULL), NULL)
191 self.assertEqual(concat(NULL, object()), NULL)
192 self.assertEqual(concat(object(), NULL), NULL)
193
194 def test_concatanddel(self):
195 """Test PyBytes_ConcatAndDel()"""
196 self.test_concat(_testlimitedcapi.bytes_concatanddel)
197
198 def test_decodeescape(self):
199 """Test PyBytes_DecodeEscape()"""
200 decodeescape = _testlimitedcapi.bytes_decodeescape
201
202 self.assertEqual(decodeescape(b''), b'')
203 self.assertEqual(decodeescape(b'abc'), b'abc')
204 self.assertEqual(decodeescape(br'\t\n\r\x0b\x0c\x00\\\'\"'),
205 b'''\t\n\r\v\f\0\\'"''')
206 self.assertEqual(decodeescape(b'\t\n\r\x0b\x0c\x00'), b'\t\n\r\v\f\0')
207 self.assertEqual(decodeescape(br'\xa1\xa2'), b'\xa1\xa2')
208 self.assertEqual(decodeescape(br'\2\24\241'), b'\x02\x14\xa1')
209 self.assertEqual(decodeescape(b'\xa1\xa2'), b'\xa1\xa2')
210 with self.assertWarns(DeprecationWarning):
211 self.assertEqual(decodeescape(br'\u4f60'), br'\u4f60')
212 with self.assertWarns(DeprecationWarning):
213 self.assertEqual(decodeescape(br'\z'), br'\z')
214 with self.assertWarns(DeprecationWarning):
215 self.assertEqual(decodeescape(br'\541'), b'a')
216
217 for b in b'\\', br'\x', br'\xa', br'\xz', br'\xaz':
218 self.assertRaises(ValueError, decodeescape, b)
219 self.assertRaises(ValueError, decodeescape, b, 'strict')
220 self.assertEqual(decodeescape(br'x\xa', 'replace'), b'x?')
221 self.assertEqual(decodeescape(br'x\xay', 'replace'), b'x?y')
222 self.assertEqual(decodeescape(br'x\xa\xy', 'replace'), b'x??y')
223 self.assertEqual(decodeescape(br'x\xa\xy', 'ignore'), b'xy')
224 self.assertRaises(ValueError, decodeescape, b'\\', 'spam')
225 self.assertEqual(decodeescape(NULL), b'')
226 self.assertRaises(OverflowError, decodeescape, b'abc', NULL, PY_SSIZE_T_MAX)
227 self.assertRaises(OverflowError, decodeescape, NULL, NULL, PY_SSIZE_T_MAX)
228
229 # CRASHES decodeescape(b'abc', NULL, -1)
230 # CRASHES decodeescape(NULL, NULL, 1)
231
232 def test_resize(self):
233 """Test _PyBytes_Resize()"""
234 resize = _testcapi.bytes_resize
235
236 for new in True, False:
237 self.assertEqual(resize(b'abc', 0, new), b'')
238 self.assertEqual(resize(b'abc', 1, new), b'a')
239 self.assertEqual(resize(b'abc', 2, new), b'ab')
240 self.assertEqual(resize(b'abc', 3, new), b'abc')
241 b = resize(b'abc', 4, new)
242 self.assertEqual(len(b), 4)
243 self.assertEqual(b[:3], b'abc')
244
245 self.assertEqual(resize(b'a', 0, new), b'')
246 self.assertEqual(resize(b'a', 1, new), b'a')
247 b = resize(b'a', 2, new)
248 self.assertEqual(len(b), 2)
249 self.assertEqual(b[:1], b'a')
250
251 self.assertEqual(resize(b'', 0, new), b'')
252 self.assertEqual(len(resize(b'', 1, new)), 1)
253 self.assertEqual(len(resize(b'', 2, new)), 2)
254
255 self.assertRaises(SystemError, resize, b'abc', -1, False)
256 self.assertRaises(SystemError, resize, bytearray(b'abc'), 3, False)
257
258 # CRASHES resize(NULL, 0, False)
259 # CRASHES resize(NULL, 3, False)
260
261 def test_join(self):
262 """Test PyBytes_Join()"""
263 bytes_join = _testcapi.bytes_join
264
265 self.assertEqual(bytes_join(b'', []), b'')
266 self.assertEqual(bytes_join(b'sep', []), b'')
267
268 self.assertEqual(bytes_join(b'', [b'a', b'b', b'c']), b'abc')
269 self.assertEqual(bytes_join(b'-', [b'a', b'b', b'c']), b'a-b-c')
270 self.assertEqual(bytes_join(b' - ', [b'a', b'b', b'c']), b'a - b - c')
271 self.assertEqual(bytes_join(b'-', [bytearray(b'abc'),
272 memoryview(b'def')]),
273 b'abc-def')
274
275 self.assertEqual(bytes_join(b'-', iter([b'a', b'b', b'c'])), b'a-b-c')
276
277 # invalid 'sep' argument
278 with self.assertRaises(TypeError):
279 bytes_join(bytearray(b'sep'), [])
280 with self.assertRaises(TypeError):
281 bytes_join(memoryview(b'sep'), [])
282 with self.assertRaises(TypeError):
283 bytes_join('', []) # empty Unicode string
284 with self.assertRaises(TypeError):
285 bytes_join('unicode', [])
286 with self.assertRaises(TypeError):
287 bytes_join(123, [])
288 with self.assertRaises(SystemError):
289 self.assertEqual(bytes_join(NULL, [b'a', b'b', b'c']), b'abc')
290
291 # invalid 'iterable' argument
292 with self.assertRaises(TypeError):
293 bytes_join(b'', [b'bytes', 'unicode'])
294 with self.assertRaises(TypeError):
295 bytes_join(b'', [b'bytes', 123])
296 with self.assertRaises(TypeError):
297 bytes_join(b'', 123)
298 with self.assertRaises(SystemError):
299 bytes_join(b'', NULL)
300
301
302 if __name__ == "__main__":
303 unittest.main()