__author__ = "gerbal"

# unit test files should be named test_<your name here>.py
# this ensures they will automatically be included in the
# ./skulpt.py test or ./skulpt.py dist testing procedures
#

# These tests are a modification of the cPython buffer tests


import unittest

class string_functions(unittest.TestCase):
    def test_islower(self):
        self.assertFalse("".islower(), "islower")
        self.assertTrue("a".islower(), "islower")
        self.assertFalse("A".islower(), "islower")
        self.assertFalse("\n".islower(), "islower")
        self.assertTrue("abc".islower(), "islower")
        self.assertFalse("aBc".islower(), "islower")
        self.assertTrue("abc\n".islower(), "islower")
        # self.assertRaises(TypeError, "abc".islower, 42) #

    def test_isupper(self):
        self.assertFalse("".isupper())
        self.assertFalse("a".isupper())
        self.assertTrue("A".isupper())
        self.assertFalse("\n".isupper())
        self.assertTrue("ABC".isupper())
        self.assertFalse("AbC".isupper())
        self.assertTrue("ABC\n".isupper())
        # self.assertRaises(TypeError, "abc".isupper, 42) #

    def test_istitle(self):
        self.assertFalse("".istitle())
        self.assertFalse("a".istitle())
        self.assertTrue("A".istitle())
        self.assertFalse("\n".istitle()) ##
        self.assertTrue("A Titlecased Line".istitle()) ##
        self.assertTrue("A\nTitlecased Line".istitle()) ##
        self.assertTrue("A Titlecased, Line".istitle()) ##
        self.assertFalse("Not a capitalized String".istitle())
        self.assertFalse("Not\ta Titlecase String".istitle())
        self.assertFalse("Not--a Titlecase String".istitle())
        self.assertFalse("NOT".istitle())
        # self.assertRaises(TypeError, "abc".istitle, 42) #

    def test_isspace(self):
        self.assertFalse("".isspace())
        self.assertFalse("a".isspace())
        self.assertTrue(" ".isspace())
        self.assertTrue("\t".isspace())
        self.assertTrue("\r".isspace())
        self.assertTrue("\n".isspace())
        self.assertTrue(" \t\r\n".isspace())
        self.assertFalse(" \t\r\na".isspace())
        # self.assertRaises(TypeError, "abc".isspace, 42) #

    def test_isalpha(self):
        self.assertFalse("".isalpha())
        self.assertTrue("a".isalpha())
        self.assertTrue("A".isalpha())
        self.assertFalse("\n".isalpha())
        self.assertTrue("abc".isalpha())
        self.assertFalse("aBc123".isalpha())
        self.assertFalse("abc\n".isalpha())
        # self.assertRaises(TypeError, "abc".isalpha, 42)

    def test_isalnum(self):
        self.assertFalse("".isalnum())
        self.assertTrue("a".isalnum())
        self.assertTrue("A".isalnum())
        self.assertFalse("\n".isalnum())
        self.assertTrue("123abc456".isalnum())
        self.assertTrue("a1b3c".isalnum())
        self.assertFalse("aBc000 ".isalnum())
        self.assertFalse("abc\n".isalnum())
        # self.assertRaises(TypeError, "abc".isalnum, 42)

    def test_isdigit(self):
        self.assertFalse("".isdigit())
        self.assertFalse("a".isdigit())
        self.assertTrue("0".isdigit())
        self.assertTrue("0123456789".isdigit())
        self.assertFalse("0123456789a".isdigit())
        # self.assertRaises(TypeError, "abc".isdigit, 42)

    def test_lower(self):
        self.assertEqual("hello", "HeLLo".lower())
        self.assertEqual("hello", "hello".lower())
        # self.assertRaises(TypeError, "hello".lower, 42)

    def test_upper(self):
        self.assertEqual("HELLO", "HeLLo".upper())
        self.assertEqual("HELLO", "HELLO".upper())
        # self.assertRaises(TypeError, "hello".upper, 42)

    def test_capitalize(self):
        self.assertEqual(" hello ", " hello ".capitalize())
        self.assertEqual("Hello ", "Hello ".capitalize())
        self.assertEqual("Hello ", "hello ".capitalize())
        self.assertEqual("Aaaa", "aaaa".capitalize())
        self.assertEqual("Aaaa", "AaAa".capitalize())
        # self.assertRaises(TypeError, "hello".capitalize, 42)

    def test_ljust(self):
        self.assertEqual("abc       ", "abc".ljust(10))
        self.assertEqual("abc   ", "abc".ljust(6))
        self.assertEqual("abc", "abc".ljust(3))
        self.assertEqual("abc", "abc".ljust(2))
        self.assertEqual("abc*******", "abc".ljust(10, "*"))
        # self.assertRaises(TypeError, "abc".ljust)

    def test_rjust(self):
        self.assertEqual("       abc", "abc".rjust(10))
        self.assertEqual("   abc", "abc".rjust(6))
        self.assertEqual("abc", "abc".rjust(3))
        self.assertEqual("abc", "abc".rjust(2))
        self.assertEqual("*******abc", "abc".rjust(10, "*"))
        # self.assertRaises(TypeError, "abc".rjust)

    def test_center(self):
        self.assertEqual("   abc    ", "abc".center(10))
        self.assertEqual(" abc  ", "abc".center(6))
        self.assertEqual("abc", "abc".center(3))
        self.assertEqual("abc", "abc".center(2))
        self.assertEqual("***abc****", "abc".center(10, "*"))
        # self.assertRaises(TypeError, "abc".center)

    def test_swapcase(self):
        self.assertEqual("hEllO CoMPuTErS", "HeLLo cOmpUteRs".swapcase())
        # self.assertRaises(TypeError, "hello".swapcase, 42)

    def test_zfill(self):
        self.assertEqual("123", "123".zfill(2))
        self.assertEqual("123", "123".zfill(3))
        self.assertEqual("0123", "123".zfill(4))
        self.assertEqual("+123", "+123".zfill(3))
        self.assertEqual("+123", "+123".zfill(4))
        self.assertEqual("+0123", "+123".zfill(5))
        self.assertEqual("-123", "-123".zfill(3))
        self.assertEqual("-123", "-123".zfill(4))
        self.assertEqual("-0123", "-123".zfill(5))
        self.assertEqual("000", "".zfill(3))
        self.assertEqual("34", "34".zfill(1))
        self.assertEqual("0034", "34".zfill(4))

        # self.assertRaises(TypeError, "123".zfill)

    def test_expandtabs(self):
        self.assertEqual("abc\rab      def\ng       hi", "abc\rab\tdef\ng\thi".expandtabs())
        self.assertEqual("abc\rab      def\ng       hi", "abc\rab\tdef\ng\thi".expandtabs(8))
        self.assertEqual("abc\rab  def\ng   hi", "abc\rab\tdef\ng\thi".expandtabs(4))
        self.assertEqual("abc\r\nab      def\ng       hi", "abc\r\nab\tdef\ng\thi".expandtabs())
        self.assertEqual("abc\r\nab      def\ng       hi", "abc\r\nab\tdef\ng\thi".expandtabs(8))
        self.assertEqual("abc\r\nab  def\ng   hi", "abc\r\nab\tdef\ng\thi".expandtabs(4))
        self.assertEqual("abc\r\nab\r\ndef\ng\r\nhi", "abc\r\nab\r\ndef\ng\r\nhi".expandtabs(4))
        # kwargs only supported in python 3
        # self.assertEqual("abc\rab      def\ng       hi",
        #                  "abc\rab\tdef\ng\thi".expandtabs(tabsize=8))
        # self.assertEqual("abc\rab  def\ng   hi",
        #                  "abc\rab\tdef\ng\thi".expandtabs(tabsize=4))

        self.assertEqual("  a\n b", " \ta\n\tb".expandtabs(1))

        # self.assertRaises(TypeError, "hello".expandtabs, 42, 42)
        # # This test is only valid when sizeof(int) == sizeof(void*) == 4.
        # if sys.maxsize < (1 << 32) and struct.calcsize("P") == 4:
        #     self.assertRaises(OverflowError,
        #                       "\ta\n\tb".expandtabs, sys.maxsize)

    def test_title(self):
        self.assertEqual(" Hello ", " hello ".title())
        self.assertEqual("Hello ", "hello ".title())
        self.assertEqual("Hello ", "Hello ".title())
        self.assertEqual("Format This As Title String",
                         "fOrMaT thIs aS titLe String".title())
        self.assertEqual("Format,This-As*Title;String",
                         "fOrMaT,thIs-aS*titLe;String".title())
        self.assertEqual("Getint", "getInt".title())
        # self.assertRaises(TypeError, "hello".title, 42)
        
    def test_startswith_endswith(self):
        x = "Please make startswith and endswith work"
        self.assertTrue(x.startswith("Please"))
        self.assertTrue(x.endswith("work"))
        self.assertFalse(x.startswith("please"))
        self.assertFalse(x.endswith("please"))

        self.assertTrue(x.startswith("and", 23))
        self.assertTrue(x.startswith("and", 23, 27))
        self.assertFalse(x.startswith("and", 24))
        self.assertFalse(x.startswith("and", 0, 23))

        self.assertTrue(x.endswith("make", 1, 11))
        self.assertFalse(x.endswith("make", 0, 12))
        self.assertFalse(x.endswith("make", 0, 10))

        self.assertTrue(x.startswith("endswith", -13, -5))
        self.assertFalse(x.startswith("endswith", -5, -13))
        self.assertFalse(x.endswith("endswith", -5, -14))
        self.assertTrue(x.endswith("endswith", -14, -5))

        # tuple
        self.assertTrue(x.startswith(("a", "nd"), 23))

        self.assertTrue(x.startswith(("ends", "with"), -13, -5))
        self.assertFalse(x.startswith(("ends", "with"), -5, -13))
        self.assertFalse(x.endswith(("ends", "with"), -5, -14))
        self.assertTrue(x.endswith(("ends", "with"), -14, -5))

        self.assertTrue(x.startswith("", -13, -5))
        self.assertTrue(x.startswith("", -13, -13))
        self.assertFalse(x.startswith("", -5, -13))

        self.assertTrue(x.endswith("", -13, -5))
        self.assertTrue(x.endswith("", -13, -13))
        self.assertFalse(x.endswith("", -5, -13))

        self.assertTrue(x.startswith("", len(x), len(x) + 5))
        self.assertTrue(x.startswith("", -len(x) - 1, -len(x) - 5))
        self.assertFalse(x.startswith("", 4, 0))
        self.assertTrue(x.endswith("", len(x), len(x) + 5))
        self.assertTrue(x.endswith("", -len(x) - 1, -len(x) - 5))
        self.assertFalse(x.endswith("", 4, 0))
        
    # Take from https://github.com/python/cpython/blob/master/Lib/test/string_tests.py
    def test_startswith(self):
        self.assertTrue('hello'.startswith('he'))
        self.assertTrue('hello'.startswith('hello'))
        self.assertFalse('hello'.startswith('hello world'))
        self.assertTrue('hello'.startswith(''))
        self.assertFalse('hello'.startswith('ello'))
        self.assertTrue('hello'.startswith('ello', 1))
        self.assertTrue('hello'.startswith('o', 4))
        self.assertFalse('hello'.startswith('o', 5))
        self.assertTrue('hello'.startswith('', 5))
        self.assertFalse('hello'.startswith('lo', 6))
        self.assertTrue('helloworld'.startswith('lowo', 3))
        self.assertTrue('helloworld'.startswith('lowo', 3, 7))
        self.assertFalse('helloworld'.startswith('lowo', 3, 6))
        self.assertTrue(''.startswith('', 0, 1))
        self.assertTrue(''.startswith('', 0, 0))
        self.assertFalse(''.startswith('', 1, 0))

        # test negative indices
        self.assertTrue('hello'.startswith('he', 0, -1))
        self.assertTrue('hello'.startswith('he', -53, -1))
        self.assertFalse('hello'.startswith('hello', 0, -1))
        self.assertFalse('hello'.startswith('hello world', -1, -10))
        self.assertFalse('hello'.startswith('ello', -5))
        self.assertTrue('hello'.startswith('ello', -4))
        self.assertFalse('hello'.startswith('o', -2))
        self.assertTrue('hello'.startswith('o', -1))
        self.assertTrue('hello'.startswith('', -3, -3))
        self.assertFalse('hello'.startswith('lo', -9))

        # test tuple arguments
        self.assertTrue('hello'.startswith(('he', 'ha')))
        self.assertFalse('hello'.startswith(('lo', 'llo')))
        self.assertTrue('hello'.startswith(('hellox', 'hello')))
        self.assertFalse('hello'.startswith(()))
        self.assertTrue('helloworld'.startswith(('hellowo','rld', 'lowo'), 3))
        self.assertFalse('helloworld'.startswith(('hellowo', 'ello',
                                                            'rld'), 3))
        self.assertTrue('hello'.startswith(('lo', 'he'), 0, -1))
        self.assertFalse('hello'.startswith(('he', 'hel'), 0, 1))
        self.assertTrue('hello'.startswith(('he', 'hel'), 0, 2))


    def test_endswith(self):
        self.assertTrue('hello'.endswith('lo'))
        self.assertFalse('hello'.endswith('he'))
        self.assertTrue('hello'.endswith(''))
        self.assertFalse('hello'.endswith('hello world'))
        self.assertFalse('helloworld'.endswith('worl'))
        self.assertTrue('helloworld'.endswith('worl', 3, 9))
        self.assertTrue('helloworld'.endswith('world', 3, 12))
        self.assertTrue('helloworld'.endswith('lowo', 1, 7))
        self.assertTrue('helloworld'.endswith('lowo', 2, 7))
        self.assertTrue('helloworld'.endswith('lowo', 3, 7))
        self.assertFalse('helloworld'.endswith('lowo', 4, 7))
        self.assertFalse('helloworld'.endswith('lowo', 3, 8))
        self.assertFalse('ab'.endswith('ab', 0, 1))
        self.assertFalse('ab'.endswith('ab', 0, 0))
        self.assertTrue(''.endswith('', 0, 1))
        self.assertTrue(''.endswith('', 0, 0))
        self.assertFalse(''.endswith('', 1, 0))

        # test negative indices
        self.assertTrue('hello'.endswith('lo', -2))
        self.assertFalse('hello'.endswith('he', -2))
        self.assertTrue('hello'.endswith('', -3, -3))
        self.assertFalse('hello'.endswith('hello world', -10, -2))
        self.assertFalse('helloworld'.endswith('worl', -6))
        self.assertTrue('helloworld'.endswith('worl', -5, -1))
        self.assertTrue('helloworld'.endswith('worl', -5, 9))
        self.assertTrue('helloworld'.endswith('world', -7, 12))
        self.assertTrue('helloworld'.endswith('lowo', -99, -3))
        self.assertTrue('helloworld'.endswith('lowo', -8, -3))
        self.assertTrue('helloworld'.endswith('lowo', -7, -3))
        self.assertFalse('helloworld'.endswith('lowo', 3, -4))
        self.assertFalse('helloworld'.endswith('lowo', -8, -2))
        

        # test tuple arguments
        self.assertFalse('hello'.endswith(('he', 'ha')))
        self.assertTrue('hello'.endswith(('lo', 'llo', 'wllo'))) 
        self.assertTrue('hello'.endswith(('hellox', 'hello')))
        self.assertFalse('hello'.endswith(()))
        self.assertTrue('helloworld'.endswith(('hellowo', 'rld', 'lowo'), 3))
        self.assertFalse('helloworld'.endswith(('hellowo', 'ello',
                                                          'rld'), 3, -1))
        self.assertTrue('hello'.endswith(('hell', 'ell'), 0, -1))
        self.assertFalse('hello'.endswith(('he', 'hel'), 0, 1))
        self.assertTrue('hello'.endswith(('he', 'hell'), 0, 4))
        
    def test_splitlines(self):
        self.assertEqual(["abc", "def", "", "ghi"],
                         "abc\ndef\n\rghi".splitlines())
        self.assertEqual(["abc", "def", "", "ghi"],
                         "abc\ndef\n\r\nghi".splitlines())
        self.assertEqual(["abc", "def", "ghi"],
                         "abc\ndef\r\nghi".splitlines())
        self.assertEqual(["abc", "def", "ghi"],
                         "abc\ndef\r\nghi\n".splitlines())
        self.assertEqual(["abc", "def", "ghi", ""],
                         "abc\ndef\r\nghi\n\r".splitlines())
        self.assertEqual(["", "abc", "def", "ghi", ""],
                         "\nabc\ndef\r\nghi\n\r".splitlines())
        self.assertEqual(["", "abc", "def", "ghi", ""],
                         "\nabc\ndef\r\nghi\n\r".splitlines(False))
        self.assertEqual(["\n", "abc\n", "def\r\n", "ghi\n", "\r"],
                         "\nabc\ndef\r\nghi\n\r".splitlines(True))
        # self.assertEqual(["", "abc", "def", "ghi", ""],
        #                  "\nabc\ndef\r\nghi\n\r".splitlines(keepends=False))
        # self.assertEqual(["\n", "abc\n", "def\r\n", "ghi\n", "\r"],
        #                  "\nabc\ndef\r\nghi\n\r".splitlines(keepends=True))

        # self.assertRaises(TypeError, "abc".splitlines, 42, 42)
        
    def test___contains__(self):
        self.assertTrue(''.__contains__(''))
        self.assertTrue('abc'.__contains__(''))
        self.assertFalse('abc'.__contains__('\0'))
        self.assertTrue('\0abc'.__contains__('\0'))
        self.assertTrue('abc\0'.__contains__('\0'))
        self.assertTrue('\0abc'.__contains__('a'))
        self.assertTrue('asdf'.__contains__('asdf'))
        self.assertFalse('asd'.__contains__('asdf'))
        self.assertFalse(''.__contains__('asdf'))
    # Copy from CPython test
    def test_none_arguments(self):
        s = 'hello'
        self.assertEqual(2, s.find('l', None))
        self.assertEqual(3, s.find('l', -2, None))
        self.assertEqual(2, s.find('l', None, -2))
        self.assertEqual(0, s.find('h', None, None))

        self.assertEqual(3, s.rfind('l', None))
        self.assertEqual(3, s.rfind('l', -2, None))
        self.assertEqual(2, s.rfind('l', None, -2))
        self.assertEqual(0, s.rfind('h', None, None))

        self.assertEqual(2, s.index('l', None))
        self.assertEqual(3, s.index('l', -2, None))
        self.assertEqual(2, s.index('l', None, -2))
        self.assertEqual(0, s.index('h', None, None))

        self.assertEqual(3, s.rindex('l', None))
        self.assertEqual(3, s.rindex('l', -2, None))
        self.assertEqual(2, s.rindex('l', None, -2))
        self.assertEqual(0, s.rindex('h', None, None))

        self.assertEqual(2, s.count('l', None))
        self.assertEqual(1, s.count('l', -2, None))
        self.assertEqual(1, s.count('l', None, -2))
        self.assertEqual(0, s.count('x', None, None))

        self.assertEqual(True, s.count('o', None))
        self.assertEqual(True, s.count('lo', -2, None))
        self.assertEqual(True, s.count('l', None, -2))
        self.assertEqual(False, s.count('x', None, None))

        self.assertEqual(True, s.count('h', None))
        self.assertEqual(True, s.count('l', -2, None))
        self.assertEqual(True, s.count('h', None, -2))
        self.assertEqual(False, s.count('x', None, None))

if __name__ == "__main__":
    unittest.main()