mirror of https://github.com/python/cpython
919 lines
39 KiB
Python
919 lines
39 KiB
Python
import unittest
|
||
import sys
|
||
from test import support
|
||
from test.support import import_helper
|
||
|
||
try:
|
||
import _testcapi
|
||
except ImportError:
|
||
_testcapi = None
|
||
|
||
|
||
NULL = None
|
||
|
||
class Str(str):
|
||
pass
|
||
|
||
|
||
class CAPITest(unittest.TestCase):
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_fromobject(self):
|
||
"""Test PyUnicode_FromObject()"""
|
||
from _testcapi import unicode_fromobject as fromobject
|
||
|
||
for s in ['abc', '\xa1\xa2', '\u4f60\u597d', 'a\U0001f600',
|
||
'a\ud800b\udfffc', '\ud834\udd1e']:
|
||
self.assertEqual(fromobject(s), s)
|
||
o = Str(s)
|
||
s2 = fromobject(o)
|
||
self.assertEqual(s2, s)
|
||
self.assertIs(type(s2), str)
|
||
self.assertIsNot(s2, s)
|
||
|
||
self.assertRaises(TypeError, fromobject, b'abc')
|
||
self.assertRaises(TypeError, fromobject, [])
|
||
# CRASHES fromobject(NULL)
|
||
|
||
def test_from_format(self):
|
||
"""Test PyUnicode_FromFormat()"""
|
||
import_helper.import_module('ctypes')
|
||
from ctypes import (
|
||
c_char_p,
|
||
pythonapi, py_object, sizeof,
|
||
c_int, c_long, c_longlong, c_ssize_t,
|
||
c_uint, c_ulong, c_ulonglong, c_size_t, c_void_p)
|
||
name = "PyUnicode_FromFormat"
|
||
_PyUnicode_FromFormat = getattr(pythonapi, name)
|
||
_PyUnicode_FromFormat.argtypes = (c_char_p,)
|
||
_PyUnicode_FromFormat.restype = py_object
|
||
|
||
def PyUnicode_FromFormat(format, *args):
|
||
cargs = tuple(
|
||
py_object(arg) if isinstance(arg, str) else arg
|
||
for arg in args)
|
||
return _PyUnicode_FromFormat(format, *cargs)
|
||
|
||
def check_format(expected, format, *args):
|
||
text = PyUnicode_FromFormat(format, *args)
|
||
self.assertEqual(expected, text)
|
||
|
||
# ascii format, non-ascii argument
|
||
check_format('ascii\x7f=unicode\xe9',
|
||
b'ascii\x7f=%U', 'unicode\xe9')
|
||
|
||
# non-ascii format, ascii argument: ensure that PyUnicode_FromFormatV()
|
||
# raises an error
|
||
self.assertRaisesRegex(ValueError,
|
||
r'^PyUnicode_FromFormatV\(\) expects an ASCII-encoded format '
|
||
'string, got a non-ASCII byte: 0xe9$',
|
||
PyUnicode_FromFormat, b'unicode\xe9=%s', 'ascii')
|
||
|
||
# test "%c"
|
||
check_format('\uabcd',
|
||
b'%c', c_int(0xabcd))
|
||
check_format('\U0010ffff',
|
||
b'%c', c_int(0x10ffff))
|
||
with self.assertRaises(OverflowError):
|
||
PyUnicode_FromFormat(b'%c', c_int(0x110000))
|
||
# Issue #18183
|
||
check_format('\U00010000\U00100000',
|
||
b'%c%c', c_int(0x10000), c_int(0x100000))
|
||
|
||
# test "%"
|
||
check_format('%',
|
||
b'%%')
|
||
check_format('%s',
|
||
b'%%s')
|
||
check_format('[%]',
|
||
b'[%%]')
|
||
check_format('%abc',
|
||
b'%%%s', b'abc')
|
||
|
||
# truncated string
|
||
check_format('abc',
|
||
b'%.3s', b'abcdef')
|
||
check_format('abc[\ufffd',
|
||
b'%.5s', 'abc[\u20ac]'.encode('utf8'))
|
||
check_format("'\\u20acABC'",
|
||
b'%A', '\u20acABC')
|
||
check_format("'\\u20",
|
||
b'%.5A', '\u20acABCDEF')
|
||
check_format("'\u20acABC'",
|
||
b'%R', '\u20acABC')
|
||
check_format("'\u20acA",
|
||
b'%.3R', '\u20acABCDEF')
|
||
check_format('\u20acAB',
|
||
b'%.3S', '\u20acABCDEF')
|
||
check_format('\u20acAB',
|
||
b'%.3U', '\u20acABCDEF')
|
||
check_format('\u20acAB',
|
||
b'%.3V', '\u20acABCDEF', None)
|
||
check_format('abc[\ufffd',
|
||
b'%.5V', None, 'abc[\u20ac]'.encode('utf8'))
|
||
|
||
# following tests comes from #7330
|
||
# test width modifier and precision modifier with %S
|
||
check_format("repr= abc",
|
||
b'repr=%5S', 'abc')
|
||
check_format("repr=ab",
|
||
b'repr=%.2S', 'abc')
|
||
check_format("repr= ab",
|
||
b'repr=%5.2S', 'abc')
|
||
|
||
# test width modifier and precision modifier with %R
|
||
check_format("repr= 'abc'",
|
||
b'repr=%8R', 'abc')
|
||
check_format("repr='ab",
|
||
b'repr=%.3R', 'abc')
|
||
check_format("repr= 'ab",
|
||
b'repr=%5.3R', 'abc')
|
||
|
||
# test width modifier and precision modifier with %A
|
||
check_format("repr= 'abc'",
|
||
b'repr=%8A', 'abc')
|
||
check_format("repr='ab",
|
||
b'repr=%.3A', 'abc')
|
||
check_format("repr= 'ab",
|
||
b'repr=%5.3A', 'abc')
|
||
|
||
# test width modifier and precision modifier with %s
|
||
check_format("repr= abc",
|
||
b'repr=%5s', b'abc')
|
||
check_format("repr=ab",
|
||
b'repr=%.2s', b'abc')
|
||
check_format("repr= ab",
|
||
b'repr=%5.2s', b'abc')
|
||
|
||
# test width modifier and precision modifier with %U
|
||
check_format("repr= abc",
|
||
b'repr=%5U', 'abc')
|
||
check_format("repr=ab",
|
||
b'repr=%.2U', 'abc')
|
||
check_format("repr= ab",
|
||
b'repr=%5.2U', 'abc')
|
||
|
||
# test width modifier and precision modifier with %V
|
||
check_format("repr= abc",
|
||
b'repr=%5V', 'abc', b'123')
|
||
check_format("repr=ab",
|
||
b'repr=%.2V', 'abc', b'123')
|
||
check_format("repr= ab",
|
||
b'repr=%5.2V', 'abc', b'123')
|
||
check_format("repr= 123",
|
||
b'repr=%5V', None, b'123')
|
||
check_format("repr=12",
|
||
b'repr=%.2V', None, b'123')
|
||
check_format("repr= 12",
|
||
b'repr=%5.2V', None, b'123')
|
||
|
||
# test integer formats (%i, %d, %u)
|
||
check_format('010',
|
||
b'%03i', c_int(10))
|
||
check_format('0010',
|
||
b'%0.4i', c_int(10))
|
||
check_format('-123',
|
||
b'%i', c_int(-123))
|
||
check_format('-123',
|
||
b'%li', c_long(-123))
|
||
check_format('-123',
|
||
b'%lli', c_longlong(-123))
|
||
check_format('-123',
|
||
b'%zi', c_ssize_t(-123))
|
||
|
||
check_format('-123',
|
||
b'%d', c_int(-123))
|
||
check_format('-123',
|
||
b'%ld', c_long(-123))
|
||
check_format('-123',
|
||
b'%lld', c_longlong(-123))
|
||
check_format('-123',
|
||
b'%zd', c_ssize_t(-123))
|
||
|
||
check_format('123',
|
||
b'%u', c_uint(123))
|
||
check_format('123',
|
||
b'%lu', c_ulong(123))
|
||
check_format('123',
|
||
b'%llu', c_ulonglong(123))
|
||
check_format('123',
|
||
b'%zu', c_size_t(123))
|
||
|
||
# test long output
|
||
min_longlong = -(2 ** (8 * sizeof(c_longlong) - 1))
|
||
max_longlong = -min_longlong - 1
|
||
check_format(str(min_longlong),
|
||
b'%lld', c_longlong(min_longlong))
|
||
check_format(str(max_longlong),
|
||
b'%lld', c_longlong(max_longlong))
|
||
max_ulonglong = 2 ** (8 * sizeof(c_ulonglong)) - 1
|
||
check_format(str(max_ulonglong),
|
||
b'%llu', c_ulonglong(max_ulonglong))
|
||
PyUnicode_FromFormat(b'%p', c_void_p(-1))
|
||
|
||
# test padding (width and/or precision)
|
||
check_format('123'.rjust(10, '0'),
|
||
b'%010i', c_int(123))
|
||
check_format('123'.rjust(100),
|
||
b'%100i', c_int(123))
|
||
check_format('123'.rjust(100, '0'),
|
||
b'%.100i', c_int(123))
|
||
check_format('123'.rjust(80, '0').rjust(100),
|
||
b'%100.80i', c_int(123))
|
||
|
||
check_format('123'.rjust(10, '0'),
|
||
b'%010u', c_uint(123))
|
||
check_format('123'.rjust(100),
|
||
b'%100u', c_uint(123))
|
||
check_format('123'.rjust(100, '0'),
|
||
b'%.100u', c_uint(123))
|
||
check_format('123'.rjust(80, '0').rjust(100),
|
||
b'%100.80u', c_uint(123))
|
||
|
||
check_format('123'.rjust(10, '0'),
|
||
b'%010x', c_int(0x123))
|
||
check_format('123'.rjust(100),
|
||
b'%100x', c_int(0x123))
|
||
check_format('123'.rjust(100, '0'),
|
||
b'%.100x', c_int(0x123))
|
||
check_format('123'.rjust(80, '0').rjust(100),
|
||
b'%100.80x', c_int(0x123))
|
||
|
||
# test %A
|
||
check_format(r"%A:'abc\xe9\uabcd\U0010ffff'",
|
||
b'%%A:%A', 'abc\xe9\uabcd\U0010ffff')
|
||
|
||
# test %V
|
||
check_format('repr=abc',
|
||
b'repr=%V', 'abc', b'xyz')
|
||
|
||
# test %p
|
||
# We cannot test the exact result,
|
||
# because it returns a hex representation of a C pointer,
|
||
# which is going to be different each time. But, we can test the format.
|
||
p_format_regex = r'^0x[a-zA-Z0-9]{3,}$'
|
||
p_format1 = PyUnicode_FromFormat(b'%p', 'abc')
|
||
self.assertIsInstance(p_format1, str)
|
||
self.assertRegex(p_format1, p_format_regex)
|
||
|
||
p_format2 = PyUnicode_FromFormat(b'%p %p', '123456', b'xyz')
|
||
self.assertIsInstance(p_format2, str)
|
||
self.assertRegex(p_format2,
|
||
r'0x[a-zA-Z0-9]{3,} 0x[a-zA-Z0-9]{3,}')
|
||
|
||
# Extra args are ignored:
|
||
p_format3 = PyUnicode_FromFormat(b'%p', '123456', None, b'xyz')
|
||
self.assertIsInstance(p_format3, str)
|
||
self.assertRegex(p_format3, p_format_regex)
|
||
|
||
# Test string decode from parameter of %s using utf-8.
|
||
# b'\xe4\xba\xba\xe6\xb0\x91' is utf-8 encoded byte sequence of
|
||
# '\u4eba\u6c11'
|
||
check_format('repr=\u4eba\u6c11',
|
||
b'repr=%V', None, b'\xe4\xba\xba\xe6\xb0\x91')
|
||
|
||
#Test replace error handler.
|
||
check_format('repr=abc\ufffd',
|
||
b'repr=%V', None, b'abc\xff')
|
||
|
||
# Issue #33817: empty strings
|
||
check_format('',
|
||
b'')
|
||
check_format('',
|
||
b'%s', b'')
|
||
|
||
# check for crashes
|
||
for fmt in (b'%', b'%0', b'%01', b'%.', b'%.1',
|
||
b'%0%s', b'%1%s', b'%.%s', b'%.1%s', b'%1abc',
|
||
b'%l', b'%ll', b'%z', b'%ls', b'%lls', b'%zs'):
|
||
with self.subTest(fmt=fmt):
|
||
self.assertRaisesRegex(SystemError, 'invalid format string',
|
||
PyUnicode_FromFormat, fmt, b'abc')
|
||
self.assertRaisesRegex(SystemError, 'invalid format string',
|
||
PyUnicode_FromFormat, b'%+i', c_int(10))
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_aswidechar(self):
|
||
"""Test PyUnicode_AsWideChar()"""
|
||
from _testcapi import unicode_aswidechar
|
||
import_helper.import_module('ctypes')
|
||
from ctypes import c_wchar, sizeof
|
||
|
||
wchar, size = unicode_aswidechar('abcdef', 2)
|
||
self.assertEqual(size, 2)
|
||
self.assertEqual(wchar, 'ab')
|
||
|
||
wchar, size = unicode_aswidechar('abc', 3)
|
||
self.assertEqual(size, 3)
|
||
self.assertEqual(wchar, 'abc')
|
||
|
||
wchar, size = unicode_aswidechar('abc', 4)
|
||
self.assertEqual(size, 3)
|
||
self.assertEqual(wchar, 'abc\0')
|
||
|
||
wchar, size = unicode_aswidechar('abc', 10)
|
||
self.assertEqual(size, 3)
|
||
self.assertEqual(wchar, 'abc\0')
|
||
|
||
wchar, size = unicode_aswidechar('abc\0def', 20)
|
||
self.assertEqual(size, 7)
|
||
self.assertEqual(wchar, 'abc\0def\0')
|
||
|
||
nonbmp = chr(0x10ffff)
|
||
if sizeof(c_wchar) == 2:
|
||
buflen = 3
|
||
nchar = 2
|
||
else: # sizeof(c_wchar) == 4
|
||
buflen = 2
|
||
nchar = 1
|
||
wchar, size = unicode_aswidechar(nonbmp, buflen)
|
||
self.assertEqual(size, nchar)
|
||
self.assertEqual(wchar, nonbmp + '\0')
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_aswidecharstring(self):
|
||
"""Test PyUnicode_AsWideCharString()"""
|
||
from _testcapi import unicode_aswidecharstring
|
||
import_helper.import_module('ctypes')
|
||
from ctypes import c_wchar, sizeof
|
||
|
||
wchar, size = unicode_aswidecharstring('abc')
|
||
self.assertEqual(size, 3)
|
||
self.assertEqual(wchar, 'abc\0')
|
||
|
||
wchar, size = unicode_aswidecharstring('abc\0def')
|
||
self.assertEqual(size, 7)
|
||
self.assertEqual(wchar, 'abc\0def\0')
|
||
|
||
nonbmp = chr(0x10ffff)
|
||
if sizeof(c_wchar) == 2:
|
||
nchar = 2
|
||
else: # sizeof(c_wchar) == 4
|
||
nchar = 1
|
||
wchar, size = unicode_aswidecharstring(nonbmp)
|
||
self.assertEqual(size, nchar)
|
||
self.assertEqual(wchar, nonbmp + '\0')
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_asucs4(self):
|
||
"""Test PyUnicode_AsUCS4()"""
|
||
from _testcapi import unicode_asucs4
|
||
for s in ['abc', '\xa1\xa2', '\u4f60\u597d', 'a\U0001f600',
|
||
'a\ud800b\udfffc', '\ud834\udd1e']:
|
||
l = len(s)
|
||
self.assertEqual(unicode_asucs4(s, l, True), s+'\0')
|
||
self.assertEqual(unicode_asucs4(s, l, False), s+'\uffff')
|
||
self.assertEqual(unicode_asucs4(s, l+1, True), s+'\0\uffff')
|
||
self.assertEqual(unicode_asucs4(s, l+1, False), s+'\0\uffff')
|
||
self.assertRaises(SystemError, unicode_asucs4, s, l-1, True)
|
||
self.assertRaises(SystemError, unicode_asucs4, s, l-2, False)
|
||
s = '\0'.join([s, s])
|
||
self.assertEqual(unicode_asucs4(s, len(s), True), s+'\0')
|
||
self.assertEqual(unicode_asucs4(s, len(s), False), s+'\uffff')
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_asutf8(self):
|
||
"""Test PyUnicode_AsUTF8()"""
|
||
from _testcapi import unicode_asutf8
|
||
|
||
bmp = '\u0100'
|
||
bmp2 = '\uffff'
|
||
nonbmp = chr(0x10ffff)
|
||
|
||
self.assertEqual(unicode_asutf8(bmp), b'\xc4\x80')
|
||
self.assertEqual(unicode_asutf8(bmp2), b'\xef\xbf\xbf')
|
||
self.assertEqual(unicode_asutf8(nonbmp), b'\xf4\x8f\xbf\xbf')
|
||
self.assertRaises(UnicodeEncodeError, unicode_asutf8, 'a\ud800b\udfffc')
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_asutf8andsize(self):
|
||
"""Test PyUnicode_AsUTF8AndSize()"""
|
||
from _testcapi import unicode_asutf8andsize
|
||
|
||
bmp = '\u0100'
|
||
bmp2 = '\uffff'
|
||
nonbmp = chr(0x10ffff)
|
||
|
||
self.assertEqual(unicode_asutf8andsize(bmp), (b'\xc4\x80', 2))
|
||
self.assertEqual(unicode_asutf8andsize(bmp2), (b'\xef\xbf\xbf', 3))
|
||
self.assertEqual(unicode_asutf8andsize(nonbmp), (b'\xf4\x8f\xbf\xbf', 4))
|
||
self.assertRaises(UnicodeEncodeError, unicode_asutf8andsize, 'a\ud800b\udfffc')
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_concat(self):
|
||
"""Test PyUnicode_Concat()"""
|
||
from _testcapi import unicode_concat as concat
|
||
|
||
self.assertEqual(concat('abc', 'def'), 'abcdef')
|
||
self.assertEqual(concat('abc', 'где'), 'abcгде')
|
||
self.assertEqual(concat('абв', 'def'), 'абвdef')
|
||
self.assertEqual(concat('абв', 'где'), 'абвгде')
|
||
self.assertEqual(concat('a\0b', 'c\0d'), 'a\0bc\0d')
|
||
|
||
self.assertRaises(TypeError, concat, b'abc', 'def')
|
||
self.assertRaises(TypeError, concat, 'abc', b'def')
|
||
self.assertRaises(TypeError, concat, b'abc', b'def')
|
||
self.assertRaises(TypeError, concat, [], 'def')
|
||
self.assertRaises(TypeError, concat, 'abc', [])
|
||
self.assertRaises(TypeError, concat, [], [])
|
||
# CRASHES concat(NULL, 'def')
|
||
# CRASHES concat('abc', NULL)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_split(self):
|
||
"""Test PyUnicode_Split()"""
|
||
from _testcapi import unicode_split as split
|
||
|
||
self.assertEqual(split('a|b|c|d', '|'), ['a', 'b', 'c', 'd'])
|
||
self.assertEqual(split('a|b|c|d', '|', 2), ['a', 'b', 'c|d'])
|
||
self.assertEqual(split('a|b|c|d', '\u20ac'), ['a|b|c|d'])
|
||
self.assertEqual(split('a||b|c||d', '||'), ['a', 'b|c', 'd'])
|
||
self.assertEqual(split('а|б|в|г', '|'), ['а', 'б', 'в', 'г'])
|
||
self.assertEqual(split('абабагаламага', 'а'),
|
||
['', 'б', 'б', 'г', 'л', 'м', 'г', ''])
|
||
self.assertEqual(split(' a\tb\nc\rd\ve\f', NULL),
|
||
['a', 'b', 'c', 'd', 'e'])
|
||
self.assertEqual(split('a\x85b\xa0c\u1680d\u2000e', NULL),
|
||
['a', 'b', 'c', 'd', 'e'])
|
||
|
||
self.assertRaises(ValueError, split, 'a|b|c|d', '')
|
||
self.assertRaises(TypeError, split, 'a|b|c|d', ord('|'))
|
||
self.assertRaises(TypeError, split, [], '|')
|
||
# CRASHES split(NULL, '|')
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_rsplit(self):
|
||
"""Test PyUnicode_RSplit()"""
|
||
from _testcapi import unicode_rsplit as rsplit
|
||
|
||
self.assertEqual(rsplit('a|b|c|d', '|'), ['a', 'b', 'c', 'd'])
|
||
self.assertEqual(rsplit('a|b|c|d', '|', 2), ['a|b', 'c', 'd'])
|
||
self.assertEqual(rsplit('a|b|c|d', '\u20ac'), ['a|b|c|d'])
|
||
self.assertEqual(rsplit('a||b|c||d', '||'), ['a', 'b|c', 'd'])
|
||
self.assertEqual(rsplit('а|б|в|г', '|'), ['а', 'б', 'в', 'г'])
|
||
self.assertEqual(rsplit('абабагаламага', 'а'),
|
||
['', 'б', 'б', 'г', 'л', 'м', 'г', ''])
|
||
self.assertEqual(rsplit('aжbжcжd', 'ж'), ['a', 'b', 'c', 'd'])
|
||
self.assertEqual(rsplit(' a\tb\nc\rd\ve\f', NULL),
|
||
['a', 'b', 'c', 'd', 'e'])
|
||
self.assertEqual(rsplit('a\x85b\xa0c\u1680d\u2000e', NULL),
|
||
['a', 'b', 'c', 'd', 'e'])
|
||
|
||
self.assertRaises(ValueError, rsplit, 'a|b|c|d', '')
|
||
self.assertRaises(TypeError, rsplit, 'a|b|c|d', ord('|'))
|
||
self.assertRaises(TypeError, rsplit, [], '|')
|
||
# CRASHES rsplit(NULL, '|')
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_partition(self):
|
||
"""Test PyUnicode_Partition()"""
|
||
from _testcapi import unicode_partition as partition
|
||
|
||
self.assertEqual(partition('a|b|c', '|'), ('a', '|', 'b|c'))
|
||
self.assertEqual(partition('a||b||c', '||'), ('a', '||', 'b||c'))
|
||
self.assertEqual(partition('а|б|в', '|'), ('а', '|', 'б|в'))
|
||
self.assertEqual(partition('кабан', 'а'), ('к', 'а', 'бан'))
|
||
self.assertEqual(partition('aжbжc', 'ж'), ('a', 'ж', 'bжc'))
|
||
|
||
self.assertRaises(ValueError, partition, 'a|b|c', '')
|
||
self.assertRaises(TypeError, partition, b'a|b|c', '|')
|
||
self.assertRaises(TypeError, partition, 'a|b|c', b'|')
|
||
self.assertRaises(TypeError, partition, 'a|b|c', ord('|'))
|
||
self.assertRaises(TypeError, partition, [], '|')
|
||
# CRASHES partition(NULL, '|')
|
||
# CRASHES partition('a|b|c', NULL)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_rpartition(self):
|
||
"""Test PyUnicode_RPartition()"""
|
||
from _testcapi import unicode_rpartition as rpartition
|
||
|
||
self.assertEqual(rpartition('a|b|c', '|'), ('a|b', '|', 'c'))
|
||
self.assertEqual(rpartition('a||b||c', '||'), ('a||b', '||', 'c'))
|
||
self.assertEqual(rpartition('а|б|в', '|'), ('а|б', '|', 'в'))
|
||
self.assertEqual(rpartition('кабан', 'а'), ('каб', 'а', 'н'))
|
||
self.assertEqual(rpartition('aжbжc', 'ж'), ('aжb', 'ж', 'c'))
|
||
|
||
self.assertRaises(ValueError, rpartition, 'a|b|c', '')
|
||
self.assertRaises(TypeError, rpartition, b'a|b|c', '|')
|
||
self.assertRaises(TypeError, rpartition, 'a|b|c', b'|')
|
||
self.assertRaises(TypeError, rpartition, 'a|b|c', ord('|'))
|
||
self.assertRaises(TypeError, rpartition, [], '|')
|
||
# CRASHES rpartition(NULL, '|')
|
||
# CRASHES rpartition('a|b|c', NULL)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_splitlines(self):
|
||
"""Test PyUnicode_SplitLines()"""
|
||
from _testcapi import unicode_splitlines as splitlines
|
||
|
||
self.assertEqual(splitlines('a\nb\rc\r\nd'), ['a', 'b', 'c', 'd'])
|
||
self.assertEqual(splitlines('a\nb\rc\r\nd', True),
|
||
['a\n', 'b\r', 'c\r\n', 'd'])
|
||
self.assertEqual(splitlines('a\x85b\u2028c\u2029d'),
|
||
['a', 'b', 'c', 'd'])
|
||
self.assertEqual(splitlines('a\x85b\u2028c\u2029d', True),
|
||
['a\x85', 'b\u2028', 'c\u2029', 'd'])
|
||
self.assertEqual(splitlines('а\nб\rв\r\nг'), ['а', 'б', 'в', 'г'])
|
||
|
||
self.assertRaises(TypeError, splitlines, b'a\nb\rc\r\nd')
|
||
# CRASHES splitlines(NULL)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_translate(self):
|
||
"""Test PyUnicode_Translate()"""
|
||
from _testcapi import unicode_translate as translate
|
||
|
||
self.assertEqual(translate('abcd', {ord('a'): 'A', ord('b'): ord('B'), ord('c'): '<>'}), 'AB<>d')
|
||
self.assertEqual(translate('абвг', {ord('а'): 'А', ord('б'): ord('Б'), ord('в'): '<>'}), 'АБ<>г')
|
||
self.assertEqual(translate('abc', {}), 'abc')
|
||
self.assertEqual(translate('abc', []), 'abc')
|
||
self.assertRaises(UnicodeTranslateError, translate, 'abc', {ord('b'): None})
|
||
self.assertRaises(UnicodeTranslateError, translate, 'abc', {ord('b'): None}, 'strict')
|
||
self.assertRaises(LookupError, translate, 'abc', {ord('b'): None}, 'foo')
|
||
self.assertEqual(translate('abc', {ord('b'): None}, 'ignore'), 'ac')
|
||
self.assertEqual(translate('abc', {ord('b'): None}, 'replace'), 'a\ufffdc')
|
||
self.assertEqual(translate('abc', {ord('b'): None}, 'backslashreplace'), r'a\x62c')
|
||
# XXX Other error handlers do not support UnicodeTranslateError
|
||
self.assertRaises(TypeError, translate, b'abc', [])
|
||
self.assertRaises(TypeError, translate, 123, [])
|
||
self.assertRaises(TypeError, translate, 'abc', {ord('a'): b'A'})
|
||
self.assertRaises(TypeError, translate, 'abc', 123)
|
||
self.assertRaises(TypeError, translate, 'abc', NULL)
|
||
self.assertRaises(LookupError, translate, 'abc', {ord('b'): None}, 'foo')
|
||
# CRASHES translate(NULL, [])
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_join(self):
|
||
"""Test PyUnicode_Join()"""
|
||
from _testcapi import unicode_join as join
|
||
self.assertEqual(join('|', ['a', 'b', 'c']), 'a|b|c')
|
||
self.assertEqual(join('|', ['a', '', 'c']), 'a||c')
|
||
self.assertEqual(join('', ['a', 'b', 'c']), 'abc')
|
||
self.assertEqual(join(NULL, ['a', 'b', 'c']), 'a b c')
|
||
self.assertEqual(join('|', ['а', 'б', 'в']), 'а|б|в')
|
||
self.assertEqual(join('ж', ['а', 'б', 'в']), 'ажбжв')
|
||
self.assertRaises(TypeError, join, b'|', ['a', 'b', 'c'])
|
||
self.assertRaises(TypeError, join, '|', [b'a', b'b', b'c'])
|
||
self.assertRaises(TypeError, join, NULL, [b'a', b'b', b'c'])
|
||
self.assertRaises(TypeError, join, '|', b'123')
|
||
self.assertRaises(TypeError, join, '|', 123)
|
||
self.assertRaises(SystemError, join, '|', NULL)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_count(self):
|
||
"""Test PyUnicode_Count()"""
|
||
from _testcapi import unicode_count
|
||
|
||
for str in "\xa1", "\u8000\u8080", "\ud800\udc02", "\U0001f100\U0001f1f1":
|
||
for i, ch in enumerate(str):
|
||
self.assertEqual(unicode_count(str, ch, 0, len(str)), 1)
|
||
|
||
str = "!>_<!"
|
||
self.assertEqual(unicode_count(str, 'z', 0, len(str)), 0)
|
||
self.assertEqual(unicode_count(str, '', 0, len(str)), len(str)+1)
|
||
# start < end
|
||
self.assertEqual(unicode_count(str, '!', 1, len(str)+1), 1)
|
||
# start >= end
|
||
self.assertEqual(unicode_count(str, '!', 0, 0), 0)
|
||
self.assertEqual(unicode_count(str, '!', len(str), 0), 0)
|
||
# negative
|
||
self.assertEqual(unicode_count(str, '!', -len(str), -1), 1)
|
||
# bad arguments
|
||
self.assertRaises(TypeError, unicode_count, str, b'!', 0, len(str))
|
||
self.assertRaises(TypeError, unicode_count, b"!>_<!", '!', 0, len(str))
|
||
self.assertRaises(TypeError, unicode_count, str, ord('!'), 0, len(str))
|
||
self.assertRaises(TypeError, unicode_count, [], '!', 0, len(str), 1)
|
||
# CRASHES unicode_count(NULL, '!', 0, len(str))
|
||
# CRASHES unicode_count(str, NULL, 0, len(str))
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_tailmatch(self):
|
||
"""Test PyUnicode_Tailmatch()"""
|
||
from _testcapi import unicode_tailmatch as tailmatch
|
||
|
||
str = 'ababahalamaha'
|
||
self.assertEqual(tailmatch(str, 'aba', 0, len(str), -1), 1)
|
||
self.assertEqual(tailmatch(str, 'aha', 0, len(str), 1), 1)
|
||
|
||
self.assertEqual(tailmatch(str, 'aba', 0, sys.maxsize, -1), 1)
|
||
self.assertEqual(tailmatch(str, 'aba', -len(str), sys.maxsize, -1), 1)
|
||
self.assertEqual(tailmatch(str, 'aba', -sys.maxsize-1, len(str), -1), 1)
|
||
self.assertEqual(tailmatch(str, 'aha', 0, sys.maxsize, 1), 1)
|
||
self.assertEqual(tailmatch(str, 'aha', -sys.maxsize-1, len(str), 1), 1)
|
||
|
||
self.assertEqual(tailmatch(str, 'z', 0, len(str), 1), 0)
|
||
self.assertEqual(tailmatch(str, 'z', 0, len(str), -1), 0)
|
||
self.assertEqual(tailmatch(str, '', 0, len(str), 1), 1)
|
||
self.assertEqual(tailmatch(str, '', 0, len(str), -1), 1)
|
||
|
||
self.assertEqual(tailmatch(str, 'ba', 0, len(str)-1, -1), 0)
|
||
self.assertEqual(tailmatch(str, 'ba', 1, len(str)-1, -1), 1)
|
||
self.assertEqual(tailmatch(str, 'aba', 1, len(str)-1, -1), 0)
|
||
self.assertEqual(tailmatch(str, 'ba', -len(str)+1, -1, -1), 1)
|
||
self.assertEqual(tailmatch(str, 'ah', 0, len(str), 1), 0)
|
||
self.assertEqual(tailmatch(str, 'ah', 0, len(str)-1, 1), 1)
|
||
self.assertEqual(tailmatch(str, 'ah', -len(str), -1, 1), 1)
|
||
|
||
# bad arguments
|
||
self.assertRaises(TypeError, tailmatch, str, ('aba', 'aha'), 0, len(str), -1)
|
||
self.assertRaises(TypeError, tailmatch, str, ('aba', 'aha'), 0, len(str), 1)
|
||
# CRASHES tailmatch(NULL, 'aba', 0, len(str), -1)
|
||
# CRASHES tailmatch(str, NULL, 0, len(str), -1)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_find(self):
|
||
"""Test PyUnicode_Find()"""
|
||
from _testcapi import unicode_find as find
|
||
|
||
for str in "\xa1", "\u8000\u8080", "\ud800\udc02", "\U0001f100\U0001f1f1":
|
||
for i, ch in enumerate(str):
|
||
self.assertEqual(find(str, ch, 0, len(str), 1), i)
|
||
self.assertEqual(find(str, ch, 0, len(str), -1), i)
|
||
|
||
str = "!>_<!"
|
||
self.assertEqual(find(str, 'z', 0, len(str), 1), -1)
|
||
self.assertEqual(find(str, 'z', 0, len(str), -1), -1)
|
||
self.assertEqual(find(str, '', 0, len(str), 1), 0)
|
||
self.assertEqual(find(str, '', 0, len(str), -1), len(str))
|
||
# start < end
|
||
self.assertEqual(find(str, '!', 1, len(str)+1, 1), 4)
|
||
self.assertEqual(find(str, '!', 1, len(str)+1, -1), 4)
|
||
# start >= end
|
||
self.assertEqual(find(str, '!', 0, 0, 1), -1)
|
||
self.assertEqual(find(str, '!', len(str), 0, 1), -1)
|
||
# negative
|
||
self.assertEqual(find(str, '!', -len(str), -1, 1), 0)
|
||
self.assertEqual(find(str, '!', -len(str), -1, -1), 0)
|
||
# bad arguments
|
||
self.assertRaises(TypeError, find, str, b'!', 0, len(str), 1)
|
||
self.assertRaises(TypeError, find, b"!>_<!", '!', 0, len(str), 1)
|
||
self.assertRaises(TypeError, find, str, ord('!'), 0, len(str), 1)
|
||
self.assertRaises(TypeError, find, [], '!', 0, len(str), 1)
|
||
# CRASHES find(NULL, '!', 0, len(str), 1)
|
||
# CRASHES find(str, NULL, 0, len(str), 1)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_findchar(self):
|
||
"""Test PyUnicode_FindChar()"""
|
||
from _testcapi import unicode_findchar
|
||
|
||
for str in "\xa1", "\u8000\u8080", "\ud800\udc02", "\U0001f100\U0001f1f1":
|
||
for i, ch in enumerate(str):
|
||
self.assertEqual(unicode_findchar(str, ord(ch), 0, len(str), 1), i)
|
||
self.assertEqual(unicode_findchar(str, ord(ch), 0, len(str), -1), i)
|
||
|
||
str = "!>_<!"
|
||
self.assertEqual(unicode_findchar(str, 0x110000, 0, len(str), 1), -1)
|
||
self.assertEqual(unicode_findchar(str, 0x110000, 0, len(str), -1), -1)
|
||
# start < end
|
||
self.assertEqual(unicode_findchar(str, ord('!'), 1, len(str)+1, 1), 4)
|
||
self.assertEqual(unicode_findchar(str, ord('!'), 1, len(str)+1, -1), 4)
|
||
# start >= end
|
||
self.assertEqual(unicode_findchar(str, ord('!'), 0, 0, 1), -1)
|
||
self.assertEqual(unicode_findchar(str, ord('!'), len(str), 0, 1), -1)
|
||
# negative
|
||
self.assertEqual(unicode_findchar(str, ord('!'), -len(str), -1, 1), 0)
|
||
self.assertEqual(unicode_findchar(str, ord('!'), -len(str), -1, -1), 0)
|
||
# bad arguments
|
||
# CRASHES unicode_findchar(b"!>_<!", ord('!'), 0, len(str), 1)
|
||
# CRASHES unicode_findchar([], ord('!'), 0, len(str), 1)
|
||
# CRASHES unicode_findchar(NULL, ord('!'), 0, len(str), 1), 1)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_replace(self):
|
||
"""Test PyUnicode_Replace()"""
|
||
from _testcapi import unicode_replace as replace
|
||
|
||
str = 'abracadabra'
|
||
self.assertEqual(replace(str, 'a', '='), '=br=c=d=br=')
|
||
self.assertEqual(replace(str, 'a', '<>'), '<>br<>c<>d<>br<>')
|
||
self.assertEqual(replace(str, 'abra', '='), '=cad=')
|
||
self.assertEqual(replace(str, 'a', '=', 2), '=br=cadabra')
|
||
self.assertEqual(replace(str, 'a', '=', 0), str)
|
||
self.assertEqual(replace(str, 'a', '=', sys.maxsize), '=br=c=d=br=')
|
||
self.assertEqual(replace(str, 'z', '='), str)
|
||
self.assertEqual(replace(str, '', '='), '=a=b=r=a=c=a=d=a=b=r=a=')
|
||
self.assertEqual(replace(str, 'a', 'ж'), 'жbrжcжdжbrж')
|
||
self.assertEqual(replace('абабагаламага', 'а', '='), '=б=б=г=л=м=г=')
|
||
self.assertEqual(replace('Баден-Баден', 'Баден', 'Baden'), 'Baden-Baden')
|
||
# bad arguments
|
||
self.assertRaises(TypeError, replace, 'a', 'a', b'=')
|
||
self.assertRaises(TypeError, replace, 'a', b'a', '=')
|
||
self.assertRaises(TypeError, replace, b'a', 'a', '=')
|
||
self.assertRaises(TypeError, replace, 'a', 'a', ord('='))
|
||
self.assertRaises(TypeError, replace, 'a', ord('a'), '=')
|
||
self.assertRaises(TypeError, replace, [], 'a', '=')
|
||
# CRASHES replace('a', 'a', NULL)
|
||
# CRASHES replace('a', NULL, '=')
|
||
# CRASHES replace(NULL, 'a', '=')
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_compare(self):
|
||
"""Test PyUnicode_Compare()"""
|
||
from _testcapi import unicode_compare as compare
|
||
|
||
self.assertEqual(compare('abc', 'abc'), 0)
|
||
self.assertEqual(compare('abc', 'def'), -1)
|
||
self.assertEqual(compare('def', 'abc'), 1)
|
||
self.assertEqual(compare('abc', 'abc\0def'), -1)
|
||
self.assertEqual(compare('abc\0def', 'abc\0def'), 0)
|
||
self.assertEqual(compare('абв', 'abc'), 1)
|
||
|
||
self.assertRaises(TypeError, compare, b'abc', 'abc')
|
||
self.assertRaises(TypeError, compare, 'abc', b'abc')
|
||
self.assertRaises(TypeError, compare, b'abc', b'abc')
|
||
self.assertRaises(TypeError, compare, [], 'abc')
|
||
self.assertRaises(TypeError, compare, 'abc', [])
|
||
self.assertRaises(TypeError, compare, [], [])
|
||
# CRASHES compare(NULL, 'abc')
|
||
# CRASHES compare('abc', NULL)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_comparewithasciistring(self):
|
||
"""Test PyUnicode_CompareWithASCIIString()"""
|
||
from _testcapi import unicode_comparewithasciistring as comparewithasciistring
|
||
|
||
self.assertEqual(comparewithasciistring('abc', b'abc'), 0)
|
||
self.assertEqual(comparewithasciistring('abc', b'def'), -1)
|
||
self.assertEqual(comparewithasciistring('def', b'abc'), 1)
|
||
self.assertEqual(comparewithasciistring('abc', b'abc\0def'), 0)
|
||
self.assertEqual(comparewithasciistring('abc\0def', b'abc\0def'), 1)
|
||
self.assertEqual(comparewithasciistring('абв', b'abc'), 1)
|
||
|
||
# CRASHES comparewithasciistring(b'abc', b'abc')
|
||
# CRASHES comparewithasciistring([], b'abc')
|
||
# CRASHES comparewithasciistring(NULL, b'abc')
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_richcompare(self):
|
||
"""Test PyUnicode_RichCompare()"""
|
||
from _testcapi import unicode_richcompare as richcompare
|
||
|
||
LT, LE, EQ, NE, GT, GE = range(6)
|
||
strings = ('abc', 'абв', '\U0001f600', 'abc\0')
|
||
for s1 in strings:
|
||
for s2 in strings:
|
||
self.assertIs(richcompare(s1, s2, LT), s1 < s2)
|
||
self.assertIs(richcompare(s1, s2, LE), s1 <= s2)
|
||
self.assertIs(richcompare(s1, s2, EQ), s1 == s2)
|
||
self.assertIs(richcompare(s1, s2, NE), s1 != s2)
|
||
self.assertIs(richcompare(s1, s2, GT), s1 > s2)
|
||
self.assertIs(richcompare(s1, s2, GE), s1 >= s2)
|
||
|
||
for op in LT, LE, EQ, NE, GT, GE:
|
||
self.assertIs(richcompare(b'abc', 'abc', op), NotImplemented)
|
||
self.assertIs(richcompare('abc', b'abc', op), NotImplemented)
|
||
self.assertIs(richcompare(b'abc', b'abc', op), NotImplemented)
|
||
self.assertIs(richcompare([], 'abc', op), NotImplemented)
|
||
self.assertIs(richcompare('abc', [], op), NotImplemented)
|
||
self.assertIs(richcompare([], [], op), NotImplemented)
|
||
|
||
# CRASHES richcompare(NULL, 'abc', op)
|
||
# CRASHES richcompare('abc', NULL, op)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_format(self):
|
||
"""Test PyUnicode_Format()"""
|
||
from _testcapi import unicode_format as format
|
||
|
||
self.assertEqual(format('x=%d!', 42), 'x=42!')
|
||
self.assertEqual(format('x=%d!', (42,)), 'x=42!')
|
||
self.assertEqual(format('x=%d y=%s!', (42, [])), 'x=42 y=[]!')
|
||
|
||
self.assertRaises(SystemError, format, 'x=%d!', NULL)
|
||
self.assertRaises(SystemError, format, NULL, 42)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_contains(self):
|
||
"""Test PyUnicode_Contains()"""
|
||
from _testcapi import unicode_contains as contains
|
||
|
||
self.assertEqual(contains('abcd', ''), 1)
|
||
self.assertEqual(contains('abcd', 'b'), 1)
|
||
self.assertEqual(contains('abcd', 'x'), 0)
|
||
self.assertEqual(contains('abcd', 'ж'), 0)
|
||
self.assertEqual(contains('abcd', '\0'), 0)
|
||
self.assertEqual(contains('abc\0def', '\0'), 1)
|
||
self.assertEqual(contains('abcd', 'bc'), 1)
|
||
|
||
self.assertRaises(TypeError, contains, b'abcd', 'b')
|
||
self.assertRaises(TypeError, contains, 'abcd', b'b')
|
||
self.assertRaises(TypeError, contains, b'abcd', b'b')
|
||
self.assertRaises(TypeError, contains, [], 'b')
|
||
self.assertRaises(TypeError, contains, 'abcd', ord('b'))
|
||
# CRASHES contains(NULL, 'b')
|
||
# CRASHES contains('abcd', NULL)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_isidentifier(self):
|
||
"""Test PyUnicode_IsIdentifier()"""
|
||
from _testcapi import unicode_isidentifier as isidentifier
|
||
|
||
self.assertEqual(isidentifier("a"), 1)
|
||
self.assertEqual(isidentifier("b0"), 1)
|
||
self.assertEqual(isidentifier("µ"), 1)
|
||
self.assertEqual(isidentifier("𝔘𝔫𝔦𝔠𝔬𝔡𝔢"), 1)
|
||
|
||
self.assertEqual(isidentifier(""), 0)
|
||
self.assertEqual(isidentifier(" "), 0)
|
||
self.assertEqual(isidentifier("["), 0)
|
||
self.assertEqual(isidentifier("©"), 0)
|
||
self.assertEqual(isidentifier("0"), 0)
|
||
self.assertEqual(isidentifier("32M"), 0)
|
||
|
||
# CRASHES isidentifier(b"a")
|
||
# CRASHES isidentifier([])
|
||
# CRASHES isidentifier(NULL)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_copycharacters(self):
|
||
"""Test PyUnicode_CopyCharacters()"""
|
||
from _testcapi import unicode_copycharacters
|
||
|
||
strings = [
|
||
'abcde', '\xa1\xa2\xa3\xa4\xa5',
|
||
'\u4f60\u597d\u4e16\u754c\uff01',
|
||
'\U0001f600\U0001f601\U0001f602\U0001f603\U0001f604'
|
||
]
|
||
|
||
for idx, from_ in enumerate(strings):
|
||
# wide -> narrow: exceed maxchar limitation
|
||
for to in strings[:idx]:
|
||
self.assertRaises(
|
||
SystemError,
|
||
unicode_copycharacters, to, 0, from_, 0, 5
|
||
)
|
||
# same kind
|
||
for from_start in range(5):
|
||
self.assertEqual(
|
||
unicode_copycharacters(from_, 0, from_, from_start, 5),
|
||
(from_[from_start:from_start+5].ljust(5, '\0'),
|
||
5-from_start)
|
||
)
|
||
for to_start in range(5):
|
||
self.assertEqual(
|
||
unicode_copycharacters(from_, to_start, from_, to_start, 5),
|
||
(from_[to_start:to_start+5].rjust(5, '\0'),
|
||
5-to_start)
|
||
)
|
||
# narrow -> wide
|
||
# Tests omitted since this creates invalid strings.
|
||
|
||
s = strings[0]
|
||
self.assertRaises(IndexError, unicode_copycharacters, s, 6, s, 0, 5)
|
||
self.assertRaises(IndexError, unicode_copycharacters, s, -1, s, 0, 5)
|
||
self.assertRaises(IndexError, unicode_copycharacters, s, 0, s, 6, 5)
|
||
self.assertRaises(IndexError, unicode_copycharacters, s, 0, s, -1, 5)
|
||
self.assertRaises(SystemError, unicode_copycharacters, s, 1, s, 0, 5)
|
||
self.assertRaises(SystemError, unicode_copycharacters, s, 0, s, 0, -1)
|
||
self.assertRaises(SystemError, unicode_copycharacters, s, 0, b'', 0, 0)
|
||
|
||
@support.cpython_only
|
||
@unittest.skipIf(_testcapi is None, 'need _testcapi module')
|
||
def test_pep393_utf8_caching_bug(self):
|
||
# Issue #25709: Problem with string concatenation and utf-8 cache
|
||
from _testcapi import getargs_s_hash
|
||
for k in 0x24, 0xa4, 0x20ac, 0x1f40d:
|
||
s = ''
|
||
for i in range(5):
|
||
# Due to CPython specific optimization the 's' string can be
|
||
# resized in-place.
|
||
s += chr(k)
|
||
# Parsing with the "s#" format code calls indirectly
|
||
# PyUnicode_AsUTF8AndSize() which creates the UTF-8
|
||
# encoded string cached in the Unicode object.
|
||
self.assertEqual(getargs_s_hash(s), chr(k).encode() * (i + 1))
|
||
# Check that the second call returns the same result
|
||
self.assertEqual(getargs_s_hash(s), chr(k).encode() * (i + 1))
|
||
|
||
|
||
if __name__ == "__main__":
|
||
unittest.main()
|