Debian Codegraph @

testsuite/runok/regex_grouping.stp

raw
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 }