580 lines
23 KiB
Python
580 lines
23 KiB
Python
import unittest
|
|
import struct
|
|
import sys
|
|
from test import test_support, string_tests
|
|
|
|
|
|
class StrSubclass(str):
|
|
pass
|
|
|
|
class StrTest(
|
|
string_tests.CommonTest,
|
|
string_tests.MixinStrUnicodeUserStringTest,
|
|
string_tests.MixinStrUserStringTest,
|
|
string_tests.MixinStrUnicodeTest,
|
|
):
|
|
|
|
type2test = str
|
|
|
|
# We don't need to propagate to str
|
|
def fixtype(self, obj):
|
|
return obj
|
|
|
|
def test_basic_creation(self):
|
|
self.assertEqual(str(''), '')
|
|
self.assertEqual(str(0), '0')
|
|
self.assertEqual(str(0L), '0')
|
|
self.assertEqual(str(()), '()')
|
|
self.assertEqual(str([]), '[]')
|
|
self.assertEqual(str({}), '{}')
|
|
a = []
|
|
a.append(a)
|
|
self.assertEqual(str(a), '[[...]]')
|
|
a = {}
|
|
a[0] = a
|
|
self.assertEqual(str(a), '{0: {...}}')
|
|
|
|
def test_formatting(self):
|
|
string_tests.MixinStrUnicodeUserStringTest.test_formatting(self)
|
|
self.assertRaises(OverflowError, '%c'.__mod__, 0x1234)
|
|
|
|
@test_support.cpython_only
|
|
def test_formatting_huge_precision(self):
|
|
from _testcapi import INT_MAX
|
|
format_string = "%.{}f".format(INT_MAX + 1)
|
|
with self.assertRaises(ValueError):
|
|
result = format_string % 2.34
|
|
|
|
def test_formatting_huge_width(self):
|
|
format_string = "%{}f".format(sys.maxsize + 1)
|
|
with self.assertRaises(ValueError):
|
|
result = format_string % 2.34
|
|
|
|
def test_conversion(self):
|
|
# Make sure __str__() behaves properly
|
|
class Foo0:
|
|
def __unicode__(self):
|
|
return u"foo"
|
|
|
|
class Foo1:
|
|
def __str__(self):
|
|
return "foo"
|
|
|
|
class Foo2(object):
|
|
def __str__(self):
|
|
return "foo"
|
|
|
|
class Foo3(object):
|
|
def __str__(self):
|
|
return u"foo"
|
|
|
|
class Foo4(unicode):
|
|
def __str__(self):
|
|
return u"foo"
|
|
|
|
class Foo5(str):
|
|
def __str__(self):
|
|
return u"foo"
|
|
|
|
class Foo6(str):
|
|
def __str__(self):
|
|
return "foos"
|
|
|
|
def __unicode__(self):
|
|
return u"foou"
|
|
|
|
class Foo7(unicode):
|
|
def __str__(self):
|
|
return "foos"
|
|
def __unicode__(self):
|
|
return u"foou"
|
|
|
|
class Foo8(str):
|
|
def __new__(cls, content=""):
|
|
return str.__new__(cls, 2*content)
|
|
def __str__(self):
|
|
return self
|
|
|
|
class Foo9(str):
|
|
def __str__(self):
|
|
return "string"
|
|
def __unicode__(self):
|
|
return "not unicode"
|
|
|
|
self.assertTrue(str(Foo0()).startswith("<")) # this is different from __unicode__
|
|
self.assertEqual(str(Foo1()), "foo")
|
|
self.assertEqual(str(Foo2()), "foo")
|
|
self.assertEqual(str(Foo3()), "foo")
|
|
self.assertEqual(str(Foo4("bar")), "foo")
|
|
self.assertEqual(str(Foo5("bar")), "foo")
|
|
self.assertEqual(str(Foo6("bar")), "foos")
|
|
self.assertEqual(str(Foo7("bar")), "foos")
|
|
self.assertEqual(str(Foo8("foo")), "foofoo")
|
|
self.assertIs(type(str(Foo8("foo"))), Foo8)
|
|
self.assertEqual(StrSubclass(Foo8("foo")), "foofoo")
|
|
self.assertIs(type(StrSubclass(Foo8("foo"))), StrSubclass)
|
|
self.assertEqual(str(Foo9("foo")), "string")
|
|
self.assertEqual(unicode(Foo9("foo")), u"not unicode")
|
|
|
|
# This test only affects 32-bit platforms because expandtabs can only take
|
|
# an int as the max value, not a 64-bit C long. If expandtabs is changed
|
|
# to take a 64-bit long, this test should apply to all platforms.
|
|
@unittest.skipIf(sys.maxint > (1 << 32) or struct.calcsize('P') != 4,
|
|
'only applies to 32-bit platforms')
|
|
def test_expandtabs_overflows_gracefully(self):
|
|
self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxint)
|
|
|
|
def test__format__(self):
|
|
def test(value, format, expected):
|
|
# test both with and without the trailing 's'
|
|
self.assertEqual(value.__format__(format), expected)
|
|
self.assertEqual(value.__format__(format + 's'), expected)
|
|
|
|
test('', '', '')
|
|
test('abc', '', 'abc')
|
|
test('abc', '.3', 'abc')
|
|
test('ab', '.3', 'ab')
|
|
test('abcdef', '.3', 'abc')
|
|
test('abcdef', '.0', '')
|
|
test('abc', '3.3', 'abc')
|
|
test('abc', '2.3', 'abc')
|
|
test('abc', '2.2', 'ab')
|
|
test('abc', '3.2', 'ab ')
|
|
test('result', 'x<0', 'result')
|
|
test('result', 'x<5', 'result')
|
|
test('result', 'x<6', 'result')
|
|
test('result', 'x<7', 'resultx')
|
|
test('result', 'x<8', 'resultxx')
|
|
test('result', ' <7', 'result ')
|
|
test('result', '<7', 'result ')
|
|
test('result', '>7', ' result')
|
|
test('result', '>8', ' result')
|
|
test('result', '^8', ' result ')
|
|
test('result', '^9', ' result ')
|
|
test('result', '^10', ' result ')
|
|
test('a', '10000', 'a' + ' ' * 9999)
|
|
test('', '10000', ' ' * 10000)
|
|
test('', '10000000', ' ' * 10000000)
|
|
|
|
def test_format(self):
|
|
self.assertEqual(''.format(), '')
|
|
self.assertEqual('a'.format(), 'a')
|
|
self.assertEqual('ab'.format(), 'ab')
|
|
self.assertEqual('a{{'.format(), 'a{')
|
|
self.assertEqual('a}}'.format(), 'a}')
|
|
self.assertEqual('{{b'.format(), '{b')
|
|
self.assertEqual('}}b'.format(), '}b')
|
|
self.assertEqual('a{{b'.format(), 'a{b')
|
|
|
|
# examples from the PEP:
|
|
import datetime
|
|
self.assertEqual("My name is {0}".format('Fred'), "My name is Fred")
|
|
self.assertEqual("My name is {0[name]}".format(dict(name='Fred')),
|
|
"My name is Fred")
|
|
self.assertEqual("My name is {0} :-{{}}".format('Fred'),
|
|
"My name is Fred :-{}")
|
|
|
|
d = datetime.date(2007, 8, 18)
|
|
self.assertEqual("The year is {0.year}".format(d),
|
|
"The year is 2007")
|
|
|
|
# classes we'll use for testing
|
|
class C:
|
|
def __init__(self, x=100):
|
|
self._x = x
|
|
def __format__(self, spec):
|
|
return spec
|
|
|
|
class D:
|
|
def __init__(self, x):
|
|
self.x = x
|
|
def __format__(self, spec):
|
|
return str(self.x)
|
|
|
|
# class with __str__, but no __format__
|
|
class E:
|
|
def __init__(self, x):
|
|
self.x = x
|
|
def __str__(self):
|
|
return 'E(' + self.x + ')'
|
|
|
|
# class with __repr__, but no __format__ or __str__
|
|
class F:
|
|
def __init__(self, x):
|
|
self.x = x
|
|
def __repr__(self):
|
|
return 'F(' + self.x + ')'
|
|
|
|
# class with __format__ that forwards to string, for some format_spec's
|
|
class G:
|
|
def __init__(self, x):
|
|
self.x = x
|
|
def __str__(self):
|
|
return "string is " + self.x
|
|
def __format__(self, format_spec):
|
|
if format_spec == 'd':
|
|
return 'G(' + self.x + ')'
|
|
return object.__format__(self, format_spec)
|
|
|
|
# class that returns a bad type from __format__
|
|
class H:
|
|
def __format__(self, format_spec):
|
|
return 1.0
|
|
|
|
class I(datetime.date):
|
|
def __format__(self, format_spec):
|
|
return self.strftime(format_spec)
|
|
|
|
class J(int):
|
|
def __format__(self, format_spec):
|
|
return int.__format__(self * 2, format_spec)
|
|
|
|
|
|
self.assertEqual(''.format(), '')
|
|
self.assertEqual('abc'.format(), 'abc')
|
|
self.assertEqual('{0}'.format('abc'), 'abc')
|
|
self.assertEqual('{0:}'.format('abc'), 'abc')
|
|
self.assertEqual('X{0}'.format('abc'), 'Xabc')
|
|
self.assertEqual('{0}X'.format('abc'), 'abcX')
|
|
self.assertEqual('X{0}Y'.format('abc'), 'XabcY')
|
|
self.assertEqual('{1}'.format(1, 'abc'), 'abc')
|
|
self.assertEqual('X{1}'.format(1, 'abc'), 'Xabc')
|
|
self.assertEqual('{1}X'.format(1, 'abc'), 'abcX')
|
|
self.assertEqual('X{1}Y'.format(1, 'abc'), 'XabcY')
|
|
self.assertEqual('{0}'.format(-15), '-15')
|
|
self.assertEqual('{0}{1}'.format(-15, 'abc'), '-15abc')
|
|
self.assertEqual('{0}X{1}'.format(-15, 'abc'), '-15Xabc')
|
|
self.assertEqual('{{'.format(), '{')
|
|
self.assertEqual('}}'.format(), '}')
|
|
self.assertEqual('{{}}'.format(), '{}')
|
|
self.assertEqual('{{x}}'.format(), '{x}')
|
|
self.assertEqual('{{{0}}}'.format(123), '{123}')
|
|
self.assertEqual('{{{{0}}}}'.format(), '{{0}}')
|
|
self.assertEqual('}}{{'.format(), '}{')
|
|
self.assertEqual('}}x{{'.format(), '}x{')
|
|
|
|
# weird field names
|
|
self.assertEqual("{0[foo-bar]}".format({'foo-bar':'baz'}), 'baz')
|
|
self.assertEqual("{0[foo bar]}".format({'foo bar':'baz'}), 'baz')
|
|
self.assertEqual("{0[ ]}".format({' ':3}), '3')
|
|
|
|
self.assertEqual('{foo._x}'.format(foo=C(20)), '20')
|
|
self.assertEqual('{1}{0}'.format(D(10), D(20)), '2010')
|
|
self.assertEqual('{0._x.x}'.format(C(D('abc'))), 'abc')
|
|
self.assertEqual('{0[0]}'.format(['abc', 'def']), 'abc')
|
|
self.assertEqual('{0[1]}'.format(['abc', 'def']), 'def')
|
|
self.assertEqual('{0[1][0]}'.format(['abc', ['def']]), 'def')
|
|
self.assertEqual('{0[1][0].x}'.format(['abc', [D('def')]]), 'def')
|
|
|
|
# strings
|
|
self.assertEqual('{0:.3s}'.format('abc'), 'abc')
|
|
self.assertEqual('{0:.3s}'.format('ab'), 'ab')
|
|
self.assertEqual('{0:.3s}'.format('abcdef'), 'abc')
|
|
self.assertEqual('{0:.0s}'.format('abcdef'), '')
|
|
self.assertEqual('{0:3.3s}'.format('abc'), 'abc')
|
|
self.assertEqual('{0:2.3s}'.format('abc'), 'abc')
|
|
self.assertEqual('{0:2.2s}'.format('abc'), 'ab')
|
|
self.assertEqual('{0:3.2s}'.format('abc'), 'ab ')
|
|
self.assertEqual('{0:x<0s}'.format('result'), 'result')
|
|
self.assertEqual('{0:x<5s}'.format('result'), 'result')
|
|
self.assertEqual('{0:x<6s}'.format('result'), 'result')
|
|
self.assertEqual('{0:x<7s}'.format('result'), 'resultx')
|
|
self.assertEqual('{0:x<8s}'.format('result'), 'resultxx')
|
|
self.assertEqual('{0: <7s}'.format('result'), 'result ')
|
|
self.assertEqual('{0:<7s}'.format('result'), 'result ')
|
|
self.assertEqual('{0:>7s}'.format('result'), ' result')
|
|
self.assertEqual('{0:>8s}'.format('result'), ' result')
|
|
self.assertEqual('{0:^8s}'.format('result'), ' result ')
|
|
self.assertEqual('{0:^9s}'.format('result'), ' result ')
|
|
self.assertEqual('{0:^10s}'.format('result'), ' result ')
|
|
self.assertEqual('{0:10000}'.format('a'), 'a' + ' ' * 9999)
|
|
self.assertEqual('{0:10000}'.format(''), ' ' * 10000)
|
|
self.assertEqual('{0:10000000}'.format(''), ' ' * 10000000)
|
|
|
|
# format specifiers for user defined type
|
|
self.assertEqual('{0:abc}'.format(C()), 'abc')
|
|
|
|
# !r and !s coercions
|
|
self.assertEqual('{0!s}'.format('Hello'), 'Hello')
|
|
self.assertEqual('{0!s:}'.format('Hello'), 'Hello')
|
|
self.assertEqual('{0!s:15}'.format('Hello'), 'Hello ')
|
|
self.assertEqual('{0!s:15s}'.format('Hello'), 'Hello ')
|
|
self.assertEqual('{0!r}'.format('Hello'), "'Hello'")
|
|
self.assertEqual('{0!r:}'.format('Hello'), "'Hello'")
|
|
self.assertEqual('{0!r}'.format(F('Hello')), 'F(Hello)')
|
|
|
|
# test fallback to object.__format__
|
|
self.assertEqual('{0}'.format({}), '{}')
|
|
self.assertEqual('{0}'.format([]), '[]')
|
|
self.assertEqual('{0}'.format([1]), '[1]')
|
|
self.assertEqual('{0}'.format(E('data')), 'E(data)')
|
|
self.assertEqual('{0:d}'.format(G('data')), 'G(data)')
|
|
self.assertEqual('{0!s}'.format(G('data')), 'string is data')
|
|
|
|
msg = 'object.__format__ with a non-empty format string is deprecated'
|
|
with test_support.check_warnings((msg, PendingDeprecationWarning)):
|
|
self.assertEqual('{0:^10}'.format(E('data')), ' E(data) ')
|
|
self.assertEqual('{0:^10s}'.format(E('data')), ' E(data) ')
|
|
self.assertEqual('{0:>15s}'.format(G('data')), ' string is data')
|
|
|
|
self.assertEqual("{0:date: %Y-%m-%d}".format(I(year=2007,
|
|
month=8,
|
|
day=27)),
|
|
"date: 2007-08-27")
|
|
|
|
# test deriving from a builtin type and overriding __format__
|
|
self.assertEqual("{0}".format(J(10)), "20")
|
|
|
|
|
|
# string format specifiers
|
|
self.assertEqual('{0:}'.format('a'), 'a')
|
|
|
|
# computed format specifiers
|
|
self.assertEqual("{0:.{1}}".format('hello world', 5), 'hello')
|
|
self.assertEqual("{0:.{1}s}".format('hello world', 5), 'hello')
|
|
self.assertEqual("{0:.{precision}s}".format('hello world', precision=5), 'hello')
|
|
self.assertEqual("{0:{width}.{precision}s}".format('hello world', width=10, precision=5), 'hello ')
|
|
self.assertEqual("{0:{width}.{precision}s}".format('hello world', width='10', precision='5'), 'hello ')
|
|
|
|
# test various errors
|
|
self.assertRaises(ValueError, '{'.format)
|
|
self.assertRaises(ValueError, '}'.format)
|
|
self.assertRaises(ValueError, 'a{'.format)
|
|
self.assertRaises(ValueError, 'a}'.format)
|
|
self.assertRaises(ValueError, '{a'.format)
|
|
self.assertRaises(ValueError, '}a'.format)
|
|
self.assertRaises(IndexError, '{0}'.format)
|
|
self.assertRaises(IndexError, '{1}'.format, 'abc')
|
|
self.assertRaises(KeyError, '{x}'.format)
|
|
self.assertRaises(ValueError, "}{".format)
|
|
self.assertRaises(ValueError, "{".format)
|
|
self.assertRaises(ValueError, "}".format)
|
|
self.assertRaises(ValueError, "abc{0:{}".format)
|
|
self.assertRaises(ValueError, "{0".format)
|
|
self.assertRaises(IndexError, "{0.}".format)
|
|
self.assertRaises(ValueError, "{0.}".format, 0)
|
|
self.assertRaises(IndexError, "{0[}".format)
|
|
self.assertRaises(ValueError, "{0[}".format, [])
|
|
self.assertRaises(KeyError, "{0]}".format)
|
|
self.assertRaises(ValueError, "{0.[]}".format, 0)
|
|
self.assertRaises(ValueError, "{0..foo}".format, 0)
|
|
self.assertRaises(ValueError, "{0[0}".format, 0)
|
|
self.assertRaises(ValueError, "{0[0:foo}".format, 0)
|
|
self.assertRaises(KeyError, "{c]}".format)
|
|
self.assertRaises(ValueError, "{{ {{{0}}".format, 0)
|
|
self.assertRaises(ValueError, "{0}}".format, 0)
|
|
self.assertRaises(KeyError, "{foo}".format, bar=3)
|
|
self.assertRaises(ValueError, "{0!x}".format, 3)
|
|
self.assertRaises(ValueError, "{0!}".format, 0)
|
|
self.assertRaises(ValueError, "{0!rs}".format, 0)
|
|
self.assertRaises(ValueError, "{!}".format)
|
|
self.assertRaises(IndexError, "{:}".format)
|
|
self.assertRaises(IndexError, "{:s}".format)
|
|
self.assertRaises(IndexError, "{}".format)
|
|
|
|
# issue 6089
|
|
self.assertRaises(ValueError, "{0[0]x}".format, [None])
|
|
self.assertRaises(ValueError, "{0[0](10)}".format, [None])
|
|
|
|
# can't have a replacement on the field name portion
|
|
self.assertRaises(TypeError, '{0[{1}]}'.format, 'abcdefg', 4)
|
|
|
|
# exceed maximum recursion depth
|
|
self.assertRaises(ValueError, "{0:{1:{2}}}".format, 'abc', 's', '')
|
|
self.assertRaises(ValueError, "{0:{1:{2:{3:{4:{5:{6}}}}}}}".format,
|
|
0, 1, 2, 3, 4, 5, 6, 7)
|
|
|
|
# string format spec errors
|
|
self.assertRaises(ValueError, "{0:-s}".format, '')
|
|
self.assertRaises(ValueError, format, "", "-")
|
|
self.assertRaises(ValueError, "{0:=s}".format, '')
|
|
|
|
def test_format_huge_precision(self):
|
|
format_string = ".{}f".format(sys.maxsize + 1)
|
|
with self.assertRaises(ValueError):
|
|
result = format(2.34, format_string)
|
|
|
|
def test_format_huge_width(self):
|
|
format_string = "{}f".format(sys.maxsize + 1)
|
|
with self.assertRaises(ValueError):
|
|
result = format(2.34, format_string)
|
|
|
|
def test_format_huge_item_number(self):
|
|
format_string = "{{{}:.6f}}".format(sys.maxsize + 1)
|
|
with self.assertRaises(ValueError):
|
|
result = format_string.format(2.34)
|
|
|
|
def test_format_auto_numbering(self):
|
|
class C:
|
|
def __init__(self, x=100):
|
|
self._x = x
|
|
def __format__(self, spec):
|
|
return spec
|
|
|
|
self.assertEqual('{}'.format(10), '10')
|
|
self.assertEqual('{:5}'.format('s'), 's ')
|
|
self.assertEqual('{!r}'.format('s'), "'s'")
|
|
self.assertEqual('{._x}'.format(C(10)), '10')
|
|
self.assertEqual('{[1]}'.format([1, 2]), '2')
|
|
self.assertEqual('{[a]}'.format({'a':4, 'b':2}), '4')
|
|
self.assertEqual('a{}b{}c'.format(0, 1), 'a0b1c')
|
|
|
|
self.assertEqual('a{:{}}b'.format('x', '^10'), 'a x b')
|
|
self.assertEqual('a{:{}x}b'.format(20, '#'), 'a0x14b')
|
|
|
|
# can't mix and match numbering and auto-numbering
|
|
self.assertRaises(ValueError, '{}{1}'.format, 1, 2)
|
|
self.assertRaises(ValueError, '{1}{}'.format, 1, 2)
|
|
self.assertRaises(ValueError, '{:{1}}'.format, 1, 2)
|
|
self.assertRaises(ValueError, '{0:{}}'.format, 1, 2)
|
|
|
|
# can mix and match auto-numbering and named
|
|
self.assertEqual('{f}{}'.format(4, f='test'), 'test4')
|
|
self.assertEqual('{}{f}'.format(4, f='test'), '4test')
|
|
self.assertEqual('{:{f}}{g}{}'.format(1, 3, g='g', f=2), ' 1g3')
|
|
self.assertEqual('{f:{}}{}{g}'.format(2, 4, f=1, g='g'), ' 14g')
|
|
|
|
def test_format_c_overflow(self):
|
|
# issue #7267
|
|
self.assertRaises(OverflowError, '{0:c}'.format, -1)
|
|
self.assertRaises(OverflowError, '{0:c}'.format, 256)
|
|
|
|
def test_buffer_is_readonly(self):
|
|
self.assertRaises(TypeError, sys.stdin.readinto, b"")
|
|
|
|
def test_encode_and_decode_kwargs(self):
|
|
self.assertEqual('abcde'.encode('ascii', 'replace'),
|
|
'abcde'.encode('ascii', errors='replace'))
|
|
self.assertEqual('abcde'.encode('ascii', 'ignore'),
|
|
'abcde'.encode(encoding='ascii', errors='ignore'))
|
|
self.assertEqual('Andr\202 x'.decode('ascii', 'ignore'),
|
|
'Andr\202 x'.decode('ascii', errors='ignore'))
|
|
self.assertEqual('Andr\202 x'.decode('ascii', 'replace'),
|
|
'Andr\202 x'.decode(encoding='ascii', errors='replace'))
|
|
|
|
def test_startswith_endswith_errors(self):
|
|
with self.assertRaises(UnicodeDecodeError):
|
|
'\xff'.startswith(u'x')
|
|
with self.assertRaises(UnicodeDecodeError):
|
|
'\xff'.endswith(u'x')
|
|
for meth in ('foo'.startswith, 'foo'.endswith):
|
|
with self.assertRaises(TypeError) as cm:
|
|
meth(['f'])
|
|
exc = str(cm.exception)
|
|
self.assertIn('unicode', exc)
|
|
self.assertIn('str', exc)
|
|
self.assertIn('tuple', exc)
|
|
|
|
def test_issue28598_strsubclass_rhs(self):
|
|
# A subclass of str with an __rmod__ method should be able to hook
|
|
# into the % operator
|
|
class SubclassedStr(str):
|
|
def __rmod__(self, other):
|
|
return 'Success, self.__rmod__({!r}) was called'.format(other)
|
|
self.assertEqual('lhs %% %r' % SubclassedStr('rhs'),
|
|
"Success, self.__rmod__('lhs %% %r') was called")
|
|
|
|
|
|
class CAPITest(unittest.TestCase):
|
|
|
|
# Test PyString_FromFormat()
|
|
def test_from_format(self):
|
|
ctypes = test_support.import_module('ctypes')
|
|
_testcapi = test_support.import_module('_testcapi')
|
|
from ctypes import pythonapi, py_object
|
|
from ctypes import (
|
|
c_int, c_uint,
|
|
c_long, c_ulong,
|
|
c_size_t, c_ssize_t,
|
|
c_char_p)
|
|
|
|
PyString_FromFormat = pythonapi.PyString_FromFormat
|
|
PyString_FromFormat.restype = py_object
|
|
|
|
# basic tests
|
|
self.assertEqual(PyString_FromFormat(b'format'),
|
|
b'format')
|
|
self.assertEqual(PyString_FromFormat(b'Hello %s !', b'world'),
|
|
b'Hello world !')
|
|
|
|
# test formatters
|
|
self.assertEqual(PyString_FromFormat(b'c=%c', c_int(0)),
|
|
b'c=\0')
|
|
self.assertEqual(PyString_FromFormat(b'c=%c', c_int(ord('@'))),
|
|
b'c=@')
|
|
self.assertEqual(PyString_FromFormat(b'c=%c', c_int(255)),
|
|
b'c=\xff')
|
|
self.assertEqual(PyString_FromFormat(b'd=%d ld=%ld zd=%zd',
|
|
c_int(1), c_long(2),
|
|
c_size_t(3)),
|
|
b'd=1 ld=2 zd=3')
|
|
self.assertEqual(PyString_FromFormat(b'd=%d ld=%ld zd=%zd',
|
|
c_int(-1), c_long(-2),
|
|
c_size_t(-3)),
|
|
b'd=-1 ld=-2 zd=-3')
|
|
self.assertEqual(PyString_FromFormat(b'u=%u lu=%lu zu=%zu',
|
|
c_uint(123), c_ulong(456),
|
|
c_size_t(789)),
|
|
b'u=123 lu=456 zu=789')
|
|
self.assertEqual(PyString_FromFormat(b'i=%i', c_int(123)),
|
|
b'i=123')
|
|
self.assertEqual(PyString_FromFormat(b'i=%i', c_int(-123)),
|
|
b'i=-123')
|
|
self.assertEqual(PyString_FromFormat(b'x=%x', c_int(0xabc)),
|
|
b'x=abc')
|
|
|
|
self.assertEqual(PyString_FromFormat(b's=%s', c_char_p(b'cstr')),
|
|
b's=cstr')
|
|
|
|
# test minimum and maximum integer values
|
|
size_max = c_size_t(-1).value
|
|
for formatstr, ctypes_type, value, py_formatter in (
|
|
(b'%d', c_int, _testcapi.INT_MIN, str),
|
|
(b'%d', c_int, _testcapi.INT_MAX, str),
|
|
(b'%ld', c_long, _testcapi.LONG_MIN, str),
|
|
(b'%ld', c_long, _testcapi.LONG_MAX, str),
|
|
(b'%lu', c_ulong, _testcapi.ULONG_MAX, str),
|
|
(b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MIN, str),
|
|
(b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MAX, str),
|
|
(b'%zu', c_size_t, size_max, str),
|
|
):
|
|
self.assertEqual(PyString_FromFormat(formatstr, ctypes_type(value)),
|
|
py_formatter(value).encode('ascii')),
|
|
|
|
# width and precision (width is currently ignored)
|
|
self.assertEqual(PyString_FromFormat(b'%5s', b'a'),
|
|
b'a')
|
|
self.assertEqual(PyString_FromFormat(b'%.3s', b'abcdef'),
|
|
b'abc')
|
|
|
|
# '%%' formatter
|
|
self.assertEqual(PyString_FromFormat(b'%%'),
|
|
b'%')
|
|
self.assertEqual(PyString_FromFormat(b'[%%]'),
|
|
b'[%]')
|
|
self.assertEqual(PyString_FromFormat(b'%%%c', c_int(ord('_'))),
|
|
b'%_')
|
|
self.assertEqual(PyString_FromFormat(b'%%s'),
|
|
b'%s')
|
|
|
|
# Invalid formats and partial formatting
|
|
self.assertEqual(PyString_FromFormat(b'%'), b'%')
|
|
self.assertEqual(PyString_FromFormat(b'x=%i y=%', c_int(2), c_int(3)),
|
|
b'x=2 y=%')
|
|
|
|
self.assertEqual(PyString_FromFormat(b'%c', c_int(-1)), b'\xff')
|
|
self.assertEqual(PyString_FromFormat(b'%c', c_int(256)), b'\0')
|
|
|
|
# Issue #33817: empty strings
|
|
self.assertEqual(PyString_FromFormat(b''),
|
|
b'')
|
|
self.assertEqual(PyString_FromFormat(b'%s', b''),
|
|
b'')
|
|
|
|
|
|
def test_main():
|
|
test_support.run_unittest(StrTest, CAPITest)
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|