1 """

     2 Common tests shared by test_str, test_unicode, test_userstring and test_string.

     3 """

     4 

     5 import unittest, string, sys, struct

     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_hash(self):

    84         # SF bug 1054139:  += optimization was not invalidating cached hash value

    85         a = self.type2test('DNSSEC')

    86         b = self.type2test('')

    87         for c in a:

    88             b += c

    89             hash(b)

    90         self.assertEqual(hash(a), hash(b))

    91 

    92     def test_capitalize(self):

    93         self.checkequal(' hello ', ' hello ', 'capitalize')

    94         self.checkequal('Hello ', 'Hello ','capitalize')

    95         self.checkequal('Hello ', 'hello ','capitalize')

    96         self.checkequal('Aaaa', 'aaaa', 'capitalize')

    97         self.checkequal('Aaaa', 'AaAa', 'capitalize')

    98 

    99         self.checkraises(TypeError, 'hello', 'capitalize', 42)

   100 

   101     def test_count(self):

   102         self.checkequal(3, 'aaa', 'count', 'a')

   103         self.checkequal(0, 'aaa', 'count', 'b')

   104         self.checkequal(3, 'aaa', 'count', 'a')

   105         self.checkequal(0, 'aaa', 'count', 'b')

   106         self.checkequal(3, 'aaa', 'count', 'a')

   107         self.checkequal(0, 'aaa', 'count', 'b')

   108         self.checkequal(0, 'aaa', 'count', 'b')

   109         self.checkequal(2, 'aaa', 'count', 'a', 1)

   110         self.checkequal(0, 'aaa', 'count', 'a', 10)

   111         self.checkequal(1, 'aaa', 'count', 'a', -1)

   112         self.checkequal(3, 'aaa', 'count', 'a', -10)

   113         self.checkequal(1, 'aaa', 'count', 'a', 0, 1)

   114         self.checkequal(3, 'aaa', 'count', 'a', 0, 10)

   115         self.checkequal(2, 'aaa', 'count', 'a', 0, -1)

   116         self.checkequal(0, 'aaa', 'count', 'a', 0, -10)

   117         self.checkequal(3, 'aaa', 'count', '', 1)

   118         self.checkequal(1, 'aaa', 'count', '', 3)

   119         self.checkequal(0, 'aaa', 'count', '', 10)

   120         self.checkequal(2, 'aaa', 'count', '', -1)

   121         self.checkequal(4, 'aaa', 'count', '', -10)

   122 

   123         self.checkraises(TypeError, 'hello', 'count')

   124         self.checkraises(TypeError, 'hello', 'count', 42)

   125 

   126         # For a variety of combinations,

   127         #    verify that str.count() matches an equivalent function

   128         #    replacing all occurrences and then differencing the string lengths

   129         charset = ['', 'a', 'b']

   130         digits = 7

   131         base = len(charset)

   132         teststrings = set()

   133         for i in xrange(base ** digits):

   134             entry = []

   135             for j in xrange(digits):

   136                 i, m = divmod(i, base)

   137                 entry.append(charset[m])

   138             teststrings.add(''.join(entry))

   139         teststrings = list(teststrings)

   140         for i in teststrings:

   141             i = self.fixtype(i)

   142             n = len(i)

   143             for j in teststrings:

   144                 r1 = i.count(j)

   145                 if j:

   146                     r2, rem = divmod(n - len(i.replace(j, '')), len(j))

   147                 else:

   148                     r2, rem = len(i)+1, 0

   149                 if rem or r1 != r2:

   150                     self.assertEqual(rem, 0, '%s != 0 for %s' % (rem, i))

   151                     self.assertEqual(r1, r2, '%s != %s for %s' % (r1, r2, i))

   152 

   153     def test_find(self):

   154         self.checkequal(0, 'abcdefghiabc', 'find', 'abc')

   155         self.checkequal(9, 'abcdefghiabc', 'find', 'abc', 1)

   156         self.checkequal(-1, 'abcdefghiabc', 'find', 'def', 4)

   157 

   158         self.checkequal(0, 'abc', 'find', '', 0)

   159         self.checkequal(3, 'abc', 'find', '', 3)

   160         self.checkequal(-1, 'abc', 'find', '', 4)

   161 

   162         self.checkraises(TypeError, 'hello', 'find')

   163         self.checkraises(TypeError, 'hello', 'find', 42)

   164 

   165         # For a variety of combinations,

   166         #    verify that str.find() matches __contains__

   167         #    and that the found substring is really at that location

   168         charset = ['', 'a', 'b', 'c']

   169         digits = 5

   170         base = len(charset)

   171         teststrings = set()

   172         for i in xrange(base ** digits):

   173             entry = []

   174             for j in xrange(digits):

   175                 i, m = divmod(i, base)

   176                 entry.append(charset[m])

   177             teststrings.add(''.join(entry))

   178         teststrings = list(teststrings)

   179         for i in teststrings:

   180             i = self.fixtype(i)

   181             for j in teststrings:

   182                 loc = i.find(j)

   183                 r1 = (loc != -1)

   184                 r2 = j in i

   185                 if r1 != r2:

   186                     self.assertEqual(r1, r2)

   187                 if loc != -1:

   188                     self.assertEqual(i[loc:loc+len(j)], j)

   189 

   190     def test_rfind(self):

   191         self.checkequal(9,  'abcdefghiabc', 'rfind', 'abc')

   192         self.checkequal(12, 'abcdefghiabc', 'rfind', '')

   193         self.checkequal(0, 'abcdefghiabc', 'rfind', 'abcd')

   194         self.checkequal(-1, 'abcdefghiabc', 'rfind', 'abcz')

   195 

   196         self.checkequal(3, 'abc', 'rfind', '', 0)

   197         self.checkequal(3, 'abc', 'rfind', '', 3)

   198         self.checkequal(-1, 'abc', 'rfind', '', 4)

   199 

   200         self.checkraises(TypeError, 'hello', 'rfind')

   201         self.checkraises(TypeError, 'hello', 'rfind', 42)

   202 

   203     def test_index(self):

   204         self.checkequal(0, 'abcdefghiabc', 'index', '')

   205         self.checkequal(3, 'abcdefghiabc', 'index', 'def')

   206         self.checkequal(0, 'abcdefghiabc', 'index', 'abc')

   207         self.checkequal(9, 'abcdefghiabc', 'index', 'abc', 1)

   208 

   209         self.checkraises(ValueError, 'abcdefghiabc', 'index', 'hib')

   210         self.checkraises(ValueError, 'abcdefghiab', 'index', 'abc', 1)

   211         self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', 8)

   212         self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', -1)

   213 

   214         self.checkraises(TypeError, 'hello', 'index')

   215         self.checkraises(TypeError, 'hello', 'index', 42)

   216 

   217     def test_rindex(self):

   218         self.checkequal(12, 'abcdefghiabc', 'rindex', '')

   219         self.checkequal(3,  'abcdefghiabc', 'rindex', 'def')

   220         self.checkequal(9,  'abcdefghiabc', 'rindex', 'abc')

   221         self.checkequal(0,  'abcdefghiabc', 'rindex', 'abc', 0, -1)

   222 

   223         self.checkraises(ValueError, 'abcdefghiabc', 'rindex', 'hib')

   224         self.checkraises(ValueError, 'defghiabc', 'rindex', 'def', 1)

   225         self.checkraises(ValueError, 'defghiabc', 'rindex', 'abc', 0, -1)

   226         self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, 8)

   227         self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, -1)

   228 

   229         self.checkraises(TypeError, 'hello', 'rindex')

   230         self.checkraises(TypeError, 'hello', 'rindex', 42)

   231 

   232     def test_lower(self):

   233         self.checkequal('hello', 'HeLLo', 'lower')

   234         self.checkequal('hello', 'hello', 'lower')

   235         self.checkraises(TypeError, 'hello', 'lower', 42)

   236 

   237     def test_upper(self):

   238         self.checkequal('HELLO', 'HeLLo', 'upper')

   239         self.checkequal('HELLO', 'HELLO', 'upper')

   240         self.checkraises(TypeError, 'hello', 'upper', 42)

   241 

   242     def test_expandtabs(self):

   243         self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi', 'expandtabs')

   244         self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8)

   245         self.checkequal('abc\rab  def\ng   hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 4)

   246         self.checkequal('abc\r\nab  def\ng   hi', 'abc\r\nab\tdef\ng\thi', 'expandtabs', 4)

   247         self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi', 'expandtabs')

   248         self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi', 'expandtabs', 8)

   249         self.checkequal('abc\r\nab\r\ndef\ng\r\nhi', 'abc\r\nab\r\ndef\ng\r\nhi', 'expandtabs', 4)

   250         self.checkequal('  a\n b', ' \ta\n\tb', 'expandtabs', 1)

   251 

   252         self.checkraises(TypeError, 'hello', 'expandtabs', 42, 42)

   253         # This test is only valid when sizeof(int) == sizeof(void*) == 4.

   254         if sys.maxint < (1 << 32) and struct.calcsize('P') == 4:

   255             self.checkraises(OverflowError,

   256                              '\ta\n\tb', 'expandtabs', sys.maxint)

   257 

   258     def test_split(self):

   259         self.checkequal(['this', 'is', 'the', 'split', 'function'],

   260             'this is the split function', 'split')

   261 

   262         # by whitespace

   263         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d ', 'split')

   264         self.checkequal(['a', 'b c d'], 'a b c d', 'split', None, 1)

   265         self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2)

   266         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 3)

   267         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 4)

   268         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None,

   269                         sys.maxint-1)

   270         self.checkequal(['a b c d'], 'a b c d', 'split', None, 0)

   271         self.checkequal(['a b c d'], '  a b c d', 'split', None, 0)

   272         self.checkequal(['a', 'b', 'c  d'], 'a  b  c  d', 'split', None, 2)

   273 

   274         self.checkequal([], '         ', 'split')

   275         self.checkequal(['a'], '  a    ', 'split')

   276         self.checkequal(['a', 'b'], '  a    b   ', 'split')

   277         self.checkequal(['a', 'b   '], '  a    b   ', 'split', None, 1)

   278         self.checkequal(['a', 'b   c   '], '  a    b   c   ', 'split', None, 1)

   279         self.checkequal(['a', 'b', 'c   '], '  a    b   c   ', 'split', None, 2)

   280         self.checkequal(['a', 'b'], '\n\ta \t\r b \v ', 'split')

   281         aaa = ' a '*20

   282         self.checkequal(['a']*20, aaa, 'split')

   283         self.checkequal(['a'] + [aaa[4:]], aaa, 'split', None, 1)

   284         self.checkequal(['a']*19 + ['a '], aaa, 'split', None, 19)

   285 

   286         # by a char

   287         self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|')

   288         self.checkequal(['a|b|c|d'], 'a|b|c|d', 'split', '|', 0)

   289         self.checkequal(['a', 'b|c|d'], 'a|b|c|d', 'split', '|', 1)

   290         self.checkequal(['a', 'b', 'c|d'], 'a|b|c|d', 'split', '|', 2)

   291         self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 3)

   292         self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 4)

   293         self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|',

   294                         sys.maxint-2)

   295         self.checkequal(['a|b|c|d'], 'a|b|c|d', 'split', '|', 0)

   296         self.checkequal(['a', '', 'b||c||d'], 'a||b||c||d', 'split', '|', 2)

   297         self.checkequal(['endcase ', ''], 'endcase |', 'split', '|')

   298         self.checkequal(['', ' startcase'], '| startcase', 'split', '|')

   299         self.checkequal(['', 'bothcase', ''], '|bothcase|', 'split', '|')

   300         self.checkequal(['a', '', 'b\x00c\x00d'], 'a\x00\x00b\x00c\x00d', 'split', '\x00', 2)

   301 

   302         self.checkequal(['a']*20, ('a|'*20)[:-1], 'split', '|')

   303         self.checkequal(['a']*15 +['a|a|a|a|a'],

   304                                    ('a|'*20)[:-1], 'split', '|', 15)

   305 

   306         # by string

   307         self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//')

   308         self.checkequal(['a', 'b//c//d'], 'a//b//c//d', 'split', '//', 1)

   309         self.checkequal(['a', 'b', 'c//d'], 'a//b//c//d', 'split', '//', 2)

   310         self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 3)

   311         self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 4)

   312         self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//',

   313                         sys.maxint-10)

   314         self.checkequal(['a//b//c//d'], 'a//b//c//d', 'split', '//', 0)

   315         self.checkequal(['a', '', 'b////c////d'], 'a////b////c////d', 'split', '//', 2)

   316         self.checkequal(['endcase ', ''], 'endcase test', 'split', 'test')

   317         self.checkequal(['', ' begincase'], 'test begincase', 'split', 'test')

   318         self.checkequal(['', ' bothcase ', ''], 'test bothcase test',

   319                         'split', 'test')

   320         self.checkequal(['a', 'bc'], 'abbbc', 'split', 'bb')

   321         self.checkequal(['', ''], 'aaa', 'split', 'aaa')

   322         self.checkequal(['aaa'], 'aaa', 'split', 'aaa', 0)

   323         self.checkequal(['ab', 'ab'], 'abbaab', 'split', 'ba')

   324         self.checkequal(['aaaa'], 'aaaa', 'split', 'aab')

   325         self.checkequal([''], '', 'split', 'aaa')

   326         self.checkequal(['aa'], 'aa', 'split', 'aaa')

   327         self.checkequal(['A', 'bobb'], 'Abbobbbobb', 'split', 'bbobb')

   328         self.checkequal(['A', 'B', ''], 'AbbobbBbbobb', 'split', 'bbobb')

   329 

   330         self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'split', 'BLAH')

   331         self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'split', 'BLAH', 19)

   332         self.checkequal(['a']*18 + ['aBLAHa'], ('aBLAH'*20)[:-4],

   333                         'split', 'BLAH', 18)

   334 

   335         # mixed use of str and unicode

   336         self.checkequal([u'a', u'b', u'c d'], 'a b c d', 'split', u' ', 2)

   337 

   338         # argument type

   339         self.checkraises(TypeError, 'hello', 'split', 42, 42, 42)

   340 

   341         # null case

   342         self.checkraises(ValueError, 'hello', 'split', '')

   343         self.checkraises(ValueError, 'hello', 'split', '', 0)

   344 

   345     def test_rsplit(self):

   346         self.checkequal(['this', 'is', 'the', 'rsplit', 'function'],

   347                          'this is the rsplit function', 'rsplit')

   348 

   349         # by whitespace

   350         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d ', 'rsplit')

   351         self.checkequal(['a b c', 'd'], 'a b c d', 'rsplit', None, 1)

   352         self.checkequal(['a b', 'c', 'd'], 'a b c d', 'rsplit', None, 2)

   353         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 3)

   354         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 4)

   355         self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None,

   356                         sys.maxint-20)

   357         self.checkequal(['a b c d'], 'a b c d', 'rsplit', None, 0)

   358         self.checkequal(['a b c d'], 'a b c d  ', 'rsplit', None, 0)

   359         self.checkequal(['a  b', 'c', 'd'], 'a  b  c  d', 'rsplit', None, 2)

   360 

   361         self.checkequal([], '         ', 'rsplit')

   362         self.checkequal(['a'], '  a    ', 'rsplit')

   363         self.checkequal(['a', 'b'], '  a    b   ', 'rsplit')

   364         self.checkequal(['  a', 'b'], '  a    b   ', 'rsplit', None, 1)

   365         self.checkequal(['  a    b','c'], '  a    b   c   ', 'rsplit',

   366                         None, 1)

   367         self.checkequal(['  a', 'b', 'c'], '  a    b   c   ', 'rsplit',

   368                         None, 2)

   369         self.checkequal(['a', 'b'], '\n\ta \t\r b \v ', 'rsplit', None, 88)

   370         aaa = ' a '*20

   371         self.checkequal(['a']*20, aaa, 'rsplit')

   372         self.checkequal([aaa[:-4]] + ['a'], aaa, 'rsplit', None, 1)

   373         self.checkequal([' a  a'] + ['a']*18, aaa, 'rsplit', None, 18)

   374 

   375 

   376         # by a char

   377         self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|')

   378         self.checkequal(['a|b|c', 'd'], 'a|b|c|d', 'rsplit', '|', 1)

   379         self.checkequal(['a|b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 2)

   380         self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 3)

   381         self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 4)

   382         self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|',

   383                         sys.maxint-100)

   384         self.checkequal(['a|b|c|d'], 'a|b|c|d', 'rsplit', '|', 0)

   385         self.checkequal(['a||b||c', '', 'd'], 'a||b||c||d', 'rsplit', '|', 2)

   386         self.checkequal(['', ' begincase'], '| begincase', 'rsplit', '|')

   387         self.checkequal(['endcase ', ''], 'endcase |', 'rsplit', '|')

   388         self.checkequal(['', 'bothcase', ''], '|bothcase|', 'rsplit', '|')

   389 

   390         self.checkequal(['a\x00\x00b', 'c', 'd'], 'a\x00\x00b\x00c\x00d', 'rsplit', '\x00', 2)

   391 

   392         self.checkequal(['a']*20, ('a|'*20)[:-1], 'rsplit', '|')

   393         self.checkequal(['a|a|a|a|a']+['a']*15,

   394                         ('a|'*20)[:-1], 'rsplit', '|', 15)

   395 

   396         # by string

   397         self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//')

   398         self.checkequal(['a//b//c', 'd'], 'a//b//c//d', 'rsplit', '//', 1)

   399         self.checkequal(['a//b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 2)

   400         self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 3)

   401         self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 4)

   402         self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//',

   403                         sys.maxint-5)

   404         self.checkequal(['a//b//c//d'], 'a//b//c//d', 'rsplit', '//', 0)

   405         self.checkequal(['a////b////c', '', 'd'], 'a////b////c////d', 'rsplit', '//', 2)

   406         self.checkequal(['', ' begincase'], 'test begincase', 'rsplit', 'test')

   407         self.checkequal(['endcase ', ''], 'endcase test', 'rsplit', 'test')

   408         self.checkequal(['', ' bothcase ', ''], 'test bothcase test',

   409                         'rsplit', 'test')

   410         self.checkequal(['ab', 'c'], 'abbbc', 'rsplit', 'bb')

   411         self.checkequal(['', ''], 'aaa', 'rsplit', 'aaa')

   412         self.checkequal(['aaa'], 'aaa', 'rsplit', 'aaa', 0)

   413         self.checkequal(['ab', 'ab'], 'abbaab', 'rsplit', 'ba')

   414         self.checkequal(['aaaa'], 'aaaa', 'rsplit', 'aab')

   415         self.checkequal([''], '', 'rsplit', 'aaa')

   416         self.checkequal(['aa'], 'aa', 'rsplit', 'aaa')

   417         self.checkequal(['bbob', 'A'], 'bbobbbobbA', 'rsplit', 'bbobb')

   418         self.checkequal(['', 'B', 'A'], 'bbobbBbbobbA', 'rsplit', 'bbobb')

   419 

   420         self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'rsplit', 'BLAH')

   421         self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'rsplit', 'BLAH', 19)

   422         self.checkequal(['aBLAHa'] + ['a']*18, ('aBLAH'*20)[:-4],

   423                         'rsplit', 'BLAH', 18)

   424 

   425         # mixed use of str and unicode

   426         self.checkequal([u'a b', u'c', u'd'], 'a b c d', 'rsplit', u' ', 2)

   427 

   428         # argument type

   429         self.checkraises(TypeError, 'hello', 'rsplit', 42, 42, 42)

   430 

   431         # null case

   432         self.checkraises(ValueError, 'hello', 'rsplit', '')

   433         self.checkraises(ValueError, 'hello', 'rsplit', '', 0)

   434 

   435     def test_strip(self):

   436         self.checkequal('hello', '   hello   ', 'strip')

   437         self.checkequal('hello   ', '   hello   ', 'lstrip')

   438         self.checkequal('   hello', '   hello   ', 'rstrip')

   439         self.checkequal('hello', 'hello', 'strip')

   440 

   441         # strip/lstrip/rstrip with None arg

   442         self.checkequal('hello', '   hello   ', 'strip', None)

   443         self.checkequal('hello   ', '   hello   ', 'lstrip', None)

   444         self.checkequal('   hello', '   hello   ', 'rstrip', None)

   445         self.checkequal('hello', 'hello', 'strip', None)

   446 

   447         # strip/lstrip/rstrip with str arg

   448         self.checkequal('hello', 'xyzzyhelloxyzzy', 'strip', 'xyz')

   449         self.checkequal('helloxyzzy', 'xyzzyhelloxyzzy', 'lstrip', 'xyz')

   450         self.checkequal('xyzzyhello', 'xyzzyhelloxyzzy', 'rstrip', 'xyz')

   451         self.checkequal('hello', 'hello', 'strip', 'xyz')

   452 

   453         # strip/lstrip/rstrip with unicode arg

   454         if test_support.have_unicode:

   455             self.checkequal(unicode('hello', 'ascii'), 'xyzzyhelloxyzzy',

   456                  'strip', unicode('xyz', 'ascii'))

   457             self.checkequal(unicode('helloxyzzy', 'ascii'), 'xyzzyhelloxyzzy',

   458                  'lstrip', unicode('xyz', 'ascii'))

   459             self.checkequal(unicode('xyzzyhello', 'ascii'), 'xyzzyhelloxyzzy',

   460                  'rstrip', unicode('xyz', 'ascii'))

   461             self.checkequal(unicode('hello', 'ascii'), 'hello',

   462                  'strip', unicode('xyz', 'ascii'))

   463 

   464         self.checkraises(TypeError, 'hello', 'strip', 42, 42)

   465         self.checkraises(TypeError, 'hello', 'lstrip', 42, 42)

   466         self.checkraises(TypeError, 'hello', 'rstrip', 42, 42)

   467 

   468     def test_ljust(self):

   469         self.checkequal('abc       ', 'abc', 'ljust', 10)

   470         self.checkequal('abc   ', 'abc', 'ljust', 6)

   471         self.checkequal('abc', 'abc', 'ljust', 3)

   472         self.checkequal('abc', 'abc', 'ljust', 2)

   473         self.checkequal('abc*******', 'abc', 'ljust', 10, '*')

   474         self.checkraises(TypeError, 'abc', 'ljust')

   475 

   476     def test_rjust(self):

   477         self.checkequal('       abc', 'abc', 'rjust', 10)

   478         self.checkequal('   abc', 'abc', 'rjust', 6)

   479         self.checkequal('abc', 'abc', 'rjust', 3)

   480         self.checkequal('abc', 'abc', 'rjust', 2)

   481         self.checkequal('*******abc', 'abc', 'rjust', 10, '*')

   482         self.checkraises(TypeError, 'abc', 'rjust')

   483 

   484     def test_center(self):

   485         self.checkequal('   abc    ', 'abc', 'center', 10)

   486         self.checkequal(' abc  ', 'abc', 'center', 6)

   487         self.checkequal('abc', 'abc', 'center', 3)

   488         self.checkequal('abc', 'abc', 'center', 2)

   489         self.checkequal('***abc****', 'abc', 'center', 10, '*')

   490         self.checkraises(TypeError, 'abc', 'center')

   491 

   492     def test_swapcase(self):

   493         self.checkequal('hEllO CoMPuTErS', 'HeLLo cOmpUteRs', 'swapcase')

   494 

   495         self.checkraises(TypeError, 'hello', 'swapcase', 42)

   496 

   497     def test_replace(self):

   498         EQ = self.checkequal

   499 

   500         # Operations on the empty string

   501         EQ("", "", "replace", "", "")

   502         EQ("A", "", "replace", "", "A")

   503         EQ("", "", "replace", "A", "")

   504         EQ("", "", "replace", "A", "A")

   505         EQ("", "", "replace", "", "", 100)

   506         EQ("", "", "replace", "", "", sys.maxint)

   507 

   508         # interleave (from=="", 'to' gets inserted everywhere)

   509         EQ("A", "A", "replace", "", "")

   510         EQ("*A*", "A", "replace", "", "*")

   511         EQ("*1A*1", "A", "replace", "", "*1")

   512         EQ("*-#A*-#", "A", "replace", "", "*-#")

   513         EQ("*-A*-A*-", "AA", "replace", "", "*-")

   514         EQ("*-A*-A*-", "AA", "replace", "", "*-", -1)

   515         EQ("*-A*-A*-", "AA", "replace", "", "*-", sys.maxint)

   516         EQ("*-A*-A*-", "AA", "replace", "", "*-", 4)

   517         EQ("*-A*-A*-", "AA", "replace", "", "*-", 3)

   518         EQ("*-A*-A", "AA", "replace", "", "*-", 2)

   519         EQ("*-AA", "AA", "replace", "", "*-", 1)

   520         EQ("AA", "AA", "replace", "", "*-", 0)

   521 

   522         # single character deletion (from=="A", to=="")

   523         EQ("", "A", "replace", "A", "")

   524         EQ("", "AAA", "replace", "A", "")

   525         EQ("", "AAA", "replace", "A", "", -1)

   526         EQ("", "AAA", "replace", "A", "", sys.maxint)

   527         EQ("", "AAA", "replace", "A", "", 4)

   528         EQ("", "AAA", "replace", "A", "", 3)

   529         EQ("A", "AAA", "replace", "A", "", 2)

   530         EQ("AA", "AAA", "replace", "A", "", 1)

   531         EQ("AAA", "AAA", "replace", "A", "", 0)

   532         EQ("", "AAAAAAAAAA", "replace", "A", "")

   533         EQ("BCD", "ABACADA", "replace", "A", "")

   534         EQ("BCD", "ABACADA", "replace", "A", "", -1)

   535         EQ("BCD", "ABACADA", "replace", "A", "", sys.maxint)

   536         EQ("BCD", "ABACADA", "replace", "A", "", 5)

   537         EQ("BCD", "ABACADA", "replace", "A", "", 4)

   538         EQ("BCDA", "ABACADA", "replace", "A", "", 3)

   539         EQ("BCADA", "ABACADA", "replace", "A", "", 2)

   540         EQ("BACADA", "ABACADA", "replace", "A", "", 1)

   541         EQ("ABACADA", "ABACADA", "replace", "A", "", 0)

   542         EQ("BCD", "ABCAD", "replace", "A", "")

   543         EQ("BCD", "ABCADAA", "replace", "A", "")

   544         EQ("BCD", "BCD", "replace", "A", "")

   545         EQ("*************", "*************", "replace", "A", "")

   546         EQ("^A^", "^"+"A"*1000+"^", "replace", "A", "", 999)

   547 

   548         # substring deletion (from=="the", to=="")

   549         EQ("", "the", "replace", "the", "")

   550         EQ("ater", "theater", "replace", "the", "")

   551         EQ("", "thethe", "replace", "the", "")

   552         EQ("", "thethethethe", "replace", "the", "")

   553         EQ("aaaa", "theatheatheathea", "replace", "the", "")

   554         EQ("that", "that", "replace", "the", "")

   555         EQ("thaet", "thaet", "replace", "the", "")

   556         EQ("here and re", "here and there", "replace", "the", "")

   557         EQ("here and re and re", "here and there and there",

   558            "replace", "the", "", sys.maxint)

   559         EQ("here and re and re", "here and there and there",

   560            "replace", "the", "", -1)

   561         EQ("here and re and re", "here and there and there",

   562            "replace", "the", "", 3)

   563         EQ("here and re and re", "here and there and there",

   564            "replace", "the", "", 2)

   565         EQ("here and re and there", "here and there and there",

   566            "replace", "the", "", 1)

   567         EQ("here and there and there", "here and there and there",

   568            "replace", "the", "", 0)

   569         EQ("here and re and re", "here and there and there", "replace", "the", "")

   570 

   571         EQ("abc", "abc", "replace", "the", "")

   572         EQ("abcdefg", "abcdefg", "replace", "the", "")

   573 

   574         # substring deletion (from=="bob", to=="")

   575         EQ("bob", "bbobob", "replace", "bob", "")

   576         EQ("bobXbob", "bbobobXbbobob", "replace", "bob", "")

   577         EQ("aaaaaaa", "aaaaaaabob", "replace", "bob", "")

   578         EQ("aaaaaaa", "aaaaaaa", "replace", "bob", "")

   579 

   580         # single character replace in place (len(from)==len(to)==1)

   581         EQ("Who goes there?", "Who goes there?", "replace", "o", "o")

   582         EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O")

   583         EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", sys.maxint)

   584         EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", -1)

   585         EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 3)

   586         EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 2)

   587         EQ("WhO goes there?", "Who goes there?", "replace", "o", "O", 1)

   588         EQ("Who goes there?", "Who goes there?", "replace", "o", "O", 0)

   589 

   590         EQ("Who goes there?", "Who goes there?", "replace", "a", "q")

   591         EQ("who goes there?", "Who goes there?", "replace", "W", "w")

   592         EQ("wwho goes there?ww", "WWho goes there?WW", "replace", "W", "w")

   593         EQ("Who goes there!", "Who goes there?", "replace", "?", "!")

   594         EQ("Who goes there!!", "Who goes there??", "replace", "?", "!")

   595 

   596         EQ("Who goes there?", "Who goes there?", "replace", ".", "!")

   597 

   598         # substring replace in place (len(from)==len(to) > 1)

   599         EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**")

   600         EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", sys.maxint)

   601         EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", -1)

   602         EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 4)

   603         EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 3)

   604         EQ("Th** ** a tissue", "This is a tissue", "replace", "is", "**", 2)

   605         EQ("Th** is a tissue", "This is a tissue", "replace", "is", "**", 1)

   606         EQ("This is a tissue", "This is a tissue", "replace", "is", "**", 0)

   607         EQ("cobob", "bobob", "replace", "bob", "cob")

   608         EQ("cobobXcobocob", "bobobXbobobob", "replace", "bob", "cob")

   609         EQ("bobob", "bobob", "replace", "bot", "bot")

   610 

   611         # replace single character (len(from)==1, len(to)>1)

   612         EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK")

   613         EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", -1)

   614         EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", sys.maxint)

   615         EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", 2)

   616         EQ("ReyKKjavik", "Reykjavik", "replace", "k", "KK", 1)

   617         EQ("Reykjavik", "Reykjavik", "replace", "k", "KK", 0)

   618         EQ("A----B----C----", "A.B.C.", "replace", ".", "----")

   619 

   620         EQ("Reykjavik", "Reykjavik", "replace", "q", "KK")

   621 

   622         # replace substring (len(from)>1, len(to)!=len(from))

   623         EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",

   624            "replace", "spam", "ham")

   625         EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",

   626            "replace", "spam", "ham", sys.maxint)

   627         EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",

   628            "replace", "spam", "ham", -1)

   629         EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",

   630            "replace", "spam", "ham", 4)

   631         EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",

   632            "replace", "spam", "ham", 3)

   633         EQ("ham, ham, eggs and spam", "spam, spam, eggs and spam",

   634            "replace", "spam", "ham", 2)

   635         EQ("ham, spam, eggs and spam", "spam, spam, eggs and spam",

   636            "replace", "spam", "ham", 1)

   637         EQ("spam, spam, eggs and spam", "spam, spam, eggs and spam",

   638            "replace", "spam", "ham", 0)

   639 

   640         EQ("bobob", "bobobob", "replace", "bobob", "bob")

   641         EQ("bobobXbobob", "bobobobXbobobob", "replace", "bobob", "bob")

   642         EQ("BOBOBOB", "BOBOBOB", "replace", "bob", "bobby")

   643 

   644         ba = buffer('a')

   645         bb = buffer('b')

   646         EQ("bbc", "abc", "replace", ba, bb)

   647         EQ("aac", "abc", "replace", bb, ba)

   648 

   649         #

   650         self.checkequal('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)

   651         self.checkequal('onetwothree', 'one!two!three!', 'replace', '!', '')

   652         self.checkequal('one@two@three!', 'one!two!three!', 'replace', '!', '@', 2)

   653         self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 3)

   654         self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 4)

   655         self.checkequal('one!two!three!', 'one!two!three!', 'replace', '!', '@', 0)

   656         self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@')

   657         self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@')

   658         self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@', 2)

   659         self.checkequal('-a-b-c-', 'abc', 'replace', '', '-')

   660         self.checkequal('-a-b-c', 'abc', 'replace', '', '-', 3)

   661         self.checkequal('abc', 'abc', 'replace', '', '-', 0)

   662         self.checkequal('', '', 'replace', '', '')

   663         self.checkequal('abc', 'abc', 'replace', 'ab', '--', 0)

   664         self.checkequal('abc', 'abc', 'replace', 'xy', '--')

   665         # Next three for SF bug 422088: [OSF1 alpha] string.replace(); died with

   666         # MemoryError due to empty result (platform malloc issue when requesting

   667         # 0 bytes).

   668         self.checkequal('', '123', 'replace', '123', '')

   669         self.checkequal('', '123123', 'replace', '123', '')

   670         self.checkequal('x', '123x123', 'replace', '123', '')

   671 

   672         self.checkraises(TypeError, 'hello', 'replace')

   673         self.checkraises(TypeError, 'hello', 'replace', 42)

   674         self.checkraises(TypeError, 'hello', 'replace', 42, 'h')

   675         self.checkraises(TypeError, 'hello', 'replace', 'h', 42)

   676 

   677     def test_replace_overflow(self):

   678         # Check for overflow checking on 32 bit machines

   679         if sys.maxint != 2147483647 or struct.calcsize("P") > 4:

   680             return

   681         A2_16 = "A" * (2**16)

   682         self.checkraises(OverflowError, A2_16, "replace", "", A2_16)

   683         self.checkraises(OverflowError, A2_16, "replace", "A", A2_16)

   684         self.checkraises(OverflowError, A2_16, "replace", "AA", A2_16+A2_16)

   685 

   686     def test_zfill(self):

   687         self.checkequal('123', '123', 'zfill', 2)

   688         self.checkequal('123', '123', 'zfill', 3)

   689         self.checkequal('0123', '123', 'zfill', 4)

   690         self.checkequal('+123', '+123', 'zfill', 3)

   691         self.checkequal('+123', '+123', 'zfill', 4)

   692         self.checkequal('+0123', '+123', 'zfill', 5)

   693         self.checkequal('-123', '-123', 'zfill', 3)

   694         self.checkequal('-123', '-123', 'zfill', 4)

   695         self.checkequal('-0123', '-123', 'zfill', 5)

   696         self.checkequal('000', '', 'zfill', 3)

   697         self.checkequal('34', '34', 'zfill', 1)

   698         self.checkequal('0034', '34', 'zfill', 4)

   699 

   700         self.checkraises(TypeError, '123', 'zfill')

   701 

   702 class MixinStrUnicodeUserStringTest:

   703     # additional tests that only work for

   704     # stringlike objects, i.e. str, unicode, UserString

   705     # (but not the string module)

   706 

   707     def test_islower(self):

   708         self.checkequal(False, '', 'islower')

   709         self.checkequal(True, 'a', 'islower')

   710         self.checkequal(False, 'A', 'islower')

   711         self.checkequal(False, '\n', 'islower')

   712         self.checkequal(True, 'abc', 'islower')

   713         self.checkequal(False, 'aBc', 'islower')

   714         self.checkequal(True, 'abc\n', 'islower')

   715         self.checkraises(TypeError, 'abc', 'islower', 42)

   716 

   717     def test_isupper(self):

   718         self.checkequal(False, '', 'isupper')

   719         self.checkequal(False, 'a', 'isupper')

   720         self.checkequal(True, 'A', 'isupper')

   721         self.checkequal(False, '\n', 'isupper')

   722         self.checkequal(True, 'ABC', 'isupper')

   723         self.checkequal(False, 'AbC', 'isupper')

   724         self.checkequal(True, 'ABC\n', 'isupper')

   725         self.checkraises(TypeError, 'abc', 'isupper', 42)

   726 

   727     def test_istitle(self):

   728         self.checkequal(False, '', 'istitle')

   729         self.checkequal(False, 'a', 'istitle')

   730         self.checkequal(True, 'A', 'istitle')

   731         self.checkequal(False, '\n', 'istitle')

   732         self.checkequal(True, 'A Titlecased Line', 'istitle')

   733         self.checkequal(True, 'A\nTitlecased Line', 'istitle')

   734         self.checkequal(True, 'A Titlecased, Line', 'istitle')

   735         self.checkequal(False, 'Not a capitalized String', 'istitle')

   736         self.checkequal(False, 'Not\ta Titlecase String', 'istitle')

   737         self.checkequal(False, 'Not--a Titlecase String', 'istitle')

   738         self.checkequal(False, 'NOT', 'istitle')

   739         self.checkraises(TypeError, 'abc', 'istitle', 42)

   740 

   741     def test_isspace(self):

   742         self.checkequal(False, '', 'isspace')

   743         self.checkequal(False, 'a', 'isspace')

   744         self.checkequal(True, ' ', 'isspace')

   745         self.checkequal(True, '\t', 'isspace')

   746         self.checkequal(True, '\r', 'isspace')

   747         self.checkequal(True, '\n', 'isspace')

   748         self.checkequal(True, ' \t\r\n', 'isspace')

   749         self.checkequal(False, ' \t\r\na', 'isspace')

   750         self.checkraises(TypeError, 'abc', 'isspace', 42)

   751 

   752     def test_isalpha(self):

   753         self.checkequal(False, '', 'isalpha')

   754         self.checkequal(True, 'a', 'isalpha')

   755         self.checkequal(True, 'A', 'isalpha')

   756         self.checkequal(False, '\n', 'isalpha')

   757         self.checkequal(True, 'abc', 'isalpha')

   758         self.checkequal(False, 'aBc123', 'isalpha')

   759         self.checkequal(False, 'abc\n', 'isalpha')

   760         self.checkraises(TypeError, 'abc', 'isalpha', 42)

   761 

   762     def test_isalnum(self):

   763         self.checkequal(False, '', 'isalnum')

   764         self.checkequal(True, 'a', 'isalnum')

   765         self.checkequal(True, 'A', 'isalnum')

   766         self.checkequal(False, '\n', 'isalnum')

   767         self.checkequal(True, '123abc456', 'isalnum')

   768         self.checkequal(True, 'a1b3c', 'isalnum')

   769         self.checkequal(False, 'aBc000 ', 'isalnum')

   770         self.checkequal(False, 'abc\n', 'isalnum')

   771         self.checkraises(TypeError, 'abc', 'isalnum', 42)

   772 

   773     def test_isdigit(self):

   774         self.checkequal(False, '', 'isdigit')

   775         self.checkequal(False, 'a', 'isdigit')

   776         self.checkequal(True, '0', 'isdigit')

   777         self.checkequal(True, '0123456789', 'isdigit')

   778         self.checkequal(False, '0123456789a', 'isdigit')

   779 

   780         self.checkraises(TypeError, 'abc', 'isdigit', 42)

   781 

   782     def test_title(self):

   783         self.checkequal(' Hello ', ' hello ', 'title')

   784         self.checkequal('Hello ', 'hello ', 'title')

   785         self.checkequal('Hello ', 'Hello ', 'title')

   786         self.checkequal('Format This As Title String', "fOrMaT thIs aS titLe String", 'title')

   787         self.checkequal('Format,This-As*Title;String', "fOrMaT,thIs-aS*titLe;String", 'title', )

   788         self.checkequal('Getint', "getInt", 'title')

   789         self.checkraises(TypeError, 'hello', 'title', 42)

   790 

   791     def test_splitlines(self):

   792         self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\rghi", 'splitlines')

   793         self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\r\nghi", 'splitlines')

   794         self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi", 'splitlines')

   795         self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi\n", 'splitlines')

   796         self.checkequal(['abc', 'def', 'ghi', ''], "abc\ndef\r\nghi\n\r", 'splitlines')

   797         self.checkequal(['', 'abc', 'def', 'ghi', ''], "\nabc\ndef\r\nghi\n\r", 'splitlines')

   798         self.checkequal(['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'], "\nabc\ndef\r\nghi\n\r", 'splitlines', 1)

   799 

   800         self.checkraises(TypeError, 'abc', 'splitlines', 42, 42)

   801 

   802     def test_startswith(self):

   803         self.checkequal(True, 'hello', 'startswith', 'he')

   804         self.checkequal(True, 'hello', 'startswith', 'hello')

   805         self.checkequal(False, 'hello', 'startswith', 'hello world')

   806         self.checkequal(True, 'hello', 'startswith', '')

   807         self.checkequal(False, 'hello', 'startswith', 'ello')

   808         self.checkequal(True, 'hello', 'startswith', 'ello', 1)

   809         self.checkequal(True, 'hello', 'startswith', 'o', 4)

   810         self.checkequal(False, 'hello', 'startswith', 'o', 5)

   811         self.checkequal(True, 'hello', 'startswith', '', 5)

   812         self.checkequal(False, 'hello', 'startswith', 'lo', 6)

   813         self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3)

   814         self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3, 7)

   815         self.checkequal(False, 'helloworld', 'startswith', 'lowo', 3, 6)

   816 

   817         # test negative indices

   818         self.checkequal(True, 'hello', 'startswith', 'he', 0, -1)

   819         self.checkequal(True, 'hello', 'startswith', 'he', -53, -1)

   820         self.checkequal(False, 'hello', 'startswith', 'hello', 0, -1)

   821         self.checkequal(False, 'hello', 'startswith', 'hello world', -1, -10)

   822         self.checkequal(False, 'hello', 'startswith', 'ello', -5)

   823         self.checkequal(True, 'hello', 'startswith', 'ello', -4)

   824         self.checkequal(False, 'hello', 'startswith', 'o', -2)

   825         self.checkequal(True, 'hello', 'startswith', 'o', -1)

   826         self.checkequal(True, 'hello', 'startswith', '', -3, -3)

   827         self.checkequal(False, 'hello', 'startswith', 'lo', -9)

   828 

   829         self.checkraises(TypeError, 'hello', 'startswith')

   830         self.checkraises(TypeError, 'hello', 'startswith', 42)

   831 

   832         # test tuple arguments

   833         self.checkequal(True, 'hello', 'startswith', ('he', 'ha'))

   834         self.checkequal(False, 'hello', 'startswith', ('lo', 'llo'))

   835         self.checkequal(True, 'hello', 'startswith', ('hellox', 'hello'))

   836         self.checkequal(False, 'hello', 'startswith', ())

   837         self.checkequal(True, 'helloworld', 'startswith', ('hellowo',

   838                                                            'rld', 'lowo'), 3)

   839         self.checkequal(False, 'helloworld', 'startswith', ('hellowo', 'ello',

   840                                                             'rld'), 3)

   841         self.checkequal(True, 'hello', 'startswith', ('lo', 'he'), 0, -1)

   842         self.checkequal(False, 'hello', 'startswith', ('he', 'hel'), 0, 1)

   843         self.checkequal(True, 'hello', 'startswith', ('he', 'hel'), 0, 2)

   844 

   845         self.checkraises(TypeError, 'hello', 'startswith', (42,))

   846 

   847     def test_endswith(self):

   848         self.checkequal(True, 'hello', 'endswith', 'lo')

   849         self.checkequal(False, 'hello', 'endswith', 'he')

   850         self.checkequal(True, 'hello', 'endswith', '')

   851         self.checkequal(False, 'hello', 'endswith', 'hello world')

   852         self.checkequal(False, 'helloworld', 'endswith', 'worl')

   853         self.checkequal(True, 'helloworld', 'endswith', 'worl', 3, 9)

   854         self.checkequal(True, 'helloworld', 'endswith', 'world', 3, 12)

   855         self.checkequal(True, 'helloworld', 'endswith', 'lowo', 1, 7)

   856         self.checkequal(True, 'helloworld', 'endswith', 'lowo', 2, 7)

   857         self.checkequal(True, 'helloworld', 'endswith', 'lowo', 3, 7)

   858         self.checkequal(False, 'helloworld', 'endswith', 'lowo', 4, 7)

   859         self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, 8)

   860         self.checkequal(False, 'ab', 'endswith', 'ab', 0, 1)

   861         self.checkequal(False, 'ab', 'endswith', 'ab', 0, 0)

   862 

   863         # test negative indices

   864         self.checkequal(True, 'hello', 'endswith', 'lo', -2)

   865         self.checkequal(False, 'hello', 'endswith', 'he', -2)

   866         self.checkequal(True, 'hello', 'endswith', '', -3, -3)

   867         self.checkequal(False, 'hello', 'endswith', 'hello world', -10, -2)

   868         self.checkequal(False, 'helloworld', 'endswith', 'worl', -6)

   869         self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, -1)

   870         self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, 9)

   871         self.checkequal(True, 'helloworld', 'endswith', 'world', -7, 12)

   872         self.checkequal(True, 'helloworld', 'endswith', 'lowo', -99, -3)

   873         self.checkequal(True, 'helloworld', 'endswith', 'lowo', -8, -3)

   874         self.checkequal(True, 'helloworld', 'endswith', 'lowo', -7, -3)

   875         self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, -4)

   876         self.checkequal(False, 'helloworld', 'endswith', 'lowo', -8, -2)

   877 

   878         self.checkraises(TypeError, 'hello', 'endswith')

   879         self.checkraises(TypeError, 'hello', 'endswith', 42)

   880 

   881         # test tuple arguments

   882         self.checkequal(False, 'hello', 'endswith', ('he', 'ha'))

   883         self.checkequal(True, 'hello', 'endswith', ('lo', 'llo'))

   884         self.checkequal(True, 'hello', 'endswith', ('hellox', 'hello'))

   885         self.checkequal(False, 'hello', 'endswith', ())

   886         self.checkequal(True, 'helloworld', 'endswith', ('hellowo',

   887                                                            'rld', 'lowo'), 3)

   888         self.checkequal(False, 'helloworld', 'endswith', ('hellowo', 'ello',

   889                                                             'rld'), 3, -1)

   890         self.checkequal(True, 'hello', 'endswith', ('hell', 'ell'), 0, -1)

   891         self.checkequal(False, 'hello', 'endswith', ('he', 'hel'), 0, 1)

   892         self.checkequal(True, 'hello', 'endswith', ('he', 'hell'), 0, 4)

   893 

   894         self.checkraises(TypeError, 'hello', 'endswith', (42,))

   895 

   896     def test___contains__(self):

   897         self.checkequal(True, '', '__contains__', '')         # vereq('' in '', True)

   898         self.checkequal(True, 'abc', '__contains__', '')      # vereq('' in 'abc', True)

   899         self.checkequal(False, 'abc', '__contains__', '\0')   # vereq('\0' in 'abc', False)

   900         self.checkequal(True, '\0abc', '__contains__', '\0')  # vereq('\0' in '\0abc', True)

   901         self.checkequal(True, 'abc\0', '__contains__', '\0')  # vereq('\0' in 'abc\0', True)

   902         self.checkequal(True, '\0abc', '__contains__', 'a')   # vereq('a' in '\0abc', True)

   903         self.checkequal(True, 'asdf', '__contains__', 'asdf') # vereq('asdf' in 'asdf', True)

   904         self.checkequal(False, 'asd', '__contains__', 'asdf') # vereq('asdf' in 'asd', False)

   905         self.checkequal(False, '', '__contains__', 'asdf')    # vereq('asdf' in '', False)

   906 

   907     def test_subscript(self):

   908         self.checkequal(u'a', 'abc', '__getitem__', 0)

   909         self.checkequal(u'c', 'abc', '__getitem__', -1)

   910         self.checkequal(u'a', 'abc', '__getitem__', 0L)

   911         self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 3))

   912         self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 1000))

   913         self.checkequal(u'a', 'abc', '__getitem__', slice(0, 1))

   914         self.checkequal(u'', 'abc', '__getitem__', slice(0, 0))

   915         # FIXME What about negative indices? This is handled differently by [] and __getitem__(slice)

   916 

   917         self.checkraises(TypeError, 'abc', '__getitem__', 'def')

   918 

   919     def test_slice(self):

   920         self.checkequal('abc', 'abc', '__getslice__', 0, 1000)

   921         self.checkequal('abc', 'abc', '__getslice__', 0, 3)

   922         self.checkequal('ab', 'abc', '__getslice__', 0, 2)

   923         self.checkequal('bc', 'abc', '__getslice__', 1, 3)

   924         self.checkequal('b', 'abc', '__getslice__', 1, 2)

   925         self.checkequal('', 'abc', '__getslice__', 2, 2)

   926         self.checkequal('', 'abc', '__getslice__', 1000, 1000)

   927         self.checkequal('', 'abc', '__getslice__', 2000, 1000)

   928         self.checkequal('', 'abc', '__getslice__', 2, 1)

   929         # FIXME What about negative indizes? This is handled differently by [] and __getslice__

   930 

   931         self.checkraises(TypeError, 'abc', '__getslice__', 'def')

   932 

   933     def test_mul(self):

   934         self.checkequal('', 'abc', '__mul__', -1)

   935         self.checkequal('', 'abc', '__mul__', 0)

   936         self.checkequal('abc', 'abc', '__mul__', 1)

   937         self.checkequal('abcabcabc', 'abc', '__mul__', 3)

   938         self.checkraises(TypeError, 'abc', '__mul__')

   939         self.checkraises(TypeError, 'abc', '__mul__', '')

   940         # XXX: on a 64-bit system, this doesn't raise an overflow error,

   941         # but either raises a MemoryError, or succeeds (if you have 54TiB)

   942         #self.checkraises(OverflowError, 10000*'abc', '__mul__', 2000000000)

   943 

   944     def test_join(self):

   945         # join now works with any sequence type

   946         # moved here, because the argument order is

   947         # different in string.join (see the test in

   948         # test.test_string.StringTest.test_join)

   949         self.checkequal('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])

   950         self.checkequal('abcd', '', 'join', ('a', 'b', 'c', 'd'))

   951         self.checkequal('bd', '', 'join', ('', 'b', '', 'd'))

   952         self.checkequal('ac', '', 'join', ('a', '', 'c', ''))

   953         self.checkequal('w x y z', ' ', 'join', Sequence())

   954         self.checkequal('abc', 'a', 'join', ('abc',))

   955         self.checkequal('z', 'a', 'join', UserList(['z']))

   956         if test_support.have_unicode:

   957             self.checkequal(unicode('a.b.c'), unicode('.'), 'join', ['a', 'b', 'c'])

   958             self.checkequal(unicode('a.b.c'), '.', 'join', [unicode('a'), 'b', 'c'])

   959             self.checkequal(unicode('a.b.c'), '.', 'join', ['a', unicode('b'), 'c'])

   960             self.checkequal(unicode('a.b.c'), '.', 'join', ['a', 'b', unicode('c')])

   961             self.checkraises(TypeError, '.', 'join', ['a', unicode('b'), 3])

   962         for i in [5, 25, 125]:

   963             self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',

   964                  ['a' * i] * i)

   965             self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',

   966                  ('a' * i,) * i)

   967 

   968         self.checkraises(TypeError, ' ', 'join', BadSeq1())

   969         self.checkequal('a b c', ' ', 'join', BadSeq2())

   970 

   971         self.checkraises(TypeError, ' ', 'join')

   972         self.checkraises(TypeError, ' ', 'join', 7)

   973         self.checkraises(TypeError, ' ', 'join', Sequence([7, 'hello', 123L]))

   974         try:

   975             def f():

   976                 yield 4 + ""

   977             self.fixtype(' ').join(f())

   978         except TypeError, e:

   979             if '+' not in str(e):

   980                 self.fail('join() ate exception message')

   981         else:

   982             self.fail('exception not raised')

   983 

   984     def test_formatting(self):

   985         self.checkequal('+hello+', '+%s+', '__mod__', 'hello')

   986         self.checkequal('+10+', '+%d+', '__mod__', 10)

   987         self.checkequal('a', "%c", '__mod__', "a")

   988         self.checkequal('a', "%c", '__mod__', "a")

   989         self.checkequal('"', "%c", '__mod__', 34)

   990         self.checkequal('$', "%c", '__mod__', 36)

   991         self.checkequal('10', "%d", '__mod__', 10)

   992         self.checkequal('\x7f', "%c", '__mod__', 0x7f)

   993 

   994         for ordinal in (-100, 0x200000):

   995             # unicode raises ValueError, str raises OverflowError

   996             self.checkraises((ValueError, OverflowError), '%c', '__mod__', ordinal)

   997 

   998         self.checkequal(' 42', '%3ld', '__mod__', 42)

   999         self.checkequal('0042.00', '%07.2f', '__mod__', 42)

  1000         self.checkequal('0042.00', '%07.2F', '__mod__', 42)

  1001 

  1002         self.checkraises(TypeError, 'abc', '__mod__')

  1003         self.checkraises(TypeError, '%(foo)s', '__mod__', 42)

  1004         self.checkraises(TypeError, '%s%s', '__mod__', (42,))

  1005         self.checkraises(TypeError, '%c', '__mod__', (None,))

  1006         self.checkraises(ValueError, '%(foo', '__mod__', {})

  1007         self.checkraises(TypeError, '%(foo)s %(bar)s', '__mod__', ('foo', 42))

  1008 

  1009         # argument names with properly nested brackets are supported

  1010         self.checkequal('bar', '%((foo))s', '__mod__', {'(foo)': 'bar'})

  1011 

  1012         # 100 is a magic number in PyUnicode_Format, this forces a resize

  1013         self.checkequal(103*'a'+'x', '%sx', '__mod__', 103*'a')

  1014 

  1015         self.checkraises(TypeError, '%*s', '__mod__', ('foo', 'bar'))

  1016         self.checkraises(TypeError, '%10.*f', '__mod__', ('foo', 42.))

  1017         self.checkraises(ValueError, '%10', '__mod__', (42,))

  1018 

  1019     def test_floatformatting(self):

  1020         # float formatting

  1021         for prec in xrange(100):

  1022             format = '%%.%if' % prec

  1023             value = 0.01

  1024             for x in xrange(60):

  1025                 value = value * 3.141592655 / 3.0 * 10.0

  1026                 # The formatfloat() code in stringobject.c and

  1027                 # unicodeobject.c uses a 120 byte buffer and switches from

  1028                 # 'f' formatting to 'g' at precision 50, so we expect

  1029                 # OverflowErrors for the ranges x < 50 and prec >= 67.

  1030                 if x < 50 and prec >= 67:

  1031                     self.checkraises(OverflowError, format, "__mod__", value)

  1032                 else:

  1033                     self.checkcall(format, "__mod__", value)

  1034 

  1035     def test_inplace_rewrites(self):

  1036         # Check that strings don't copy and modify cached single-character strings

  1037         self.checkequal('a', 'A', 'lower')

  1038         self.checkequal(True, 'A', 'isupper')

  1039         self.checkequal('A', 'a', 'upper')

  1040         self.checkequal(True, 'a', 'islower')

  1041 

  1042         self.checkequal('a', 'A', 'replace', 'A', 'a')

  1043         self.checkequal(True, 'A', 'isupper')

  1044 

  1045         self.checkequal('A', 'a', 'capitalize')

  1046         self.checkequal(True, 'a', 'islower')

  1047 

  1048         self.checkequal('A', 'a', 'swapcase')

  1049         self.checkequal(True, 'a', 'islower')

  1050 

  1051         self.checkequal('A', 'a', 'title')

  1052         self.checkequal(True, 'a', 'islower')

  1053 

  1054     def test_partition(self):

  1055 

  1056         self.checkequal(('this is the par', 'ti', 'tion method'),

  1057             'this is the partition method', 'partition', 'ti')

  1058 

  1059         # from raymond's original specification

  1060         S = 'http://www.python.org'

  1061         self.checkequal(('http', '://', 'www.python.org'), S, 'partition', '://')

  1062         self.checkequal(('http://www.python.org', '', ''), S, 'partition', '?')

  1063         self.checkequal(('', 'http://', 'www.python.org'), S, 'partition', 'http://')

  1064         self.checkequal(('http://www.python.', 'org', ''), S, 'partition', 'org')

  1065 

  1066         self.checkraises(ValueError, S, 'partition', '')

  1067         self.checkraises(TypeError, S, 'partition', None)

  1068 

  1069     def test_rpartition(self):

  1070 

  1071         self.checkequal(('this is the rparti', 'ti', 'on method'),

  1072             'this is the rpartition method', 'rpartition', 'ti')

  1073 

  1074         # from raymond's original specification

  1075         S = 'http://www.python.org'

  1076         self.checkequal(('http', '://', 'www.python.org'), S, 'rpartition', '://')

  1077         self.checkequal(('', '', 'http://www.python.org'), S, 'rpartition', '?')

  1078         self.checkequal(('', 'http://', 'www.python.org'), S, 'rpartition', 'http://')

  1079         self.checkequal(('http://www.python.', 'org', ''), S, 'rpartition', 'org')

  1080 

  1081         self.checkraises(ValueError, S, 'rpartition', '')

  1082         self.checkraises(TypeError, S, 'rpartition', None)

  1083 

  1084 

  1085 class MixinStrStringUserStringTest:

  1086     # Additional tests for 8bit strings, i.e. str, UserString and

  1087     # the string module

  1088 

  1089     def test_maketrans(self):

  1090         self.assertEqual(

  1091            ''.join(map(chr, xrange(256))).replace('abc', 'xyz'),

  1092            string.maketrans('abc', 'xyz')

  1093         )

  1094         self.assertRaises(ValueError, string.maketrans, 'abc', 'xyzw')

  1095 

  1096     def test_translate(self):

  1097         table = string.maketrans('abc', 'xyz')

  1098         self.checkequal('xyzxyz', 'xyzabcdef', 'translate', table, 'def')

  1099 

  1100         table = string.maketrans('a', 'A')

  1101         self.checkequal('Abc', 'abc', 'translate', table)

  1102         self.checkequal('xyz', 'xyz', 'translate', table)

  1103         self.checkequal('yz', 'xyz', 'translate', table, 'x')

  1104         self.checkraises(ValueError, 'xyz', 'translate', 'too short', 'strip')

  1105         self.checkraises(ValueError, 'xyz', 'translate', 'too short')

  1106 

  1107 

  1108 class MixinStrUserStringTest:

  1109     # Additional tests that only work with

  1110     # 8bit compatible object, i.e. str and UserString

  1111 

  1112     if test_support.have_unicode:

  1113         def test_encoding_decoding(self):

  1114             codecs = [('rot13', 'uryyb jbeyq'),

  1115                       ('base64', 'aGVsbG8gd29ybGQ=\n'),

  1116                       ('hex', '68656c6c6f20776f726c64'),

  1117                       ('uu', 'begin 666 <data>\n+:&5L;&\\@=V]R;&0 \n \nend\n')]

  1118             for encoding, data in codecs:

  1119                 self.checkequal(data, 'hello world', 'encode', encoding)

  1120                 self.checkequal('hello world', data, 'decode', encoding)

  1121             # zlib is optional, so we make the test optional too...

  1122             try:

  1123                 import zlib

  1124             except ImportError:

  1125                 pass

  1126             else:

  1127                 data = 'x\x9c\xcbH\xcd\xc9\xc9W(\xcf/\xcaI\x01\x00\x1a\x0b\x04]'

  1128                 self.checkequal(data, 'hello world', 'encode', 'zlib')

  1129                 self.checkequal('hello world', data, 'decode', 'zlib')

  1130 

  1131             self.checkraises(TypeError, 'xyz', 'decode', 42)

  1132             self.checkraises(TypeError, 'xyz', 'encode', 42)

  1133 

  1134 

  1135 class MixinStrUnicodeTest: