Lib/test/string_tests.py

   1 """
   2 Common tests shared by test_str, test_unicode, test_userstring and test_string.
   3 """
   4
   5 import unittest, string, sys
   6 from test import test_support
   7 from UserList import UserList
   8
   9 class Sequence:
  10     def __init__(self, seq='wxyz'): self.seq = seq
  11     def __len__(self): return len(self.seq)
  12     def __getitem__(self, i): return self.seq[i]
  13
  14 class BadSeq1(Sequence):
  15     def __init__(self): self.seq = [7, 'hello', 123L]
  16
  17 class BadSeq2(Sequence):
  18     def __init__(self): self.seq = ['a', 'b', 'c']
  19     def __len__(self): return 8
  20
  21 class CommonTest(unittest.TestCase):
  22     # This testcase contains test that can be used in all
  23     # stringlike classes. Currently this is str, unicode
  24     # UserString and the string module.
  25
  26     # The type to be tested
  27     # Change in subclasses to change the behaviour of fixtesttype()
  28     type2test = None
  29
  30     # All tests pass their arguments to the testing methods
  31     # as str objects. fixtesttype() can be used to propagate
  32     # these arguments to the appropriate type
  33     def fixtype(self, obj):
  34         if isinstance(obj, str):
  35             return self.__class__.type2test(obj)
  36         elif isinstance(obj, list):
  37             return [self.fixtype(x) for x in obj]
  38         elif isinstance(obj, tuple):
  39             return tuple([self.fixtype(x) for x in obj])
  40         elif isinstance(obj, dict):
  41             return dict([
  42                (self.fixtype(key), self.fixtype(value))
  43                for (key, value) in obj.iteritems()
  44             ])
  45         else:
  46             return obj
  47
  48     # check that object.method(*args) returns result
  49     def checkequal(self, result, object, methodname, *args):
  50         result = self.fixtype(result)
  51         object = self.fixtype(object)
  52         args = self.fixtype(args)
  53         realresult = getattr(object, methodname)(*args)
  54         self.assertEqual(
  55             result,
  56             realresult
  57         )
  58         # if the original is returned make sure that
  59         # this doesn't happen with subclasses
  60         if object == realresult:
  61             class subtype(self.__class__.type2test):
  62                 pass
  63             object = subtype(object)
  64             realresult = getattr(object, methodname)(*args)
  65             self.assert_(object is not realresult)
  66
  67     # check that object.method(*args) raises exc
  68     def checkraises(self, exc, object, methodname, *args):
  69         object = self.fixtype(object)
  70         args = self.fixtype(args)
  71         self.assertRaises(
  72             exc,
  73             getattr(object, methodname),
  74             *args
  75         )
  76
  77     # call object.method(*args) without any checks
  78     def checkcall(self, object, methodname, *args):
  79         object = self.fixtype(object)
  80         args = self.fixtype(args)
  81         getattr(object, methodname)(*args)
  82
  83     def test_capitalize(self):
  84         self.checkequal(' hello ', ' hello ', 'capitalize')
  85         self.checkequal('Hello ', 'Hello ','capitalize')
  86         self.checkequal('Hello ', 'hello ','capitalize')
  87         self.checkequal('Aaaa', 'aaaa', 'capitalize')
  88         self.checkequal('Aaaa', 'AaAa', 'capitalize')
  89
  90         self.checkraises(TypeError, 'hello', 'capitalize', 42)
  91
  92     def test_count(self):
  93         self.checkequal(3, 'aaa', 'count', 'a')
  94         self.checkequal(0, 'aaa', 'count', 'b')
  95         self.checkequal(3, 'aaa', 'count', 'a')
  96         self.checkequal(0, 'aaa', 'count', 'b')
  97         self.checkequal(3, 'aaa', 'count', 'a')
  98         self.checkequal(0, 'aaa', 'count', 'b')
  99         self.checkequal(0, 'aaa', 'count', 'b')
 100         self.checkequal(1, 'aaa', 'count', 'a', -1)
 101         self.checkequal(3, 'aaa', 'count', 'a', -10)
 102         self.checkequal(2, 'aaa', 'count', 'a', 0, -1)
 103         self.checkequal(0, 'aaa', 'count', 'a', 0, -10)
 104
 105         self.checkraises(TypeError, 'hello', 'count')
 106         self.checkraises(TypeError, 'hello', 'count', 42)
 107
 108     def test_find(self):
 109         self.checkequal(0, 'abcdefghiabc', 'find', 'abc')
 110         self.checkequal(9, 'abcdefghiabc', 'find', 'abc', 1)
 111         self.checkequal(-1, 'abcdefghiabc', 'find', 'def', 4)
 112
 113         self.checkraises(TypeError, 'hello', 'find')
 114         self.checkraises(TypeError, 'hello', 'find', 42)
 115
 116     def test_rfind(self):
 117         self.checkequal(9,  'abcdefghiabc', 'rfind', 'abc')
 118         self.checkequal(12, 'abcdefghiabc', 'rfind', '')
 119         self.checkequal(0, 'abcdefghiabc', 'rfind', 'abcd')
 120         self.checkequal(-1, 'abcdefghiabc', 'rfind', 'abcz')
 121
 122         self.checkraises(TypeError, 'hello', 'rfind')
 123         self.checkraises(TypeError, 'hello', 'rfind', 42)
 124
 125     def test_index(self):
 126         self.checkequal(0, 'abcdefghiabc', 'index', '')
 127         self.checkequal(3, 'abcdefghiabc', 'index', 'def')
 128         self.checkequal(0, 'abcdefghiabc', 'index', 'abc')
 129         self.checkequal(9, 'abcdefghiabc', 'index', 'abc', 1)
 130
 131         self.checkraises(ValueError, 'abcdefghiabc', 'index', 'hib')
 132         self.checkraises(ValueError, 'abcdefghiab', 'index', 'abc', 1)
 133         self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', 8)
 134         self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', -1)
 135
 136         self.checkraises(TypeError, 'hello', 'index')
 137         self.checkraises(TypeError, 'hello', 'index', 42)
 138
 139     def test_rindex(self):
 140         self.checkequal(12, 'abcdefghiabc', 'rindex', '')
 141         self.checkequal(3,  'abcdefghiabc', 'rindex', 'def')
 142         self.checkequal(9,  'abcdefghiabc', 'rindex', 'abc')
 143         self.checkequal(0,  'abcdefghiabc', 'rindex', 'abc', 0, -1)
 144
 145         self.checkraises(ValueError, 'abcdefghiabc', 'rindex', 'hib')
 146         self.checkraises(ValueError, 'defghiabc', 'rindex', 'def', 1)
 147         self.checkraises(ValueError, 'defghiabc', 'rindex', 'abc', 0, -1)
 148         self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, 8)
 149         self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, -1)
 150
 151         self.checkraises(TypeError, 'hello', 'rindex')
 152         self.checkraises(TypeError, 'hello', 'rindex', 42)
 153
 154     def test_lower(self):
 155         self.checkequal('hello', 'HeLLo', 'lower')
 156         self.checkequal('hello', 'hello', 'lower')
 157         self.checkraises(TypeError, 'hello', 'lower', 42)
 158
 159     def test_upper(self):
 160         self.checkequal('HELLO', 'HeLLo', 'upper')
 161         self.checkequal('HELLO', 'HELLO', 'upper')
 162         self.checkraises(TypeError, 'hello', 'upper', 42)
 163
 164     def test_expandtabs(self):
 165         self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi', 'expandtabs')
 166         self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8)
 167         self.checkequal('abc\rab  def\ng   hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 4)
 168         self.checkequal('abc\r\nab  def\ng   hi', 'abc\r\nab\tdef\ng\thi', 'expandtabs', 4)
 169         self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi', 'expandtabs')
 170         self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8)
 171         self.checkequal('abc\r\nab\r\ndef\ng\r\nhi', 'abc\r\nab\r\ndef\ng\r\nhi', 'expandtabs', 4)
 172
 173         self.checkraises(TypeError, 'hello', 'expandtabs', 42, 42)
 174
 175     def test_split(self):
 176         self.checkequal(['this', 'is', 'the', 'split', 'function'],
 177             'this is the split function', 'split')
 178         self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|')
 179         self.checkequal(['a', 'b', 'c|d'], 'a|b|c|d', 'split', '|', 2)
 180         self.checkequal(['a', 'b c d'], 'a b c d', 'split', None, 1)
 181         self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2)
 182         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 3)
 183         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 4)
 184         self.checkequal(['a b c d'], 'a b c d', 'split', None, 0)
 185         self.checkequal(['a', 'b', 'c  d'], 'a  b  c  d', 'split', None, 2)
 186         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d ', 'split')
 187         self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//')
 188         self.checkequal(['endcase ', ''], 'endcase test', 'split', 'test')
 189
 190         self.checkraises(TypeError, 'hello', 'split', 42, 42, 42)
 191
 192     def test_strip(self):
 193         self.checkequal('hello', '   hello   ', 'strip')
 194         self.checkequal('hello   ', '   hello   ', 'lstrip')
 195         self.checkequal('   hello', '   hello   ', 'rstrip')
 196         self.checkequal('hello', 'hello', 'strip')
 197
 198     def test_ljust(self):
 199         self.checkequal('abc       ', 'abc', 'ljust', 10)
 200         self.checkequal('abc   ', 'abc', 'ljust', 6)
 201         self.checkequal('abc', 'abc', 'ljust', 3)
 202         self.checkequal('abc', 'abc', 'ljust', 2)
 203
 204         self.checkraises(TypeError, 'abc', 'ljust')
 205
 206     def test_rjust(self):
 207         self.checkequal('       abc', 'abc', 'rjust', 10)
 208         self.checkequal('   abc', 'abc', 'rjust', 6)
 209         self.checkequal('abc', 'abc', 'rjust', 3)
 210         self.checkequal('abc', 'abc', 'rjust', 2)
 211
 212         self.checkraises(TypeError, 'abc', 'rjust')
 213
 214     def test_center(self):
 215         self.checkequal('   abc    ', 'abc', 'center', 10)
 216         self.checkequal(' abc  ', 'abc', 'center', 6)
 217         self.checkequal('abc', 'abc', 'center', 3)
 218         self.checkequal('abc', 'abc', 'center', 2)
 219
 220         self.checkraises(TypeError, 'abc', 'center')
 221
 222     def test_swapcase(self):
 223         self.checkequal('hEllO CoMPuTErS', 'HeLLo cOmpUteRs', 'swapcase')
 224
 225         self.checkraises(TypeError, 'hello', 'swapcase', 42)
 226
 227     def test_replace(self):
 228         self.checkequal('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
 229         self.checkequal('onetwothree', 'one!two!three!', 'replace', '!', '')
 230         self.checkequal('one@two@three!', 'one!two!three!', 'replace', '!', '@', 2)
 231         self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 3)
 232         self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 4)
 233         self.checkequal('one!two!three!', 'one!two!three!', 'replace', '!', '@', 0)
 234         self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@')
 235         self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@')
 236         self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@', 2)
 237         self.checkequal('-a-b-c-', 'abc', 'replace', '', '-')
 238         self.checkequal('-a-b-c', 'abc', 'replace', '', '-', 3)
 239         self.checkequal('abc', 'abc', 'replace', '', '-', 0)
 240         self.checkequal('', '', 'replace', '', '')
 241         self.checkequal('abc', 'abc', 'replace', 'ab', '--', 0)
 242         self.checkequal('abc', 'abc', 'replace', 'xy', '--')
 243         # Next three for SF bug 422088: [OSF1 alpha] string.replace(); died with
 244         # MemoryError due to empty result (platform malloc issue when requesting
 245         # 0 bytes).
 246         self.checkequal('', '123', 'replace', '123', '')
 247         self.checkequal('', '123123', 'replace', '123', '')
 248         self.checkequal('x', '123x123', 'replace', '123', '')
 249
 250         self.checkraises(TypeError, 'hello', 'replace')
 251         self.checkraises(TypeError, 'hello', 'replace', 42)
 252         self.checkraises(TypeError, 'hello', 'replace', 42, 'h')
 253         self.checkraises(TypeError, 'hello', 'replace', 'h', 42)
 254
 255     def test_zfill(self):
 256         self.checkequal('123', '123', 'zfill', 2)
 257         self.checkequal('123', '123', 'zfill', 3)
 258         self.checkequal('0123', '123', 'zfill', 4)
 259         self.checkequal('+123', '+123', 'zfill', 3)
 260         self.checkequal('+123', '+123', 'zfill', 4)
 261         self.checkequal('+0123', '+123', 'zfill', 5)
 262         self.checkequal('-123', '-123', 'zfill', 3)
 263         self.checkequal('-123', '-123', 'zfill', 4)
 264         self.checkequal('-0123', '-123', 'zfill', 5)
 265         self.checkequal('000', '', 'zfill', 3)
 266         self.checkequal('34', '34', 'zfill', 1)
 267         self.checkequal('0034', '34', 'zfill', 4)
 268
 269         self.checkraises(TypeError, '123', 'zfill')
 270
 271 class MixinStrUnicodeUserStringTest:
 272     # additional tests that only work for
 273     # stringlike objects, i.e. str, unicode, UserString
 274     # (but not the string module)
 275
 276     def test_islower(self):
 277         self.checkequal(False, '', 'islower')
 278         self.checkequal(True, 'a', 'islower')
 279         self.checkequal(False, 'A', 'islower')
 280         self.checkequal(False, '\n', 'islower')
 281         self.checkequal(True, 'abc', 'islower')
 282         self.checkequal(False, 'aBc', 'islower')
 283         self.checkequal(True, 'abc\n', 'islower')
 284         self.checkraises(TypeError, 'abc', 'islower', 42)
 285
 286     def test_isupper(self):
 287         self.checkequal(False, '', 'isupper')
 288         self.checkequal(False, 'a', 'isupper')
 289         self.checkequal(True, 'A', 'isupper')
 290         self.checkequal(False, '\n', 'isupper')
 291         self.checkequal(True, 'ABC', 'isupper')
 292         self.checkequal(False, 'AbC', 'isupper')
 293         self.checkequal(True, 'ABC\n', 'isupper')
 294         self.checkraises(TypeError, 'abc', 'isupper', 42)
 295
 296     def test_istitle(self):
 297         self.checkequal(False, '', 'istitle')
 298         self.checkequal(False, 'a', 'istitle')
 299         self.checkequal(True, 'A', 'istitle')
 300         self.checkequal(False, '\n', 'istitle')
 301         self.checkequal(True, 'A Titlecased Line', 'istitle')
 302         self.checkequal(True, 'A\nTitlecased Line', 'istitle')
 303         self.checkequal(True, 'A Titlecased, Line', 'istitle')
 304         self.checkequal(False, 'Not a capitalized String', 'istitle')
 305         self.checkequal(False, 'Not\ta Titlecase String', 'istitle')
 306         self.checkequal(False, 'Not--a Titlecase String', 'istitle')
 307         self.checkequal(False, 'NOT', 'istitle')
 308         self.checkraises(TypeError, 'abc', 'istitle', 42)
 309
 310     def test_isspace(self):
 311         self.checkequal(False, '', 'isspace')
 312         self.checkequal(False, 'a', 'isspace')
 313         self.checkequal(True, ' ', 'isspace')
 314         self.checkequal(True, '\t', 'isspace')
 315         self.checkequal(True, '\r', 'isspace')
 316         self.checkequal(True, '\n', 'isspace')
 317         self.checkequal(True, ' \t\r\n', 'isspace')
 318         self.checkequal(False, ' \t\r\na', 'isspace')
 319         self.checkraises(TypeError, 'abc', 'isspace', 42)
 320
 321     def test_isalpha(self):
 322         self.checkequal(False, '', 'isalpha')
 323         self.checkequal(True, 'a', 'isalpha')
 324         self.checkequal(True, 'A', 'isalpha')
 325         self.checkequal(False, '\n', 'isalpha')
 326         self.checkequal(True, 'abc', 'isalpha')
 327         self.checkequal(False, 'aBc123', 'isalpha')
 328         self.checkequal(False, 'abc\n', 'isalpha')
 329         self.checkraises(TypeError, 'abc', 'isalpha', 42)
 330
 331     def test_isalnum(self):
 332         self.checkequal(False, '', 'isalnum')
 333         self.checkequal(True, 'a', 'isalnum')
 334         self.checkequal(True, 'A', 'isalnum')
 335         self.checkequal(False, '\n', 'isalnum')
 336         self.checkequal(True, '123abc456', 'isalnum')
 337         self.checkequal(True, 'a1b3c', 'isalnum')
 338         self.checkequal(False, 'aBc000 ', 'isalnum')
 339         self.checkequal(False, 'abc\n', 'isalnum')
 340         self.checkraises(TypeError, 'abc', 'isalnum', 42)
 341
 342     def test_isdigit(self):
 343         self.checkequal(False, '', 'isdigit')
 344         self.checkequal(False, 'a', 'isdigit')
 345         self.checkequal(True, '0', 'isdigit')
 346         self.checkequal(True, '0123456789', 'isdigit')
 347         self.checkequal(False, '0123456789a', 'isdigit')
 348
 349         self.checkraises(TypeError, 'abc', 'isdigit', 42)
 350
 351     def test_title(self):
 352         self.checkequal(' Hello ', ' hello ', 'title')
 353         self.checkequal('Hello ', 'hello ', 'title')
 354         self.checkequal('Hello ', 'Hello ', 'title')
 355         self.checkequal('Format This As Title String', "fOrMaT thIs aS titLe String", 'title')
 356         self.checkequal('Format,This-As*Title;String', "fOrMaT,thIs-aS*titLe;String", 'title', )
 357         self.checkequal('Getint', "getInt", 'title')
 358         self.checkraises(TypeError, 'hello', 'title', 42)
 359
 360     def test_splitlines(self):
 361         self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\rghi", 'splitlines')
 362         self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\r\nghi", 'splitlines')
 363         self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi", 'splitlines')
 364         self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi\n", 'splitlines')
 365         self.checkequal(['abc', 'def', 'ghi', ''], "abc\ndef\r\nghi\n\r", 'splitlines')
 366         self.checkequal(['', 'abc', 'def', 'ghi', ''], "\nabc\ndef\r\nghi\n\r", 'splitlines')
 367         self.checkequal(['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'], "\nabc\ndef\r\nghi\n\r", 'splitlines', 1)
 368
 369         self.checkraises(TypeError, 'abc', 'splitlines', 42, 42)
 370
 371     def test_startswith(self):
 372         self.checkequal(True, 'hello', 'startswith', 'he')
 373         self.checkequal(True, 'hello', 'startswith', 'hello')
 374         self.checkequal(False, 'hello', 'startswith', 'hello world')
 375         self.checkequal(True, 'hello', 'startswith', '')
 376         self.checkequal(False, 'hello', 'startswith', 'ello')
 377         self.checkequal(True, 'hello', 'startswith', 'ello', 1)
 378         self.checkequal(True, 'hello', 'startswith', 'o', 4)
 379         self.checkequal(False, 'hello', 'startswith', 'o', 5)
 380         self.checkequal(True, 'hello', 'startswith', '', 5)
 381         self.checkequal(False, 'hello', 'startswith', 'lo', 6)
 382         self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3)
 383         self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3, 7)
 384         self.checkequal(False, 'helloworld', 'startswith', 'lowo', 3, 6)
 385
 386         # test negative indices
 387         self.checkequal(True, 'hello', 'startswith', 'he', 0, -1)
 388         self.checkequal(True, 'hello', 'startswith', 'he', -53, -1)
 389         self.checkequal(False, 'hello', 'startswith', 'hello', 0, -1)
 390         self.checkequal(False, 'hello', 'startswith', 'hello world', -1, -10)
 391         self.checkequal(False, 'hello', 'startswith', 'ello', -5)
 392         self.checkequal(True, 'hello', 'startswith', 'ello', -4)
 393         self.checkequal(False, 'hello', 'startswith', 'o', -2)
 394         self.checkequal(True, 'hello', 'startswith', 'o', -1)
 395         self.checkequal(True, 'hello', 'startswith', '', -3, -3)
 396         self.checkequal(False, 'hello', 'startswith', 'lo', -9)
 397
 398         self.checkraises(TypeError, 'hello', 'startswith')
 399         self.checkraises(TypeError, 'hello', 'startswith', 42)
 400
 401     def test_endswith(self):
 402         self.checkequal(True, 'hello', 'endswith', 'lo')
 403         self.checkequal(False, 'hello', 'endswith', 'he')
 404         self.checkequal(True, 'hello', 'endswith', '')
 405         self.checkequal(False, 'hello', 'endswith', 'hello world')
 406         self.checkequal(False, 'helloworld', 'endswith', 'worl')
 407         self.checkequal(True, 'helloworld', 'endswith', 'worl', 3, 9)
 408         self.checkequal(True, 'helloworld', 'endswith', 'world', 3, 12)
 409         self.checkequal(True, 'helloworld', 'endswith', 'lowo', 1, 7)
 410         self.checkequal(True, 'helloworld', 'endswith', 'lowo', 2, 7)
 411         self.checkequal(True, 'helloworld', 'endswith', 'lowo', 3, 7)
 412         self.checkequal(False, 'helloworld', 'endswith', 'lowo', 4, 7)
 413         self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, 8)
 414         self.checkequal(False, 'ab', 'endswith', 'ab', 0, 1)
 415         self.checkequal(False, 'ab', 'endswith', 'ab', 0, 0)
 416
 417         # test negative indices
 418         self.checkequal(True, 'hello', 'endswith', 'lo', -2)
 419         self.checkequal(False, 'hello', 'endswith', 'he', -2)
 420         self.checkequal(True, 'hello', 'endswith', '', -3, -3)
 421         self.checkequal(False, 'hello', 'endswith', 'hello world', -10, -2)
 422         self.checkequal(False, 'helloworld', 'endswith', 'worl', -6)
 423         self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, -1)
 424         self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, 9)
 425         self.checkequal(True, 'helloworld', 'endswith', 'world', -7, 12)
 426         self.checkequal(True, 'helloworld', 'endswith', 'lowo', -99, -3)
 427         self.checkequal(True, 'helloworld', 'endswith', 'lowo', -8, -3)
 428         self.checkequal(True, 'helloworld', 'endswith', 'lowo', -7, -3)
 429         self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, -4)
 430         self.checkequal(False, 'helloworld', 'endswith', 'lowo', -8, -2)
 431
 432         self.checkraises(TypeError, 'hello', 'endswith')
 433         self.checkraises(TypeError, 'hello', 'endswith', 42)
 434
 435     def test_strip_args(self):
 436         # strip/lstrip/rstrip with None arg
 437         self.checkequal('hello', '   hello   ', 'strip', None)
 438         self.checkequal('hello   ', '   hello   ', 'lstrip', None)
 439         self.checkequal('   hello', '   hello   ', 'rstrip', None)
 440         self.checkequal('hello', 'hello', 'strip', None)
 441
 442         # strip/lstrip/rstrip with str arg
 443         self.checkequal('hello', 'xyzzyhelloxyzzy', 'strip', 'xyz')
 444         self.checkequal('helloxyzzy', 'xyzzyhelloxyzzy', 'lstrip', 'xyz')
 445         self.checkequal('xyzzyhello', 'xyzzyhelloxyzzy', 'rstrip', 'xyz')
 446         self.checkequal('hello', 'hello', 'strip', 'xyz')
 447
 448         # strip/lstrip/rstrip with unicode arg
 449         if test_support.have_unicode:
 450             self.checkequal(unicode('hello', 'ascii'), 'xyzzyhelloxyzzy',
 451                  'strip', unicode('xyz', 'ascii'))
 452             self.checkequal(unicode('helloxyzzy', 'ascii'), 'xyzzyhelloxyzzy',
 453                  'lstrip', unicode('xyz', 'ascii'))
 454             self.checkequal(unicode('xyzzyhello', 'ascii'), 'xyzzyhelloxyzzy',
 455                  'rstrip', unicode('xyz', 'ascii'))
 456             self.checkequal(unicode('hello', 'ascii'), 'hello',
 457                  'strip', unicode('xyz', 'ascii'))
 458
 459         self.checkraises(TypeError, 'hello', 'strip', 42, 42)
 460         self.checkraises(TypeError, 'hello', 'lstrip', 42, 42)
 461         self.checkraises(TypeError, 'hello', 'rstrip', 42, 42)
 462
 463     def test___contains__(self):
 464         self.checkequal(True, '', '__contains__', '')         # vereq('' in '', True)
 465         self.checkequal(True, 'abc', '__contains__', '')      # vereq('' in 'abc', True)
 466         self.checkequal(False, 'abc', '__contains__', '\0')   # vereq('\0' in 'abc', False)
 467         self.checkequal(True, '\0abc', '__contains__', '\0')  # vereq('\0' in '\0abc', True)
 468         self.checkequal(True, 'abc\0', '__contains__', '\0')  # vereq('\0' in 'abc\0', True)
 469         self.checkequal(True, '\0abc', '__contains__', 'a')   # vereq('a' in '\0abc', True)
 470         self.checkequal(True, 'asdf', '__contains__', 'asdf') # vereq('asdf' in 'asdf', True)
 471         self.checkequal(False, 'asd', '__contains__', 'asdf') # vereq('asdf' in 'asd', False)
 472         self.checkequal(False, '', '__contains__', 'asdf')    # vereq('asdf' in '', False)
 473
 474     def test_subscript(self):
 475         self.checkequal(u'a', 'abc', '__getitem__', 0)
 476         self.checkequal(u'c', 'abc', '__getitem__', -1)
 477         self.checkequal(u'a', 'abc', '__getitem__', 0L)
 478         self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 3))
 479         self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 1000))
 480         self.checkequal(u'a', 'abc', '__getitem__', slice(0, 1))
 481         self.checkequal(u'', 'abc', '__getitem__', slice(0, 0))
 482         # FIXME What about negative indizes? This is handled differently by [] and __getitem__(slice)
 483
 484         self.checkraises(TypeError, 'abc', '__getitem__', 'def')
 485
 486     def test_slice(self):
 487         self.checkequal('abc', 'abc', '__getslice__', 0, 1000)
 488         self.checkequal('abc', 'abc', '__getslice__', 0, 3)
 489         self.checkequal('ab', 'abc', '__getslice__', 0, 2)
 490         self.checkequal('bc', 'abc', '__getslice__', 1, 3)
 491         self.checkequal('b', 'abc', '__getslice__', 1, 2)
 492         self.checkequal('', 'abc', '__getslice__', 2, 2)
 493         self.checkequal('', 'abc', '__getslice__', 1000, 1000)
 494         self.checkequal('', 'abc', '__getslice__', 2000, 1000)
 495         self.checkequal('', 'abc', '__getslice__', 2, 1)
 496         # FIXME What about negative indizes? This is handled differently by [] and __getslice__
 497
 498         self.checkraises(TypeError, 'abc', '__getslice__', 'def')
 499
 500     def test_mul(self):
 501         self.checkequal('', 'abc', '__mul__', -1)
 502         self.checkequal('', 'abc', '__mul__', 0)
 503         self.checkequal('abc', 'abc', '__mul__', 1)
 504         self.checkequal('abcabcabc', 'abc', '__mul__', 3)
 505         self.checkraises(TypeError, 'abc', '__mul__')
 506         self.checkraises(TypeError, 'abc', '__mul__', '')
 507         self.checkraises(OverflowError, 10000*'abc', '__mul__', 2000000000)
 508
 509     def test_join(self):
 510         # join now works with any sequence type
 511         # moved here, because the argument order is
 512         # different in string.join (see the test in
 513         # test.test_string.StringTest.test_join)
 514         self.checkequal('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
 515         self.checkequal('abcd', '', 'join', ('a', 'b', 'c', 'd'))
 516         self.checkequal('w x y z', ' ', 'join', Sequence())
 517         self.checkequal('abc', 'a', 'join', ('abc',))
 518         self.checkequal('z', 'a', 'join', UserList(['z']))
 519         if test_support.have_unicode:
 520             self.checkequal(unicode('a.b.c'), unicode('.'), 'join', ['a', 'b', 'c'])
 521             self.checkequal(unicode('a.b.c'), '.', 'join', [unicode('a'), 'b', 'c'])
 522             self.checkequal(unicode('a.b.c'), '.', 'join', ['a', unicode('b'), 'c'])
 523             self.checkequal(unicode('a.b.c'), '.', 'join', ['a', 'b', unicode('c')])
 524             self.checkraises(TypeError, '.', 'join', ['a', unicode('b'), 3])
 525         for i in [5, 25, 125]:
 526             self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',
 527                  ['a' * i] * i)
 528             self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',
 529                  ('a' * i,) * i)
 530
 531         self.checkraises(TypeError, ' ', 'join', BadSeq1())
 532         self.checkequal('a b c', ' ', 'join', BadSeq2())
 533
 534         self.checkraises(TypeError, ' ', 'join')
 535         self.checkraises(TypeError, ' ', 'join', 7)
 536         self.checkraises(TypeError, ' ', 'join', Sequence([7, 'hello', 123L]))
 537
 538     def test_formatting(self):
 539         self.checkequal('+hello+', '+%s+', '__mod__', 'hello')
 540         self.checkequal('+10+', '+%d+', '__mod__', 10)
 541         self.checkequal('a', "%c", '__mod__', "a")
 542         self.checkequal('a', "%c", '__mod__', "a")
 543         self.checkequal('"', "%c", '__mod__', 34)
 544         self.checkequal('$', "%c", '__mod__', 36)
 545         self.checkequal('10', "%d", '__mod__', 10)
 546
 547         for ordinal in (-100, 0x200000):
 548             # unicode raises ValueError, str raises OverflowError
 549             self.checkraises((ValueError, OverflowError), '%c', '__mod__', ordinal)
 550
 551         self.checkequal(' 42', '%3ld', '__mod__', 42)
 552         self.checkequal('0042.00', '%07.2f', '__mod__', 42)
 553
 554         self.checkraises(TypeError, 'abc', '__mod__')
 555         self.checkraises(TypeError, '%(foo)s', '__mod__', 42)
 556         self.checkraises(TypeError, '%s%s', '__mod__', (42,))
 557         self.checkraises(TypeError, '%c', '__mod__', (None,))
 558         self.checkraises(ValueError, '%(foo', '__mod__', {})
 559         self.checkraises(TypeError, '%(foo)s %(bar)s', '__mod__', ('foo', 42))
 560
 561         # argument names with properly nested brackets are supported
 562         self.checkequal('bar', '%((foo))s', '__mod__', {'(foo)': 'bar'})
 563
 564         # 100 is a magic number in PyUnicode_Format, this forces a resize
 565         self.checkequal(103*'a'+'x', '%sx', '__mod__', 103*'a')
 566
 567         self.checkraises(TypeError, '%*s', '__mod__', ('foo', 'bar'))
 568         self.checkraises(TypeError, '%10.*f', '__mod__', ('foo', 42.))
 569         self.checkraises(ValueError, '%10', '__mod__', (42,))
 570
 571     def test_floatformatting(self):
 572         # float formatting
 573         for prec in xrange(100):
 574             format = '%%.%if' % prec
 575             value = 0.01
 576             for x in xrange(60):
 577                 value = value * 3.141592655 / 3.0 * 10.0
 578                 # The formatfloat() code in stringobject.c and
 579                 # unicodeobject.c uses a 120 byte buffer and switches from
 580                 # 'f' formatting to 'g' at precision 50, so we expect
 581                 # OverflowErrors for the ranges x < 50 and prec >= 67.
 582                 if x < 50 and prec >= 67:
 583                     self.checkraises(OverflowError, format, "__mod__", value)
 584                 else:
 585                     self.checkcall(format, "__mod__", value)
 586
 587 class MixinStrStringUserStringTest:
 588     # Additional tests for 8bit strings, i.e. str, UserString and
 589     # the string module
 590
 591     def test_maketrans(self):
 592         self.assertEqual(
 593            ''.join(map(chr, xrange(256))).replace('abc', 'xyz'),
 594            string.maketrans('abc', 'xyz')
 595         )
 596         self.assertRaises(ValueError, string.maketrans, 'abc', 'xyzw')
 597
 598     def test_translate(self):
 599         table = string.maketrans('abc', 'xyz')
 600         self.checkequal('xyzxyz', 'xyzabcdef', 'translate', table, 'def')
 601
 602         table = string.maketrans('a', 'A')
 603         self.checkequal('Abc', 'abc', 'translate', table)
 604         self.checkequal('xyz', 'xyz', 'translate', table)
 605         self.checkequal('yz', 'xyz', 'translate', table, 'x')
 606         self.checkraises(ValueError, 'xyz', 'translate', 'too short', 'strip')
 607         self.checkraises(ValueError, 'xyz', 'translate', 'too short')
 608
 609
 610 class MixinStrUserStringTest:
 611     # Additional tests that only work with
 612     # 8bit compatible object, i.e. str and UserString
 613
 614     def test_encoding_decoding(self):
 615         codecs = [('rot13', 'uryyb jbeyq'),
 616                   ('base64', 'aGVsbG8gd29ybGQ=\n'),
 617                   ('hex', '68656c6c6f20776f726c64'),
 618                   ('uu', 'begin 666 <data>\n+:&5L;&\\@=V]R;&0 \n \nend\n')]
 619         for encoding, data in codecs:
 620             self.checkequal(data, 'hello world', 'encode', encoding)
 621             self.checkequal('hello world', data, 'decode', encoding)
 622         # zlib is optional, so we make the test optional too...
 623         try:
 624             import zlib
 625         except ImportError:
 626             pass
 627         else:
 628             data = 'x\x9c\xcbH\xcd\xc9\xc9W(\xcf/\xcaI\x01\x00\x1a\x0b\x04]'
 629             self.checkequal(data, 'hello world', 'encode', 'zlib')
 630             self.checkequal('hello world', data, 'decode', 'zlib')