1"""
2Common tests shared by test_unicode, test_userstring and test_bytes.
3"""
4
5import unittest, string, sys, struct
6from test import support
7from collections import UserList
8
9class 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
14class BadSeq1(Sequence):
15    def __init__(self): self.seq = [7, 'hello', 123]
16    def __str__(self): return '{0} {1} {2}'.format(*self.seq)
17
18class BadSeq2(Sequence):
19    def __init__(self): self.seq = ['a', 'b', 'c']
20    def __len__(self): return 8
21
22class BaseTest:
23    # These tests are for buffers of values (bytes) and not
24    # specific to character interpretation, used for bytes objects
25    # and various string implementations
26
27    # The type to be tested
28    # Change in subclasses to change the behaviour of fixtesttype()
29    type2test = None
30
31    # Whether the "contained items" of the container are integers in
32    # range(0, 256) (i.e. bytes, bytearray) or strings of length 1
33    # (str)
34    contains_bytes = False
35
36    # All tests pass their arguments to the testing methods
37    # as str objects. fixtesttype() can be used to propagate
38    # these arguments to the appropriate type
39    def fixtype(self, obj):
40        if isinstance(obj, str):
41            return self.__class__.type2test(obj)
42        elif isinstance(obj, list):
43            return [self.fixtype(x) for x in obj]
44        elif isinstance(obj, tuple):
45            return tuple([self.fixtype(x) for x in obj])
46        elif isinstance(obj, dict):
47            return dict([
48               (self.fixtype(key), self.fixtype(value))
49               for (key, value) in obj.items()
50            ])
51        else:
52            return obj
53
54    def test_fixtype(self):
55        self.assertIs(type(self.fixtype("123")), self.type2test)
56
57    # check that obj.method(*args) returns result
58    def checkequal(self, result, obj, methodname, *args, **kwargs):
59        result = self.fixtype(result)
60        obj = self.fixtype(obj)
61        args = self.fixtype(args)
62        kwargs = {k: self.fixtype(v) for k,v in kwargs.items()}
63        realresult = getattr(obj, methodname)(*args, **kwargs)
64        self.assertEqual(
65            result,
66            realresult
67        )
68        # if the original is returned make sure that
69        # this doesn't happen with subclasses
70        if obj is realresult:
71            try:
72                class subtype(self.__class__.type2test):
73                    pass
74            except TypeError:
75                pass  # Skip this if we can't subclass
76            else:
77                obj = subtype(obj)
78                realresult = getattr(obj, methodname)(*args)
79                self.assertIsNot(obj, realresult)
80
81    # check that obj.method(*args) raises exc
82    def checkraises(self, exc, obj, methodname, *args):
83        obj = self.fixtype(obj)
84        args = self.fixtype(args)
85        with self.assertRaises(exc) as cm:
86            getattr(obj, methodname)(*args)
87        self.assertNotEqual(str(cm.exception), '')
88
89    # call obj.method(*args) without any checks
90    def checkcall(self, obj, methodname, *args):
91        obj = self.fixtype(obj)
92        args = self.fixtype(args)
93        getattr(obj, methodname)(*args)
94
95    def test_count(self):
96        self.checkequal(3, 'aaa', 'count', 'a')
97        self.checkequal(0, 'aaa', 'count', 'b')
98        self.checkequal(3, 'aaa', 'count', 'a')
99        self.checkequal(0, 'aaa', 'count', 'b')
100        self.checkequal(3, 'aaa', 'count', 'a')
101        self.checkequal(0, 'aaa', 'count', 'b')
102        self.checkequal(0, 'aaa', 'count', 'b')
103        self.checkequal(2, 'aaa', 'count', 'a', 1)
104        self.checkequal(0, 'aaa', 'count', 'a', 10)
105        self.checkequal(1, 'aaa', 'count', 'a', -1)
106        self.checkequal(3, 'aaa', 'count', 'a', -10)
107        self.checkequal(1, 'aaa', 'count', 'a', 0, 1)
108        self.checkequal(3, 'aaa', 'count', 'a', 0, 10)
109        self.checkequal(2, 'aaa', 'count', 'a', 0, -1)
110        self.checkequal(0, 'aaa', 'count', 'a', 0, -10)
111        self.checkequal(3, 'aaa', 'count', '', 1)
112        self.checkequal(1, 'aaa', 'count', '', 3)
113        self.checkequal(0, 'aaa', 'count', '', 10)
114        self.checkequal(2, 'aaa', 'count', '', -1)
115        self.checkequal(4, 'aaa', 'count', '', -10)
116
117        self.checkequal(1, '', 'count', '')
118        self.checkequal(0, '', 'count', '', 1, 1)
119        self.checkequal(0, '', 'count', '', sys.maxsize, 0)
120
121        self.checkequal(0, '', 'count', 'xx')
122        self.checkequal(0, '', 'count', 'xx', 1, 1)
123        self.checkequal(0, '', 'count', 'xx', sys.maxsize, 0)
124
125        self.checkraises(TypeError, 'hello', 'count')
126
127        if self.contains_bytes:
128            self.checkequal(0, 'hello', 'count', 42)
129        else:
130            self.checkraises(TypeError, 'hello', 'count', 42)
131
132        # For a variety of combinations,
133        #    verify that str.count() matches an equivalent function
134        #    replacing all occurrences and then differencing the string lengths
135        charset = ['', 'a', 'b']
136        digits = 7
137        base = len(charset)
138        teststrings = set()
139        for i in range(base ** digits):
140            entry = []
141            for j in range(digits):
142                i, m = divmod(i, base)
143                entry.append(charset[m])
144            teststrings.add(''.join(entry))
145        teststrings = [self.fixtype(ts) for ts in teststrings]
146        for i in teststrings:
147            n = len(i)
148            for j in teststrings:
149                r1 = i.count(j)
150                if j:
151                    r2, rem = divmod(n - len(i.replace(j, self.fixtype(''))),
152                                     len(j))
153                else:
154                    r2, rem = len(i)+1, 0
155                if rem or r1 != r2:
156                    self.assertEqual(rem, 0, '%s != 0 for %s' % (rem, i))
157                    self.assertEqual(r1, r2, '%s != %s for %s' % (r1, r2, i))
158
159    def test_find(self):
160        self.checkequal(0, 'abcdefghiabc', 'find', 'abc')
161        self.checkequal(9, 'abcdefghiabc', 'find', 'abc', 1)
162        self.checkequal(-1, 'abcdefghiabc', 'find', 'def', 4)
163
164        self.checkequal(0, 'abc', 'find', '', 0)
165        self.checkequal(3, 'abc', 'find', '', 3)
166        self.checkequal(-1, 'abc', 'find', '', 4)
167
168        # to check the ability to pass None as defaults
169        self.checkequal( 2, 'rrarrrrrrrrra', 'find', 'a')
170        self.checkequal(12, 'rrarrrrrrrrra', 'find', 'a', 4)
171        self.checkequal(-1, 'rrarrrrrrrrra', 'find', 'a', 4, 6)
172        self.checkequal(12, 'rrarrrrrrrrra', 'find', 'a', 4, None)
173        self.checkequal( 2, 'rrarrrrrrrrra', 'find', 'a', None, 6)
174
175        self.checkraises(TypeError, 'hello', 'find')
176
177        if self.contains_bytes:
178            self.checkequal(-1, 'hello', 'find', 42)
179        else:
180            self.checkraises(TypeError, 'hello', 'find', 42)
181
182        self.checkequal(0, '', 'find', '')
183        self.checkequal(-1, '', 'find', '', 1, 1)
184        self.checkequal(-1, '', 'find', '', sys.maxsize, 0)
185
186        self.checkequal(-1, '', 'find', 'xx')
187        self.checkequal(-1, '', 'find', 'xx', 1, 1)
188        self.checkequal(-1, '', 'find', 'xx', sys.maxsize, 0)
189
190        # issue 7458
191        self.checkequal(-1, 'ab', 'find', 'xxx', sys.maxsize + 1, 0)
192
193        # For a variety of combinations,
194        #    verify that str.find() matches __contains__
195        #    and that the found substring is really at that location
196        charset = ['', 'a', 'b', 'c']
197        digits = 5
198        base = len(charset)
199        teststrings = set()
200        for i in range(base ** digits):
201            entry = []
202            for j in range(digits):
203                i, m = divmod(i, base)
204                entry.append(charset[m])
205            teststrings.add(''.join(entry))
206        teststrings = [self.fixtype(ts) for ts in teststrings]
207        for i in teststrings:
208            for j in teststrings:
209                loc = i.find(j)
210                r1 = (loc != -1)
211                r2 = j in i
212                self.assertEqual(r1, r2)
213                if loc != -1:
214                    self.assertEqual(i[loc:loc+len(j)], j)
215
216    def test_rfind(self):
217        self.checkequal(9,  'abcdefghiabc', 'rfind', 'abc')
218        self.checkequal(12, 'abcdefghiabc', 'rfind', '')
219        self.checkequal(0, 'abcdefghiabc', 'rfind', 'abcd')
220        self.checkequal(-1, 'abcdefghiabc', 'rfind', 'abcz')
221
222        self.checkequal(3, 'abc', 'rfind', '', 0)
223        self.checkequal(3, 'abc', 'rfind', '', 3)
224        self.checkequal(-1, 'abc', 'rfind', '', 4)
225
226        # to check the ability to pass None as defaults
227        self.checkequal(12, 'rrarrrrrrrrra', 'rfind', 'a')
228        self.checkequal(12, 'rrarrrrrrrrra', 'rfind', 'a', 4)
229        self.checkequal(-1, 'rrarrrrrrrrra', 'rfind', 'a', 4, 6)
230        self.checkequal(12, 'rrarrrrrrrrra', 'rfind', 'a', 4, None)
231        self.checkequal( 2, 'rrarrrrrrrrra', 'rfind', 'a', None, 6)
232
233        self.checkraises(TypeError, 'hello', 'rfind')
234
235        if self.contains_bytes:
236            self.checkequal(-1, 'hello', 'rfind', 42)
237        else:
238            self.checkraises(TypeError, 'hello', 'rfind', 42)
239
240        # For a variety of combinations,
241        #    verify that str.rfind() matches __contains__
242        #    and that the found substring is really at that location
243        charset = ['', 'a', 'b', 'c']
244        digits = 5
245        base = len(charset)
246        teststrings = set()
247        for i in range(base ** digits):
248            entry = []
249            for j in range(digits):
250                i, m = divmod(i, base)
251                entry.append(charset[m])
252            teststrings.add(''.join(entry))
253        teststrings = [self.fixtype(ts) for ts in teststrings]
254        for i in teststrings:
255            for j in teststrings:
256                loc = i.rfind(j)
257                r1 = (loc != -1)
258                r2 = j in i
259                self.assertEqual(r1, r2)
260                if loc != -1:
261                    self.assertEqual(i[loc:loc+len(j)], j)
262
263        # issue 7458
264        self.checkequal(-1, 'ab', 'rfind', 'xxx', sys.maxsize + 1, 0)
265
266        # issue #15534
267        self.checkequal(0, '<......\u043c...', "rfind", "<")
268
269    def test_index(self):
270        self.checkequal(0, 'abcdefghiabc', 'index', '')
271        self.checkequal(3, 'abcdefghiabc', 'index', 'def')
272        self.checkequal(0, 'abcdefghiabc', 'index', 'abc')
273        self.checkequal(9, 'abcdefghiabc', 'index', 'abc', 1)
274
275        self.checkraises(ValueError, 'abcdefghiabc', 'index', 'hib')
276        self.checkraises(ValueError, 'abcdefghiab', 'index', 'abc', 1)
277        self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', 8)
278        self.checkraises(ValueError, 'abcdefghi', 'index', 'ghi', -1)
279
280        # to check the ability to pass None as defaults
281        self.checkequal( 2, 'rrarrrrrrrrra', 'index', 'a')
282        self.checkequal(12, 'rrarrrrrrrrra', 'index', 'a', 4)
283        self.checkraises(ValueError, 'rrarrrrrrrrra', 'index', 'a', 4, 6)
284        self.checkequal(12, 'rrarrrrrrrrra', 'index', 'a', 4, None)
285        self.checkequal( 2, 'rrarrrrrrrrra', 'index', 'a', None, 6)
286
287        self.checkraises(TypeError, 'hello', 'index')
288
289        if self.contains_bytes:
290            self.checkraises(ValueError, 'hello', 'index', 42)
291        else:
292            self.checkraises(TypeError, 'hello', 'index', 42)
293
294    def test_rindex(self):
295        self.checkequal(12, 'abcdefghiabc', 'rindex', '')
296        self.checkequal(3,  'abcdefghiabc', 'rindex', 'def')
297        self.checkequal(9,  'abcdefghiabc', 'rindex', 'abc')
298        self.checkequal(0,  'abcdefghiabc', 'rindex', 'abc', 0, -1)
299
300        self.checkraises(ValueError, 'abcdefghiabc', 'rindex', 'hib')
301        self.checkraises(ValueError, 'defghiabc', 'rindex', 'def', 1)
302        self.checkraises(ValueError, 'defghiabc', 'rindex', 'abc', 0, -1)
303        self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, 8)
304        self.checkraises(ValueError, 'abcdefghi', 'rindex', 'ghi', 0, -1)
305
306        # to check the ability to pass None as defaults
307        self.checkequal(12, 'rrarrrrrrrrra', 'rindex', 'a')
308        self.checkequal(12, 'rrarrrrrrrrra', 'rindex', 'a', 4)
309        self.checkraises(ValueError, 'rrarrrrrrrrra', 'rindex', 'a', 4, 6)
310        self.checkequal(12, 'rrarrrrrrrrra', 'rindex', 'a', 4, None)
311        self.checkequal( 2, 'rrarrrrrrrrra', 'rindex', 'a', None, 6)
312
313        self.checkraises(TypeError, 'hello', 'rindex')
314
315        if self.contains_bytes:
316            self.checkraises(ValueError, 'hello', 'rindex', 42)
317        else:
318            self.checkraises(TypeError, 'hello', 'rindex', 42)
319
320    def test_lower(self):
321        self.checkequal('hello', 'HeLLo', 'lower')
322        self.checkequal('hello', 'hello', 'lower')
323        self.checkraises(TypeError, 'hello', 'lower', 42)
324
325    def test_upper(self):
326        self.checkequal('HELLO', 'HeLLo', 'upper')
327        self.checkequal('HELLO', 'HELLO', 'upper')
328        self.checkraises(TypeError, 'hello', 'upper', 42)
329
330    def test_expandtabs(self):
331        self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi',
332                        'expandtabs')
333        self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi',
334                        'expandtabs', 8)
335        self.checkequal('abc\rab  def\ng   hi', 'abc\rab\tdef\ng\thi',
336                        'expandtabs', 4)
337        self.checkequal('abc\r\nab      def\ng       hi', 'abc\r\nab\tdef\ng\thi',
338                        'expandtabs')
339        self.checkequal('abc\r\nab      def\ng       hi', 'abc\r\nab\tdef\ng\thi',
340                        'expandtabs', 8)
341        self.checkequal('abc\r\nab  def\ng   hi', 'abc\r\nab\tdef\ng\thi',
342                        'expandtabs', 4)
343        self.checkequal('abc\r\nab\r\ndef\ng\r\nhi', 'abc\r\nab\r\ndef\ng\r\nhi',
344                        'expandtabs', 4)
345        # check keyword args
346        self.checkequal('abc\rab      def\ng       hi', 'abc\rab\tdef\ng\thi',
347                        'expandtabs', tabsize=8)
348        self.checkequal('abc\rab  def\ng   hi', 'abc\rab\tdef\ng\thi',
349                        'expandtabs', tabsize=4)
350
351        self.checkequal('  a\n b', ' \ta\n\tb', 'expandtabs', 1)
352
353        self.checkraises(TypeError, 'hello', 'expandtabs', 42, 42)
354        # This test is only valid when sizeof(int) == sizeof(void*) == 4.
355        if sys.maxsize < (1 << 32) and struct.calcsize('P') == 4:
356            self.checkraises(OverflowError,
357                             '\ta\n\tb', 'expandtabs', sys.maxsize)
358
359    def test_split(self):
360        # by a char
361        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|')
362        self.checkequal(['a|b|c|d'], 'a|b|c|d', 'split', '|', 0)
363        self.checkequal(['a', 'b|c|d'], 'a|b|c|d', 'split', '|', 1)
364        self.checkequal(['a', 'b', 'c|d'], 'a|b|c|d', 'split', '|', 2)
365        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 3)
366        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 4)
367        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|',
368                        sys.maxsize-2)
369        self.checkequal(['a|b|c|d'], 'a|b|c|d', 'split', '|', 0)
370        self.checkequal(['a', '', 'b||c||d'], 'a||b||c||d', 'split', '|', 2)
371        self.checkequal(['abcd'], 'abcd', 'split', '|')
372        self.checkequal([''], '', 'split', '|')
373        self.checkequal(['endcase ', ''], 'endcase |', 'split', '|')
374        self.checkequal(['', ' startcase'], '| startcase', 'split', '|')
375        self.checkequal(['', 'bothcase', ''], '|bothcase|', 'split', '|')
376        self.checkequal(['a', '', 'b\x00c\x00d'], 'a\x00\x00b\x00c\x00d', 'split', '\x00', 2)
377
378        self.checkequal(['a']*20, ('a|'*20)[:-1], 'split', '|')
379        self.checkequal(['a']*15 +['a|a|a|a|a'],
380                                   ('a|'*20)[:-1], 'split', '|', 15)
381
382        # by string
383        self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//')
384        self.checkequal(['a', 'b//c//d'], 'a//b//c//d', 'split', '//', 1)
385        self.checkequal(['a', 'b', 'c//d'], 'a//b//c//d', 'split', '//', 2)
386        self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 3)
387        self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 4)
388        self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//',
389                        sys.maxsize-10)
390        self.checkequal(['a//b//c//d'], 'a//b//c//d', 'split', '//', 0)
391        self.checkequal(['a', '', 'b////c////d'], 'a////b////c////d', 'split', '//', 2)
392        self.checkequal(['endcase ', ''], 'endcase test', 'split', 'test')
393        self.checkequal(['', ' begincase'], 'test begincase', 'split', 'test')
394        self.checkequal(['', ' bothcase ', ''], 'test bothcase test',
395                        'split', 'test')
396        self.checkequal(['a', 'bc'], 'abbbc', 'split', 'bb')
397        self.checkequal(['', ''], 'aaa', 'split', 'aaa')
398        self.checkequal(['aaa'], 'aaa', 'split', 'aaa', 0)
399        self.checkequal(['ab', 'ab'], 'abbaab', 'split', 'ba')
400        self.checkequal(['aaaa'], 'aaaa', 'split', 'aab')
401        self.checkequal([''], '', 'split', 'aaa')
402        self.checkequal(['aa'], 'aa', 'split', 'aaa')
403        self.checkequal(['A', 'bobb'], 'Abbobbbobb', 'split', 'bbobb')
404        self.checkequal(['A', 'B', ''], 'AbbobbBbbobb', 'split', 'bbobb')
405
406        self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'split', 'BLAH')
407        self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'split', 'BLAH', 19)
408        self.checkequal(['a']*18 + ['aBLAHa'], ('aBLAH'*20)[:-4],
409                        'split', 'BLAH', 18)
410
411        # with keyword args
412        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', sep='|')
413        self.checkequal(['a', 'b|c|d'],
414                        'a|b|c|d', 'split', '|', maxsplit=1)
415        self.checkequal(['a', 'b|c|d'],
416                        'a|b|c|d', 'split', sep='|', maxsplit=1)
417        self.checkequal(['a', 'b|c|d'],
418                        'a|b|c|d', 'split', maxsplit=1, sep='|')
419        self.checkequal(['a', 'b c d'],
420                        'a b c d', 'split', maxsplit=1)
421
422        # argument type
423        self.checkraises(TypeError, 'hello', 'split', 42, 42, 42)
424
425        # null case
426        self.checkraises(ValueError, 'hello', 'split', '')
427        self.checkraises(ValueError, 'hello', 'split', '', 0)
428
429    def test_rsplit(self):
430        # by a char
431        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|')
432        self.checkequal(['a|b|c', 'd'], 'a|b|c|d', 'rsplit', '|', 1)
433        self.checkequal(['a|b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 2)
434        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 3)
435        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 4)
436        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|',
437                        sys.maxsize-100)
438        self.checkequal(['a|b|c|d'], 'a|b|c|d', 'rsplit', '|', 0)
439        self.checkequal(['a||b||c', '', 'd'], 'a||b||c||d', 'rsplit', '|', 2)
440        self.checkequal(['abcd'], 'abcd', 'rsplit', '|')
441        self.checkequal([''], '', 'rsplit', '|')
442        self.checkequal(['', ' begincase'], '| begincase', 'rsplit', '|')
443        self.checkequal(['endcase ', ''], 'endcase |', 'rsplit', '|')
444        self.checkequal(['', 'bothcase', ''], '|bothcase|', 'rsplit', '|')
445
446        self.checkequal(['a\x00\x00b', 'c', 'd'], 'a\x00\x00b\x00c\x00d', 'rsplit', '\x00', 2)
447
448        self.checkequal(['a']*20, ('a|'*20)[:-1], 'rsplit', '|')
449        self.checkequal(['a|a|a|a|a']+['a']*15,
450                        ('a|'*20)[:-1], 'rsplit', '|', 15)
451
452        # by string
453        self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//')
454        self.checkequal(['a//b//c', 'd'], 'a//b//c//d', 'rsplit', '//', 1)
455        self.checkequal(['a//b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 2)
456        self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 3)
457        self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 4)
458        self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//',
459                        sys.maxsize-5)
460        self.checkequal(['a//b//c//d'], 'a//b//c//d', 'rsplit', '//', 0)
461        self.checkequal(['a////b////c', '', 'd'], 'a////b////c////d', 'rsplit', '//', 2)
462        self.checkequal(['', ' begincase'], 'test begincase', 'rsplit', 'test')
463        self.checkequal(['endcase ', ''], 'endcase test', 'rsplit', 'test')
464        self.checkequal(['', ' bothcase ', ''], 'test bothcase test',
465                        'rsplit', 'test')
466        self.checkequal(['ab', 'c'], 'abbbc', 'rsplit', 'bb')
467        self.checkequal(['', ''], 'aaa', 'rsplit', 'aaa')
468        self.checkequal(['aaa'], 'aaa', 'rsplit', 'aaa', 0)
469        self.checkequal(['ab', 'ab'], 'abbaab', 'rsplit', 'ba')
470        self.checkequal(['aaaa'], 'aaaa', 'rsplit', 'aab')
471        self.checkequal([''], '', 'rsplit', 'aaa')
472        self.checkequal(['aa'], 'aa', 'rsplit', 'aaa')
473        self.checkequal(['bbob', 'A'], 'bbobbbobbA', 'rsplit', 'bbobb')
474        self.checkequal(['', 'B', 'A'], 'bbobbBbbobbA', 'rsplit', 'bbobb')
475
476        self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'rsplit', 'BLAH')
477        self.checkequal(['a']*20, ('aBLAH'*20)[:-4], 'rsplit', 'BLAH', 19)
478        self.checkequal(['aBLAHa'] + ['a']*18, ('aBLAH'*20)[:-4],
479                        'rsplit', 'BLAH', 18)
480
481        # with keyword args
482        self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', sep='|')
483        self.checkequal(['a|b|c', 'd'],
484                        'a|b|c|d', 'rsplit', '|', maxsplit=1)
485        self.checkequal(['a|b|c', 'd'],
486                        'a|b|c|d', 'rsplit', sep='|', maxsplit=1)
487        self.checkequal(['a|b|c', 'd'],
488                        'a|b|c|d', 'rsplit', maxsplit=1, sep='|')
489        self.checkequal(['a b c', 'd'],
490                        'a b c d', 'rsplit', maxsplit=1)
491
492        # argument type
493        self.checkraises(TypeError, 'hello', 'rsplit', 42, 42, 42)
494
495        # null case
496        self.checkraises(ValueError, 'hello', 'rsplit', '')
497        self.checkraises(ValueError, 'hello', 'rsplit', '', 0)
498
499    def test_replace(self):
500        EQ = self.checkequal
501
502        # Operations on the empty string
503        EQ("", "", "replace", "", "")
504        EQ("A", "", "replace", "", "A")
505        EQ("", "", "replace", "A", "")
506        EQ("", "", "replace", "A", "A")
507        EQ("", "", "replace", "", "", 100)
508        EQ("", "", "replace", "", "", sys.maxsize)
509
510        # interleave (from=="", 'to' gets inserted everywhere)
511        EQ("A", "A", "replace", "", "")
512        EQ("*A*", "A", "replace", "", "*")
513        EQ("*1A*1", "A", "replace", "", "*1")
514        EQ("*-#A*-#", "A", "replace", "", "*-#")
515        EQ("*-A*-A*-", "AA", "replace", "", "*-")
516        EQ("*-A*-A*-", "AA", "replace", "", "*-", -1)
517        EQ("*-A*-A*-", "AA", "replace", "", "*-", sys.maxsize)
518        EQ("*-A*-A*-", "AA", "replace", "", "*-", 4)
519        EQ("*-A*-A*-", "AA", "replace", "", "*-", 3)
520        EQ("*-A*-A", "AA", "replace", "", "*-", 2)
521        EQ("*-AA", "AA", "replace", "", "*-", 1)
522        EQ("AA", "AA", "replace", "", "*-", 0)
523
524        # single character deletion (from=="A", to=="")
525        EQ("", "A", "replace", "A", "")
526        EQ("", "AAA", "replace", "A", "")
527        EQ("", "AAA", "replace", "A", "", -1)
528        EQ("", "AAA", "replace", "A", "", sys.maxsize)
529        EQ("", "AAA", "replace", "A", "", 4)
530        EQ("", "AAA", "replace", "A", "", 3)
531        EQ("A", "AAA", "replace", "A", "", 2)
532        EQ("AA", "AAA", "replace", "A", "", 1)
533        EQ("AAA", "AAA", "replace", "A", "", 0)
534        EQ("", "AAAAAAAAAA", "replace", "A", "")
535        EQ("BCD", "ABACADA", "replace", "A", "")
536        EQ("BCD", "ABACADA", "replace", "A", "", -1)
537        EQ("BCD", "ABACADA", "replace", "A", "", sys.maxsize)
538        EQ("BCD", "ABACADA", "replace", "A", "", 5)
539        EQ("BCD", "ABACADA", "replace", "A", "", 4)
540        EQ("BCDA", "ABACADA", "replace", "A", "", 3)
541        EQ("BCADA", "ABACADA", "replace", "A", "", 2)
542        EQ("BACADA", "ABACADA", "replace", "A", "", 1)
543        EQ("ABACADA", "ABACADA", "replace", "A", "", 0)
544        EQ("BCD", "ABCAD", "replace", "A", "")
545        EQ("BCD", "ABCADAA", "replace", "A", "")
546        EQ("BCD", "BCD", "replace", "A", "")
547        EQ("*************", "*************", "replace", "A", "")
548        EQ("^A^", "^"+"A"*1000+"^", "replace", "A", "", 999)
549
550        # substring deletion (from=="the", to=="")
551        EQ("", "the", "replace", "the", "")
552        EQ("ater", "theater", "replace", "the", "")
553        EQ("", "thethe", "replace", "the", "")
554        EQ("", "thethethethe", "replace", "the", "")
555        EQ("aaaa", "theatheatheathea", "replace", "the", "")
556        EQ("that", "that", "replace", "the", "")
557        EQ("thaet", "thaet", "replace", "the", "")
558        EQ("here and re", "here and there", "replace", "the", "")
559        EQ("here and re and re", "here and there and there",
560           "replace", "the", "", sys.maxsize)
561        EQ("here and re and re", "here and there and there",
562           "replace", "the", "", -1)
563        EQ("here and re and re", "here and there and there",
564           "replace", "the", "", 3)
565        EQ("here and re and re", "here and there and there",
566           "replace", "the", "", 2)
567        EQ("here and re and there", "here and there and there",
568           "replace", "the", "", 1)
569        EQ("here and there and there", "here and there and there",
570           "replace", "the", "", 0)
571        EQ("here and re and re", "here and there and there", "replace", "the", "")
572
573        EQ("abc", "abc", "replace", "the", "")
574        EQ("abcdefg", "abcdefg", "replace", "the", "")
575
576        # substring deletion (from=="bob", to=="")
577        EQ("bob", "bbobob", "replace", "bob", "")
578        EQ("bobXbob", "bbobobXbbobob", "replace", "bob", "")
579        EQ("aaaaaaa", "aaaaaaabob", "replace", "bob", "")
580        EQ("aaaaaaa", "aaaaaaa", "replace", "bob", "")
581
582        # single character replace in place (len(from)==len(to)==1)
583        EQ("Who goes there?", "Who goes there?", "replace", "o", "o")
584        EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O")
585        EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", sys.maxsize)
586        EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", -1)
587        EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 3)
588        EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 2)
589        EQ("WhO goes there?", "Who goes there?", "replace", "o", "O", 1)
590        EQ("Who goes there?", "Who goes there?", "replace", "o", "O", 0)
591
592        EQ("Who goes there?", "Who goes there?", "replace", "a", "q")
593        EQ("who goes there?", "Who goes there?", "replace", "W", "w")
594        EQ("wwho goes there?ww", "WWho goes there?WW", "replace", "W", "w")
595        EQ("Who goes there!", "Who goes there?", "replace", "?", "!")
596        EQ("Who goes there!!", "Who goes there??", "replace", "?", "!")
597
598        EQ("Who goes there?", "Who goes there?", "replace", ".", "!")
599
600        # substring replace in place (len(from)==len(to) > 1)
601        EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**")
602        EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", sys.maxsize)
603        EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", -1)
604        EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 4)
605        EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 3)
606        EQ("Th** ** a tissue", "This is a tissue", "replace", "is", "**", 2)
607        EQ("Th** is a tissue", "This is a tissue", "replace", "is", "**", 1)
608        EQ("This is a tissue", "This is a tissue", "replace", "is", "**", 0)
609        EQ("cobob", "bobob", "replace", "bob", "cob")
610        EQ("cobobXcobocob", "bobobXbobobob", "replace", "bob", "cob")
611        EQ("bobob", "bobob", "replace", "bot", "bot")
612
613        # replace single character (len(from)==1, len(to)>1)
614        EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK")
615        EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", -1)
616        EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", sys.maxsize)
617        EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", 2)
618        EQ("ReyKKjavik", "Reykjavik", "replace", "k", "KK", 1)
619        EQ("Reykjavik", "Reykjavik", "replace", "k", "KK", 0)
620        EQ("A----B----C----", "A.B.C.", "replace", ".", "----")
621        # issue #15534
622        EQ('...\u043c......&lt;', '...\u043c......<', "replace", "<", "&lt;")
623
624        EQ("Reykjavik", "Reykjavik", "replace", "q", "KK")
625
626        # replace substring (len(from)>1, len(to)!=len(from))
627        EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",
628           "replace", "spam", "ham")
629        EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",
630           "replace", "spam", "ham", sys.maxsize)
631        EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",
632           "replace", "spam", "ham", -1)
633        EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",
634           "replace", "spam", "ham", 4)
635        EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",
636           "replace", "spam", "ham", 3)
637        EQ("ham, ham, eggs and spam", "spam, spam, eggs and spam",
638           "replace", "spam", "ham", 2)
639        EQ("ham, spam, eggs and spam", "spam, spam, eggs and spam",
640           "replace", "spam", "ham", 1)
641        EQ("spam, spam, eggs and spam", "spam, spam, eggs and spam",
642           "replace", "spam", "ham", 0)
643
644        EQ("bobob", "bobobob", "replace", "bobob", "bob")
645        EQ("bobobXbobob", "bobobobXbobobob", "replace", "bobob", "bob")
646        EQ("BOBOBOB", "BOBOBOB", "replace", "bob", "bobby")
647
648        self.checkequal('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
649        self.checkequal('onetwothree', 'one!two!three!', 'replace', '!', '')
650        self.checkequal('one@two@three!', 'one!two!three!', 'replace', '!', '@', 2)
651        self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 3)
652        self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@', 4)
653        self.checkequal('one!two!three!', 'one!two!three!', 'replace', '!', '@', 0)
654        self.checkequal('one@two@three@', 'one!two!three!', 'replace', '!', '@')
655        self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@')
656        self.checkequal('one!two!three!', 'one!two!three!', 'replace', 'x', '@', 2)
657        self.checkequal('-a-b-c-', 'abc', 'replace', '', '-')
658        self.checkequal('-a-b-c', 'abc', 'replace', '', '-', 3)
659        self.checkequal('abc', 'abc', 'replace', '', '-', 0)
660        self.checkequal('', '', 'replace', '', '')
661        self.checkequal('abc', 'abc', 'replace', 'ab', '--', 0)
662        self.checkequal('abc', 'abc', 'replace', 'xy', '--')
663        # Next three for SF bug 422088: [OSF1 alpha] string.replace(); died with
664        # MemoryError due to empty result (platform malloc issue when requesting
665        # 0 bytes).
666        self.checkequal('', '123', 'replace', '123', '')
667        self.checkequal('', '123123', 'replace', '123', '')
668        self.checkequal('x', '123x123', 'replace', '123', '')
669
670        self.checkraises(TypeError, 'hello', 'replace')
671        self.checkraises(TypeError, 'hello', 'replace', 42)
672        self.checkraises(TypeError, 'hello', 'replace', 42, 'h')
673        self.checkraises(TypeError, 'hello', 'replace', 'h', 42)
674
675    @unittest.skipIf(sys.maxsize > (1 << 32) or struct.calcsize('P') != 4,
676                     'only applies to 32-bit platforms')
677    def test_replace_overflow(self):
678        # Check for overflow checking on 32 bit machines
679        A2_16 = "A" * (2**16)
680        self.checkraises(OverflowError, A2_16, "replace", "", A2_16)
681        self.checkraises(OverflowError, A2_16, "replace", "A", A2_16)
682        self.checkraises(OverflowError, A2_16, "replace", "AA", A2_16+A2_16)
683
684    def test_capitalize(self):
685        self.checkequal(' hello ', ' hello ', 'capitalize')
686        self.checkequal('Hello ', 'Hello ','capitalize')
687        self.checkequal('Hello ', 'hello ','capitalize')
688        self.checkequal('Aaaa', 'aaaa', 'capitalize')
689        self.checkequal('Aaaa', 'AaAa', 'capitalize')
690
691        self.checkraises(TypeError, 'hello', 'capitalize', 42)
692
693    def test_additional_split(self):
694        self.checkequal(['this', 'is', 'the', 'split', 'function'],
695            'this is the split function', 'split')
696
697        # by whitespace
698        self.checkequal(['a', 'b', 'c', 'd'], 'a b c d ', 'split')
699        self.checkequal(['a', 'b c d'], 'a b c d', 'split', None, 1)
700        self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2)
701        self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 3)
702        self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 4)
703        self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None,
704                        sys.maxsize-1)
705        self.checkequal(['a b c d'], 'a b c d', 'split', None, 0)
706        self.checkequal(['a b c d'], '  a b c d', 'split', None, 0)
707        self.checkequal(['a', 'b', 'c  d'], 'a  b  c  d', 'split', None, 2)
708
709        self.checkequal([], '         ', 'split')
710        self.checkequal(['a'], '  a    ', 'split')
711        self.checkequal(['a', 'b'], '  a    b   ', 'split')
712        self.checkequal(['a', 'b   '], '  a    b   ', 'split', None, 1)
713        self.checkequal(['a    b   c   '], '  a    b   c   ', 'split', None, 0)
714        self.checkequal(['a', 'b   c   '], '  a    b   c   ', 'split', None, 1)
715        self.checkequal(['a', 'b', 'c   '], '  a    b   c   ', 'split', None, 2)
716        self.checkequal(['a', 'b', 'c'], '  a    b   c   ', 'split', None, 3)
717        self.checkequal(['a', 'b'], '\n\ta \t\r b \v ', 'split')
718        aaa = ' a '*20
719        self.checkequal(['a']*20, aaa, 'split')
720        self.checkequal(['a'] + [aaa[4:]], aaa, 'split', None, 1)
721        self.checkequal(['a']*19 + ['a '], aaa, 'split', None, 19)
722
723        for b in ('arf\tbarf', 'arf\nbarf', 'arf\rbarf',
724                  'arf\fbarf', 'arf\vbarf'):
725            self.checkequal(['arf', 'barf'], b, 'split')
726            self.checkequal(['arf', 'barf'], b, 'split', None)
727            self.checkequal(['arf', 'barf'], b, 'split', None, 2)
728
729    def test_additional_rsplit(self):
730        self.checkequal(['this', 'is', 'the', 'rsplit', 'function'],
731                         'this is the rsplit function', 'rsplit')
732
733        # by whitespace
734        self.checkequal(['a', 'b', 'c', 'd'], 'a b c d ', 'rsplit')
735        self.checkequal(['a b c', 'd'], 'a b c d', 'rsplit', None, 1)
736        self.checkequal(['a b', 'c', 'd'], 'a b c d', 'rsplit', None, 2)
737        self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 3)
738        self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 4)
739        self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None,
740                        sys.maxsize-20)
741        self.checkequal(['a b c d'], 'a b c d', 'rsplit', None, 0)
742        self.checkequal(['a b c d'], 'a b c d  ', 'rsplit', None, 0)
743        self.checkequal(['a  b', 'c', 'd'], 'a  b  c  d', 'rsplit', None, 2)
744
745        self.checkequal([], '         ', 'rsplit')
746        self.checkequal(['a'], '  a    ', 'rsplit')
747        self.checkequal(['a', 'b'], '  a    b   ', 'rsplit')
748        self.checkequal(['  a', 'b'], '  a    b   ', 'rsplit', None, 1)
749        self.checkequal(['  a    b   c'], '  a    b   c   ', 'rsplit',
750                        None, 0)
751        self.checkequal(['  a    b','c'], '  a    b   c   ', 'rsplit',
752                        None, 1)
753        self.checkequal(['  a', 'b', 'c'], '  a    b   c   ', 'rsplit',
754                        None, 2)
755        self.checkequal(['a', 'b', 'c'], '  a    b   c   ', 'rsplit',
756                        None, 3)
757        self.checkequal(['a', 'b'], '\n\ta \t\r b \v ', 'rsplit', None, 88)
758        aaa = ' a '*20
759        self.checkequal(['a']*20, aaa, 'rsplit')
760        self.checkequal([aaa[:-4]] + ['a'], aaa, 'rsplit', None, 1)
761        self.checkequal([' a  a'] + ['a']*18, aaa, 'rsplit', None, 18)
762
763        for b in ('arf\tbarf', 'arf\nbarf', 'arf\rbarf',
764                  'arf\fbarf', 'arf\vbarf'):
765            self.checkequal(['arf', 'barf'], b, 'rsplit')
766            self.checkequal(['arf', 'barf'], b, 'rsplit', None)
767            self.checkequal(['arf', 'barf'], b, 'rsplit', None, 2)
768
769    def test_strip_whitespace(self):
770        self.checkequal('hello', '   hello   ', 'strip')
771        self.checkequal('hello   ', '   hello   ', 'lstrip')
772        self.checkequal('   hello', '   hello   ', 'rstrip')
773        self.checkequal('hello', 'hello', 'strip')
774
775        b = ' \t\n\r\f\vabc \t\n\r\f\v'
776        self.checkequal('abc', b, 'strip')
777        self.checkequal('abc \t\n\r\f\v', b, 'lstrip')
778        self.checkequal(' \t\n\r\f\vabc', b, 'rstrip')
779
780        # strip/lstrip/rstrip with None arg
781        self.checkequal('hello', '   hello   ', 'strip', None)
782        self.checkequal('hello   ', '   hello   ', 'lstrip', None)
783        self.checkequal('   hello', '   hello   ', 'rstrip', None)
784        self.checkequal('hello', 'hello', 'strip', None)
785
786    def test_strip(self):
787        # strip/lstrip/rstrip with str arg
788        self.checkequal('hello', 'xyzzyhelloxyzzy', 'strip', 'xyz')
789        self.checkequal('helloxyzzy', 'xyzzyhelloxyzzy', 'lstrip', 'xyz')
790        self.checkequal('xyzzyhello', 'xyzzyhelloxyzzy', 'rstrip', 'xyz')
791        self.checkequal('hello', 'hello', 'strip', 'xyz')
792        self.checkequal('', 'mississippi', 'strip', 'mississippi')
793
794        # only trim the start and end; does not strip internal characters
795        self.checkequal('mississipp', 'mississippi', 'strip', 'i')
796
797        self.checkraises(TypeError, 'hello', 'strip', 42, 42)
798        self.checkraises(TypeError, 'hello', 'lstrip', 42, 42)
799        self.checkraises(TypeError, 'hello', 'rstrip', 42, 42)
800
801    def test_ljust(self):
802        self.checkequal('abc       ', 'abc', 'ljust', 10)
803        self.checkequal('abc   ', 'abc', 'ljust', 6)
804        self.checkequal('abc', 'abc', 'ljust', 3)
805        self.checkequal('abc', 'abc', 'ljust', 2)
806        self.checkequal('abc*******', 'abc', 'ljust', 10, '*')
807        self.checkraises(TypeError, 'abc', 'ljust')
808
809    def test_rjust(self):
810        self.checkequal('       abc', 'abc', 'rjust', 10)
811        self.checkequal('   abc', 'abc', 'rjust', 6)
812        self.checkequal('abc', 'abc', 'rjust', 3)
813        self.checkequal('abc', 'abc', 'rjust', 2)
814        self.checkequal('*******abc', 'abc', 'rjust', 10, '*')
815        self.checkraises(TypeError, 'abc', 'rjust')
816
817    def test_center(self):
818        self.checkequal('   abc    ', 'abc', 'center', 10)
819        self.checkequal(' abc  ', 'abc', 'center', 6)
820        self.checkequal('abc', 'abc', 'center', 3)
821        self.checkequal('abc', 'abc', 'center', 2)
822        self.checkequal('***abc****', 'abc', 'center', 10, '*')
823        self.checkraises(TypeError, 'abc', 'center')
824
825    def test_swapcase(self):
826        self.checkequal('hEllO CoMPuTErS', 'HeLLo cOmpUteRs', 'swapcase')
827
828        self.checkraises(TypeError, 'hello', 'swapcase', 42)
829
830    def test_zfill(self):
831        self.checkequal('123', '123', 'zfill', 2)
832        self.checkequal('123', '123', 'zfill', 3)
833        self.checkequal('0123', '123', 'zfill', 4)
834        self.checkequal('+123', '+123', 'zfill', 3)
835        self.checkequal('+123', '+123', 'zfill', 4)
836        self.checkequal('+0123', '+123', 'zfill', 5)
837        self.checkequal('-123', '-123', 'zfill', 3)
838        self.checkequal('-123', '-123', 'zfill', 4)
839        self.checkequal('-0123', '-123', 'zfill', 5)
840        self.checkequal('000', '', 'zfill', 3)
841        self.checkequal('34', '34', 'zfill', 1)
842        self.checkequal('0034', '34', 'zfill', 4)
843
844        self.checkraises(TypeError, '123', 'zfill')
845
846    def test_islower(self):
847        self.checkequal(False, '', 'islower')
848        self.checkequal(True, 'a', 'islower')
849        self.checkequal(False, 'A', 'islower')
850        self.checkequal(False, '\n', 'islower')
851        self.checkequal(True, 'abc', 'islower')
852        self.checkequal(False, 'aBc', 'islower')
853        self.checkequal(True, 'abc\n', 'islower')
854        self.checkraises(TypeError, 'abc', 'islower', 42)
855
856    def test_isupper(self):
857        self.checkequal(False, '', 'isupper')
858        self.checkequal(False, 'a', 'isupper')
859        self.checkequal(True, 'A', 'isupper')
860        self.checkequal(False, '\n', 'isupper')
861        self.checkequal(True, 'ABC', 'isupper')
862        self.checkequal(False, 'AbC', 'isupper')
863        self.checkequal(True, 'ABC\n', 'isupper')
864        self.checkraises(TypeError, 'abc', 'isupper', 42)
865
866    def test_istitle(self):
867        self.checkequal(False, '', 'istitle')
868        self.checkequal(False, 'a', 'istitle')
869        self.checkequal(True, 'A', 'istitle')
870        self.checkequal(False, '\n', 'istitle')
871        self.checkequal(True, 'A Titlecased Line', 'istitle')
872        self.checkequal(True, 'A\nTitlecased Line', 'istitle')
873        self.checkequal(True, 'A Titlecased, Line', 'istitle')
874        self.checkequal(False, 'Not a capitalized String', 'istitle')
875        self.checkequal(False, 'Not\ta Titlecase String', 'istitle')
876        self.checkequal(False, 'Not--a Titlecase String', 'istitle')
877        self.checkequal(False, 'NOT', 'istitle')
878        self.checkraises(TypeError, 'abc', 'istitle', 42)
879
880    def test_isspace(self):
881        self.checkequal(False, '', 'isspace')
882        self.checkequal(False, 'a', 'isspace')
883        self.checkequal(True, ' ', 'isspace')
884        self.checkequal(True, '\t', 'isspace')
885        self.checkequal(True, '\r', 'isspace')
886        self.checkequal(True, '\n', 'isspace')
887        self.checkequal(True, ' \t\r\n', 'isspace')
888        self.checkequal(False, ' \t\r\na', 'isspace')
889        self.checkraises(TypeError, 'abc', 'isspace', 42)
890
891    def test_isalpha(self):
892        self.checkequal(False, '', 'isalpha')
893        self.checkequal(True, 'a', 'isalpha')
894        self.checkequal(True, 'A', 'isalpha')
895        self.checkequal(False, '\n', 'isalpha')
896        self.checkequal(True, 'abc', 'isalpha')
897        self.checkequal(False, 'aBc123', 'isalpha')
898        self.checkequal(False, 'abc\n', 'isalpha')
899        self.checkraises(TypeError, 'abc', 'isalpha', 42)
900
901    def test_isalnum(self):
902        self.checkequal(False, '', 'isalnum')
903        self.checkequal(True, 'a', 'isalnum')
904        self.checkequal(True, 'A', 'isalnum')
905        self.checkequal(False, '\n', 'isalnum')
906        self.checkequal(True, '123abc456', 'isalnum')
907        self.checkequal(True, 'a1b3c', 'isalnum')
908        self.checkequal(False, 'aBc000 ', 'isalnum')
909        self.checkequal(False, 'abc\n', 'isalnum')
910        self.checkraises(TypeError, 'abc', 'isalnum', 42)
911
912    def test_isascii(self):
913        self.checkequal(True, '', 'isascii')
914        self.checkequal(True, '\x00', 'isascii')
915        self.checkequal(True, '\x7f', 'isascii')
916        self.checkequal(True, '\x00\x7f', 'isascii')
917        self.checkequal(False, '\x80', 'isascii')
918        self.checkequal(False, '\xe9', 'isascii')
919        # bytes.isascii() and bytearray.isascii() has optimization which
920        # check 4 or 8 bytes at once.  So check some alignments.
921        for p in range(8):
922            self.checkequal(True, ' '*p + '\x7f', 'isascii')
923            self.checkequal(False, ' '*p + '\x80', 'isascii')
924            self.checkequal(True, ' '*p + '\x7f' + ' '*8, 'isascii')
925            self.checkequal(False, ' '*p + '\x80' + ' '*8, 'isascii')
926
927    def test_isdigit(self):
928        self.checkequal(False, '', 'isdigit')
929        self.checkequal(False, 'a', 'isdigit')
930        self.checkequal(True, '0', 'isdigit')
931        self.checkequal(True, '0123456789', 'isdigit')
932        self.checkequal(False, '0123456789a', 'isdigit')
933
934        self.checkraises(TypeError, 'abc', 'isdigit', 42)
935
936    def test_title(self):
937        self.checkequal(' Hello ', ' hello ', 'title')
938        self.checkequal('Hello ', 'hello ', 'title')
939        self.checkequal('Hello ', 'Hello ', 'title')
940        self.checkequal('Format This As Title String', "fOrMaT thIs aS titLe String", 'title')
941        self.checkequal('Format,This-As*Title;String', "fOrMaT,thIs-aS*titLe;String", 'title', )
942        self.checkequal('Getint', "getInt", 'title')
943        self.checkraises(TypeError, 'hello', 'title', 42)
944
945    def test_splitlines(self):
946        self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\rghi", 'splitlines')
947        self.checkequal(['abc', 'def', '', 'ghi'], "abc\ndef\n\r\nghi", 'splitlines')
948        self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi", 'splitlines')
949        self.checkequal(['abc', 'def', 'ghi'], "abc\ndef\r\nghi\n", 'splitlines')
950        self.checkequal(['abc', 'def', 'ghi', ''], "abc\ndef\r\nghi\n\r", 'splitlines')
951        self.checkequal(['', 'abc', 'def', 'ghi', ''], "\nabc\ndef\r\nghi\n\r", 'splitlines')
952        self.checkequal(['', 'abc', 'def', 'ghi', ''],
953                        "\nabc\ndef\r\nghi\n\r", 'splitlines', False)
954        self.checkequal(['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'],
955                        "\nabc\ndef\r\nghi\n\r", 'splitlines', True)
956        self.checkequal(['', 'abc', 'def', 'ghi', ''], "\nabc\ndef\r\nghi\n\r",
957                        'splitlines', keepends=False)
958        self.checkequal(['\n', 'abc\n', 'def\r\n', 'ghi\n', '\r'],
959                        "\nabc\ndef\r\nghi\n\r", 'splitlines', keepends=True)
960
961        self.checkraises(TypeError, 'abc', 'splitlines', 42, 42)
962
963
964class CommonTest(BaseTest):
965    # This testcase contains tests that can be used in all
966    # stringlike classes. Currently this is str and UserString.
967
968    def test_hash(self):
969        # SF bug 1054139:  += optimization was not invalidating cached hash value
970        a = self.type2test('DNSSEC')
971        b = self.type2test('')
972        for c in a:
973            b += c
974            hash(b)
975        self.assertEqual(hash(a), hash(b))
976
977    def test_capitalize_nonascii(self):
978        # check that titlecased chars are lowered correctly
979        # \u1ffc is the titlecased char
980        self.checkequal('\u1ffc\u1ff3\u1ff3\u1ff3',
981                        '\u1ff3\u1ff3\u1ffc\u1ffc', 'capitalize')
982        # check with cased non-letter chars
983        self.checkequal('\u24c5\u24e8\u24e3\u24d7\u24de\u24dd',
984                        '\u24c5\u24ce\u24c9\u24bd\u24c4\u24c3', 'capitalize')
985        self.checkequal('\u24c5\u24e8\u24e3\u24d7\u24de\u24dd',
986                        '\u24df\u24e8\u24e3\u24d7\u24de\u24dd', 'capitalize')
987        self.checkequal('\u2160\u2171\u2172',
988                        '\u2160\u2161\u2162', 'capitalize')
989        self.checkequal('\u2160\u2171\u2172',
990                        '\u2170\u2171\u2172', 'capitalize')
991        # check with Ll chars with no upper - nothing changes here
992        self.checkequal('\u019b\u1d00\u1d86\u0221\u1fb7',
993                        '\u019b\u1d00\u1d86\u0221\u1fb7', 'capitalize')
994
995
996class MixinStrUnicodeUserStringTest:
997    # additional tests that only work for
998    # stringlike objects, i.e. str, UserString
999
1000    def test_startswith(self):
1001        self.checkequal(True, 'hello', 'startswith', 'he')
1002        self.checkequal(True, 'hello', 'startswith', 'hello')
1003        self.checkequal(False, 'hello', 'startswith', 'hello world')
1004        self.checkequal(True, 'hello', 'startswith', '')
1005        self.checkequal(False, 'hello', 'startswith', 'ello')
1006        self.checkequal(True, 'hello', 'startswith', 'ello', 1)
1007        self.checkequal(True, 'hello', 'startswith', 'o', 4)
1008        self.checkequal(False, 'hello', 'startswith', 'o', 5)
1009        self.checkequal(True, 'hello', 'startswith', '', 5)
1010        self.checkequal(False, 'hello', 'startswith', 'lo', 6)
1011        self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3)
1012        self.checkequal(True, 'helloworld', 'startswith', 'lowo', 3, 7)
1013        self.checkequal(False, 'helloworld', 'startswith', 'lowo', 3, 6)
1014        self.checkequal(True, '', 'startswith', '', 0, 1)
1015        self.checkequal(True, '', 'startswith', '', 0, 0)
1016        self.checkequal(False, '', 'startswith', '', 1, 0)
1017
1018        # test negative indices
1019        self.checkequal(True, 'hello', 'startswith', 'he', 0, -1)
1020        self.checkequal(True, 'hello', 'startswith', 'he', -53, -1)
1021        self.checkequal(False, 'hello', 'startswith', 'hello', 0, -1)
1022        self.checkequal(False, 'hello', 'startswith', 'hello world', -1, -10)
1023        self.checkequal(False, 'hello', 'startswith', 'ello', -5)
1024        self.checkequal(True, 'hello', 'startswith', 'ello', -4)
1025        self.checkequal(False, 'hello', 'startswith', 'o', -2)
1026        self.checkequal(True, 'hello', 'startswith', 'o', -1)
1027        self.checkequal(True, 'hello', 'startswith', '', -3, -3)
1028        self.checkequal(False, 'hello', 'startswith', 'lo', -9)
1029
1030        self.checkraises(TypeError, 'hello', 'startswith')
1031        self.checkraises(TypeError, 'hello', 'startswith', 42)
1032
1033        # test tuple arguments
1034        self.checkequal(True, 'hello', 'startswith', ('he', 'ha'))
1035        self.checkequal(False, 'hello', 'startswith', ('lo', 'llo'))
1036        self.checkequal(True, 'hello', 'startswith', ('hellox', 'hello'))
1037        self.checkequal(False, 'hello', 'startswith', ())
1038        self.checkequal(True, 'helloworld', 'startswith', ('hellowo',
1039                                                           'rld', 'lowo'), 3)
1040        self.checkequal(False, 'helloworld', 'startswith', ('hellowo', 'ello',
1041                                                            'rld'), 3)
1042        self.checkequal(True, 'hello', 'startswith', ('lo', 'he'), 0, -1)
1043        self.checkequal(False, 'hello', 'startswith', ('he', 'hel'), 0, 1)
1044        self.checkequal(True, 'hello', 'startswith', ('he', 'hel'), 0, 2)
1045
1046        self.checkraises(TypeError, 'hello', 'startswith', (42,))
1047
1048    def test_endswith(self):
1049        self.checkequal(True, 'hello', 'endswith', 'lo')
1050        self.checkequal(False, 'hello', 'endswith', 'he')
1051        self.checkequal(True, 'hello', 'endswith', '')
1052        self.checkequal(False, 'hello', 'endswith', 'hello world')
1053        self.checkequal(False, 'helloworld', 'endswith', 'worl')
1054        self.checkequal(True, 'helloworld', 'endswith', 'worl', 3, 9)
1055        self.checkequal(True, 'helloworld', 'endswith', 'world', 3, 12)
1056        self.checkequal(True, 'helloworld', 'endswith', 'lowo', 1, 7)
1057        self.checkequal(True, 'helloworld', 'endswith', 'lowo', 2, 7)
1058        self.checkequal(True, 'helloworld', 'endswith', 'lowo', 3, 7)
1059        self.checkequal(False, 'helloworld', 'endswith', 'lowo', 4, 7)
1060        self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, 8)
1061        self.checkequal(False, 'ab', 'endswith', 'ab', 0, 1)
1062        self.checkequal(False, 'ab', 'endswith', 'ab', 0, 0)
1063        self.checkequal(True, '', 'endswith', '', 0, 1)
1064        self.checkequal(True, '', 'endswith', '', 0, 0)
1065        self.checkequal(False, '', 'endswith', '', 1, 0)
1066
1067        # test negative indices
1068        self.checkequal(True, 'hello', 'endswith', 'lo', -2)
1069        self.checkequal(False, 'hello', 'endswith', 'he', -2)
1070        self.checkequal(True, 'hello', 'endswith', '', -3, -3)
1071        self.checkequal(False, 'hello', 'endswith', 'hello world', -10, -2)
1072        self.checkequal(False, 'helloworld', 'endswith', 'worl', -6)
1073        self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, -1)
1074        self.checkequal(True, 'helloworld', 'endswith', 'worl', -5, 9)
1075        self.checkequal(True, 'helloworld', 'endswith', 'world', -7, 12)
1076        self.checkequal(True, 'helloworld', 'endswith', 'lowo', -99, -3)
1077        self.checkequal(True, 'helloworld', 'endswith', 'lowo', -8, -3)
1078        self.checkequal(True, 'helloworld', 'endswith', 'lowo', -7, -3)
1079        self.checkequal(False, 'helloworld', 'endswith', 'lowo', 3, -4)
1080        self.checkequal(False, 'helloworld', 'endswith', 'lowo', -8, -2)
1081
1082        self.checkraises(TypeError, 'hello', 'endswith')
1083        self.checkraises(TypeError, 'hello', 'endswith', 42)
1084
1085        # test tuple arguments
1086        self.checkequal(False, 'hello', 'endswith', ('he', 'ha'))
1087        self.checkequal(True, 'hello', 'endswith', ('lo', 'llo'))
1088        self.checkequal(True, 'hello', 'endswith', ('hellox', 'hello'))
1089        self.checkequal(False, 'hello', 'endswith', ())
1090        self.checkequal(True, 'helloworld', 'endswith', ('hellowo',
1091                                                           'rld', 'lowo'), 3)
1092        self.checkequal(False, 'helloworld', 'endswith', ('hellowo', 'ello',
1093                                                            'rld'), 3, -1)
1094        self.checkequal(True, 'hello', 'endswith', ('hell', 'ell'), 0, -1)
1095        self.checkequal(False, 'hello', 'endswith', ('he', 'hel'), 0, 1)
1096        self.checkequal(True, 'hello', 'endswith', ('he', 'hell'), 0, 4)
1097
1098        self.checkraises(TypeError, 'hello', 'endswith', (42,))
1099
1100    def test___contains__(self):
1101        self.checkequal(True, '', '__contains__', '')
1102        self.checkequal(True, 'abc', '__contains__', '')
1103        self.checkequal(False, 'abc', '__contains__', '\0')
1104        self.checkequal(True, '\0abc', '__contains__', '\0')
1105        self.checkequal(True, 'abc\0', '__contains__', '\0')
1106        self.checkequal(True, '\0abc', '__contains__', 'a')
1107        self.checkequal(True, 'asdf', '__contains__', 'asdf')
1108        self.checkequal(False, 'asd', '__contains__', 'asdf')
1109        self.checkequal(False, '', '__contains__', 'asdf')
1110
1111    def test_subscript(self):
1112        self.checkequal('a', 'abc', '__getitem__', 0)
1113        self.checkequal('c', 'abc', '__getitem__', -1)
1114        self.checkequal('a', 'abc', '__getitem__', 0)
1115        self.checkequal('abc', 'abc', '__getitem__', slice(0, 3))
1116        self.checkequal('abc', 'abc', '__getitem__', slice(0, 1000))
1117        self.checkequal('a', 'abc', '__getitem__', slice(0, 1))
1118        self.checkequal('', 'abc', '__getitem__', slice(0, 0))
1119
1120        self.checkraises(TypeError, 'abc', '__getitem__', 'def')
1121
1122    def test_slice(self):
1123        self.checkequal('abc', 'abc', '__getitem__', slice(0, 1000))
1124        self.checkequal('abc', 'abc', '__getitem__', slice(0, 3))
1125        self.checkequal('ab', 'abc', '__getitem__', slice(0, 2))
1126        self.checkequal('bc', 'abc', '__getitem__', slice(1, 3))
1127        self.checkequal('b', 'abc', '__getitem__', slice(1, 2))
1128        self.checkequal('', 'abc', '__getitem__', slice(2, 2))
1129        self.checkequal('', 'abc', '__getitem__', slice(1000, 1000))
1130        self.checkequal('', 'abc', '__getitem__', slice(2000, 1000))
1131        self.checkequal('', 'abc', '__getitem__', slice(2, 1))
1132
1133        self.checkraises(TypeError, 'abc', '__getitem__', 'def')
1134
1135    def test_extended_getslice(self):
1136        # Test extended slicing by comparing with list slicing.
1137        s = string.ascii_letters + string.digits
1138        indices = (0, None, 1, 3, 41, sys.maxsize, -1, -2, -37)
1139        for start in indices:
1140            for stop in indices:
1141                # Skip step 0 (invalid)
1142                for step in indices[1:]:
1143                    L = list(s)[start:stop:step]
1144                    self.checkequal("".join(L), s, '__getitem__',
1145                                    slice(start, stop, step))
1146
1147    def test_mul(self):
1148        self.checkequal('', 'abc', '__mul__', -1)
1149        self.checkequal('', 'abc', '__mul__', 0)
1150        self.checkequal('abc', 'abc', '__mul__', 1)
1151        self.checkequal('abcabcabc', 'abc', '__mul__', 3)
1152        self.checkraises(TypeError, 'abc', '__mul__')
1153        self.checkraises(TypeError, 'abc', '__mul__', '')
1154        # XXX: on a 64-bit system, this doesn't raise an overflow error,
1155        # but either raises a MemoryError, or succeeds (if you have 54TiB)
1156        #self.checkraises(OverflowError, 10000*'abc', '__mul__', 2000000000)
1157
1158    def test_join(self):
1159        # join now works with any sequence type
1160        # moved here, because the argument order is
1161        # different in string.join
1162        self.checkequal('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
1163        self.checkequal('abcd', '', 'join', ('a', 'b', 'c', 'd'))
1164        self.checkequal('bd', '', 'join', ('', 'b', '', 'd'))
1165        self.checkequal('ac', '', 'join', ('a', '', 'c', ''))
1166        self.checkequal('w x y z', ' ', 'join', Sequence())
1167        self.checkequal('abc', 'a', 'join', ('abc',))
1168        self.checkequal('z', 'a', 'join', UserList(['z']))
1169        self.checkequal('a.b.c', '.', 'join', ['a', 'b', 'c'])
1170        self.assertRaises(TypeError, '.'.join, ['a', 'b', 3])
1171        for i in [5, 25, 125]:
1172            self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',
1173                 ['a' * i] * i)
1174            self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',
1175                 ('a' * i,) * i)
1176
1177        #self.checkequal(str(BadSeq1()), ' ', 'join', BadSeq1())
1178        self.checkequal('a b c', ' ', 'join', BadSeq2())
1179
1180        self.checkraises(TypeError, ' ', 'join')
1181        self.checkraises(TypeError, ' ', 'join', None)
1182        self.checkraises(TypeError, ' ', 'join', 7)
1183        self.checkraises(TypeError, ' ', 'join', [1, 2, bytes()])
1184        try:
1185            def f():
1186                yield 4 + ""
1187            self.fixtype(' ').join(f())
1188        except TypeError as e:
1189            if '+' not in str(e):
1190                self.fail('join() ate exception message')
1191        else:
1192            self.fail('exception not raised')
1193
1194    def test_formatting(self):
1195        self.checkequal('+hello+', '+%s+', '__mod__', 'hello')
1196        self.checkequal('+10+', '+%d+', '__mod__', 10)
1197        self.checkequal('a', "%c", '__mod__', "a")
1198        self.checkequal('a', "%c", '__mod__', "a")
1199        self.checkequal('"', "%c", '__mod__', 34)
1200        self.checkequal('$', "%c", '__mod__', 36)
1201        self.checkequal('10', "%d", '__mod__', 10)
1202        self.checkequal('\x7f', "%c", '__mod__', 0x7f)
1203
1204        for ordinal in (-100, 0x200000):
1205            # unicode raises ValueError, str raises OverflowError
1206            self.checkraises((ValueError, OverflowError), '%c', '__mod__', ordinal)
1207
1208        longvalue = sys.maxsize + 10
1209        slongvalue = str(longvalue)
1210        self.checkequal(' 42', '%3ld', '__mod__', 42)
1211        self.checkequal('42', '%d', '__mod__', 42.0)
1212        self.checkequal(slongvalue, '%d', '__mod__', longvalue)
1213        self.checkcall('%d', '__mod__', float(longvalue))
1214        self.checkequal('0042.00', '%07.2f', '__mod__', 42)
1215        self.checkequal('0042.00', '%07.2F', '__mod__', 42)
1216
1217        self.checkraises(TypeError, 'abc', '__mod__')
1218        self.checkraises(TypeError, '%(foo)s', '__mod__', 42)
1219        self.checkraises(TypeError, '%s%s', '__mod__', (42,))
1220        self.checkraises(TypeError, '%c', '__mod__', (None,))
1221        self.checkraises(ValueError, '%(foo', '__mod__', {})
1222        self.checkraises(TypeError, '%(foo)s %(bar)s', '__mod__', ('foo', 42))
1223        self.checkraises(TypeError, '%d', '__mod__', "42") # not numeric
1224        self.checkraises(TypeError, '%d', '__mod__', (42+0j)) # no int conversion provided
1225
1226        # argument names with properly nested brackets are supported
1227        self.checkequal('bar', '%((foo))s', '__mod__', {'(foo)': 'bar'})
1228
1229        # 100 is a magic number in PyUnicode_Format, this forces a resize
1230        self.checkequal(103*'a'+'x', '%sx', '__mod__', 103*'a')
1231
1232        self.checkraises(TypeError, '%*s', '__mod__', ('foo', 'bar'))
1233        self.checkraises(TypeError, '%10.*f', '__mod__', ('foo', 42.))
1234        self.checkraises(ValueError, '%10', '__mod__', (42,))
1235
1236        # Outrageously large width or precision should raise ValueError.
1237        self.checkraises(ValueError, '%%%df' % (2**64), '__mod__', (3.2))
1238        self.checkraises(ValueError, '%%.%df' % (2**64), '__mod__', (3.2))
1239        self.checkraises(OverflowError, '%*s', '__mod__',
1240                         (sys.maxsize + 1, ''))
1241        self.checkraises(OverflowError, '%.*f', '__mod__',
1242                         (sys.maxsize + 1, 1. / 7))
1243
1244        class X(object): pass
1245        self.checkraises(TypeError, 'abc', '__mod__', X())
1246
1247    @support.cpython_only
1248    def test_formatting_c_limits(self):
1249        from _testcapi import PY_SSIZE_T_MAX, INT_MAX, UINT_MAX
1250        SIZE_MAX = (1 << (PY_SSIZE_T_MAX.bit_length() + 1)) - 1
1251        self.checkraises(OverflowError, '%*s', '__mod__',
1252                         (PY_SSIZE_T_MAX + 1, ''))
1253        self.checkraises(OverflowError, '%.*f', '__mod__',
1254                         (INT_MAX + 1, 1. / 7))
1255        # Issue 15989
1256        self.checkraises(OverflowError, '%*s', '__mod__',
1257                         (SIZE_MAX + 1, ''))
1258        self.checkraises(OverflowError, '%.*f', '__mod__',
1259                         (UINT_MAX + 1, 1. / 7))
1260
1261    def test_floatformatting(self):
1262        # float formatting
1263        for prec in range(100):
1264            format = '%%.%if' % prec
1265            value = 0.01
1266            for x in range(60):
1267                value = value * 3.14159265359 / 3.0 * 10.0
1268                self.checkcall(format, "__mod__", value)
1269
1270    def test_inplace_rewrites(self):
1271        # Check that strings don't copy and modify cached single-character strings
1272        self.checkequal('a', 'A', 'lower')
1273        self.checkequal(True, 'A', 'isupper')
1274        self.checkequal('A', 'a', 'upper')
1275        self.checkequal(True, 'a', 'islower')
1276
1277        self.checkequal('a', 'A', 'replace', 'A', 'a')
1278        self.checkequal(True, 'A', 'isupper')
1279
1280        self.checkequal('A', 'a', 'capitalize')
1281        self.checkequal(True, 'a', 'islower')
1282
1283        self.checkequal('A', 'a', 'swapcase')
1284        self.checkequal(True, 'a', 'islower')
1285
1286        self.checkequal('A', 'a', 'title')
1287        self.checkequal(True, 'a', 'islower')
1288
1289    def test_partition(self):
1290
1291        self.checkequal(('this is the par', 'ti', 'tion method'),
1292            'this is the partition method', 'partition', 'ti')
1293
1294        # from raymond's original specification
1295        S = 'http://www.python.org'
1296        self.checkequal(('http', '://', 'www.python.org'), S, 'partition', '://')
1297        self.checkequal(('http://www.python.org', '', ''), S, 'partition', '?')
1298        self.checkequal(('', 'http://', 'www.python.org'), S, 'partition', 'http://')
1299        self.checkequal(('http://www.python.', 'org', ''), S, 'partition', 'org')
1300
1301        self.checkraises(ValueError, S, 'partition', '')
1302        self.checkraises(TypeError, S, 'partition', None)
1303
1304    def test_rpartition(self):
1305
1306        self.checkequal(('this is the rparti', 'ti', 'on method'),
1307            'this is the rpartition method', 'rpartition', 'ti')
1308
1309        # from raymond's original specification
1310        S = 'http://www.python.org'
1311        self.checkequal(('http', '://', 'www.python.org'), S, 'rpartition', '://')
1312        self.checkequal(('', '', 'http://www.python.org'), S, 'rpartition', '?')
1313        self.checkequal(('', 'http://', 'www.python.org'), S, 'rpartition', 'http://')
1314        self.checkequal(('http://www.python.', 'org', ''), S, 'rpartition', 'org')
1315
1316        self.checkraises(ValueError, S, 'rpartition', '')
1317        self.checkraises(TypeError, S, 'rpartition', None)
1318
1319    def test_none_arguments(self):
1320        # issue 11828
1321        s = 'hello'
1322        self.checkequal(2, s, 'find', 'l', None)
1323        self.checkequal(3, s, 'find', 'l', -2, None)
1324        self.checkequal(2, s, 'find', 'l', None, -2)
1325        self.checkequal(0, s, 'find', 'h', None, None)
1326
1327        self.checkequal(3, s, 'rfind', 'l', None)
1328        self.checkequal(3, s, 'rfind', 'l', -2, None)
1329        self.checkequal(2, s, 'rfind', 'l', None, -2)
1330        self.checkequal(0, s, 'rfind', 'h', None, None)
1331
1332        self.checkequal(2, s, 'index', 'l', None)
1333        self.checkequal(3, s, 'index', 'l', -2, None)
1334        self.checkequal(2, s, 'index', 'l', None, -2)
1335        self.checkequal(0, s, 'index', 'h', None, None)
1336
1337        self.checkequal(3, s, 'rindex', 'l', None)
1338        self.checkequal(3, s, 'rindex', 'l', -2, None)
1339        self.checkequal(2, s, 'rindex', 'l', None, -2)
1340        self.checkequal(0, s, 'rindex', 'h', None, None)
1341
1342        self.checkequal(2, s, 'count', 'l', None)
1343        self.checkequal(1, s, 'count', 'l', -2, None)
1344        self.checkequal(1, s, 'count', 'l', None, -2)
1345        self.checkequal(0, s, 'count', 'x', None, None)
1346
1347        self.checkequal(True, s, 'endswith', 'o', None)
1348        self.checkequal(True, s, 'endswith', 'lo', -2, None)
1349        self.checkequal(True, s, 'endswith', 'l', None, -2)
1350        self.checkequal(False, s, 'endswith', 'x', None, None)
1351
1352        self.checkequal(True, s, 'startswith', 'h', None)
1353        self.checkequal(True, s, 'startswith', 'l', -2, None)
1354        self.checkequal(True, s, 'startswith', 'h', None, -2)
1355        self.checkequal(False, s, 'startswith', 'x', None, None)
1356
1357    def test_find_etc_raise_correct_error_messages(self):
1358        # issue 11828
1359        s = 'hello'
1360        x = 'x'
1361        self.assertRaisesRegex(TypeError, r'^find\(', s.find,
1362                                x, None, None, None)
1363        self.assertRaisesRegex(TypeError, r'^rfind\(', s.rfind,
1364                                x, None, None, None)
1365        self.assertRaisesRegex(TypeError, r'^index\(', s.index,
1366                                x, None, None, None)
1367        self.assertRaisesRegex(TypeError, r'^rindex\(', s.rindex,
1368                                x, None, None, None)
1369        self.assertRaisesRegex(TypeError, r'^count\(', s.count,
1370                                x, None, None, None)
1371        self.assertRaisesRegex(TypeError, r'^startswith\(', s.startswith,
1372                                x, None, None, None)
1373        self.assertRaisesRegex(TypeError, r'^endswith\(', s.endswith,
1374                                x, None, None, None)
1375
1376        # issue #15534
1377        self.checkequal(10, "...\u043c......<", "find", "<")
1378
1379
1380class MixinStrUnicodeTest:
1381    # Additional tests that only work with str.
1382
1383    def test_bug1001011(self):
1384        # Make sure join returns a NEW object for single item sequences
1385        # involving a subclass.
1386        # Make sure that it is of the appropriate type.
1387        # Check the optimisation still occurs for standard objects.
1388        t = self.type2test
1389        class subclass(t):
1390            pass
1391        s1 = subclass("abcd")
1392        s2 = t().join([s1])
1393        self.assertIsNot(s1, s2)
1394        self.assertIs(type(s2), t)
1395
1396        s1 = t("abcd")
1397        s2 = t().join([s1])
1398        self.assertIs(s1, s2)
1399