mirror of
https://github.com/python/cpython.git
synced 2025-10-31 02:15:10 +00:00
1cc02ca063
Move the following files from Modules/_testcapi/ to Modules/_testlimitedcapi/: * bytearray.c * bytes.c * pyos.c * sys.c Changes: * Replace PyBytes_AS_STRING() with PyBytes_AsString(). * Replace PyBytes_GET_SIZE() with PyBytes_Size(). * Update related test_capi tests. * Copy Modules/_testcapi/util.h to Modules/_testlimitedcapi/util.h.
222 lines
9.4 KiB
Python
222 lines
9.4 KiB
Python
import unittest
|
|
from test.support import import_helper
|
|
|
|
_testlimitedcapi = import_helper.import_module('_testlimitedcapi')
|
|
from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
|
|
|
|
NULL = None
|
|
|
|
class BytesSubclass(bytes):
|
|
pass
|
|
|
|
class BytesLike:
|
|
def __init__(self, value):
|
|
self.value = value
|
|
def __bytes__(self):
|
|
return self.value
|
|
|
|
|
|
class CAPITest(unittest.TestCase):
|
|
def test_check(self):
|
|
# Test PyBytes_Check()
|
|
check = _testlimitedcapi.bytes_check
|
|
self.assertTrue(check(b'abc'))
|
|
self.assertFalse(check('abc'))
|
|
self.assertFalse(check(bytearray(b'abc')))
|
|
self.assertTrue(check(BytesSubclass(b'abc')))
|
|
self.assertFalse(check(BytesLike(b'abc')))
|
|
self.assertFalse(check(3))
|
|
self.assertFalse(check([]))
|
|
self.assertFalse(check(object()))
|
|
|
|
# CRASHES check(NULL)
|
|
|
|
def test_checkexact(self):
|
|
# Test PyBytes_CheckExact()
|
|
check = _testlimitedcapi.bytes_checkexact
|
|
self.assertTrue(check(b'abc'))
|
|
self.assertFalse(check('abc'))
|
|
self.assertFalse(check(bytearray(b'abc')))
|
|
self.assertFalse(check(BytesSubclass(b'abc')))
|
|
self.assertFalse(check(BytesLike(b'abc')))
|
|
self.assertFalse(check(3))
|
|
self.assertFalse(check([]))
|
|
self.assertFalse(check(object()))
|
|
|
|
# CRASHES check(NULL)
|
|
|
|
def test_fromstringandsize(self):
|
|
# Test PyBytes_FromStringAndSize()
|
|
fromstringandsize = _testlimitedcapi.bytes_fromstringandsize
|
|
|
|
self.assertEqual(fromstringandsize(b'abc'), b'abc')
|
|
self.assertEqual(fromstringandsize(b'abc', 2), b'ab')
|
|
self.assertEqual(fromstringandsize(b'abc\0def'), b'abc\0def')
|
|
self.assertEqual(fromstringandsize(b'', 0), b'')
|
|
self.assertEqual(fromstringandsize(NULL, 0), b'')
|
|
self.assertEqual(len(fromstringandsize(NULL, 3)), 3)
|
|
self.assertRaises((MemoryError, OverflowError),
|
|
fromstringandsize, NULL, PY_SSIZE_T_MAX)
|
|
|
|
self.assertRaises(SystemError, fromstringandsize, b'abc', -1)
|
|
self.assertRaises(SystemError, fromstringandsize, b'abc', PY_SSIZE_T_MIN)
|
|
self.assertRaises(SystemError, fromstringandsize, NULL, -1)
|
|
self.assertRaises(SystemError, fromstringandsize, NULL, PY_SSIZE_T_MIN)
|
|
|
|
def test_fromstring(self):
|
|
# Test PyBytes_FromString()
|
|
fromstring = _testlimitedcapi.bytes_fromstring
|
|
|
|
self.assertEqual(fromstring(b'abc\0def'), b'abc')
|
|
self.assertEqual(fromstring(b''), b'')
|
|
|
|
# CRASHES fromstring(NULL)
|
|
|
|
def test_fromobject(self):
|
|
# Test PyBytes_FromObject()
|
|
fromobject = _testlimitedcapi.bytes_fromobject
|
|
|
|
self.assertEqual(fromobject(b'abc'), b'abc')
|
|
self.assertEqual(fromobject(bytearray(b'abc')), b'abc')
|
|
self.assertEqual(fromobject(BytesSubclass(b'abc')), b'abc')
|
|
self.assertEqual(fromobject([97, 98, 99]), b'abc')
|
|
self.assertRaises(TypeError, fromobject, 3)
|
|
self.assertRaises(TypeError, fromobject, BytesLike(b'abc'))
|
|
self.assertRaises(TypeError, fromobject, 'abc')
|
|
self.assertRaises(TypeError, fromobject, object())
|
|
self.assertRaises(SystemError, fromobject, NULL)
|
|
|
|
def test_size(self):
|
|
# Test PyBytes_Size()
|
|
size = _testlimitedcapi.bytes_size
|
|
|
|
self.assertEqual(size(b'abc'), 3)
|
|
self.assertEqual(size(BytesSubclass(b'abc')), 3)
|
|
self.assertRaises(TypeError, size, bytearray(b'abc'))
|
|
self.assertRaises(TypeError, size, 'abc')
|
|
self.assertRaises(TypeError, size, object())
|
|
|
|
# CRASHES size(NULL)
|
|
|
|
def test_asstring(self):
|
|
"""Test PyBytes_AsString()"""
|
|
asstring = _testlimitedcapi.bytes_asstring
|
|
|
|
self.assertEqual(asstring(b'abc', 4), b'abc\0')
|
|
self.assertEqual(asstring(b'abc\0def', 8), b'abc\0def\0')
|
|
self.assertRaises(TypeError, asstring, 'abc', 0)
|
|
self.assertRaises(TypeError, asstring, object(), 0)
|
|
|
|
# CRASHES asstring(NULL, 0)
|
|
|
|
def test_asstringandsize(self):
|
|
"""Test PyBytes_AsStringAndSize()"""
|
|
asstringandsize = _testlimitedcapi.bytes_asstringandsize
|
|
asstringandsize_null = _testlimitedcapi.bytes_asstringandsize_null
|
|
|
|
self.assertEqual(asstringandsize(b'abc', 4), (b'abc\0', 3))
|
|
self.assertEqual(asstringandsize(b'abc\0def', 8), (b'abc\0def\0', 7))
|
|
self.assertEqual(asstringandsize_null(b'abc', 4), b'abc\0')
|
|
self.assertRaises(ValueError, asstringandsize_null, b'abc\0def', 8)
|
|
self.assertRaises(TypeError, asstringandsize, 'abc', 0)
|
|
self.assertRaises(TypeError, asstringandsize_null, 'abc', 0)
|
|
self.assertRaises(TypeError, asstringandsize, object(), 0)
|
|
self.assertRaises(TypeError, asstringandsize_null, object(), 0)
|
|
|
|
# CRASHES asstringandsize(NULL, 0)
|
|
# CRASHES asstringandsize_null(NULL, 0)
|
|
|
|
def test_repr(self):
|
|
# Test PyBytes_Repr()
|
|
bytes_repr = _testlimitedcapi.bytes_repr
|
|
|
|
self.assertEqual(bytes_repr(b'''abc''', 0), r"""b'abc'""")
|
|
self.assertEqual(bytes_repr(b'''abc''', 1), r"""b'abc'""")
|
|
self.assertEqual(bytes_repr(b'''a'b"c"d''', 0), r"""b'a\'b"c"d'""")
|
|
self.assertEqual(bytes_repr(b'''a'b"c"d''', 1), r"""b'a\'b"c"d'""")
|
|
self.assertEqual(bytes_repr(b'''a'b"c''', 0), r"""b'a\'b"c'""")
|
|
self.assertEqual(bytes_repr(b'''a'b"c''', 1), r"""b'a\'b"c'""")
|
|
self.assertEqual(bytes_repr(b'''a'b'c"d''', 0), r"""b'a\'b\'c"d'""")
|
|
self.assertEqual(bytes_repr(b'''a'b'c"d''', 1), r"""b'a\'b\'c"d'""")
|
|
self.assertEqual(bytes_repr(b'''a'b'c'd''', 0), r"""b'a\'b\'c\'d'""")
|
|
self.assertEqual(bytes_repr(b'''a'b'c'd''', 1), r'''b"a'b'c'd"''')
|
|
|
|
self.assertEqual(bytes_repr(BytesSubclass(b'abc'), 0), r"""b'abc'""")
|
|
|
|
# UDEFINED bytes_repr(object(), 0)
|
|
# CRASHES bytes_repr(NULL, 0)
|
|
|
|
def test_concat(self, concat=None):
|
|
"""Test PyBytes_Concat()"""
|
|
if concat is None:
|
|
concat = _testlimitedcapi.bytes_concat
|
|
|
|
self.assertEqual(concat(b'abc', b'def'), b'abcdef')
|
|
self.assertEqual(concat(b'a\0b', b'c\0d'), b'a\0bc\0d')
|
|
self.assertEqual(concat(bytearray(b'abc'), b'def'), b'abcdef')
|
|
self.assertEqual(concat(b'abc', bytearray(b'def')), b'abcdef')
|
|
self.assertEqual(concat(bytearray(b'abc'), b''), b'abc')
|
|
self.assertEqual(concat(b'', bytearray(b'def')), b'def')
|
|
self.assertEqual(concat(memoryview(b'xabcy')[1:4], b'def'), b'abcdef')
|
|
self.assertEqual(concat(b'abc', memoryview(b'xdefy')[1:4]), b'abcdef')
|
|
|
|
self.assertEqual(concat(b'abc', b'def', True), b'abcdef')
|
|
self.assertEqual(concat(b'abc', bytearray(b'def'), True), b'abcdef')
|
|
# Check that it does not change the singleton
|
|
self.assertEqual(concat(bytes(), b'def', True), b'def')
|
|
self.assertEqual(len(bytes()), 0)
|
|
|
|
self.assertRaises(TypeError, concat, memoryview(b'axbycz')[::2], b'def')
|
|
self.assertRaises(TypeError, concat, b'abc', memoryview(b'dxeyfz')[::2])
|
|
self.assertRaises(TypeError, concat, b'abc', 'def')
|
|
self.assertRaises(TypeError, concat, 'abc', b'def')
|
|
self.assertRaises(TypeError, concat, 'abc', 'def')
|
|
self.assertRaises(TypeError, concat, [], b'def')
|
|
self.assertRaises(TypeError, concat, b'abc', [])
|
|
self.assertRaises(TypeError, concat, [], [])
|
|
|
|
self.assertEqual(concat(NULL, b'def'), NULL)
|
|
self.assertEqual(concat(b'abc', NULL), NULL)
|
|
self.assertEqual(concat(NULL, object()), NULL)
|
|
self.assertEqual(concat(object(), NULL), NULL)
|
|
|
|
def test_concatanddel(self):
|
|
"""Test PyBytes_ConcatAndDel()"""
|
|
self.test_concat(_testlimitedcapi.bytes_concatanddel)
|
|
|
|
def test_decodeescape(self):
|
|
"""Test PyBytes_DecodeEscape()"""
|
|
decodeescape = _testlimitedcapi.bytes_decodeescape
|
|
|
|
self.assertEqual(decodeescape(b'abc'), b'abc')
|
|
self.assertEqual(decodeescape(br'\t\n\r\x0b\x0c\x00\\\'\"'),
|
|
b'''\t\n\r\v\f\0\\'"''')
|
|
self.assertEqual(decodeescape(b'\t\n\r\x0b\x0c\x00'), b'\t\n\r\v\f\0')
|
|
self.assertEqual(decodeescape(br'\xa1\xa2'), b'\xa1\xa2')
|
|
self.assertEqual(decodeescape(br'\2\24\241'), b'\x02\x14\xa1')
|
|
self.assertEqual(decodeescape(b'\xa1\xa2'), b'\xa1\xa2')
|
|
with self.assertWarns(DeprecationWarning):
|
|
self.assertEqual(decodeescape(br'\u4f60'), br'\u4f60')
|
|
with self.assertWarns(DeprecationWarning):
|
|
self.assertEqual(decodeescape(br'\z'), br'\z')
|
|
with self.assertWarns(DeprecationWarning):
|
|
self.assertEqual(decodeescape(br'\541'), b'a')
|
|
|
|
for b in b'\\', br'\x', br'\xa', br'\xz', br'\xaz':
|
|
self.assertRaises(ValueError, decodeescape, b)
|
|
self.assertRaises(ValueError, decodeescape, b, 'strict')
|
|
self.assertEqual(decodeescape(br'x\xa', 'replace'), b'x?')
|
|
self.assertEqual(decodeescape(br'x\xay', 'replace'), b'x?y')
|
|
self.assertEqual(decodeescape(br'x\xa\xy', 'replace'), b'x??y')
|
|
self.assertEqual(decodeescape(br'x\xa\xy', 'ignore'), b'xy')
|
|
self.assertRaises(ValueError, decodeescape, b'\\', 'spam')
|
|
self.assertEqual(decodeescape(NULL), b'')
|
|
self.assertRaises(OverflowError, decodeescape, b'abc', NULL, PY_SSIZE_T_MAX)
|
|
self.assertRaises(OverflowError, decodeescape, NULL, NULL, PY_SSIZE_T_MAX)
|
|
|
|
# CRASHES decodeescape(b'abc', NULL, -1)
|
|
# CRASHES decodeescape(NULL, NULL, 1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|