Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 1 | import unittest, string |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 2 | from test import support |
Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 3 | |
Raymond Hettinger | 674f241 | 2004-08-23 23:23:54 +0000 | [diff] [blame] | 4 | |
Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 5 | class ModuleTest(unittest.TestCase): |
| 6 | |
| 7 | def test_attrs(self): |
| 8 | string.whitespace |
Martin v. Löwis | 967f1e3 | 2007-08-14 09:23:10 +0000 | [diff] [blame] | 9 | string.ascii_lowercase |
| 10 | string.ascii_uppercase |
| 11 | string.ascii_letters |
Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 12 | string.digits |
| 13 | string.hexdigits |
| 14 | string.octdigits |
| 15 | string.punctuation |
| 16 | string.printable |
| 17 | |
Ezio Melotti | 2c6a949 | 2009-09-26 12:19:30 +0000 | [diff] [blame] | 18 | def test_capwords(self): |
| 19 | self.assertEqual(string.capwords('abc def ghi'), 'Abc Def Ghi') |
| 20 | self.assertEqual(string.capwords('abc\tdef\nghi'), 'Abc Def Ghi') |
| 21 | self.assertEqual(string.capwords('abc\t def \nghi'), 'Abc Def Ghi') |
| 22 | self.assertEqual(string.capwords('ABC DEF GHI'), 'Abc Def Ghi') |
| 23 | self.assertEqual(string.capwords('ABC-DEF-GHI', '-'), 'Abc-Def-Ghi') |
| 24 | self.assertEqual(string.capwords('ABC-def DEF-ghi GHI'), 'Abc-def Def-ghi Ghi') |
Ezio Melotti | a40bdda | 2009-09-26 12:33:22 +0000 | [diff] [blame] | 25 | self.assertEqual(string.capwords(' aBc DeF '), 'Abc Def') |
| 26 | self.assertEqual(string.capwords('\taBc\tDeF\t'), 'Abc Def') |
| 27 | self.assertEqual(string.capwords('\taBc\tDeF\t', '\t'), '\tAbc\tDef\t') |
Ezio Melotti | 2c6a949 | 2009-09-26 12:19:30 +0000 | [diff] [blame] | 28 | |
Nick Coghlan | 62ecb6a | 2011-05-31 19:40:11 +1000 | [diff] [blame] | 29 | def test_basic_formatter(self): |
Eric Smith | 8c66326 | 2007-08-25 02:26:07 +0000 | [diff] [blame] | 30 | fmt = string.Formatter() |
| 31 | self.assertEqual(fmt.format("foo"), "foo") |
Eric Smith | 7ade648 | 2007-08-26 22:27:13 +0000 | [diff] [blame] | 32 | self.assertEqual(fmt.format("foo{0}", "bar"), "foobar") |
| 33 | self.assertEqual(fmt.format("foo{1}{0}-{1}", "bar", 6), "foo6bar-6") |
Serhiy Storchaka | 8ffe917 | 2015-03-24 22:28:43 +0200 | [diff] [blame^] | 34 | self.assertRaises(TypeError, fmt.format) |
| 35 | self.assertRaises(TypeError, string.Formatter.format) |
| 36 | |
| 37 | def test_format_keyword_arguments(self): |
| 38 | fmt = string.Formatter() |
| 39 | self.assertEqual(fmt.format("-{arg}-", arg='test'), '-test-') |
| 40 | self.assertRaises(KeyError, fmt.format, "-{arg}-") |
| 41 | self.assertEqual(fmt.format("-{self}-", self='test'), '-test-') |
| 42 | self.assertRaises(KeyError, fmt.format, "-{self}-") |
| 43 | self.assertEqual(fmt.format("-{format_string}-", format_string='test'), |
| 44 | '-test-') |
| 45 | self.assertRaises(KeyError, fmt.format, "-{format_string}-") |
| 46 | self.assertEqual(fmt.format(arg='test', format_string="-{arg}-"), |
| 47 | '-test-') |
Eric Smith | 7ade648 | 2007-08-26 22:27:13 +0000 | [diff] [blame] | 48 | |
Eric V. Smith | 7ce9074 | 2014-04-14 16:43:50 -0400 | [diff] [blame] | 49 | def test_auto_numbering(self): |
| 50 | fmt = string.Formatter() |
| 51 | self.assertEqual(fmt.format('foo{}{}', 'bar', 6), |
| 52 | 'foo{}{}'.format('bar', 6)) |
| 53 | self.assertEqual(fmt.format('foo{1}{num}{1}', None, 'bar', num=6), |
| 54 | 'foo{1}{num}{1}'.format(None, 'bar', num=6)) |
| 55 | self.assertEqual(fmt.format('{:^{}}', 'bar', 6), |
| 56 | '{:^{}}'.format('bar', 6)) |
| 57 | self.assertEqual(fmt.format('{:^{pad}}{}', 'foo', 'bar', pad=6), |
| 58 | '{:^{pad}}{}'.format('foo', 'bar', pad=6)) |
| 59 | |
| 60 | with self.assertRaises(ValueError): |
| 61 | fmt.format('foo{1}{}', 'bar', 6) |
| 62 | |
| 63 | with self.assertRaises(ValueError): |
| 64 | fmt.format('foo{}{1}', 'bar', 6) |
| 65 | |
Nick Coghlan | 62ecb6a | 2011-05-31 19:40:11 +1000 | [diff] [blame] | 66 | def test_conversion_specifiers(self): |
| 67 | fmt = string.Formatter() |
| 68 | self.assertEqual(fmt.format("-{arg!r}-", arg='test'), "-'test'-") |
| 69 | self.assertEqual(fmt.format("{0!s}", 'test'), 'test') |
| 70 | self.assertRaises(ValueError, fmt.format, "{0!h}", 'test') |
R David Murray | e56bf97 | 2012-08-19 17:26:34 -0400 | [diff] [blame] | 71 | # issue13579 |
| 72 | self.assertEqual(fmt.format("{0!a}", 42), '42') |
| 73 | self.assertEqual(fmt.format("{0!a}", string.ascii_letters), |
| 74 | "'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'") |
| 75 | self.assertEqual(fmt.format("{0!a}", chr(255)), "'\\xff'") |
| 76 | self.assertEqual(fmt.format("{0!a}", chr(256)), "'\\u0100'") |
Nick Coghlan | 62ecb6a | 2011-05-31 19:40:11 +1000 | [diff] [blame] | 77 | |
| 78 | def test_name_lookup(self): |
| 79 | fmt = string.Formatter() |
| 80 | class AnyAttr: |
| 81 | def __getattr__(self, attr): |
| 82 | return attr |
| 83 | x = AnyAttr() |
| 84 | self.assertEqual(fmt.format("{0.lumber}{0.jack}", x), 'lumberjack') |
| 85 | with self.assertRaises(AttributeError): |
| 86 | fmt.format("{0.lumber}{0.jack}", '') |
| 87 | |
| 88 | def test_index_lookup(self): |
| 89 | fmt = string.Formatter() |
| 90 | lookup = ["eggs", "and", "spam"] |
| 91 | self.assertEqual(fmt.format("{0[2]}{0[0]}", lookup), 'spameggs') |
| 92 | with self.assertRaises(IndexError): |
| 93 | fmt.format("{0[2]}{0[0]}", []) |
| 94 | with self.assertRaises(KeyError): |
| 95 | fmt.format("{0[2]}{0[0]}", {}) |
| 96 | |
| 97 | def test_override_get_value(self): |
Eric Smith | 7ade648 | 2007-08-26 22:27:13 +0000 | [diff] [blame] | 98 | class NamespaceFormatter(string.Formatter): |
| 99 | def __init__(self, namespace={}): |
| 100 | string.Formatter.__init__(self) |
| 101 | self.namespace = namespace |
| 102 | |
| 103 | def get_value(self, key, args, kwds): |
| 104 | if isinstance(key, str): |
| 105 | try: |
| 106 | # Check explicitly passed arguments first |
| 107 | return kwds[key] |
| 108 | except KeyError: |
| 109 | return self.namespace[key] |
| 110 | else: |
| 111 | string.Formatter.get_value(key, args, kwds) |
| 112 | |
| 113 | fmt = NamespaceFormatter({'greeting':'hello'}) |
| 114 | self.assertEqual(fmt.format("{greeting}, world!"), 'hello, world!') |
Eric Smith | 8c66326 | 2007-08-25 02:26:07 +0000 | [diff] [blame] | 115 | |
| 116 | |
Nick Coghlan | 62ecb6a | 2011-05-31 19:40:11 +1000 | [diff] [blame] | 117 | def test_override_format_field(self): |
Eric Smith | 8193669 | 2007-08-31 01:14:01 +0000 | [diff] [blame] | 118 | class CallFormatter(string.Formatter): |
| 119 | def format_field(self, value, format_spec): |
| 120 | return format(value(), format_spec) |
| 121 | |
| 122 | fmt = CallFormatter() |
| 123 | self.assertEqual(fmt.format('*{0}*', lambda : 'result'), '*result*') |
| 124 | |
| 125 | |
Nick Coghlan | 62ecb6a | 2011-05-31 19:40:11 +1000 | [diff] [blame] | 126 | def test_override_convert_field(self): |
Eric Smith | 8193669 | 2007-08-31 01:14:01 +0000 | [diff] [blame] | 127 | class XFormatter(string.Formatter): |
| 128 | def convert_field(self, value, conversion): |
| 129 | if conversion == 'x': |
| 130 | return None |
Nick Coghlan | 62ecb6a | 2011-05-31 19:40:11 +1000 | [diff] [blame] | 131 | return super().convert_field(value, conversion) |
Eric Smith | 8193669 | 2007-08-31 01:14:01 +0000 | [diff] [blame] | 132 | |
| 133 | fmt = XFormatter() |
| 134 | self.assertEqual(fmt.format("{0!r}:{0!x}", 'foo', 'foo'), "'foo':None") |
| 135 | |
| 136 | |
Nick Coghlan | 62ecb6a | 2011-05-31 19:40:11 +1000 | [diff] [blame] | 137 | def test_override_parse(self): |
Eric Smith | 8193669 | 2007-08-31 01:14:01 +0000 | [diff] [blame] | 138 | class BarFormatter(string.Formatter): |
| 139 | # returns an iterable that contains tuples of the form: |
| 140 | # (literal_text, field_name, format_spec, conversion) |
| 141 | def parse(self, format_string): |
| 142 | for field in format_string.split('|'): |
| 143 | if field[0] == '+': |
| 144 | # it's markup |
| 145 | field_name, _, format_spec = field[1:].partition(':') |
| 146 | yield '', field_name, format_spec, None |
| 147 | else: |
| 148 | yield field, None, None, None |
| 149 | |
| 150 | fmt = BarFormatter() |
| 151 | self.assertEqual(fmt.format('*|+0:^10s|*', 'foo'), '* foo *') |
| 152 | |
Nick Coghlan | 62ecb6a | 2011-05-31 19:40:11 +1000 | [diff] [blame] | 153 | def test_check_unused_args(self): |
Eric Smith | 3bcc42a | 2007-08-31 02:26:31 +0000 | [diff] [blame] | 154 | class CheckAllUsedFormatter(string.Formatter): |
| 155 | def check_unused_args(self, used_args, args, kwargs): |
Ezio Melotti | 42da663 | 2011-03-15 05:18:48 +0200 | [diff] [blame] | 156 | # Track which arguments actually got used |
Eric Smith | 3bcc42a | 2007-08-31 02:26:31 +0000 | [diff] [blame] | 157 | unused_args = set(kwargs.keys()) |
| 158 | unused_args.update(range(0, len(args))) |
| 159 | |
| 160 | for arg in used_args: |
| 161 | unused_args.remove(arg) |
| 162 | |
| 163 | if unused_args: |
| 164 | raise ValueError("unused arguments") |
| 165 | |
| 166 | fmt = CheckAllUsedFormatter() |
| 167 | self.assertEqual(fmt.format("{0}", 10), "10") |
| 168 | self.assertEqual(fmt.format("{0}{i}", 10, i=100), "10100") |
| 169 | self.assertEqual(fmt.format("{0}{i}{1}", 10, 20, i=100), "1010020") |
| 170 | self.assertRaises(ValueError, fmt.format, "{0}{i}{1}", 10, 20, i=100, j=0) |
| 171 | self.assertRaises(ValueError, fmt.format, "{0}", 10, 20) |
| 172 | self.assertRaises(ValueError, fmt.format, "{0}", 10, 20, i=100) |
| 173 | self.assertRaises(ValueError, fmt.format, "{i}", 10, 20, i=100) |
| 174 | |
Nick Coghlan | 62ecb6a | 2011-05-31 19:40:11 +1000 | [diff] [blame] | 175 | def test_vformat_recursion_limit(self): |
| 176 | fmt = string.Formatter() |
| 177 | args = () |
| 178 | kwargs = dict(i=100) |
| 179 | with self.assertRaises(ValueError) as err: |
| 180 | fmt._vformat("{i}", args, kwargs, set(), -1) |
| 181 | self.assertIn("recursion", str(err.exception)) |
Nick Coghlan | d25fd4d | 2011-03-15 08:54:37 +1000 | [diff] [blame] | 182 | |
| 183 | |
Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 184 | def test_main(): |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 185 | support.run_unittest(ModuleTest) |
Walter Dörwald | 0fd583c | 2003-02-21 12:53:50 +0000 | [diff] [blame] | 186 | |
| 187 | if __name__ == "__main__": |
| 188 | test_main() |