path: root/tests/reg.test

# reg.test --
#
# This file contains a collection of tests for one or more of the Tcl
# built-in commands.  Sourcing this file into Tcl runs the tests and
# generates output for errors.  No output means no errors were found.
# (Don't panic if you are seeing this as part of the reg distribution
# and aren't using Tcl -- reg's own regression tester also knows how
# to read this file, ignoring the Tcl-isms.)
#
# Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.

if {[lsearch [namespace children] ::tcltest] == -1} {
    package require tcltest 2
}

::tcltest::loadTestedCommands
catch [list package require -exact Tcltest [info patchlevel]]

# All tests require the testregexp command, return if this
# command doesn't exist

::tcltest::testConstraint testregexp [llength [info commands testregexp]]
::tcltest::testConstraint localeRegexp 0

# This file uses some custom procedures, defined below, for regexp regression
# testing.  The name of the procedure indicates the general nature of the
# test:
#	expectError	compile error expected
#	expectNomatch	match failure expected
#	expectMatch	successful match
#	expectIndices	successful match with -indices (used in checking things
#			like nonparticipating subexpressions)
#	expectPartial	unsuccessful match with -indices (!!) (used in checking
#			partial-match reporting)
# There is also "doing" which sets up title and major test number for each
# block of tests.

# The first 3 arguments are constant: a minor number (which often gets
# a letter or two suffixed to it internally), some flags, and the RE
# itself.  For expectError, the remaining argument is the name of the
# compile error expected, less the leading "REG_".  For the rest, the
# next argument is the string to try the match against.  Remaining
# arguments are the substring expected to be matched, and any
# substrings expected to be matched by subexpressions.  (For
# expectNomatch, these arguments are optional, and if present are
# ignored except that they indicate how many subexpressions should be
# present in the RE.)  It is an error for the number of subexpression
# arguments to be wrong.  Cases involving nonparticipating
# subexpressions, checking where empty substrings are located,
# etc. should be done using expectIndices and expectPartial.

# The flag characters are complex and a bit eclectic.  Generally speaking,
# lowercase letters are compile options, uppercase are expected re_info
# bits, and nonalphabetics are match options, controls for how the test is
# run, or testing options.  The one small surprise is that AREs are the
# default, and you must explicitly request lesser flavors of RE.  The flags
# are as follows.  It is admitted that some are not very mnemonic.
# There are some others which are purely debugging tools and are not
# useful in this file.
#
#	-	no-op (placeholder)
#	+	provide fake xy equivalence class and ch collating element
#	%	force small state-set cache in matcher (to test cache replace)
#	^	beginning of string is not beginning of line
#	$	end of string is not end of line
#	*	test is Unicode-specific, needs big character set
#
#	&	test as both ARE and BRE
#	b	BRE
#	e	ERE
#	a	turn advanced-features bit on (error unless ERE already)
#	q	literal string, no metacharacters at all
#
#	i	case-independent matching
#	o	("opaque") no subexpression capture
#	p	newlines are half-magic, excluded from . and [^ only
#	w	newlines are half-magic, significant to ^ and $ only
#	n	newlines are fully magic, both effects
#	x	expanded RE syntax
#	t	incomplete-match reporting
#
#	A	backslash-_a_lphanumeric seen
#	B	ERE/ARE literal-_b_race heuristic used
#	E	backslash (_e_scape) seen within []
#	H	looka_h_ead constraint seen
#	I	_i_mpossible to match
#	L	_l_ocale-specific construct seen
#	M	unportable (_m_achine-specific) construct seen
#	N	RE can match empty (_n_ull) string
#	P	non-_P_OSIX construct seen
#	Q	{} _q_uantifier seen
#	R	back _r_eference seen
#	S	POSIX-un_s_pecified syntax seen
#	T	prefers shortest (_t_iny)
#	U	saw original-POSIX botch:  unmatched right paren in ERE (_u_gh)

# The one area we can't easily test is memory-allocation failures (which
# are hard to provoke on command).  Embedded NULs also are not tested at
# the moment, but this is a historical accident which should be fixed.


# test procedures and related
namespace eval RETest {
    namespace export doing expect* knownBug

    variable regBug 0

    # re_info abbreviation mapping table
    variable infonames
    array set infonames {
	A REG_UBSALNUM
	B REG_UBRACES
	E REG_UBBS
	H REG_ULOOKAHEAD
	I REG_UIMPOSSIBLE
	L REG_ULOCALE
	M REG_UUNPORT
	N REG_UEMPTYMATCH
	P REG_UNONPOSIX
	Q REG_UBOUNDS
	R REG_UBACKREF
	S REG_UUNSPEC
	T REG_USHORTEST
	U REG_UPBOTCH
    }
    variable infonameorder "RHQBAUEPSMLNIT" ;# must match bit order, lsb first

    # build test number (internal)
    proc TestNum {args} {
	return reg-[join [concat $args] .]
    }

    # build description, with possible modifiers (internal)
    proc TestDesc {args} {
	variable description

	set testid [concat $args]
	set d $description
	if {[llength $testid] > 1} {
	    set d "$d ([lrange $testid 1 end])"
	}
	return $d
    }

    # build trailing options and flags argument from a flags string (internal)
    proc TestFlags {fl} {
	set args [list]
	set flags ""
	foreach f [split $fl ""] {
	    switch -exact -- $f {
		"i" { lappend args "-nocase" }
		"x" { lappend args "-expanded" }
		"n" { lappend args "-line" }
		"p" { lappend args "-linestop" }
		"w" { lappend args "-lineanchor" }
		"-" { }
		default { append flags $f }
	    }
	}
	if {$flags ne ""} {
	    lappend args -xflags $flags
	}
	return $args
    }

    # build info-flags list from a flags string (internal)
    proc TestInfoFlags {fl} {
	variable infonames
	variable infonameorder

	set ret [list]
	foreach f [split $infonameorder ""] {
	    if {[string match *$f* $fl]} {
		lappend ret $infonames($f)
	    }
	}
	return $ret
    }

    # Share the generation of the list of test constraints so it is
    # done the same on all routes.
    proc TestConstraints {flags} {
	set constraints [list testregexp]

	variable regBug
	if {$regBug} {
	    # This will trigger registration as a skipped test
	    lappend constraints knownBug
	}

	# Tcl locale stuff doesn't do the ch/xy test fakery yet
	if {[string match *+* $flags]} {
	    # This will trigger registration as a skipped test
	    lappend constraints localeRegexp
	}

	return $constraints
    }

    # match expected, internal routine that does the work
    # parameters like the "real" routines except they don't have "opts",
    #  which is a possibly-empty list of switches for the regexp match attempt
    # The ! flag is used to indicate expected match failure (for REG_EXPECT,
    #  which wants argument testing even in the event of failure).
    proc MatchExpected {opts testid flags re target args} {
	# if &, test as both BRE and ARE
	if {[string match *&* $flags]} {
	    set f [string map {& {}} $flags]
	    MatchExpected $opts "$testid ARE" ${f}  $re $target {*}$args
	    MatchExpected $opts "$testid BRE" ${f}b $re $target {*}$args
	    return
	}

	set constraints [TestConstraints $flags]

	set f [TestFlags $flags]
	set infoflags [TestInfoFlags $flags]
	set ccmd [list testregexp -about        {*}$f $re]
	set ecmd [list testregexp {*}$opts {*}$f $re $target]

	set nsub [expr {[llength $args] - 1}]
	set names [list]
	set refs ""
	for {set i 0} {$i < [llength $args]} {incr i} {
	    if {$i == 0} {
		set name match
	    } else {
		set name sub$i
	    }
	    lappend names $name
	    append refs " \$$name"
	    set $name ""
	}
	if {[string match *o* $flags]} {	;# REG_NOSUB kludge
	    set nsub 0				;# unsigned value cannot be -1
	}
	if {[string match *t* $flags]} {	;# REG_EXPECT
	    incr nsub -1			;# the extra does not count
	}
	set erun "list \[[concat $ecmd $names]\] $refs"
	set result [list [expr {![string match *!* $flags]}] {*}$args]
	set info [list $nsub $infoflags]

	::tcltest::test [TestNum $testid compile] [TestDesc $testid compile] \
		-constraints $constraints -body $ccmd -result $info
	::tcltest::test [TestNum $testid execute] [TestDesc $testid execute] \
		-constraints $constraints -body $erun -result $result
    }

    # set major test number and description
    proc doing {major desc} {
	variable description "RE engine $desc"
    }

    # compilation error expected
    proc expectError {testid flags re err} {
	# if &, test as both ARE and BRE
	if {[string match *&* $flags]} {
	    set f [string map {& {}} $flags]
	    expectError "$testid ARE" ${f}  $re $err
	    expectError "$testid BRE" ${f}b $re $err
	    return
	}

	set constraints [TestConstraints $flags]

	set cmd [list testregexp -about {*}[TestFlags $flags] $re]
	::tcltest::test [TestNum $testid error] [TestDesc $testid error] \
		-constraints $constraints -result [list 1 REG_$err] -body \
		"list \[catch \{$cmd\}\] \[lindex \$::errorCode 1\]"
    }

    # match failure expected
    proc expectNomatch {testid flags re target args} {
	variable regBug
	# if &, test as both ARE and BRE
	if {[string match *&* $flags]} {
	    set f [string map {& {}} $flags]
	    expectNomatch "$testid ARE" ${f}  $re $target {*}$args
	    expectNomatch "$testid BRE" ${f}b $re $target {*}$args
	    return
	}

	set constraints [TestConstraints $flags]

	set f [TestFlags $flags]
	set infoflags [TestInfoFlags $flags]
	set ccmd [list testregexp -about {*}$f $re]
	set nsub [expr {[llength $args] - 1}]
	if {$nsub == -1} {
	    # didn't tell us number of subexps
	    set ccmd "lreplace \[$ccmd\] 0 0"
	    set info [list $infoflags]
	} else {
	    set info [list $nsub $infoflags]
	}
	set ecmd [list testregexp {*}$f $re $target]

	::tcltest::test [TestNum $testid compile] [TestDesc $testid compile] \
		-constraints $constraints -body $ccmd -result $info
	::tcltest::test [TestNum $testid execute] [TestDesc $testid execute] \
		-constraints $constraints -body $ecmd -result 0
    }

    # match expected (no missing, empty, or ambiguous submatches)
    # expectMatch testno flags re target mat submat ...
    proc expectMatch {args} {
	MatchExpected {} {*}$args
    }

    # match expected (full fanciness)
    # expectIndices testno flags re target mat submat ...
    proc expectIndices {args} {
	MatchExpected -indices {*}$args
    }

    # partial match expected
    # expectPartial testno flags re target mat "" ...
    # Quirk:  number of ""s must be one more than number of subREs.
    proc expectPartial {args} {
	lset args 1 ![lindex $args 1]	;# add ! flag
	MatchExpected -indices {*}$args
    }

    # test is a knownBug
    proc knownBug {args} {
	variable regBug 1
	uplevel \#0 $args
	set regBug 0
    }
}
namespace import RETest::*

######## the tests themselves ########

# support functions and preliminary misc.
# This is sensitive to changes in message wording, but we really have to
# test the code->message expansion at least once.
::tcltest::test reg-0.1 "regexp error reporting" {
    list [catch {regexp (*) ign} msg] $msg
} {1 {couldn't compile regular expression pattern: quantifier operand invalid}}


doing 1 "basic sanity checks"
expectMatch	1.1 &		abc	abc		abc
expectNomatch	1.2 &		abc	def
expectMatch	1.3 &		abc	xyabxabce	abc


doing 2 "invalid option combinations"
expectError	2.1 qe		a	INVARG
expectError	2.2 qa		a	INVARG
expectError	2.3 qx		a	INVARG
expectError	2.4 qn		a	INVARG
expectError	2.5 ba		a	INVARG


doing 3 "basic syntax"
expectIndices	3.1 &NS		""	a	{0 -1}
expectMatch	3.2 NS		a|	a	a
expectMatch	3.3 -		a|b	a	a
expectMatch	3.4 -		a|b	b	b
expectMatch	3.5 NS		a||b	b	b
expectMatch	3.6 &		ab	ab	ab


doing 4 "parentheses"
expectMatch	4.1  -		(a)e		ae	ae	a
expectMatch	4.2  o		(a)e		ae
expectMatch	4.3  b		{\(a\)b}	ab	ab	a
expectMatch	4.4  -		a((b)c)		abc	abc	bc	b
expectMatch	4.5  -		a(b)(c)		abc	abc	b	c
expectError	4.6  -		a(b		EPAREN
expectError	4.7  b		{a\(b}		EPAREN
# sigh, we blew it on the specs here... someday this will be fixed in POSIX,
#  but meanwhile, it's fixed in AREs
expectMatch	4.8  eU		a)b		a)b	a)b
expectError	4.9  -		a)b		EPAREN
expectError	4.10 b		{a\)b}		EPAREN
expectMatch	4.11 P		a(?:b)c		abc	abc
expectError	4.12 e		a(?:b)c		BADRPT
expectIndices	4.13 S		a()b		ab	{0 1}	{1 0}
expectMatch	4.14 SP		a(?:)b		ab	ab
expectIndices	4.15 S		a(|b)c		ac	{0 1}	{1 0}
expectMatch	4.16 S		a(b|)c		abc	abc	b


doing 5 "simple one-char matching"
# general case of brackets done later
expectMatch	5.1 &		a.b		axb	axb
expectNomatch	5.2 &n		"a.b"		"a\nb"
expectMatch	5.3 &		{a[bc]d}	abd	abd
expectMatch	5.4 &		{a[bc]d}	acd	acd
expectNomatch	5.5 &		{a[bc]d}	aed
expectNomatch	5.6 &		{a[^bc]d}	abd
expectMatch	5.7 &		{a[^bc]d}	aed	aed
expectNomatch	5.8 &p		"a\[^bc]d"	"a\nd"


doing 6 "context-dependent syntax"
# plus odds and ends
expectError	6.1  -		*	BADRPT
expectMatch	6.2  b		*	*	*
expectMatch	6.3  b		{\(*\)}	*	*	*
expectError	6.4  -		(*)	BADRPT
expectMatch	6.5  b		^*	*	*
expectError	6.6  -		^*	BADRPT
expectNomatch	6.7  &		^b	^b
expectMatch	6.8  b		x^	x^	x^
expectNomatch	6.9  I		x^	x
expectMatch	6.10 n		"\n^"	"x\nb"	"\n"
expectNomatch	6.11 bS		{\(^b\)} ^b
expectMatch	6.12 -		(^b)	b	b	b
expectMatch	6.13 &		{x$}	x	x
expectMatch	6.14 bS		{\(x$\)} x	x	x
expectMatch	6.15 -		{(x$)}	x	x	x
expectMatch	6.16 b		{x$y}	"x\$y"	"x\$y"
expectNomatch	6.17 I		{x$y}	xy
expectMatch	6.18 n		"x\$\n"	"x\n"	"x\n"
expectError	6.19 -		+	BADRPT
expectError	6.20 -		?	BADRPT


doing 7 "simple quantifiers"
expectMatch	7.1  &N		a*	aa	aa
expectIndices	7.2  &N		a*	b	{0 -1}
expectMatch	7.3  -		a+	aa	aa
expectMatch	7.4  -		a?b	ab	ab
expectMatch	7.5  -		a?b	b	b
expectError	7.6  -		**	BADRPT
expectMatch	7.7  bN		**	***	***
expectError	7.8  &		a**	BADRPT
expectError	7.9  &		a**b	BADRPT
expectError	7.10 &		***	BADRPT
expectError	7.11 -		a++	BADRPT
expectError	7.12 -		a?+	BADRPT
expectError	7.13 -		a?*	BADRPT
expectError	7.14 -		a+*	BADRPT
expectError	7.15 -		a*+	BADRPT


doing 8 "braces"
expectMatch	8.1  NQ		"a{0,1}"	""	""
expectMatch	8.2  NQ		"a{0,1}"	ac	a
expectError	8.3  -		"a{1,0}"	BADBR
expectError	8.4  -		"a{1,2,3}"	BADBR
expectError	8.5  -		"a{257}"	BADBR
expectError	8.6  -		"a{1000}"	BADBR
expectError	8.7  -		"a{1"		EBRACE
expectError	8.8  -		"a{1n}"		BADBR
expectMatch	8.9  BS		"a{b"		"a\{b"	"a\{b"
expectMatch	8.10 BS		"a{"		"a\{"	"a\{"
expectMatch	8.11 bQ		"a\\{0,1\\}b"	cb	b
expectError	8.12 b		"a\\{0,1"	EBRACE
expectError	8.13 -		"a{0,1\\"	BADBR
expectMatch	8.14 Q		"a{0}b"		ab	b
expectMatch	8.15 Q		"a{0,0}b"	ab	b
expectMatch	8.16 Q		"a{0,1}b"	ab	ab
expectMatch	8.17 Q		"a{0,2}b"	b	b
expectMatch	8.18 Q		"a{0,2}b"	aab	aab
expectMatch	8.19 Q		"a{0,}b"	aab	aab
expectMatch	8.20 Q		"a{1,1}b"	aab	ab
expectMatch	8.21 Q		"a{1,3}b"	aaaab	aaab
expectNomatch	8.22 Q		"a{1,3}b"	b
expectMatch	8.23 Q		"a{1,}b"	aab	aab
expectNomatch	8.24 Q		"a{2,3}b"	ab
expectMatch	8.25 Q		"a{2,3}b"	aaaab	aaab
expectNomatch	8.26 Q		"a{2,}b"	ab
expectMatch	8.27 Q		"a{2,}b"	aaaab	aaaab


doing 9 "brackets"
expectMatch	9.1  &		{a[bc]}		ac	ac
expectMatch	9.2  &		{a[-]}		a-	a-
expectMatch	9.3  &		{a[[.-.]]}	a-	a-
expectMatch	9.4  &L		{a[[.zero.]]}	a0	a0
expectMatch	9.5  &LM	{a[[.zero.]-9]}	a2	a2
expectMatch	9.6  &M		{a[0-[.9.]]}	a2	a2
expectMatch	9.7  &+L	{a[[=x=]]}	ax	ax
expectMatch	9.8  &+L	{a[[=x=]]}	ay	ay
expectNomatch	9.9  &+L	{a[[=x=]]}	az
expectError	9.10 &		{a[0-[=x=]]}	ERANGE
expectMatch	9.11 &L		{a[[:digit:]]}	a0	a0
expectError	9.12 &		{a[[:woopsie:]]}	ECTYPE
expectNomatch	9.13 &L		{a[[:digit:]]}	ab
expectError	9.14 &		{a[0-[:digit:]]}	ERANGE
expectMatch	9.15 &LP	{[[:<:]]a}	a	a
expectMatch	9.16 &LP	{a[[:>:]]}	a	a
expectError	9.17 &		{a[[..]]b}	ECOLLATE
expectError	9.18 &		{a[[==]]b}	ECOLLATE
expectError	9.19 &		{a[[::]]b}	ECTYPE
expectError	9.20 &		{a[[.a}		EBRACK
expectError	9.21 &		{a[[=a}		EBRACK
expectError	9.22 &		{a[[:a}		EBRACK
expectError	9.23 &		{a[}		EBRACK
expectError	9.24 &		{a[b}		EBRACK
expectError	9.25 &		{a[b-}		EBRACK
expectError	9.26 &		{a[b-c}		EBRACK
expectMatch	9.27 &M		{a[b-c]}	ab	ab
expectMatch	9.28 &		{a[b-b]}	ab	ab
expectMatch	9.29 &M		{a[1-2]}	a2	a2
expectError	9.30 &		{a[c-b]}	ERANGE
expectError	9.31 &		{a[a-b-c]}	ERANGE
expectMatch	9.32 &M		{a[--?]b}	a?b	a?b
expectMatch	9.33 &		{a[---]b}	a-b	a-b
expectMatch	9.34 &		{a[]b]c}	a]c	a]c
expectMatch	9.35 EP		{a[\]]b}	a]b	a]b
expectNomatch	9.36 bE		{a[\]]b}	a]b
expectMatch	9.37 bE		{a[\]]b}	"a\\]b"	"a\\]b"
expectMatch	9.38 eE		{a[\]]b}	"a\\]b"	"a\\]b"
expectMatch	9.39 EP		{a[\\]b}	"a\\b"	"a\\b"
expectMatch	9.40 eE		{a[\\]b}	"a\\b"	"a\\b"
expectMatch	9.41 bE		{a[\\]b}	"a\\b"	"a\\b"
expectError	9.42 -		{a[\Z]b}	EESCAPE
expectMatch	9.43 &		{a[[b]c}	"a\[c"	"a\[c"
expectMatch	9.44 EMP*	{a[\u00fe-\u0507][\u00ff-\u0300]b} \
	"a\u0102\u02ffb"	"a\u0102\u02ffb"


doing 10 "anchors and newlines"
expectMatch	10.1  &		^a	a	a
expectNomatch	10.2  &^	^a	a
expectIndices	10.3  &N	^	a	{0 -1}
expectIndices	10.4  &		{a$}	aba	{2 2}
expectNomatch	10.5  {&$}	{a$}	a
expectIndices	10.6  &N	{$}	ab	{2 1}
expectMatch	10.7  &n	^a	a	a
expectMatch	10.8  &n	"^a"	"b\na"	"a"
expectIndices	10.9  &w	"^a"	"a\na"	{0 0}
expectIndices	10.10 &n^	"^a"	"a\na"	{2 2}
expectMatch	10.11 &n	{a$}	a	a
expectMatch	10.12 &n	"a\$"	"a\nb"	"a"
expectIndices	10.13 &n	"a\$"	"a\na"	{0 0}
expectIndices	10.14 N		^^	a	{0 -1}
expectMatch	10.15 b		^^	^	^
expectIndices	10.16 N		{$$}	a	{1 0}
expectMatch	10.17 b		{$$}	"\$"	"\$"
expectMatch	10.18 &N	{^$}	""	""
expectNomatch	10.19 &N	{^$}	a
expectIndices	10.20 &nN	"^\$"	a\n\nb	{2 1}
expectMatch	10.21 N		{$^}	""	""
expectMatch	10.22 b		{$^}	"\$^"	"\$^"
expectMatch	10.23 P		{\Aa}	a	a
expectMatch	10.24 ^P	{\Aa}	a	a
expectNomatch	10.25 ^nP	{\Aa}	"b\na"
expectMatch	10.26 P		{a\Z}	a	a
expectMatch	10.27 \$P	{a\Z}	a	a
expectNomatch	10.28 \$nP	{a\Z}	"a\nb"
expectError	10.29 -		^*	BADRPT
expectError	10.30 -		{$*}	BADRPT
expectError	10.31 -		{\A*}	BADRPT
expectError	10.32 -		{\Z*}	BADRPT


doing 11 "boundary constraints"
expectMatch	11.1  &LP	{[[:<:]]a}	a	a
expectMatch	11.2  &LP	{[[:<:]]a}	-a	a
expectNomatch	11.3  &LP	{[[:<:]]a}	ba
expectMatch	11.4  &LP	{a[[:>:]]}	a	a
expectMatch	11.5  &LP	{a[[:>:]]}	a-	a
expectNomatch	11.6  &LP	{a[[:>:]]}	ab
expectMatch	11.7  bLP	{\<a}		a	a
expectNomatch	11.8  bLP	{\<a}		ba
expectMatch	11.9  bLP	{a\>}		a	a
expectNomatch	11.10 bLP	{a\>}		ab
expectMatch	11.11 LP	{\ya}		a	a
expectNomatch	11.12 LP	{\ya}		ba
expectMatch	11.13 LP	{a\y}		a	a
expectNomatch	11.14 LP	{a\y}		ab
expectMatch	11.15 LP	{a\Y}		ab	a
expectNomatch	11.16 LP	{a\Y}		a-
expectNomatch	11.17 LP	{a\Y}		a
expectNomatch	11.18 LP	{-\Y}		-a
expectMatch	11.19 LP	{-\Y}		-%	-
expectNomatch	11.20 LP	{\Y-}		a-
expectError	11.21 -		{[[:<:]]*}	BADRPT
expectError	11.22 -		{[[:>:]]*}	BADRPT
expectError	11.23 b		{\<*}		BADRPT
expectError	11.24 b		{\>*}		BADRPT
expectError	11.25 -		{\y*}		BADRPT
expectError	11.26 -		{\Y*}		BADRPT
expectMatch	11.27 LP	{\ma}		a	a
expectNomatch	11.28 LP	{\ma}		ba
expectMatch	11.29 LP	{a\M}		a	a
expectNomatch	11.30 LP	{a\M}		ab
expectNomatch	11.31 ILP	{\Ma}		a
expectNomatch	11.32 ILP	{a\m}		a


doing 12 "character classes"
expectMatch	12.1  LP	{a\db}		a0b	a0b
expectNomatch	12.2  LP	{a\db}		axb
expectNomatch	12.3  LP	{a\Db}		a0b
expectMatch	12.4  LP	{a\Db}		axb	axb
expectMatch	12.5  LP	"a\\sb"		"a b"	"a b"
expectMatch	12.6  LP	"a\\sb"		"a\tb"	"a\tb"
expectMatch	12.7  LP	"a\\sb"		"a\nb"	"a\nb"
expectNomatch	12.8  LP	{a\sb}		axb
expectMatch	12.9  LP	{a\Sb}		axb	axb
expectNomatch	12.10 LP	"a\\Sb"		"a b"
expectMatch	12.11 LP	{a\wb}		axb	axb
expectNomatch	12.12 LP	{a\wb}		a-b
expectNomatch	12.13 LP	{a\Wb}		axb
expectMatch	12.14 LP	{a\Wb}		a-b	a-b
expectMatch	12.15 LP	{\y\w+z\y}	adze-guz	guz
expectMatch	12.16 LPE	{a[\d]b}	a1b	a1b
expectMatch	12.17 LPE	"a\[\\s]b"	"a b"	"a b"
expectMatch	12.18 LPE	{a[\w]b}	axb	axb


doing 13 "escapes"
expectError	13.1  &		"a\\"		EESCAPE
expectMatch	13.2  -		{a\<b}		a<b	a<b
expectMatch	13.3  e		{a\<b}		a<b	a<b
expectMatch	13.4  bAS	{a\wb}		awb	awb
expectMatch	13.5  eAS	{a\wb}		awb	awb
expectMatch	13.6  PL	"a\\ab"		"a\007b"	"a\007b"
expectMatch	13.7  P		"a\\bb"		"a\bb"	"a\bb"
expectMatch	13.8  P		{a\Bb}		"a\\b"	"a\\b"
expectMatch	13.9  MP	"a\\chb"	"a\bb"	"a\bb"
expectMatch	13.10 MP	"a\\cHb"	"a\bb"	"a\bb"
expectMatch	13.11 LMP	"a\\e"		"a\033"	"a\033"
expectMatch	13.12 P		"a\\fb"		"a\fb"	"a\fb"
expectMatch	13.13 P		"a\\nb"		"a\nb"	"a\nb"
expectMatch	13.14 P		"a\\rb"		"a\rb"	"a\rb"
expectMatch	13.15 P		"a\\tb"		"a\tb"	"a\tb"
expectMatch	13.16 P		"a\\u0008x"	"a\bx"	"a\bx"
expectMatch	13.17 P		{a\u008x}	"a\bx"	"a\bx"
expectMatch	13.18 P		"a\\u00088x"	"a\b8x"	"a\b8x"
expectMatch	13.19 P		"a\\U00000008x"	"a\bx"	"a\bx"
expectMatch	13.20 P		{a\U0000008x}	"a\bx"	"a\bx"
expectMatch	13.21 P		"a\\vb"		"a\vb"	"a\vb"
expectMatch	13.22 MP	"a\\x08x"	"a\bx"	"a\bx"
expectError	13.23 -		{a\xq}		EESCAPE
expectMatch	13.24 MP	"a\\x08x"	"a\bx"	"a\bx"
expectError	13.25 -		{a\z}		EESCAPE
expectMatch	13.26 MP	"a\\010b"	"a\bb"	"a\bb"
expectMatch	13.27 P		"a\\U00001234x"	"a\u1234x"	"a\u1234x"
expectMatch	13.28 P		{a\U00001234x}	"a\u1234x"	"a\u1234x"
expectMatch	13.29 P		"a\\U0001234x"	"a\u1234x"	"a\u1234x"
expectMatch	13.30 P		{a\U0001234x}	"a\u1234x"	"a\u1234x"
expectMatch	13.31 P		"a\\U000012345x"	"a\u12345x"	"a\u12345x"
expectMatch	13.32 P		{a\U000012345x}	"a\u12345x"	"a\u12345x"
expectMatch	13.33 P		"a\\U1000000x"	"a\ufffd0x"	"a\ufffd0x"
expectMatch	13.34 P		{a\U1000000x}	"a\ufffd0x"	"a\ufffd0x"


doing 14 "back references"
# ugh
expectMatch	14.1  RP	{a(b*)c\1}	abbcbb	abbcbb	bb
expectMatch	14.2  RP	{a(b*)c\1}	ac	ac	""
expectNomatch	14.3  RP	{a(b*)c\1}	abbcb
expectMatch	14.4  RP	{a(b*)\1}	abbcbb	abb	b
expectMatch	14.5  RP	{a(b|bb)\1}	abbcbb	abb	b
expectMatch	14.6  RP	{a([bc])\1}	abb	abb	b
expectNomatch	14.7  RP	{a([bc])\1}	abc
expectMatch	14.8  RP	{a([bc])\1}	abcabb	abb	b
expectNomatch	14.9  RP	{a([bc])*\1}	abc
expectNomatch	14.10 RP	{a([bc])\1}	abB
expectMatch	14.11 iRP	{a([bc])\1}	abB	abB	b
expectMatch	14.12 RP	{a([bc])\1+}	abbb	abbb	b
expectMatch	14.13 QRP	"a(\[bc])\\1{3,4}"	abbbb	abbbb	b
expectNomatch	14.14 QRP	"a(\[bc])\\1{3,4}"	abbb
expectMatch	14.15 RP	{a([bc])\1*}	abbb	abbb	b
expectMatch	14.16 RP	{a([bc])\1*}	ab	ab	b
expectMatch	14.17 RP	{a([bc])(\1*)}	ab	ab	b	""
expectError	14.18 -		{a((b)\1)}	ESUBREG
expectError	14.19 -		{a(b)c\2}	ESUBREG
expectMatch	14.20 bR	{a\(b*\)c\1}	abbcbb	abbcbb	bb
expectMatch	14.21 RP	{^([bc])\1*$}	bbb	bbb	b
expectMatch	14.22 RP	{^([bc])\1*$}	ccc	ccc	c
expectNomatch	14.23 RP	{^([bc])\1*$}	bcb
expectMatch	14.24 LRP	{^(\w+)( \1)+$}	{abc abc abc} {abc abc abc} abc { abc}
expectNomatch	14.25 LRP	{^(\w+)( \1)+$}	{abc abd abc}
expectNomatch	14.26 LRP	{^(\w+)( \1)+$}	{abc abc abd}
expectMatch	14.27 RP	{^(.+)( \1)+$}	{abc abc abc} {abc abc abc} abc { abc}
expectNomatch	14.28 RP	{^(.+)( \1)+$}	{abc abd abc}
expectNomatch	14.29 RP	{^(.+)( \1)+$}	{abc abc abd}


doing 15 "octal escapes vs back references"
# initial zero is always octal
expectMatch	15.1  MP	"a\\010b"	"a\bb"	"a\bb"
expectMatch	15.2  MP	"a\\0070b"	"a\0070b"	"a\0070b"
expectMatch	15.3  MP	"a\\07b"	"a\007b"	"a\007b"
expectMatch	15.4  MP	"a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\\07c" \
	"abbbbbbbbbb\007c" abbbbbbbbbb\007c b b b b b b b b b b
# a single digit is always a backref
expectError	15.5  -		{a\7b}	ESUBREG
# otherwise it's a backref only if within range (barf!)
expectMatch	15.6  MP	"a\\10b"	"a\bb"	"a\bb"
expectMatch	15.7  MP	{a\101b}	aAb	aAb
expectMatch	15.8  RP	{a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\10c} \
	"abbbbbbbbbbbc" abbbbbbbbbbbc b b b b b b b b b b
# but we're fussy about border cases -- guys who want octal should use the zero
expectError	15.9  -	{a((((((((((b\10))))))))))c}	ESUBREG
# BREs don't have octal, EREs don't have backrefs
expectMatch	15.10 MP	"a\\12b"	"a\nb"	"a\nb"
expectError	15.11 b		{a\12b}		ESUBREG
expectMatch	15.12 eAS	{a\12b}		a12b	a12b
expectMatch	15.13 MP	{a\701b}	a\u00381b	a\u00381b


doing 16 "expanded syntax"
expectMatch	16.1 xP		"a b c"		"abc"	"abc"
expectMatch	16.2 xP		"a b #oops\nc\td"	"abcd"	"abcd"
expectMatch	16.3 x		"a\\ b\\\tc"	"a b\tc"	"a b\tc"
expectMatch	16.4 xP		"a b\\#c"	"ab#c"	"ab#c"
expectMatch	16.5 xP		"a b\[c d]e"	"ab e"	"ab e"
expectMatch	16.6 xP		"a b\[c#d]e"	"ab#e"	"ab#e"
expectMatch	16.7 xP		"a b\[c#d]e"	"abde"	"abde"
expectMatch	16.8 xSPB	"ab{ d"		"ab\{d"	"ab\{d"
expectMatch	16.9 xPQ	"ab{ 1 , 2 }c"	"abc"	"abc"


doing 17 "misc syntax"
expectMatch	17.1 P	a(?#comment)b	ab	ab


doing 18 "unmatchable REs"
expectNomatch	18.1 I	a^b		ab


doing 19 "case independence"
expectMatch	19.1 &i		ab		Ab	Ab
expectMatch	19.2 &i		{a[bc]}		aC	aC
expectNomatch	19.3 &i		{a[^bc]}	aB
expectMatch	19.4 &iM	{a[b-d]}	aC	aC
expectNomatch	19.5 &iM	{a[^b-d]}	aC


doing 20 "directors and embedded options"
expectError	20.1  &		***?		BADPAT
expectMatch	20.2  q		***?		***?	***?
expectMatch	20.3  &P	***=a*b		a*b	a*b
expectMatch	20.4  q		***=a*b		***=a*b	***=a*b
expectMatch	20.5  bLP	{***:\w+}	ab	ab
expectMatch	20.6  eLP	{***:\w+}	ab	ab
expectError	20.7  &		***:***=a*b	BADRPT
expectMatch	20.8  &P	***:(?b)a+b	a+b	a+b
expectMatch	20.9  P		(?b)a+b		a+b	a+b
expectError	20.10 e		{(?b)\w+}	BADRPT
expectMatch	20.11 bAS	{(?b)\w+}	(?b)w+	(?b)w+
expectMatch	20.12 iP	(?c)a		a	a
expectNomatch	20.13 iP	(?c)a		A
expectMatch	20.14 APS	{(?e)\W+}	WW	WW
expectMatch	20.15 P		(?i)a+		Aa	Aa
expectNomatch	20.16 P		"(?m)a.b"	"a\nb"
expectMatch	20.17 P		"(?m)^b"	"a\nb"	"b"
expectNomatch	20.18 P		"(?n)a.b"	"a\nb"
expectMatch	20.19 P		"(?n)^b"	"a\nb"	"b"
expectNomatch	20.20 P		"(?p)a.b"	"a\nb"
expectNomatch	20.21 P		"(?p)^b"	"a\nb"
expectMatch	20.22 P		(?q)a+b		a+b	a+b
expectMatch	20.23 nP	"(?s)a.b"	"a\nb"	"a\nb"
expectMatch	20.24 xP	"(?t)a b"	"a b"	"a b"
expectMatch	20.25 P		"(?w)a.b"	"a\nb"	"a\nb"
expectMatch	20.26 P		"(?w)^b"	"a\nb"	"b"
expectMatch	20.27 P		"(?x)a b"	"ab"	"ab"
expectError	20.28 -		(?z)ab		BADOPT
expectMatch	20.29 P		(?ici)a+	Aa	Aa
expectError	20.30 P		(?i)(?q)a+	BADRPT
expectMatch	20.31 P		(?q)(?i)a+	(?i)a+	(?i)a+
expectMatch	20.32 P		(?qe)a+		a	a
expectMatch	20.33 xP	"(?q)a b"	"a b"	"a b"
expectMatch	20.34 P		"(?qx)a b"	"a b"	"a b"
expectMatch	20.35 P		(?qi)ab		Ab	Ab


doing 21 "capturing"
expectMatch	21.1  -		a(b)c		abc	abc	b
expectMatch	21.2  P		a(?:b)c		xabc	abc
expectMatch	21.3  -		a((b))c		xabcy	abc	b	b
expectMatch	21.4  P		a(?:(b))c	abcy	abc	b
expectMatch	21.5  P		a((?:b))c	abc	abc	b
expectMatch	21.6  P		a(?:(?:b))c	abc	abc
expectIndices	21.7  Q		"a(b){0}c"	ac	{0 1}	{-1 -1}
expectMatch	21.8  -		a(b)c(d)e	abcde	abcde	b	d
expectMatch	21.9  -		(b)c(d)e	bcde	bcde	b	d
expectMatch	21.10 -		a(b)(d)e	abde	abde	b	d
expectMatch	21.11 -		a(b)c(d)	abcd	abcd	b	d
expectMatch	21.12 -		(ab)(cd)	xabcdy	abcd	ab	cd
expectMatch	21.13 -		a(b)?c		xabcy	abc	b
expectIndices	21.14 -		a(b)?c		xacy	{1 2}	{-1 -1}
expectMatch	21.15 -		a(b)?c(d)?e	xabcdey	abcde	b	d
expectIndices	21.16 -		a(b)?c(d)?e	xacdey	{1 4}	{-1 -1}	{3 3}
expectIndices	21.17 -		a(b)?c(d)?e	xabcey	{1 4}	{2 2}	{-1 -1}
expectIndices	21.18 -		a(b)?c(d)?e	xacey	{1 3}	{-1 -1}	{-1 -1}
expectMatch	21.19 -		a(b)*c		xabcy	abc	b
expectIndices	21.20 -		a(b)*c		xabbbcy	{1 5}	{4 4}
expectIndices	21.21 -		a(b)*c		xacy	{1 2}	{-1 -1}
expectMatch	21.22 -		a(b*)c		xabbbcy	abbbc	bbb
expectMatch	21.23 -		a(b*)c		xacy	ac	""
expectNomatch	21.24 -		a(b)+c		xacy
expectMatch	21.25 -		a(b)+c		xabcy	abc	b
expectIndices	21.26 -		a(b)+c		xabbbcy	{1 5}	{4 4}
expectMatch	21.27 -		a(b+)c		xabbbcy	abbbc	bbb
expectIndices	21.28 Q		"a(b){2,3}c"	xabbbcy	{1 5}	{4 4}
expectIndices	21.29 Q		"a(b){2,3}c"	xabbcy	{1 4}	{3 3}
expectNomatch	21.30 Q		"a(b){2,3}c"	xabcy
expectMatch	21.31 LP	"\\y(\\w+)\\y"	"-- abc-"	"abc"	"abc"
expectMatch	21.32 -		a((b|c)d+)+	abacdbd	acdbd	bd	b
expectMatch	21.33 N		(.*).*		abc	abc	abc
expectMatch	21.34 N		(a*)*		bc	""	""
expectMatch	21.35 M		{ TO (([a-z0-9._]+|"([^"]+|"")+")+)}	{asd TO foo}	{ TO foo} foo o {}


doing 22 "multicharacter collating elements"
# again ugh
expectMatch	22.1  &+L	{a[c]e}		ace	ace
expectNomatch	22.2  &+IL	{a[c]h}		ach
expectMatch	22.3  &+L	{a[[.ch.]]}	ach	ach
expectNomatch	22.4  &+L	{a[[.ch.]]}	ace
expectMatch	22.5  &+L	{a[c[.ch.]]}	ac	ac
expectMatch	22.6  &+L	{a[c[.ch.]]}	ace	ac
expectMatch	22.7  &+L	{a[c[.ch.]]}	ache	ach
expectNomatch	22.8  &+L	{a[^c]e}	ace
expectMatch	22.9  &+L	{a[^c]e}	abe	abe
expectMatch	22.10 &+L	{a[^c]e}	ache	ache
expectNomatch	22.11 &+L	{a[^[.ch.]]}	ach
expectMatch	22.12 &+L	{a[^[.ch.]]}	ace	ac
expectMatch	22.13 &+L	{a[^[.ch.]]}	ac	ac
expectMatch	22.14 &+L	{a[^[.ch.]]}	abe	ab
expectNomatch	22.15 &+L	{a[^c[.ch.]]}	ach
expectNomatch	22.16 &+L	{a[^c[.ch.]]}	ace
expectNomatch	22.17 &+L	{a[^c[.ch.]]}	ac
expectMatch	22.18 &+L	{a[^c[.ch.]]}	abe	ab
expectMatch	22.19 &+L	{a[^b]}		ac	ac
expectMatch	22.20 &+L	{a[^b]}		ace	ac
expectMatch	22.21 &+L	{a[^b]}		ach	ach
expectNomatch	22.22 &+L	{a[^b]}		abe


doing 23 "lookahead constraints"
expectMatch	23.1 HP		a(?=b)b*	ab	ab
expectNomatch	23.2 HP		a(?=b)b*	a
expectMatch	23.3 HP		a(?=b)b*(?=c)c*	abc	abc
expectNomatch	23.4 HP		a(?=b)b*(?=c)c*	ab
expectNomatch	23.5 HP		a(?!b)b*	ab
expectMatch	23.6 HP		a(?!b)b*	a	a
expectMatch	23.7 HP		(?=b)b		b	b
expectNomatch	23.8 HP		(?=b)b		a


doing 24 "non-greedy quantifiers"
expectMatch	24.1  PT	ab+?		abb	ab
expectMatch	24.2  PT	ab+?c		abbc	abbc
expectMatch	24.3  PT	ab*?		abb	a
expectMatch	24.4  PT	ab*?c		abbc	abbc
expectMatch	24.5  PT	ab??		ab	a
expectMatch	24.6  PT	ab??c		abc	abc
expectMatch	24.7  PQT	"ab{2,4}?"	abbbb	abb
expectMatch	24.8  PQT	"ab{2,4}?c"	abbbbc	abbbbc
expectMatch	24.9  -		3z*		123zzzz456	3zzzz
expectMatch	24.10 PT	3z*?		123zzzz456	3
expectMatch	24.11 -		z*4		123zzzz456	zzzz4
expectMatch	24.12 PT	z*?4		123zzzz456	zzzz4
expectMatch	24.13 PT	{^([^/]+?)(?:/([^/]+?))(?:/([^/]+?))?$}	{foo/bar/baz}	{foo/bar/baz} {foo} {bar} {baz}


doing 25 "mixed quantifiers"
# this is very incomplete as yet
# should include |
expectMatch	25.1 PNT	{^(.*?)(a*)$}	"xyza"	xyza	xyz	a
expectMatch	25.2 PNT	{^(.*?)(a*)$}	"xyzaa"	xyzaa	xyz	aa
expectMatch	25.3 PNT	{^(.*?)(a*)$}	"xyz"	xyz	xyz	""


doing 26 "tricky cases"
# attempts to trick the matcher into accepting a short match
expectMatch	26.1 -		(week|wee)(night|knights) \
	"weeknights" weeknights wee knights
expectMatch	26.2 RP		{a(bc*).*\1}	abccbccb abccbccb	b
expectMatch	26.3 -		{a(b.[bc]*)+}	abcbd	abcbd	bd


doing 27 "implementation misc."
# duplicate arcs are suppressed
expectMatch	27.1 P		a(?:b|b)c	abc	abc
# make color/subcolor relationship go back and forth
expectMatch	27.2 &		{[ab][ab][ab]}	aba	aba
expectMatch	27.3 &		{[ab][ab][ab][ab][ab][ab][ab]} \
	"abababa" abababa


doing 28 "boundary busters etc."
# color-descriptor allocation changes at 10
expectMatch	28.1 &		abcdefghijkl	"abcdefghijkl"	abcdefghijkl
# so does arc allocation
expectMatch	28.2 P		a(?:b|c|d|e|f|g|h|i|j|k|l|m)n	"agn"	agn
# subexpression tracking also at 10
expectMatch	28.3 -		a(((((((((((((b)))))))))))))c \
	"abc" abc b b b b b b b b b b b b b
# state-set handling changes slightly at unsigned size (might be 64...)
# (also stresses arc allocation)
expectMatch	28.4  Q		"ab{1,100}c"	abbc	abbc
expectMatch	28.5  Q		"ab{1,100}c" \
	"abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc" \
	abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
expectMatch	28.6  Q		"ab{1,100}c" \
	"abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc"\
	abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
# force small cache and bust it, several ways
expectMatch	28.7  LP	{\w+abcdefgh}	xyzabcdefgh	xyzabcdefgh
expectMatch	28.8  %LP	{\w+abcdefgh}	xyzabcdefgh	xyzabcdefgh
expectMatch	28.9  %LP	{\w+abcdefghijklmnopqrst} \
	"xyzabcdefghijklmnopqrst" xyzabcdefghijklmnopqrst
expectIndices	28.10 %LP	{\w+(abcdefgh)?} xyz	{0 2}	{-1 -1}
expectIndices	28.11 %LP	{\w+(abcdefgh)?} xyzabcdefg	{0 9}	{-1 -1}
expectIndices	28.12 %LP	{\w+(abcdefghijklmnopqrst)?} \
	"xyzabcdefghijklmnopqrs" {0 21} {-1 -1}


doing 29 "incomplete matches"
expectPartial		29.1  t		def	abc	{3 2}	""
expectPartial		29.2  t		bcd	abc	{1 2}	""
expectPartial		29.3  t		abc	abab	{0 3}	""
expectPartial		29.4  t		abc	abdab	{3 4}	""
expectIndices		29.5  t		abc	abc	{0 2}	{0 2}
expectIndices		29.6  t		abc	xyabc	{2 4}	{2 4}
expectPartial		29.7  t		abc+	xyab	{2 3}	""
expectIndices		29.8  t		abc+	xyabc	{2 4}	{2 4}
knownBug expectIndices	29.9  t		abc+	xyabcd	{2 4}	{6 5}
expectIndices		29.10 t		abc+	xyabcdd	{2 4}	{7 6}
expectPartial		29.11 tPT	abc+?	xyab	{2 3}	""
# the retain numbers in these two may look wrong, but they aren't
expectIndices		29.12 tPT	abc+?	xyabc	{2 4}	{5 4}
expectIndices		29.13 tPT	abc+?	xyabcc	{2 4}	{6 5}
expectIndices		29.14 tPT	abc+?	xyabcd	{2 4}	{6 5}
expectIndices		29.15 tPT	abc+?	xyabcdd	{2 4}	{7 6}
expectIndices		29.16 t		abcd|bc	xyabc	{3 4}	{2 4}
expectPartial		29.17 tn	.*k	"xx\nyyy"	{3 5}	""


doing 30 "misc. oddities and old bugs"
expectError	30.1 &		***	BADRPT
expectMatch	30.2 N		a?b*	abb	abb
expectMatch	30.3 N		a?b*	bb	bb
expectMatch	30.4 &		a*b	aab	aab
expectMatch	30.5 &		^a*b	aaaab	aaaab
expectMatch	30.6 &M		{[0-6][1-2][0-3][0-6][1-6][0-6]} \
	"010010" 010010
# temporary REG_BOSONLY kludge
expectMatch	30.7 s		abc	abcd	abc
expectNomatch	30.8 s		abc	xabcd
# back to normal stuff
expectMatch	30.9 HLP	{(?n)^(?![t#])\S+} \
	"tk\n\n#\n#\nit0"	it0


# Now for tests *not* written by Henry Spencer

namespace import -force ::tcltest::test

# Tests resulting from bugs reported by users
test reg-31.1 {[[:xdigit:]] behaves correctly when followed by [[:space:]]} {
    set str {2:::DebugWin32}
    set re {([[:xdigit:]])([[:space:]]*)}
    list [regexp $re $str match xdigit spaces] $match $xdigit $spaces
    # Code used to produce {1 2:::DebugWin32 2 :::DebugWin32} !!!
} {1 2 2 {}}

test reg-32.1 {canmatch functionality -- at end} testregexp {
    set pat {blah}
    set line "asd asd"
    # can match at the final d, if '%' follows
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 7}
test reg-32.2 {canmatch functionality -- at end} testregexp {
    set pat {s%$}
    set line "asd asd"
    # can only match after the end of the string
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 7}
test reg-32.3 {canmatch functionality -- not last char} testregexp {
    set pat {[^d]%$}
    set line "asd asd"
    # can only match after the end of the string
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 7}
test reg-32.3.1 {canmatch functionality -- no match} testregexp {
    set pat {\Zx}
    set line "asd asd"
    # can match the last char, if followed by x
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 -1}
test reg-32.4 {canmatch functionality -- last char} {knownBug testregexp} {
    set pat {.x}
    set line "asd asd"
    # can match the last char, if followed by x
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 6}
test reg-32.4.1 {canmatch functionality -- last char} {knownBug testregexp} {
    set pat {.x$}
    set line "asd asd"
    # can match the last char, if followed by x
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 6}
test reg-32.5 {canmatch functionality -- last char} {knownBug testregexp} {
    set pat {.[^d]x$}
    set line "asd asd"
    # can match the last char, if followed by not-d and x.
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 6}
test reg-32.6 {canmatch functionality -- last char} {knownBug testregexp} {
    set pat {[^a]%[^\r\n]*$}
    set line "asd asd"
    # can match at the final d, if '%' follows
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 6}
test reg-32.7 {canmatch functionality -- last char} {knownBug testregexp} {
    set pat {[^a]%$}
    set line "asd asd"
    # can match at the final d, if '%' follows
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 6}
test reg-32.8 {canmatch functionality -- last char} {knownBug testregexp} {
    set pat {[^x]%$}
    set line "asd asd"
    # can match at the final d, if '%' follows
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 6}
test reg-32.9 {canmatch functionality -- more complex case} {knownBug testregexp} {
    set pat {((\B\B|\Bh+line)[ \t]*|[^\B]%[^\r\n]*)$}
    set line "asd asd"
    # can match at the final d, if '%' follows
    set res [testregexp -xflags -- c $pat $line resvar]
    lappend res $resvar
} {0 6}

# Tests reg-33.*: Checks for bug fixes

test reg-33.1 {Bug 230589} {
    regexp {[ ]*(^|[^%])%V} "*%V2" m s
} 1
test reg-33.2 {Bug 504785} {
    regexp -inline {([^_.]*)([^.]*)\.(..)(.).*} bbcos_001_c01.q1la
} {bbcos_001_c01.q1la bbcos _001_c01 q1 l}
test reg-33.3 {Bug 505048} {
    regexp {\A\s*[^<]*\s*<([^>]+)>} a<a>
} 1
test reg-33.4 {Bug 505048} {
    regexp {\A\s*([^b]*)b} ab
} 1
test reg-33.5 {Bug 505048} {
    regexp {\A\s*[^b]*(b)} ab
} 1
test reg-33.6 {Bug 505048} {
    regexp {\A(\s*)[^b]*(b)} ab
} 1
test reg-33.7 {Bug 505048} {
    regexp {\A\s*[^b]*b} ab
} 1
test reg-33.8 {Bug 505048} {
    regexp -inline {\A\s*[^b]*b} ab
} ab
test reg-33.9 {Bug 505048} {
    regexp -indices -inline {\A\s*[^b]*b} ab
} {{0 1}}
test reg-33.10 {Bug 840258} -body {
    regsub {(^|\n)+\.*b} \n.b {} tmp
} -cleanup {
    unset tmp
} -result 1
test reg-33.11 {Bug 840258} -body {
    regsub {(^|[\n\r]+)\.*\?<.*?(\n|\r)+} \
	    "TQ\r\n.?<5000267>Test already stopped\r\n" {} tmp
} -cleanup {
    unset tmp
} -result 1
test reg-33.12 {Bug 1810264 - bad read} {
    regexp {\3161573148} {\3161573148}
} 0
test reg-33.13 {Bug 1810264 - infinite loop} {
    regexp {($|^)*} {x}
} 1
# Some environments have small default stack sizes. [Bug 1905562]
test reg-33.14 {Bug 1810264 - super-expensive expression} nonPortable {
    regexp {(x{200}){200}$y} {x}
} 0

test reg-33.15.1 {Bug 3603557 - an "in the wild" RE} {
    lindex [regexp -expanded -about {
	^TETRA_MODE_CMD				# Message Type
	([[:blank:]]+)				# Pad
	(ETS_1_1|ETS_1_2|ETS_2_2)		# SystemCode
	([[:blank:]]+)				# Pad
	(CONTINUOUS|CARRIER|MCCH|TRAFFIC)	# SharingMode
	([[:blank:]]+)				# Pad
	([[:digit:]]{1,2})			# ColourCode
	([[:blank:]]+)				# Pad
	(1|2|3|4|6|9|12|18)			# TSReservedFrames
	([[:blank:]]+)				# Pad
	(PASS|TRUE|FAIL|FALSE)			# UPlaneDTX
	([[:blank:]]+)				# Pad
	(PASS|TRUE|FAIL|FALSE)			# Frame18Extension
	([[:blank:]]+)				# Pad
	([[:digit:]]{1,4})			# MCC
	([[:blank:]]+)				# Pad
	([[:digit:]]{1,5})			# MNC
	([[:blank:]]+)				# Pad
	(BOTH|BCAST|ENQRY|NONE)			# NbrCellBcast
	([[:blank:]]+)				# Pad
	(UNKNOWN|LOW|MEDIUM|HIGH)		# CellServiceLevel
	([[:blank:]]+)				# Pad
	(PASS|TRUE|FAIL|FALSE)			# LateEntryInfo
	([[:blank:]]+)				# Pad
	(300|400)				# FrequencyBand
	([[:blank:]]+)				# Pad
	(NORMAL|REVERSE)			# ReverseOperation
	([[:blank:]]+)				# Pad
	(NONE|\+6\.25|\-6\.25|\+12\.5)		# Offset
	([[:blank:]]+)				# Pad
	(10)					# DuplexSpacing
	([[:blank:]]+)				# Pad
	([[:digit:]]{1,4})			# MainCarrierNr
	([[:blank:]]+)				# Pad
	(0|1|2|3)				# NrCSCCH
	([[:blank:]]+)				# Pad
	(15|20|25|30|35|40|45)			# MSTxPwrMax
	([[:blank:]]+)				# Pad
	(\-125|\-120|\-115|\-110|\-105|\-100|\-95|\-90|\-85|\-80|\-75|\-70|\-65|\-60|\-55|\-50)
						# RxLevAccessMin
	([[:blank:]]+)				# Pad
	(\-53|\-51|\-49|\-47|\-45|\-43|\-41|\-39|\-37|\-35|\-33|\-31|\-29|\-27|\-25|\-23)
						# AccessParameter
	([[:blank:]]+)				# Pad
	(DISABLE|[[:digit:]]{3,4})		# RadioDLTimeout
	([[:blank:]]+)				# Pad
	(\-[[:digit:]]{2,3})			# RSSIThreshold
	([[:blank:]]+)				# Pad
	([[:digit:]]{1,5})			# CCKIdSCKVerNr
	([[:blank:]]+)				# Pad
	([[:digit:]]{1,5})			# LocationArea
	([[:blank:]]+)				# Pad
	([(1|0)]{16})				# SubscriberClass
	([[:blank:]]+)				# Pad
	([(1|0)]{12})				# BSServiceDetails
	([[:blank:]]+)				# Pad
	(RANDOMIZE|IMMEDIATE|[[:digit:]]{1,2})	# IMM
	([[:blank:]]+)				# Pad
	([[:digit:]]{1,2})			# WT
	([[:blank:]]+)				# Pad
	([[:digit:]]{1,2})			# Nu
	([[:blank:]]+)				# Pad
	([0-1])					# FrameLngFctr
	([[:blank:]]+)				# Pad
	([[:digit:]]{1,2})			# TSPtr
	([[:blank:]]+)				# Pad
	([0-7])					# MinPriority
	([[:blank:]]+)				# Pad
	(PASS|TRUE|FAIL|FALSE)			# ExtdSrvcsEnabled
	([[:blank:]]+)				# Pad
	(.*)					# ConditionalFields
    }] 0
} 68
test reg-33.16.1 {Bug [8d2c0da36d]- another "in the wild" RE} {
    lindex [regexp -about "^MRK:client1: =1339 14HKelly Talisman 10011000 (\[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]*) \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 8 0 8 0 0 0 77 77 1 1 2 0 11 { 1 3 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 13HC6 My Creator 2 3 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 31HC7 Slightly offensive name, huh 3 8 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 23HE-mail:kelly@hotbox.com 4 9 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 17Hcompface must die 5 10 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 0 3HAir 6 12 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 14HPGP public key 7 13 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 16Hkelly@hotbox.com 8 30 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 0 12H2 text/plain 9 30 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 0 13H2 x-kom/basic 10 33 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 1H0 11 14 8 \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* \[0-9\]* 00000000 1 1H3 }\r?"] 0
} 1

test reg-33.15 {constraint fixes} {
    regexp {(^)+^} x
} 1
test reg-33.16 {constraint fixes} {
    regexp {($^)+} x
} 0
test reg-33.17 {constraint fixes} {
    regexp {(^$)*} x
} 1
test reg-33.18 {constraint fixes} {
    regexp {(^(?!aa))+} {aa bb cc}
} 0
test reg-33.19 {constraint fixes} {
    regexp {(^(?!aa)(?!bb)(?!cc))+} {aa x}
} 0
test reg-33.20 {constraint fixes} {
    regexp {(^(?!aa)(?!bb)(?!cc))+} {bb x}
} 0
test reg-33.21 {constraint fixes} {
    regexp {(^(?!aa)(?!bb)(?!cc))+} {cc x}
} 0
test reg-33.22 {constraint fixes} {
    regexp {(^(?!aa)(?!bb)(?!cc))+} {dd x}
} 1

test reg-33.23 {} {
    regexp {abcd(\m)+xyz} x
} 0
test reg-33.24 {} {
    regexp {abcd(\m)+xyz} a
} 0
test reg-33.25 {} {
    regexp {^abcd*(((((^(a c(e?d)a+|)+|)+|)+|)+|a)+|)} x
} 0
test reg-33.26 {} {
    regexp {a^(^)bcd*xy(((((($a+|)+|)+|)+$|)+|)+|)^$} x
} 0
test reg-33.27 {} {
    regexp {xyz(\Y\Y)+} x
} 0
test reg-33.28 {} {
    regexp {x|(?:\M)+} x
} 1
test reg-33.29 {} {
    # This is near the limits of the RE engine
    regexp [string repeat x*y*z* 480] x
} 1

test reg-33.30 {Bug 1080042} {
    regexp {(\Y)+} foo
} 1

# cleanup
::tcltest::cleanupTests
return

# Local Variables:
# mode: tcl
# End: