"""

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

"""

import unittest, string, sys, struct

from test import test_support

from UserList import UserList

class Sequence:

    def __init__(self, seq='wxyz'): self.seq = seq

    def __len__(self): return len(self.seq)

    def __getitem__(self, i): return self.seq[i]

class BadSeq1(Sequence):

    def __init__(self): self.seq = [7, 'hello', 123L]

class BadSeq2(Sequence):

    def __init__(self): self.seq = ['a', 'b', 'c']

    def __len__(self): return 8

class CommonTest(unittest.TestCase):

    # This testcase contains test that can be used in all

    # stringlike classes. Currently this is str, unicode

    # UserString and the string module.

    # The type to be tested

    # Change in subclasses to change the behaviour of fixtesttype()

    type2test = None

    # All tests pass their arguments to the testing methods

    # as str objects. fixtesttype() can be used to propagate

    # these arguments to the appropriate type

    def fixtype(self, obj):

        if isinstance(obj, str):

            return self.__class__.type2test(obj)

        elif isinstance(obj, list):

            return [self.fixtype(x) for x in obj]

        elif isinstance(obj, tuple):

            return tuple([self.fixtype(x) for x in obj])

        elif isinstance(obj, dict):

            return dict([

               (self.fixtype(key), self.fixtype(value))

               for (key, value) in obj.iteritems()

            ])

        else:

            return obj

    # check that object.method(*args) returns result

    def checkequal(self, result, object, methodname, *args):

        result = self.fixtype(result)

        object = self.fixtype(object)

        args = self.fixtype(args)

        realresult = getattr(object, methodname)(*args)

        self.assertEqual(

            result,

            realresult

        )

        # if the original is returned make sure that

        # this doesn't happen with subclasses

        if object == realresult:

            class subtype(self.__class__.type2test):

                pass

            object = subtype(object)

            realresult = getattr(object, methodname)(*args)

            self.assert_(object is not realresult)

    # check that object.method(*args) raises exc

    def checkraises(self, exc, object, methodname, *args):

        object = self.fixtype(object)

        args = self.fixtype(args)

        self.assertRaises(

            exc,

            getattr(object, methodname),

            *args

        )

    # call object.method(*args) without any checks

    def checkcall(self, object, methodname, *args):

        object = self.fixtype(object)

        args = self.fixtype(args)

        getattr(object, methodname)(*args)

    def test_hash(self):

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

        a = self.type2test('DNSSEC')

        b = self.type2test('')

        for c in a:

            b += c

            hash(b)

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

    def test_capitalize(self):

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

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

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

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

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

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

    def test_count(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        # For a variety of combinations,

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

        #    replacing all occurrences and then differencing the string lengths

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

        digits = 7

        base = len(charset)

        teststrings = set()

        for i in xrange(base ** digits):

            entry = []

            for j in xrange(digits):

                i, m = divmod(i, base)

                entry.append(charset[m])

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

        teststrings = list(teststrings)

        for i in teststrings:

            i = self.fixtype(i)

            n = len(i)

            for j in teststrings:

                r1 = i.count(j)

                if j:

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

                else:

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

                if rem or r1 != r2:

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

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

    def test_find(self):

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

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

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

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

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

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

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

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

        # For a variety of combinations,

        #    verify that str.find() matches __contains__

        #    and that the found substring is really at that location

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

        digits = 5

        base = len(charset)

        teststrings = set()

        for i in xrange(base ** digits):

            entry = []

            for j in xrange(digits):

                i, m = divmod(i, base)

                entry.append(charset[m])

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

        teststrings = list(teststrings)

        for i in teststrings:

            i = self.fixtype(i)

            for j in teststrings:

                loc = i.find(j)

                r1 = (loc != -1)

                r2 = j in i

                if r1 != r2:

                    self.assertEqual(r1, r2)

                if loc != -1:

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

    def test_rfind(self):

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

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

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

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

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

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

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

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

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

    def test_index(self):

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

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

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

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

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

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

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

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

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

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

    def test_rindex(self):

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

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

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

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

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

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

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

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

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

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

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

    def test_lower(self):

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

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

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

    def test_upper(self):

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

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

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

    def test_expandtabs(self):

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

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

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

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

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

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

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

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

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

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

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

            self.checkraises(OverflowError,

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

    def test_split(self):

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

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

        # by whitespace

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

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

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

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

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

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

                        sys.maxint-1)

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

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

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

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

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

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

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

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

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

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

        aaa = ' a '*20

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

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

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

        # by a char

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

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

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

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

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

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

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

                        sys.maxint-2)

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

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

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

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

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

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

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

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

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

        # by string

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

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

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

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

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

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

                        sys.maxint-10)

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

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

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

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

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

                        'split', 'test')

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

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

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

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

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

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

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

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

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

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

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

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

                        'split', 'BLAH', 18)

        # mixed use of str and unicode

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

        # argument type

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

        # null case

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

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

    def test_rsplit(self):

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

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

        # by whitespace

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

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

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

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

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

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

                        sys.maxint-20)

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

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

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

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

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

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

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

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

                        None, 1)

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

                        None, 2)

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

        aaa = ' a '*20

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

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

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

        # by a char

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

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

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

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

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

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

                        sys.maxint-100)

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

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

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

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

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

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

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

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

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

        # by string

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

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

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

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

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

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

                        sys.maxint-5)

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

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

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

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

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

                        'rsplit', 'test')

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

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

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

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

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

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

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

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

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

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

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

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

                        'rsplit', 'BLAH', 18)

        # mixed use of str and unicode

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

        # argument type

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

        # null case

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

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

    def test_strip(self):

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

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

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

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

        # strip/lstrip/rstrip with None arg

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

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

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

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

        # strip/lstrip/rstrip with str arg

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

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

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

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

        # strip/lstrip/rstrip with unicode arg

        if test_support.have_unicode:

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

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

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

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

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

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

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

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

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

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

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

    def test_ljust(self):

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

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

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

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

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

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

    def test_rjust(self):

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

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

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

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

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

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

    def test_center(self):

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

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

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

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

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

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

    def test_swapcase(self):

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

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

    def test_replace(self):

        EQ = self.checkequal

        # Operations on the empty string

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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