summaryrefslogtreecommitdiff
path: root/lib/python2.7/test/test_str.py
diff options
context:
space:
mode:
Diffstat (limited to 'lib/python2.7/test/test_str.py')
-rw-r--r--lib/python2.7/test/test_str.py461
1 files changed, 461 insertions, 0 deletions
diff --git a/lib/python2.7/test/test_str.py b/lib/python2.7/test/test_str.py
new file mode 100644
index 0000000..eb704ea
--- /dev/null
+++ b/lib/python2.7/test/test_str.py
@@ -0,0 +1,461 @@
+
+import struct
+import sys
+from test import test_support, string_tests
+
+
+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.assertEqual(str(Foo9("foo")), "string")
+ self.assertEqual(unicode(Foo9("foo")), u"not unicode")
+
+ def test_expandtabs_overflows_gracefully(self):
+ # 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.
+ if sys.maxint > (1 << 32) or struct.calcsize('P') != 4:
+ return
+ 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_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_main():
+ test_support.run_unittest(StrTest)
+
+if __name__ == "__main__":
+ test_main()
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-05 07:26:46 +0000