import unittest
from test import test_support

_2_GB = 2 * 1024 * 1024 * 1024

class StrTest2GB(unittest.TestCase):

    size = _2_GB

    def test_capitalize(self):
        SUBSTR = ' abc def ghi'
        s = '-' * self.size
        s += SUBSTR
        self.assertEqual(s[-len(SUBSTR):].capitalize(), SUBSTR.capitalize())

    def test_center(self):
        # XXX(nnorwitz): skip until can create 2GB string efficiently
        return

        SUBSTR = ' abc def ghi'
        s = '-' * self.size
        s += SUBSTR
        self.assertEqual(s[-len(SUBSTR):].capitalize(), SUBSTR.capitalize())

    def test_count(self):
        SUBSTR = ' abc def ghi'
        s = '-' * self.size
        s += 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)

    def test_decode(self):
        pass

    def test_encode(self):
        pass

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

    def test_expandtabs(self):
        pass

    def test_find(self):
        SUBSTR = ' abc def ghi'
        s = '-' * self.size
        s += SUBSTR
        self.assertEqual(s.find(' '), self.size)
        self.assertEqual(s.find(SUBSTR), self.size)
        self.assertEqual(s.find('i'), self.size + len(SUBSTR))

    def test_index(self):
        SUBSTR = ' abc def ghi'
        s = '-' * self.size
        s += SUBSTR
        self.assertEqual(s.index(' '), self.size)
        self.assertEqual(s.index('i'), self.size + len(SUBSTR))
        self.assertRaises(IndexError, s.index, 'j')

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

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

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

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

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

    def test_istitle(self):
        # XXX(nnorwitz): skip until can create 2GB string efficiently
        return

        SUBSTR = '123456'
        s = 'a' * self.size
        s += SUBSTR
        self.assertEqual(s.istitle(), True)
        s += '.'
        self.assertEqual(s.istitle(), False)

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

    def test_join(self):
        s = 'A' * (self.size // 2)
        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):
        pass

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

    def test_lstrip(self):
        pass

    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)

    def test_rfind(self):
        pass

    def test_rindex(self):
        pass

    def test_rjust(self):
        pass

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

    def test_split(self):
        pass

    def test_splitlines(self):
        pass

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

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

    def test_swapcase(self):
        pass

    def test_title(self):
        pass

    def test_translate(self):
        pass

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

    def test_zfill(self):
        pass

    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 StrTest4GB(StrTest2GB):
    size = 2 * _2_GB


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

if __name__ == "__main__":
    test_main()