mirror of https://github.com/exaloop/codon.git
812 lines
29 KiB
Python
812 lines
29 KiB
Python
@test
|
|
def test_isdigit():
|
|
assert "0".isdigit() == True
|
|
assert "".isdigit() == False
|
|
assert "a".isdigit() == False
|
|
assert "2829357".isdigit() == True
|
|
assert "kshfkjhe".isdigit() == False
|
|
assert "9735g385497".isdigit() == False
|
|
|
|
|
|
@test
|
|
def test_islower():
|
|
assert "".islower() == False
|
|
assert "a".islower() == True
|
|
assert "A".islower() == False
|
|
assert "5".islower() == False
|
|
assert "ahuiuej".islower() == True
|
|
assert "AhUiUeJ".islower() == False
|
|
assert "9735g385497".islower() == True
|
|
assert "9735G385497".islower() == False
|
|
|
|
|
|
@test
|
|
def test_isupper():
|
|
assert "".isupper() == False
|
|
assert "a".isupper() == False
|
|
assert "A".isupper() == True
|
|
assert "5".isupper() == False
|
|
assert ".J, U-I".isupper() == True
|
|
assert "AHUIUEJ".isupper() == True
|
|
assert "AhUiUeJ".isupper() == False
|
|
assert "9735g385497".isupper() == False
|
|
assert "9735G385497".isupper() == True
|
|
|
|
|
|
@test
|
|
def test_isalnum():
|
|
assert "".isalnum() == False
|
|
assert "a".isalnum() == True
|
|
assert "5".isalnum() == True
|
|
assert ",".isalnum() == False
|
|
assert "H6".isalnum() == True
|
|
assert ".J, U-I".isalnum() == False
|
|
assert "A4kki83UE".isalnum() == True
|
|
assert "AhUiUeJ".isalnum() == True
|
|
assert "973 g38597".isalnum() == False
|
|
assert "9735G3-5497".isalnum() == False
|
|
|
|
|
|
@test
|
|
def test_isalpha():
|
|
assert "".isalpha() == False
|
|
assert "a".isalpha() == True
|
|
assert "5".isalpha() == False
|
|
assert ",".isalpha() == False
|
|
assert "Hh".isalpha() == True
|
|
assert ".J, U-I".isalpha() == False
|
|
assert "A4kki83UE".isalpha() == False
|
|
assert "AhUiUeJ".isalpha() == True
|
|
assert "973 g38597".isalpha() == False
|
|
assert "9735G3-5497".isalpha() == False
|
|
|
|
|
|
@test
|
|
def test_isspace():
|
|
assert "".isspace() == False
|
|
assert " ".isspace() == True
|
|
assert "5 ".isspace() == False
|
|
assert "\t\n\r ".isspace() == True
|
|
assert "\t ".isspace() == True
|
|
assert "\t\ngh\r ".isspace() == False
|
|
assert "A4kki 3UE".isspace() == False
|
|
|
|
|
|
@test
|
|
def test_istitle():
|
|
assert "".istitle() == False
|
|
assert " ".istitle() == False
|
|
assert "I ".istitle() == True
|
|
assert "IH".istitle() == False
|
|
assert "Ih".istitle() == True
|
|
assert "Hter Hewri".istitle() == True
|
|
assert "Kweiur oiejf".istitle() == False
|
|
|
|
|
|
@test
|
|
def test_capitalize():
|
|
assert " hello ".capitalize() == " hello "
|
|
assert "Hello ".capitalize() == "Hello "
|
|
assert "hello ".capitalize() == "Hello "
|
|
assert "aaaa".capitalize() == "Aaaa"
|
|
assert "AaAa".capitalize() == "Aaaa"
|
|
|
|
|
|
@test
|
|
def test_isdecimal():
|
|
assert "".isdecimal() == False
|
|
assert "a".isdecimal() == False
|
|
assert "0".isdecimal() == True
|
|
assert "\xbc".isdecimal() == False
|
|
assert "0123456789".isdecimal() == True
|
|
assert "0123456789a".isdecimal() == False
|
|
|
|
|
|
@test
|
|
def test_lower():
|
|
assert "HeLLo".lower() == "hello"
|
|
assert "hello".lower() == "hello"
|
|
assert "HELLO".lower() == "hello"
|
|
assert "HEL _ LO".lower() == "hel _ lo"
|
|
|
|
|
|
@test
|
|
def test_upper():
|
|
assert "HeLLo".upper() == "HELLO"
|
|
assert "hello".upper() == "HELLO"
|
|
assert "HELLO".upper() == "HELLO"
|
|
assert "HEL _ LO".upper() == "HEL _ LO"
|
|
|
|
|
|
@test
|
|
def test_isascii():
|
|
assert "".isascii() == True
|
|
assert "\x00".isascii() == True
|
|
assert "\x7f".isascii() == True
|
|
assert "\x00\x7f".isascii() == True
|
|
assert "\x80".isascii() == False
|
|
assert "строка".isascii() == False
|
|
assert "\xe9".isascii() == False
|
|
|
|
|
|
@test
|
|
def test_casefold():
|
|
assert "".casefold() == ""
|
|
assert "HeLLo".casefold() == "hello"
|
|
assert "hello".casefold() == "hello"
|
|
assert "HELLO".casefold() == "hello"
|
|
assert "HEL _ LO".casefold() == "hel _ lo"
|
|
|
|
|
|
@test
|
|
def test_swapcase():
|
|
assert "".swapcase() == ""
|
|
assert "HeLLo cOmpUteRs".swapcase() == "hEllO CoMPuTErS"
|
|
assert "H.e_L,L-o cOmpUteRs".swapcase() == "h.E_l,l-O CoMPuTErS"
|
|
|
|
|
|
@test
|
|
def test_title():
|
|
assert "".title() == ""
|
|
assert " hello ".title() == " Hello "
|
|
assert "hello ".title() == "Hello "
|
|
assert "Hello ".title() == "Hello "
|
|
assert "fOrMaT thIs aS titLe String".title() == "Format This As Title String"
|
|
assert "fOrMaT,thIs-aS*titLe;String".title() == "Format,This-As*Title;String"
|
|
assert "getInt".title() == "Getint"
|
|
|
|
|
|
@test
|
|
def test_isnumeric():
|
|
assert "".isdecimal() == False
|
|
assert "a".isdecimal() == False
|
|
assert "0".isdecimal() == True
|
|
assert "\xbc".isdecimal() == False
|
|
assert "0123456789".isdecimal() == True
|
|
assert "0123456789a".isdecimal() == False
|
|
|
|
|
|
@test
|
|
def test_ljust():
|
|
assert "abc".ljust(10, " ") == "abc "
|
|
assert "abc".ljust(6, " ") == "abc "
|
|
assert "abc".ljust(3, " ") == "abc"
|
|
assert "abc".ljust(2, " ") == "abc"
|
|
assert "abc".ljust(10, "*") == "abc*******"
|
|
|
|
|
|
@test
|
|
def test_rjust():
|
|
assert "abc".rjust(10, " ") == " abc"
|
|
assert "abc".rjust(6, " ") == " abc"
|
|
assert "abc".rjust(3, " ") == "abc"
|
|
assert "abc".rjust(2, " ") == "abc"
|
|
assert "abc".rjust(10, "*") == "*******abc"
|
|
|
|
|
|
@test
|
|
def test_center():
|
|
assert "abc".center(10, " ") == " abc "
|
|
assert "abc".center(6, " ") == " abc "
|
|
assert "abc".center(3, " ") == "abc"
|
|
assert "abc".center(2, " ") == "abc"
|
|
assert "abc".center(10, "*") == "***abc****"
|
|
|
|
|
|
@test
|
|
def test_zfill():
|
|
assert "123".zfill(2) == "123"
|
|
assert "123".zfill(3) == "123"
|
|
assert "123".zfill(4) == "0123"
|
|
assert "+123".zfill(3) == "+123"
|
|
assert "+123".zfill(4) == "+123"
|
|
assert "+123".zfill(5) == "+0123"
|
|
assert "-123".zfill(3) == "-123"
|
|
assert "-123".zfill(4) == "-123"
|
|
assert "-123".zfill(5) == "-0123"
|
|
assert "".zfill(3) == "000"
|
|
assert "34".zfill(1) == "34"
|
|
assert "34".zfill(4) == "0034"
|
|
assert "1+2".zfill(5) == "001+2"
|
|
assert "+".zfill(10) == "+000000000"
|
|
assert "-".zfill(10) == "-000000000"
|
|
|
|
|
|
@test
|
|
def test_count():
|
|
assert "aaa".count("a", 0, len("aaa")) == 3
|
|
assert "aaa".count("b", 0, len("aaa")) == 0
|
|
assert "aaa".count("a", 1, len("aaa")) == 2
|
|
assert "aaa".count("a", 10, len("aaa")) == 0
|
|
assert "aaa".count("a", -1, len("aaa")) == 1
|
|
assert "aaa".count("a", 0, 1) == 1
|
|
assert "aaa".count("a", 0, 10) == 3
|
|
assert "aaa".count("a", 0, -1) == 2
|
|
assert "aaa".count("aa") == 1
|
|
assert "ababa".count("aba") == 1
|
|
assert "abababa".count("aba") == 2
|
|
assert "abababa".count("abab") == 1
|
|
|
|
|
|
@test
|
|
def test_find():
|
|
assert "abcdefghiabc".find("abc", 0, len("abcdefghiabc")) == 0
|
|
assert "abcdefghiabc".find("abc") == 0
|
|
assert "abcdefghiabc".find("abc", 1, len("abcdefghiabc")) == 9
|
|
assert "abcdefghiabc".find("def", 4, len("abcdefghiabc")) == -1
|
|
assert "abcdefghiabc".find("abcdef", 0, len("abcdefghiabc")) == 0
|
|
assert "abcdefghiabc".find("abcdef") == 0
|
|
assert "abcdefghiabc".find("hiabc", 1, len("abcdefghiabc")) == 7
|
|
assert "abcdefghiabc".find("defgh", 4, len("abcdefghiabc")) == -1
|
|
assert "rrarrrrrrrrra".find("a", 0, len("rrarrrrrrrrra")) == 2
|
|
assert "rrarrrrrrrrra".find("a", 4, len("rrarrrrrrrrra")) == 12
|
|
assert "rrarrrrrrrrra".find("a", 4, 6) == -1
|
|
assert "abc".find("", 0, len("abc")) == 0
|
|
assert "abc".find("", 3, len("abc")) == 3
|
|
assert "abc".find("", 4, len("abc")) == -1
|
|
|
|
|
|
@test
|
|
def test_rfind():
|
|
assert "abcdefghiabc".rfind("abc", 0, len("abcdefghiabc")) == 9
|
|
assert "abcdefghiabc".rfind("", 0, len("abcdefghiabc")) == 12
|
|
assert "abcdefghiabc".rfind("abcd", 0, len("abcdefghiabc")) == 0
|
|
assert "abcdefghiabc".rfind("abcz", 0, len("abcdefghiabc")) == -1
|
|
assert "abcdefghiabc".rfind("abc") == 9
|
|
assert "abcdefghiabc".rfind("") == 12
|
|
assert "abcdefghiabc".rfind("abcd") == 0
|
|
assert "abcdefghiabc".rfind("abcz") == -1
|
|
assert "rrarrrrrrrrra".rfind("a", 0, len("rrarrrrrrrrra")) == 12
|
|
assert "rrarrrrrrrrra".rfind("a", 4, len("rrarrrrrrrrra")) == 12
|
|
assert "rrarrrrrrrrra".rfind("a", 4, 6) == -1
|
|
assert "abc".rfind("", 0, len("abc")) == 3
|
|
assert "abc".rfind("", 3, len("abc")) == 3
|
|
assert "abc".rfind("", 4, len("abc")) == -1
|
|
|
|
|
|
@test
|
|
def test_isidentifier():
|
|
assert "a".isidentifier() == True
|
|
assert "Z".isidentifier() == True
|
|
assert "_".isidentifier() == True
|
|
assert "b0".isidentifier() == True
|
|
assert "bc".isidentifier() == True
|
|
assert "b_".isidentifier() == True
|
|
assert " ".isidentifier() == False
|
|
assert "3t".isidentifier() == False
|
|
assert "_gth_45".isidentifier() == True
|
|
|
|
|
|
@test
|
|
def test_isprintable():
|
|
assert "".isprintable() == True
|
|
assert '"'.isprintable() == True
|
|
assert "'".isprintable() == True
|
|
assert " ".isprintable() == True
|
|
assert "abcdef".isprintable() == True
|
|
assert "0123456789".isprintable() == True
|
|
assert "ABCDEFGHIJKLMNOPQRSTUVWXYZ".isprintable() == True
|
|
assert "abcdefghijklmnopqrstuvwxyz".isprintable() == True
|
|
assert "!#$%&()*+,-./:;?@[\\]^_`{|}~".isprintable() == True
|
|
assert "abcdef\n".isprintable() == False
|
|
|
|
|
|
@test
|
|
def test_lstrip():
|
|
assert "".lstrip() == ""
|
|
assert " ".lstrip() == ""
|
|
assert " hello ".lstrip("") == "hello "
|
|
assert " \t\n\rabc \t\n\r".lstrip("") == "abc \t\n\r"
|
|
assert "xyzzyhelloxyzzy".lstrip("xyz") == "helloxyzzy"
|
|
|
|
|
|
@test
|
|
def test_rstrip():
|
|
assert "".rstrip() == ""
|
|
assert " ".rstrip() == ""
|
|
assert " hello ".rstrip("") == " hello"
|
|
assert " \t\n\rabc \t\n\r".rstrip("") == " \t\n\rabc"
|
|
assert "xyzzyhelloxyzzy".rstrip("xyz") == "xyzzyhello"
|
|
|
|
|
|
@test
|
|
def test_strip():
|
|
assert "".strip() == ""
|
|
assert " ".strip() == ""
|
|
assert " hello ".strip("") == "hello"
|
|
assert " hello ".strip() == "hello"
|
|
assert " \t\n\rabc \t\n\r".strip() == "abc"
|
|
assert "xyzzyhelloxyzzy".strip("xyz") == "hello"
|
|
assert "hello".strip("xyz") == "hello"
|
|
assert "mississippi".strip("mississippi") == ""
|
|
assert "mississippi".strip("i") == "mississipp"
|
|
|
|
|
|
@test
|
|
def test_partition():
|
|
assert "hello".partition("l") == ("he", "l", "lo")
|
|
assert "this is the partition method".partition("ti") == (
|
|
"this is the par",
|
|
"ti",
|
|
"tion method",
|
|
)
|
|
assert "http://www.seq.org".partition("://") == ("http", "://", "www.seq.org")
|
|
assert "http://www.seq.org".partition("?") == ("http://www.seq.org", "", "")
|
|
assert "http://www.seq.org".partition("http://") == ("", "http://", "www.seq.org")
|
|
assert "http://www.seq.org".partition("org") == ("http://www.seq.", "org", "")
|
|
|
|
|
|
@test
|
|
def test_rpartition():
|
|
assert "hello".rpartition("l") == ("hel", "l", "o")
|
|
assert "this is the rpartition method".rpartition("ti") == (
|
|
"this is the rparti",
|
|
"ti",
|
|
"on method",
|
|
)
|
|
assert "http://www.seq.org".rpartition("://") == ("http", "://", "www.seq.org")
|
|
assert "http://www.seq.org".rpartition("?") == ("", "", "http://www.seq.org")
|
|
assert "http://www.seq.org".rpartition("http://") == ("", "http://", "www.seq.org")
|
|
assert "http://www.seq.org".rpartition("org") == ("http://www.seq.", "org", "")
|
|
|
|
|
|
@test
|
|
def test_split():
|
|
assert " h l \t\n l o ".split() == ["h", "l", "l", "o"]
|
|
assert " h l \t\n l o ".split(None, 2) == ["h", "l", "l o "]
|
|
assert " h l \t\n l o ".split(None, 0) == ["h l \t\n l o "]
|
|
assert not "".split()
|
|
assert not " ".split()
|
|
assert "h l l o".split(" ", -1) == ["h", "l", "l", "o"]
|
|
assert "a|b|c|d".split("|", -1) == ["a", "b", "c", "d"]
|
|
assert "h l l o".split(" ") == ["h", "l", "l", "o"]
|
|
assert "a|b|c|d".split("|") == ["a", "b", "c", "d"]
|
|
assert "a|b|c|d".split("|", 0) == ["a|b|c|d"]
|
|
assert "abcd".split("|", -1) == ["abcd"]
|
|
assert "".split("|", -1) == [""]
|
|
assert "endcase |".split("|", -1) == ["endcase ", ""]
|
|
assert "| startcase".split("|", -1) == ["", " startcase"]
|
|
assert "|bothcase|".split("|", -1) == ["", "bothcase", ""]
|
|
assert "abbbc".split("bb", -1) == ["a", "bc"]
|
|
assert "aaa".split("aaa", -1) == ["", ""]
|
|
assert "aaa".split("aaa", 0) == ["aaa"]
|
|
assert "abbaab".split("ba", -1) == ["ab", "ab"]
|
|
assert "aa".split("aaa", -1) == ["aa"]
|
|
assert "Abbobbbobb".split("bbobb", -1) == ["A", "bobb"]
|
|
assert "AbbobbBbbobb".split("bbobb", -1) == ["A", "B", ""]
|
|
assert ("a|" * 20)[:-1].split("|", -1) == ["a"] * 20
|
|
assert ("a|" * 20)[:-1].split("|", 15) == ["a"] * 15 + ["a|a|a|a|a"]
|
|
assert "a|b|c|d".split("|", 1) == ["a", "b|c|d"]
|
|
assert "a|b|c|d".split("|", 2) == ["a", "b", "c|d"]
|
|
assert "a|b|c|d".split("|", 3) == ["a", "b", "c", "d"]
|
|
assert "a|b|c|d".split("|", 4) == ["a", "b", "c", "d"]
|
|
assert "a||b||c||d".split("|", 2) == ["a", "", "b||c||d"]
|
|
|
|
|
|
@test
|
|
def test_rsplit():
|
|
assert " h l \t\n l o ".rsplit() == ["h", "l", "l", "o"]
|
|
assert " h l \t\n l o ".rsplit(None, 2) == [" h l", "l", "o"]
|
|
assert " h l \t\n l o ".rsplit(None, 0) == [" h l \t\n l o"]
|
|
assert not "".rsplit()
|
|
assert not " ".rsplit()
|
|
assert "a|b|c|d".rsplit("|", -1) == ["a", "b", "c", "d"]
|
|
assert "a|b|c|d".rsplit("|") == ["a", "b", "c", "d"]
|
|
assert "a|b|c|d".rsplit("|", 1) == ["a|b|c", "d"]
|
|
assert "a|b|c|d".rsplit("|", 2) == ["a|b", "c", "d"]
|
|
assert "a|b|c|d".rsplit("|", 3) == ["a", "b", "c", "d"]
|
|
assert "a|b|c|d".rsplit("|", 4) == ["a", "b", "c", "d"]
|
|
assert "a|b|c|d".rsplit("|", 0) == ["a|b|c|d"]
|
|
assert "a||b||c||d".rsplit("|", 2) == ["a||b||c", "", "d"]
|
|
assert "abcd".rsplit("|", -1) == ["abcd"]
|
|
assert "".rsplit("|", -1) == [""]
|
|
assert "endcase |".rsplit("|", -1) == ["endcase ", ""]
|
|
assert "| startcase".rsplit("|", -1) == ["", " startcase"]
|
|
assert "|bothcase|".rsplit("|", -1) == ["", "bothcase", ""]
|
|
# assert 'a\x00\x00b\x00c\x00d'.rsplit('\x00', -1)
|
|
assert "abbbc".rsplit("bb", -1) == ["ab", "c"]
|
|
assert "aaa".rsplit("aaa", -1) == ["", ""]
|
|
assert "aaa".rsplit("aaa", 0) == ["aaa"]
|
|
assert "abbaab".rsplit("ba", -1) == ["ab", "ab"]
|
|
assert "aa".rsplit("aaa", -1) == ["aa"]
|
|
assert "bbobbbobbA".rsplit("bbobb", -1) == ["bbob", "A"]
|
|
assert "bbobbBbbobbA".rsplit("bbobb", -1) == ["", "B", "A"]
|
|
assert ("aBLAH" * 20)[:-4].rsplit("BLAH", -1) == ["a"] * 20
|
|
assert ("a|" * 20)[:-1].rsplit("|", 15) == ["a|a|a|a|a"] + ["a"] * 15
|
|
assert "a||b||c||d".rsplit("|", 2) == ["a||b||c", "", "d"]
|
|
|
|
|
|
@test
|
|
def test_splitlines():
|
|
assert "\n\nasdf\nsadf\nsdf\n".splitlines(False) == ["", "", "asdf", "sadf", "sdf"]
|
|
assert "\n\nasdf\nsadf\nsdf\n".splitlines() == ["", "", "asdf", "sadf", "sdf"]
|
|
assert "abc\ndef\n\rghi".splitlines(False) == ["abc", "def", "", "ghi"]
|
|
assert "abc\ndef\n\r\nghi".splitlines(False) == ["abc", "def", "", "ghi"]
|
|
assert "abc\ndef\r\nghi".splitlines(False) == ["abc", "def", "ghi"]
|
|
assert "abc\ndef\r\nghi\n".splitlines(False) == ["abc", "def", "ghi"]
|
|
assert "abc\ndef\r\nghi\n\r".splitlines(False) == ["abc", "def", "ghi", ""]
|
|
assert "\nabc\ndef\r\nghi\n\r".splitlines(False) == ["", "abc", "def", "ghi", ""]
|
|
assert "\nabc\ndef\r\nghi\n\r".splitlines(True) == [
|
|
"\n",
|
|
"abc\n",
|
|
"def\r\n",
|
|
"ghi\n",
|
|
"\r",
|
|
]
|
|
assert "abc\ndef\r\nghi\n".splitlines(True) == ["abc\n", "def\r\n", "ghi\n"]
|
|
|
|
|
|
@test
|
|
def test_startswith():
|
|
assert "hello".startswith("he", 0, len("hello")) == True
|
|
assert "hello".startswith("hello", 0, len("hello")) == True
|
|
assert "hello".startswith("hello world", 0, len("hello")) == False
|
|
assert "hello".startswith("", 0, len("hello")) == True
|
|
assert "hello".startswith("ello", 0, len("hello")) == False
|
|
assert "hello".startswith("he") == True
|
|
assert "hello".startswith("hello") == True
|
|
assert "hello".startswith("hello world") == False
|
|
assert "hello".startswith("") == True
|
|
assert "hello".startswith("ello") == False
|
|
assert "hello".startswith("ello", 1, len("hello")) == True
|
|
assert "hello".startswith("o", 4, len("hello")) == True
|
|
assert "hello".startswith("o", 5, len("hello")) == False
|
|
assert "hello".startswith("lo", 3, len("hello")) == True
|
|
assert "hello".startswith("", 5, len("hello")) == True
|
|
assert "hello".startswith("lo", 6, len("hello")) == False
|
|
assert "helloworld".startswith("lowo", 3, len("helloworld")) == True
|
|
assert "helloworld".startswith("lowo", 3, 7) == True
|
|
assert "helloworld".startswith("lowo", 3, 6) == False
|
|
assert "".startswith("", 0, 1) == True
|
|
assert "".startswith("", 0, 0) == True
|
|
assert "".startswith("", 1, 0) == False
|
|
assert "hello".startswith("he", 0, -1) == True
|
|
assert "hello".startswith("hello", 0, -1) == False
|
|
assert "hello".startswith("he", 0, -3) == True
|
|
assert "hello".startswith("ello", -4, len("hello")) == True
|
|
assert "hello".startswith("ello", -5, len("hello")) == False
|
|
assert "hello".startswith("", -3, -3) == True
|
|
assert "hello".startswith("o", -1, len("hello")) == True
|
|
|
|
|
|
@test
|
|
def test_endswith():
|
|
assert "hello".endswith("lo", 0, len("hello")) == True
|
|
assert "hello".endswith("he", 0, len("hello")) == False
|
|
assert "hello".endswith("", 0, len("hello")) == True
|
|
assert "hello".endswith("hello world", 0, len("hello")) == False
|
|
assert "hello".endswith("lo") == True
|
|
assert "hello".endswith("he") == False
|
|
assert "hello".endswith("") == True
|
|
assert "hello".endswith("hello world") == False
|
|
assert "helloworld".endswith("worl", 0, len("hello")) == False
|
|
assert "helloworld".endswith("worl", 3, 9) == True
|
|
assert "helloworld".endswith("world", 3, 12) == True
|
|
assert "helloworld".endswith("lowo", 1, 7) == True
|
|
assert "helloworld".endswith("lowo", 2, 7) == True
|
|
assert "helloworld".endswith("lowo", 3, 7) == True
|
|
assert "helloworld".endswith("lowo", 4, 7) == False
|
|
assert "helloworld".endswith("lowo", 3, 8) == False
|
|
assert "ab".endswith("ab", 0, 1) == False
|
|
assert "ab".endswith("ab", 0, 0) == False
|
|
assert "".endswith("", 0, 1) == True
|
|
assert "".endswith("", 0, 0) == True
|
|
assert "".endswith("", 1, 0) == False
|
|
assert "hello".endswith("lo", -2, len("hello")) == True
|
|
assert "hello".endswith("he", -2, len("hello")) == False
|
|
assert "hello".endswith("", -3, -3) == True
|
|
assert "helloworld".endswith("worl", -6, len("helloworld")) == False
|
|
assert "helloworld".endswith("worl", -5, -1) == True
|
|
assert "helloworld".endswith("worl", -5, 9) == True
|
|
assert "helloworld".endswith("world", -7, 12) == True
|
|
assert "helloworld".endswith("lowo", -99, -3) == True
|
|
assert "helloworld".endswith("lowo", -8, -3) == True
|
|
assert "helloworld".endswith("lowo", -7, -3) == True
|
|
assert "helloworld".endswith("lowo", 3, -4) == False
|
|
assert "helloworld".endswith("lowo", -8, -2) == False
|
|
|
|
|
|
@test
|
|
def test_index():
|
|
assert "abcdefghiabc".index("abc", 0, len("abcdefghiabc")) == 0
|
|
assert "abcdefghiabc".index("abc") == 0
|
|
assert "abcdefghiabc".index("abc", 1, len("abcdefghiabc")) == 9
|
|
assert "abc".index("", 0, len("abc")) == 0
|
|
assert "abc".index("", 3, len("abc")) == 3
|
|
assert "rrarrrrrrrrra".index("a", 0, len("rrarrrrrrrrra")) == 2
|
|
assert "rrarrrrrrrrra".index("a", 4, len("rrarrrrrrrrra")) == 12
|
|
try:
|
|
"abcdefghiabc".index("def", 4, len("abcdefghiabc"))
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
|
|
@test
|
|
def test_rindex():
|
|
assert "abcdefghiabc".rindex("", 0, len("abcdefghiabc")) == 12
|
|
assert "abcdefghiabc".rindex("") == 12
|
|
assert "abcdefghiabc".rindex("def", 0, len("abcdefghiabc")) == 3
|
|
assert "abcdefghiabc".rindex("abc", 0, len("abcdefghiabc")) == 9
|
|
assert "abcdefghiabc".rindex("abc", 0, -1) == 0
|
|
assert "rrarrrrrrrrra".rindex("a", 0, len("rrarrrrrrrrra")) == 12
|
|
assert "rrarrrrrrrrra".rindex("a", 4, len("rrarrrrrrrrra")) == 12
|
|
try:
|
|
"rrarrrrrrrrra".rindex("a", 4, 6)
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
|
|
@test
|
|
def test_replace():
|
|
# interleave-- default will be len(str) + 1
|
|
assert "A".replace("", "", len("A") + 1) == "A"
|
|
assert "A".replace("", "*", len("A") + 1) == "*A*"
|
|
assert "A".replace("", "*1", len("A") + 1) == "*1A*1"
|
|
assert "A".replace("", "*-#", len("A") + 1) == "*-#A*-#"
|
|
assert "AA".replace("", "*-", len("AA") + 1) == "*-A*-A*-"
|
|
assert "AA".replace("", "*-", -1) == "*-A*-A*-"
|
|
assert "AA".replace("", "*-") == "*-A*-A*-"
|
|
assert "AA".replace("", "*-", 4) == "*-A*-A*-"
|
|
assert "AA".replace("", "*-", 3) == "*-A*-A*-"
|
|
assert "AA".replace("", "*-", 2) == "*-A*-A"
|
|
assert "AA".replace("", "*-", 1) == "*-AA"
|
|
assert "AA".replace("", "*-", 0) == "AA"
|
|
|
|
# substring deletion
|
|
assert "A".replace("A", "", len("A") + 1) == ""
|
|
assert "AAA".replace("A", "", len("AAA") + 1) == ""
|
|
assert "AAA".replace("A", "", -1) == ""
|
|
assert "AAA".replace("A", "") == ""
|
|
assert "AAA".replace("A", "", 4) == ""
|
|
assert "AAA".replace("A", "", 3) == ""
|
|
assert "AAA".replace("A", "", 2) == "A"
|
|
assert "AAA".replace("A", "", 1) == "AA"
|
|
assert "AAA".replace("A", "", 0) == "AAA"
|
|
assert "ABACADA".replace("A", "", len("ABACADA") + 1) == "BCD"
|
|
assert "ABACADA".replace("A", "", -1) == "BCD"
|
|
assert "ABACADA".replace("A", "", 5) == "BCD"
|
|
assert "ABACADA".replace("A", "", 4) == "BCD"
|
|
assert "ABACADA".replace("A", "", 3) == "BCDA"
|
|
assert "ABACADA".replace("A", "", 2) == "BCADA"
|
|
assert "ABACADA".replace("A", "", 1) == "BACADA"
|
|
assert "ABACADA".replace("A", "", 0) == "ABACADA"
|
|
assert "ABCAD".replace("A", "", len("ABCAD") + 1) == "BCD"
|
|
assert "ABCADAA".replace("A", "", len("ABCADAA") + 1) == "BCD"
|
|
assert "BCD".replace("A", "", len("BCD") + 1) == "BCD"
|
|
assert ("^" + ("A" * 1000) + "^").replace("A", "", 999) == "^A^"
|
|
assert "the".replace("the", "", len("the") + 1) == ""
|
|
assert "theater".replace("the", "", len("theater") + 1) == "ater"
|
|
assert "thethe".replace("the", "", len("thethe") + 1) == ""
|
|
assert "thethethethe".replace("the", "", len("thethethethe") + 1) == ""
|
|
assert "theatheatheathea".replace("the", "", len("theatheatheathea") + 1) == "aaaa"
|
|
assert "that".replace("the", "", len("that") + 1) == "that"
|
|
assert (
|
|
"here and there".replace("the", "", len("here and there") + 1) == "here and re"
|
|
)
|
|
assert (
|
|
"here and there and there".replace(
|
|
"the", "", len("here and there and there") + 1
|
|
)
|
|
== "here and re and re"
|
|
)
|
|
assert "here and there and there".replace("the", "", -1) == "here and re and re"
|
|
assert "here and there and there".replace("the", "", 3) == "here and re and re"
|
|
assert "here and there and there".replace("the", "", 2) == "here and re and re"
|
|
assert "here and there and there".replace("the", "", 1) == "here and re and there"
|
|
assert (
|
|
"here and there and there".replace("the", "", 0) == "here and there and there"
|
|
)
|
|
|
|
# substring replace in place
|
|
assert (
|
|
"Who goes there?".replace("o", "o", len("Who goes there?") + 1)
|
|
== "Who goes there?"
|
|
)
|
|
assert (
|
|
"Who goes there?".replace("o", "O", len("Who goes there?") + 1)
|
|
== "WhO gOes there?"
|
|
)
|
|
assert "Who goes there?".replace("o", "O", -1) == "WhO gOes there?"
|
|
assert "Who goes there?".replace("o", "O", 3) == "WhO gOes there?"
|
|
assert "Who goes there?".replace("o", "O", 2) == "WhO gOes there?"
|
|
assert "Who goes there?".replace("o", "O", 1) == "WhO goes there?"
|
|
assert "Who goes there?".replace("o", "O", 0) == "Who goes there?"
|
|
assert (
|
|
"Who goes there?".replace("a", "q", len("Who goes there?") + 1)
|
|
== "Who goes there?"
|
|
)
|
|
assert (
|
|
"Who goes there?".replace("W", "w", len("Who goes there?") + 1)
|
|
== "who goes there?"
|
|
)
|
|
assert (
|
|
"WWho goes there?WW".replace("W", "w", len("WWho goes there?WW") + 1)
|
|
== "wwho goes there?ww"
|
|
)
|
|
assert (
|
|
"Who goes there?".replace("?", "!", len("Who goes there?") + 1)
|
|
== "Who goes there!"
|
|
)
|
|
assert (
|
|
"This is a tissue".replace("is", "**", len("This is a tissue") + 1)
|
|
== "Th** ** a t**sue"
|
|
)
|
|
assert "This is a tissue".replace("is", "**", -1) == "Th** ** a t**sue"
|
|
assert "This is a tissue".replace("is", "**", 4) == "Th** ** a t**sue"
|
|
assert "This is a tissue".replace("is", "**", 3) == "Th** ** a t**sue"
|
|
assert "This is a tissue".replace("is", "**", 2) == "Th** ** a tissue"
|
|
assert "This is a tissue".replace("is", "**", 1) == "Th** is a tissue"
|
|
assert "This is a tissue".replace("is", "**", 0) == "This is a tissue"
|
|
assert "Reykjavik".replace("k", "KK", len("Reykjavik") + 1) == "ReyKKjaviKK"
|
|
assert "Reykjavik".replace("k", "KK", -1) == "ReyKKjaviKK"
|
|
assert "Reykjavik".replace("k", "KK", 2) == "ReyKKjaviKK"
|
|
assert "Reykjavik".replace("k", "KK", 1) == "ReyKKjavik"
|
|
assert "Reykjavik".replace("k", "KK", 0) == "Reykjavik"
|
|
assert "A.B.C.".replace(".", "----", len("A.B.C.") + 1) == "A----B----C----"
|
|
assert (
|
|
"spam, spam, eggs and spam".replace(
|
|
"spam", "ham", len("spam, spam, eggs and spam") + 1
|
|
)
|
|
== "ham, ham, eggs and ham"
|
|
)
|
|
assert (
|
|
"spam, spam, eggs and spam".replace("spam", "ham", -1)
|
|
== "ham, ham, eggs and ham"
|
|
)
|
|
assert (
|
|
"spam, spam, eggs and spam".replace("spam", "ham", 4)
|
|
== "ham, ham, eggs and ham"
|
|
)
|
|
assert (
|
|
"spam, spam, eggs and spam".replace("spam", "ham", 3)
|
|
== "ham, ham, eggs and ham"
|
|
)
|
|
assert (
|
|
"spam, spam, eggs and spam".replace("spam", "ham", 2)
|
|
== "ham, ham, eggs and spam"
|
|
)
|
|
assert (
|
|
"spam, spam, eggs and spam".replace("spam", "ham", 1)
|
|
== "ham, spam, eggs and spam"
|
|
)
|
|
assert (
|
|
"spam, spam, eggs and spam".replace("spam", "ham", 0)
|
|
== "spam, spam, eggs and spam"
|
|
)
|
|
|
|
|
|
@test
|
|
def test_expandtabs():
|
|
assert "abc\rab\tdef\ng\thi".expandtabs(8) == "abc\rab def\ng hi"
|
|
assert "abc\rab\tdef\ng\thi".expandtabs(8) == "abc\rab def\ng hi"
|
|
assert "abc\rab\tdef\ng\thi".expandtabs(4) == "abc\rab def\ng hi"
|
|
assert "abc\r\nab\tdef\ng\thi".expandtabs(8) == "abc\r\nab def\ng hi"
|
|
assert "abc\r\nab\tdef\ng\thi".expandtabs(4) == "abc\r\nab def\ng hi"
|
|
assert "abc\r\nab\r\ndef\ng\r\nhi".expandtabs(4) == "abc\r\nab\r\ndef\ng\r\nhi"
|
|
assert " \ta\n\tb".expandtabs(1) == " a\n b"
|
|
assert "\tdndhd\ty\ty\tyu\t".expandtabs(3) == " dndhd y y yu "
|
|
|
|
|
|
@test
|
|
def test_translate():
|
|
assert "I yor ge".translate({ord("g"): "w", ord("y"): "f"}) == "I for we"
|
|
assert "abababc".translate({ord("a"): ""}) == "bbbc"
|
|
assert "abababc".translate({ord("a"): "", ord("b"): "i"}) == "iiic"
|
|
assert "abababc".translate({ord("a"): "", ord("b"): "i", ord("c"): "x"}) == "iiix"
|
|
assert "abababc".translate({ord("a"): "", ord("b"): ""}) == "c"
|
|
assert "xzx".translate({ord("z"): "yy"}) == "xyyx"
|
|
assert "aaabbbccc".translate({ord("b"): Optional("XY"), ord("c"): None, ord("a"): Optional("")}) == "XYXYXY"
|
|
|
|
@test
|
|
def test_repr():
|
|
assert repr("") == "''"
|
|
assert repr("hello") == "'hello'"
|
|
assert repr(" ") == "' '"
|
|
assert repr("\r\a\n\t") == "'\\r\\a\\n\\t'"
|
|
|
|
|
|
@test
|
|
def test_fstr():
|
|
assert f"{2+2}" == "4"
|
|
n = 42
|
|
assert f"{n}{n}xx{n}" == "4242xx42"
|
|
assert f"{n=}" == "n=42"
|
|
assert f"hello {n=} world" == "hello n=42 world"
|
|
|
|
|
|
@test
|
|
def test_slice(
|
|
s="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
|
|
indices=(0, 1, 3, 41, 0xFFFFFFFFFFF, -1, -2, -37),
|
|
):
|
|
for start in indices:
|
|
for stop in indices:
|
|
for step in indices[1:]:
|
|
L = list(s)[start:stop:step]
|
|
assert s[start:stop:step] == "".join(L)
|
|
|
|
|
|
@test
|
|
def test_join():
|
|
assert "".join(str(a) for a in range(0)) == ""
|
|
assert "".join(List[str]()) == ""
|
|
assert "a".join(str(a) for a in range(0)) == ""
|
|
assert "a".join(List[str]()) == ""
|
|
assert "ab".join(str(a) for a in range(999, 1000)) == "999"
|
|
assert "ab".join(["999"]) == "999"
|
|
assert "xyz".join(str(a) for a in range(5)) == "0xyz1xyz2xyz3xyz4"
|
|
assert "xyz".join(["00", "1", "22", "3", "44"]) == "00xyz1xyz22xyz3xyz44"
|
|
assert "xyz".join(iter(["00", "1", "22", "3", "44"])) == "00xyz1xyz22xyz3xyz44"
|
|
assert "xyz".join(["00", "1", "22", "3", "44"]) == "00xyz1xyz22xyz3xyz44"
|
|
assert "xyz".join(iter(["00", "", "22", "3", ""])) == "00xyzxyz22xyz3xyz"
|
|
|
|
|
|
@test
|
|
def test_repr():
|
|
s = (
|
|
"\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19"
|
|
"\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefg"
|
|
"hijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91"
|
|
"\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xff"
|
|
)
|
|
assert repr(s) == (
|
|
"'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f\\x10\\x11"
|
|
"\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f !\"#$%&\\'()*+,"
|
|
"-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\"
|
|
"x7f\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d\\x8e\\x8f\\x90"
|
|
"\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b\\x9c\\x9d\\x9e\\x9f\\xa0\\xff'"
|
|
)
|
|
assert repr("") == "''"
|
|
assert repr('"') == "'\"'"
|
|
assert repr("'") == '"\'"'
|
|
assert repr("\"'") == "'\"\\''"
|
|
|
|
|
|
test_isdigit()
|
|
test_islower()
|
|
test_isupper()
|
|
test_isalnum()
|
|
test_isalpha()
|
|
test_isspace()
|
|
test_istitle()
|
|
test_capitalize()
|
|
test_isdecimal()
|
|
test_lower()
|
|
test_upper()
|
|
test_isascii()
|
|
test_casefold()
|
|
test_swapcase()
|
|
test_title()
|
|
test_isnumeric()
|
|
test_ljust()
|
|
test_rjust()
|
|
test_center()
|
|
test_zfill()
|
|
test_count()
|
|
test_find()
|
|
test_rfind()
|
|
test_isidentifier()
|
|
test_isprintable()
|
|
test_lstrip()
|
|
test_rstrip()
|
|
test_strip()
|
|
test_partition()
|
|
test_rpartition()
|
|
test_split()
|
|
test_rsplit()
|
|
test_splitlines()
|
|
test_startswith()
|
|
test_endswith()
|
|
test_index()
|
|
test_rindex()
|
|
test_replace()
|
|
test_expandtabs()
|
|
test_translate()
|
|
test_repr()
|
|
test_fstr()
|
|
test_slice()
|
|
test_join()
|
|
test_repr()
|