1 2 import struct 3 import sys 4 from test import test_support, string_tests 5 6 7 class StrTest( 8 string_tests.CommonTest, 9 string_tests.MixinStrUnicodeUserStringTest, 10 string_tests.MixinStrUserStringTest, 11 string_tests.MixinStrUnicodeTest, 12 ): 13 14 type2test = str 15 16 # We don't need to propagate to str 17 def fixtype(self, obj): 18 return obj 19 20 def test_basic_creation(self): 21 self.assertEqual(str(''), '') 22 self.assertEqual(str(0), '0') 23 self.assertEqual(str(0L), '0') 24 self.assertEqual(str(()), '()') 25 self.assertEqual(str([]), '[]') 26 self.assertEqual(str({}), '{}') 27 a = [] 28 a.append(a) 29 self.assertEqual(str(a), '[[...]]') 30 a = {} 31 a[0] = a 32 self.assertEqual(str(a), '{0: {...}}') 33 34 def test_formatting(self): 35 string_tests.MixinStrUnicodeUserStringTest.test_formatting(self) 36 self.assertRaises(OverflowError, '%c'.__mod__, 0x1234) 37 38 @test_support.cpython_only 39 def test_formatting_huge_precision(self): 40 from _testcapi import INT_MAX 41 format_string = "%.{}f".format(INT_MAX + 1) 42 with self.assertRaises(ValueError): 43 result = format_string % 2.34 44 45 def test_formatting_huge_width(self): 46 format_string = "%{}f".format(sys.maxsize + 1) 47 with self.assertRaises(ValueError): 48 result = format_string % 2.34 49 50 def test_conversion(self): 51 # Make sure __str__() behaves properly 52 class Foo0: 53 def __unicode__(self): 54 return u"foo" 55 56 class Foo1: 57 def __str__(self): 58 return "foo" 59 60 class Foo2(object): 61 def __str__(self): 62 return "foo" 63 64 class Foo3(object): 65 def __str__(self): 66 return u"foo" 67 68 class Foo4(unicode): 69 def __str__(self): 70 return u"foo" 71 72 class Foo5(str): 73 def __str__(self): 74 return u"foo" 75 76 class Foo6(str): 77 def __str__(self): 78 return "foos" 79 80 def __unicode__(self): 81 return u"foou" 82 83 class Foo7(unicode): 84 def __str__(self): 85 return "foos" 86 def __unicode__(self): 87 return u"foou" 88 89 class Foo8(str): 90 def __new__(cls, content=""): 91 return str.__new__(cls, 2*content) 92 def __str__(self): 93 return self 94 95 class Foo9(str): 96 def __str__(self): 97 return "string" 98 def __unicode__(self): 99 return "not unicode" 100 101 self.assertTrue(str(Foo0()).startswith("<")) # this is different from __unicode__ 102 self.assertEqual(str(Foo1()), "foo") 103 self.assertEqual(str(Foo2()), "foo") 104 self.assertEqual(str(Foo3()), "foo") 105 self.assertEqual(str(Foo4("bar")), "foo") 106 self.assertEqual(str(Foo5("bar")), "foo") 107 self.assertEqual(str(Foo6("bar")), "foos") 108 self.assertEqual(str(Foo7("bar")), "foos") 109 self.assertEqual(str(Foo8("foo")), "foofoo") 110 self.assertEqual(str(Foo9("foo")), "string") 111 self.assertEqual(unicode(Foo9("foo")), u"not unicode") 112 113 def test_expandtabs_overflows_gracefully(self): 114 # This test only affects 32-bit platforms because expandtabs can only take 115 # an int as the max value, not a 64-bit C long. If expandtabs is changed 116 # to take a 64-bit long, this test should apply to all platforms. 117 if sys.maxint > (1 << 32) or struct.calcsize('P') != 4: 118 return 119 self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxint) 120 121 def test__format__(self): 122 def test(value, format, expected): 123 # test both with and without the trailing 's' 124 self.assertEqual(value.__format__(format), expected) 125 self.assertEqual(value.__format__(format + 's'), expected) 126 127 test('', '', '') 128 test('abc', '', 'abc') 129 test('abc', '.3', 'abc') 130 test('ab', '.3', 'ab') 131 test('abcdef', '.3', 'abc') 132 test('abcdef', '.0', '') 133 test('abc', '3.3', 'abc') 134 test('abc', '2.3', 'abc') 135 test('abc', '2.2', 'ab') 136 test('abc', '3.2', 'ab ') 137 test('result', 'x<0', 'result') 138 test('result', 'x<5', 'result') 139 test('result', 'x<6', 'result') 140 test('result', 'x<7', 'resultx') 141 test('result', 'x<8', 'resultxx') 142 test('result', ' <7', 'result ') 143 test('result', '<7', 'result ') 144 test('result', '>7', ' result') 145 test('result', '>8', ' result') 146 test('result', '^8', ' result ') 147 test('result', '^9', ' result ') 148 test('result', '^10', ' result ') 149 test('a', '10000', 'a' + ' ' * 9999) 150 test('', '10000', ' ' * 10000) 151 test('', '10000000', ' ' * 10000000) 152 153 def test_format(self): 154 self.assertEqual(''.format(), '') 155 self.assertEqual('a'.format(), 'a') 156 self.assertEqual('ab'.format(), 'ab') 157 self.assertEqual('a{{'.format(), 'a{') 158 self.assertEqual('a}}'.format(), 'a}') 159 self.assertEqual('{{b'.format(), '{b') 160 self.assertEqual('}}b'.format(), '}b') 161 self.assertEqual('a{{b'.format(), 'a{b') 162 163 # examples from the PEP: 164 import datetime 165 self.assertEqual("My name is {0}".format('Fred'), "My name is Fred") 166 self.assertEqual("My name is {0[name]}".format(dict(name='Fred')), 167 "My name is Fred") 168 self.assertEqual("My name is {0} :-{{}}".format('Fred'), 169 "My name is Fred :-{}") 170 171 d = datetime.date(2007, 8, 18) 172 self.assertEqual("The year is {0.year}".format(d), 173 "The year is 2007") 174 175 # classes we'll use for testing 176 class C: 177 def __init__(self, x=100): 178 self._x = x 179 def __format__(self, spec): 180 return spec 181 182 class D: 183 def __init__(self, x): 184 self.x = x 185 def __format__(self, spec): 186 return str(self.x) 187 188 # class with __str__, but no __format__ 189 class E: 190 def __init__(self, x): 191 self.x = x 192 def __str__(self): 193 return 'E(' + self.x + ')' 194 195 # class with __repr__, but no __format__ or __str__ 196 class F: 197 def __init__(self, x): 198 self.x = x 199 def __repr__(self): 200 return 'F(' + self.x + ')' 201 202 # class with __format__ that forwards to string, for some format_spec's 203 class G: 204 def __init__(self, x): 205 self.x = x 206 def __str__(self): 207 return "string is " + self.x 208 def __format__(self, format_spec): 209 if format_spec == 'd': 210 return 'G(' + self.x + ')' 211 return object.__format__(self, format_spec) 212 213 # class that returns a bad type from __format__ 214 class H: 215 def __format__(self, format_spec): 216 return 1.0 217 218 class I(datetime.date): 219 def __format__(self, format_spec): 220 return self.strftime(format_spec) 221 222 class J(int): 223 def __format__(self, format_spec): 224 return int.__format__(self * 2, format_spec) 225 226 227 self.assertEqual(''.format(), '') 228 self.assertEqual('abc'.format(), 'abc') 229 self.assertEqual('{0}'.format('abc'), 'abc') 230 self.assertEqual('{0:}'.format('abc'), 'abc') 231 self.assertEqual('X{0}'.format('abc'), 'Xabc') 232 self.assertEqual('{0}X'.format('abc'), 'abcX') 233 self.assertEqual('X{0}Y'.format('abc'), 'XabcY') 234 self.assertEqual('{1}'.format(1, 'abc'), 'abc') 235 self.assertEqual('X{1}'.format(1, 'abc'), 'Xabc') 236 self.assertEqual('{1}X'.format(1, 'abc'), 'abcX') 237 self.assertEqual('X{1}Y'.format(1, 'abc'), 'XabcY') 238 self.assertEqual('{0}'.format(-15), '-15') 239 self.assertEqual('{0}{1}'.format(-15, 'abc'), '-15abc') 240 self.assertEqual('{0}X{1}'.format(-15, 'abc'), '-15Xabc') 241 self.assertEqual('{{'.format(), '{') 242 self.assertEqual('}}'.format(), '}') 243 self.assertEqual('{{}}'.format(), '{}') 244 self.assertEqual('{{x}}'.format(), '{x}') 245 self.assertEqual('{{{0}}}'.format(123), '{123}') 246 self.assertEqual('{{{{0}}}}'.format(), '{{0}}') 247 self.assertEqual('}}{{'.format(), '}{') 248 self.assertEqual('}}x{{'.format(), '}x{') 249 250 # weird field names 251 self.assertEqual("{0[foo-bar]}".format({'foo-bar':'baz'}), 'baz') 252 self.assertEqual("{0[foo bar]}".format({'foo bar':'baz'}), 'baz') 253 self.assertEqual("{0[ ]}".format({' ':3}), '3') 254 255 self.assertEqual('{foo._x}'.format(foo=C(20)), '20') 256 self.assertEqual('{1}{0}'.format(D(10), D(20)), '2010') 257 self.assertEqual('{0._x.x}'.format(C(D('abc'))), 'abc') 258 self.assertEqual('{0[0]}'.format(['abc', 'def']), 'abc') 259 self.assertEqual('{0[1]}'.format(['abc', 'def']), 'def') 260 self.assertEqual('{0[1][0]}'.format(['abc', ['def']]), 'def') 261 self.assertEqual('{0[1][0].x}'.format(['abc', [D('def')]]), 'def') 262 263 # strings 264 self.assertEqual('{0:.3s}'.format('abc'), 'abc') 265 self.assertEqual('{0:.3s}'.format('ab'), 'ab') 266 self.assertEqual('{0:.3s}'.format('abcdef'), 'abc') 267 self.assertEqual('{0:.0s}'.format('abcdef'), '') 268 self.assertEqual('{0:3.3s}'.format('abc'), 'abc') 269 self.assertEqual('{0:2.3s}'.format('abc'), 'abc') 270 self.assertEqual('{0:2.2s}'.format('abc'), 'ab') 271 self.assertEqual('{0:3.2s}'.format('abc'), 'ab ') 272 self.assertEqual('{0:x<0s}'.format('result'), 'result') 273 self.assertEqual('{0:x<5s}'.format('result'), 'result') 274 self.assertEqual('{0:x<6s}'.format('result'), 'result') 275 self.assertEqual('{0:x<7s}'.format('result'), 'resultx') 276 self.assertEqual('{0:x<8s}'.format('result'), 'resultxx') 277 self.assertEqual('{0: <7s}'.format('result'), 'result ') 278 self.assertEqual('{0:<7s}'.format('result'), 'result ') 279 self.assertEqual('{0:>7s}'.format('result'), ' result') 280 self.assertEqual('{0:>8s}'.format('result'), ' result') 281 self.assertEqual('{0:^8s}'.format('result'), ' result ') 282 self.assertEqual('{0:^9s}'.format('result'), ' result ') 283 self.assertEqual('{0:^10s}'.format('result'), ' result ') 284 self.assertEqual('{0:10000}'.format('a'), 'a' + ' ' * 9999) 285 self.assertEqual('{0:10000}'.format(''), ' ' * 10000) 286 self.assertEqual('{0:10000000}'.format(''), ' ' * 10000000) 287 288 # format specifiers for user defined type 289 self.assertEqual('{0:abc}'.format(C()), 'abc') 290 291 # !r and !s coercions 292 self.assertEqual('{0!s}'.format('Hello'), 'Hello') 293 self.assertEqual('{0!s:}'.format('Hello'), 'Hello') 294 self.assertEqual('{0!s:15}'.format('Hello'), 'Hello ') 295 self.assertEqual('{0!s:15s}'.format('Hello'), 'Hello ') 296 self.assertEqual('{0!r}'.format('Hello'), "'Hello'") 297 self.assertEqual('{0!r:}'.format('Hello'), "'Hello'") 298 self.assertEqual('{0!r}'.format(F('Hello')), 'F(Hello)') 299 300 # test fallback to object.__format__ 301 self.assertEqual('{0}'.format({}), '{}') 302 self.assertEqual('{0}'.format([]), '[]') 303 self.assertEqual('{0}'.format([1]), '[1]') 304 self.assertEqual('{0}'.format(E('data')), 'E(data)') 305 self.assertEqual('{0:d}'.format(G('data')), 'G(data)') 306 self.assertEqual('{0!s}'.format(G('data')), 'string is data') 307 308 msg = 'object.__format__ with a non-empty format string is deprecated' 309 with test_support.check_warnings((msg, PendingDeprecationWarning)): 310 self.assertEqual('{0:^10}'.format(E('data')), ' E(data) ') 311 self.assertEqual('{0:^10s}'.format(E('data')), ' E(data) ') 312 self.assertEqual('{0:>15s}'.format(G('data')), ' string is data') 313 314 self.assertEqual("{0:date: %Y-%m-%d}".format(I(year=2007, 315 month=8, 316 day=27)), 317 "date: 2007-08-27") 318 319 # test deriving from a builtin type and overriding __format__ 320 self.assertEqual("{0}".format(J(10)), "20") 321 322 323 # string format specifiers 324 self.assertEqual('{0:}'.format('a'), 'a') 325 326 # computed format specifiers 327 self.assertEqual("{0:.{1}}".format('hello world', 5), 'hello') 328 self.assertEqual("{0:.{1}s}".format('hello world', 5), 'hello') 329 self.assertEqual("{0:.{precision}s}".format('hello world', precision=5), 'hello') 330 self.assertEqual("{0:{width}.{precision}s}".format('hello world', width=10, precision=5), 'hello ') 331 self.assertEqual("{0:{width}.{precision}s}".format('hello world', width='10', precision='5'), 'hello ') 332 333 # test various errors 334 self.assertRaises(ValueError, '{'.format) 335 self.assertRaises(ValueError, '}'.format) 336 self.assertRaises(ValueError, 'a{'.format) 337 self.assertRaises(ValueError, 'a}'.format) 338 self.assertRaises(ValueError, '{a'.format) 339 self.assertRaises(ValueError, '}a'.format) 340 self.assertRaises(IndexError, '{0}'.format) 341 self.assertRaises(IndexError, '{1}'.format, 'abc') 342 self.assertRaises(KeyError, '{x}'.format) 343 self.assertRaises(ValueError, "}{".format) 344 self.assertRaises(ValueError, "{".format) 345 self.assertRaises(ValueError, "}".format) 346 self.assertRaises(ValueError, "abc{0:{}".format) 347 self.assertRaises(ValueError, "{0".format) 348 self.assertRaises(IndexError, "{0.}".format) 349 self.assertRaises(ValueError, "{0.}".format, 0) 350 self.assertRaises(IndexError, "{0[}".format) 351 self.assertRaises(ValueError, "{0[}".format, []) 352 self.assertRaises(KeyError, "{0]}".format) 353 self.assertRaises(ValueError, "{0.[]}".format, 0) 354 self.assertRaises(ValueError, "{0..foo}".format, 0) 355 self.assertRaises(ValueError, "{0[0}".format, 0) 356 self.assertRaises(ValueError, "{0[0:foo}".format, 0) 357 self.assertRaises(KeyError, "{c]}".format) 358 self.assertRaises(ValueError, "{{ {{{0}}".format, 0) 359 self.assertRaises(ValueError, "{0}}".format, 0) 360 self.assertRaises(KeyError, "{foo}".format, bar=3) 361 self.assertRaises(ValueError, "{0!x}".format, 3) 362 self.assertRaises(ValueError, "{0!}".format, 0) 363 self.assertRaises(ValueError, "{0!rs}".format, 0) 364 self.assertRaises(ValueError, "{!}".format) 365 self.assertRaises(IndexError, "{:}".format) 366 self.assertRaises(IndexError, "{:s}".format) 367 self.assertRaises(IndexError, "{}".format) 368 369 # issue 6089 370 self.assertRaises(ValueError, "{0[0]x}".format, [None]) 371 self.assertRaises(ValueError, "{0[0](10)}".format, [None]) 372 373 # can't have a replacement on the field name portion 374 self.assertRaises(TypeError, '{0[{1}]}'.format, 'abcdefg', 4) 375 376 # exceed maximum recursion depth 377 self.assertRaises(ValueError, "{0:{1:{2}}}".format, 'abc', 's', '') 378 self.assertRaises(ValueError, "{0:{1:{2:{3:{4:{5:{6}}}}}}}".format, 379 0, 1, 2, 3, 4, 5, 6, 7) 380 381 # string format spec errors 382 self.assertRaises(ValueError, "{0:-s}".format, '') 383 self.assertRaises(ValueError, format, "", "-") 384 self.assertRaises(ValueError, "{0:=s}".format, '') 385 386 def test_format_huge_precision(self): 387 format_string = ".{}f".format(sys.maxsize + 1) 388 with self.assertRaises(ValueError): 389 result = format(2.34, format_string) 390 391 def test_format_huge_width(self): 392 format_string = "{}f".format(sys.maxsize + 1) 393 with self.assertRaises(ValueError): 394 result = format(2.34, format_string) 395 396 def test_format_huge_item_number(self): 397 format_string = "{{{}:.6f}}".format(sys.maxsize + 1) 398 with self.assertRaises(ValueError): 399 result = format_string.format(2.34) 400 401 def test_format_auto_numbering(self): 402 class C: 403 def __init__(self, x=100): 404 self._x = x 405 def __format__(self, spec): 406 return spec 407 408 self.assertEqual('{}'.format(10), '10') 409 self.assertEqual('{:5}'.format('s'), 's ') 410 self.assertEqual('{!r}'.format('s'), "'s'") 411 self.assertEqual('{._x}'.format(C(10)), '10') 412 self.assertEqual('{[1]}'.format([1, 2]), '2') 413 self.assertEqual('{[a]}'.format({'a':4, 'b':2}), '4') 414 self.assertEqual('a{}b{}c'.format(0, 1), 'a0b1c') 415 416 self.assertEqual('a{:{}}b'.format('x', '^10'), 'a x b') 417 self.assertEqual('a{:{}x}b'.format(20, '#'), 'a0x14b') 418 419 # can't mix and match numbering and auto-numbering 420 self.assertRaises(ValueError, '{}{1}'.format, 1, 2) 421 self.assertRaises(ValueError, '{1}{}'.format, 1, 2) 422 self.assertRaises(ValueError, '{:{1}}'.format, 1, 2) 423 self.assertRaises(ValueError, '{0:{}}'.format, 1, 2) 424 425 # can mix and match auto-numbering and named 426 self.assertEqual('{f}{}'.format(4, f='test'), 'test4') 427 self.assertEqual('{}{f}'.format(4, f='test'), '4test') 428 self.assertEqual('{:{f}}{g}{}'.format(1, 3, g='g', f=2), ' 1g3') 429 self.assertEqual('{f:{}}{}{g}'.format(2, 4, f=1, g='g'), ' 14g') 430 431 def test_buffer_is_readonly(self): 432 self.assertRaises(TypeError, sys.stdin.readinto, b"") 433 434 def test_encode_and_decode_kwargs(self): 435 self.assertEqual('abcde'.encode('ascii', 'replace'), 436 'abcde'.encode('ascii', errors='replace')) 437 self.assertEqual('abcde'.encode('ascii', 'ignore'), 438 'abcde'.encode(encoding='ascii', errors='ignore')) 439 self.assertEqual('Andr\202 x'.decode('ascii', 'ignore'), 440 'Andr\202 x'.decode('ascii', errors='ignore')) 441 self.assertEqual('Andr\202 x'.decode('ascii', 'replace'), 442 'Andr\202 x'.decode(encoding='ascii', errors='replace')) 443 444 def test_startswith_endswith_errors(self): 445 with self.assertRaises(UnicodeDecodeError): 446 '\xff'.startswith(u'x') 447 with self.assertRaises(UnicodeDecodeError): 448 '\xff'.endswith(u'x') 449 for meth in ('foo'.startswith, 'foo'.endswith): 450 with self.assertRaises(TypeError) as cm: 451 meth(['f']) 452 exc = str(cm.exception) 453 self.assertIn('unicode', exc) 454 self.assertIn('str', exc) 455 self.assertIn('tuple', exc) 456 457 def test_main(): 458 test_support.run_unittest(StrTest) 459 460 if __name__ == "__main__": 461 test_main() 462
