]> git.saurik.com Git - wxWidgets.git/blob - tests/regex/reg.test
make sure the quit item is only shown where appropriate on osx
[wxWidgets.git] / tests / regex / reg.test
1 # reg.test --
2 #
3 # This file contains a collection of tests for one or more of the Tcl
4 # built-in commands. Sourcing this file into Tcl runs the tests and
5 # generates output for errors. No output means no errors were found.
6 # (Don't panic if you are seeing this as part of the reg distribution
7 # and aren't using Tcl -- reg's own regression tester also knows how
8 # to read this file, ignoring the Tcl-isms.)
9 #
10 # Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
11 #
12 # RCS: @(#) $Id$
13
14 if {[lsearch [namespace children] ::tcltest] == -1} {
15 package require tcltest 2
16 namespace import -force ::tcltest::*
17 }
18
19 # All tests require the testregexp command, return if this
20 # command doesn't exist
21
22 ::tcltest::testConstraint testregexp \
23 [expr {[info commands testregexp] != {}}]
24 ::tcltest::testConstraint localeRegexp 0
25
26 # This file uses some custom procedures, defined below, for regexp regression
27 # testing. The name of the procedure indicates the general nature of the
28 # test:
29 # e compile error expected
30 # f match failure expected
31 # m successful match
32 # i successful match with -indices (used in checking things like
33 # nonparticipating subexpressions)
34 # p unsuccessful match with -indices (!!) (used in checking
35 # partial-match reporting)
36 # There is also "doing" which sets up title and major test number for each
37 # block of tests.
38
39 # The first 3 arguments are constant: a minor number (which often gets
40 # a letter or two suffixed to it internally), some flags, and the RE itself.
41 # For e, the remaining argument is the name of the compile error expected,
42 # less the leading "REG_". For the rest, the next argument is the string
43 # to try the match against. Remaining arguments are the substring expected
44 # to be matched, and any substrings expected to be matched by subexpressions.
45 # (For f, these arguments are optional, and if present are ignored except
46 # that they indicate how many subexpressions should be present in the RE.)
47 # It is an error for the number of subexpression arguments to be wrong.
48 # Cases involving nonparticipating subexpressions, checking where empty
49 # substrings are located, etc. should be done using i and p.
50
51 # The flag characters are complex and a bit eclectic. Generally speaking,
52 # lowercase letters are compile options, uppercase are expected re_info
53 # bits, and nonalphabetics are match options, controls for how the test is
54 # run, or testing options. The one small surprise is that AREs are the
55 # default, and you must explicitly request lesser flavors of RE. The flags
56 # are as follows. It is admitted that some are not very mnemonic.
57 # There are some others which are purely debugging tools and are not
58 # useful in this file.
59 #
60 # - no-op (placeholder)
61 # + provide fake xy equivalence class and ch collating element
62 # % force small state-set cache in matcher (to test cache replace)
63 # ^ beginning of string is not beginning of line
64 # $ end of string is not end of line
65 # * test is Unicode-specific, needs big character set
66 #
67 # & test as both ARE and BRE
68 # b BRE
69 # e ERE
70 # a turn advanced-features bit on (error unless ERE already)
71 # q literal string, no metacharacters at all
72 #
73 # i case-independent matching
74 # o ("opaque") no subexpression capture
75 # p newlines are half-magic, excluded from . and [^ only
76 # w newlines are half-magic, significant to ^ and $ only
77 # n newlines are fully magic, both effects
78 # x expanded RE syntax
79 # t incomplete-match reporting
80 #
81 # A backslash-_a_lphanumeric seen
82 # B ERE/ARE literal-_b_race heuristic used
83 # E backslash (_e_scape) seen within []
84 # H looka_h_ead constraint seen
85 # I _i_mpossible to match
86 # L _l_ocale-specific construct seen
87 # M unportable (_m_achine-specific) construct seen
88 # N RE can match empty (_n_ull) string
89 # P non-_P_OSIX construct seen
90 # Q {} _q_uantifier seen
91 # R back _r_eference seen
92 # S POSIX-un_s_pecified syntax seen
93 # T prefers shortest (_t_iny)
94 # U saw original-POSIX botch: unmatched right paren in ERE (_u_gh)
95
96 # The one area we can't easily test is memory-allocation failures (which
97 # are hard to provoke on command). Embedded NULs also are not tested at
98 # the moment, but this is a historical accident which should be fixed.
99
100
101
102 # test procedures and related
103
104 set ask "about"
105 set xflags "xflags"
106 set testbypassed 0
107
108 # re_info abbreviation mapping table
109 set infonames(A) "REG_UBSALNUM"
110 set infonames(B) "REG_UBRACES"
111 set infonames(E) "REG_UBBS"
112 set infonames(H) "REG_ULOOKAHEAD"
113 set infonames(I) "REG_UIMPOSSIBLE"
114 set infonames(L) "REG_ULOCALE"
115 set infonames(M) "REG_UUNPORT"
116 set infonames(N) "REG_UEMPTYMATCH"
117 set infonames(P) "REG_UNONPOSIX"
118 set infonames(Q) "REG_UBOUNDS"
119 set infonames(R) "REG_UBACKREF"
120 set infonames(S) "REG_UUNSPEC"
121 set infonames(T) "REG_USHORTEST"
122 set infonames(U) "REG_UPBOTCH"
123 set infonameorder "RHQBAUEPSMLNIT" ;# must match bit order, lsb first
124
125 # set major test number and description
126 proc doing {major desc} {
127 global prefix description testbypassed
128
129 if {$testbypassed != 0} {
130 puts stdout "!!! bypassed $testbypassed tests in\
131 $prefix, `$description'"
132 }
133
134 set prefix reg-$major
135 set description "reg $desc"
136 set testbypassed 0
137 }
138
139 # build test number (internal)
140 proc tno {testid} {
141 return [join $testid .]
142 }
143
144 # build description, with possible modifiers (internal)
145 proc desc {testid} {
146 global description
147
148 set d $description
149 if {[llength $testid] > 1} {
150 set d "([lreplace $testid 0 0]) $d"
151 }
152 return $d
153 }
154
155 # build trailing options and flags argument from a flags string (internal)
156 proc flags {fl} {
157 global xflags
158
159 set args [list]
160 set flags ""
161 foreach f [split $fl ""] {
162 switch -exact -- $f {
163 "i" { lappend args "-nocase" }
164 "x" { lappend args "-expanded" }
165 "n" { lappend args "-line" }
166 "p" { lappend args "-linestop" }
167 "w" { lappend args "-lineanchor" }
168 "-" { }
169 default { append flags $f }
170 }
171 }
172 if {[string compare $flags ""] != 0} {
173 lappend args -$xflags $flags
174 }
175 return $args
176 }
177
178 # build info-flags list from a flags string (internal)
179 proc infoflags {fl} {
180 global infonames infonameorder
181
182 set ret [list]
183 foreach f [split $infonameorder ""] {
184 if {[string first $f $fl] >= 0} {
185 lappend ret $infonames($f)
186 }
187 }
188 return $ret
189 }
190
191 # compilation error expected
192 proc e {testid flags re err} {
193 global prefix ask errorCode
194
195 # Tcl locale stuff doesn't do the ch/xy test fakery yet
196 if {[string first "+" $flags] >= 0} {
197 # This will register as a skipped test
198 test $prefix.[tno $testid] [desc $testid] localeRegexp {} {}
199 return
200 }
201
202 # if &, test as both ARE and BRE
203 set amp [string first "&" $flags]
204 if {$amp >= 0} {
205 set f [string range $flags 0 [expr $amp - 1]]
206 append f [string range $flags [expr $amp + 1] end]
207 e [linsert $testid end ARE] ${f} $re $err
208 e [linsert $testid end BRE] ${f}b $re $err
209 return
210 }
211
212 set cmd [concat [list testregexp -$ask] [flags $flags] [list $re]]
213 set run "list \[catch \{$cmd\}\] \[lindex \$errorCode 1\]"
214 test $prefix.[tno $testid] [desc $testid] \
215 {testregexp} $run [list 1 REG_$err]
216 }
217
218 # match failure expected
219 proc f {testid flags re target args} {
220 global prefix description ask
221
222 # Tcl locale stuff doesn't do the ch/xy test fakery yet
223 if {[string first "+" $flags] >= 0} {
224 # This will register as a skipped test
225 test $prefix.[tno $testid] [desc $testid] localeRegexp {} {}
226 return
227 }
228
229 # if &, test as both ARE and BRE
230 set amp [string first "&" $flags]
231 if {$amp >= 0} {
232 set f [string range $flags 0 [expr $amp - 1]]
233 append f [string range $flags [expr $amp + 1] end]
234 eval [linsert $args 0 f [linsert $testid end ARE] ${f} $re \
235 $target]
236 eval [linsert $args 0 f [linsert $testid end BRE] ${f}b $re \
237 $target]
238 return
239 }
240
241 set f [flags $flags]
242 set infoflags [infoflags $flags]
243 set ccmd [concat [list testregexp -$ask] $f [list $re]]
244 set nsub [expr [llength $args] - 1]
245 if {$nsub == -1} {
246 # didn't tell us number of subexps
247 set ccmd "lreplace \[$ccmd\] 0 0"
248 set info [list $infoflags]
249 } else {
250 set info [list $nsub $infoflags]
251 }
252 lappend testid "compile"
253 test $prefix.[tno $testid] [desc $testid] {testregexp} $ccmd $info
254
255 set testid [lreplace $testid end end "execute"]
256 set ecmd [concat [list testregexp] $f [list $re $target]]
257 test $prefix.[tno $testid] [desc $testid] {testregexp} $ecmd 0
258 }
259
260 # match expected, internal routine that does the work
261 # parameters like the "real" routines except they don't have "opts",
262 # which is a possibly-empty list of switches for the regexp match attempt
263 # The ! flag is used to indicate expected match failure (for REG_EXPECT,
264 # which wants argument testing even in the event of failure).
265 proc matchexpected {opts testid flags re target args} {
266 global prefix description ask regBug
267
268 if {[info exists regBug] && $regBug} {
269 # This will register as a skipped test
270 test $prefix.[tno $testid] [desc $testid] knownBug {format 0} {1}
271 return
272 }
273
274 # Tcl locale stuff doesn't do the ch/xy test fakery yet
275 if {[string first "+" $flags] >= 0} {
276 # This will register as a skipped test
277 test $prefix.[tno $testid] [desc $testid] localeRegexp {} {}
278 return
279 }
280
281 # if &, test as both BRE and ARE
282 set amp [string first "&" $flags]
283 if {$amp >= 0} {
284 set f [string range $flags 0 [expr $amp - 1]]
285 append f [string range $flags [expr $amp + 1] end]
286 eval [concat [list matchexpected $opts \
287 [linsert $testid end ARE] ${f} $re $target] $args]
288 eval [concat [list matchexpected $opts \
289 [linsert $testid end BRE] ${f}b $re $target] $args]
290 return
291 }
292
293 set f [flags $flags]
294 set infoflags [infoflags $flags]
295 set ccmd [concat [list testregexp -$ask] $f [list $re]]
296 set ecmd [concat [list testregexp] $opts $f [list $re $target]]
297
298 set nsub [expr [llength $args] - 1]
299 set names [list]
300 set refs ""
301 for {set i 0} {$i <= $nsub} {incr i} {
302 if {$i == 0} {
303 set name match
304 } else {
305 set name sub$i
306 }
307 lappend names $name
308 append refs " \$$name"
309 set $name ""
310 }
311 if {[string first "o" $flags] >= 0} { ;# REG_NOSUB kludge
312 set nsub 0 ;# unsigned value cannot be -1
313 }
314 if {[string first "t" $flags] >= 0} { ;# REG_EXPECT
315 incr nsub -1 ;# the extra does not count
316 }
317 set ecmd [concat $ecmd $names]
318 set erun "list \[$ecmd\] $refs"
319 set retcode [list 1]
320 if {[string first "!" $flags] >= 0} {
321 set retcode [list 0]
322 }
323 set result [concat $retcode $args]
324
325 set info [list $nsub $infoflags]
326 lappend testid "compile"
327 test $prefix.[tno $testid] [desc $testid] {testregexp} $ccmd $info
328 set testid [lreplace $testid end end "execute"]
329 test $prefix.[tno $testid] [desc $testid] {testregexp} $erun $result
330 }
331
332 # match expected (no missing, empty, or ambiguous submatches)
333 # m testno flags re target mat submat ...
334 proc m {args} {
335 eval matchexpected [linsert $args 0 [list]]
336 }
337
338 # match expected (full fanciness)
339 # i testno flags re target mat submat ...
340 proc i {args} {
341 eval matchexpected [linsert $args 0 [list "-indices"]]
342 }
343
344 # partial match expected
345 # p testno flags re target mat "" ...
346 # Quirk: number of ""s must be one more than number of subREs.
347 proc p {args} {
348 set f [lindex $args 1] ;# add ! flag
349 set args [lreplace $args 1 1 "!$f"]
350 eval matchexpected [linsert $args 0 [list "-indices"]]
351 }
352
353 # test is a knownBug
354 proc knownBug {args} {
355 set ::regBug 1
356 uplevel #0 $args
357 set ::regBug 0
358 }
359
360
361
362 # the tests themselves
363
364
365
366 # support functions and preliminary misc.
367 # This is sensitive to changes in message wording, but we really have to
368 # test the code->message expansion at least once.
369 test reg-0.1 "regexp error reporting" {
370 list [catch {regexp (*) ign} msg] $msg
371 } {1 {couldn't compile regular expression pattern: quantifier operand invalid}}
372
373
374
375 doing 1 "basic sanity checks"
376 m 1 & abc abc abc
377 f 2 & abc def
378 m 3 & abc xyabxabce abc
379
380
381
382 doing 2 "invalid option combinations"
383 e 1 qe a INVARG
384 e 2 qa a INVARG
385 e 3 qx a INVARG
386 e 4 qn a INVARG
387 e 5 ba a INVARG
388
389
390
391 doing 3 "basic syntax"
392 i 1 &NS "" a {0 -1}
393 m 2 NS a| a a
394 m 3 - a|b a a
395 m 4 - a|b b b
396 m 5 NS a||b b b
397 m 6 & ab ab ab
398
399
400
401 doing 4 "parentheses"
402 m 1 - (a)e ae ae a
403 m 2 o (a)e ae
404 m 3 b {\(a\)b} ab ab a
405 m 4 - a((b)c) abc abc bc b
406 m 5 - a(b)(c) abc abc b c
407 e 6 - a(b EPAREN
408 e 7 b {a\(b} EPAREN
409 # sigh, we blew it on the specs here... someday this will be fixed in POSIX,
410 # but meanwhile, it's fixed in AREs
411 m 8 eU a)b a)b a)b
412 e 9 - a)b EPAREN
413 e 10 b {a\)b} EPAREN
414 m 11 P a(?:b)c abc abc
415 e 12 e a(?:b)c BADRPT
416 i 13 S a()b ab {0 1} {1 0}
417 m 14 SP a(?:)b ab ab
418 i 15 S a(|b)c ac {0 1} {1 0}
419 m 16 S a(b|)c abc abc b
420
421
422
423 doing 5 "simple one-char matching"
424 # general case of brackets done later
425 m 1 & a.b axb axb
426 f 2 &n "a.b" "a\nb"
427 m 3 & {a[bc]d} abd abd
428 m 4 & {a[bc]d} acd acd
429 f 5 & {a[bc]d} aed
430 f 6 & {a[^bc]d} abd
431 m 7 & {a[^bc]d} aed aed
432 f 8 &p "a\[^bc]d" "a\nd"
433
434
435
436 doing 6 "context-dependent syntax"
437 # plus odds and ends
438 e 1 - * BADRPT
439 m 2 b * * *
440 m 3 b {\(*\)} * * *
441 e 4 - (*) BADRPT
442 m 5 b ^* * *
443 e 6 - ^* BADRPT
444 f 7 & ^b ^b
445 m 8 b x^ x^ x^
446 f 9 I x^ x
447 m 10 n "\n^" "x\nb" "\n"
448 f 11 bS {\(^b\)} ^b
449 m 12 - (^b) b b b
450 m 13 & {x$} x x
451 m 14 bS {\(x$\)} x x x
452 m 15 - {(x$)} x x x
453 m 16 b {x$y} "x\$y" "x\$y"
454 f 17 I {x$y} xy
455 m 18 n "x\$\n" "x\n" "x\n"
456 e 19 - + BADRPT
457 e 20 - ? BADRPT
458
459
460
461 doing 7 "simple quantifiers"
462 m 1 &N a* aa aa
463 i 2 &N a* b {0 -1}
464 m 3 - a+ aa aa
465 m 4 - a?b ab ab
466 m 5 - a?b b b
467 e 6 - ** BADRPT
468 m 7 bN ** *** ***
469 e 8 & a** BADRPT
470 e 9 & a**b BADRPT
471 e 10 & *** BADRPT
472 e 11 - a++ BADRPT
473 e 12 - a?+ BADRPT
474 e 13 - a?* BADRPT
475 e 14 - a+* BADRPT
476 e 15 - a*+ BADRPT
477
478
479
480 doing 8 "braces"
481 m 1 NQ "a{0,1}" "" ""
482 m 2 NQ "a{0,1}" ac a
483 e 3 - "a{1,0}" BADBR
484 e 4 - "a{1,2,3}" BADBR
485 e 5 - "a{257}" BADBR
486 e 6 - "a{1000}" BADBR
487 e 7 - "a{1" EBRACE
488 e 8 - "a{1n}" BADBR
489 m 9 BS "a{b" "a\{b" "a\{b"
490 m 10 BS "a{" "a\{" "a\{"
491 m 11 bQ "a\\{0,1\\}b" cb b
492 e 12 b "a\\{0,1" EBRACE
493 e 13 - "a{0,1\\" BADBR
494 m 14 Q "a{0}b" ab b
495 m 15 Q "a{0,0}b" ab b
496 m 16 Q "a{0,1}b" ab ab
497 m 17 Q "a{0,2}b" b b
498 m 18 Q "a{0,2}b" aab aab
499 m 19 Q "a{0,}b" aab aab
500 m 20 Q "a{1,1}b" aab ab
501 m 21 Q "a{1,3}b" aaaab aaab
502 f 22 Q "a{1,3}b" b
503 m 23 Q "a{1,}b" aab aab
504 f 24 Q "a{2,3}b" ab
505 m 25 Q "a{2,3}b" aaaab aaab
506 f 26 Q "a{2,}b" ab
507 m 27 Q "a{2,}b" aaaab aaaab
508
509
510
511 doing 9 "brackets"
512 m 1 & {a[bc]} ac ac
513 m 2 & {a[-]} a- a-
514 m 3 & {a[[.-.]]} a- a-
515 m 4 &L {a[[.zero.]]} a0 a0
516 m 5 &LM {a[[.zero.]-9]} a2 a2
517 m 6 &M {a[0-[.9.]]} a2 a2
518 m 7 &+L {a[[=x=]]} ax ax
519 m 8 &+L {a[[=x=]]} ay ay
520 f 9 &+L {a[[=x=]]} az
521 e 10 & {a[0-[=x=]]} ERANGE
522 m 11 &L {a[[:digit:]]} a0 a0
523 e 12 & {a[[:woopsie:]]} ECTYPE
524 f 13 &L {a[[:digit:]]} ab
525 e 14 & {a[0-[:digit:]]} ERANGE
526 m 15 &LP {[[:<:]]a} a a
527 m 16 &LP {a[[:>:]]} a a
528 e 17 & {a[[..]]b} ECOLLATE
529 e 18 & {a[[==]]b} ECOLLATE
530 e 19 & {a[[::]]b} ECTYPE
531 e 20 & {a[[.a} EBRACK
532 e 21 & {a[[=a} EBRACK
533 e 22 & {a[[:a} EBRACK
534 e 23 & {a[} EBRACK
535 e 24 & {a[b} EBRACK
536 e 25 & {a[b-} EBRACK
537 e 26 & {a[b-c} EBRACK
538 m 27 &M {a[b-c]} ab ab
539 m 28 & {a[b-b]} ab ab
540 m 29 &M {a[1-2]} a2 a2
541 e 30 & {a[c-b]} ERANGE
542 e 31 & {a[a-b-c]} ERANGE
543 m 32 &M {a[--?]b} a?b a?b
544 m 33 & {a[---]b} a-b a-b
545 m 34 & {a[]b]c} a]c a]c
546 m 35 EP {a[\]]b} a]b a]b
547 f 36 bE {a[\]]b} a]b
548 m 37 bE {a[\]]b} "a\\]b" "a\\]b"
549 m 38 eE {a[\]]b} "a\\]b" "a\\]b"
550 m 39 EP {a[\\]b} "a\\b" "a\\b"
551 m 40 eE {a[\\]b} "a\\b" "a\\b"
552 m 41 bE {a[\\]b} "a\\b" "a\\b"
553 e 42 - {a[\Z]b} EESCAPE
554 m 43 & {a[[b]c} "a\[c" "a\[c"
555 m 44 EMP* {a[\u00fe-\u0507][\u00ff-\u0300]b} \
556 "a\u0102\u02ffb" "a\u0102\u02ffb"
557
558
559
560 doing 10 "anchors and newlines"
561 m 1 & ^a a a
562 f 2 &^ ^a a
563 i 3 &N ^ a {0 -1}
564 i 4 & {a$} aba {2 2}
565 f 5 {&$} {a$} a
566 i 6 &N {$} ab {2 1}
567 m 7 &n ^a a a
568 m 8 &n "^a" "b\na" "a"
569 i 9 &w "^a" "a\na" {0 0}
570 i 10 &n^ "^a" "a\na" {2 2}
571 m 11 &n {a$} a a
572 m 12 &n "a\$" "a\nb" "a"
573 i 13 &n "a\$" "a\na" {0 0}
574 i 14 N ^^ a {0 -1}
575 m 15 b ^^ ^ ^
576 i 16 N {$$} a {1 0}
577 m 17 b {$$} "\$" "\$"
578 m 18 &N {^$} "" ""
579 f 19 &N {^$} a
580 i 20 &nN "^\$" "a\n\nb" {2 1}
581 m 21 N {$^} "" ""
582 m 22 b {$^} "\$^" "\$^"
583 m 23 P {\Aa} a a
584 m 24 ^P {\Aa} a a
585 f 25 ^nP {\Aa} "b\na"
586 m 26 P {a\Z} a a
587 m 27 {$P} {a\Z} a a
588 f 28 {$nP} {a\Z} "a\nb"
589 e 29 - ^* BADRPT
590 e 30 - {$*} BADRPT
591 e 31 - {\A*} BADRPT
592 e 32 - {\Z*} BADRPT
593
594
595
596 doing 11 "boundary constraints"
597 m 1 &LP {[[:<:]]a} a a
598 m 2 &LP {[[:<:]]a} -a a
599 f 3 &LP {[[:<:]]a} ba
600 m 4 &LP {a[[:>:]]} a a
601 m 5 &LP {a[[:>:]]} a- a
602 f 6 &LP {a[[:>:]]} ab
603 m 7 bLP {\<a} a a
604 f 8 bLP {\<a} ba
605 m 9 bLP {a\>} a a
606 f 10 bLP {a\>} ab
607 m 11 LP {\ya} a a
608 f 12 LP {\ya} ba
609 m 13 LP {a\y} a a
610 f 14 LP {a\y} ab
611 m 15 LP {a\Y} ab a
612 f 16 LP {a\Y} a-
613 f 17 LP {a\Y} a
614 f 18 LP {-\Y} -a
615 m 19 LP {-\Y} -% -
616 f 20 LP {\Y-} a-
617 e 21 - {[[:<:]]*} BADRPT
618 e 22 - {[[:>:]]*} BADRPT
619 e 23 b {\<*} BADRPT
620 e 24 b {\>*} BADRPT
621 e 25 - {\y*} BADRPT
622 e 26 - {\Y*} BADRPT
623 m 27 LP {\ma} a a
624 f 28 LP {\ma} ba
625 m 29 LP {a\M} a a
626 f 30 LP {a\M} ab
627 f 31 ILP {\Ma} a
628 f 32 ILP {a\m} a
629
630
631
632 doing 12 "character classes"
633 m 1 LP {a\db} a0b a0b
634 f 2 LP {a\db} axb
635 f 3 LP {a\Db} a0b
636 m 4 LP {a\Db} axb axb
637 m 5 LP "a\\sb" "a b" "a b"
638 m 6 LP "a\\sb" "a\tb" "a\tb"
639 m 7 LP "a\\sb" "a\nb" "a\nb"
640 f 8 LP {a\sb} axb
641 m 9 LP {a\Sb} axb axb
642 f 10 LP "a\\Sb" "a b"
643 m 11 LP {a\wb} axb axb
644 f 12 LP {a\wb} a-b
645 f 13 LP {a\Wb} axb
646 m 14 LP {a\Wb} a-b a-b
647 m 15 LP {\y\w+z\y} adze-guz guz
648 m 16 LPE {a[\d]b} a1b a1b
649 m 17 LPE "a\[\\s]b" "a b" "a b"
650 m 18 LPE {a[\w]b} axb axb
651
652
653
654 doing 13 "escapes"
655 e 1 & "a\\" EESCAPE
656 m 2 - {a\<b} a<b a<b
657 m 3 e {a\<b} a<b a<b
658 m 4 bAS {a\wb} awb awb
659 m 5 eAS {a\wb} awb awb
660 m 6 PL "a\\ab" "a\007b" "a\007b"
661 m 7 P "a\\bb" "a\bb" "a\bb"
662 m 8 P {a\Bb} "a\\b" "a\\b"
663 m 9 MP "a\\chb" "a\bb" "a\bb"
664 m 10 MP "a\\cHb" "a\bb" "a\bb"
665 m 11 LMP "a\\e" "a\033" "a\033"
666 m 12 P "a\\fb" "a\fb" "a\fb"
667 m 13 P "a\\nb" "a\nb" "a\nb"
668 m 14 P "a\\rb" "a\rb" "a\rb"
669 m 15 P "a\\tb" "a\tb" "a\tb"
670 m 16 P "a\\u0008x" "a\bx" "a\bx"
671 e 17 - {a\u008x} EESCAPE
672 m 18 P "a\\u00088x" "a\b8x" "a\b8x"
673 m 19 P "a\\U00000008x" "a\bx" "a\bx"
674 e 20 - {a\U0000008x} EESCAPE
675 m 21 P "a\\vb" "a\vb" "a\vb"
676 m 22 MP "a\\x08x" "a\bx" "a\bx"
677 e 23 - {a\xq} EESCAPE
678 m 24 MP "a\\x0008x" "a\bx" "a\bx"
679 e 25 - {a\z} EESCAPE
680 m 26 MP "a\\010b" "a\bb" "a\bb"
681
682
683
684 doing 14 "back references"
685 # ugh
686 m 1 RP {a(b*)c\1} abbcbb abbcbb bb
687 m 2 RP {a(b*)c\1} ac ac ""
688 f 3 RP {a(b*)c\1} abbcb
689 m 4 RP {a(b*)\1} abbcbb abb b
690 m 5 RP {a(b|bb)\1} abbcbb abb b
691 m 6 RP {a([bc])\1} abb abb b
692 f 7 RP {a([bc])\1} abc
693 m 8 RP {a([bc])\1} abcabb abb b
694 f 9 RP {a([bc])*\1} abc
695 f 10 RP {a([bc])\1} abB
696 m 11 iRP {a([bc])\1} abB abB b
697 m 12 RP {a([bc])\1+} abbb abbb b
698 m 13 QRP "a(\[bc])\\1{3,4}" abbbb abbbb b
699 f 14 QRP "a(\[bc])\\1{3,4}" abbb
700 m 15 RP {a([bc])\1*} abbb abbb b
701 m 16 RP {a([bc])\1*} ab ab b
702 m 17 RP {a([bc])(\1*)} ab ab b ""
703 e 18 - {a((b)\1)} ESUBREG
704 e 19 - {a(b)c\2} ESUBREG
705 m 20 bR {a\(b*\)c\1} abbcbb abbcbb bb
706
707
708
709 doing 15 "octal escapes vs back references"
710 # initial zero is always octal
711 m 1 MP "a\\010b" "a\bb" "a\bb"
712 m 2 MP "a\\0070b" "a\0070b" "a\0070b"
713 m 3 MP "a\\07b" "a\007b" "a\007b"
714 m 4 MP "a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\\07c" "abbbbbbbbbb\007c" \
715 "abbbbbbbbbb\007c" "b" "b" "b" "b" "b" "b" \
716 "b" "b" "b" "b"
717 # a single digit is always a backref
718 e 5 - {a\7b} ESUBREG
719 # otherwise it's a backref only if within range (barf!)
720 m 6 MP "a\\10b" "a\bb" "a\bb"
721 m 7 MP {a\101b} aAb aAb
722 m 8 RP {a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\10c} abbbbbbbbbbbc \
723 abbbbbbbbbbbc b b b b b b b \
724 b b b
725 # but we're fussy about border cases -- guys who want octal should use the zero
726 e 9 - {a((((((((((b\10))))))))))c} ESUBREG
727 # BREs don't have octal, EREs don't have backrefs
728 m 10 MP "a\\12b" "a\nb" "a\nb"
729 e 11 b {a\12b} ESUBREG
730 m 12 eAS {a\12b} a12b a12b
731
732
733
734 doing 16 "expanded syntax"
735 m 1 xP "a b c" "abc" "abc"
736 m 2 xP "a b #oops\nc\td" "abcd" "abcd"
737 m 3 x "a\\ b\\\tc" "a b\tc" "a b\tc"
738 m 4 xP "a b\\#c" "ab#c" "ab#c"
739 m 5 xP "a b\[c d]e" "ab e" "ab e"
740 m 6 xP "a b\[c#d]e" "ab#e" "ab#e"
741 m 7 xP "a b\[c#d]e" "abde" "abde"
742 m 8 xSPB "ab{ d" "ab\{d" "ab\{d"
743 m 9 xPQ "ab{ 1 , 2 }c" "abc" "abc"
744
745
746
747 doing 17 "misc syntax"
748 m 1 P a(?#comment)b ab ab
749
750
751
752 doing 18 "unmatchable REs"
753 f 1 I a^b ab
754
755
756
757 doing 19 "case independence"
758 m 1 &i ab Ab Ab
759 m 2 &i {a[bc]} aC aC
760 f 3 &i {a[^bc]} aB
761 m 4 &iM {a[b-d]} aC aC
762 f 5 &iM {a[^b-d]} aC
763
764
765
766 doing 20 "directors and embedded options"
767 e 1 & ***? BADPAT
768 m 2 q ***? ***? ***?
769 m 3 &P ***=a*b a*b a*b
770 m 4 q ***=a*b ***=a*b ***=a*b
771 m 5 bLP {***:\w+} ab ab
772 m 6 eLP {***:\w+} ab ab
773 e 7 & ***:***=a*b BADRPT
774 m 8 &P ***:(?b)a+b a+b a+b
775 m 9 P (?b)a+b a+b a+b
776 e 10 e {(?b)\w+} BADRPT
777 m 11 bAS {(?b)\w+} (?b)w+ (?b)w+
778 m 12 iP (?c)a a a
779 f 13 iP (?c)a A
780 m 14 APS {(?e)\W+} WW WW
781 m 15 P (?i)a+ Aa Aa
782 f 16 P "(?m)a.b" "a\nb"
783 m 17 P "(?m)^b" "a\nb" "b"
784 f 18 P "(?n)a.b" "a\nb"
785 m 19 P "(?n)^b" "a\nb" "b"
786 f 20 P "(?p)a.b" "a\nb"
787 f 21 P "(?p)^b" "a\nb"
788 m 22 P (?q)a+b a+b a+b
789 m 23 nP "(?s)a.b" "a\nb" "a\nb"
790 m 24 xP "(?t)a b" "a b" "a b"
791 m 25 P "(?w)a.b" "a\nb" "a\nb"
792 m 26 P "(?w)^b" "a\nb" "b"
793 m 27 P "(?x)a b" "ab" "ab"
794 e 28 - (?z)ab BADOPT
795 m 29 P (?ici)a+ Aa Aa
796 e 30 P (?i)(?q)a+ BADRPT
797 m 31 P (?q)(?i)a+ (?i)a+ (?i)a+
798 m 32 P (?qe)a+ a a
799 m 33 xP "(?q)a b" "a b" "a b"
800 m 34 P "(?qx)a b" "a b" "a b"
801 m 35 P (?qi)ab Ab Ab
802
803
804
805 doing 21 "capturing"
806 m 1 - a(b)c abc abc b
807 m 2 P a(?:b)c xabc abc
808 m 3 - a((b))c xabcy abc b b
809 m 4 P a(?:(b))c abcy abc b
810 m 5 P a((?:b))c abc abc b
811 m 6 P a(?:(?:b))c abc abc
812 i 7 Q "a(b){0}c" ac {0 1} {-1 -1}
813 m 8 - a(b)c(d)e abcde abcde b d
814 m 9 - (b)c(d)e bcde bcde b d
815 m 10 - a(b)(d)e abde abde b d
816 m 11 - a(b)c(d) abcd abcd b d
817 m 12 - (ab)(cd) xabcdy abcd ab cd
818 m 13 - a(b)?c xabcy abc b
819 i 14 - a(b)?c xacy {1 2} {-1 -1}
820 m 15 - a(b)?c(d)?e xabcdey abcde b d
821 i 16 - a(b)?c(d)?e xacdey {1 4} {-1 -1} {3 3}
822 i 17 - a(b)?c(d)?e xabcey {1 4} {2 2} {-1 -1}
823 i 18 - a(b)?c(d)?e xacey {1 3} {-1 -1} {-1 -1}
824 m 19 - a(b)*c xabcy abc b
825 i 20 - a(b)*c xabbbcy {1 5} {4 4}
826 i 21 - a(b)*c xacy {1 2} {-1 -1}
827 m 22 - a(b*)c xabbbcy abbbc bbb
828 m 23 - a(b*)c xacy ac ""
829 f 24 - a(b)+c xacy
830 m 25 - a(b)+c xabcy abc b
831 i 26 - a(b)+c xabbbcy {1 5} {4 4}
832 m 27 - a(b+)c xabbbcy abbbc bbb
833 i 28 Q "a(b){2,3}c" xabbbcy {1 5} {4 4}
834 i 29 Q "a(b){2,3}c" xabbcy {1 4} {3 3}
835 f 30 Q "a(b){2,3}c" xabcy
836 m 31 LP "\\y(\\w+)\\y" "-- abc-" "abc" "abc"
837 m 32 - a((b|c)d+)+ abacdbd acdbd bd b
838 m 33 N (.*).* abc abc abc
839 m 34 N (a*)* bc "" ""
840
841
842
843 doing 22 "multicharacter collating elements"
844 # again ugh
845 m 1 &+L {a[c]e} ace ace
846 f 2 &+IL {a[c]h} ach
847 m 3 &+L {a[[.ch.]]} ach ach
848 f 4 &+L {a[[.ch.]]} ace
849 m 5 &+L {a[c[.ch.]]} ac ac
850 m 6 &+L {a[c[.ch.]]} ace ac
851 m 7 &+L {a[c[.ch.]]} ache ach
852 f 8 &+L {a[^c]e} ace
853 m 9 &+L {a[^c]e} abe abe
854 m 10 &+L {a[^c]e} ache ache
855 f 11 &+L {a[^[.ch.]]} ach
856 m 12 &+L {a[^[.ch.]]} ace ac
857 m 13 &+L {a[^[.ch.]]} ac ac
858 m 14 &+L {a[^[.ch.]]} abe ab
859 f 15 &+L {a[^c[.ch.]]} ach
860 f 16 &+L {a[^c[.ch.]]} ace
861 f 17 &+L {a[^c[.ch.]]} ac
862 m 18 &+L {a[^c[.ch.]]} abe ab
863 m 19 &+L {a[^b]} ac ac
864 m 20 &+L {a[^b]} ace ac
865 m 21 &+L {a[^b]} ach ach
866 f 22 &+L {a[^b]} abe
867
868
869
870 doing 23 "lookahead constraints"
871 m 1 HP a(?=b)b* ab ab
872 f 2 HP a(?=b)b* a
873 m 3 HP a(?=b)b*(?=c)c* abc abc
874 f 4 HP a(?=b)b*(?=c)c* ab
875 f 5 HP a(?!b)b* ab
876 m 6 HP a(?!b)b* a a
877 m 7 HP (?=b)b b b
878 f 8 HP (?=b)b a
879
880
881
882 doing 24 "non-greedy quantifiers"
883 m 1 PT ab+? abb ab
884 m 2 PT ab+?c abbc abbc
885 m 3 PT ab*? abb a
886 m 4 PT ab*?c abbc abbc
887 m 5 PT ab?? ab a
888 m 6 PT ab??c abc abc
889 m 7 PQT "ab{2,4}?" abbbb abb
890 m 8 PQT "ab{2,4}?c" abbbbc abbbbc
891 m 9 - 3z* 123zzzz456 3zzzz
892 m 10 PT 3z*? 123zzzz456 3
893 m 11 - z*4 123zzzz456 zzzz4
894 m 12 PT z*?4 123zzzz456 zzzz4
895
896
897
898 doing 25 "mixed quantifiers"
899 # this is very incomplete as yet
900 # should include |
901 m 1 PNT {^(.*?)(a*)$} xyza xyza xyz a
902 m 2 PNT {^(.*?)(a*)$} xyzaa xyzaa xyz aa
903 m 3 PNT {^(.*?)(a*)$} xyz xyz xyz ""
904
905
906
907 doing 26 "tricky cases"
908 # attempts to trick the matcher into accepting a short match
909 m 1 - (week|wee)(night|knights) weeknights weeknights \
910 wee knights
911 m 2 RP {a(bc*).*\1} abccbccb abccbccb b
912 m 3 - {a(b.[bc]*)+} abcbd abcbd bd
913
914
915
916 doing 27 "implementation misc."
917 # duplicate arcs are suppressed
918 m 1 P a(?:b|b)c abc abc
919 # make color/subcolor relationship go back and forth
920 m 2 & {[ab][ab][ab]} aba aba
921 m 3 & {[ab][ab][ab][ab][ab][ab][ab]} abababa abababa
922
923
924
925 doing 28 "boundary busters etc."
926 # color-descriptor allocation changes at 10
927 m 1 & abcdefghijkl abcdefghijkl abcdefghijkl
928 # so does arc allocation
929 m 2 P a(?:b|c|d|e|f|g|h|i|j|k|l|m)n agn agn
930 # subexpression tracking also at 10
931 m 3 - a(((((((((((((b)))))))))))))c abc abc b b b b b b b b b b b b b
932 # state-set handling changes slightly at unsigned size (might be 64...)
933 # (also stresses arc allocation)
934 m 4 Q "ab{1,100}c" abbc abbc
935 m 5 Q "ab{1,100}c" abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc \
936 abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
937 m 6 Q "ab{1,100}c" \
938 abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc \
939 abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
940 # force small cache and bust it, several ways
941 m 7 LP {\w+abcdefgh} xyzabcdefgh xyzabcdefgh
942 m 8 %LP {\w+abcdefgh} xyzabcdefgh xyzabcdefgh
943 m 9 %LP {\w+abcdefghijklmnopqrst} xyzabcdefghijklmnopqrst \
944 xyzabcdefghijklmnopqrst
945 i 10 %LP {\w+(abcdefgh)?} xyz {0 2} {-1 -1}
946 i 11 %LP {\w+(abcdefgh)?} xyzabcdefg {0 9} {-1 -1}
947 i 12 %LP {\w+(abcdefghijklmnopqrst)?} xyzabcdefghijklmnopqrs \
948 {0 21} {-1 -1}
949
950
951
952 doing 29 "incomplete matches"
953 p 1 t def abc {3 2} ""
954 p 2 t bcd abc {1 2} ""
955 p 3 t abc abab {0 3} ""
956 p 4 t abc abdab {3 4} ""
957 i 5 t abc abc {0 2} {0 2}
958 i 6 t abc xyabc {2 4} {2 4}
959 p 7 t abc+ xyab {2 3} ""
960 i 8 t abc+ xyabc {2 4} {2 4}
961 knownBug i 9 t abc+ xyabcd {2 4} {6 5}
962 i 10 t abc+ xyabcdd {2 4} {7 6}
963 p 11 tPT abc+? xyab {2 3} ""
964 # the retain numbers in these two may look wrong, but they aren't
965 i 12 tPT abc+? xyabc {2 4} {5 4}
966 i 13 tPT abc+? xyabcc {2 4} {6 5}
967 i 14 tPT abc+? xyabcd {2 4} {6 5}
968 i 15 tPT abc+? xyabcdd {2 4} {7 6}
969 i 16 t abcd|bc xyabc {3 4} {2 4}
970 p 17 tn .*k "xx\nyyy" {3 5} ""
971
972
973 doing 30 "misc. oddities and old bugs"
974 e 1 & *** BADRPT
975 m 2 N a?b* abb abb
976 m 3 N a?b* bb bb
977 m 4 & a*b aab aab
978 m 5 & ^a*b aaaab aaaab
979 m 6 &M {[0-6][1-2][0-3][0-6][1-6][0-6]} 010010 010010
980 # temporary REG_BOSONLY kludge
981 m 7 s abc abcd abc
982 f 8 s abc xabcd
983 # back to normal stuff
984 m 9 HLP {(?n)^(?![t#])\S+} "tk\n\n#\n#\nit0" it0
985
986
987 # flush any leftover complaints
988 doing 0 "flush"
989
990 # Tests resulting from bugs reported by users
991 test reg-31.1 {[[:xdigit:]] behaves correctly when followed by [[:space:]]} {
992 set str {2:::DebugWin32}
993 set re {([[:xdigit:]])([[:space:]]*)}
994 list [regexp $re $str match xdigit spaces] $match $xdigit $spaces
995 # Code used to produce {1 2:::DebugWin32 2 :::DebugWin32} !!!
996 } {1 2 2 {}}
997
998 test reg-32.1 {canmatch functionality -- at end} {
999 set pat {blah}
1000 set line "asd asd"
1001 # can match at the final d, if '%' follows
1002 set res [testregexp -xflags -- c $pat $line resvar]
1003 lappend res $resvar
1004 } {0 7}
1005
1006 test reg-32.2 {canmatch functionality -- at end} {
1007 set pat {s%$}
1008 set line "asd asd"
1009 # can only match after the end of the string
1010 set res [testregexp -xflags -- c $pat $line resvar]
1011 lappend res $resvar
1012 } {0 7}
1013
1014 test reg-32.3 {canmatch functionality -- not last char} {
1015 set pat {[^d]%$}
1016 set line "asd asd"
1017 # can only match after the end of the string
1018 set res [testregexp -xflags -- c $pat $line resvar]
1019 lappend res $resvar
1020 } {0 7}
1021
1022 test reg-32.3.1 {canmatch functionality -- no match} {
1023 set pat {\Zx}
1024 set line "asd asd"
1025 # can match the last char, if followed by x
1026 set res [testregexp -xflags -- c $pat $line resvar]
1027 lappend res $resvar
1028 } {0 -1}
1029
1030 test reg-32.4 {canmatch functionality -- last char} {knownBug} {
1031 set pat {.x}
1032 set line "asd asd"
1033 # can match the last char, if followed by x
1034 set res [testregexp -xflags -- c $pat $line resvar]
1035 lappend res $resvar
1036 } {0 6}
1037
1038 test reg-32.4.1 {canmatch functionality -- last char} {knownBug} {
1039 set pat {.x$}
1040 set line "asd asd"
1041 # can match the last char, if followed by x
1042 set res [testregexp -xflags -- c $pat $line resvar]
1043 lappend res $resvar
1044 } {0 6}
1045
1046 test reg-32.5 {canmatch functionality -- last char} {knownBug} {
1047 set pat {.[^d]x$}
1048 set line "asd asd"
1049 # can match the last char, if followed by not-d and x.
1050 set res [testregexp -xflags -- c $pat $line resvar]
1051 lappend res $resvar
1052 } {0 6}
1053
1054 test reg-32.6 {canmatch functionality -- last char} {knownBug} {
1055 set pat {[^a]%[^\r\n]*$}
1056 set line "asd asd"
1057 # can match at the final d, if '%' follows
1058 set res [testregexp -xflags -- c $pat $line resvar]
1059 lappend res $resvar
1060 } {0 6}
1061
1062 test reg-32.7 {canmatch functionality -- last char} {knownBug} {
1063 set pat {[^a]%$}
1064 set line "asd asd"
1065 # can match at the final d, if '%' follows
1066 set res [testregexp -xflags -- c $pat $line resvar]
1067 lappend res $resvar
1068 } {0 6}
1069
1070 test reg-32.8 {canmatch functionality -- last char} {knownBug} {
1071 set pat {[^x]%$}
1072 set line "asd asd"
1073 # can match at the final d, if '%' follows
1074 set res [testregexp -xflags -- c $pat $line resvar]
1075 lappend res $resvar
1076 } {0 6}
1077
1078 test reg-32.9 {canmatch functionality -- more complex case} {knownBug} {
1079 set pat {((\B\B|\Bh+line)[ \t]*|[^\B]%[^\r\n]*)$}
1080 set line "asd asd"
1081 # can match at the final d, if '%' follows
1082 set res [testregexp -xflags -- c $pat $line resvar]
1083 lappend res $resvar
1084 } {0 6}
1085
1086 # Tests reg-33.*: Checks for bug fixes
1087
1088 test reg-33.1 {Bug 230589} {
1089 regexp {[ ]*(^|[^%])%V} "*%V2" m s
1090 } 1
1091
1092 test reg-33.2 {Bug 504785} {
1093 regexp -inline {([^_.]*)([^.]*)\.(..)(.).*} bbcos_001_c01.q1la
1094 } {bbcos_001_c01.q1la bbcos _001_c01 q1 l}
1095
1096 test reg-33.3 {Bug 505048} {
1097 regexp {\A\s*[^<]*\s*<([^>]+)>} a<a>
1098 } 1
1099
1100 test reg-33.4 {Bug 505048} {
1101 regexp {\A\s*([^b]*)b} ab
1102 } 1
1103
1104 test reg-33.5 {Bug 505048} {
1105 regexp {\A\s*[^b]*(b)} ab
1106 } 1
1107
1108 test reg-33.6 {Bug 505048} {
1109 regexp {\A(\s*)[^b]*(b)} ab
1110 } 1
1111
1112 test reg-33.7 {Bug 505048} {
1113 regexp {\A\s*[^b]*b} ab
1114 } 1
1115
1116 test reg-33.8 {Bug 505048} {
1117 regexp -inline {\A\s*[^b]*b} ab
1118 } ab
1119
1120 test reg-33.9 {Bug 505048} {
1121 regexp -indices -inline {\A\s*[^b]*b} ab
1122 } {{0 1}}
1123
1124 test reg-33.10 {Bug 840258} {
1125 regsub {(^|\n)+\.*b} \n.b {} tmp
1126 } 1
1127
1128 test reg-33.11 {Bug 840258} {
1129 regsub {(^|[\n\r]+)\.*\?<.*?(\n|\r)+} \
1130 "TQ\r\n.?<5000267>Test already stopped\r\n" {} tmp
1131 } 1
1132
1133 # cleanup
1134 ::tcltest::cleanupTests
1135 return