| 1 |
#! stap -p5 |
| 2 |
|
| 3 |
global n |
| 4 |
global pass, fail |
| 5 |
|
| 6 |
function print_groups() { |
| 7 |
for (i = 0; i < ngroups(); i++) printf("'%s' ", matched(i)) |
| 8 |
} |
| 9 |
|
| 10 |
@define test(code, regexp, str) %( |
| 11 |
passed = 1; match_fail = 0 |
| 12 |
result = (@str =~ @regexp) |
| 13 |
if (result != !@code) { passed = 0; match_fail = 1 } |
| 14 |
%) |
| 15 |
|
| 16 |
@define check_equal(n, str1, str2) %( |
| 17 |
// intercept 'group does not exist' error |
| 18 |
if (@n >= ngroups()) { passed = 0 } |
| 19 |
else if (@str1 != @str2) { passed = 0 } |
| 20 |
%) |
| 21 |
|
| 22 |
@define tally_result(code, regexp, str) %( |
| 23 |
// TODOXXX: may also want to print *expected* group values |
| 24 |
n++ |
| 25 |
if (passed) { |
| 26 |
printf("regex PASS: #%d: %s %s %s", n, @str, (@code ? "!~" : "=~"), @regexp) |
| 27 |
if (@code == 0) { |
| 28 |
printf(" with %d groups ", ngroups()) |
| 29 |
print_groups() |
| 30 |
} |
| 31 |
pass++ |
| 32 |
} else if (match_fail) { |
| 33 |
printf("regex FAIL: #%d: %s %s %s\n", n, @str, (@code ? "!~" : "=~"), @regexp) |
| 34 |
fail++ |
| 35 |
} else { |
| 36 |
printf("regex FAIL (grouping): #%d: %s %s %s with %d groups ", n, @str, (@code ? "!~" : "=~"), @regexp, ngroups()) |
| 37 |
print_groups() |
| 38 |
fail++ |
| 39 |
} |
| 40 |
printf("\n") |
| 41 |
%) |
| 42 |
|
| 43 |
@define check(code, regex, str) %( |
| 44 |
@test(@code, @regex, @str) |
| 45 |
@tally_result(@code, @regex, @str) |
| 46 |
%) |
| 47 |
|
| 48 |
@define test0 (regex, str, grp0) %( |
| 49 |
@test(0, @regex, @str) |
| 50 |
@check_equal(0, matched(0), @grp0) |
| 51 |
%) |
| 52 |
|
| 53 |
@define check0 (regex, str, grp0) %( |
| 54 |
@test0(@regex, @str, @grp0) |
| 55 |
@tally_result(0, @regex, @str) |
| 56 |
%) |
| 57 |
|
| 58 |
@define test1 (regex, str, grp0, grp1) %( |
| 59 |
@test0(@regex, @str, @grp0) |
| 60 |
@check_equal(1, matched(1), @grp1) |
| 61 |
%) |
| 62 |
|
| 63 |
@define check1 (regex, str, grp0, grp1) %( |
| 64 |
@test1(@regex, @str, @grp0, @grp1) |
| 65 |
@tally_result(0, @regex, @str) |
| 66 |
%) |
| 67 |
|
| 68 |
@define check2 (regex, str, grp0, grp1, grp2) %( |
| 69 |
@test1(@regex, @str, @grp0, @grp1) |
| 70 |
@check_equal(2, matched(2), @grp2) |
| 71 |
@tally_result(0, @regex, @str) |
| 72 |
%) |
| 73 |
|
| 74 |
probe begin { |
| 75 |
# tests for longest-match behaviour / TODO: need to clarify POSIX/PCRE rules |
| 76 |
# TODOXXX: check against different regex implementations |
| 77 |
@check0("a*", "aaa", "aaa") |
| 78 |
@check0("a?", "aaa", "a") |
| 79 |
@check1("(ab)*", "abab", "abab", "ab") |
| 80 |
@check1("(ab)?", "ab", "ab", "ab") |
| 81 |
@check1("(ab)?", "abab", "ab", "ab") |
| 82 |
@check1("c(ab)*", "cabab", "cabab", "ab") |
| 83 |
@check1("c(ab)?", "cab", "cab", "ab") |
| 84 |
@check1("c(ab)?", "cabab", "cab", "ab") |
| 85 |
@check1("(a*)a*a", "aaa", "aaa", "aa") |
| 86 |
@check1("re(gex)", "regex", "regex", "gex") |
| 87 |
@check0("(long|longer)", "longer", "longer") |
| 88 |
@check(1, "regex", "unrelated") |
| 89 |
@check0("a|b", "ab", "a") |
| 90 |
@check0("a+|b", "baaab", "b") |
| 91 |
@check0("a*|b", "aaab", "aaa") |
| 92 |
|
| 93 |
# XXX: different engines show subtle differences in behaviour |
| 94 |
#@check0("a*|b", "baaab", "") # <- PCRE behaviour |
| 95 |
@check0("a*|b", "baaab", "b") # <- glibc behaviour |
| 96 |
@check0("b|a*", "baaab", "b") |
| 97 |
@check1("(.*).*", "abcdef", "abcdef", "abcdef") |
| 98 |
|
| 99 |
# a subset of the tests from regex.stp |
| 100 |
@check0("\\\\", "\\", "\\") |
| 101 |
@check0("abc", "xabcy", "abc") |
| 102 |
@check0("ab*bc", "abbbbc", "abbbbc") |
| 103 |
@check0("ab?bc", "abbc", "abbc") |
| 104 |
@check(1, "^abc$", "abcc") |
| 105 |
@check(1, "a[b-d]e", "abd") |
| 106 |
@check0("a[b-d]e", "ace", "ace") |
| 107 |
@check0("a\\(*b", "ab", "ab") |
| 108 |
@check0("a\\(*b", "a((b", "a((b") |
| 109 |
@check1("(a+|b)*", "ab", "ab", "b") |
| 110 |
@check1("(a+|b)+", "ab", "ab", "b") |
| 111 |
@check1("([abc])*d", "abbbcd", "abbbcd", "c") |
| 112 |
|
| 113 |
@check(1, "^(ab|cd)e", "abcde") |
| 114 |
@check1("(ab|cd)e", "abcde", "cde", "cd") # variant.. |
| 115 |
@check1("(ab|cd)e$", "abcde", "cde", "cd") # variant.. |
| 116 |
|
| 117 |
@check0("[A-Za-z_][A-Za-z0-9_]*", "alpha", "alpha") |
| 118 |
|
| 119 |
@check2("(bc+d$|ef*g.|h?i(j|k))", "ij", "ij", "ij", "j") |
| 120 |
@check(1, "(bc+d$|ef*g.|h?i(j|k))", "effg") |
| 121 |
@check2("(bc+d$|ef*g.|h?i(j|k))", "00effg12", "effg1", "effg1", "") |
| 122 |
@check2("(bc+d$|ef*g.|h?i(j|k))", "bcccd", "bcccd", "bcccd", "") # variant.. |
| 123 |
|
| 124 |
@check(0, "(((((((((a)))))))))", "a") # TODO: check all the groups? |
| 125 |
@check(1, "\\((.*),", "(.*)\\)") |
| 126 |
@check(1, "[k]", "ab") |
| 127 |
@check0("abcd", "abcd", "abcd") |
| 128 |
@check1("a(bc)d", "abcd", "abcd", "bc") |
| 129 |
|
| 130 |
# selected tests from glibc's grouping testsuite (subfolder posix/bug-regex*.c) |
| 131 |
@check0("ab[cde]", "xyabez", "abe") |
| 132 |
@check(0, "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?", "http://www.regex.com/pattern/matching.html#intro") # TODO: check 9 groups |
| 133 |
@check(0, "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?", "http://www.regex.com/pattern/matching.html?query#intro") # TODO: check 9 groups |
| 134 |
@check(1, "xy$", "xyz") |
| 135 |
# TODO -- @check("xy\\>", "xy ") |
| 136 |
# TODO -- @check("xy \\<", "xy z") |
| 137 |
@check1("^#! */.*/(k|ba||pdk|z)sh", "#! /bin/sh", "#! /bin/sh", "") |
| 138 |
@check0("[abc]*d", "foacabdxy", "acabd") |
| 139 |
@check1("a(.*)b", "a b", "a b", " ") |
| 140 |
@check1("(^|foo)bar", "bar", "bar", "") |
| 141 |
@check1("(foo|^)bar", "bar", "bar", "") |
| 142 |
@check(1, "(foo|^)bar", "bazbar") # variant.. |
| 143 |
@check1("(foo|^)bar", "bazfoobar", "foobar", "foo") # variant.. |
| 144 |
@check(1, "a^b", "a^b") |
| 145 |
@check0("a t.st", "This is a test.", "a test") |
| 146 |
# TODO -- @check("^6?3?[25]?5?[14]*[25]*[69]*+[58]*87?4?$", ??) |
| 147 |
|
| 148 |
# glibc posix/bug-regex13.c |
| 149 |
@check0("ab{0}c", "ac", "ac") |
| 150 |
@check(1, "ab{0}c", "abc") |
| 151 |
@check(1, "ab{0}c", "abbc") |
| 152 |
@check(1, "ab{1}{1}c", "ac") |
| 153 |
@check0("ab{1}{1}c", "abc", "abc") |
| 154 |
@check(1, "ab{1}{1}c", "abbc") |
| 155 |
@check(1, "ab{2}{2}c", "ac") |
| 156 |
@check(1, "ab{2}{2}c", "abbc") |
| 157 |
@check0("ab{2}{2}c", "abbbbc", "abbbbc") |
| 158 |
@check(1, "ab{2}{2}c", "abbbbbc") |
| 159 |
@check0("ab{0}{1}c", "ac", "ac") |
| 160 |
@check(1, "ab{0}{1}c", "abc") |
| 161 |
@check(1, "ab{0}{1}c", "abbc") |
| 162 |
@check0("ab{1}{0}c", "ac", "ac") |
| 163 |
@check(1, "ab{1}{0}c", "abc") |
| 164 |
@check(1, "ab{1}{0}c", "abbc") |
| 165 |
@check0("ab{0}*c", "ac", "ac") |
| 166 |
@check(1, "ab{0}*c", "abc") |
| 167 |
@check(1, "ab{0}*c", "abbc") |
| 168 |
@check0("ab{0}?c", "ac", "ac") |
| 169 |
@check(1, "ab{0}?c", "abc") |
| 170 |
@check(1, "ab{0}?c", "abbc") |
| 171 |
@check0("ab{0}+c", "ac", "ac") |
| 172 |
@check(1, "ab{0}+c", "abc") |
| 173 |
@check(1, "ab{0}+c", "abbc") |
| 174 |
|
| 175 |
# glibc posix/bug-regex20.c - just one case for sanitycheck |
| 176 |
@check0("foo", "b\xc3\xa4rfoob\xc3\xa4z", "foo") |
| 177 |
#@check(2, "\xa4rfoo", "b\xc3\xa4rfoob\xc3\xa4z") # variant.. |
| 178 |
@check0("b.*foo", "b\xc3\xa4rfoob\xc3\xa4z", "b\xc3\xa4rfoo") |
| 179 |
#@check0("b.", "b\xc3\xa4rfoob\xc3\xa4z", "b\xc3\xa4") # -> doesn't work yet |
| 180 |
# XXX: . can match non-ASCII chars, but in general proper multibyte/UTF support is still in the future... |
| 181 |
|
| 182 |
# extra check -- what happens if the same regex is used twice? |
| 183 |
@check0("foo", "barfoom", "foo") |
| 184 |
@check(1, "foo", "barsoom") |
| 185 |
|
| 186 |
# extra check -- missing groups should be empty |
| 187 |
@check1("a|(b)", "a", "a", "") |
| 188 |
|
| 189 |
# extra check -- any extra groups from previous match cleared properly |
| 190 |
@check2("a(b)(c)", "abc", "abc", "b", "c") |
| 191 |
r = @check0("a", "a", "a") |
| 192 |
if (r && ngroups() != 1) { pass --; fail ++ } |
| 193 |
|
| 194 |
# TODO: extra check: be sure using ngroups() with failed / nonexistent match throws an error properly |
| 195 |
# TODO: further tests here... |
| 196 |
|
| 197 |
exit() |
| 198 |
} |
| 199 |
|
| 200 |
probe end { |
| 201 |
printf ("\nregex total PASS: %d, FAIL: %d\n", pass, fail) |
| 202 |
if (fail > 0) error ("Oops") |
| 203 |
} |