/Lib/test/test_str.py

http://unladen-swallow.googlecode.com/ · Python · 379 lines · 299 code · 55 blank · 25 comment · 4 complexity · f9faa9b37d88d5ec6148589e56ee5fb5 MD5 · raw file

  1. import struct
  2. import sys
  3. from test import test_support, string_tests
  4. class StrTest(
  5. string_tests.CommonTest,
  6. string_tests.MixinStrUnicodeUserStringTest,
  7. string_tests.MixinStrUserStringTest,
  8. string_tests.MixinStrUnicodeTest,
  9. ):
  10. type2test = str
  11. # We don't need to propagate to str
  12. def fixtype(self, obj):
  13. return obj
  14. def test_basic_creation(self):
  15. self.assertEqual(str(''), '')
  16. self.assertEqual(str(0), '0')
  17. self.assertEqual(str(0L), '0')
  18. self.assertEqual(str(()), '()')
  19. self.assertEqual(str([]), '[]')
  20. self.assertEqual(str({}), '{}')
  21. a = []
  22. a.append(a)
  23. self.assertEqual(str(a), '[[...]]')
  24. a = {}
  25. a[0] = a
  26. self.assertEqual(str(a), '{0: {...}}')
  27. def test_formatting(self):
  28. string_tests.MixinStrUnicodeUserStringTest.test_formatting(self)
  29. self.assertRaises(OverflowError, '%c'.__mod__, 0x1234)
  30. def test_conversion(self):
  31. # Make sure __str__() behaves properly
  32. class Foo0:
  33. def __unicode__(self):
  34. return u"foo"
  35. class Foo1:
  36. def __str__(self):
  37. return "foo"
  38. class Foo2(object):
  39. def __str__(self):
  40. return "foo"
  41. class Foo3(object):
  42. def __str__(self):
  43. return u"foo"
  44. class Foo4(unicode):
  45. def __str__(self):
  46. return u"foo"
  47. class Foo5(str):
  48. def __str__(self):
  49. return u"foo"
  50. class Foo6(str):
  51. def __str__(self):
  52. return "foos"
  53. def __unicode__(self):
  54. return u"foou"
  55. class Foo7(unicode):
  56. def __str__(self):
  57. return "foos"
  58. def __unicode__(self):
  59. return u"foou"
  60. class Foo8(str):
  61. def __new__(cls, content=""):
  62. return str.__new__(cls, 2*content)
  63. def __str__(self):
  64. return self
  65. class Foo9(str):
  66. def __str__(self):
  67. return "string"
  68. def __unicode__(self):
  69. return "not unicode"
  70. self.assert_(str(Foo0()).startswith("<")) # this is different from __unicode__
  71. self.assertEqual(str(Foo1()), "foo")
  72. self.assertEqual(str(Foo2()), "foo")
  73. self.assertEqual(str(Foo3()), "foo")
  74. self.assertEqual(str(Foo4("bar")), "foo")
  75. self.assertEqual(str(Foo5("bar")), "foo")
  76. self.assertEqual(str(Foo6("bar")), "foos")
  77. self.assertEqual(str(Foo7("bar")), "foos")
  78. self.assertEqual(str(Foo8("foo")), "foofoo")
  79. self.assertEqual(str(Foo9("foo")), "string")
  80. self.assertEqual(unicode(Foo9("foo")), u"not unicode")
  81. def test_expandtabs_overflows_gracefully(self):
  82. # This test only affects 32-bit platforms because expandtabs can only take
  83. # an int as the max value, not a 64-bit C long. If expandtabs is changed
  84. # to take a 64-bit long, this test should apply to all platforms.
  85. if sys.maxint > (1 << 32) or struct.calcsize('P') != 4:
  86. return
  87. self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxint)
  88. def test__format__(self):
  89. def test(value, format, expected):
  90. # test both with and without the trailing 's'
  91. self.assertEqual(value.__format__(format), expected)
  92. self.assertEqual(value.__format__(format + 's'), expected)
  93. test('', '', '')
  94. test('abc', '', 'abc')
  95. test('abc', '.3', 'abc')
  96. test('ab', '.3', 'ab')
  97. test('abcdef', '.3', 'abc')
  98. test('abcdef', '.0', '')
  99. test('abc', '3.3', 'abc')
  100. test('abc', '2.3', 'abc')
  101. test('abc', '2.2', 'ab')
  102. test('abc', '3.2', 'ab ')
  103. test('result', 'x<0', 'result')
  104. test('result', 'x<5', 'result')
  105. test('result', 'x<6', 'result')
  106. test('result', 'x<7', 'resultx')
  107. test('result', 'x<8', 'resultxx')
  108. test('result', ' <7', 'result ')
  109. test('result', '<7', 'result ')
  110. test('result', '>7', ' result')
  111. test('result', '>8', ' result')
  112. test('result', '^8', ' result ')
  113. test('result', '^9', ' result ')
  114. test('result', '^10', ' result ')
  115. test('a', '10000', 'a' + ' ' * 9999)
  116. test('', '10000', ' ' * 10000)
  117. test('', '10000000', ' ' * 10000000)
  118. def test_format(self):
  119. self.assertEqual(''.format(), '')
  120. self.assertEqual('a'.format(), 'a')
  121. self.assertEqual('ab'.format(), 'ab')
  122. self.assertEqual('a{{'.format(), 'a{')
  123. self.assertEqual('a}}'.format(), 'a}')
  124. self.assertEqual('{{b'.format(), '{b')
  125. self.assertEqual('}}b'.format(), '}b')
  126. self.assertEqual('a{{b'.format(), 'a{b')
  127. # examples from the PEP:
  128. import datetime
  129. self.assertEqual("My name is {0}".format('Fred'), "My name is Fred")
  130. self.assertEqual("My name is {0[name]}".format(dict(name='Fred')),
  131. "My name is Fred")
  132. self.assertEqual("My name is {0} :-{{}}".format('Fred'),
  133. "My name is Fred :-{}")
  134. d = datetime.date(2007, 8, 18)
  135. self.assertEqual("The year is {0.year}".format(d),
  136. "The year is 2007")
  137. # classes we'll use for testing
  138. class C:
  139. def __init__(self, x=100):
  140. self._x = x
  141. def __format__(self, spec):
  142. return spec
  143. class D:
  144. def __init__(self, x):
  145. self.x = x
  146. def __format__(self, spec):
  147. return str(self.x)
  148. # class with __str__, but no __format__
  149. class E:
  150. def __init__(self, x):
  151. self.x = x
  152. def __str__(self):
  153. return 'E(' + self.x + ')'
  154. # class with __repr__, but no __format__ or __str__
  155. class F:
  156. def __init__(self, x):
  157. self.x = x
  158. def __repr__(self):
  159. return 'F(' + self.x + ')'
  160. # class with __format__ that forwards to string, for some format_spec's
  161. class G:
  162. def __init__(self, x):
  163. self.x = x
  164. def __str__(self):
  165. return "string is " + self.x
  166. def __format__(self, format_spec):
  167. if format_spec == 'd':
  168. return 'G(' + self.x + ')'
  169. return object.__format__(self, format_spec)
  170. # class that returns a bad type from __format__
  171. class H:
  172. def __format__(self, format_spec):
  173. return 1.0
  174. class I(datetime.date):
  175. def __format__(self, format_spec):
  176. return self.strftime(format_spec)
  177. class J(int):
  178. def __format__(self, format_spec):
  179. return int.__format__(self * 2, format_spec)
  180. self.assertEqual(''.format(), '')
  181. self.assertEqual('abc'.format(), 'abc')
  182. self.assertEqual('{0}'.format('abc'), 'abc')
  183. self.assertEqual('{0:}'.format('abc'), 'abc')
  184. self.assertEqual('X{0}'.format('abc'), 'Xabc')
  185. self.assertEqual('{0}X'.format('abc'), 'abcX')
  186. self.assertEqual('X{0}Y'.format('abc'), 'XabcY')
  187. self.assertEqual('{1}'.format(1, 'abc'), 'abc')
  188. self.assertEqual('X{1}'.format(1, 'abc'), 'Xabc')
  189. self.assertEqual('{1}X'.format(1, 'abc'), 'abcX')
  190. self.assertEqual('X{1}Y'.format(1, 'abc'), 'XabcY')
  191. self.assertEqual('{0}'.format(-15), '-15')
  192. self.assertEqual('{0}{1}'.format(-15, 'abc'), '-15abc')
  193. self.assertEqual('{0}X{1}'.format(-15, 'abc'), '-15Xabc')
  194. self.assertEqual('{{'.format(), '{')
  195. self.assertEqual('}}'.format(), '}')
  196. self.assertEqual('{{}}'.format(), '{}')
  197. self.assertEqual('{{x}}'.format(), '{x}')
  198. self.assertEqual('{{{0}}}'.format(123), '{123}')
  199. self.assertEqual('{{{{0}}}}'.format(), '{{0}}')
  200. self.assertEqual('}}{{'.format(), '}{')
  201. self.assertEqual('}}x{{'.format(), '}x{')
  202. # weird field names
  203. self.assertEqual("{0[foo-bar]}".format({'foo-bar':'baz'}), 'baz')
  204. self.assertEqual("{0[foo bar]}".format({'foo bar':'baz'}), 'baz')
  205. self.assertEqual("{0[ ]}".format({' ':3}), '3')
  206. self.assertEqual('{foo._x}'.format(foo=C(20)), '20')
  207. self.assertEqual('{1}{0}'.format(D(10), D(20)), '2010')
  208. self.assertEqual('{0._x.x}'.format(C(D('abc'))), 'abc')
  209. self.assertEqual('{0[0]}'.format(['abc', 'def']), 'abc')
  210. self.assertEqual('{0[1]}'.format(['abc', 'def']), 'def')
  211. self.assertEqual('{0[1][0]}'.format(['abc', ['def']]), 'def')
  212. self.assertEqual('{0[1][0].x}'.format(['abc', [D('def')]]), 'def')
  213. # strings
  214. self.assertEqual('{0:.3s}'.format('abc'), 'abc')
  215. self.assertEqual('{0:.3s}'.format('ab'), 'ab')
  216. self.assertEqual('{0:.3s}'.format('abcdef'), 'abc')
  217. self.assertEqual('{0:.0s}'.format('abcdef'), '')
  218. self.assertEqual('{0:3.3s}'.format('abc'), 'abc')
  219. self.assertEqual('{0:2.3s}'.format('abc'), 'abc')
  220. self.assertEqual('{0:2.2s}'.format('abc'), 'ab')
  221. self.assertEqual('{0:3.2s}'.format('abc'), 'ab ')
  222. self.assertEqual('{0:x<0s}'.format('result'), 'result')
  223. self.assertEqual('{0:x<5s}'.format('result'), 'result')
  224. self.assertEqual('{0:x<6s}'.format('result'), 'result')
  225. self.assertEqual('{0:x<7s}'.format('result'), 'resultx')
  226. self.assertEqual('{0:x<8s}'.format('result'), 'resultxx')
  227. self.assertEqual('{0: <7s}'.format('result'), 'result ')
  228. self.assertEqual('{0:<7s}'.format('result'), 'result ')
  229. self.assertEqual('{0:>7s}'.format('result'), ' result')
  230. self.assertEqual('{0:>8s}'.format('result'), ' result')
  231. self.assertEqual('{0:^8s}'.format('result'), ' result ')
  232. self.assertEqual('{0:^9s}'.format('result'), ' result ')
  233. self.assertEqual('{0:^10s}'.format('result'), ' result ')
  234. self.assertEqual('{0:10000}'.format('a'), 'a' + ' ' * 9999)
  235. self.assertEqual('{0:10000}'.format(''), ' ' * 10000)
  236. self.assertEqual('{0:10000000}'.format(''), ' ' * 10000000)
  237. # format specifiers for user defined type
  238. self.assertEqual('{0:abc}'.format(C()), 'abc')
  239. # !r and !s coersions
  240. self.assertEqual('{0!s}'.format('Hello'), 'Hello')
  241. self.assertEqual('{0!s:}'.format('Hello'), 'Hello')
  242. self.assertEqual('{0!s:15}'.format('Hello'), 'Hello ')
  243. self.assertEqual('{0!s:15s}'.format('Hello'), 'Hello ')
  244. self.assertEqual('{0!r}'.format('Hello'), "'Hello'")
  245. self.assertEqual('{0!r:}'.format('Hello'), "'Hello'")
  246. self.assertEqual('{0!r}'.format(F('Hello')), 'F(Hello)')
  247. # test fallback to object.__format__
  248. self.assertEqual('{0}'.format({}), '{}')
  249. self.assertEqual('{0}'.format([]), '[]')
  250. self.assertEqual('{0}'.format([1]), '[1]')
  251. self.assertEqual('{0}'.format(E('data')), 'E(data)')
  252. self.assertEqual('{0:^10}'.format(E('data')), ' E(data) ')
  253. self.assertEqual('{0:^10s}'.format(E('data')), ' E(data) ')
  254. self.assertEqual('{0:d}'.format(G('data')), 'G(data)')
  255. self.assertEqual('{0:>15s}'.format(G('data')), ' string is data')
  256. self.assertEqual('{0!s}'.format(G('data')), 'string is data')
  257. self.assertEqual("{0:date: %Y-%m-%d}".format(I(year=2007,
  258. month=8,
  259. day=27)),
  260. "date: 2007-08-27")
  261. # test deriving from a builtin type and overriding __format__
  262. self.assertEqual("{0}".format(J(10)), "20")
  263. # string format specifiers
  264. self.assertEqual('{0:}'.format('a'), 'a')
  265. # computed format specifiers
  266. self.assertEqual("{0:.{1}}".format('hello world', 5), 'hello')
  267. self.assertEqual("{0:.{1}s}".format('hello world', 5), 'hello')
  268. self.assertEqual("{0:.{precision}s}".format('hello world', precision=5), 'hello')
  269. self.assertEqual("{0:{width}.{precision}s}".format('hello world', width=10, precision=5), 'hello ')
  270. self.assertEqual("{0:{width}.{precision}s}".format('hello world', width='10', precision='5'), 'hello ')
  271. # test various errors
  272. self.assertRaises(ValueError, '{'.format)
  273. self.assertRaises(ValueError, '}'.format)
  274. self.assertRaises(ValueError, 'a{'.format)
  275. self.assertRaises(ValueError, 'a}'.format)
  276. self.assertRaises(ValueError, '{a'.format)
  277. self.assertRaises(ValueError, '}a'.format)
  278. self.assertRaises(IndexError, '{0}'.format)
  279. self.assertRaises(IndexError, '{1}'.format, 'abc')
  280. self.assertRaises(KeyError, '{x}'.format)
  281. self.assertRaises(ValueError, "}{".format)
  282. self.assertRaises(ValueError, "{".format)
  283. self.assertRaises(ValueError, "}".format)
  284. self.assertRaises(ValueError, "abc{0:{}".format)
  285. self.assertRaises(ValueError, "{0".format)
  286. self.assertRaises(IndexError, "{0.}".format)
  287. self.assertRaises(ValueError, "{0.}".format, 0)
  288. self.assertRaises(IndexError, "{0[}".format)
  289. self.assertRaises(ValueError, "{0[}".format, [])
  290. self.assertRaises(KeyError, "{0]}".format)
  291. self.assertRaises(ValueError, "{0.[]}".format, 0)
  292. self.assertRaises(ValueError, "{0..foo}".format, 0)
  293. self.assertRaises(ValueError, "{0[0}".format, 0)
  294. self.assertRaises(ValueError, "{0[0:foo}".format, 0)
  295. self.assertRaises(KeyError, "{c]}".format)
  296. self.assertRaises(ValueError, "{{ {{{0}}".format, 0)
  297. self.assertRaises(ValueError, "{0}}".format, 0)
  298. self.assertRaises(KeyError, "{foo}".format, bar=3)
  299. self.assertRaises(ValueError, "{0!x}".format, 3)
  300. self.assertRaises(ValueError, "{0!}".format, 0)
  301. self.assertRaises(ValueError, "{0!rs}".format, 0)
  302. self.assertRaises(ValueError, "{!}".format)
  303. self.assertRaises(ValueError, "{:}".format)
  304. self.assertRaises(ValueError, "{:s}".format)
  305. self.assertRaises(ValueError, "{}".format)
  306. # issue 6089
  307. self.assertRaises(ValueError, "{0[0]x}".format, [None])
  308. self.assertRaises(ValueError, "{0[0](10)}".format, [None])
  309. # can't have a replacement on the field name portion
  310. self.assertRaises(TypeError, '{0[{1}]}'.format, 'abcdefg', 4)
  311. # exceed maximum recursion depth
  312. self.assertRaises(ValueError, "{0:{1:{2}}}".format, 'abc', 's', '')
  313. self.assertRaises(ValueError, "{0:{1:{2:{3:{4:{5:{6}}}}}}}".format,
  314. 0, 1, 2, 3, 4, 5, 6, 7)
  315. # string format spec errors
  316. self.assertRaises(ValueError, "{0:-s}".format, '')
  317. self.assertRaises(ValueError, format, "", "-")
  318. self.assertRaises(ValueError, "{0:=s}".format, '')
  319. def test_buffer_is_readonly(self):
  320. self.assertRaises(TypeError, sys.stdin.readinto, b"")
  321. def test_main():
  322. test_support.run_unittest(StrTest)
  323. if __name__ == "__main__":
  324. test_main()