Major simplification of reg.test to de-Spencer it somewhat.

It's still cryptic, but perhaps not quite so bad now. :^)

1 files changed, 672 insertions, 744 deletions

diff --git a/tests/reg.test b/tests/reg.test
index 5b66341..37536ce 100644
--- a/tests/reg.test
+++ b/tests/reg.test
@@ -9,44 +9,44 @@
 #
 # Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
 #
-# RCS: @(#) $Id: reg.test,v 1.21 2004/06/24 10:34:12 dkf Exp $
+# RCS: @(#) $Id: reg.test,v 1.22 2004/11/05 15:15:25 dkf Exp $
 
 if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest 2
-    namespace import -force ::tcltest::*
 }
 
 # All tests require the testregexp command, return if this
 # command doesn't exist
 
-::tcltest::testConstraint testregexp \
-	[expr {[info commands testregexp] != {}}]
+::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:
-#	e	compile error expected
-#	f	match failure expected
-#	m	successful match
-#	i	successful match with -indices (used in checking things like
-#		nonparticipating subexpressions)
-#	p	unsuccessful match with -indices (!!) (used in checking
-#		partial-match reporting)
+#	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 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 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 i and p.
+# 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
@@ -98,68 +98,55 @@ if {[lsearch [namespace children] ::tcltest] == -1} {
 # 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
 
-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(T) "REG_USHORTEST"
-set infonames(U) "REG_UPBOTCH"
-set infonameorder "RHQBAUEPSMLNIT"	;# 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\
-					 $prefix, `$description'"
-	}
-
-	set prefix reg-$major
-	set description "reg $desc"
-	set testbypassed 0
-}
-
-# build test number (internal)
-proc tno {testid} {
-	return [join $testid .]
-}
+    # build test number (internal)
+    proc TestNum {args} {
+	return reg-[join [concat $args] .]
+    }
 
-# build description, with possible modifiers (internal)
-proc desc {testid} {
-	global description
+    # build description, with possible modifiers (internal)
+    proc TestDesc {args} {
+	variable description
 
+	set testid [concat $args]
 	set d $description
 	if {[llength $testid] > 1} {
-		set d "([lreplace $testid 0 0]) $d"
+	    set d "$d ([lrange $testid 1 end])"
 	}
 	return $d
-}
-
-# build trailing options and flags argument from a flags string (internal)
-proc flags {fl} {
-	global xflags
+    }
 
+    # 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 {
+	    switch -exact -- $f {
 		"i" { lappend args "-nocase" }
 		"x" { lappend args "-expanded" }
 		"n" { lappend args "-line" }
@@ -167,825 +154,786 @@ proc flags {fl} {
 		"w" { lappend args "-lineanchor" }
 		"-" { }
 		default { append flags $f }
-		}
+	    }
 	}
-	if {[string compare $flags ""] != 0} {
-		lappend args -$xflags $flags
+	if {$flags ne ""} {
+	    lappend args -xflags $flags
 	}
 	return $args
-}
+    }
 
-# build info-flags list from a flags string (internal)
-proc infoflags {fl} {
-	global infonames infonameorder
+    # 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 first $f $fl] >= 0} {
-			lappend ret $infonames($f)
-		}
+	    if {[string match *$f* $fl]} {
+		lappend ret $infonames($f)
+	    }
 	}
 	return $ret
-}
+    }
 
-# compilation error expected
-proc e {testid flags re err} {
-	global prefix ask errorCode
+    # 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} {
+	variable regBug
 
-	# Tcl locale stuff doesn't do the ch/xy test fakery yet
-	if {[string first "+" $flags] >= 0} {
-	    # This will register as a skipped test
-	    test $prefix.[tno $testid] [desc $testid] localeRegexp {} {}
+	# if &, test as both BRE and ARE
+	if {[string match *&* $flags]} {
+	    set f [string map {& {}} $flags]
+	    MatchExpected $opts "$testid ARE" ${f}  $re $target {expand}$args
+	    MatchExpected $opts "$testid BRE" ${f}b $re $target {expand}$args
 	    return
 	}
 
-	# 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]
-}
+	set constraints [list testregexp]
 
-# match failure expected
-proc f {testid flags re target args} {
-	global prefix description ask
+	if {$regBug} {
+	    # This will register as a skipped test
+	    lappend constraints knownBug
+	}
 
 	# Tcl locale stuff doesn't do the ch/xy test fakery yet
-	if {[string first "+" $flags] >= 0} {
+	if {[string match *+* $flags]} {
 	    # This will register as a skipped test
-	    test $prefix.[tno $testid] [desc $testid] localeRegexp {} {}
-	    return
+	    lappend constraints localeRegexp
 	}
 
-	# 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]
-		f [linsert $testid end ARE] ${f} $re $target {expand}$args
-		f [linsert $testid end BRE] ${f}b $re $target {expand}$args
-		return
-	}
+	set f [TestFlags $flags]
+	set infoflags [TestInfoFlags $flags]
+	set ccmd [list testregexp -about        {expand}$f $re]
+	set ecmd [list testregexp {expand}$opts {expand}$f $re $target]
 
-	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]
+	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
 	}
-	lappend testid "compile"
-	test $prefix.[tno $testid] [desc $testid] {testregexp} $ccmd $info
+	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]}] {expand}$args]
+	set info [list $nsub $infoflags]
 
-	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
-}
+	::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
+    }
 
-# 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} {
-	global prefix description ask regBug
-
-    if {[info exists regBug] && $regBug} {
-	# This will register as a skipped test
-	test $prefix.[tno $testid] [desc $testid] knownBug {format 0} {1}
-	return
+    # set major test number and description
+    proc doing {major desc} {
+	variable description "RE engine $desc"
     }
 
-	# Tcl locale stuff doesn't do the ch/xy test fakery yet
-	if {[string first "+" $flags] >= 0} {
-	    # This will register as a skipped test
-	    test $prefix.[tno $testid] [desc $testid] localeRegexp {} {}
+    # 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
 	}
 
-	# 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]
-		matchexpected $opts [linsert $testid end ARE] \
-			${f} $re $target {expand}$args
-
+	set constraints [list testregexp]
 
-		matchexpected $opts [linsert $testid end BRE] \
-			${f}b $re $target {expand}$args
-		return
+	# Tcl locale stuff doesn't do the ch/xy test fakery yet
+	if {[string match *+* $flags]} {
+	    # This will register as a skipped test
+	    lappend constraints localeRegexp
 	}
 
-	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 cmd [list testregexp -about {expand}[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\]"
+    }
 
-	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 kludge
-		set nsub 0		;# unsigned value cannot be -1
-	}
-	if {[string first "t" $flags] >= 0} {	;# REG_EXPECT
-		incr nsub -1		;# the extra does not count
-	}
-	set ecmd [concat $ecmd $names]
-	set erun "list \[$ecmd\] $refs"
-	set retcode [list 1]
-	if {[string first "!" $flags] >= 0} {
-		set retcode [list 0]
+    # match failure expected
+    proc expectNomatch {testid flags re target args} {
+	# if &, test as both ARE and BRE
+	if {[string match *&* $flags]} {
+	    set f [string map {& {}} $flags]
+	    expectNomatch "$testid ARE" ${f}  $re $target {expand}$args
+	    expectNomatch "$testid BRE" ${f}b $re $target {expand}$args
+	    return
 	}
-	set result [concat $retcode $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
-}
+	set constraints [list testregexp]
 
-# match expected (no missing, empty, or ambiguous submatches)
-# m testno flags re target mat submat ...
-proc m {args} {
-	matchexpected {} {expand}$args
-}
-
-# match expected (full fanciness)
-# i testno flags re target mat submat ...
-proc i {args} {
-	matchexpected -indices {expand}$args 
-}
+	# Tcl locale stuff doesn't do the ch/xy test fakery yet
+	if {[string match *+* $flags]} {
+	    # This will register as a skipped test
+	    lappend constraints localeRegexp
+	}
 
-# partial match expected
-# p testno flags re target mat "" ...
-# Quirk:  number of ""s must be one more than number of subREs.
-proc p {args} {
-	set f [lindex $args 1]			;# add ! flag
-	set args [lreplace $args 1 1 "!$f"]
-	matchexpected -indices {expand}$args
-}
+	set f [TestFlags $flags]
+	set infoflags [TestInfoFlags $flags]
+	set ccmd [list testregexp -about {expand}$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 {expand}$f $re $target]
 
-# test is a knownBug
-proc knownBug {args} {
-    set ::regBug 1
-    uplevel #0 $args
-    set ::regBug 0
-}
+	::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 {} {expand}$args
+    }
 
+    # match expected (full fanciness)
+    # expectIndices testno flags re target mat submat ...
+    proc expectIndices {args} {
+	MatchExpected -indices {expand}$args 
+    }
 
-# the tests themselves
+    # 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 {expand}$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.
-test reg-0.1 "regexp error reporting" {
-	list [catch {regexp (*) ign} msg] $msg
+::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"
-m  1	&	abc		abc	abc
-f  2	&	abc		def
-m  3	&	abc		xyabxabce	abc
-
+expectMatch	1.1 &		abc	abc		abc
+expectNomatch	1.2 &		abc	def
+expectMatch	1.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
-
+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"
-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
-
+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"
-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
+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
-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
-
+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
-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"
-
+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
-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
-
+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"
-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
-
+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"
-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
-
+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"
-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"
-
+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"
-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
-
+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"
-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
-
+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"
-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
-
+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"
-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"
-
+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"
+expectError	13.17 -		{a\u008x}	EESCAPE
+expectMatch	13.18 P		"a\\u00088x"	"a\b8x"	"a\b8x"
+expectMatch	13.19 P		"a\\U00000008x"	"a\bx"	"a\bx"
+expectError	13.20 -		{a\U0000008x}	EESCAPE
+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\\x0008x"	"a\bx"	"a\bx"
+expectError	13.25 -		{a\z}		EESCAPE
+expectMatch	13.26 MP	"a\\010b"	"a\bb"	"a\bb"
 
 
 doing 14 "back references"
 # ugh
-m  1	RP	{a(b*)c\1}	abbcbb	abbcbb	bb
-m  2	RP	{a(b*)c\1}	ac	ac	""
-f  3	RP	{a(b*)c\1}	abbcb
-m  4	RP	{a(b*)\1}	abbcbb	abb	b
-m  5	RP	{a(b|bb)\1}	abbcbb	abb	b
-m  6	RP	{a([bc])\1}	abb	abb	b
-f  7	RP	{a([bc])\1}	abc
-m  8	RP	{a([bc])\1}	abcabb	abb	b
-f  9	RP	{a([bc])*\1}	abc
-f 10	RP	{a([bc])\1}	abB
-m 11	iRP	{a([bc])\1}	abB	abB	b
-m 12	RP	{a([bc])\1+}	abbb	abbb	b
-m 13	QRP	"a(\[bc])\\1{3,4}"	abbbb	abbbb	b
-f 14	QRP	"a(\[bc])\\1{3,4}"	abbb
-m 15	RP	{a([bc])\1*}	abbb	abbb	b
-m 16	RP	{a([bc])\1*}	ab	ab	b
-m 17	RP	{a([bc])(\1*)}	ab	ab	b	""
-e 18	-	{a((b)\1)}	ESUBREG
-e 19	-	{a(b)c\2}	ESUBREG
-m 20	bR	{a\(b*\)c\1}	abbcbb	abbcbb	bb
-
+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
 
 
 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"
+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
-e  5	-	{a\7b}		ESUBREG
+expectError	15.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
+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
-e  9	-	{a((((((((((b\10))))))))))c}	ESUBREG
+expectError	15.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
-
+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
 
 
 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"
-
+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"
-m  1	P	a(?#comment)b	ab	ab
-
+expectMatch	17.1 P	a(?#comment)b	ab	ab
 
 
 doing 18 "unmatchable REs"
-f  1	I	a^b		ab
-
+expectNomatch	18.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
-
+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"
-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
-
+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"
-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	""	""
-
+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	""	""
 
 
 doing 22 "multicharacter collating elements"
 # again ugh
-m  1	&+L	{a[c]e}		ace	ace
-f  2	&+IL	{a[c]h}		ach
-m  3	&+L	{a[[.ch.]]}	ach	ach
-f  4	&+L	{a[[.ch.]]}	ace
-m  5	&+L	{a[c[.ch.]]}	ac	ac
-m  6	&+L	{a[c[.ch.]]}	ace	ac
-m  7	&+L	{a[c[.ch.]]}	ache	ach
-f  8	&+L	{a[^c]e}	ace
-m  9	&+L	{a[^c]e}	abe	abe
-m 10	&+L	{a[^c]e}	ache	ache
-f 11	&+L	{a[^[.ch.]]}	ach
-m 12	&+L	{a[^[.ch.]]}	ace	ac
-m 13	&+L	{a[^[.ch.]]}	ac	ac
-m 14	&+L	{a[^[.ch.]]}	abe	ab
-f 15	&+L	{a[^c[.ch.]]}	ach
-f 16	&+L	{a[^c[.ch.]]}	ace
-f 17	&+L	{a[^c[.ch.]]}	ac
-m 18	&+L	{a[^c[.ch.]]}	abe	ab
-m 19	&+L	{a[^b]}		ac	ac
-m 20	&+L	{a[^b]}		ace	ac
-m 21	&+L	{a[^b]}		ach	ach
-f 22	&+L	{a[^b]}		abe
-
+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"
-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
-
+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"
-m  1	PT	ab+?		abb	ab
-m  2	PT	ab+?c		abbc	abbc
-m  3	PT	ab*?		abb	a
-m  4	PT	ab*?c		abbc	abbc
-m  5	PT	ab??		ab	a
-m  6	PT	ab??c		abc	abc
-m  7	PQT	"ab{2,4}?"	abbbb	abb
-m  8	PQT	"ab{2,4}?c"	abbbbc	abbbbc
-m  9	-	3z*		123zzzz456	3zzzz
-m 10	PT	3z*?		123zzzz456	3
-m 11	-	z*4		123zzzz456	zzzz4
-m 12	PT	z*?4		123zzzz456	zzzz4
-
+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
 
 
 doing 25 "mixed quantifiers"
 # this is very incomplete as yet
 # should include |
-m  1	PNT	{^(.*?)(a*)$}	xyza	xyza	xyz	a
-m  2	PNT	{^(.*?)(a*)$}	xyzaa	xyzaa	xyz	aa
-m  3	PNT	{^(.*?)(a*)$}	xyz	xyz	xyz	""
-
+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
-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
-
+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
-m  1	P	a(?:b|b)c	abc	abc
+expectMatch	27.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
-
+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
-m  1	&	abcdefghijkl	abcdefghijkl	abcdefghijkl
+expectMatch	28.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
+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
-m  3	-	a(((((((((((((b)))))))))))))c	abc	abc	b	b	b	b	b	b	b	b	b	b	b	b	b
+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)
-m  4	Q	"ab{1,100}c"	abbc	abbc
-m  5	Q	"ab{1,100}c"	abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc \
+expectMatch	28.4  Q		"ab{1,100}c"	abbc	abbc
+expectMatch	28.5  Q		"ab{1,100}c" \
+	"abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc" \
 	abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
-m  6	Q	"ab{1,100}c" \
-	abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc \
+expectMatch	28.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}
-
+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"
-p  1	t	def		abc	{3 2}	""
-p  2	t	bcd		abc	{1 2}	""
-p  3	t	abc		abab	{0 3}	""
-p  4	t	abc		abdab	{3 4}	""
-i  5	t	abc		abc	{0 2}	{0 2}
-i  6	t	abc		xyabc	{2 4}	{2 4}
-p  7	t	abc+		xyab	{2 3}	""
-i  8	t	abc+		xyabc	{2 4}	{2 4}
-knownBug i  9	t	abc+		xyabcd	{2 4}	{6 5}
-i  10	t	abc+		xyabcdd	{2 4}	{7 6}
-p  11	tPT	abc+?		xyab	{2 3}	""
+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
-i  12	tPT	abc+?		xyabc	{2 4}	{5 4}
-i  13	tPT	abc+?		xyabcc	{2 4}	{6 5}
-i  14	tPT	abc+?		xyabcd	{2 4}	{6 5}
-i  15	tPT	abc+?		xyabcdd	{2 4}	{7 6}
-i  16	t	abcd|bc		xyabc	{3 4}	{2 4}
-p  17	tn	.*k		"xx\nyyy"	{3 5}	""
+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"
-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
+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
-m  7	s	abc		abcd	abc
-f  8	s	abc		xabcd
+expectMatch	30.7 s		abc	abcd	abc
+expectNomatch	30.8 s		abc	xabcd
 # back to normal stuff
-m  9	HLP	{(?n)^(?![t#])\S+}	"tk\n\n#\n#\nit0"	it0
+expectMatch	30.9 HLP	{(?n)^(?![t#])\S+} \
+	"tk\n\n#\n#\nit0"	it0
+
 
+# Now for tests *not* written by Henry Spencer
 
-# flush any leftover complaints
-doing 0 "flush"
+namespace import -force ::tcltest::test
 
 # Tests resulting from bugs reported by users
 test reg-31.1 {[[:xdigit:]] behaves correctly when followed by [[:space:]]} {
@@ -1002,7 +950,6 @@ test reg-32.1 {canmatch functionality -- at end} testregexp {
     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"
@@ -1010,7 +957,6 @@ test reg-32.2 {canmatch functionality -- at end} testregexp {
     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"
@@ -1018,7 +964,6 @@ test reg-32.3 {canmatch functionality -- not last char} testregexp {
     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"
@@ -1026,7 +971,6 @@ test reg-32.3.1 {canmatch functionality -- no match} testregexp {
     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"
@@ -1034,7 +978,6 @@ test reg-32.4 {canmatch functionality -- last char} {knownBug testregexp} {
     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"
@@ -1042,7 +985,6 @@ test reg-32.4.1 {canmatch functionality -- last char} {knownBug testregexp} {
     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"
@@ -1050,7 +992,6 @@ test reg-32.5 {canmatch functionality -- last char} {knownBug testregexp} {
     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"
@@ -1058,7 +999,6 @@ test reg-32.6 {canmatch functionality -- last char} {knownBug testregexp} {
     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"
@@ -1066,7 +1006,6 @@ test reg-32.7 {canmatch functionality -- last char} {knownBug testregexp} {
     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"
@@ -1074,7 +1013,6 @@ test reg-32.8 {canmatch functionality -- last char} {knownBug testregexp} {
     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"
@@ -1088,43 +1026,33 @@ test reg-32.9 {canmatch functionality -- more complex case} {knownBug testregexp
 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} {
     regsub {(^|\n)+\.*b} \n.b {} tmp
 } 1
-
 test reg-33.11 {Bug 840258} {
     regsub {(^|[\n\r]+)\.*\?<.*?(\n|\r)+} \
 	    "TQ\r\n.?<5000267>Test already stopped\r\n" {} tmp