import unittest
from test import test_support

# Bigmem string test houserules:
#
#  - Try not to allocate much more than 2 times self.size.
#    That means two strings of self.size (or a bit more), plus the usual few
#    Mb of overhead. If you need more than two large strings in total,
#    arrange the code so that only two of them are alive at any given time.
#    It's okay to rely on refcounting semantics, but don't forget that
#    's = create_largestring()' doesn't release the old 's' (if it exists)
#    until well after its new value has been created. Use 'del s' before
#    the create_largestring call.
#
#  - Do *not* compare large strings using assertEqual or similar. It's a
#    lengty operation and the errormessage will be utterly useless due to
#    its size. To make sure whether a result has the right contents, better
#    to use the strip or count methods, or compare meaningful slices.
#
#  - Don't forget to test for large indices and numerical results and such,
#    in addition to large sizes.


_2_GB = 2 * 1024 * 1024 * 1024

class StrTest(unittest.TestCase):
    size = -1
    def test_capitalize(self):
        SUBSTR = ' abc def ghi'
        s = '-' * self.size + SUBSTR
        caps = s.capitalize()
        self.assertEqual(caps[-len(SUBSTR):],
                         SUBSTR.capitalize())
        self.assertEqual(caps.lstrip("-"), SUBSTR)

    def test_center(self):
        SUBSTR = ' abc def ghi'
        s = SUBSTR.center(self.size + 10)
        self.assertEqual(len(s), self.size + 10)
        padsize = (len(s) - len(SUBSTR)) / 2
        self.assertEqual(s[padsize:-padsize], SUBSTR)
        self.assertEqual(s.strip(), SUBSTR.strip())

    def test_count(self):
        SUBSTR = ' abc def ghi'
        s = '.' * self.size + SUBSTR
        self.assertEqual(s.count('.'), self.size)
        s += '.'
        self.assertEqual(s.count('.'), self.size + 1)
        self.assertEqual(s.count(' '), 3)
        self.assertEqual(s.count('i'), 1)
        self.assertEqual(s.count('j'), 0)

    def test_decode(self):
        pass

    def test_encode(self):
        pass

    def test_endswith(self):
        SUBSTR = ' abc def ghi'
        s = '-' * self.size + SUBSTR
        self.assertEqual(s.endswith(SUBSTR), True)
        self.assertEqual(s.endswith(s), True)
        self.assertEqual(s.endswith('a' + SUBSTR), False)
        self.assertEqual(("..." + s).endswith(s), True)
        self.assertEqual(SUBSTR.endswith(s), False)

    def test_expandtabs(self):
        size = self.size + 5
        s = "-" * size
        tabsize = 8
        self.assertEqual(s.expandtabs(), s)
        del s
        slen, remainder = divmod(size, tabsize)
        s = "       \t" * slen
        self.assertEqual(s.expandtabs(tabsize), " " * (size - remainder))

    def test_find(self):
        SUBSTR = ' abc def ghi'
        sublen = len(SUBSTR)
        s = "".join([SUBSTR, '-' * self.size, SUBSTR])
        self.assertEqual(s.find(' '), 0)
        self.assertEqual(s.find(SUBSTR), 0)
        self.assertEqual(s.find(' ', sublen), sublen + self.size)
        self.assertEqual(s.find(SUBSTR, len(SUBSTR)), sublen + self.size)
        self.assertEqual(s.find('i'), SUBSTR.find('i'))
        self.assertEqual(s.find('i', sublen),
                         sublen + self.size + SUBSTR.find('i'))
        self.assertEqual(s.find('i', self.size),
                         sublen + self.size + SUBSTR.find('i'))
        self.assertEqual(s.find('j'), -1)

    def test_index(self):
        SUBSTR = ' abc def ghi'
        sublen = len(SUBSTR)
        s = "".join([SUBSTR, '-' * self.size, SUBSTR])
        self.assertEqual(s.index(' '), 0)
        self.assertEqual(s.index(SUBSTR), 0)
        self.assertEqual(s.index(' ', sublen), sublen + self.size)
        self.assertEqual(s.index(SUBSTR, sublen), sublen + self.size)
        self.assertEqual(s.index('i'), SUBSTR.index('i'))
        self.assertEqual(s.index('i', sublen),
                         sublen + self.size + SUBSTR.index('i'))
        self.assertEqual(s.index('i', self.size),
                         sublen + self.size + SUBSTR.index('i'))
        self.assertRaises(ValueError, s.index, 'j')

    def test_isalnum(self):
        SUBSTR = '123456'
        s = 'a' * self.size + SUBSTR
        self.assertEqual(s.isalnum(), True)
        s += '.'
        self.assertEqual(s.isalnum(), False)

    def test_isalpha(self):
        SUBSTR = 'zzzzzzz'
        s = 'a' * self.size + SUBSTR
        self.assertEqual(s.isalpha(), True)
        s += '.'
        self.assertEqual(s.isalpha(), False)

    def test_isdigit(self):
        SUBSTR = '123456'
        s = '9' * self.size + SUBSTR
        self.assertEqual(s.isdigit(), True)
        s += 'z'
        self.assertEqual(s.isdigit(), False)

    def test_islower(self):
        SUBSTR = 'zzzzzz'
        s = 'a' * self.size + SUBSTR
        self.assertEqual(s.islower(), True)
        s += 'A'
        self.assertEqual(s.islower(), False)

    def test_isspace(self):
        SUBSTR = '                  '
        s = ' ' * self.size + SUBSTR
        self.assertEqual(s.isspace(), True)
        s += 'j'
        self.assertEqual(s.isspace(), False)

    def test_istitle(self):
        SUBSTR = '123456'
        s = "".join(["A", 'a' * self.size, SUBSTR])
        self.assertEqual(s.istitle(), True)
        s += "A"
        self.assertEqual(s.istitle(), True)
        s += 'aA'
        self.assertEqual(s.istitle(), False)

    def test_isupper(self):
        SUBSTR = 'ZZZZZZ'
        s = 'A' * self.size + SUBSTR
        self.assertEqual(s.isupper(), True)
        s += 'a'
        self.assertEqual(s.isupper(), False)

    def test_join(self):
        s = 'A' * self.size
        x = s.join(['aaaaa', 'bbbbb'])
        self.assertEqual(x.count('a'), 5)
        self.assertEqual(x.count('b'), 5)
        self.assertEqual(x.startswith('aaaaaA'), True)
        self.assertEqual(x.endswith('Abbbbb'), True)

    def test_ljust(self):
        SUBSTR = ' abc def ghi'
        s = SUBSTR.ljust(self.size + 10)
        self.assertEqual(s.startswith(SUBSTR + "  "), True)
        self.assertEqual(len(s), self.size + 10)

    def test_lower(self):
        s = 'A' * (self.size + 5)
        self.assertEqual(s.lower().count('a'), len(s))

    def test_lstrip(self):
        SUBSTR = ' abc def ghi'
        s = " " * self.size + SUBSTR
        self.assertEqual(s.lstrip(), SUBSTR.lstrip())
        del s
        s = SUBSTR + " " * self.size
        self.assertEqual(len(s.lstrip()), self.size + len(SUBSTR.lstrip()))

    def test_replace(self):
        replacement = 'a'
        size = self.size + 5
        s = ' ' * size
        s = s.replace(' ', replacement)
        self.assertEqual(len(s), size)
        self.assertEqual(s.count(replacement), size)
        s = s.replace(replacement, ' ', size - 4)
        self.assertEqual(len(s), size)
        self.assertEqual(s.count(replacement), 4)
        self.assertEqual(s[-10:], "      aaaa")

    def test_rfind(self):
        SUBSTR = ' abc def ghi'
        sublen = len(SUBSTR)
        s = "".join([SUBSTR, '-' * self.size, SUBSTR])
        self.assertEqual(s.rfind(' '), sublen + self.size + SUBSTR.rfind(' '))
        self.assertEqual(s.rfind(SUBSTR), sublen + self.size)
        self.assertEqual(s.rfind(' ', 0, self.size), SUBSTR.rfind(' '))
        self.assertEqual(s.rfind(SUBSTR, 0, sublen + self.size), 0)
        self.assertEqual(s.rfind('i'), sublen + self.size + SUBSTR.rfind('i'))
        self.assertEqual(s.rfind('i', 0, sublen), SUBSTR.rfind('i'))
        self.assertEqual(s.rfind('i', 0, sublen + self.size),
                         SUBSTR.rfind('i'))
        self.assertEqual(s.rfind('j'), -1)

    def test_rindex(self):
        SUBSTR = ' abc def ghi'
        sublen = len(SUBSTR)
        s = "".join([SUBSTR, '-' * self.size, SUBSTR])
        self.assertEqual(s.rindex(' '),
                         sublen + self.size + SUBSTR.rindex(' '))
        self.assertEqual(s.rindex(SUBSTR), sublen + self.size)
        self.assertEqual(s.rindex(' ', 0, sublen + self.size - 1),
                         SUBSTR.rindex(' '))
        self.assertEqual(s.rindex(SUBSTR, 0, sublen + self.size), 0)
        self.assertEqual(s.rindex('i'),
                         sublen + self.size + SUBSTR.rindex('i'))
        self.assertEqual(s.rindex('i', 0, sublen), SUBSTR.rindex('i'))
        self.assertEqual(s.rindex('i', 0, sublen + self.size),
                         SUBSTR.rindex('i'))
        self.assertRaises(ValueError, s.rindex, 'j')

    def test_rjust(self):
        SUBSTR = ' abc def ghi'
        s = SUBSTR.ljust(self.size + 10)
        self.assertEqual(s.startswith(SUBSTR + "  "), True)
        self.assertEqual(len(s), self.size + 10)

    def test_rstrip(self):
        SUBSTR = ' abc def ghi'
        s = SUBSTR + " " * self.size
        self.assertEqual(s.rstrip(), SUBSTR.rstrip())
        del s
        s = " " * self.size + SUBSTR
        self.assertEqual(len(s.rstrip()), self.size + len(SUBSTR.rstrip()))

    def test_split(self):
        # Crudely calculate an estimate so that the result of s.split won't
        # take up an inordinate amount of memory
        chunksize = int(self.size ** 0.5 + 1)
        SUBSTR = "a" + " " * chunksize
        s = SUBSTR * chunksize
        l = s.split()
        self.assertEqual(len(l), chunksize)
        self.assertEqual(set(l), set(["a"]))
        del l
        l = s.split('a')
        self.assertEqual(len(l), chunksize + 1)
        self.assertEqual(set(l), set(["", " " * chunksize]))

    def test_splitlines(self):
        # Crudely calculate an estimate so that the result of s.split won't
        # take up an inordinate amount of memory
        chunksize = int(self.size ** 0.5 + 1) // 2
        SUBSTR = " " * chunksize + "\n" + " " * chunksize + "\r\n"
        s = SUBSTR * chunksize
        l = s.splitlines()
        self.assertEqual(len(l), chunksize * 2)
        self.assertEqual(set(l), set([" " * chunksize]))

    def test_startswith(self):
        SUBSTR = ' abc def ghi'
        s = '-' * self.size + SUBSTR
        self.assertEqual(s.startswith(s), True)
        self.assertEqual(s.endswith('-' + SUBSTR), True)

    def test_strip(self):
        SUBSTR = '   abc def ghi   '
        s = ' ' * self.size + SUBSTR
        self.assertEqual(s.strip(), SUBSTR.strip())
        del s
        s = SUBSTR + ' ' * self.size
        self.assertEqual(s.strip(), SUBSTR.strip())

    def test_swapcase(self):
        SUBSTR = "aBcDeFG12.'\xa9"
        s = SUBSTR * (self.size // 12 + 5)
        s = s.swapcase()
        self.assertEqual(s[:len(SUBSTR) * 3], SUBSTR.swapcase() * 3)
        self.assertEqual(s[-len(SUBSTR) * 3:], SUBSTR.swapcase() * 3)

    def test_title(self):
        SUBSTR = "SpaaHAaAaham"
        s = SUBSTR * (self.size // 12 + 5)
        s = s.title()
        self.assertEqual(s.startswith((SUBSTR * 3).title()), True)
        self.assertEqual(s.endswith(SUBSTR.lower() * 3), True)

    def test_translate(self):
        pass

    def test_upper(self):
        s = 'a' * (self.size + 5)
        self.assertEqual(s.upper().count('A'), len(s))

    def test_zfill(self):
        SUBSTR = '-568324723598234'
        s = SUBSTR.zfill(self.size + 10)
        self.assertEqual(s.endswith("0" + SUBSTR[1:]), True)
        self.assertEqual(s.startswith("-0"), True)
        self.assertEqual(len(s), self.size + 10)
        self.assertEqual(s.count("0"), self.size + 10 - len(SUBSTR))

    def test_format(self):
        pass

    def test_repr(self):
        pass

    def test_concat(self):
        pass

    def test_repeat(self):
        pass

    def test_slice(self):
        pass

    def test_contains(self):
        pass

    def test_getitem(self):
        pass

    def test_compare(self):
        pass

    def test_hash(self):
        pass

class StrTest1KB(StrTest):
    size = 1024

class StrTest2GB(StrTest):
    size = _2_GB

class StrTest4GB(StrTest):
    size = 2 * _2_GB

def test_main():
    test_support.run_unittest(StrTest1KB, StrTest2GB, StrTest4GB)

if __name__ == "__main__":
    test_main()