diff options
Diffstat (limited to 'Lib/test/test_format.py')
| -rw-r--r-- | Lib/test/test_format.py | 658 |
1 files changed, 271 insertions, 387 deletions
diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py index 4559cd5..78eccec 100644 --- a/Lib/test/test_format.py +++ b/Lib/test/test_format.py @@ -1,34 +1,33 @@ -from test.support import verbose, TestFailed -import locale import sys -import test.support as support +from test.test_support import verbose, have_unicode, TestFailed +import test.test_support as test_support import unittest -maxsize = support.MAX_Py_ssize_t +maxsize = test_support.MAX_Py_ssize_t # test string formatting operator (I am not sure if this is being tested # elsewhere but, surely, some of the given cases are *not* tested because # they crash python) -# test on bytes object as well +# test on unicode strings as well def testformat(formatstr, args, output=None, limit=None, overflowok=False): if verbose: if output: - print("{!a} % {!a} =? {!a} ...".format(formatstr, args, output), - end=' ') + print "%s %% %s =? %s ..." %\ + (repr(formatstr), repr(args), repr(output)), else: - print("{!a} % {!a} works? ...".format(formatstr, args), end=' ') + print "%s %% %s works? ..." % (repr(formatstr), repr(args)), try: result = formatstr % args except OverflowError: if not overflowok: raise if verbose: - print('overflow (this is fine)') + print 'overflow (this is fine)' else: if output and limit is None and result != output: if verbose: - print('no') + print 'no' raise AssertionError("%r %% %r == %r != %r" % (formatstr, args, result, output)) # when 'limit' is specified, it determines how many characters @@ -39,272 +38,258 @@ def testformat(formatstr, args, output=None, limit=None, overflowok=False): elif output and limit is not None and ( len(result)!=len(output) or result[:limit]!=output[:limit]): if verbose: - print('no') - print("%s %% %s == %s != %s" % \ - (repr(formatstr), repr(args), repr(result), repr(output))) + print 'no' + print "%s %% %s == %s != %s" % \ + (repr(formatstr), repr(args), repr(result), repr(output)) else: if verbose: - print('yes') - -def testcommon(formatstr, args, output=None, limit=None, overflowok=False): - # if formatstr is a str, test str, bytes, and bytearray; - # otherwise, test bytes and bytearray - if isinstance(formatstr, str): - testformat(formatstr, args, output, limit, overflowok) - b_format = formatstr.encode('ascii') - else: - b_format = formatstr - ba_format = bytearray(b_format) - b_args = [] - if not isinstance(args, tuple): - args = (args, ) - b_args = tuple(args) - if output is None: - b_output = ba_output = None - else: - if isinstance(output, str): - b_output = output.encode('ascii') - else: - b_output = output - ba_output = bytearray(b_output) - testformat(b_format, b_args, b_output, limit, overflowok) - testformat(ba_format, b_args, ba_output, limit, overflowok) + print 'yes' -def test_exc(formatstr, args, exception, excmsg): - try: - testformat(formatstr, args) - except exception as exc: - if str(exc) == excmsg: - if verbose: - print("yes") - else: - if verbose: print('no') - print('Unexpected ', exception, ':', repr(str(exc))) - except: - if verbose: print('no') - print('Unexpected exception') - raise - else: - raise TestFailed('did not get expected exception: %s' % excmsg) -def test_exc_common(formatstr, args, exception, excmsg): - # test str and bytes - test_exc(formatstr, args, exception, excmsg) - test_exc(formatstr.encode('ascii'), args, exception, excmsg) +def testboth(formatstr, *args, **kwargs): + testformat(formatstr, *args, **kwargs) + if have_unicode: + testformat(unicode(formatstr), *args, **kwargs) -class FormatTest(unittest.TestCase): - def test_common_format(self): - # test the format identifiers that work the same across - # str, bytes, and bytearrays (integer, float, oct, hex) - testcommon("%%", (), "%") - testcommon("%.1d", (1,), "1") - testcommon("%.*d", (sys.maxsize,1), overflowok=True) # expect overflow - testcommon("%.100d", (1,), '00000000000000000000000000000000000000' +class FormatTest(unittest.TestCase): + def test_format(self): + testboth("%.1d", (1,), "1") + testboth("%.*d", (sys.maxint,1), overflowok=True) # expect overflow + testboth("%.100d", (1,), '00000000000000000000000000000000000000' '000000000000000000000000000000000000000000000000000000' '00000001', overflowok=True) - testcommon("%#.117x", (1,), '0x00000000000000000000000000000000000' + testboth("%#.117x", (1,), '0x00000000000000000000000000000000000' '000000000000000000000000000000000000000000000000000000' '0000000000000000000000000001', overflowok=True) - testcommon("%#.118x", (1,), '0x00000000000000000000000000000000000' + testboth("%#.118x", (1,), '0x00000000000000000000000000000000000' '000000000000000000000000000000000000000000000000000000' '00000000000000000000000000001', overflowok=True) - testcommon("%f", (1.0,), "1.000000") + testboth("%f", (1.0,), "1.000000") # these are trying to test the limits of the internal magic-number-length # formatting buffer, if that number changes then these tests are less # effective - testcommon("%#.*g", (109, -1.e+49/3.)) - testcommon("%#.*g", (110, -1.e+49/3.)) - testcommon("%#.*g", (110, -1.e+100/3.)) + testboth("%#.*g", (109, -1.e+49/3.)) + testboth("%#.*g", (110, -1.e+49/3.)) + testboth("%#.*g", (110, -1.e+100/3.)) + # test some ridiculously large precision, expect overflow - testcommon('%12.*f', (123456, 1.0)) + testboth('%12.*f', (123456, 1.0)) # check for internal overflow validation on length of precision # these tests should no longer cause overflow in Python # 2.7/3.1 and later. - testcommon("%#.*g", (110, -1.e+100/3.)) - testcommon("%#.*G", (110, -1.e+100/3.)) - testcommon("%#.*f", (110, -1.e+100/3.)) - testcommon("%#.*F", (110, -1.e+100/3.)) - # Formatting of integers. Overflow is not ok - testcommon("%x", 10, "a") - testcommon("%x", 100000000000, "174876e800") - testcommon("%o", 10, "12") - testcommon("%o", 100000000000, "1351035564000") - testcommon("%d", 10, "10") - testcommon("%d", 100000000000, "100000000000") - - big = 123456789012345678901234567890 - testcommon("%d", big, "123456789012345678901234567890") - testcommon("%d", -big, "-123456789012345678901234567890") - testcommon("%5d", -big, "-123456789012345678901234567890") - testcommon("%31d", -big, "-123456789012345678901234567890") - testcommon("%32d", -big, " -123456789012345678901234567890") - testcommon("%-32d", -big, "-123456789012345678901234567890 ") - testcommon("%032d", -big, "-0123456789012345678901234567890") - testcommon("%-032d", -big, "-123456789012345678901234567890 ") - testcommon("%034d", -big, "-000123456789012345678901234567890") - testcommon("%034d", big, "0000123456789012345678901234567890") - testcommon("%0+34d", big, "+000123456789012345678901234567890") - testcommon("%+34d", big, " +123456789012345678901234567890") - testcommon("%34d", big, " 123456789012345678901234567890") - testcommon("%.2d", big, "123456789012345678901234567890") - testcommon("%.30d", big, "123456789012345678901234567890") - testcommon("%.31d", big, "0123456789012345678901234567890") - testcommon("%32.31d", big, " 0123456789012345678901234567890") - testcommon("%d", float(big), "123456________________________", 6) - - big = 0x1234567890abcdef12345 # 21 hex digits - testcommon("%x", big, "1234567890abcdef12345") - testcommon("%x", -big, "-1234567890abcdef12345") - testcommon("%5x", -big, "-1234567890abcdef12345") - testcommon("%22x", -big, "-1234567890abcdef12345") - testcommon("%23x", -big, " -1234567890abcdef12345") - testcommon("%-23x", -big, "-1234567890abcdef12345 ") - testcommon("%023x", -big, "-01234567890abcdef12345") - testcommon("%-023x", -big, "-1234567890abcdef12345 ") - testcommon("%025x", -big, "-0001234567890abcdef12345") - testcommon("%025x", big, "00001234567890abcdef12345") - testcommon("%0+25x", big, "+0001234567890abcdef12345") - testcommon("%+25x", big, " +1234567890abcdef12345") - testcommon("%25x", big, " 1234567890abcdef12345") - testcommon("%.2x", big, "1234567890abcdef12345") - testcommon("%.21x", big, "1234567890abcdef12345") - testcommon("%.22x", big, "01234567890abcdef12345") - testcommon("%23.22x", big, " 01234567890abcdef12345") - testcommon("%-23.22x", big, "01234567890abcdef12345 ") - testcommon("%X", big, "1234567890ABCDEF12345") - testcommon("%#X", big, "0X1234567890ABCDEF12345") - testcommon("%#x", big, "0x1234567890abcdef12345") - testcommon("%#x", -big, "-0x1234567890abcdef12345") - testcommon("%#27x", big, " 0x1234567890abcdef12345") - testcommon("%#-27x", big, "0x1234567890abcdef12345 ") - testcommon("%#027x", big, "0x00001234567890abcdef12345") - testcommon("%#.23x", big, "0x001234567890abcdef12345") - testcommon("%#.23x", -big, "-0x001234567890abcdef12345") - testcommon("%#27.23x", big, " 0x001234567890abcdef12345") - testcommon("%#-27.23x", big, "0x001234567890abcdef12345 ") - testcommon("%#027.23x", big, "0x00001234567890abcdef12345") - testcommon("%#+.23x", big, "+0x001234567890abcdef12345") - testcommon("%# .23x", big, " 0x001234567890abcdef12345") - testcommon("%#+.23X", big, "+0X001234567890ABCDEF12345") + testboth("%#.*g", (110, -1.e+100/3.)) + testboth("%#.*G", (110, -1.e+100/3.)) + testboth("%#.*f", (110, -1.e+100/3.)) + testboth("%#.*F", (110, -1.e+100/3.)) + + # Formatting of long integers. Overflow is not ok + testboth("%x", 10L, "a") + testboth("%x", 100000000000L, "174876e800") + testboth("%o", 10L, "12") + testboth("%o", 100000000000L, "1351035564000") + testboth("%d", 10L, "10") + testboth("%d", 100000000000L, "100000000000") + + big = 123456789012345678901234567890L + testboth("%d", big, "123456789012345678901234567890") + testboth("%d", -big, "-123456789012345678901234567890") + testboth("%5d", -big, "-123456789012345678901234567890") + testboth("%31d", -big, "-123456789012345678901234567890") + testboth("%32d", -big, " -123456789012345678901234567890") + testboth("%-32d", -big, "-123456789012345678901234567890 ") + testboth("%032d", -big, "-0123456789012345678901234567890") + testboth("%-032d", -big, "-123456789012345678901234567890 ") + testboth("%034d", -big, "-000123456789012345678901234567890") + testboth("%034d", big, "0000123456789012345678901234567890") + testboth("%0+34d", big, "+000123456789012345678901234567890") + testboth("%+34d", big, " +123456789012345678901234567890") + testboth("%34d", big, " 123456789012345678901234567890") + testboth("%.2d", big, "123456789012345678901234567890") + testboth("%.30d", big, "123456789012345678901234567890") + testboth("%.31d", big, "0123456789012345678901234567890") + testboth("%32.31d", big, " 0123456789012345678901234567890") + testboth("%d", float(big), "123456________________________", 6) + + big = 0x1234567890abcdef12345L # 21 hex digits + testboth("%x", big, "1234567890abcdef12345") + testboth("%x", -big, "-1234567890abcdef12345") + testboth("%5x", -big, "-1234567890abcdef12345") + testboth("%22x", -big, "-1234567890abcdef12345") + testboth("%23x", -big, " -1234567890abcdef12345") + testboth("%-23x", -big, "-1234567890abcdef12345 ") + testboth("%023x", -big, "-01234567890abcdef12345") + testboth("%-023x", -big, "-1234567890abcdef12345 ") + testboth("%025x", -big, "-0001234567890abcdef12345") + testboth("%025x", big, "00001234567890abcdef12345") + testboth("%0+25x", big, "+0001234567890abcdef12345") + testboth("%+25x", big, " +1234567890abcdef12345") + testboth("%25x", big, " 1234567890abcdef12345") + testboth("%.2x", big, "1234567890abcdef12345") + testboth("%.21x", big, "1234567890abcdef12345") + testboth("%.22x", big, "01234567890abcdef12345") + testboth("%23.22x", big, " 01234567890abcdef12345") + testboth("%-23.22x", big, "01234567890abcdef12345 ") + testboth("%X", big, "1234567890ABCDEF12345") + testboth("%#X", big, "0X1234567890ABCDEF12345") + testboth("%#x", big, "0x1234567890abcdef12345") + testboth("%#x", -big, "-0x1234567890abcdef12345") + testboth("%#.23x", -big, "-0x001234567890abcdef12345") + testboth("%#+.23x", big, "+0x001234567890abcdef12345") + testboth("%# .23x", big, " 0x001234567890abcdef12345") + testboth("%#+.23X", big, "+0X001234567890ABCDEF12345") + testboth("%#-+.23X", big, "+0X001234567890ABCDEF12345") + testboth("%#-+26.23X", big, "+0X001234567890ABCDEF12345") + testboth("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ") + testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345") # next one gets two leading zeroes from precision, and another from the # 0 flag and the width - testcommon("%#+027.23X", big, "+0X0001234567890ABCDEF12345") - testcommon("%# 027.23X", big, " 0X0001234567890ABCDEF12345") + testboth("%#+027.23X", big, "+0X0001234567890ABCDEF12345") # same, except no 0 flag - testcommon("%#+27.23X", big, " +0X001234567890ABCDEF12345") - testcommon("%#-+27.23x", big, "+0x001234567890abcdef12345 ") - testcommon("%#- 27.23x", big, " 0x001234567890abcdef12345 ") - - big = 0o12345670123456701234567012345670 # 32 octal digits - testcommon("%o", big, "12345670123456701234567012345670") - testcommon("%o", -big, "-12345670123456701234567012345670") - testcommon("%5o", -big, "-12345670123456701234567012345670") - testcommon("%33o", -big, "-12345670123456701234567012345670") - testcommon("%34o", -big, " -12345670123456701234567012345670") - testcommon("%-34o", -big, "-12345670123456701234567012345670 ") - testcommon("%034o", -big, "-012345670123456701234567012345670") - testcommon("%-034o", -big, "-12345670123456701234567012345670 ") - testcommon("%036o", -big, "-00012345670123456701234567012345670") - testcommon("%036o", big, "000012345670123456701234567012345670") - testcommon("%0+36o", big, "+00012345670123456701234567012345670") - testcommon("%+36o", big, " +12345670123456701234567012345670") - testcommon("%36o", big, " 12345670123456701234567012345670") - testcommon("%.2o", big, "12345670123456701234567012345670") - testcommon("%.32o", big, "12345670123456701234567012345670") - testcommon("%.33o", big, "012345670123456701234567012345670") - testcommon("%34.33o", big, " 012345670123456701234567012345670") - testcommon("%-34.33o", big, "012345670123456701234567012345670 ") - testcommon("%o", big, "12345670123456701234567012345670") - testcommon("%#o", big, "0o12345670123456701234567012345670") - testcommon("%#o", -big, "-0o12345670123456701234567012345670") - testcommon("%#38o", big, " 0o12345670123456701234567012345670") - testcommon("%#-38o", big, "0o12345670123456701234567012345670 ") - testcommon("%#038o", big, "0o000012345670123456701234567012345670") - testcommon("%#.34o", big, "0o0012345670123456701234567012345670") - testcommon("%#.34o", -big, "-0o0012345670123456701234567012345670") - testcommon("%#38.34o", big, " 0o0012345670123456701234567012345670") - testcommon("%#-38.34o", big, "0o0012345670123456701234567012345670 ") - testcommon("%#038.34o", big, "0o000012345670123456701234567012345670") - testcommon("%#+.34o", big, "+0o0012345670123456701234567012345670") - testcommon("%# .34o", big, " 0o0012345670123456701234567012345670") - testcommon("%#+38.34o", big, " +0o0012345670123456701234567012345670") - testcommon("%#-+38.34o", big, "+0o0012345670123456701234567012345670 ") - testcommon("%#- 38.34o", big, " 0o0012345670123456701234567012345670 ") - testcommon("%#+038.34o", big, "+0o00012345670123456701234567012345670") - testcommon("%# 038.34o", big, " 0o00012345670123456701234567012345670") + testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345") + testboth("%x", float(big), "123456_______________", 6) + + big = 012345670123456701234567012345670L # 32 octal digits + testboth("%o", big, "12345670123456701234567012345670") + testboth("%o", -big, "-12345670123456701234567012345670") + testboth("%5o", -big, "-12345670123456701234567012345670") + testboth("%33o", -big, "-12345670123456701234567012345670") + testboth("%34o", -big, " -12345670123456701234567012345670") + testboth("%-34o", -big, "-12345670123456701234567012345670 ") + testboth("%034o", -big, "-012345670123456701234567012345670") + testboth("%-034o", -big, "-12345670123456701234567012345670 ") + testboth("%036o", -big, "-00012345670123456701234567012345670") + testboth("%036o", big, "000012345670123456701234567012345670") + testboth("%0+36o", big, "+00012345670123456701234567012345670") + testboth("%+36o", big, " +12345670123456701234567012345670") + testboth("%36o", big, " 12345670123456701234567012345670") + testboth("%.2o", big, "12345670123456701234567012345670") + testboth("%.32o", big, "12345670123456701234567012345670") + testboth("%.33o", big, "012345670123456701234567012345670") + testboth("%34.33o", big, " 012345670123456701234567012345670") + testboth("%-34.33o", big, "012345670123456701234567012345670 ") + testboth("%o", big, "12345670123456701234567012345670") + testboth("%#o", big, "012345670123456701234567012345670") + testboth("%#o", -big, "-012345670123456701234567012345670") + testboth("%#.34o", -big, "-0012345670123456701234567012345670") + testboth("%#+.34o", big, "+0012345670123456701234567012345670") + testboth("%# .34o", big, " 0012345670123456701234567012345670") + testboth("%#+.34o", big, "+0012345670123456701234567012345670") + testboth("%#-+.34o", big, "+0012345670123456701234567012345670") + testboth("%#-+37.34o", big, "+0012345670123456701234567012345670 ") + testboth("%#+37.34o", big, " +0012345670123456701234567012345670") # next one gets one leading zero from precision - testcommon("%.33o", big, "012345670123456701234567012345670") - # base marker added in spite of leading zero (different to Python 2) - testcommon("%#.33o", big, "0o012345670123456701234567012345670") - # reduce precision, and base marker is always added - testcommon("%#.32o", big, "0o12345670123456701234567012345670") - # one leading zero from precision, plus two from "0" flag & width - testcommon("%035.33o", big, "00012345670123456701234567012345670") - # base marker shouldn't change the size - testcommon("%0#35.33o", big, "0o012345670123456701234567012345670") - - # Some small ints, in both Python int and flavors). - testcommon("%d", 42, "42") - testcommon("%d", -42, "-42") - testcommon("%d", 42.0, "42") - testcommon("%#x", 1, "0x1") - testcommon("%#X", 1, "0X1") - testcommon("%#o", 1, "0o1") - testcommon("%#o", 0, "0o0") - testcommon("%o", 0, "0") - testcommon("%d", 0, "0") - testcommon("%#x", 0, "0x0") - testcommon("%#X", 0, "0X0") - testcommon("%x", 0x42, "42") - testcommon("%x", -0x42, "-42") - testcommon("%o", 0o42, "42") - testcommon("%o", -0o42, "-42") + testboth("%.33o", big, "012345670123456701234567012345670") + # base marker shouldn't change that, since "0" is redundant + testboth("%#.33o", big, "012345670123456701234567012345670") + # but reduce precision, and base marker should add a zero + testboth("%#.32o", big, "012345670123456701234567012345670") + # one leading zero from precision, and another from "0" flag & width + testboth("%034.33o", big, "0012345670123456701234567012345670") + # base marker shouldn't change that + testboth("%0#34.33o", big, "0012345670123456701234567012345670") + testboth("%o", float(big), "123456__________________________", 6) + + # Some small ints, in both Python int and long flavors). + testboth("%d", 42, "42") + testboth("%d", -42, "-42") + testboth("%d", 42L, "42") + testboth("%d", -42L, "-42") + testboth("%d", 42.0, "42") + testboth("%#x", 1, "0x1") + testboth("%#x", 1L, "0x1") + testboth("%#X", 1, "0X1") + testboth("%#X", 1L, "0X1") + testboth("%#x", 1.0, "0x1") + testboth("%#o", 1, "01") + testboth("%#o", 1L, "01") + testboth("%#o", 0, "0") + testboth("%#o", 0L, "0") + testboth("%o", 0, "0") + testboth("%o", 0L, "0") + testboth("%d", 0, "0") + testboth("%d", 0L, "0") + testboth("%#x", 0, "0x0") + testboth("%#x", 0L, "0x0") + testboth("%#X", 0, "0X0") + testboth("%#X", 0L, "0X0") + + testboth("%x", 0x42, "42") + testboth("%x", -0x42, "-42") + testboth("%x", 0x42L, "42") + testboth("%x", -0x42L, "-42") + testboth("%x", float(0x42), "42") + + testboth("%o", 042, "42") + testboth("%o", -042, "-42") + testboth("%o", 042L, "42") + testboth("%o", -042L, "-42") + testboth("%o", float(042), "42") + # alternate float formatting - testcommon('%g', 1.1, '1.1') - testcommon('%#g', 1.1, '1.10000') + testformat('%g', 1.1, '1.1') + testformat('%#g', 1.1, '1.10000') + # Regression test for http://bugs.python.org/issue15516. + class IntFails(object): + def __int__(self): + raise TestFailed + def __long__(self): + return 0 + + fst = IntFails() + testformat("%x", fst, '0') + testformat(u"%x", fst, '0') + + # Test exception for unknown format characters if verbose: - print('Testing exceptions') - test_exc_common('%', (), ValueError, "incomplete format") - test_exc_common('% %s', 1, ValueError, - "unsupported format character '%' (0x25) at index 2") - test_exc_common('%d', '1', TypeError, - "%d format: a number is required, not str") - test_exc_common('%d', b'1', TypeError, - "%d format: a number is required, not bytes") - test_exc_common('%x', '1', TypeError, - "%x format: an integer is required, not str") - test_exc_common('%x', 3.14, TypeError, - "%x format: an integer is required, not float") - - def test_str_format(self): - testformat("%r", "\u0378", "'\\u0378'") # non printable - testformat("%a", "\u0378", "'\\u0378'") # non printable - testformat("%r", "\u0374", "'\u0374'") # printable - testformat("%a", "\u0374", "'\\u0374'") # printable - - # Test exception for unknown format characters, etc. - if verbose: - print('Testing exceptions') - test_exc('abc %b', 1, ValueError, - "unsupported format character 'b' (0x62) at index 5") - #test_exc(unicode('abc %\u3000','raw-unicode-escape'), 1, ValueError, - # "unsupported format character '?' (0x3000) at index 5") - test_exc('%g', '1', TypeError, "must be real number, not str") + print 'Testing exceptions' + + def test_exc(formatstr, args, exception, excmsg): + try: + testformat(formatstr, args) + except exception, exc: + if str(exc) == excmsg: + if verbose: + print "yes" + else: + if verbose: print 'no' + print 'Unexpected ', exception, ':', repr(str(exc)) + except: + if verbose: print 'no' + print 'Unexpected exception' + raise + else: + raise TestFailed, 'did not get expected exception: %s' % excmsg + + test_exc('abc %a', 1, ValueError, + "unsupported format character 'a' (0x61) at index 5") + if have_unicode: + test_exc(unicode('abc %\u3000','raw-unicode-escape'), 1, ValueError, + "unsupported format character '?' (0x3000) at index 5") + + test_exc('%d', '1', TypeError, "%d format: a number is required, not str") + test_exc('%g', '1', TypeError, "float argument required, not str") test_exc('no format', '1', TypeError, "not all arguments converted during string formatting") - test_exc('%c', -1, OverflowError, "%c arg not in range(0x110000)") - test_exc('%c', sys.maxunicode+1, OverflowError, - "%c arg not in range(0x110000)") - #test_exc('%c', 2**128, OverflowError, "%c arg not in range(0x110000)") - test_exc('%c', 3.14, TypeError, "%c requires int or char") - test_exc('%c', 'ab', TypeError, "%c requires int or char") - test_exc('%c', b'x', TypeError, "%c requires int or char") + test_exc('no format', u'1', TypeError, + "not all arguments converted during string formatting") + test_exc(u'no format', '1', TypeError, + "not all arguments converted during string formatting") + test_exc(u'no format', u'1', TypeError, + "not all arguments converted during string formatting") + + class Foobar(long): + def __oct__(self): + # Returning a non-string should not blow up. + return self + 1 + + test_exc('%o', Foobar(), TypeError, + "expected string or Unicode object, long found") if maxsize == 2**31-1: # crashes 2.2.1 and earlier: @@ -313,151 +298,48 @@ class FormatTest(unittest.TestCase): except MemoryError: pass else: - raise TestFailed('"%*d"%(maxsize, -127) should fail') - - def test_bytes_and_bytearray_format(self): - # %c will insert a single byte, either from an int in range(256), or - # from a bytes argument of length 1, not from a str. - testcommon(b"%c", 7, b"\x07") - testcommon(b"%c", b"Z", b"Z") - testcommon(b"%c", bytearray(b"Z"), b"Z") - testcommon(b"%5c", 65, b" A") - testcommon(b"%-5c", 65, b"A ") - # %b will insert a series of bytes, either from a type that supports - # the Py_buffer protocol, or something that has a __bytes__ method - class FakeBytes(object): - def __bytes__(self): - return b'123' - fb = FakeBytes() - testcommon(b"%b", b"abc", b"abc") - testcommon(b"%b", bytearray(b"def"), b"def") - testcommon(b"%b", fb, b"123") - testcommon(b"%b", memoryview(b"abc"), b"abc") - # # %s is an alias for %b -- should only be used for Py2/3 code - testcommon(b"%s", b"abc", b"abc") - testcommon(b"%s", bytearray(b"def"), b"def") - testcommon(b"%s", fb, b"123") - testcommon(b"%s", memoryview(b"abc"), b"abc") - # %a will give the equivalent of - # repr(some_obj).encode('ascii', 'backslashreplace') - testcommon(b"%a", 3.14, b"3.14") - testcommon(b"%a", b"ghi", b"b'ghi'") - testcommon(b"%a", "jkl", b"'jkl'") - testcommon(b"%a", "\u0544", b"'\\u0544'") - # %r is an alias for %a - testcommon(b"%r", 3.14, b"3.14") - testcommon(b"%r", b"ghi", b"b'ghi'") - testcommon(b"%r", "jkl", b"'jkl'") - testcommon(b"%r", "\u0544", b"'\\u0544'") - - # Test exception for unknown format characters, etc. - if verbose: - print('Testing exceptions') - test_exc(b'%g', '1', TypeError, "float argument required, not str") - test_exc(b'%g', b'1', TypeError, "float argument required, not bytes") - test_exc(b'no format', 7, TypeError, - "not all arguments converted during bytes formatting") - test_exc(b'no format', b'1', TypeError, - "not all arguments converted during bytes formatting") - test_exc(b'no format', bytearray(b'1'), TypeError, - "not all arguments converted during bytes formatting") - test_exc(b"%c", -1, OverflowError, - "%c arg not in range(256)") - test_exc(b"%c", 256, OverflowError, - "%c arg not in range(256)") - test_exc(b"%c", 2**128, OverflowError, - "%c arg not in range(256)") - test_exc(b"%c", b"Za", TypeError, - "%c requires an integer in range(256) or a single byte") - test_exc(b"%c", "Y", TypeError, - "%c requires an integer in range(256) or a single byte") - test_exc(b"%c", 3.14, TypeError, - "%c requires an integer in range(256) or a single byte") - test_exc(b"%b", "Xc", TypeError, - "%b requires a bytes-like object, " - "or an object that implements __bytes__, not 'str'") - test_exc(b"%s", "Wd", TypeError, - "%b requires a bytes-like object, " - "or an object that implements __bytes__, not 'str'") - - if maxsize == 2**31-1: - # crashes 2.2.1 and earlier: + raise TestFailed, '"%*d"%(maxsize, -127) should fail' + + def test_invalid_special_methods(self): + tests = [] + for f in 'sriduoxXfge': + tests.append(('%' + f, 1, TypeError)) + tests.append(('%#' + f, 1, TypeError)) + for r in ['', '-', 'L', '-L']: + for f in 'iduoxX': + tests.append(('%' + f, r, ValueError)) + tests.append(('%#' + f, r, ValueError)) + tests.append(('%o', 'abc', ValueError)) + for r in ('abc', '0abc', '0x', '0xL'): + for f in 'xX': + tests.append(('%' + f, r, ValueError)) + for r in ('0x', '0xL'): + for f in 'xX': + tests.append(('%#' + f, r, ValueError)) + + class X(long): + def __repr__(self): + return result + def __str__(self): + return result + def __oct__(self): + return result + def __hex__(self): + return result + def __float__(self): + return result + for fmt, result, exc in tests: try: - "%*d"%(maxsize, -127) - except MemoryError: + fmt % X() + except exc: pass else: - raise TestFailed('"%*d"%(maxsize, -127) should fail') - - def test_nul(self): - # test the null character - testcommon("a\0b", (), 'a\0b') - testcommon("a%cb", (0,), 'a\0b') - testformat("a%sb", ('c\0d',), 'ac\0db') - testcommon(b"a%sb", (b'c\0d',), b'ac\0db') - - def test_non_ascii(self): - testformat("\u20ac=%f", (1.0,), "\u20ac=1.000000") - - self.assertEqual(format("abc", "\u2007<5"), "abc\u2007\u2007") - self.assertEqual(format(123, "\u2007<5"), "123\u2007\u2007") - self.assertEqual(format(12.3, "\u2007<6"), "12.3\u2007\u2007") - self.assertEqual(format(0j, "\u2007<4"), "0j\u2007\u2007") - self.assertEqual(format(1+2j, "\u2007<8"), "(1+2j)\u2007\u2007") - - self.assertEqual(format("abc", "\u2007>5"), "\u2007\u2007abc") - self.assertEqual(format(123, "\u2007>5"), "\u2007\u2007123") - self.assertEqual(format(12.3, "\u2007>6"), "\u2007\u200712.3") - self.assertEqual(format(1+2j, "\u2007>8"), "\u2007\u2007(1+2j)") - self.assertEqual(format(0j, "\u2007>4"), "\u2007\u20070j") - - self.assertEqual(format("abc", "\u2007^5"), "\u2007abc\u2007") - self.assertEqual(format(123, "\u2007^5"), "\u2007123\u2007") - self.assertEqual(format(12.3, "\u2007^6"), "\u200712.3\u2007") - self.assertEqual(format(1+2j, "\u2007^8"), "\u2007(1+2j)\u2007") - self.assertEqual(format(0j, "\u2007^4"), "\u20070j\u2007") - - def test_locale(self): - try: - oldloc = locale.setlocale(locale.LC_ALL) - locale.setlocale(locale.LC_ALL, '') - except locale.Error as err: - self.skipTest("Cannot set locale: {}".format(err)) - try: - localeconv = locale.localeconv() - sep = localeconv['thousands_sep'] - point = localeconv['decimal_point'] - - text = format(123456789, "n") - self.assertIn(sep, text) - self.assertEqual(text.replace(sep, ''), '123456789') - - text = format(1234.5, "n") - self.assertIn(sep, text) - self.assertIn(point, text) - self.assertEqual(text.replace(sep, ''), '1234' + point + '5') - finally: - locale.setlocale(locale.LC_ALL, oldloc) - - @support.cpython_only - def test_optimisations(self): - text = "abcde" # 5 characters - - self.assertIs("%s" % text, text) - self.assertIs("%.5s" % text, text) - self.assertIs("%.10s" % text, text) - self.assertIs("%1s" % text, text) - self.assertIs("%5s" % text, text) - - self.assertIs("{0}".format(text), text) - self.assertIs("{0:s}".format(text), text) - self.assertIs("{0:.5s}".format(text), text) - self.assertIs("{0:.10s}".format(text), text) - self.assertIs("{0:1s}".format(text), text) - self.assertIs("{0:5s}".format(text), text) - - self.assertIs(text % (), text) - self.assertIs(text.format(), text) + self.fail('%s not raised for %r format of %r' % + (exc.__name__, fmt, result)) + + +def test_main(): + test_support.run_unittest(FormatTest) def test_precision(self): f = 1.2 @@ -465,14 +347,16 @@ class FormatTest(unittest.TestCase): self.assertEqual(format(f, ".3f"), "1.200") with self.assertRaises(ValueError) as cm: format(f, ".%sf" % (sys.maxsize + 1)) + self.assertEqual(str(cm.exception), "precision too big") c = complex(f) self.assertEqual(format(c, ".0f"), "1+0j") self.assertEqual(format(c, ".3f"), "1.200+0.000j") with self.assertRaises(ValueError) as cm: format(c, ".%sf" % (sys.maxsize + 1)) + self.assertEqual(str(cm.exception), "precision too big") - @support.cpython_only + @test_support.cpython_only def test_precision_c_limits(self): from _testcapi import INT_MAX |