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