module Hidden.TestMain where
import Test.HUnit
import Text.RegexPR ( matchRegexPR, gsubRegexPR, subRegexPR )
main :: IO Counts
main = runTestTT $ test suite
suite :: [ Test ]
suite = [
"base1" ~: testBase1
, "base2" ~: testBase2
]
testBase1, testBase2 :: [ Test ]
testBase1 = [
Just ( ("" , ("", "" )), [] ) ~=? matchRegexPR "" ""
, Just ( ("" , ("", "abcde" )), [] ) ~=? matchRegexPR "" "abcde"
, Just ( ("a", ("", "" )), [] ) ~=? matchRegexPR "." "a"
, Just ( ("bc", ("a", "d")), [] ) ~=? matchRegexPR "b." "abcd"
, Just ( ("abbc", ("", "d")), [] ) ~=? matchRegexPR ".b+." "abbcd"
, Just ( ("abbbbc", ("cd", "d")), [] ) ~=? matchRegexPR ".b+." "cdabbbbcd"
, Nothing ~=? matchRegexPR ".b+." "cdacd"
, Just ( ("abbc", ("", "d")), [] ) ~=? matchRegexPR ".b*." "abbcd"
, Just ( ("cd", ("", "abbbbcd")), [] ) ~=? matchRegexPR ".b*." "cdabbbbcd"
, Just ( ("cd", ("", "acd")), [] ) ~=? matchRegexPR ".b*." "cdacd"
, Just ( ("abcdef", ("", "")), [(3, "ef"), (2, "cd"), (1, "ab")] )
~=?
matchRegexPR "(ab)(cd)(ef)" "abcdef"
, Just ( ("defghabc", ("abc", "def")), [(1, "fghabc"), (3, "abc"), (4, "bc"),
(2, "h"), (2, "g"), (2, "f")] )
~=?
matchRegexPR "de((.)+(a(bc)))" "abcdefghabcdef"
, Just ( ("abca", ("", "")), [(1,"a"), (2,"a"), (3,"a"), (4,"a"), (5,"a"),
(6,"a"), (7,"a"), (8,"a"), (9,"a"), (10,"a")] )
~=?
matchRegexPR "((((((((((a))))))))))bc\\10" "abca"
, Just ( (")(", ("", "")), [(1, ")("), (2, ")(")] )
~=?
matchRegexPR "((\\)\\())" ")("
, Just ( ("+", ("a", "b")), [] ) ~=? matchRegexPR "\\+" "a+b"
, Just ( ("def", ("", "")), [] ) ~=? matchRegexPR "abc|def|gh" "def"
, Just ( ("abde", ("", "f")), [(1,"d")] )
~=? matchRegexPR "ab(c|d)e" "abdef"
, Just ( ("de", ("abc", "f")), [] ) ~=? matchRegexPR "[abcd]e" "abcdef"
, Just ( ("me", ("abc", "f")), [] ) ~=? matchRegexPR "[abk-n]e" "abcmef"
, Just ( ("dcd", ("abc", "")), [] ) ~=? matchRegexPR "[^ab]cd" "abcdcd"
, Just ( ("dcd", ("abmc", "")), [] ) ~=? matchRegexPR "[^abk-n]cd" "abmcdcd"
, Just ( ("cde", ("", "")), [] ) ~=? matchRegexPR "cde$" "cde"
, Just ( ("cde", ("ab", "")), [] ) ~=? matchRegexPR "cde$" "abcde"
, Just ( ("cde", ("cde", "\nfg")), [] )
~=? matchRegexPR "cde$" "cdecde\nfg"
, Nothing ~=? matchRegexPR "cde$" "abcdefg"
, Just ( ("abc", ("", "defg")), [] ) ~=? matchRegexPR "^abc" "abcdefg"
, Just ( ("abc", ("def\n", "")), [] ) ~=? matchRegexPR "^abc" "def\nabc"
]
testBase2 = [
Just ( ("abcd", ("", "e")), [(1,"abc")] )
~=? matchRegexPR "(abc(?=de))d" "abcde"
, Just ( ("def", ("abc", "")), [] ) ~=? matchRegexPR "(?<=abc)def" "abcdef"
, Just ( ("aaaa", ("b", "cd")), [] ) ~=? matchRegexPR "a+" "baaaacd"
, Just ( ("a", ("b", "aaacd")), [] ) ~=? matchRegexPR "a+?" "baaaacd"
, Just ( ("", ("", "baaaacd")), [] ) ~=? matchRegexPR "a*" "baaaacd"
, Just ( ("", ("", "baaaacd")), [] ) ~=? matchRegexPR "a*?" "baaaacd"
, Just ( ("", ("", "baaaacd")), [] ) ~=? matchRegexPR "a?" "baaaacd"
, Just ( ("", ("", "baaaacd")), [] ) ~=? matchRegexPR "a??" "baaaacd"
, Just ( ("a", ("", "aabaacd")), [] ) ~=? matchRegexPR "a?" "aaabaacd"
, Just ( ("ab", ("aa", "aacd")), [] ) ~=? matchRegexPR "a??b" "aaabaacd"
, Just ( ("acd", ("", "")), [(1,"a")] )
~=? matchRegexPR "(a)(?!b)cd" "acd"
, Just ( ("abcdef", ("", "")), [(1, "abcdef")] )
~=?
matchRegexPR "(abcdef)(?<=\\1)" "abcdef"
, Just ( ("", ("", "abc")), [(1, "abc")] )
~=?
matchRegexPR "(?=(abc))" "abc"
, Just ( ("", ("abc", "")), [(1, "abc")] )
~=?
matchRegexPR "(?<=(abc))" "abc"
, Just ( ("", ("", "abc")), [] ) ~=? matchRegexPR "(?=(?=ab)abc)" "abc"
, Just ( ("", ("ab", "c")), [] ) ~=? matchRegexPR "(?=(?<=ab)c)" "abc"
, Just ( ("", ("abc", "")), [] ) ~=? matchRegexPR "(?<=(?=ab)abc)" "abc"
, Just ( ("", ("abc", "")), [] ) ~=? matchRegexPR "(?<=(?<=ab)c)" "abc"
, Just ( ("", ("a", "bc")), [] ) ~=? matchRegexPR "(?<=.+)" "abc"
, Just ( ("abc", ("", "d")), [(1, "c"), (1, "b"), (1, "a")] )
~=? matchRegexPR "(.)+(?=d)" "abcd"
, Just ( ("", ("abc", "d")), [(1, "c"), (1, "b"), (1, "a")] )
~=? matchRegexPR "(?<=(.)+)(?=d)" "abcd"
, Just ( ("", ("abc", "d")), [(1, "c"), (1, "b"), (1, "a")] )
~=?
matchRegexPR "(?<=(?<=(.)+))(?=d)" "abcd"
, Just ( ("ab", ("", "cde")), [] ) ~=? matchRegexPR "\\Gab" "abcde"
, Nothing ~=? matchRegexPR "\\Gab" "dabcde"
, "kickickicccabab" ~=?
gsubRegexPR "\\Gab" "kic" "abababccabab"
, "kic2" ~: "kickickiccckickic" ~=?
gsubRegexPR "ab" "kic" "abababccabab"
, "1:(hello), 2:(boke), 3:(kasu)" ~=?
gsubRegexPR "\\[(.+?)\\]" "(\\1)" "1:[hello], 2:[boke], 3:[kasu]"
, Just ( ("ab12", ("!", "?32")), [] ) ~=? matchRegexPR "\\w+" "!ab12?32"
, Just ( ("!?;:", ("3a", "c")), [] ) ~=? matchRegexPR "\\W+" "3a!?;:c"
, Just ( ("\t\n ", ("!", "d")), [] ) ~=? matchRegexPR "\\s+" "!\t\n d"
, Just ( ("a!:0", ("\f ", "\n")), [] ) ~=? matchRegexPR "\\S+" "\f a!:0\n"
, Just ( ("321", ("a ", "bc")), [] ) ~=? matchRegexPR "\\d+" "a 321bc"
, Just ( (" a!c", ("3", "21")), [] ) ~=? matchRegexPR "\\D+" "3 a!c21"
, Just ( ("\nab", ("", "c")), [] ) ~=? matchRegexPR "\\A\\s.." "\nabc"
, Just ( ("de", ("abc", "")), [] ) ~=? matchRegexPR "..\\Z" "abcde"
, "o\no" ~=? gsubRegexPR "\\Z" "o" "\n"
, "o\no" ~=? gsubRegexPR "$" "o" "\n"
, Just ( ("", ("", "\n")), [] ) ~=? matchRegexPR "$" "\n"
, "oaoboco" ~=? gsubRegexPR "" "o" "abc"
, "\no" ~=? gsubRegexPR "\\z" "o" "\n"
, Just ( ("cat", (" ", "\n")), [] ) ~=? matchRegexPR "\\bcat\\b" " cat\n"
, Nothing ~=? matchRegexPR "\\bcat\\b" "concat\n"
, Just ( ("cat", ("", "")), [] ) ~=? matchRegexPR "\\bcat\\b" "cat"
, Just ( ("cat", ("con", "")), [] ) ~=? matchRegexPR "\\Bcat\\b" "concat"
, Nothing ~=? matchRegexPR "\\Bcat\\b" "cat"
, Just ( ("ooogl", ("goo", "e")), [] ) ~=? matchRegexPR "o{3}gl" "gooooogle"
, Just ( ("ooooogl", ("g", "e")), [] ) ~=? matchRegexPR "o{3,}gl" "gooooogle"
, Just ( ("oooogl", ("go", "e")), [] ) ~=? matchRegexPR "o{2,4}gl" "gooooogle"
, Just ( ("ooogl", ("goo", "e")), [] ) ~=? matchRegexPR "o{3}?gl" "gooooogle"
, Just ( ("ooooogl", ("g", "e")), [] ) ~=? matchRegexPR "o{3,}?gl" "gooooogle"
, Just ( ("oooogl", ("go", "e")), [] ) ~=? matchRegexPR "o{2,4}?gl" "gooooogle"
, Just ( ("gooo", ("", "oogle")), [] ) ~=? matchRegexPR "go{3}" "gooooogle"
, Just ( ("gooooo", ("", "gle")), [] ) ~=? matchRegexPR "go{3,}" "gooooogle"
, Just ( ("goooo", ("", "ogle")), [] ) ~=? matchRegexPR "go{2,4}" "gooooogle"
, Just ( ("gooo", ("", "oogle")), [] ) ~=? matchRegexPR "go{3}?" "gooooogle"
, Just ( ("gooo", ("", "oogle")), [] ) ~=? matchRegexPR "go{3,}?" "gooooogle"
, Just ( ("goo", ("", "ooogle")), [] ) ~=? matchRegexPR "go{2,4}?" "gooooogle"
, Just ( ("com", ("", "ment")), [] ) ~=? matchRegexPR "c(?#what)om" "comment"
, Just ( ("papar", ("", "ens")), [] ) ~=? matchRegexPR "(?:pa)*r" "paparens"
, "abc\t323\tdef\t45" ~=?
gsubRegexPR "(?<=\\d)(?=\\D)|(?<=\\D)(?=\\d)" "\t" "abc323def45"
, Just ( ("ab cd", ("", "e")), [] ) ~=? matchRegexPR "ab cd" "ab cde"
, Just ( ("ab,cd", ("", "e")), [] ) ~=? matchRegexPR "ab,cd" "ab,cde"
, Just ( ("cde", ("ab", "fg")), [] ) ~=?
matchRegexPR "c(?# comment)de" "abcdefg"
, Just ( ("abCde", ("d", "fg")), [] ) ~=? matchRegexPR "ab(?i)cDe" "dabCdefg"
, Just ( ("aBcdE", ("", "")), [] ) ~=? matchRegexPR "a(?i:bC)dE" "aBcdE"
, Nothing ~=? matchRegexPR "a(?i:bC)dE" "aBcde"
, Just ( ("abcDe", ("", "")), [] ) ~=?
matchRegexPR "a(?i)bC(?-i)De" "abcDe"
, Nothing ~=?
matchRegexPR "a(?i)bC(?-i)De" "abcdE"
, Just ( ("abc\nde", ("", "")), [] ) ~=? matchRegexPR "(?m).+" "abc\nde"
, Just ( ("Abc", ("", "\nde")), [] ) ~=? matchRegexPR "(?im-m)a.+" "Abc\nde"
, Just ( ("bcd", ("a", "e")), [] ) ~=?
matchRegexPR "(?x)# hello\n# goodbye\n\t\tbcd\n\n" "abcde"
, Just ( ("bcd", ("a", "e")), [] ) ~=? matchRegexPR "b[[:alnum:]]d" "abcde"
, Just ( ("90af", ("", "g")), [] ) ~=? matchRegexPR "[[:xdigit:]]+" "90afg"
, Just ( (" \n\t\r", ("", "a")), [] ) ~=?
matchRegexPR "[[:blank:]]+" " \n\t\ra"
, "<em>Ruby</b> and <b>Perl</em>" ~=?
gsubRegexPR "<b>(.*)<\\/b>" "<em>\\1</em>" "<b>Ruby</b> and <b>Perl</b>"
, "<em>Ruby</em> and <em>Perl</em>" ~=?
gsubRegexPR "<b>(.*?)<\\/b>" "<em>\\1</em>" "<b>Ruby</b> and <b>Perl</b>"
, Just ( ("abab0", ("", "")), [(1,"ab")] )
~=? matchRegexPR "(ab){\\1}0" "abab0"
, Just ( ("\227\129\130", ("", "")), [] )
~=?
matchRegexPR "\227\129\130" "\227\129\130"
, "abc!abc!abc!bc" ~=?
gsubRegexPR "(?ixm) aBc . # comment " "abc!" "abc\nABCDAbcAbc"
, Just ( ("FGH-12345", ("abcDE", "67")), [] )
~=?
matchRegexPR "[A-Z]{3}-\\d{5}" "abcDEFGH-1234567"
, Just ( ("ABc", ("", " de")), [] ) ~=? matchRegexPR "(?i)[A-Z]+" "ABc de"
, Just ( ("?", ("", "!abc")), [] ) ~=? matchRegexPR "[\\--z]*" "?!abc"
, Just ( ("?!abc-A", ("", " b")), [] ) ~=? matchRegexPR "[!-z]*" "?!abc-A b"
, Just ( ("!!:!", ("!", "!!")), [] ) ~=?
matchRegexPR "(?<=!)!{1,3}:!(?=!)" "!!!:!!!"
, Nothing ~=? matchRegexPR "(?>a*)ab" "aaab"
, Just ( ("\n\n", ("abc", "def")), [] )~=? matchRegexPR "\n\n" "abc\n\ndef"
, Just ( ("aBd", ("", "e")), [] ) ~=? matchRegexPR "(?i)[^e-\\}]*" "aBde"
, Just ( ("_ac", ("!", " kk")), [] ) ~=?
matchRegexPR "[a-zA-Z0-9_]+" "!_ac kk"
, Just ( ("_ac", ("!", " kk")), [] ) ~=? matchRegexPR "\\w+" "!_ac kk"
, Just ( ("!", ("", "_ac kk")), [] ) ~=? matchRegexPR "\\W+" "!_ac kk"
, Just ( ("ab", (" \t\f", "\n\r ")), [] )
~=?
matchRegexPR "[^ \f\n\r\t]+" " \t\fab\n\r "
, Just ( ("a^[b]", ("c", "kk")), [] ) ~=? matchRegexPR "[][^ab]+" "ca^[b]kk"
, Just ( ("flag =\t1", ("", "")), [] ) ~=?
matchRegexPR "flag[ \t]*=[ \t]*\\w" "flag =\t1"
, Just ( (", <>-!:#@\n_\f\r\t=", ("", "")), [] )
~=?
matchRegexPR ", <>-!:#@\n_\f\r\t=" ", <>-!:#@\n_\f\r\t="
, Just ( ("/usr/bin/env", ("#!", " runhaskell")), [] )
~=?
matchRegexPR "/usr/bin/env" "#!/usr/bin/env runhaskell"
, Just ( ("-100.5", ("", "")), [] ) ~=?
matchRegexPR "[-+]?\\d+\\.\\d+" "-100.5"
, "abc defabc defghiabc " ~=?
gsubRegexPR "abc" "\\0 " "abcdefabcdefghiabc"
, "ca1at ha1at da1ad" ~=?
gsubRegexPR "((((((((((a))))))))))" "\\{10}1\\{10}" "cat hat dad"
, "Is a b? No, a is not b" ~=?
gsubRegexPR "c(a)t|(b)ad" "\\+" "Is cat bad? No, cat is not bad"
, "aababcabcdabcdeabcdefabcdefg" ~=? gsubRegexPR "." "\\`" "abcdefgh"
, "bcdefghcdefghdefghefghfghghh" ~=? gsubRegexPR "." "\\'" "abcdefgh"
, "abc" ~=? gsubRegexPR "\b" "" "a\bb\bc\b"
, "abcd" ~=? subRegexPR "[.]" "c" "ab.d"
, "abcdcfcg" ~=? gsubRegexPR "[.+$]" "c" "ab.d+f$g"
, Just ( ("", ("abc", "")), [] ) ~=? matchRegexPR "(?<=abc)" "abc"
, Just ( ("{}", ("", "")), [] ) ~=? matchRegexPR "{}" "{}"
, Just ( ("3{}4", ("", "")), [] ) ~=? matchRegexPR "3{}4" "3{}4"
]