Lib/test/test_format.py

   1 from test.test_support import verbose, have_unicode, TestFailed
   2 import sys
   3
   4 # test string formatting operator (I am not sure if this is being tested
   5 # elsewhere but, surely, some of the given cases are *not* tested because
   6 # they crash python)
   7 # test on unicode strings as well
   8
   9 overflowok = 1
  10
  11 def testformat(formatstr, args, output=None):
  12     if verbose:
  13         if output:
  14             print "%s %% %s =? %s ..." %\
  15                 (repr(formatstr), repr(args), repr(output)),
  16         else:
  17             print "%s %% %s works? ..." % (repr(formatstr), repr(args)),
  18     try:
  19         result = formatstr % args
  20     except OverflowError:
  21         if not overflowok:
  22             raise
  23         if verbose:
  24             print 'overflow (this is fine)'
  25     else:
  26         if output and result != output:
  27             if verbose:
  28                 print 'no'
  29             print "%s %% %s == %s != %s" %\
  30                 (repr(formatstr), repr(args), repr(result), repr(output))
  31         else:
  32             if verbose:
  33                 print 'yes'
  34
  35 def testboth(formatstr, *args):
  36     testformat(formatstr, *args)
  37     if have_unicode:
  38         testformat(unicode(formatstr), *args)
  39
  40
  41 testboth("%.1d", (1,), "1")
  42 testboth("%.*d", (sys.maxint,1))  # expect overflow
  43 testboth("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
  44 testboth("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
  45 testboth("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
  46
  47 testboth("%f", (1.0,), "1.000000")
  48 # these are trying to test the limits of the internal magic-number-length
  49 # formatting buffer, if that number changes then these tests are less
  50 # effective
  51 testboth("%#.*g", (109, -1.e+49/3.))
  52 testboth("%#.*g", (110, -1.e+49/3.))
  53 testboth("%#.*g", (110, -1.e+100/3.))
  54
  55 # test some ridiculously large precision, expect overflow
  56 testboth('%12.*f', (123456, 1.0))
  57
  58 # Formatting of long integers. Overflow is not ok
  59 overflowok = 0
  60 testboth("%x", 10L, "a")
  61 testboth("%x", 100000000000L, "174876e800")
  62 testboth("%o", 10L, "12")
  63 testboth("%o", 100000000000L, "1351035564000")
  64 testboth("%d", 10L, "10")
  65 testboth("%d", 100000000000L, "100000000000")
  66
  67 big = 123456789012345678901234567890L
  68 testboth("%d", big, "123456789012345678901234567890")
  69 testboth("%d", -big, "-123456789012345678901234567890")
  70 testboth("%5d", -big, "-123456789012345678901234567890")
  71 testboth("%31d", -big, "-123456789012345678901234567890")
  72 testboth("%32d", -big, " -123456789012345678901234567890")
  73 testboth("%-32d", -big, "-123456789012345678901234567890 ")
  74 testboth("%032d", -big, "-0123456789012345678901234567890")
  75 testboth("%-032d", -big, "-123456789012345678901234567890 ")
  76 testboth("%034d", -big, "-000123456789012345678901234567890")
  77 testboth("%034d", big, "0000123456789012345678901234567890")
  78 testboth("%0+34d", big, "+000123456789012345678901234567890")
  79 testboth("%+34d", big, "   +123456789012345678901234567890")
  80 testboth("%34d", big, "    123456789012345678901234567890")
  81 testboth("%.2d", big, "123456789012345678901234567890")
  82 testboth("%.30d", big, "123456789012345678901234567890")
  83 testboth("%.31d", big, "0123456789012345678901234567890")
  84 testboth("%32.31d", big, " 0123456789012345678901234567890")
  85
  86 big = 0x1234567890abcdef12345L  # 21 hex digits
  87 testboth("%x", big, "1234567890abcdef12345")
  88 testboth("%x", -big, "-1234567890abcdef12345")
  89 testboth("%5x", -big, "-1234567890abcdef12345")
  90 testboth("%22x", -big, "-1234567890abcdef12345")
  91 testboth("%23x", -big, " -1234567890abcdef12345")
  92 testboth("%-23x", -big, "-1234567890abcdef12345 ")
  93 testboth("%023x", -big, "-01234567890abcdef12345")
  94 testboth("%-023x", -big, "-1234567890abcdef12345 ")
  95 testboth("%025x", -big, "-0001234567890abcdef12345")
  96 testboth("%025x", big, "00001234567890abcdef12345")
  97 testboth("%0+25x", big, "+0001234567890abcdef12345")
  98 testboth("%+25x", big, "   +1234567890abcdef12345")
  99 testboth("%25x", big, "    1234567890abcdef12345")
 100 testboth("%.2x", big, "1234567890abcdef12345")
 101 testboth("%.21x", big, "1234567890abcdef12345")
 102 testboth("%.22x", big, "01234567890abcdef12345")
 103 testboth("%23.22x", big, " 01234567890abcdef12345")
 104 testboth("%-23.22x", big, "01234567890abcdef12345 ")
 105 testboth("%X", big, "1234567890ABCDEF12345")
 106 testboth("%#X", big, "0X1234567890ABCDEF12345")
 107 testboth("%#x", big, "0x1234567890abcdef12345")
 108 testboth("%#x", -big, "-0x1234567890abcdef12345")
 109 testboth("%#.23x", -big, "-0x001234567890abcdef12345")
 110 testboth("%#+.23x", big, "+0x001234567890abcdef12345")
 111 testboth("%# .23x", big, " 0x001234567890abcdef12345")
 112 testboth("%#+.23X", big, "+0X001234567890ABCDEF12345")
 113 testboth("%#-+.23X", big, "+0X001234567890ABCDEF12345")
 114 testboth("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
 115 testboth("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
 116 testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
 117 # next one gets two leading zeroes from precision, and another from the
 118 # 0 flag and the width
 119 testboth("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
 120 # same, except no 0 flag
 121 testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
 122
 123 big = 012345670123456701234567012345670L  # 32 octal digits
 124 testboth("%o", big, "12345670123456701234567012345670")
 125 testboth("%o", -big, "-12345670123456701234567012345670")
 126 testboth("%5o", -big, "-12345670123456701234567012345670")
 127 testboth("%33o", -big, "-12345670123456701234567012345670")
 128 testboth("%34o", -big, " -12345670123456701234567012345670")
 129 testboth("%-34o", -big, "-12345670123456701234567012345670 ")
 130 testboth("%034o", -big, "-012345670123456701234567012345670")
 131 testboth("%-034o", -big, "-12345670123456701234567012345670 ")
 132 testboth("%036o", -big, "-00012345670123456701234567012345670")
 133 testboth("%036o", big, "000012345670123456701234567012345670")
 134 testboth("%0+36o", big, "+00012345670123456701234567012345670")
 135 testboth("%+36o", big, "   +12345670123456701234567012345670")
 136 testboth("%36o", big, "    12345670123456701234567012345670")
 137 testboth("%.2o", big, "12345670123456701234567012345670")
 138 testboth("%.32o", big, "12345670123456701234567012345670")
 139 testboth("%.33o", big, "012345670123456701234567012345670")
 140 testboth("%34.33o", big, " 012345670123456701234567012345670")
 141 testboth("%-34.33o", big, "012345670123456701234567012345670 ")
 142 testboth("%o", big, "12345670123456701234567012345670")
 143 testboth("%#o", big, "012345670123456701234567012345670")
 144 testboth("%#o", -big, "-012345670123456701234567012345670")
 145 testboth("%#.34o", -big, "-0012345670123456701234567012345670")
 146 testboth("%#+.34o", big, "+0012345670123456701234567012345670")
 147 testboth("%# .34o", big, " 0012345670123456701234567012345670")
 148 testboth("%#+.34o", big, "+0012345670123456701234567012345670")
 149 testboth("%#-+.34o", big, "+0012345670123456701234567012345670")
 150 testboth("%#-+37.34o", big, "+0012345670123456701234567012345670  ")
 151 testboth("%#+37.34o", big, "  +0012345670123456701234567012345670")
 152 # next one gets one leading zero from precision
 153 testboth("%.33o", big, "012345670123456701234567012345670")
 154 # base marker shouldn't change that, since "0" is redundant
 155 testboth("%#.33o", big, "012345670123456701234567012345670")
 156 # but reduce precision, and base marker should add a zero
 157 testboth("%#.32o", big, "012345670123456701234567012345670")
 158 # one leading zero from precision, and another from "0" flag & width
 159 testboth("%034.33o", big, "0012345670123456701234567012345670")
 160 # base marker shouldn't change that
 161 testboth("%0#34.33o", big, "0012345670123456701234567012345670")
 162
 163 # Some small ints, in both Python int and long flavors).
 164 testboth("%d", 42, "42")
 165 testboth("%d", -42, "-42")
 166 testboth("%d", 42L, "42")
 167 testboth("%d", -42L, "-42")
 168 testboth("%#x", 1, "0x1")
 169 testboth("%#x", 1L, "0x1")
 170 testboth("%#X", 1, "0X1")
 171 testboth("%#X", 1L, "0X1")
 172 testboth("%#o", 1, "01")
 173 testboth("%#o", 1L, "01")
 174 testboth("%#o", 0, "0")
 175 testboth("%#o", 0L, "0")
 176 testboth("%o", 0, "0")
 177 testboth("%o", 0L, "0")
 178 testboth("%d", 0, "0")
 179 testboth("%d", 0L, "0")
 180 testboth("%#x", 0, "0x0")
 181 testboth("%#x", 0L, "0x0")
 182 testboth("%#X", 0, "0X0")
 183 testboth("%#X", 0L, "0X0")
 184
 185 testboth("%x", 0x42, "42")
 186 # testboth("%x", -0x42, "ffffffbe") # specific to 32-bit boxes; see below
 187 testboth("%x", 0x42L, "42")
 188 testboth("%x", -0x42L, "-42")
 189
 190 testboth("%o", 042, "42")
 191 # testboth("%o", -042, "37777777736") # specific to 32-bit boxes; see below
 192 testboth("%o", 042L, "42")
 193 testboth("%o", -042L, "-42")
 194
 195 # Test exception for unknown format characters
 196 if verbose:
 197     print 'Testing exceptions'
 198
 199 def test_exc(formatstr, args, exception, excmsg):
 200     try:
 201         testformat(formatstr, args)
 202     except exception, exc:
 203         if str(exc) == excmsg:
 204             if verbose:
 205                 print "yes"
 206         else:
 207             if verbose: print 'no'
 208             print 'Unexpected ', exception, ':', repr(str(exc))
 209     except:
 210         if verbose: print 'no'
 211         print 'Unexpected exception'
 212         raise
 213     else:
 214         raise TestFailed, 'did not get expected exception: %s' % excmsg
 215
 216 test_exc('abc %a', 1, ValueError,
 217          "unsupported format character 'a' (0x61) at index 5")
 218 if have_unicode:
 219     test_exc(unicode('abc %\u3000','raw-unicode-escape'), 1, ValueError,
 220              "unsupported format character '?' (0x3000) at index 5")
 221
 222 test_exc('%d', '1', TypeError, "int argument required")
 223 test_exc('%g', '1', TypeError, "float argument required")
 224 test_exc('no format', '1', TypeError,
 225          "not all arguments converted during string formatting")
 226 test_exc('no format', u'1', TypeError,
 227          "not all arguments converted during string formatting")
 228 test_exc(u'no format', '1', TypeError,
 229          "not all arguments converted during string formatting")
 230 test_exc(u'no format', u'1', TypeError,
 231          "not all arguments converted during string formatting")
 232
 233 if sys.maxint == 2**32-1:
 234     # crashes 2.2.1 and earlier:
 235     try:
 236         "%*d"%(sys.maxint, -127)
 237     except MemoryError:
 238         pass
 239     else:
 240         raise TestFailed, '"%*d"%(sys.maxint, -127) should fail'
 241     # (different things go wrong on a 64 bit box...)
 242     testboth("%x", -0x42, "ffffffbe")
 243     testboth("%o", -042, "37777777736")