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