merged tcl 8.1 branch back into the main trunk

1 files changed, 905 insertions, 0 deletions

diff --git a/tests/reg.test b/tests/reg.test
new file mode 100644
index 0000000..de20e33
--- /dev/null
+++ b/tests/reg.test
@@ -0,0 +1,905 @@
+# 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.
+#
+# Copyright (c) 1998-1999 by Scriptics Corporation.
+# All rights reserved.
+#
+# RCS: @(#) $Id: reg.test,v 1.2 1999/04/16 00:47:33 stanton Exp $
+
+if {[lsearch [namespace children] ::tcltest] == -1} {
+    source [file join [pwd] [file dirname [info script]] defs.tcl]
+}
+
+# All tests require the testregexp command, return if this
+# command doesn't exist
+
+set ::tcltest::testConfig(testregexp) \
+	[expr {[info commands testregexp] != {}}]
+
+# This file uses some custom procedures, defined below, for regexp regression
+# testing.  The name of the procedure indicates the general nature of the
+# test:  e for compile error expected, f for match failure expected, m
+# for a successful match, and i for a successful match with -indices (used
+# in checking things like nonparticipating subexpressions).  There is also
+# a "doing" procedure which sets up title and major test number for each
+# block of tests, and an "xx" procedure which ignores its arguments and
+# arranges for the next invocation of "doing" to announce that some tests
+# were bypassed (which is better than just commenting them out).
+
+# 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 e, 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 f, these arguments are optional, and if present are ignored except
+# that they indicate how many subexpressions should be presents 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 i.
+
+# 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
+#	%	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 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
+#
+#	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
+#	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
+
+set ask "about"
+set xflags "xflags"
+set testbypassed 0
+
+# re_info abbreviation mapping table
+set infonames(A) "REG_UBSALNUM"
+set infonames(B) "REG_UBRACES"
+set infonames(E) "REG_UBBS"
+set infonames(H) "REG_ULOOKAHEAD"
+set infonames(I) "REG_UIMPOSSIBLE"
+set infonames(L) "REG_ULOCALE"
+set infonames(M) "REG_UUNPORT"
+set infonames(N) "REG_UEMPTYMATCH"
+set infonames(P) "REG_UNONPOSIX"
+set infonames(Q) "REG_UBOUNDS"
+set infonames(R) "REG_UBACKREF"
+set infonames(S) "REG_UUNSPEC"
+set infonames(U) "REG_UPBOTCH"
+set infonameorder "RHQBAUEPSMLNI"	;# must match bit order, lsb first
+
+# set major test number and description
+proc doing {major desc} {
+	global prefix description testbypassed
+
+	if {$testbypassed != 0} {
+		puts stdout "!!! bypassed $testbypassed tests in\
+					 $major, `$description'"
+	}
+
+	set prefix reg-$major
+	set description "reg $desc"
+	set testbypassed 0
+}
+
+# build test number (internal)
+proc tno {testid} {
+	return [lindex $testid 0]
+}
+
+# build description, with possible modifiers (internal)
+proc desc {testid} {
+	global description
+
+	set d $description
+	if {[llength $testid] > 1} {
+		set d "([lreplace $testid 0 0]) $d"
+	}
+	return $d
+}
+
+# build trailing options and flags argument from a flags string (internal)
+proc flags {fl} {
+	global xflags
+
+	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 {[string compare $flags ""] != 0} {
+		lappend args -$xflags $flags
+	}
+	return $args
+}
+
+# build info-flags list from a flags string (internal)
+proc infoflags {fl} {
+	global infonames infonameorder
+
+	set ret [list]
+	foreach f [split $infonameorder ""] {
+		if {[string first $f $fl] >= 0} {
+			lappend ret $infonames($f)
+		}
+	}
+	return $ret
+}
+
+# compilation error expected
+proc e {testid flags re err} {
+	global prefix ask errorCode
+
+	# if &, test as both ARE and BRE
+	set amp [string first "&" $flags]
+	if {$amp >= 0} {
+		set f [string range $flags 0 [expr $amp - 1]]
+		append f [string range $flags [expr $amp + 1] end]
+		e [linsert $testid end ARE] ${f} $re $err
+		e [linsert $testid end BRE] ${f}b $re $err
+		return
+	}
+
+	set cmd [concat [list testregexp -$ask] [flags $flags] [list $re]]
+	set run "list \[catch \{$cmd\}\] \[lindex \$errorCode 1\]"
+	test $prefix.[tno $testid] [desc $testid] {testregexp} $run [list 1 REG_$err]
+}
+
+# match failure expected
+proc f {testid flags re target args} {
+	global prefix description ask
+
+	# if &, test as both ARE and BRE
+	set amp [string first "&" $flags]
+	if {$amp >= 0} {
+		set f [string range $flags 0 [expr $amp - 1]]
+		append f [string range $flags [expr $amp + 1] end]
+		eval [linsert $args 0 f [linsert $testid end ARE] ${f} $re \
+								$target]
+		eval [linsert $args 0 f [linsert $testid end BRE] ${f}b $re \
+								$target]
+		return
+	}
+
+	set f [flags $flags]
+	set infoflags [infoflags $flags]
+	set ccmd [concat [list testregexp -$ask] $f [list $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]
+	}
+	lappend testid "compile"
+	test $prefix.[tno $testid] [desc $testid] {testregexp} $ccmd $info
+
+	set testid [lreplace $testid end end "execute"]
+	set ecmd [concat [list testregexp] $f [list $re $target]]
+	test $prefix.[tno $testid] [desc $testid] {testregexp} $ecmd 0
+}
+
+# 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
+proc matchexpected {opts testid flags re target args} {
+	global prefix description ask
+
+	# if &, test as both BRE and ARE
+	set amp [string first "&" $flags]
+	if {$amp >= 0} {
+		set f [string range $flags 0 [expr $amp - 1]]
+		append f [string range $flags [expr $amp + 1] end]
+		eval [concat [list matchexpected $opts \
+			[linsert $testid end ARE] ${f} $re $target] $args]
+		eval [concat [list matchexpected $opts \
+			[linsert $testid end BRE] ${f}b $re $target] $args]
+		return
+	}
+
+	set f [flags $flags]
+	set infoflags [infoflags $flags]
+	set ccmd [concat [list testregexp -$ask] $f [list $re]]
+	set ecmd [concat [list testregexp] $opts $f [list $re $target]]
+
+	set nsub [expr [llength $args] - 1]
+	set names [list]
+	set refs ""
+	for {set i 0} {$i <= $nsub} {incr i} {
+		if {$i == 0} {
+			set name match
+		} else {
+			set name sub$i
+		}
+		lappend names $name
+		append refs " \$$name"
+		set $name ""
+	}
+	if {[string first "o" $flags] >= 0} {	;# REG_NOSUB
+		set nsub 0		;# unsigned value cannot be -1
+	}
+	set ecmd [concat $ecmd $names]
+	set erun "list \[$ecmd\] $refs"
+	set result [concat [list 1] $args]
+
+	set info [list $nsub $infoflags]
+	lappend testid "compile"
+	test $prefix.[tno $testid] [desc $testid] {testregexp} $ccmd $info
+	set testid [lreplace $testid end end "execute"]
+	test $prefix.[tno $testid] [desc $testid] {testregexp} $erun $result
+}
+
+# match expected (no missing, empty, or ambiguous submatches)
+# m testno flags re target mat submat ...
+proc m {args} {
+	eval matchexpected [linsert $args 0 [list]]
+}
+
+# match expected (full fanciness)
+# i testno flags re target mat submat ...
+proc i {args} {
+	eval matchexpected [linsert $args 0 [list "-indices"]]
+}
+
+# test temporarily unimplemented
+proc xx {args} {
+	global testbypassed
+
+	incr testbypassed
+}
+
+
+
+# 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.
+test regexp-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"
+m  1	&	abc		abc	abc
+f  2	&	abc		def
+m  3	&	abc		xyabxabce	abc
+
+
+
+doing 2 "invalid option combinations"
+e  1	qe	a		INVARG
+e  2	qa	a		INVARG
+e  3	qx	a		INVARG
+e  4	qn	a		INVARG
+e  5	ba	a		INVARG
+
+
+
+doing 3 "basic syntax"
+i  1	&NS	""		a	{0 -1}
+m  2	NS	a|		a	a
+m  3	-	a|b		a	a
+m  4	-	a|b		b	b
+m  5	NS	a||b		b	b
+m  6	&	ab		ab	ab
+
+
+
+doing 4 "parentheses"
+m  1	-	(a)e		ae	ae	a
+m  2	o	(a)e		ae
+m  3	b	{\(a\)b}	ab	ab	a
+m  4	-	a((b)c)		abc	abc	bc	b
+m  5	-	a(b)(c)		abc	abc	b	c
+e  6	-	a(b		EPAREN
+e  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
+m  8	eU	a)b		a)b	a)b
+e  9	-	a)b		EPAREN
+e 10	b	{a\)b}		EPAREN
+m 11	P	a(?:b)c		abc	abc
+e 12	e	a(?:b)c		BADRPT
+i 13	S	a()b		ab	{0 1}	{1 0}
+m 14	SP	a(?:)b		ab	ab
+i 15	S	a(|b)c		ac	{0 1}	{1 0}
+m 16	S	a(b|)c		abc	abc	b
+
+
+
+doing 5 "simple one-char matching"
+# general case of brackets done later
+m  1	&	a.b		axb	axb
+f  2	&n	"a.b"		"a\nb"
+m  3	&	{a[bc]d}	abd	abd
+m  4	&	{a[bc]d}	acd	acd
+f  5	&	{a[bc]d}	aed
+f  6	&	{a[^bc]d}	abd
+m  7	&	{a[^bc]d}	aed	aed
+f  8	&p	"a\[^bc]d"	"a\nd"
+
+
+
+doing 6 "context-dependent syntax"
+# plus odds and ends
+e  1	-	*		BADRPT
+m  2	b	*		*	*
+m  3	b	{\(*\)}		*	*	*
+e  4	-	(*)		BADRPT
+m  5	b	^*		*	*
+e  6	-	^*		BADRPT
+f  7	&	^b		^b
+m  8	b	x^		x^	x^
+f  9	I	x^		x
+m 10	n	"\n^"		"x\nb"	"\n"
+f 11	bS	{\(^b\)}	^b
+m 12	-	(^b)		b	b	b
+m 13	&	{x$}		x	x
+m 14	bS	{\(x$\)}	x	x	x
+m 15	-	{(x$)}		x	x	x
+m 16	b	{x$y}		"x\$y"	"x\$y"
+f 17	I	{x$y}		xy
+m 18	n	"x\$\n"		"x\n"	"x\n"
+e 19	-	+		BADRPT
+e 20	-	?		BADRPT
+
+
+
+doing 7 "simple quantifiers"
+m  1	&N	a*		aa	aa
+i  2	&N	a*		b	{0 -1}
+m  3	-	a+		aa	aa
+m  4	-	a?b		ab	ab
+m  5	-	a?b		b	b
+e  6	-	**		BADRPT
+m  7	bN	**		***	***
+e  8	&	a**		BADRPT
+e  9	&	a**b		BADRPT
+e 10	&	***		BADRPT
+e 11	*	a++		BADRPT
+e 12	*	a?+		BADRPT
+e 13	*	a?*		BADRPT
+e 14	*	a+*		BADRPT
+e 15	*	a*+		BADRPT
+
+
+
+doing 8 "braces"
+m  1	NQ	"a{0,1}"	""	""
+m  2	NQ	"a{0,1}"	ac	a
+e  3	-	"a{1,0}"	BADBR
+e  4	-	"a{1,2,3}"	BADBR
+e  5	-	"a{257}"	BADBR
+e  6	-	"a{1000}"	BADBR
+e  7	-	"a{1"		EBRACE
+e  8	-	"a{1n}"		BADBR
+m  9	BS	"a{b"		"a\{b"	"a\{b"
+m 10	BS	"a{"		"a\{"	"a\{"
+m 11	bQ	{a\{0,1\}b}	cb	b
+e 12	b	{a\{0,1}	EBRACE
+e 13	-	"a{0,1\\"	BADBR
+m 14	Q	"a{0}b"		ab	b
+m 15	Q	"a{0,0}b"	ab	b
+m 16	Q	"a{0,1}b"	ab	ab
+m 17	Q	"a{0,2}b"	b	b
+m 18	Q	"a{0,2}b"	aab	aab
+m 19	Q	"a{0,}b"	aab	aab
+m 20	Q	"a{1,1}b"	aab	ab
+m 21	Q	"a{1,3}b"	aaaab	aaab
+f 22	Q	"a{1,3}b"	b
+m 23	Q	"a{1,}b"	aab	aab
+f 24	Q	"a{2,3}b"	ab
+m 25	Q	"a{2,3}b"	aaaab	aaab
+f 26	Q	"a{2,}b"	ab
+m 27	Q	"a{2,}b"	aaaab	aaaab
+
+
+
+doing 9 "brackets"
+m  1	&	{a[bc]}		ac	ac
+m  2	&	{a[-]}		a-	a-
+m  3	&	{a[[.-.]]}	a-	a-
+m  4	&L	{a[[.zero.]]}	a0	a0
+m  5	&LM	{a[[.zero.]-9]}	a2	a2
+m  6	&M	{a[0-[.9.]]}	a2	a2
+m  7	&+L	{a[[=x=]]}	ax	ax
+m  8	&+L	{a[[=x=]]}	ay	ay
+f  9	&+L	{a[[=x=]]}	az
+e 10	&	{a[0-[=x=]]}	ERANGE
+m 11	&L	{a[[:digit:]]}	a0	a0
+e 12	&	{a[[:woopsie:]]}	ECTYPE
+f 13	&L	{a[[:digit:]]}	ab
+e 14	&	{a[0-[:digit:]]}	ERANGE
+m 15	&LP	{[[:<:]]a}	a	a
+m 16	&LP	{a[[:>:]]}	a	a
+e 17	&	{a[[..]]b}	ECOLLATE
+e 18	&	{a[[==]]b}	ECOLLATE
+e 19	&	{a[[::]]b}	ECTYPE
+e 20	&	{a[[.a}		EBRACK
+e 21	&	{a[[=a}		EBRACK
+e 22	&	{a[[:a}		EBRACK
+e 23	&	{a[}		EBRACK
+e 24	&	{a[b}		EBRACK
+e 25	&	{a[b-}		EBRACK
+e 26	&	{a[b-c}		EBRACK
+m 27	&M	{a[b-c]}	ab	ab
+m 28	&	{a[b-b]}	ab	ab
+m 29	&M	{a[1-2]}	a2	a2
+e 30	&	{a[c-b]}	ERANGE
+e 31	&	{a[a-b-c]}	ERANGE
+m 32	&M	{a[--?]b}	a?b	a?b
+m 33	&	{a[---]b}	a-b	a-b
+m 34	&	{a[]b]c}	a]c	a]c
+m 35	EP	{a[\]]b}	a]b	a]b
+f 36	bE	{a[\]]b}	a]b
+m 37	bE	{a[\]]b}	"a\\]b"	"a\\]b"
+m 38	eE	{a[\]]b}	"a\\]b"	"a\\]b"
+m 39	EP	{a[\\]b}	"a\\b"	"a\\b"
+m 40	eE	{a[\\]b}	"a\\b"	"a\\b"
+m 41	bE	{a[\\]b}	"a\\b"	"a\\b"
+e 42	-	{a[\Z]b}	EESCAPE
+m 43	&	{a[[b]c}	"a\[c"	"a\[c"
+m 44	EMP	{a[\u00fe-\u0507][\u00ff-\u0300]b} \
+			"a\u0102\u02ffb"	"a\u0102\u02ffb"
+
+
+
+doing 10 "anchors and newlines"
+m  1	&	^a		a	a
+f  2	&^	^a		a
+i  3	&N	^		a	{0 -1}
+i  4	&	{a$}		aba	{2 2}
+f  5	{&$}	{a$}		a
+i  6	&N	{$}		ab	{2 1}
+m  7	&n	^a		a	a
+m  8	&n	"^a"		"b\na"	"a"
+i  9	&w	"^a"		"a\na"	{0 0}
+i 10	&n^	"^a"		"a\na"	{2 2}
+m 11	&n	{a$}		a	a
+m 12	&n	"a\$"		"a\nb"	"a"
+i 13	&n	"a\$"		"a\na"	{0 0}
+i 14	N	^^		a	{0 -1}
+m 15	b	^^		^	^
+i 16	N	{$$}		a	{1 0}
+m 17	b	{$$}		"\$"	"\$"
+m 18	&N	{^$}		""	""
+f 19	&N	{^$}		a
+i 20	&nN	"^\$"		"a\n\nb"	{2 1}
+m 21	N	{$^}		""	""
+m 22	b	{$^}		"\$^"	"\$^"
+m 23	P	{\Aa}		a	a
+m 24	^P	{\Aa}		a	a
+f 25	^nP	{\Aa}		"b\na"
+m 26	P	{a\Z}		a	a
+m 27	{$P}	{a\Z}		a	a
+f 28	{$nP}	{a\Z}		"a\nb"
+e 29	-	^*		BADRPT
+e 30	-	{$*}		BADRPT
+e 31	-	{\A*}		BADRPT
+e 32	-	{\Z*}		BADRPT
+
+
+
+doing 11 "boundary constraints"
+m  1	&LP	{[[:<:]]a}	a	a
+m  2	&LP	{[[:<:]]a}	-a	a
+f  3	&LP	{[[:<:]]a}	ba
+m  4	&LP	{a[[:>:]]}	a	a
+m  5	&LP	{a[[:>:]]}	a-	a
+f  6	&LP	{a[[:>:]]}	ab
+m  7	bLP	{\<a}		a	a
+f  8	bLP	{\<a}		ba
+m  9	bLP	{a\>}		a	a
+f 10	bLP	{a\>}		ab
+m 11	LP	{\ya}		a	a
+f 12	LP	{\ya}		ba
+m 13	LP	{a\y}		a	a
+f 14	LP	{a\y}		ab
+m 15	LP	{a\Y}		ab	a
+f 16	LP	{a\Y}		a-
+f 17	LP	{a\Y}		a
+f 18	LP	{-\Y}		-a
+m 19	LP	{-\Y}		-%	-
+f 20	LP	{\Y-}		a-
+e 21	-	{[[:<:]]*}	BADRPT
+e 22	-	{[[:>:]]*}	BADRPT
+e 23	b	{\<*}		BADRPT
+e 24	b	{\>*}		BADRPT
+e 25	-	{\y*}		BADRPT
+e 26	-	{\Y*}		BADRPT
+m 27	LP	{\ma}		a	a
+f 28	LP	{\ma}		ba
+m 29	LP	{a\M}		a	a
+f 30	LP	{a\M}		ab
+f 31	ILP	{\Ma}		a
+f 32	ILP	{a\m}		a
+
+
+
+doing 12 "character classes"
+m  1	LP	{a\db}		a0b	a0b
+f  2	LP	{a\db}		axb
+f  3	LP	{a\Db}		a0b
+m  4	LP	{a\Db}		axb	axb
+m  5	LP	"a\\sb"		"a b"	"a b"
+m  6	LP	"a\\sb"		"a\tb"	"a\tb"
+m  7	LP	"a\\sb"		"a\nb"	"a\nb"
+f  8	LP	{a\sb}		axb
+m  9	LP	{a\Sb}		axb	axb
+f 10	LP	"a\\Sb"		"a b"
+m 11	LP	{a\wb}		axb	axb
+f 12	LP	{a\wb}		a-b
+f 13	LP	{a\Wb}		axb
+m 14	LP	{a\Wb}		a-b	a-b
+m 15	LP	{\y\w+z\y}	adze-guz	guz
+m 16	LPE	{a[\d]b}	a1b	a1b
+m 17	LPE	"a\[\\s]b"	"a b"	"a b"
+m 18	LPE	{a[\w]b}	axb	axb
+
+
+
+doing 13 "escapes"
+e  1	&	"a\\"		EESCAPE
+m  2	-	{a\<b}		a<b	a<b
+m  3	e	{a\<b}		a<b	a<b
+m  4	bAS	{a\wb}		awb	awb
+m  5	eAS	{a\wb}		awb	awb
+m  6	PL	"a\\ab"		"a\007b"	"a\007b"
+m  7	P	"a\\bb"		"a\bb"	"a\bb"
+m  8	P	{a\Bb}		"a\\b"	"a\\b"
+m  9	MP	"a\\chb"	"a\bb"	"a\bb"
+m 10	MP	"a\\cHb"	"a\bb"	"a\bb"
+m 11	LMP	"a\\e"		"a\033"	"a\033"
+m 12	P	"a\\fb"		"a\fb"	"a\fb"
+m 13	P	"a\\nb"		"a\nb"	"a\nb"
+m 14	P	"a\\rb"		"a\rb"	"a\rb"
+m 15	P	"a\\tb"		"a\tb"	"a\tb"
+m 16	P	"a\\u0008x"	"a\bx"	"a\bx"
+e 17	-	{a\u008x}	EESCAPE
+m 18	P	"a\\u00088x"	"a\b8x"	"a\b8x"
+m 19	P	"a\\U00000008x"	"a\bx"	"a\bx"
+e 20	-	{a\U0000008x}	EESCAPE
+m 21	P	"a\\vb"		"a\vb"	"a\vb"
+m 22	MP	"a\\x08x"	"a\bx"	"a\bx"
+e 23	-	{a\xq}		EESCAPE
+m 24	MP	"a\\x0008x"	"a\bx"	"a\bx"
+e 25	-	{a\z}		EESCAPE
+m 26	MP	"a\\010b"	"a\bb"	"a\bb"
+
+
+
+doing 14 "back references"
+# ugh
+m  1	{R[1P}	{a(b*)c\1}	abbcbb	abbcbb	bb
+m  2	{R[1P}	{a(b*)c\1}	ac	ac	""
+f  3	{R[1P}	{a(b*)c\1}	abbcb
+m  4	{R[1P}	{a(b*)\1}	abbcbb	abb	b
+m  5	{R[1P}	{a(b|bb)\1}	abbcbb	abb	b
+m  6	{R[1P}	{a([bc])\1}	abb	abb	b
+f  7	{R[1P}	{a([bc])\1}	abc
+m  8	{R[1P}	{a([bc])\1}	abcabb	abb	b
+f  9	{R[1P}	{a([bc])*\1}	abc
+f 10	{R[1P}	{a([bc])\1}	abB
+m 11	{iR[1P}	{a([bc])\1}	abB	abB	b
+m 12	{R[1P}	{a([bc])\1+}	abbb	abbb	b
+m 13	{QR[1P}	"a(\[bc])\\1{3,4}"	abbbb	abbbb	b
+f 14	{QR[1P}	"a(\[bc])\\1{3,4}"	abbb
+m 15	{R[1P}	{a([bc])\1*}	abbb	abbb	b
+m 16	{R[1P}	{a([bc])\1*}	ab	ab	b
+m 17	{R[2P}	{a([bc])(\1*)}	ab	ab	b	""
+e 18	-	{a((b)\1)}	ESUBREG
+e 19	-	{a(b)c\2}	ESUBREG
+m 20	{bR[1}	{a\(b*\)c\1}	abbcbb	abbcbb	bb
+
+
+
+doing 15 "octal escapes vs back references"
+# initial zero is always octal
+m  1	MP	"a\\010b"	"a\bb"	"a\bb"
+m  2	MP	"a\\0070b"	"a\0070b"	"a\0070b"
+m  3	MP	"a\\07b"	"a\007b"	"a\007b"
+m  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
+e  5	-	{a\7b}		ESUBREG
+# otherwise it's a backref only if within range (barf!)
+m  6	MP	"a\\10b"	"a\bb"	"a\bb"
+m  7	MP	{a\101b}	aAb	aAb
+m  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
+e  9	-	{a((((((((((b\10))))))))))c}	ESUBREG
+# BREs don't have octal, EREs don't have backrefs
+m 10	MP	"a\\12b"	"a\nb"	"a\nb"
+e 11	b	{a\12b}		ESUBREG
+m 12	eAS	{a\12b}		a12b	a12b
+
+
+
+doing 16 "expanded syntax"
+m  1	xP	"a b c"		"abc"	"abc"
+m  2	xP	"a b #oops\nc\td"	"abcd"	"abcd"
+m  3	x	"a\\ b\\\tc"	"a b\tc"	"a b\tc"
+m  4	xP	"a b\\#c"	"ab#c"	"ab#c"
+m  5	xP	"a b\[c d]e"	"ab e"	"ab e"
+m  6	xP	"a b\[c#d]e"	"ab#e"	"ab#e"
+m  7	xP	"a b\[c#d]e"	"abde"	"abde"
+m  8	xSPB	"ab{ d"		"ab\{d"	"ab\{d"
+m  9	xPQ	"ab{ 1 , 2 }c"	"abc"	"abc"
+
+
+
+doing 17 "misc syntax"
+m  1	P	a(?#comment)b	ab	ab
+
+
+
+doing 18 "unmatchable REs"
+f  1	I	a^b		ab
+
+
+
+doing 19 "case independence"
+m  1	&i	ab		Ab	Ab
+m  2	&i	{a[bc]}		aC	aC
+f  3	&i	{a[^bc]}	aB
+m  4	&iM	{a[b-d]}	aC	aC
+f  5	&iM	{a[^b-d]}	aC
+
+
+
+doing 20 "directors and embedded options"
+e  1	&	***?		BADPAT
+m  2	q	***?		***?	***?
+m  3	&P	***=a*b		a*b	a*b
+m  4	q	***=a*b		***=a*b	***=a*b
+m  5	bLP	{***:\w+}	ab	ab
+m  6	eLP	{***:\w+}	ab	ab
+e  7	&	***:***=a*b	BADRPT
+m  8	&P	***:(?b)a+b	a+b	a+b
+m  9	P	(?b)a+b		a+b	a+b
+e 10	e	{(?b)\w+}	BADRPT
+m 11	bAS	{(?b)\w+}	(?b)w+	(?b)w+
+m 12	iP	(?c)a		a	a
+f 13	iP	(?c)a		A
+m 14	APS	{(?e)\W+}	WW	WW
+m 15	P	(?i)a+		Aa	Aa
+f 16	P	"(?m)a.b"	"a\nb"
+m 17	P	"(?m)^b"	"a\nb"	"b"
+f 18	P	"(?n)a.b"	"a\nb"
+m 19	P	"(?n)^b"	"a\nb"	"b"
+f 20	P	"(?p)a.b"	"a\nb"
+f 21	P	"(?p)^b"	"a\nb"
+m 22	P	(?q)a+b		a+b	a+b
+m 23	nP	"(?s)a.b"	"a\nb"	"a\nb"
+m 24	xP	"(?t)a b"	"a b"	"a b"
+m 25	P	"(?w)a.b"	"a\nb"	"a\nb"
+m 26	P	"(?w)^b"	"a\nb"	"b"
+m 27	P	"(?x)a b"	"ab"	"ab"
+e 28	-	(?z)ab		BADOPT
+m 29	P	(?ici)a+	Aa	Aa
+e 30	P	(?i)(?q)a+	BADRPT
+m 31	P	(?q)(?i)a+	(?i)a+	(?i)a+
+m 32	P	(?qe)a+		a	a
+m 33	xP	"(?q)a b"	"a b"	"a b"
+m 34	P	"(?qx)a b"	"a b"	"a b"
+m 35	P	(?qi)ab		Ab	Ab
+
+
+
+doing 21 "capturing"
+m  1	-	a(b)c		abc	abc	b
+m  2	P	a(?:b)c		xabc	abc
+m  3	-	a((b))c		xabcy	abc	b	b
+m  4	P	a(?:(b))c	abcy	abc	b
+m  5	P	a((?:b))c	abc	abc	b
+m  6	P	a(?:(?:b))c	abc	abc
+i  7	Q	"a(b){0}c"	ac	{0 1}	{-1 -1}
+m  8	-	a(b)c(d)e	abcde	abcde	b	d
+m  9	-	(b)c(d)e	bcde	bcde	b	d
+m 10	-	a(b)(d)e	abde	abde	b	d
+m 11	-	a(b)c(d)	abcd	abcd	b	d
+m 12	-	(ab)(cd)	xabcdy	abcd	ab	cd
+m 13	-	a(b)?c		xabcy	abc	b
+i 14	-	a(b)?c		xacy	{1 2}	{-1 -1}
+m 15	-	a(b)?c(d)?e	xabcdey	abcde	b	d
+i 16	-	a(b)?c(d)?e	xacdey	{1 4}	{-1 -1}	{3 3}
+i 17	-	a(b)?c(d)?e	xabcey	{1 4}	{2 2}	{-1 -1}
+i 18	-	a(b)?c(d)?e	xacey	{1 3}	{-1 -1}	{-1 -1}
+m 19	-	a(b)*c		xabcy	abc	b
+i 20	-	a(b)*c		xabbbcy	{1 5}	{4 4}
+i 21	-	a(b)*c		xacy	{1 2}	{-1 -1}
+m 22	-	a(b*)c		xabbbcy	abbbc	bbb
+m 23	-	a(b*)c		xacy	ac	""
+f 24	-	a(b)+c		xacy
+m 25	-	a(b)+c		xabcy	abc	b
+i 26	-	a(b)+c		xabbbcy	{1 5}	{4 4}
+m 27	-	a(b+)c		xabbbcy	abbbc	bbb
+i 28	Q	"a(b){2,3}c"	xabbbcy	{1 5}	{4 4}
+i 29	Q	"a(b){2,3}c"	xabbcy	{1 4}	{3 3}
+f 30	Q	"a(b){2,3}c"	xabcy
+m 31	LP	"\\y(\\w+)\\y"	"-- abc-"	"abc"	"abc"
+m 32	-	a((b|c)d+)+	abacdbd	acdbd	bd	b
+m 33	N	(.*).*		abc	abc	abc
+m 34	N	(a*)*		bc	""	""
+
+
+
+doing 22 "multicharacter collating elements"
+# again ugh
+# currently disabled because the fake MCCE we use for testing is unavailable
+xx m  1	&+L	{a[c]e}		ace	ace
+xx f  2	&+I	{a[c]h}		ach
+xx m  3	&+L	{a[[.ch.]]}	ach	ach
+xx f  4	&+L	{a[[.ch.]]}	ace
+xx m  5	&+L	{a[c[.ch.]]}	ac	ac
+xx m  6	&+L	{a[c[.ch.]]}	ace	ac
+xx m  7	&+L	{a[c[.ch.]]}	ache	ach
+xx f  8	&+L	{a[^c]e}	ace
+xx m  9	&+L	{a[^c]e}	abe	abe
+xx m 10	&+L	{a[^c]e}	ache	ache
+xx f 11	&+L	{a[^[.ch.]]}	ach
+xx m 12	&+L	{a[^[.ch.]]}	ace	ac
+xx m 13	&+L	{a[^[.ch.]]}	ac	ac
+xx m 14	&+L	{a[^[.ch.]]}	abe	ab
+xx f 15	&+L	{a[^c[.ch.]]}	ach
+xx f 16	&+L	{a[^c[.ch.]]}	ace
+xx f 17	&+L	{a[^c[.ch.]]}	ac
+xx m 18	&+L	{a[^c[.ch.]]}	abe	ab
+xx m 19	&+L	{a[^b]}		ac	ac
+xx m 20	&+L	{a[^b]}		ace	ac
+xx m 21	&+L	{a[^b]}		ach	ach
+xx f 22	&+L	{a[^b]}		abe
+
+
+
+doing 23 "lookahead constraints"
+m  1	HP	a(?=b)b*	ab	ab
+f  2	HP	a(?=b)b*	a
+m  3	HP	a(?=b)b*(?=c)c*	abc	abc
+f  4	HP	a(?=b)b*(?=c)c*	ab
+f  5	HP	a(?!b)b*	ab
+m  6	HP	a(?!b)b*	a	a
+m  7	HP	(?=b)b		b	b
+f  8	HP	(?=b)b		a
+
+
+
+doing 24 "non-greedy quantifiers"
+m  1	P	ab+?		abb	ab
+m  2	P	ab+?c		abbc	abbc
+m  3	P	ab*?		abb	a
+m  4	P	ab*?c		abbc	abbc
+m  5	P	ab??		ab	a
+m  6	P	ab??c		abc	abc
+m  7	PQ	"ab{2,4}?"	abbbb	abb
+m  8	PQ	"ab{2,4}?c"	abbbbc	abbbbc
+
+
+
+doing 25 "mixed quantifiers"
+xx to be done, actually
+xx should include |
+
+
+
+doing 26 "tricky cases"
+# attempts to trick the matcher into accepting a short match
+m  1	-	(week|wee)(night|knights)	weeknights	weeknights \
+	wee	knights
+m  2	RP	{a(bc*).*\1}	abccbccb	abccbccb	b
+m  3	-	{a(b.[bc]*)+}	abcbd	abcbd	bd
+
+
+
+doing 27 "implementation misc."
+# duplicate arcs are suppressed
+m  1	P	a(?:b|b)c	abc	abc
+# make color/subcolor relationship go back and forth
+m  2	&	{[ab][ab][ab]}	aba	aba
+m  3	&	{[ab][ab][ab][ab][ab][ab][ab]}	abababa	abababa
+
+
+
+doing 28 "boundary busters etc."
+# color-descriptor allocation changes at 10
+m  1	&	abcdefghijkl	abcdefghijkl	abcdefghijkl
+# so does arc allocation
+m  2	P	a(?:b|c|d|e|f|g|h|i|j|k|l|m)n	agn	agn
+# subexpression tracking also at 10
+m  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)
+m  4	Q	"ab{1,100}c"	abbc	abbc
+m  5	Q	"ab{1,100}c"	abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc \
+	abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
+m  6	Q	"ab{1,100}c" \
+	abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc \
+	abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
+# force small cache and bust it, several ways
+m  7	LP	{\w+abcdefgh}	xyzabcdefgh	xyzabcdefgh
+m  8	%LP	{\w+abcdefgh}	xyzabcdefgh	xyzabcdefgh
+m  9	%LP	{\w+abcdefghijklmnopqrst}	xyzabcdefghijklmnopqrst \
+	xyzabcdefghijklmnopqrst
+i 10	%LP	{\w+(abcdefgh)?}	xyz	{0 2}	{-1 -1}
+i 11	%LP	{\w+(abcdefgh)?}	xyzabcdefg	{0 9}	{-1 -1}
+i 12	%LP	{\w+(abcdefghijklmnopqrst)?}	xyzabcdefghijklmnopqrs \
+	{0 21}	{-1 -1}
+
+
+
+doing 29 "misc. oddities and old bugs"
+e  1	&	***		BADRPT
+m  2	N	a?b*		abb	abb
+m  3	N	a?b*		bb	bb
+m  4	&	a*b		aab	aab
+m  5	&	^a*b		aaaab aaaab
+m  6	&M	 {[0-6][1-2][0-3][0-6][1-6][0-6]}	010010	010010
+
+
+
+doing 0 "flush"			;# to flush any leftover complaints
+
+# cleanup
+::tcltest::cleanupTests
+return
+
+