PageRenderTime 59ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 1ms

/Languages/IronPython/Tests/test_strformat.py

http://github.com/IronLanguages/main
Python | 1219 lines | 1140 code | 52 blank | 27 comment | 31 complexity | 994f4ffd19b46da1d1bbb75f071c3a63 MD5 | raw file
Possible License(s): CPL-1.0, BSD-3-Clause, ISC, GPL-2.0, MPL-2.0-no-copyleft-exception 
    

  1. #####################################################################################
    2. 

  2. #
    3. 

  3. #  Copyright (c) Microsoft Corporation. All rights reserved.
    4. 

  4. #
    5. 

  5. # This source code is subject to terms and conditions of the Apache License, Version 2.0. A
    6. 

  6. # copy of the license can be found in the License.html file at the root of this distribution. If
    7. 

  7. # you cannot locate the  Apache License, Version 2.0, please send an email to
    8. 

  8. # ironpy@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
    9. 

  9. # by the terms of the Apache License, Version 2.0.
    10. 

  10. #
    11. 

  11. # You must not remove this notice, or any other, from this software.
    12. 

  12. #
    13. 

  13. #
    14. 

  14. #####################################################################################
    15. 

  15. 

  16. from iptest.assert_util import *
    17. 

  17. import sys
    18. 

  18. 

  19. allChars = ''      
    20. 

  20. for y in [chr(x) for x in xrange(256) if chr(x) != '[' and chr(x) != '.']:
    21. 

  21.     allChars += y
    22. 

  22. 

  23. class TestException(Exception): pass
    24. 

  24. 

  25. class bad_str(object):
    26. 

  26.     def __str__(self):
    27. 

  27.         raise TestException('booh')
    28. 

  28.             
    29. 

  29. 

  30. def test_formatter_parser_errors():
    31. 

  31.     errors = [ ("{0!",             "unmatched '{' in format"),
    32. 

  32.                ("{0!}}",           "end of format while looking for conversion specifier"),
    33. 

  33.                ("}a{",             "Single '}' encountered in format string"),
    34. 

  34.                ("{0:0.1a",         "unmatched '{' in format"),
    35. 

  35.                ("{0:{}",           "unmatched '{' in format"),
    36. 

  36.                ("{0:aa{ab}",       "unmatched '{' in format"),
    37. 

  37.                ("{0!}}",           "end of format while looking for conversion specifier"),
    38. 

  38.                ("{0!}",            "end of format while looking for conversion specifier"),
    39. 

  39.                ("{0!",             "unmatched '{' in format"),
    40. 

  40.                ("{0!aa}",          "expected ':' after format specifier"),
    41. 

  41.                ("{0.{!:{.}.}}",    "expected ':' after format specifier"),
    42. 

  42.                ("{",               "Single '{' encountered in format string"),
    43. 

  43.              ]
    44. 

  44.   
    45. 

  45.     for format, errorMsg in errors:
    46. 

  46.         AssertErrorWithMessage(ValueError, errorMsg, list, format._formatter_parser())
    47. 

  47. 

  48. def test_formatter_parser():
    49. 

  49.     tests = [ ('{0.}',             [('', '0.', '', None)]),
    50. 

  50.               ('{0:.{abc}}',       [('', '0', '.{abc}', None)]),
    51. 

  51.               ('{0[]}',            [('', '0[]', '', None)]),
    52. 

  52.               ('{0.{:{.}.}}',      [('', '0.{', '{.}.}', None)]),
    53. 

  53.               ('{0.{:.}.}',        [('', '0.{', '.}.', None)]),
    54. 

  54.               ('{0.{!.:{.}.}}',    [('', '0.{', '{.}.}', '.')]),
    55. 

  55.               ('{0.{!!:{.}.}}',    [('', '0.{', '{.}.}', '!')]),
    56. 

  56.               ('{0!!}',            [('', '0', '', '!')]),
    57. 

  57.               ('{0[}',             [('', '0[', '', None)]),
    58. 

  58.               ('{0:::!!::!::}',    [('', '0', '::!!::!::', None)]),
    59. 

  59.               ('{0.]}',            [('', '0.]', '', None)]),
    60. 

  60.               ('{0.[}',            [('', '0.[', '', None)]),
    61. 

  61.               ('{0..}',            [('', '0..', '', None)]),
    62. 

  62.               ('{{',               [('{', None, None, None)]),
    63. 

  63.               ('}}',               [('}', None, None, None)]),
    64. 

  64.               ('{{}}',             [('{', None, None, None), ('}', None, None, None)]),
    65. 

  65.             ]
    66. 

  66.     
    67. 

  67.     for format, expected in tests:
    68. 

  68.         AreEqual(list(format._formatter_parser()), expected)
    69. 

  69. 

  70. def test_format_field_name_split_errors():
    71. 

  71.     if is_cpython: #http://ironpython.codeplex.com/workitem/28224
    72. 

  72.         temp = ''._formatter_field_name_split() #Just ensure it doesn't throw
    73. 

  73.     else:
    74. 

  74.         AssertErrorWithMessage(ValueError, "empty field name", ''._formatter_field_name_split)
    75. 

  75.         AssertErrorWithMessage(ValueError, "empty field name", '['._formatter_field_name_split)
    76. 

  76.         AssertErrorWithMessage(ValueError, "empty field name", '.'._formatter_field_name_split)
    77. 

  77.         AssertErrorWithMessage(ValueError, "empty field name", '[.abc'._formatter_field_name_split)
    78. 

  78.         AssertErrorWithMessage(ValueError, "empty field name", '.abc'._formatter_field_name_split)
    79. 

  79.     
    80. 

  80.     errors = [ ("0[",              "Missing ']' in format string"),
    81. 

  81.                ("abc.",            "Empty attribute in format string"),
    82. 

  82.                ("abc[]",           "Empty attribute in format string"),
    83. 

  83.              ]
    84. 

  84. 

  85.     for format, errorMsg in errors:
    86. 

  86.         AssertErrorWithMessage(ValueError, errorMsg, list, format._formatter_field_name_split()[1])
    87. 

  87. 

  88. def test_format_field_name_split():  
    89. 

  89.     tests = [ ('0',                [0L, []]),
    90. 

  90.               ('abc.foo',          ['abc', [(True, 'foo')]]),
    91. 

  91.               ('abc[2]',           ['abc', [(False, 2L)]]),
    92. 

  92.               ('1[2]',             [1L, [(False, 2L)]]),
    93. 

  93.               ('1.abc',            [1L, [(True, 'abc')]]),
    94. 

  94.               ('abc 2.abc',        ['abc 2', [(True, 'abc')]]),
    95. 

  95.               ('abc!2.abc',        ['abc!2', [(True, 'abc')]]),
    96. 

  96.               ('].abc',            [']', [(True, 'abc')]]),
    97. 

  97.               ("abc[[]",           ['abc', [(False, '[')]] ),
    98. 

  98.               ("abc[[[]",          ['abc', [(False, '[[')]] ),
    99. 

  99.             ]
    100. 

  100. 

  101.     if not is_cpython: #http://ironpython.codeplex.com/workitem/28331
    102. 

  102.         tests.append(("abc[2]#x",         ['abc', [(False, 2L)]] ))
    103. 

  103.     tests.append([allChars, [allChars, []]])
    104. 

  104.     tests.append([allChars + '.foo', [allChars, [(True, 'foo')]]])
    105. 

  105.     tests.append([allChars + '[2]', [allChars, [(False, 2L)]]])
    106. 

  106.     
    107. 

  107.     for format, expected in tests:
    108. 

  108.         res = list(format._formatter_field_name_split())
    109. 

  109.         res[1] = list(res[1])
    110. 

  110.         AreEqual(res, expected)
    111. 

  111. 

  112. def test_format_arg_errors():
    113. 

  113.     AssertError(IndexError, '{0}'.format)
    114. 

  114.     AssertErrorWithMessage(ValueError, "Empty attribute in format string", '{0.}'.format, 42)
    115. 

  115.     AssertErrorWithMessage(ValueError, "Empty attribute in format string", '{0[]}'.format, 42)
    116. 

  116.     AssertErrorWithMessage(ValueError, "Missing ']' in format string", '{0[}'.format, 42)
    117. 

  117.     AssertError(IndexError, '{0[}'.format)
    118. 

  118. 

  119. @skip("win32")
    120. 

  120. def test_format_cli_interop():
    121. 

  121.     # test classes implementing IFormattable where we pass
    122. 

  122.     # the format spec through
    123. 

  123.     import System
    124. 

  124.     dt = System.DateTime(2008, 10, 26)      
    125. 

  125. 

  126.     class x(object):
    127. 

  127.         abc = dt    
    128. 

  128.     
    129. 

  129.     AreEqual(format(dt, 'MM-dd'), '10-26')
    130. 

  130.     AreEqual('{0:MM-dd}'.format(dt), '10-26')
    131. 

  131.     AreEqual('{abc:MM-dd}'.format(abc=dt), '10-26')
    132. 

  132.     AreEqual('{0.abc:MM-dd}'.format(x), '10-26')
    133. 

  133.     
    134. 

  134.     # test accessing a .NET attribute
    135. 

  135.     AreEqual('{0.Year}'.format(dt), '2008')
    136. 

  136.     
    137. 

  137.     # indexing into .NET dictionaries 
    138. 

  138.     strDict = System.Collections.Generic.Dictionary[str, object]()
    139. 

  139.     strDict['abc'] = dt    
    140. 

  140.     AreEqual('{0[abc]:MM-dd}'.format(strDict), '10-26')
    141. 

  141. 

  142.     intDict = System.Collections.Generic.Dictionary[int, object]()
    143. 

  143.     intDict[42] = dt
    144. 

  144.     AreEqual('{0[42]:MM-dd}'.format(intDict), '10-26')
    145. 

  145. 

  146.     objDict = System.Collections.Generic.Dictionary[object, object]()
    147. 

  147.     objDict[42], objDict['42'] = 'abc', 'def'
    148. 

  148.     AreEqual('{0[42]}'.format(objDict), 'abc')
    149. 

  149.     
    150. 

  150.     # import clr doesn't flow through
    151. 

  151.     AssertError(AttributeError, '{0.MaxValue}'.format, int)
    152. 

  152. 

  153. def test_format_object_access():    
    154. 

  154.     class y(object):
    155. 

  155.         bar = 23
    156. 

  156. 

  157.     class x(object):
    158. 

  158.         def __getitem__(self, index):
    159. 

  159.             return type(index).__name__ + ' ' + str(index)
    160. 

  160.         abc = 42
    161. 

  161.         baz = y
    162. 

  162.         def __str__(self): return 'foo'
    163. 

  163.         def __repr__(self): return 'bar'    
    164. 

  164.     
    165. 

  165.     AreEqual('{0.abc}'.format(x), '42')
    166. 

  166.     AreEqual('{0.abc}xyz'.format(x), '42xyz')
    167. 

  167.     AreEqual('{0[42]}'.format(x()), 'int 42')
    168. 

  168.     AreEqual('{0[abc]}'.format(x()), 'str abc')
    169. 

  169.     AreEqual('{0.baz.bar}'.format(x()), '23')
    170. 

  170.     AreEqual('{0[abc]!r}'.format(x()), "'str abc'")
    171. 

  171.     AreEqual('{0[abc]!s}'.format(x()), 'str abc')
    172. 

  172.     AreEqual('{0!r}'.format(x()), 'bar')
    173. 

  173.     AreEqual('{0!s}'.format(x()), 'foo')
    174. 

  174.     AreEqual('{abc!s}'.format(abc = x()), 'foo')
    175. 

  175.     AreEqual('{abc!r}'.format(abc = x()), 'bar')
    176. 

  176.     
    177. 

  177. def test_format():
    178. 

  178.     class x(object):
    179. 

  179.         def __format__(self, formatSpec):
    180. 

  180.             return formatSpec
    181. 

  181. 

  182.     # computed format specs
    183. 

  183.     AreEqual('{0:{1}}'.format(x(), 'abc'), 'abc')    
    184. 

  184.     AssertErrorWithMessage(ValueError, "Max string recursion exceeded", '{0:{1:{2}}}'.format, x(), x(), 'abc')
    185. 

  185.     
    186. 

  186.     # built-in format method
    187. 

  187.     AreEqual(format(x()), '')
    188. 

  188.     AreEqual(format(x(), 'abc'), 'abc')
    189. 

  189.     
    190. 

  190.     class x:
    191. 

  191.         def __format__(self, *args): 
    192. 

  192.             return 'abc'
    193. 

  193.         
    194. 

  194.     AreEqual(format(x(), ''), 'abc')
    195. 

  195.     AreEqual('{0}'.format(x()), 'abc')
    196. 

  196. 

  197.     # format for old instances isn't done by an old-instance __format__ method,
    198. 

  198.     # it would seem to be done by a special case.
    199. 

  199.     Assert('__format__' not in type(x()).__dict__)
    200. 

  200. 

  201. def test_format_errors():
    202. 

  202.     class bad(object):
    203. 

  203.         def __format__(self, *args):
    204. 

  204.             return None
    205. 

  205.     
    206. 

  206.     class bad2(object):
    207. 

  207.         def __format__(self, *args):
    208. 

  208.             return 42
    209. 

  209. 

  210.     AssertErrorWithMessage(TypeError, "bad.__format__ must return string or unicode, not NoneType", '{0}'.format, bad())
    211. 

  211.     AssertErrorWithMessage(TypeError, "bad2.__format__ must return string or unicode, not int", '{0}'.format, bad2())
    212. 

  212.     
    213. 

  213.     AssertErrorWithMessage(ValueError, "Unknown conversion specifier x", '{0!x}'.format, 'abc')
    214. 

  214.     
    215. 

  215.     AssertErrorWithMessage(TypeError, "bad.__format__ must return string or unicode, not NoneType", format, bad())
    216. 

  216.     AssertErrorWithMessage(TypeError, "bad2.__format__ must return string or unicode, not int", format, bad2())
    217. 

  217. 

  218. def test_object___format__():
    219. 

  219.     class x(object):
    220. 

  220.         def __str__(self):
    221. 

  221.             return 'abc'
    222. 

  222.             
    223. 

  223.     tests = [ ('',     'abc'),
    224. 

  224.               ('6',    'abc   '),
    225. 

  225.               ('6s',   'abc   '),
    226. 

  226.               ('<6',   'abc   '),
    227. 

  227.               ('>6',   '   abc'),
    228. 

  228.               ('^6',   ' abc  '),
    229. 

  229.               ('x^6',  'xabcxx'),
    230. 

  230.               ('x<6',  'abcxxx'),
    231. 

  231.               ('<<6',  'abc<<<'),
    232. 

  232.               ('x>6',  'xxxabc'),
    233. 

  233.               ('}^6',  '}abc}}'),
    234. 

  234.               ('\0<6', 'abc   '),
    235. 

  235.               ('.0',   ''),
    236. 

  236.               ('.1',   'a'),
    237. 

  237.               ('5.2',  'ab   '),
    238. 

  238.               ('5.2s', 'ab   '),
    239. 

  239.              ]
    240. 

  240.              
    241. 

  241.     for spec, result in tests:
    242. 

  242.         AreEqual(object.__format__(x(), spec), result)
    243. 

  243. 

  244. def test_object___format___errors():
    245. 

  245.     errors = [ ("+",             "Sign not allowed in string format specifier"),
    246. 

  246.                ("=+",            "Sign not allowed in string format specifier"),
    247. 

  247.                ('=10',            "'=' alignment not allowed in string format specifier"),
    248. 

  248.                ("10r",            "Unknown format code 'r' for object of type 'str'"),
    249. 

  249.                ("=+r",            "Unknown format code 'r' for object of type 'str'"),
    250. 

  250.                (".",              "Format specifier missing precision"),
    251. 

  251.                (".a",             "Format specifier missing precision"),
    252. 

  252.              ]
    253. 

  253.     
    254. 

  254.     # ensure only the s format type is recognized
    255. 

  255.     for char in allChars:
    256. 

  256.         if char != 's' and (char < '0' or char > '9'):
    257. 

  257.             if char==',': 
    258. 

  258.                 errors.append(('10' + char, "Cannot specify ',' with 's'."))
    259. 

  259.             else:
    260. 

  260.                 errors.append(('10' + char, "Unknown format code '%s' for object of type 'str'" % char))
    261. 

  261. 

  262.         
    263. 

  263.     for errorFmt, errorMsg in errors:
    264. 

  264.         AssertErrorWithMessage(ValueError, errorMsg, object().__format__, errorFmt)
    265. 

  265. 

  266.     # __str__ is called before processing spec
    267. 

  267.     AssertErrorWithMessage(TestException, 'booh', bad_str().__format__, '+')
    268. 

  268.     AssertErrorWithMessage(TestException, 'booh', bad_str().__format__, '=10')
    269. 

  269.     AssertErrorWithMessage(TestException, 'booh', bad_str().__format__, '.')
    270. 

  270.     
    271. 

  271. def test_float___format__():
    272. 

  272.     tests = []
    273. 

  273.     if is_cpython: #In large part due to http://ironpython.codeplex.com/workitem/28206
    274. 

  274.         tests+= [   (2.0,              '6.1',      ' 2e+00'),
    275. 

  275.                     (2.5,              '6.1',      ' 2e+00'),
    276. 

  276.                     (2.25,             '6.1',      ' 2e+00'),
    277. 

  277.                     (2.25,             '6.2',      '   2.2'),
    278. 

  278.                     (23.0,             '.1',       '2e+01'),
    279. 

  279.                     (23.0,             '.2',       '2.3e+01'),
    280. 

  280.                     (230.5,            '.3',       '2.3e+02'),
    281. 

  281.                     (11230.54,         '.5',       '1.1231e+04'),
    282. 

  282.                     (111230.54,        '.1',       '1e+05'),
    283. 

  283.                     (100000.0,           '.5',     '1e+05'),
    284. 

  284.                     (230.5,            '.3g',       '230'),
    285. 

  285.                     (230.5,            '.3n',       '230'),
    286. 

  286.                     (0.0,              '1.1',      '0e+00'),
    287. 

  287.                     (0.0,              '1.0',      '0e+00'),
    288. 

  288.                     (1.0,              '.0',       '1e+00'),
    289. 

  289.                     (1.1,              '.0',       '1e+00'),
    290. 

  290.                     (1.1,              '.1',       '1e+00'),
    291. 

  291.                     (10.0,             '.1',       '1e+01'),
    292. 

  292.                     (10.0,             '.0',       '1e+01'),
    293. 

  293.                     (100000000000.0,   '',         '1e+11'),
    294. 

  294.                     (1000000000.12,    '1.10',     '1e+09'),
    295. 

  295.                     (1000000000.12,    '1.3',      '1e+09'),
    296. 

  296.                     (999999999999.9,   '1.0',      '1e+12'),
    297. 

  297.                     (999999999999.9,   '1.2',      '1e+12'),
    298. 

  298.                     (999999999999.0,   '',         '9.99999999999e+11'),
    299. 

  299.                     (-999999999999.0,  '',         '-9.99999999999e+11'),
    300. 

  300.                     (10e667,           '+',        '+inf'),
    301. 

  301.                     (-10e667,          '+',        '-inf'),
    302. 

  302.                     (10e667/10e667,    '+',        '+nan'),
    303. 

  303.                     (10e667,           '-',        'inf'),
    304. 

  304.                     (-10e667,          '-',        '-inf'),
    305. 

  305.                     (10e667/10e667,    '-',        'nan'),
    306. 

  306.                     (10e667,           ' ',        ' inf'),
    307. 

  307.                     (-10e667,          ' ',        '-inf'),
    308. 

  308.                     (10e667/10e667,    ' ',        ' nan'),
    309. 

  309.                 ]
    310. 

  310.     else:
    311. 

  311.         tests+= [   (2.0,              '6.1',      '   2.0'),
    312. 

  312.                     (2.5,              '6.1',      '   3.0'),
    313. 

  313.                     (2.25,             '6.1',      '   2.0'),
    314. 

  314.                     (2.25,             '6.2',      '   2.3'),
    315. 

  315.                     (23.0,             '.1',       '2.0e+01'),
    316. 

  316.                     (23.0,             '.2',       '23.0'),
    317. 

  317.                     (230.5,            '.3',       '231.0'),
    318. 

  318.                     (11230.54,         '.5',       '11231.0'),
    319. 

  319.                     (111230.54,        '.1',       '1.0e+05'),
    320. 

  320.                     (100000.0,           '.5',     '1.0e+05'),
    321. 

  321.                     (230.5,            '.3g',       '231'),
    322. 

  322.                     (230.5,            '.3n',       '231'),
    323. 

  323.                     (0.0,              '1.1',      '0.0'),
    324. 

  324.                     (0.0,              '1.0',      '0.0'),
    325. 

  325.                     (1.0,              '.0',       '1.0'),
    326. 

  326.                     (1.1,              '.0',       '1.0'),
    327. 

  327.                     (1.1,              '.1',       '1.0'),
    328. 

  328.                     (10.0,             '.1',       '1.0e+01'),
    329. 

  329.                     (10.0,             '.0',       '1.0e+01'),
    330. 

  330.                     (100000000000.0,   '',         '100000000000.0'),
    331. 

  331.                     (1000000000.12,    '1.10',     '1000000000.0'),
    332. 

  332.                     (1000000000.12,    '1.3',      '1.0e+09'),
    333. 

  333.                     (999999999999.9,   '1.0',      '1.0e+12'),
    334. 

  334.                     (999999999999.9,   '1.2',      '1.0e+12'),
    335. 

  335.                     (999999999999.0,   '',         '999999999999.0'),
    336. 

  336.                     (-999999999999.0,  '',         '-999999999999.0'),
    337. 

  337.                     (10e667,           '+',        '+inf'),
    338. 

  338.                     (-10e667,          '+',        '-inf'),
    339. 

  339.                     (10e667/10e667,    '+',        '+nan'),
    340. 

  340.                     (10e667,           '-',        'inf'),
    341. 

  341.                     (-10e667,          '-',        '-inf'),
    342. 

  342.                     (10e667/10e667,    '-',        'nan'),
    343. 

  343.                     (10e667,           ' ',        ' inf'),
    344. 

  344.                     (-10e667,          ' ',        '-inf'),
    345. 

  345.                     (10e667/10e667,    ' ',        ' nan'),
    346. 

  346.                 ]
    347. 

  347.     
    348. 

  348.     tests+= [ (2.0,              '',         '2.0'),
    349. 

  349.               (2.0,              'g',         '2'),
    350. 

  350.               (2.0,              'f',         '2.000000'),
    351. 

  351.               (2.5,              '',         '2.5'),
    352. 

  352.               (2.5,              'g',         '2.5'),
    353. 

  353.               (2.0,              '+',        '+2.0'),
    354. 

  354.               (2.0,              '-',        '2.0'),
    355. 

  355.               (2.0,              ' ',        ' 2.0'),
    356. 

  356.               (2.0,              '<5',       '2.0  '),
    357. 

  357.               (2.0,              '>5',       '  2.0'),
    358. 

  358.               (2.0,              '=5',       '  2.0'),
    359. 

  359.               (2.0,              '^6',       ' 2.0  '),
    360. 

  360.               (2.0,              '6',        '   2.0'),
    361. 

  361.               (2.0,              'x< 10.10', ' 2.0xxxxxx'),
    362. 

  362.               (2.01,             'x< 10.10', ' 2.01xxxxx'),
    363. 

  363.               (2.0,              'x> 10.10', 'xxxxxx 2.0'),
    364. 

  364.               (2.0,              'x= 10.10', ' xxxxxx2.0'),
    365. 

  365.               (2.0,              'x^ 10.10', 'xxx 2.0xxx'),
    366. 

  366.               (2.0,              'x^ 9.10',  'xx 2.0xxx'),
    367. 

  367.               (2.0,              '\0^ 9.10', '   2.0   '),
    368. 

  368.               (2.23,             '6.2',      '   2.2'),
    369. 

  369.               (2.25,             '6.3',      '  2.25'),
    370. 

  370.               (2.123456789,      '2.10',     '2.123456789'),
    371. 

  371.               
    372. 

  372.               
    373. 

  373.               (230.0,            '.2',       '2.3e+02'),
    374. 

  374.               (230.1,            '.2',       '2.3e+02'),
    375. 

  375.               (230.5,            '.4',       '230.5'),
    376. 

  376.               (230.54,           '.4',       '230.5'),
    377. 

  377.               (230.54,           '.5',       '230.54'),
    378. 

  378.               (1230.54,          '.5',       '1230.5'),
    379. 

  379.               (111230.54,        '.5',       '1.1123e+05'),
    380. 

  380.               (111230.54,        '.4',       '1.112e+05'),
    381. 

  381.               (111230.54,        '.3',       '1.11e+05'),
    382. 

  382.               (111230.54,        '.2',       '1.1e+05'),
    383. 

  383. 

  384.               
    385. 

  385.               (23.0,             'e',        '2.300000e+01'),
    386. 

  386.               (23.0,             '.6e',      '2.300000e+01'),
    387. 

  387.               (23.0,             '.0e',      '2e+01'),
    388. 

  388.               (23.0,             '.1e',      '2.3e+01'),
    389. 

  389.               (23.0,             '.2e',      '2.30e+01'),
    390. 

  390.               (23.0,             '.3e',      '2.300e+01'),
    391. 

  391.               (23.0,             '.4e',      '2.3000e+01'),
    392. 

  392.               (230.0,            '.2e',      '2.30e+02'),
    393. 

  393.               (230.1,            '.2e',      '2.30e+02'),
    394. 

  394.               (230.5,            '.3e',      '2.305e+02'),
    395. 

  395.               (230.5,            '.4e',      '2.3050e+02'),
    396. 

  396.               (230.54,           '.4e',      '2.3054e+02'),
    397. 

  397.               (230.54,           '.5e',      '2.30540e+02'),
    398. 

  398.               (1230.54,          '.5e',      '1.23054e+03'),
    399. 

  399.               (11230.54,         '.5e',      '1.12305e+04'),
    400. 

  400.               (111230.54,        '.5e',      '1.11231e+05'),
    401. 

  401.               (111230.54,        '.4e',      '1.1123e+05'),
    402. 

  402.               (111230.54,        '.3e',      '1.112e+05'),
    403. 

  403.               (111230.54,        '.2e',      '1.11e+05'),
    404. 

  404.               (111230.54,        '.1e',      '1.1e+05'),
    405. 

  405.                             
    406. 

  406.               (23.0,             'E',        '2.300000E+01'),
    407. 

  407.               (23.0,             '.6E',      '2.300000E+01'),
    408. 

  408.               (23.0,             '.0E',      '2E+01'),
    409. 

  409.               (23.0,             '.1E',      '2.3E+01'),
    410. 

  410.               (23.0,             '.2E',      '2.30E+01'),
    411. 

  411.               (23.0,             '.3E',      '2.300E+01'),
    412. 

  412.               (23.0,             '.4E',      '2.3000E+01'),
    413. 

  413.               (230.0,            '.2E',      '2.30E+02'),
    414. 

  414.               (230.1,            '.2E',      '2.30E+02'),
    415. 

  415.               (230.5,            '.3E',      '2.305E+02'),
    416. 

  416.               (230.5,            '.4E',      '2.3050E+02'),
    417. 

  417.               (230.54,           '.4E',      '2.3054E+02'),
    418. 

  418.               (230.54,           '.5E',      '2.30540E+02'),
    419. 

  419.               (1230.54,          '.5E',      '1.23054E+03'),
    420. 

  420.               (11230.54,         '.5E',      '1.12305E+04'),
    421. 

  421.               (111230.54,        '.5E',      '1.11231E+05'),
    422. 

  422.               (111230.54,        '.4E',      '1.1123E+05'),
    423. 

  423.               (111230.54,        '.3E',      '1.112E+05'),
    424. 

  424.               (111230.54,        '.2E',      '1.11E+05'),
    425. 

  425.               (111230.54,        '.1E',      '1.1E+05'),
    426. 

  426. 

  427.               (23.0,             'F',        '23.000000'),
    428. 

  428.               (23.0,             '.6F',      '23.000000'),
    429. 

  429.               (23.0,             '.0F',      '23'),
    430. 

  430.               (23.0,             '.1F',      '23.0'),
    431. 

  431.               (23.0,             '.2F',      '23.00'),
    432. 

  432.               (23.0,             '.3F',      '23.000'),
    433. 

  433.               (23.0,             '.4F',      '23.0000'),
    434. 

  434.               (230.0,            '.2F',      '230.00'),
    435. 

  435.               (230.1,            '.2F',      '230.10'),
    436. 

  436.               (230.5,            '.3F',      '230.500'),
    437. 

  437.               (230.5,            '.4F',      '230.5000'),
    438. 

  438.               (230.54,           '.4F',      '230.5400'),
    439. 

  439.               (230.54,           '.5F',      '230.54000'),
    440. 

  440.               (1230.54,          '.5F',      '1230.54000'),
    441. 

  441.               (11230.54,         '.5F',      '11230.54000'),
    442. 

  442.               (111230.54,        '.5F',      '111230.54000'),
    443. 

  443.               (111230.54,        '.4F',      '111230.5400'),
    444. 

  444.               (111230.54,        '.3F',      '111230.540'),
    445. 

  445.               (111230.54,        '.2F',      '111230.54'),
    446. 

  446.               (111230.54,        '.1F',      '111230.5'),
    447. 

  447.               (111230.55,        '.1F',      '111230.6'),
    448. 

  448.               (-111230.55,       '.1F',      '-111230.6'),
    449. 

  449.               (111230.55,        '.1f',      '111230.6'),
    450. 

  450.               (-111230.55,       '.1f',      '-111230.6'),
    451. 

  451.               
    452. 

  452.               (23.0,             '%',        '2300.000000%'),
    453. 

  453.               (23.0,             '.6%',      '2300.000000%'),
    454. 

  454.               (23.0,             '.0%',      '2300%'),
    455. 

  455.               (23.0,             '.1%',      '2300.0%'),
    456. 

  456.               (23.0,             '.2%',      '2300.00%'),
    457. 

  457.               (23.0,             '.3%',      '2300.000%'),
    458. 

  458.               (23.0,             '.4%',      '2300.0000%'),
    459. 

  459.               (230.0,            '.2%',      '23000.00%'),
    460. 

  460.               (230.1,            '.2%',      '23010.00%'),
    461. 

  461.               (230.5,            '.3%',      '23050.000%'),
    462. 

  462.               (230.5,            '.4%',      '23050.0000%'),
    463. 

  463.               (230.54,           '.4%',      '23054.0000%'),
    464. 

  464.               (230.54,           '.5%',      '23054.00000%'),
    465. 

  465.               (1230.54,          '.5%',      '123054.00000%'),
    466. 

  466.               (11230.54,         '.5%',      '1123054.00000%'),
    467. 

  467.               (111230.54,        '.5%',      '11123054.00000%'),
    468. 

  468.               (111230.54,        '.4%',      '11123054.0000%'),
    469. 

  469.               (111230.54,        '.3%',      '11123054.000%'),
    470. 

  470.               (111230.54,        '.2%',      '11123054.00%'),
    471. 

  471.               (111230.54,        '.1%',      '11123054.0%'),
    472. 

  472.               (111230.55,        '.1%',      '11123055.0%'),
    473. 

  473.               (-111230.55,       '.1%',      '-11123055.0%'),
    474. 

  474.               
    475. 

  475.               (23.0,             '.1g',       '2e+01'),
    476. 

  476.               (23.0,             '.0g',       '2e+01'),
    477. 

  477.               (230.0,            '.1g',       '2e+02'),
    478. 

  478.               (23.0,             '.2g',       '23'),
    479. 

  479.               (23.5,             '.2g',       '24'),
    480. 

  480.               (23.4,             '.2g',       '23'),
    481. 

  481.               (23.45,            '.2g',       '23'),
    482. 

  482.               (230.0,            '.2g',       '2.3e+02'),
    483. 

  483.               (230.1,            '.2g',       '2.3e+02'),
    484. 

  484.               
    485. 

  485.               (230.5,            '.4g',       '230.5'),
    486. 

  486.               (230.54,           '.4g',       '230.5'),
    487. 

  487.               (230.54,           '.5g',       '230.54'),
    488. 

  488.               (1230.54,          '.5g',       '1230.5'),
    489. 

  489.               (11230.54,         '.5g',       '11231'),
    490. 

  490.               (111230.54,        '.5g',       '1.1123e+05'),
    491. 

  491.               (111230.54,        '.4g',       '1.112e+05'),
    492. 

  492.               (111230.54,        '.3g',       '1.11e+05'),
    493. 

  493.               (111230.54,        '.2g',       '1.1e+05'),
    494. 

  494.               (111230.54,        '.1g',       '1e+05'),
    495. 

  495.              
    496. 

  496.               (23.0,             '.1n',       '2e+01'),
    497. 

  497.               (23.0,             '.2n',       '23'),
    498. 

  498.               (230.0,            '.2n',       '2.3e+02'),
    499. 

  499.               (230.1,            '.2n',       '2.3e+02'),
    500. 

  500.               
    501. 

  501.               (230.5,            '.4n',       '230.5'),
    502. 

  502.               (230.54,           '.4n',       '230.5'),
    503. 

  503.               (230.54,           '.5n',       '230.54'),
    504. 

  504.               (1230.54,          '.5n',       '1230.5'),
    505. 

  505.               (11230.54,         '.5n',       '11231'),
    506. 

  506.               (111230.54,        '.5n',       '1.1123e+05'),
    507. 

  507.               (111230.54,        '.4n',       '1.112e+05'),
    508. 

  508.               (111230.54,        '.3n',       '1.11e+05'),
    509. 

  509.               (111230.54,        '.2n',       '1.1e+05'),
    510. 

  510.               (111230.54,        '.1n',       '1e+05'),
    511. 

  511.               (11231.54,         'n',        '11231.5'),
    512. 

  512.               (111230.54,        'n',        '111231'),
    513. 

  513.               (111230.54,        'g',        '111231'), 
    514. 

  514.               (0.0,              '',         '0.0'),
    515. 

  515.               (0.0,              '1',        '0.0'),
    516. 

  516.               (1.1,              '.2',       '1.1'),
    517. 

  517.               (1000000.0,        '',         '1000000.0'),
    518. 

  518.               (10000000.0,       '',         '10000000.0'),
    519. 

  519.               (100000000.0,      '',         '100000000.0'),
    520. 

  520.               (1000000000.0,     '',         '1000000000.0'),
    521. 

  521.               (10000000000.0,    '',         '10000000000.0'),
    522. 

  522.               (1000000000000.0,  '',         '1e+12'),
    523. 

  523.               (-1000000000000.0, '',         '-1e+12'),
    524. 

  524.               (-1000000000000.0, 'g',        '-1e+12'),
    525. 

  525.               (-1000000000000.0, 'G',        '-1E+12'),
    526. 

  526.               (-1000000000000.0, '.1g',      '-1e+12'),
    527. 

  527.               (-1000000000000.0, '.1G',      '-1E+12'),
    528. 

  528.               (10e667,           '',         'inf'),
    529. 

  529.               (-10e667,          '',         '-inf'),
    530. 

  530.               (10e667/10e667,    '',         'nan'),
    531. 

  531.             ]
    532. 

  532. 

  533.     for value, spec, result in tests:
    534. 

  534.         AreEqual(value.__format__(spec), result)
    535. 

  535. 

  536. 

  537.     # check locale specific formatting
    538. 

  538.     import _locale
    539. 

  539.     try:
    540. 

  540.         if is_cli:
    541. 

  541.             _locale.setlocale(_locale.LC_ALL, 'en_US')
    542. 

  542.         else:
    543. 

  543.             _locale.setlocale(_locale.LC_ALL, 'English_United States.1252')
    544. 

  544.             
    545. 

  545.         tests = [ (1000.0,              'n',         '1,000'),
    546. 

  546.                   (1000.12345,          'n',         '1,000.12'),
    547. 

  547.                   (1000.5,              'n',         '1,000.5'),
    548. 

  548.                   (100000.0,            'n',         '100,000'),
    549. 

  549.                   
    550. 

  550.                   (100000.0,            '.5n',       '1e+05'),
    551. 

  551.                   (100000.5,            '.5n',       '1e+05'),
    552. 

  552.                   
    553. 

  553.                   (100000.5,            '.7n',       '100,000.5'),
    554. 

  554.                 ]
    555. 

  555.         if is_cpython: #http://ironpython.codeplex.com/workitem/28206
    556. 

  556.             tests+= [
    557. 

  557.                         (100000.5,            'n',         '100,000'),
    558. 

  558.                         (100000.5,            '.6n',       '100,000'),
    559. 

  559.                     ]
    560. 

  560.         else:
    561. 

  561.             tests+= [
    562. 

  562.                         (100000.5,            'n',         '100,001'),
    563. 

  563.                         (100000.5,            '.6n',       '100,001'),
    564. 

  564.                     ]
    565. 

  565. 

  566.         for value, spec, result in tests:
    567. 

  567.             AreEqual(value.__format__(spec), result)
    568. 

  568.     finally:
    569. 

  569.         # and restore it back...
    570. 

  570.         _locale.setlocale(_locale.LC_ALL, 'C')
    571. 

  571.         AreEqual(100000.0.__format__('n'), '100000')
    572. 

  572. 

  573. def test_float___format___errors():
    574. 

  574.     errors = []
    575. 

  575.     
    576. 

  576.     okChars = set(['\0', '%', 'E', 'F', 'G', 'e', 'f', 'g', 'n', ','])
    577. 

  577.     # verify the okChars are actually ok
    578. 

  578.     for char in okChars:
    579. 

  579.         2.0.__format__('10' + char)
    580. 

  580. 

  581.     for char in allChars:
    582. 

  582.         if char not in okChars and (char < '0' or char > '9'):
    583. 

  583.             errors.append((2.0, '10' + char, "Unknown format code '%s' for object of type 'float'" % char))
    584. 

  584. 

  585.     for value, errorFmt, errorMsg in errors:
    586. 

  586.         AssertErrorWithMessage(ValueError, errorMsg, value.__format__, errorFmt)
    587. 

  587. 

  588. def test_int___format__():
    589. 

  589.     tests = [ 
    590. 

  590.               (0,    '+',        '+0'),
    591. 

  591.               (0,    ' ',        ' 0'),
    592. 

  592.               (0,    '-',        '0'),
    593. 

  593.               (2,    '',         '2'),
    594. 

  594.               (2,    '+',        '+2'),
    595. 

  595.               (2,    '-',        '2'),
    596. 

  596.               (2,    ' ',        ' 2'),
    597. 

  597.               (2,    '<5',       '2    '),
    598. 

  598.               (2,    '05',       '00002'),
    599. 

  599.               (20000,'+4',       '+20000'),
    600. 

  600.               (2,    '>5',       '    2'),
    601. 

  601.               (2,    '=5',       '    2'),
    602. 

  602.               (2,    '^6',       '  2   '),
    603. 

  603.               (2,    '6',        '     2'),
    604. 

  604.               (2,    'x< 10',    ' 2xxxxxxxx'),
    605. 

  605.               (2,    'x> 10',    'xxxxxxxx 2'),
    606. 

  606.               (2,    'x= 10',    ' xxxxxxxx2'),
    607. 

  607.               (2,    'x^ 10',    'xxxx 2xxxx'),
    608. 

  608.               (2,    'x^ 9',     'xxx 2xxxx'),
    609. 

  609.               (2,    'x<+10',    '+2xxxxxxxx'),
    610. 

  610.               (2,    'x>+10',    'xxxxxxxx+2'),
    611. 

  611.               (2,    'x=+10',    '+xxxxxxxx2'),
    612. 

  612.               (2,    'x^+10',    'xxxx+2xxxx'),
    613. 

  613.               (2,    'x^+9',     'xxx+2xxxx'),
    614. 

  614.               (2,    'x<-10',    '2xxxxxxxxx'),
    615. 

  615.               (2,    'x>-10',    'xxxxxxxxx2'),
    616. 

  616.               (2,    'x=-10',    'xxxxxxxxx2'),
    617. 

  617.               (2,    'x^-10',    'xxxx2xxxxx'),
    618. 

  618.               (2,    'x^-9',     'xxxx2xxxx'),
    619. 

  619.               (-2,   'x<-10',    '-2xxxxxxxx'),
    620. 

  620.               (-2,   'x>-10',    'xxxxxxxx-2'),
    621. 

  621.               (-2,   'x=-10',   '-xxxxxxxx2'),
    622. 

  622.               (-2,   'x^-10',    'xxxx-2xxxx'),
    623. 

  623.               (-2,   'x^-9',     'xxx-2xxxx'),
    624. 

  624.               (-2,   'x<+10',    '-2xxxxxxxx'),
    625. 

  625.               (-2,   'x>+10',    'xxxxxxxx-2'),
    626. 

  626.               (-2,   'x=+10',   '-xxxxxxxx2'),
    627. 

  627.               (-2,   'x^+10',    'xxxx-2xxxx'),
    628. 

  628.               (-2,   'x^+9',     'xxx-2xxxx'),
    629. 

  629.               (-2,   'x< 10',    '-2xxxxxxxx'),
    630. 

  630.               (-2,   'x> 10',    'xxxxxxxx-2'),
    631. 

  631.               (-2,   'x= 10',   '-xxxxxxxx2'),
    632. 

  632.               (-2,   'x^ 10',    'xxxx-2xxxx'),
    633. 

  633.               (-2,   'x^ 9',     'xxx-2xxxx'),
    634. 

  634.               (2,    '\0^ 9',    '    2    '),
    635. 

  635. 

  636.               (2,    'c',         '\x02'),
    637. 

  637.               (2,    '<5c',       '\x02    '),
    638. 

  638.               (2,    '>5c',       '    \x02'),
    639. 

  639.               (2,    '=5c',       '    \x02'),
    640. 

  640.               (2,    '^6c',       '  \x02   '),
    641. 

  641.               (2,    '6c',        '     \x02'),
    642. 

  642.               
    643. 

  643.               (3,    'b',         '11'),
    644. 

  644.               (3,    '+b',        '+11'),
    645. 

  645.               (3,    '-b',        '11'),
    646. 

  646.               (3,    ' b',        ' 11'),
    647. 

  647.               (3,    '<5b',       '11   '),
    648. 

  648.               (3,    '>5b',       '   11'),
    649. 

  649.               (3,    '=5b',       '   11'),
    650. 

  650.               (3,    '^6b',       '  11  '),
    651. 

  651.               (3,    '6b',        '    11'),
    652. 

  652.               (3,    'x< 010b',   ' 11xxxxxxx'),
    653. 

  653.               (3,    '< 010b',    ' 110000000'),
    654. 

  654.               (3,    'x< 010b',    ' 11xxxxxxx'),
    655. 

  655.               (3,    'x< 10b',    ' 11xxxxxxx'),
    656. 

  656.               (3,    'x< 10b',    ' 11xxxxxxx'),
    657. 

  657.               (3,    'x> 10b',    'xxxxxxx 11'),
    658. 

  658.               (3,    'x= 10b',    ' xxxxxxx11'),
    659. 

  659.               (3,    'x^ 10b',    'xxx 11xxxx'),
    660. 

  660.               (3,    'x^ 9b',     'xxx 11xxx'),
    661. 

  661.               (3,    'x<+10b',    '+11xxxxxxx'),
    662. 

  662.               (3,    'x>+10b',    'xxxxxxx+11'),
    663. 

  663.               (3,    'x=+10b',    '+xxxxxxx11'),
    664. 

  664.               (3,    'x^+10b',    'xxx+11xxxx'),
    665. 

  665.               (3,    'x^+9b',     'xxx+11xxx'),
    666. 

  666.               (3,    'x<-10b',    '11xxxxxxxx'),
    667. 

  667.               (3,    'x>-10b',    'xxxxxxxx11'),
    668. 

  668.               (3,    'x=-10b',    'xxxxxxxx11'),
    669. 

  669.               (3,    'x^-10b',    'xxxx11xxxx'),
    670. 

  670.               (3,    'x^-9b',     'xxx11xxxx'),
    671. 

  671.               (-3,   'x<-10b',    '-11xxxxxxx'),
    672. 

  672.               (-3,   'x>-10b',    'xxxxxxx-11'),
    673. 

  673.               (-3,   'x=-10b',    '-xxxxxxx11'),
    674. 

  674.               (-3,   'x^-10b',    'xxx-11xxxx'),
    675. 

  675.               (-3,   'x^-9b',     'xxx-11xxx'),
    676. 

  676.               (-3,   'x<+10b',    '-11xxxxxxx'),
    677. 

  677.               (-3,   'x>+10b',    'xxxxxxx-11'),
    678. 

  678.               (-3,   'x=+10b',    '-xxxxxxx11'),
    679. 

  679.               (-3,   'x^+10b',    'xxx-11xxxx'),
    680. 

  680.               (-3,   'x^+9b',     'xxx-11xxx'),
    681. 

  681.               (-3,   'x< 10b',    '-11xxxxxxx'),
    682. 

  682.               (-3,   'x> 10b',    'xxxxxxx-11'),
    683. 

  683.               (-3,   'x= 10b',    '-xxxxxxx11'),
    684. 

  684.               (-3,   'x^ 10b',    'xxx-11xxxx'),
    685. 

  685.               (-3,   'x^ #10b',   'xx-0b11xxx'),
    686. 

  686.               (-3,   'x^ 9b',     'xxx-11xxx'),
    687. 

  687.               (3,    '\0^ 9b',    '    11   '),   
    688. 

  688.               (-2147483648, 'b',  '-10000000000000000000000000000000'),
    689. 

  689.               (0,      'b',  '0'),
    690. 

  690.               
    691. 

  691.               (9,    'o',         '11'),
    692. 

  692.               (9,    '+o',        '+11'),
    693. 

  693.               (9,    '-o',        '11'),
    694. 

  694.               (9,    ' o',        ' 11'),
    695. 

  695.               (9,    '<5o',       '11   '),
    696. 

  696.               (9,    '>5o',       '   11'),
    697. 

  697.               (9,    '=5o',       '   11'),
    698. 

  698.               (9,    '^6o',       '  11  '),
    699. 

  699.               (9,    '6o',        '    11'),
    700. 

  700.               (9,    'x< 10o',    ' 11xxxxxxx'),
    701. 

  701.               (9,    'x> 10o',    'xxxxxxx 11'),
    702. 

  702.               (9,    'x= 10o',    ' xxxxxxx11'),
    703. 

  703.               (9,    'x^ 10o',    'xxx 11xxxx'),
    704. 

  704.               (9,    'x^ 9o',     'xxx 11xxx'),
    705. 

  705.               (9,    'x<+10o',    '+11xxxxxxx'),
    706. 

  706.               (9,    'x>+10o',    'xxxxxxx+11'),
    707. 

  707.               (9,    'x=+10o',    '+xxxxxxx11'),
    708. 

  708.               (9,    'x^+10o',    'xxx+11xxxx'),
    709. 

  709.               (9,    'x^+9o',     'xxx+11xxx'),
    710. 

  710.               (9,    'x<-10o',    '11xxxxxxxx'),
    711. 

  711.               (9,    'x>-10o',    'xxxxxxxx11'),
    712. 

  712.               (9,    'x=-10o',    'xxxxxxxx11'),
    713. 

  713.               (9,    'x^-10o',    'xxxx11xxxx'),
    714. 

  714.               (9,    'x^-9o',     'xxx11xxxx'),
    715. 

  715.               (-9,   'x<-10o',    '-11xxxxxxx'),
    716. 

  716.               (-9,   'x>-10o',    'xxxxxxx-11'),
    717. 

  717.               (-9,   'x=-10o',   '-xxxxxxx11'),
    718. 

  718.               (-9,   'x^-10o',    'xxx-11xxxx'),
    719. 

  719.               (-9,   'x^-9o',     'xxx-11xxx'),
    720. 

  720.               (-9,   'x<+10o',    '-11xxxxxxx'),
    721. 

  721.               (-9,   'x>+10o',    'xxxxxxx-11'),
    722. 

  722.               (-9,   'x=+10o',   '-xxxxxxx11'),
    723. 

  723.               (-9,   'x^+10o',    'xxx-11xxxx'),
    724. 

  724.               (-9,   'x^+9o',     'xxx-11xxx'),
    725. 

  725.               (-9,   'x< 10o',    '-11xxxxxxx'),
    726. 

  726.               (-9,   'x< #10o',    '-0o11xxxxx'),
    727. 

  727.               (-9,   'x> 10o',    'xxxxxxx-11'),
    728. 

  728.               (-9,   'x= 10o',   '-xxxxxxx11'),
    729. 

  729.               (-9,   'x^ 10o',    'xxx-11xxxx'),
    730. 

  730.               (-9,   'x^ 9o',     'xxx-11xxx'),
    731. 

  731.               (9,    '\0^ 9o',    '    11   '),
    732. 

  732.               (-9,   'x^ 9o',     'xxx-11xxx'),              
    733. 

  733.               
    734. 

  734.               (-2147483648, 'o',  '-20000000000'),
    735. 

  735.               (-42,         'o',  '-52'),
    736. 

  736.               (42,          'o',  '52'),
    737. 

  737.               (0,           'o',  '0'),
    738. 

  738. 

  739.               (-2147483648, 'X',  '-80000000'),
    740. 

  740.               (-2147483648, 'x',  '-80000000'),
    741. 

  741.               (-42,         'X',  '-2A'),
    742. 

  742.               (-42,         'x',  '-2a'),
    743. 

  743.               (42,          'X',  '2A'),
    744. 

  744.               (42,          'x',  '2a'),
    745. 

  745.               (2147483647,  'X',  '7FFFFFFF'),
    746. 

  746.               (0,           'x',  '0'),
    747. 

  747.               (2147483647,  'x',  '7fffffff'),
    748. 

  748.               (2147483647,  '#x',  '0x7fffffff'),
    749. 

  749.               (2147483647,  '#X',  '0X7FFFFFFF'),
    750. 

  750.               
    751. 

  751.               (2147483647, 'f',  '2147483647.000000'),
    752. 

  752.               (2147483647, '%', '214748364700.000000%'),
    753. 

  753. 

  754.               (999999,     '-g',  '999999'),
    755. 

  755.               (999999,     '+g',  '+999999'),
    756. 

  756.               (999999,     ' g',  ' 999999'),
    757. 

  757.               (999999,     'g',  '999999'),
    758. 

  758.               (999999 ,    'G',  '999999'),
    759. 

  759.               (-999999,    'g',  '-999999'),
    760. 

  760.               (-999999 ,   'G',  '-999999'),
    761. 

  761.               (100000,     'g',  '100000'),
    762. 

  762.               (100000,     'G',  '100000'),
    763. 

  763.               (-1000000,   'g',  '-1e+06'),
    764. 

  764.               (-1000000,   'G',  '-1E+06'),
    765. 

  765.               (1000000,    'g',  '1e+06'),
    766. 

  766.               (1000000,    'G',  '1E+06'),
    767. 

  767.               (10000000,   'g',  '1e+07'),
    768. 

  768.               (10000000,   'G',  '1E+07'),
    769. 

  769.               (100000000,  'g',  '1e+08'),
    770. 

  770.               (100000000,  'G',  '1E+08'),           
    771. 

  771.               (1000000,    '10g',  '     1e+06'),
    772. 

  772.               (1000000,    '10G',  '     1E+06'),
    773. 

  773.               (10000000,   '10g',  '     1e+07'),
    774. 

  774.               (10000000,   '10G',  '     1E+07'),
    775. 

  775.               (100000000,  '10g',  '     1e+08'),
    776. 

  776.               (100000000,  '10G',  '     1E+08'),           
    777. 

  777.               (110000000,  'g',  '1.1e+08'),
    778. 

  778.               (110000000,  'G',  '1.1E+08'),           
    779. 

  779.               (112000000,  'g',  '1.12e+08'),
    780. 

  780.               (112000000,  'G',  '1.12E+08'),           
    781. 

  781.               (112300000,  'g',  '1.123e+08'),
    782. 

  782.               (112300000,  'G',  '1.123E+08'),           
    783. 

  783.               (112340000,  'g',  '1.1234e+08'),
    784. 

  784.               (112340000,  'G',  '1.1234E+08'),           
    785. 

  785.               (112345000,  'g',  '1.12345e+08'),
    786. 

  786.               (112345000,  'G',  '1.12345E+08'),           
    787. 

  787.               (112345600,  'g',  '1.12346e+08'),
    788. 

  788.               (112345600,  'G',  '1.12346E+08'),           
    789. 

  789.               (112345500,  'g',  '1.12346e+08'),
    790. 

  790.               (112345500,  'G',  '1.12346E+08'),           
    791. 

  791.               (112345510,  'g',  '1.12346e+08'),
    792. 

  792.               (112345510,  'G',  '1.12346E+08'),           
    793. 

  793.               (112345400,  'g',  '1.12345e+08'),
    794. 

  794.               (112345400,  'G',  '1.12345E+08'),           
    795. 

  795.               (112345401,  'g',  '1.12345e+08'),
    796. 

  796.               (112345401,  'G',  '1.12345E+08'),           
    797. 

  797.               (-112345000,  'g',  '-1.12345e+08'),
    798. 

  798.               (-112345000,  'G',  '-1.12345E+08'),           
    799. 

  799.               (-112345600,  'g',  '-1.12346e+08'),
    800. 

  800.               (-112345600,  'G',  '-1.12346E+08'),           
    801. 

  801.               (-112345500,  'g',  '-1.12346e+08'),
    802. 

  802.               (-112345500,  'G',  '-1.12346E+08'),           
    803. 

  803.               (-112345510,  'g',  '-1.12346e+08'),
    804. 

  804.               (-112345510,  'G',  '-1.12346E+08'),           
    805. 

  805.               (-112345400,  'g',  '-1.12345e+08'),
    806. 

  806.               (-112345400,  'G',  '-1.12345E+08'),           
    807. 

  807.               (-112345401,  'g',  '-1.12345e+08'),
    808. 

  808.               (-112345401,  'G',  '-1.12345E+08'),           
    809. 

  809. 

  810.               (2147483647, 'g',  '2.14748e+09'),
    811. 

  811.               (2147483647, 'G',  '2.14748E+09'),
    812. 

  812.               (-2147483647, 'g',  '-2.14748e+09'),
    813. 

  813.               (-2147483647, 'G',  '-2.14748E+09'),
    814. 

  814.               
    815. 

  815.               (2147483647, 'e',  '2.147484e+09'),
    816. 

  816.               (100000,     'e',  '1.000000e+05'),
    817. 

  817.               (100000,     'E',  '1.000000E+05'),
    818. 

  818.               (10000000,   'E',  '1.000000E+07'),
    819. 

  819.               (100000000,  'e',  '1.000000e+08'),
    820. 

  820.               (100000000,  'E',  '1.000000E+08'),           
    821. 

  821.               (110000000,  'e',  '1.100000e+08'),
    822. 

  822.               (110000000,  'E',  '1.100000E+08'),           
    823. 

  823.               (112000000,  'e',  '1.120000e+08'),
    824. 

  824.               (112000000,  'E',  '1.120000E+08'),           
    825. 

  825.               (112300000,  'e',  '1.123000e+08'),
    826. 

  826.               (112300000,  'E',  '1.123000E+08'),           
    827. 

  827.               (112340000,  'e',  '1.123400e+08'),
    828. 

  828.               (112340000,  'E',  '1.123400E+08'),           
    829. 

  829.               (112345000,  'e',  '1.123450e+08'),
    830. 

  830.               (112345000,  'E',  '1.123450E+08'),           
    831. 

  831.               (1112345600, 'e',  '1.112346e+09'),
    832. 

  832.               (1112345600, 'E',  '1.112346E+09'),           
    833. 

  833.               (1112345500, 'e',  '1.112346e+09'),
    834. 

  834.               (1112345500, 'E',  '1.112346E+09'),           
    835. 

  835.               (1112345510, 'e',  '1.112346e+09'),
    836. 

  836.               (1112345510, 'E',  '1.112346E+09'),           
    837. 

  837.               (1112345400, 'e',  '1.112345e+09'),
    838. 

  838.               (1112345400, 'E',  '1.112345E+09'),           
    839. 

  839.               (1112345401, 'e',  '1.112345e+09'),
    840. 

  840.               (1112345401, 'E',  '1.112345E+09'),           
    841. 

  841.               
    842. 

  842.               (100000,     'n',  '100000'),
    843. 

  843.             ]
    844. 

  844. 

  845.     for value, spec, result in tests:
    846. 

  846.         AreEqual(value.__format__(spec), result)
    847. 

  847.     
    848. 

  848.     # check locale specific formatting
    849. 

  849.     import _locale
    850. 

  850.     try:
    851. 

  851.         if is_cli:
    852. 

  852.             _locale.setlocale(_locale.LC_ALL, 'en_US')
    853. 

  853.         else:
    854. 

  854.             _locale.setlocale(_locale.LC_ALL, 'English_United States.1252')
    855. 

  855.         x = 100000
    856. 

  856.         AreEqual(x.__format__('n'), '100,000')
    857. 

  857.     finally:
    858. 

  858.         # and restore it back...
    859. 

  859.         _locale.setlocale(_locale.LC_ALL, 'C')
    860. 

  860.         AreEqual(x.__format__('n'), '100000')
    861. 

  861. 

  862. def test_int___format___errors():
    863. 

  863.     errors = [
    864. 

  864.                 (ValueError, 2, '6.1', "Precision not allowed in integer format specifier"),
    865. 

  865.                 (ValueError, 2, '+c', "Sign not allowed with integer format specifier 'c'"),
    866. 

  866.                 (ValueError, 2, '-c', "Sign not allowed with integer format specifier 'c'"),
    867. 

  867.                 (ValueError, 2, ' c', "Sign not allowed with integer format specifier 'c'"),
    868. 

  868.                 (OverflowError, -2, 'c', "%c arg not in range(0x10000)"),
    869. 

  869.                 #(-2, 'c', ),
    870. 

  870.                 #(-2, '%', "Sign not allowed with integer format specifier 'c'"),
    871. 

  871.              ]
    872. 

  872.     
    873. 

  873.     okChars = set(['%', 'E', 'F', 'G', 'X', 'x', 'b', 'c', 'd', 'o', 'e', 'f', 'g', 'n', ','])
    874. 

  874. 

  875.     # verify the okChars are actually ok
    876. 

  876.     for char in okChars:
    877. 

  877.         (2).__format__('10' + char)
    878. 

  878.     
    879. 

  879.     for char in allChars:
    880. 

  880.         if char not in okChars and (char < '0' or char > '9'):
    881. 

  881.             errors.append((ValueError, 2, '10' + char, "Unknown format code '%s'" % char))
    882. 

  882. 

  883.     for error, value, errorFmt, errorMsg in errors:
    884. 

  884.         AssertErrorWithPartialMessage(error, errorMsg, value.__format__, errorFmt)
    885. 

  885. 

  886. @skip("posix") # mono doesn't support some of the formatting specifiers https://github.com/IronLanguages/main/issues/1598
    887. 

  887. def test_long___format__():
    888. 

  888.     tests = [ 
    889. 

  889.               (0L,    '+',        '+0'),
    890. 

  890.               (0L,    ' ',        ' 0'),
    891. 

  891.               (0L,    '-',        '0'),
    892. 

  892.               (2L,    '',         '2'),
    893. 

  893.               (2L,    '+',        '+2'),
    894. 

  894.               (2L,    '-',        '2'),
    895. 

  895.               (2L,    ' ',        ' 2'),
    896. 

  896.               (2L,    '<5',       '2    '),
    897. 

  897.               (2L,    '>5',       '    2'),
    898. 

  898.               (2L,    '=5',       '    2'),
    899. 

  899.               (2L,    '^6',       '  2   '),
    900. 

  900.               (2L,    '6',        '     2'),
    901. 

  901.               (2L,    'x< 10',    ' 2xxxxxxxx'),
    902. 

  902.               (2L,    'x> 10',    'xxxxxxxx 2'),
    903. 

  903.               (2L,    'x= 10',    ' xxxxxxxx2'),
    904. 

  904.               (2L,    'x^ 10',    'xxxx 2xxxx'),
    905. 

  905.               (2L,    'x^ 9',     'xxx 2xxxx'),
    906. 

  906.               (2L,    'x<+10',    '+2xxxxxxxx'),
    907. 

  907.               (2L,    'x>+10',    'xxxxxxxx+2'),
    908. 

  908.               (2L,    'x=+10',    '+xxxxxxxx2'),
    909. 

  909.               (2L,    'x^+10',    'xxxx+2xxxx'),
    910. 

  910.               (2L,    'x^+9',     'xxx+2xxxx'),
    911. 

  911.               (2L,    'x<-10',    '2xxxxxxxxx'),
    912. 

  912.               (2L,    'x>-10',    'xxxxxxxxx2'),
    913. 

  913.               (2L,    'x=-10',    'xxxxxxxxx2'),
    914. 

  914.               (2L,    'x^-10',    'xxxx2xxxxx'),
    915. 

  915.               (2L,    'x^-9',     'xxxx2xxxx'),
    916. 

  916.               (-2L,   'x<-10',    '-2xxxxxxxx'),
    917. 

  917.               (-2L,   'x>-10',    'xxxxxxxx-2'),
    918. 

  918.               (-2L,   'x=-10',   '-xxxxxxxx2'),
    919. 

  919.               (-2L,   'x^-10',    'xxxx-2xxxx'),
    920. 

  920.               (-2L,   'x^-9',     'xxx-2xxxx'),
    921. 

  921.               (-2L,   'x<+10',    '-2xxxxxxxx'),
    922. 

  922.               (-2L,   'x>+10',    'xxxxxxxx-2'),
    923. 

  923.               (-2L,   'x=+10',   '-xxxxxxxx2'),
    924. 

  924.               (-2L,   'x^+10',    'xxxx-2xxxx'),
    925. 

  925.               (-2L,   'x^+9',     'xxx-2xxxx'),
    926. 

  926.               (-2L,   'x< 10',    '-2xxxxxxxx'),
    927. 

  927.               (-2L,   'x> 10',    'xxxxxxxx-2'),
    928. 

  928.               (-2L,   'x= 10',   '-xxxxxxxx2'),
    929. 

  929.               (-2L,   'x^ 10',    'xxxx-2xxxx'),
    930. 

  930.               (-2L,   'x^ 9',     'xxx-2xxxx'),
    931. 

  931.               (2L,    '\0^ 9',    '    2    '),
    932. 

  932. 

  933.               (2L,    'c',         '\x02'),
    934. 

  934.               (2L,    '<5c',       '\x02    '),
    935. 

  935.               (2L,    '>5c',       '    \x02'),
    936. 

  936.               (2L,    '=5c',       '    \x02'),
    937. 

  937.               (2L,    '^6c',       '  \x02   '),
    938. 

  938.               (2L,    '6c',        '     \x02'),
    939. 

  939.               
    940. 

  940.               (3L,    'b',         '11'),
    941. 

  941.               (3L,    '+b',        '+11'),
    942. 

  942.               (3L,    '-b',        '11'),
    943. 

  943.               (3L,    ' b',        ' 11'),
    944. 

  944.               (3L,    '<5b',       '11   '),
    945. 

  945.               (3L,    '>5b',       '   11'),
    946. 

  946.               (3L,    '=5b',       '   11'),
    947. 

  947.               (3L,    '^6b',       '  11  '),
    948. 

  948.               (3L,    '6b',        '    11'),
    949. 

  949.               (3L,    'x< 010b',   ' 11xxxxxxx'),
    950. 

  950.               (3L,    '< 010b',    ' 110000000'),
    951. 

  951.               (3L,    'x< 010b',    ' 11xxxxxxx'),
    952. 

  952.               (3L,    'x< 10b',    ' 11xxxxxxx'),
    953. 

  953.               (3L,    'x< 10b',    ' 11xxxxxxx'),
    954. 

  954.               (3L,    'x> 10b',    'xxxxxxx 11'),
    955. 

  955.               (3L,    'x= 10b',    ' xxxxxxx11'),
    956. 

  956.               (3L,    'x^ 10b',    'xxx 11xxxx'),
    957. 

  957.               (3L,    'x^ 9b',     'xxx 11xxx'),
    958. 

  958.               (3L,    'x<+10b',    '+11xxxxxxx'),
    959. 

  959.               (3L,    'x>+10b',    'xxxxxxx+11'),
    960. 

  960.               (3L,    'x=+10b',    '+xxxxxxx11'),
    961. 

  961.               (3L,    'x^+10b',    'xxx+11xxxx'),
    962. 

  962.               (3L,    'x^+9b',     'xxx+11xxx'),
    963. 

  963.               (3L,    'x<-10b',    '11xxxxxxxx'),
    964. 

  964.               (3L,    'x>-10b',    'xxxxxxxx11'),
    965. 

  965.               (3L,    'x=-10b',    'xxxxxxxx11'),
    966. 

  966.               (3L,    'x^-10b',    'xxxx11xxxx'),
    967. 

  967.               (3L,    'x^-9b',     'xxx11xxxx'),
    968. 

  968.               (-3L,   'x<-10b',    '-11xxxxxxx'),
    969. 

  969.               (-3L,   'x>-10b',    'xxxxxxx-11'),
    970. 

  970.               (-3L,   'x=-10b',    '-xxxxxxx11'),
    971. 

  971.               (-3L,   'x^-10b',    'xxx-11xxxx'),
    972. 

  972.               (-3L,   'x^-9b',     'xxx-11xxx'),
    973. 

  973.               (-3L,   'x<+10b',    '-11xxxxxxx'),
    974. 

  974.               (-3L,   'x>+10b',    'xxxxxxx-11'),
    975. 

  975.               (-3L,   'x=+10b',    '-xxxxxxx11'),
    976. 

  976.               (-3L,   'x^+10b',    'xxx-11xxxx'),
    977. 

  977.               (-3L,   'x^+9b',     'xxx-11xxx'),
    978. 

  978.               (-3L,   'x< 10b',    '-11xxxxxxx'),
    979. 

  979.               (-3L,   'x> 10b',    'xxxxxxx-11'),
    980. 

  980.               (-3L,   'x= 10b',    '-xxxxxxx11'),
    981. 

  981.               (-3L,   'x^ 10b',    'xxx-11xxxx'),
    982. 

  982.               (-3L,   'x^ #10b',   'xx-0b11xxx'),
    983. 

  983.               (-3L,   'x^ 9b',     'xxx-11xxx'),
    984. 

  984.               (3L,    '\0^ 9b',    '    11   '),   
    985. 

  985.               (-2147483648L, 'b',  '-10000000000000000000000000000000'),
    986. 

  986.               (0L,      'b',  '0'),
    987. 

  987.               
    988. 

  988.               (9L,    'o',         '11'),
    989. 

  989.               (9L,    '+o',        '+11'),
    990. 

  990.               (9L,    '-o',        '11'),
    991. 

  991.               (9L,    ' o',        ' 11'),
    992. 

  992.               (9L,    '<5o',       '11   '),
    993. 

  993.               (9L,    '>5o',       '   11'),
    994. 

  994.               (9L,    '=5o',       '   11'),
    995. 

  995.               (9L,    '^6o',       '  11  '),
    996. 

  996.               (9L,    '6o',        '    11'),
    997. 

  997.               (9L,    'x< 10o',    ' 11xxxxxxx'),
    998. 

  998.               (9L,    'x> 10o',    'xxxxxxx 11'),
    999. 

  999.               (9L,    'x= 10o',    ' xxxxxxx11'),
    1000. 

  1000.               (9L,    'x^ 10o',    'xxx 11xxxx'),
    1001. 

  1001.               (9L,    'x^ 9o',     'xxx 11xxx'),
    1002. 

  1002.               (9L,    'x<+10o',    '+11xxxxxxx'),
    1003. 

  1003.               (9L,    'x>+10o',    'xxxxxxx+11'),
    1004. 

  1004.               (9L,    'x=+10o',    '+xxxxxxx11'),
    1005. 

  1005.               (9L,    'x^+10o',    'xxx+11xxxx'),
    1006. 

  1006.               (9L,    'x^+9o',     'xxx+11xxx'),
    1007. 

  1007.               (9L,    'x<-10o',    '11xxxxxxxx'),
    1008. 

  1008.               (9L,    'x>-10o',    'xxxxxxxx11'),
    1009. 

  1009.               (9L,    'x=-10o',    'xxxxxxxx11'),
    1010. 

  1010.               (9L,    'x^-10o',    'xxxx11xxxx'),
    1011. 

  1011.               (9L,    'x^-9o',     'xxx11xxxx'),
    1012. 

  1012.               (-9L,   'x<-10o',    '-11xxxxxxx'),
    1013. 

  1013.               (-9L,   'x>-10o',    'xxxxxxx-11'),
    1014. 

  1014.               (-9L,   'x=-10o',   '-xxxxxxx11'),
    1015. 

  1015.               (-9L,   'x^-10o',    'xxx-11xxxx'),
    1016. 

  1016.               (-9L,   'x^-9o',     'xxx-11xxx'),
    1017. 

  1017.               (-9L,   'x<+10o',    '-11xxxxxxx'),
    1018. 

  1018.               (-9L,   'x>+10o',    'xxxxxxx-11'),
    1019. 

  1019.               (-9L,   'x=+10o',   '-xxxxxxx11'),
    1020. 

  1020.               (-9L,   'x^+10o',    'xxx-11xxxx'),
    1021. 

  1021.               (-9L,   'x^+9o',     'xxx-11xxx'),
    1022. 

  1022.               (-9L,   'x< 10o',    '-11xxxxxxx'),
    1023. 

  1023.               (-9L,   'x< #10o',    '-0o11xxxxx'),
    1024. 

  1024.               (-9L,   'x> 10o',    'xxxxxxx-11'),
    1025. 

  1025.               (-9L,   'x= 10o',   '-xxxxxxx11'),
    1026. 

  1026.               (-9L,   'x^ 10o',    'xxx-11xxxx'),
    1027. 

  1027.               (-9L,   'x^ 9o',     'xxx-11xxx'),
    1028. 

  1028.               (9L,    '\0^ 9o',    '    11   '),
    1029. 

  1029.               (-9L,   'x^ 9o',     'xxx-11xxx'),              
    1030. 

  1030.               
    1031. 

  1031.               (-2147483648L, 'o',  '-20000000000'),
    1032. 

  1032.               (-42L,         'o',  '-52'),
    1033. 

  1033.               (0,            'o',  '0'),
    1034. 

  1034.               (42L,          'o',  '52'),
    1035. 

  1035. 

  1036.               (0,            'x',  '0'),
    1037. 

  1037.               (-2147483648L, 'X',  '-80000000'),
    1038. 

  1038.               (-2147483648L, 'x',  '-80000000'),
    1039. 

  1039.               (-42L,         'X',  '-2A'),
    1040. 

  1040.               (-42L,         'x',  '-2a'),
    1041. 

  1041.               (42L,          'X',  '2A'),
    1042. 

  1042.               (42L,          'x',  '2a'),
    1043. 

  1043.               (2147483647L,  'X',  '7FFFFFFF'),
    1044. 

  1044.               (2147483647L,  'x',  '7fffffff'),
    1045. 

  1045.               (2147483647L,  '#x',  '0x7fffffff'),
    1046. 

  1046.               (2147483647L,  '#X',  '0X7FFFFFFF'),
    1047. 

  1047.               
    1048. 

  1048.               (2147483647L, 'f',  '2147483647.000000'),
    1049. 

  1049.               (2147483647L, '%', '214748364700.000000%'),
    1050. 

  1050. 

  1051.               (999999L,     '-g',  '999999'),
    1052. 

  1052.               (999999L,     '+g',  '+999999'),
    1053. 

  1053.               (999999L,     ' g',  ' 999999'),
    1054. 

  1054.               (999999L,     'g',  '999999'),
    1055. 

  1055.               (999999L,    'G',  '999999'),
    1056. 

  1056.               (-999999L,    'g',  '-999999'),
    1057. 

  1057.               (-999999L,   'G',  '-999999'),
    1058. 

  1058.               (100000L,     'g',  '100000'),
    1059. 

  1059.               (100000L,     'G',  '100000'),
    1060. 

  1060.               (-1000000L,   'g',  '-1e+06'),
    1061. 

  1061.               (-1000000L,   'G',  '-1E+06'),
    1062. 

  1062.               (1000000L,    'g',  '1e+06'),
    1063. 

  1063.               (1000000L,    'G',  '1E+06'),
    1064. 

  1064.               (10000000L,   'g',  '1e+07'),
    1065. 

  1065.               (10000000L,   'G',  '1E+07'),
    1066. 

  1066.               (100000000L,  'g',  '1e+08'),
    1067. 

  1067.               (100000000L,  'G',  '1E+08'),           
    1068. 

  1068.               (1000000L,    '10g',  '     1e+06'),
    1069. 

  1069.               (1000000L,    '10G',  '     1E+06'),
    1070. 

  1070.               (10000000L,   '10g',  '     1e+07'),
    1071. 

  1071.               (10000000L,   '10G',  '     1E+07'),
    1072. 

  1072.               (10200000L,   '10G',  '  1.02E+07'),
    1073. 

  1073.               (100000000L,  '10g',  '     1e+08'),
    1074. 

  1074.               (100000000L,  '10G',  '     1E+08'),           
    1075. 

  1075.               (110000000L,  'g',  '1.1e+08'),
    1076. 

  1076.               (110000000L,  'G',  '1.1E+08'),           
    1077. 

  1077.               (112000000L,  'g',  '1.12e+08'),
    1078. 

  1078.               (112000000L,  'G',  '1.12E+08'),           
    1079. 

  1079.               (112300000L,  'g',  '1.123e+08'),
    1080. 

  1080.               (112300000L,  'G',  '1.123E+08'),           
    1081. 

  1081.               (112340000L,  'g',  '1.1234e+08'),
    1082. 

  1082.               (112340000L,  'G',  '1.1234E+08'),           
    1083. 

  1083.               (112345000L,  'g',  '1.12345e+08'),
    1084. 

  1084.               (112345000L,  'G',  '1.12345E+08'),           
    1085. 

  1085.               (112345600L,  'g',  '1.12346e+08'),
    1086. 

  1086.               (112345600L,  'G',  '1.12346E+08'),           
    1087. 

  1087.               (112345500L,  'g',  '1.12346e+08'),
    1088. 

  1088.               (112345500L,  'G',  '1.12346E+08'),           
    1089. 

  1089.               (112345510L,  'g',  '1.12346e+08'),
    1090. 

  1090.               (112345510L,  'G',  '1.12346E+08'),           
    1091. 

  1091.               (112345400L,  'g',  '1.12345e+08'),
    1092. 

  1092.               (112345400L,  'G',  '1.12345E+08'),           
    1093. 

  1093.               (112345401L,  'g',  '1.12345e+08'),
    1094. 

  1094.               (112345401L,  'G',  '1.12345E+08'),           
    1095. 

  1095.               (-112345000L,  'g',  '-1.12345e+08'),
    1096. 

  1096.               (-112345000L,  'G',  '-1.12345E+08'),           
    1097. 

  1097.               (-112345600L,  'g',  '-1.12346e+08'),
    1098. 

  1098.               (-112345600L,  'G',  '-1.12346E+08'),           
    1099. 

  1099.               (-112345500L,  'g',  '-1.12346e+08'),
    1100. 

  1100.               (-112345500L,  'G',  '-1.12346E+08'),           
    1101. 

  1101.               (-112345510L,  'g',  '-1.12346e+08'),
    1102. 

  1102.               (-112345510L,  'G',  '-1.12346E+08'),           
    1103. 

  1103.               (-112345400L,  'g',  '-1.12345e+08'),
    1104. 

  1104.               (-112345400L,  'G',  '-1.12345E+08'),           
    1105. 

  1105.               (-112345401L,  'g',  '-1.12345e+08'),
    1106. 

  1106.               (-112345401L,  'G',  '-1.12345E+08'),           
    1107. 

  1107. 

  1108.               (2147483647L, 'g',  '2.14748e+09'),
    1109. 

  1109.               (2147483647L, 'G',  '2.14748E+09'),
    1110. 

  1110.               (-2147483647L, 'g',  '-2.14748e+09'),
    1111. 

  1111.               (-2147483647L, 'G',  '-2.14748E+09'),
    1112. 

  1112.               
    1113. 

  1113.               (2147483647L, 'e',  '2.147484e+09'),
    1114. 

  1114.               (100000L,     'e',  '1.000000e+05'),
    1115. 

  1115.               (100000L,     'E',  '1.000000E+05'),
    1116. 

  1116.               (10000000L,   'E',  '1.000000E+07'),
    1117. 

  1117.               (100000000L,  'e',  '1.000000e+08'),
    1118. 

  1118.               (100000000L,  'E',  '1.000000E+08'),           
    1119. 

  1119.               (110000000L,  'e',  '1.100000e+08'),
    1120. 

  1120.               (110000000L,  'E',  '1.100000E+08'),           
    1121. 

  1121.               (112000000L,  'e',  '1.120000e+08'),
    1122. 

  1122.               (112000000L,  'E',  '1.120000E+08'),           
    1123. 

  1123.               (112300000L,  'e',  '1.123000e+08'),
    1124. 

  1124.               (112300000L,  'E',  '1.123000E+08'),           
    1125. 

  1125.               (112340000L,  'e',  '1.123400e+08'),
    1126. 

  1126.               (112340000L,  'E',  '1.123400E+08'),           
    1127. 

  1127.               (112345000L,  'e',  '1.123450e+08'),
    1128. 

  1128.               (112345000L,  'E',  '1.123450E+08'),           
    1129. 

  1129.               (1112345600L, 'e',  '1.112346e+09'),
    1130. 

  1130.               (1112345600L, 'E',  '1.112346E+09'),           
    1131. 

  1131.               (1112345500L, 'e',  '1.112346e+09'),
    1132. 

  1132.               (1112345500L, 'E',  '1.112346E+09'),           
    1133. 

  1133.               (1112345510L, 'e',  '1.112346e+09'),
    1134. 

  1134.               (1112345510L, 'E',  '1.112346E+09'),           
    1135. 

  1135.               (1112345400L, 'e',  '1.112345e+09'),
    1136. 

  1136.               (1112345400L, 'E',  '1.112345E+09'),           
    1137. 

  1137.               (1112345401L, 'e',  '1.112345e+09'),
    1138. 

  1138.               (1112345401L, 'E',  '1.112345E+09'),           
    1139. 

  1139.               (111234540100L, 'E',  '1.112345E+11'),           
    1140. 

  1140.               
    1141. 

  1141.               (100000L,     'n',  '100000'),
    1142. 

  1142.             ]
    1143. 

  1143. 

  1144.     for value, spec, result in tests:
    1145. 

  1145.         AreEqual(value.__format__(spec), result)
    1146. 

  1146.     
    1147. 

  1147.     # check locale specific formatting
    1148. 

  1148.     import _locale
    1149. 

  1149.     try:
    1150. 

  1150.         if is_cli:
    1151. 

  1151.             _locale.setlocale(_locale.LC_ALL, 'en_US')
    1152. 

  1152.         else:
    1153. 

  1153.             _locale.setlocale(_locale.LC_ALL, 'English_United States.1252')
    1154. 

  1154.         AreEqual(100000L.__format__('n'), '100,000')
    1155. 

  1155.         AreEqual(100000000L.__format__('n'), '100,000,000')
    1156. 

  1156.     finally:
    1157. 

  1157.         # and restore it back...
    1158. 

  1158.         _locale.setlocale(_locale.LC_ALL, 'C')
    1159. 

  1159.         AreEqual(100000L.__format__('n'), '100000')
    1160. 

  1160.         AreEqual(100000000L.__format__('n'), '100000000')
    1161. 

  1161. 

  1162. @skip("posix") # mono doesn't support some of the formatting specifiers https://github.com/IronLanguages/main/issues/1598
    1163. 

  1163. def test_long___format___errors():
    1164. 

  1164.     errors = [
    1165. 

  1165.                 (ValueError, 2L, '6.1', "Precision not allowed in integer format specifier"),
    1166. 

  1166.                 (ValueError, 2L, '+c', "Sign not allowed with integer format specifier 'c'"),
    1167. 

  1167.                 (ValueError, 2L, '-c', "Sign not allowed with integer format specifier 'c'"),
    1168. 

  1168.                 (ValueError, 2L, ' c', "Sign not allowed with integer format specifier 'c'"),
    1169. 

  1169.                 (OverflowError, -2L, 'c', "%c arg not in range(0x10000)"),
    1170. 

  1170.                 (OverflowError, 1000000L, 'c', "%c arg not in range(0x10000)"),
    1171. 

  1171.              ]
    1172. 

  1172.     
    1173. 

  1173.     if not is_cpython: #http://ironpython.codeplex.com/workitem/28373
    1174. 

  1174.         errors.append((OverflowError, sys.maxint + 1, 'c', "long int too large to convert to int"))
    1175. 

  1175.     else:
    1176. 

  1176.         errors.append((OverflowError, sys.maxint + 1, 'c', "Python int too large to convert to C long"))
    1177. 

  1177. 

  1178.     okChars = set(['%', 'E', 'F', 'G', 'X', 'x', 'b', 'c', 'd', 'o', 'e', 'f', 'g', 'n', ','])
    1179. 

  1179.     
    1180. 

  1180.     # verify the okChars are actually ok
    1181. 

  1181.     for char in okChars:
    1182. 

  1182.         (2L).__format__('10' + char)
    1183. 

  1183. 

  1184.     for char in allChars:
    1185. 

  1185.         if char not in okChars and (char < '0' or char > '9'):
    1186. 

  1186.             errors.append((ValueError, 2L, '10' + char, "Unknown format code '%s'" % char))
    1187. 

  1187. 

  1188.     for exceptionType, value, errorFmt, errorMsg in errors:
    1189. 

  1189.         AssertErrorWithPartialMessage(exceptionType, errorMsg, value.__format__, errorFmt)
    1190. 

  1190. 

  1191. 

  1192. def test_builtin_types_that_implement_format():
    1193. 

  1193.     import __builtin__
    1194. 

  1194.     types = [getattr(__builtin__, typeName) for typeName in dir(__builtin__) if type(getattr(__builtin__, typeName)) is type]
    1195. 

  1195.     formatTypes = list(set([builtinType.__name__ for builtinType in types if '__format__' in builtinType.__dict__]))
    1196. 

  1196.     
    1197. 

  1197.     formatTypes.sort()
    1198. 

  1198.     if is_cli:
    1199. 

  1199.         # no unicode
    1200. 

  1200.         # why does bool have __format__ in ipy?
    1201. 

  1201.         AreEqual(formatTypes, ['bool', 'complex', 'float', 'int', 'long', 'object', 'str'])
    1202. 

  1202.     else:
    1203. 

  1203.         AreEqual(formatTypes, ['complex', 'float', 'int', 'long', 'object', 'str', 'unicode'])
    1204. 

  1204.     
    1205. 

  1205. 

  1206. def test_computed_format():
    1207. 

  1207.     AreEqual("|{0:10}|".format("a"), "|a         |")
    1208. 

  1208.     AreEqual("|{0:*^10}|".format("a"), "|****a*****|")
    1209. 

  1209.     AreEqual("|{0:*^{1}}|".format("a", 10), "|****a*****|")
    1210. 

  1210.     AreEqual("{0:*{2}10}".format("a", "*", "^", "10"), "****a*****")
    1211. 

  1211.     AreEqual("{0:{1}^{3}}".format("a", "*", "^", "10"), "****a*****")
    1212. 

  1212.     AreEqual("{0:{1}{2}{3}}".format("a", "*", "^", "10"), "****a*****")
    1213. 

  1213.     AreEqual("{0:{1}*^{2}}".format("a", "", "10"), "****a*****")
    1214. 

  1214. 

  1215. def test_none_format():
    1216. 

  1216.     AreEqual("{0} {1}".format(None, 10), "None 10")
    1217. 

  1217.     AreEqual("{0}".format(None), 'None')
    1218. 

  1218. 

  1219. run_test(__name__)
    1220.