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_string.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  8.7 KB  |  215 lines
  1. import unittest, string
  2. from test import test_support, string_tests
  3. from UserList import UserList
  4.  
  5. class StringTest(
  6.     string_tests.CommonTest,
  7.     string_tests.MixinStrStringUserStringTest
  8.     ):
  9.  
  10.     type2test = str
  11.  
  12.     def checkequal(self, result, object, methodname, *args):
  13.         realresult = getattr(string, methodname)(object, *args)
  14.         self.assertEqual(
  15.             result,
  16.             realresult
  17.         )
  18.  
  19.     def checkraises(self, exc, object, methodname, *args):
  20.         self.assertRaises(
  21.             exc,
  22.             getattr(string, methodname),
  23.             object,
  24.             *args
  25.         )
  26.  
  27.     def checkcall(self, object, methodname, *args):
  28.         getattr(string, methodname)(object, *args)
  29.  
  30.     def test_join(self):
  31.         # These are the same checks as in string_test.ObjectTest.test_join
  32.         # but the argument order ist different
  33.         self.checkequal('a b c d', ['a', 'b', 'c', 'd'], 'join', ' ')
  34.         self.checkequal('abcd', ('a', 'b', 'c', 'd'), 'join', '')
  35.         self.checkequal('w x y z', string_tests.Sequence(), 'join', ' ')
  36.         self.checkequal('abc', ('abc',), 'join', 'a')
  37.         self.checkequal('z', UserList(['z']), 'join', 'a')
  38.         if test_support.have_unicode:
  39.             self.checkequal(unicode('a.b.c'), ['a', 'b', 'c'], 'join', unicode('.'))
  40.             self.checkequal(unicode('a.b.c'), [unicode('a'), 'b', 'c'], 'join', '.')
  41.             self.checkequal(unicode('a.b.c'), ['a', unicode('b'), 'c'], 'join', '.')
  42.             self.checkequal(unicode('a.b.c'), ['a', 'b', unicode('c')], 'join', '.')
  43.             self.checkraises(TypeError, ['a', unicode('b'), 3], 'join', '.')
  44.         for i in [5, 25, 125]:
  45.             self.checkequal(
  46.                 ((('a' * i) + '-') * i)[:-1],
  47.                 ['a' * i] * i, 'join', '-')
  48.             self.checkequal(
  49.                 ((('a' * i) + '-') * i)[:-1],
  50.                 ('a' * i,) * i, 'join', '-')
  51.  
  52.         self.checkraises(TypeError, string_tests.BadSeq1(), 'join', ' ')
  53.         self.checkequal('a b c', string_tests.BadSeq2(), 'join', ' ')
  54.         try:
  55.             def f():
  56.                 yield 4 + ""
  57.             self.fixtype(' ').join(f())
  58.         except TypeError, e:
  59.             if '+' not in str(e):
  60.                 self.fail('join() ate exception message')
  61.         else:
  62.             self.fail('exception not raised')
  63.  
  64.  
  65.  
  66.  
  67. class ModuleTest(unittest.TestCase):
  68.  
  69.     def test_attrs(self):
  70.         string.whitespace
  71.         string.lowercase
  72.         string.uppercase
  73.         string.letters
  74.         string.digits
  75.         string.hexdigits
  76.         string.octdigits
  77.         string.punctuation
  78.         string.printable
  79.  
  80.     def test_atoi(self):
  81.         self.assertEqual(string.atoi(" 1 "), 1)
  82.         self.assertRaises(ValueError, string.atoi, " 1x")
  83.         self.assertRaises(ValueError, string.atoi, " x1 ")
  84.  
  85.     def test_atol(self):
  86.         self.assertEqual(string.atol("  1  "), 1L)
  87.         self.assertRaises(ValueError, string.atol, "  1x ")
  88.         self.assertRaises(ValueError, string.atol, "  x1 ")
  89.  
  90.     def test_atof(self):
  91.         self.assertAlmostEqual(string.atof("  1  "), 1.0)
  92.         self.assertRaises(ValueError, string.atof, "  1x ")
  93.         self.assertRaises(ValueError, string.atof, "  x1 ")
  94.  
  95.     def test_maketrans(self):
  96.         transtable = '\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`xyzdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377'
  97.  
  98.         self.assertEqual(string.maketrans('abc', 'xyz'), transtable)
  99.         self.assertRaises(ValueError, string.maketrans, 'abc', 'xyzq')
  100.  
  101.     def test_capwords(self):
  102.         self.assertEqual(string.capwords('abc def ghi'), 'Abc Def Ghi')
  103.         self.assertEqual(string.capwords('abc\tdef\nghi'), 'Abc Def Ghi')
  104.         self.assertEqual(string.capwords('abc\t   def  \nghi'), 'Abc Def Ghi')
  105.         self.assertEqual(string.capwords('ABC DEF GHI'), 'Abc Def Ghi')
  106.         self.assertEqual(string.capwords('ABC-DEF-GHI', '-'), 'Abc-Def-Ghi')
  107.         self.assertEqual(string.capwords('ABC-def DEF-ghi GHI'), 'Abc-def Def-ghi Ghi')
  108.  
  109.     def test_formatter(self):
  110.         fmt = string.Formatter()
  111.         self.assertEqual(fmt.format("foo"), "foo")
  112.  
  113.         self.assertEqual(fmt.format("foo{0}", "bar"), "foobar")
  114.         self.assertEqual(fmt.format("foo{1}{0}-{1}", "bar", 6), "foo6bar-6")
  115.         self.assertEqual(fmt.format("-{arg!r}-", arg='test'), "-'test'-")
  116.  
  117.         # override get_value ############################################
  118.         class NamespaceFormatter(string.Formatter):
  119.             def __init__(self, namespace={}):
  120.                 string.Formatter.__init__(self)
  121.                 self.namespace = namespace
  122.  
  123.             def get_value(self, key, args, kwds):
  124.                 if isinstance(key, str):
  125.                     try:
  126.                         # Check explicitly passed arguments first
  127.                         return kwds[key]
  128.                     except KeyError:
  129.                         return self.namespace[key]
  130.                 else:
  131.                     string.Formatter.get_value(key, args, kwds)
  132.  
  133.         fmt = NamespaceFormatter({'greeting':'hello'})
  134.         self.assertEqual(fmt.format("{greeting}, world!"), 'hello, world!')
  135.  
  136.  
  137.         # override format_field #########################################
  138.         class CallFormatter(string.Formatter):
  139.             def format_field(self, value, format_spec):
  140.                 return format(value(), format_spec)
  141.  
  142.         fmt = CallFormatter()
  143.         self.assertEqual(fmt.format('*{0}*', lambda : 'result'), '*result*')
  144.  
  145.  
  146.         # override convert_field ########################################
  147.         class XFormatter(string.Formatter):
  148.             def convert_field(self, value, conversion):
  149.                 if conversion == 'x':
  150.                     return None
  151.                 return super(XFormatter, self).convert_field(value, conversion)
  152.  
  153.         fmt = XFormatter()
  154.         self.assertEqual(fmt.format("{0!r}:{0!x}", 'foo', 'foo'), "'foo':None")
  155.  
  156.  
  157.         # override parse ################################################
  158.         class BarFormatter(string.Formatter):
  159.             # returns an iterable that contains tuples of the form:
  160.             # (literal_text, field_name, format_spec, conversion)
  161.             def parse(self, format_string):
  162.                 for field in format_string.split('|'):
  163.                     if field[0] == '+':
  164.                         # it's markup
  165.                         field_name, _, format_spec = field[1:].partition(':')
  166.                         yield '', field_name, format_spec, None
  167.                     else:
  168.                         yield field, None, None, None
  169.  
  170.         fmt = BarFormatter()
  171.         self.assertEqual(fmt.format('*|+0:^10s|*', 'foo'), '*   foo    *')
  172.  
  173.         # test all parameters used
  174.         class CheckAllUsedFormatter(string.Formatter):
  175.             def check_unused_args(self, used_args, args, kwargs):
  176.                 # Track which arguments actuallly got used
  177.                 unused_args = set(kwargs.keys())
  178.                 unused_args.update(range(0, len(args)))
  179.  
  180.                 for arg in used_args:
  181.                     unused_args.remove(arg)
  182.  
  183.                 if unused_args:
  184.                     raise ValueError("unused arguments")
  185.  
  186.         fmt = CheckAllUsedFormatter()
  187.         self.assertEqual(fmt.format("{0}", 10), "10")
  188.         self.assertEqual(fmt.format("{0}{i}", 10, i=100), "10100")
  189.         self.assertEqual(fmt.format("{0}{i}{1}", 10, 20, i=100), "1010020")
  190.         self.assertRaises(ValueError, fmt.format, "{0}{i}{1}", 10, 20, i=100, j=0)
  191.         self.assertRaises(ValueError, fmt.format, "{0}", 10, 20)
  192.         self.assertRaises(ValueError, fmt.format, "{0}", 10, 20, i=100)
  193.         self.assertRaises(ValueError, fmt.format, "{i}", 10, 20, i=100)
  194.  
  195.         # Alternate formatting is not supported
  196.         self.assertRaises(ValueError, format, '', '#')
  197.         self.assertRaises(ValueError, format, '', '#20')
  198.  
  199. class BytesAliasTest(unittest.TestCase):
  200.  
  201.     def test_builtin(self):
  202.         self.assert_(str is bytes)
  203.  
  204.     def test_syntax(self):
  205.         self.assertEqual(b"spam", "spam")
  206.         self.assertEqual(br"egg\foo", "egg\\foo")
  207.         self.assert_(type(b""), str)
  208.         self.assert_(type(br""), str)
  209.  
  210. def test_main():
  211.     test_support.run_unittest(StringTest, ModuleTest, BytesAliasTest)
  212.  
  213. if __name__ == "__main__":
  214.     test_main()
  215.