cmd/re/regex++.dat

: translated from the Regex++ tests.txt by cvtregex++.c 2001-05-16
# manual edits were done to insert the standard error codes
#
# inserted {...} features tests may have changed line numbers and/or ordering
#
# comments beyond this point are verbatim from the original input
#
# this file contains a script of tests to run through regress.exe
#
# comments start with a semicolon and proceed to the end of the line
#
# changes to regular expression compile flags start with a "-" as the first
# non-whitespace character and consist of a list of the printable names
# of the flags, for example "match_default"
#
# Other lines contain a test to perform using the current flag status
# the first token contains the expression to compile, the second the string
# to match it against. If the second string is "!" then the expression should
# not compile, that is the first string is an invalid regular expression.
# This is then followed by a list of integers that specify what should match,
# each pair represents the starting and ending positions of a subexpression
# starting with the zeroth subexpression (the whole match).
# A value of -1 indicates that the subexpression should not take part in the
# match at all, if the first value is -1 then no part of the expression should
# match the string.
#

# - match_default normal REG_EXTENDED

#
# try some really simple literals:
E	a	a	(0,1)
E	Z	Z	(0,1)
E	Z	aaa	NOMATCH
E	Z	xxxxZZxxx	(4,5)

# and some simple brackets:
E	(a)	zzzaazz	(3,4)(3,4)
Exz	()	zzz	(0,0)(0,0)
Exz	()	NULL	(0,0)(0,0)
E	(	!	EPAREN
E	)	!	NOMATCH
E	(aa	!	EPAREN
E	aa)	!	NOMATCH
E	a	b	NOMATCH
E	\(\)	()	(0,2)
E	\(a\)	(a)	(0,3)
E	\()	!	NOMATCH
E	(\)	!	EPAREN
E	p(a)rameter	ABCparameterXYZ	(3,12)(4,5)
E	[pq](a)rameter	ABCparameterXYZ	(3,12)(4,5)

# now try escaped brackets:
# - match_default bk_parens REG_BASIC
B	\(a\)	zzzaazz	(3,4)(3,4)
B	\(\)	zzz	(0,0)(0,0)
B	\(\)	NULL	(0,0)(0,0)
B	\(	!	EPAREN
B	\)	!	EPAREN
B	\(aa	!	EPAREN
B	aa\)	!	EPAREN
B	()	()	(0,2)
B	(a)	(a)	(0,3)
B	(\)	!	EPAREN
B	\()	!	EPAREN

# now move on to "." wildcards
# - match_default normal REG_EXTENDED REG_STARTEND
E	.	a	(0,1)
E$	.	\n	(0,1)
E$	.	\r	(0,1)
E	.	NULL	NOMATCH
# - match_default normal match_not_dot_newline REG_EXTENDED REG_STARTEND REG_NEWLINE
En	.	a	(0,1)
En$	.	\n	NOMATCH
En$	.	\r	(0,1)
En	.	NULL	NOMATCH
# - match_default normal match_not_dot_null match_not_dot_newline REG_EXTENDED REG_STARTEND REG_NEWLINE
En$	.	\n	NOMATCH
En$	.	\r	(0,1)
# this *WILL* produce an error from the POSIX API functions:
# - match_default normal match_not_dot_null match_not_dot_newline REG_EXTENDED REG_STARTEND REG_NEWLINE REG_NO_POSIX_TEST
Enz	.	NULL	NOMATCH


#
# now move on to the repetion ops,
# starting with operator *
# - match_default normal REG_EXTENDED
E	a*	b	(0,0)
E	ab*	a	(0,1)
E	ab*	ab	(0,2)
E	ab*	sssabbbbbbsss	(3,10)
E	ab*c*	a	(0,1)
E	ab*c*	abbb	(0,4)
E	ab*c*	accc	(0,4)
E	ab*c*	abbcc	(0,5)
E	*a	!	BADRPT
E$	\n*	\n\n	(0,2)
E	\**	**	(0,2)
E	\*	*	(0,1)

# now try operator +
E	ab+	a	NOMATCH
E	ab+	ab	(0,2)
E	ab+	sssabbbbbbsss	(3,10)
E	ab+c+	a	NOMATCH
E	ab+c+	abbb	NOMATCH
E	ab+c+	accc	NOMATCH
E	ab+c+	abbcc	(0,5)
E	+a	!	BADRPT
E$	\n+	\n\n	(0,2)
E	\+	+	(0,1)
E	\+	++	(0,1)
E	\++	++	(0,2)
# - match_default normal bk_plus_qm REG_EXTENDED REG_NO_POSIX_TEST
Exz	+	+	BADRPT
Exz	\+	!	NOMATCH
Exz	a\+	aa	NOMATCH

# now try operator ?
# - match_default normal REG_EXTENDED
E	a?	b	(0,0)
E	ab?	a	(0,1)
E	ab?	ab	(0,2)
E	ab?	sssabbbbbbsss	(3,5)
E	ab?c?	a	(0,1)
E	ab?c?	abbb	(0,2)
E	ab?c?	accc	(0,2)
E	ab?c?	abcc	(0,3)
E	?a	!	BADRPT
E$	\n?	\n\n	(0,1)
E	\?	?	(0,1)
E	\?	??	(0,1)
E	\??	??	(0,1)
# - match_default normal bk_plus_qm REG_EXTENDED REG_NO_POSIX_TEST
Exz	?	?	BADRPT
Exz	\?	!	NOMATCH
Exz	a\?	aa	NOMATCH
Exz	a\?	b	NOMATCH

# - match_default normal limited_ops
B	a?	a?	(0,2)
B	a+	a+	(0,2)
B	a\?	a?	(0,2)
B	a\+	a+	(0,2)

# now try operator {}
# - match_default normal REG_EXTENDED
E	a{2}	a	NOMATCH
E	a{2}	aa	(0,2)
E	a{2}	aaa	(0,2)
E	a{2,}	a	NOMATCH
E	a{2,}	aa	(0,2)
E	a{2,}	aaaaa	(0,5)
E	a{2,4}	a	NOMATCH
E	a{2,4}	aa	(0,2)
E	a{2,4}	aaa	(0,3)
E	a{2,4}	aaaa	(0,4)
E	a{2,4}	aaaaa	(0,4)
# spaces are now allowed inside {}
E	a{ 2 , 4 }	aaaaa	BADBR
E	a{}	!	BADBR
E	a{ }	!	BADBR
E	a{2	!	EBRACE
E	a}	!	NOMATCH
E	\{\}	{}	(0,2)

# - match_default normal bk_braces
B	a\{2\}	a	NOMATCH
B	a\{2\}	aa	(0,2)
B	a\{2\}	aaa	(0,2)
B	a\{2,\}	a	NOMATCH
B	a\{2,\}	aa	(0,2)
B	a\{2,\}	aaaaa	(0,5)
B	a\{2,4\}	a	NOMATCH
B	a\{2,4\}	aa	(0,2)
B	a\{2,4\}	aaa	(0,3)
B	a\{2,4\}	aaaa	(0,4)
B	a\{2,4\}	aaaaa	(0,4)
B	a\{ 2 , 4 \}	aaaaa	BADBR
B	{}	{}	(0,2)

# now test the alternation operator |
# - match_default normal REG_EXTENDED
E	a|b	a	(0,1)
E	a|b	b	(0,1)
E	a(b|c)	ab	(0,2)(1,2)
E	a(b|c)	ac	(0,2)(1,2)
E	a(b|c)	ad	NOMATCH
E	|c	!	ENULL
E	c|	!	ENULL
E	(|)	!	ENULL
E	(a|)	!	ENULL
E	(|a)	!	ENULL
E	a\|	a|	(0,2)
# - match_default normal limited_ops
B	a|	a|	(0,2)
B	a\|	a|	(0,2)
B	|	|	(0,1)
# - match_default normal bk_vbar REG_NO_POSIX_TEST
Bxz	a|	a|	(0,2)
Bxz	a\|b	a	(0,1)
Bxz	a\|b	b	(0,1)

# now test the set operator []
# - match_default normal REG_EXTENDED
# try some literals first
E	[abc]	a	(0,1)
E	[abc]	b	(0,1)
E	[abc]	c	(0,1)
E	[abc]	d	NOMATCH
E	[^bcd]	a	(0,1)
E	[^bcd]	b	NOMATCH
E	[^bcd]	d	NOMATCH
E	[^bcd]	e	(0,1)
E	a[b]c	abc	(0,3)
E	a[ab]c	abc	(0,3)
E	a[^ab]c	adc	(0,3)
E	a[]b]c	a]c	(0,3)
E	a[[b]c	a[c	(0,3)
E	a[-b]c	a-c	(0,3)
E	a[^]b]c	adc	(0,3)
E	a[^-b]c	adc	(0,3)
E	a[b-]c	a-c	(0,3)
E	a[b	!	EBRACK
E	a[]	!	EBRACK

# then some ranges
E	[b-e]	a	NOMATCH
E	[b-e]	b	(0,1)
E	[b-e]	e	(0,1)
E	[b-e]	f	NOMATCH
E	[^b-e]	a	(0,1)
E	[^b-e]	b	NOMATCH
E	[^b-e]	e	NOMATCH
E	[^b-e]	f	(0,1)
E	a[1-3]c	a2c	(0,3)
E	a[3-1]c	!	ERANGE
E	a[1-3-5]c	!	ERANGE
E	a[1-	!	EBRACK

# and some classes
E	a[[:alpha:]]c	abc	(0,3)
E	a[[:unknown:]]c	!	ECTYPE
E	a[[:	!	ECTYPE
E	a[[:alpha	!	ECTYPE
E	a[[:alpha:]	!	EBRACK
E	a[[:alpha,:]	!	ECTYPE
E	a[[:]:]]b	!	ECTYPE
E	a[[:-:]]b	!	ECTYPE
E	a[[:alph:]]	!	ECTYPE
E	a[[:alphabet:]]	!	ECTYPE
E	[[:alnum:]]+	-%@a0X-	(3,6)
E	[[:alpha:]]+	-%@aX0-	(3,5)
E$	[[:blank:]]+	a  \tb	(1,4)
E$	[[:cntrl:]]+	a\n\tb	(1,3)
E	[[:digit:]]+	a019b	(1,4)
E	[[:graph:]]+	a%b 	(0,3)
E	[[:lower:]]+	AabC	(1,3)
# This test fails with STLPort, disable for now as this is a corner case anyway...
#[[:print:]]+ "\na b\n" 1 4
E$	[[:punct:]]+	%-&\t	(0,3)
E$	[[:space:]]+	a \n\t\rb	(1,5)
E	[[:upper:]]+	aBCd	(1,3)
E	[[:xdigit:]]+	p0f3Cx	(1,5)

# now test flag settings:
# - escape_in_lists REG_NO_POSIX_TEST
Exz$	[\n]	\n	(0,1)
# - REG_NO_POSIX_TEST
Bxz$	[\n]	\n	(0,1)
Bxz$	[\n]	\\	NOMATCH
Bxz	[[:class:]	:	ECTYPE
Bxz	[[:class:]	[	ECTYPE
Bxz	[[:class:]	c	ECTYPE

# line anchors
# - match_default normal REG_EXTENDED
En	^ab	ab	(0,2)
En	^ab	xxabxx	NOMATCH
En$	^ab	xx\nabzz	(3,5)
En	ab$	ab	(0,2)
En	ab$	abxx	NOMATCH
En$	ab$	ab\nzz	(0,2)
# - match_default match_not_bol match_not_eol normal REG_EXTENDED REG_NOTBOL REG_NOTEOL
Eben	^ab	ab	NOMATCH
Eben	^ab	xxabxx	NOMATCH
Eben$	^ab	xx\nabzz	(3,5)
Eben	ab$	ab	NOMATCH
Eben	ab$	abxx	NOMATCH
Eben$	ab$	ab\nzz	(0,2)

# back references
# - match_default normal REG_EXTENDED
E	a(b)\2c	!	ESUBREG
E	a(b\1)c	!	ESUBREG
E	a(b*)c\1d	abbcbbd	(0,7)(1,3)
E	a(b*)c\1d	abbcbd	NOMATCH
E	a(b*)c\1d	abbcbbbd	NOMATCH
E	^(.)\1	abc	NOMATCH
E	a([bc])\1d	abcdabbd	(4,8)(5,6)
# strictly speaking this is at best ambiguous, at worst wrong, this is what most
# re implimentations will match though.
E	a(([bc])\2)*d	abbccd	(0,6)(3,5)(3,4)

E	a(([bc])\2)*d	abbcbd	NOMATCH
E	a((b)*\2)*d	abbbd	(0,5)(1,4)(2,3)
E	(ab*)[ab]*\1	ababaaa	(0,7)(0,1)
E	(a)\1bcd	aabcd	(0,5)(0,1)
E	(a)\1bc*d	aabcd	(0,5)(0,1)
E	(a)\1bc*d	aabd	(0,4)(0,1)
E	(a)\1bc*d	aabcccd	(0,7)(0,1)
E	(a)\1bc*[ce]d	aabcccd	(0,7)(0,1)
E	^(a)\1b(c)*cd$	aabcccd	(0,7)(0,1)(4,5)

#
# characters by code:
# - match_default normal REG_EXTENDED REG_STARTEND
{E	\101	A	(0,1)		not an ascii implementation
E	\172	z	(0,1)
E	\0172	z	NOMATCH
}
E	NULL	NULL	ENULL
E	NULL	NULL	ENULL

#
# word operators:
{E	\w	a	(0,1)		perl \w not supported
E	\w	z	(0,1)
E	\w	A	(0,1)
E	\w	Z	(0,1)
E	\w	_	(0,1)
E	\w	}	NOMATCH
E	\w	`	NOMATCH
E	\w	[	NOMATCH
E	\w	@	NOMATCH
}
# non-word:
{E	\W	W	NOMATCH		perl \W not supported
E	\W	z	NOMATCH
E	\W	A	NOMATCH
E	\W	Z	NOMATCH
E	\W	_	NOMATCH
E	\W	}	(0,1)
E	\W	`	(0,1)
E	\W	[	(0,1)
E	\W	@	(0,1)

E	\<\w+\W+	 aa  aa  a 	(1,5)
}
# word boundaries
{E	\<a\>	,a,	(1,2)		word boundaries not supported
E	\<*	!	BADRPT
E	\>*	!	BADRPT
E	\<+	!	BADRPT
E	\>+	!	BADRPT
E	\<?	!	BADRPT
E	\>?	!	BADRPT
# word start:
E	\<abcd	  abcd	(2,6)
E	\<ab	cab	NOMATCH
E$	\\<ab	\nab	(1,3)
E	\<tag	::tag	(2,5)
# word end:
E	abc\>	abc	(0,3)
E	abc\>	abcd	NOMATCH
E$	abc\\>	abc\n	(0,3)
E	abc\>	abc::	(0,3)

E	\<abc	abcabc abc\n\nabc	(0,3)
E	\<	  ab a aaa  		(2,2)
}
# word boundary:
{E	\babcd	abcd	(0,4)		perl \b not supported
E	\babcd	:abcd:	(1,5)		perl \b not supported
E	\bab	cab	NOMATCH
E$	\\bab	\nab	(1,3)
E	\btag	::tag	(2,5)
E	abc\b	abc	(0,3)
E	abc\b	abcd	NOMATCH
E$	abc\\b	abc\n	(0,3)
E	abc\b	abc::	(0,3)

E	\b	  abb a abbb 	(0,0)
}
# within word:
{E	\B	ab	(1,1)		perl \B not supported
E	a\Bb	ab	(0,2)
E	a\B	ab	(0,1)
E	a\B	a	NOMATCH
E	a\B	a 	NOMATCH
}

#
# buffer operators:
{E	\`abc	abc	(0,3)		regex++ \' not supported
E$	\\`abc	\nabc	NOMATCH
E	\`abc	 abc	NOMATCH
E	abc\'	abc	(0,3)
E$	abc\\'	abc\n	NOMATCH
E	abc\'	abc 	NOMATCH
}

#
# extra escape sequences:
E$	\a	\a	(0,1)
E$	\f	\f	(0,1)
E$	\n	\n	(0,1)
E$	\r	\r	(0,1)
E$	\t	\t	(0,1)
E$	\v	\v	(0,1)

E$	\\a	\a	(0,1)
E$	\\f	\f	(0,1)
E$	\\n	\n	(0,1)
E$	\\r	\r	(0,1)
E$	\\t	\t	(0,1)
E$	\\v	\v	(0,1)

E	\\a	\a	(0,2)
E	\\f	\f	(0,2)
E	\\n	\n	(0,2)
E	\\r	\r	(0,2)
E	\\t	\t	(0,2)
E	\\v	\v	(0,2)

#
# now follows various complex expressions designed to try and bust the matcher:
E	a(((b)))c	abc	(0,3)(1,2)(1,2)(1,2)
E	a(b|(c))d	abd	(0,3)(1,2)
E	a(b|(c))d	acd	(0,3)(1,2)(1,2)
E	a(b*|c)d	abbd	(0,4)(1,3)
# just gotta have one DFA-buster, of course
E	a[ab]{20}	aaaaabaaaabaaaabaaaab	(0,21)
# and an inline expansion in case somebody gets tricky
E	a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab]	aaaaabaaaabaaaabaaaab	(0,21)
# and in case somebody just slips in an NFA...
E	a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab](wee|week)(knights|night)	aaaaabaaaabaaaabaaaabweeknights	(0,31)(21,24)(24,31)
# one really big one
E	1234567890123456789012345678901234567890123456789012345678901234567890	a1234567890123456789012345678901234567890123456789012345678901234567890b	(1,71)
# fish for problems as brackets go past 8
E	[ab][cd][ef][gh][ij][kl][mn]	xacegikmoq	(1,8)
E	[ab][cd][ef][gh][ij][kl][mn][op]	xacegikmoq	(1,9)
E	[ab][cd][ef][gh][ij][kl][mn][op][qr]	xacegikmoqy	(1,10)
E	[ab][cd][ef][gh][ij][kl][mn][op][q]	xacegikmoqy	(1,10)
# and as parenthesis go past 9:
E	(a)(b)(c)(d)(e)(f)(g)(h)	zabcdefghi	(1,9)(1,2)(2,3)(3,4)(4,5)(5,6)(6,7)(7,8)(8,9)
E	(a)(b)(c)(d)(e)(f)(g)(h)(i)	zabcdefghij	(1,10)(1,2)(2,3)(3,4)(4,5)(5,6)(6,7)(7,8)(8,9)(9,10)
E	(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)	zabcdefghijk	(1,11)(1,2)(2,3)(3,4)(4,5)(5,6)(6,7)(7,8)(8,9)(9,10)(10,11)
E	(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)	zabcdefghijkl	(1,12)(1,2)(2,3)(3,4)(4,5)(5,6)(6,7)(7,8)(8,9)(9,10)(10,11)(11,12)
E	(a)d|(b)c	abc	(1,3)(-1,-1)(1,2)
E	_+((www)|(ftp)|(mailto)):_*	_wwwnocolon _mailto:	(12,20)(13,19)(-1,-1)(-1,-1)(13,19)

# subtleties of matching
E	a(b)?cd		acd	(0,3)
E	a(b)?c\1d	acd	NOMATCH
E	a(b?c)+d	accd	(0,4)(2,3)
E	(wee|week)(knights|night)	weeknights	(0,10)(0,3)(3,10)
E	.*	abc	(0,3)
E	a(b|(c))d	abd	(0,3)(1,2)
E	a(b|(c))d	acd	(0,3)(1,2)(1,2)
E	a(b*|c|e)d	abbd	(0,4)(1,3)
E	a(b*|c|e)d	acd	(0,3)(1,2)
E	a(b*|c|e)d	ad	(0,2)(1,1)
E	a(b?)c	abc	(0,3)(1,2)
E	a(b?)c	ac	(0,2)(1,1)
E	a(b+)c	abc	(0,3)(1,2)
E	a(b+)c	abbbc	(0,5)(1,4)
E	a(b*)c	ac	(0,2)(1,1)
E	(a|ab)(bc([de]+)f|cde)	abcdef	(0,6)(0,1)(1,6)(3,5)
E	a([bc]?)c	abc	(0,3)(1,2)
E	a([bc]?)c	ac	(0,2)(1,1)
E	a([bc]+)c	abc	(0,3)(1,2)
E	a([bc]+)c	abcc	(0,4)(1,3)
E	a([bc]+)bc	abcbc	(0,5)(1,3)
E	a(bb+|b)b	abb	(0,3)(1,2)
E	a(bbb+|bb+|b)b	abb	(0,3)(1,2)
E	a(bbb+|bb+|b)b	abbb	(0,4)(1,3)
E	a(bbb+|bb+|b)bb	abbb	(0,4)(1,2)
E	(.*).*	abcdef	(0,6)(0,6)
E	(a*)*	bc	(0,0)(0,0)

# do we get the right subexpression when it is used more than once?
E	a(b|c)*d	ad	(0,2)
E	a(b|c)*d	abcd	(0,4)(2,3)
E	a(b|c)+d	abd	(0,3)(1,2)
E	a(b|c)+d	abcd	(0,4)(2,3)
E	a(b|c?)+d	ad	(0,2)(1,1)
E	a(b|c?)+d	abcd	(0,4)(2,3)
E	a(b|c){0,0}d	ad	(0,2)
E	a(b|c){0,1}d	ad	(0,2)
E	a(b|c){0,1}d	abd	(0,3)(1,2)
E	a(b|c){0,2}d	ad	(0,2)
E	a(b|c){0,2}d	abcd	(0,4)(2,3)
E	a(b|c){0,}d	ad	(0,2)
E	a(b|c){0,}d	abcd	(0,4)(2,3)
E	a(b|c){1,1}d	abd	(0,3)(1,2)
E	a(b|c){1,2}d	abd	(0,3)(1,2)
E	a(b|c){1,2}d	abcd	(0,4)(2,3)
E	a(b|c){1,}d	abd	(0,3)(1,2)
E	a(b|c){1,}d	abcd	(0,4)(2,3)
E	a(b|c){2,2}d	acbd	(0,4)(2,3)
E	a(b|c){2,2}d	abcd	(0,4)(2,3)
E	a(b|c){2,4}d	abcd	(0,4)(2,3)
E	a(b|c){2,4}d	abcbd	(0,5)(3,4)
E	a(b|c){2,4}d	abcbcd	(0,6)(4,5)
E	a(b|c){2,}d	abcd	(0,4)(2,3)
E	a(b|c){2,}d	abcbd	(0,5)(3,4)
E	a(b+|((c)*))+d	abd	(0,3)(1,2)
E	a(b+|((c)*))+d	abcd	(0,4)(2,3)(2,3)(2,3)

# - match_default normal REG_EXTENDED REG_STARTEND REG_NOSPEC literal
L	\**?/{}	\**?/{}	(0,7)

# - match_default normal REG_EXTENDED REG_NO_POSIX_TEST
# try to match C++ syntax elements:
# line comment:
Exz$	//[^\n]*	++i //here is a line comment\n	(4,28)
# block comment:
Exz	/\*([^*]|\*+[^*/])*\*+/	/* here is a block comment */	(0,29)(26,27)
Exz	/\*([^*]|\*+[^*/])*\*+/	/**/	(0,4)
Exz	/\*([^*]|\*+[^*/])*\*+/	/***/	(0,5)
Exz	/\*([^*]|\*+[^*/])*\*+/	/****/	(0,6)
Exz	/\*([^*]|\*+[^*/])*\*+/	/*****/	(0,7)
Exz	/\*([^*]|\*+[^*/])*\*+/	/*****/*/	(0,7)
# preprossor directives:
E$	^[[:blank:]]*#([^\n]*\\[[:space:]]+)*[^\n]*	#define some_symbol	(0,19)
E$	^[[:blank:]]*#([^\n]*\\[[:space:]]+)*[^\n]*	#define some_symbol(x) #x	(0,25)
E$	^[[:blank:]]*#([^\n]*\\[[:space:]]+)*[^\n]*	#define some_symbol(x) \\  \r\n  foo();\\\r\n   printf(#x);	(0,27)
# literals:
E	((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)?	0xFF	(0,4)(0,4)(0,4)
E	((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)?	35	(0,2)(0,2)(-1,-1)(0,2)
E	((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)?	0xFFu	(0,5)(0,4)(0,4)
E	((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)?	0xFFL	(0,5)(0,4)(0,4)(-1,-1)(4,5)
E	((0x[[:xdigit:]]+)|([[:digit:]]+))u?((int(8|16|32|64))|L)?	0xFFFFFFFFFFFFFFFFuint64	(0,24)(0,18)(0,18)(-1,-1)(19,24)(19,24)(22,24)
# strings:
#E	'([^\\']|\\.)*'	'\\x3A'	(0,6)(4,5)
E	'([^\\']|\\.)*'	'\\''	(0,4)(1,3)
E$	'([^']|\\.)*'	'\n'	(0,3)(1,2)

# now try and test some unicode specific characters:
# - match_default normal REG_EXTENDED REG_UNICODE_ONLY
E	[[:unicode:]]+	a\0300\0400z	ECTYPE

# finally try some case insensitive matches:
# - match_default normal REG_EXTENDED REG_ICASE
# upper and lower have no meaning here so they fail, however these
# may compile with other libraries...
Ei	[[:lower:]]+	Ab	(0,2)
Ei	[[:lower:]]+	aB	(0,2)
Ei	[[:upper:]]+	Ab	(0,2)
Ei	[[:upper:]]+	aB	(0,2)
Ei	0123456789@abcdefghijklmnopqrstuvwxyz_`ABCDEFGHIJKLMNOPQRSTUVWXYZ	0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz	(0,65)
Ei	0123456789@abcdefghijklmnopqrstuvwxyz\^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ	0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz	(0,66)
Ei	0123456789@abcdefghijklmnopqrstuvwxyz\[\\\]\^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ\{\|\}	0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}	(0,72)

# known and suspected bugs:
# - match_default normal REG_EXTENDED
E	\(	(	(0,1)
E	\)	)	(0,1)
E	\$	$	(0,1)
E	\^	^	(0,1)
E	\.	.	(0,1)
E	\*	*	(0,1)
E	\+	+	(0,1)
E	\?	?	(0,1)
E	\[	[	(0,1)
E	\]	]	(0,1)
E	\|	|	(0,1)
E	\\	\\	(0,1)
E	#	#	(0,1)
E	\#	#	BADESC
Ex	\#	#	(0,1)
E	a-	a-	(0,2)
E	\-	-	BADESC
Ex	\-	-	(0,1)
E	\{	{	(0,1)
E	\}	}	(0,1)
E	0	0	(0,1)
E	1	1	(0,1)
E	9	9	(0,1)
E	b	b	(0,1)
E	B	B	(0,1)
E	<	<	(0,1)
E	>	>	(0,1)
E	w	w	(0,1)
E	W	W	(0,1)
E	`	`	(0,1)
E	'	'	(0,1)
E$	\n	\n	(0,1)
E	,	,	(0,1)
E	a	a	(0,1)
E	f	f	(0,1)
E	n	n	(0,1)
E	r	r	(0,1)
E	t	t	(0,1)
E	v	v	(0,1)
E	c	c	(0,1)
E	x	x	(0,1)
E	:	:	(0,1)
E	(\.[[:alnum:]]+){2}	w.a.b 	(1,5)(3,5)

# - match_default normal REG_EXTENDED REG_ICASE
Ei	a	A	(0,1)
Ei	A	a	(0,1)
Ei	[abc]+	abcABC	(0,6)
Ei	[ABC]+	abcABC	(0,6)
Ei	[a-z]+	abcABC	(0,6)
Ei	[A-Z]+	abzANZ	(0,6)
Ei	[a-Z]+	abzABZ	ERANGE
Eix	[a-Z]+	abzABZ	NOMATCH
Ei	[A-z]+	abzABZ	(0,6)
Ei	[[:lower:]]+	abyzABYZ	(0,8)
Ei	[[:upper:]]+	abzABZ	(0,6)
Ei	[[:word:]]+	abcZZZ	(0,6)
Ei	[[:alpha:]]+	abyzABYZ	(0,8)
Ei	[[:alnum:]]+	09abyzABYZ	(0,10)

# updated tests for version 2:
# - match_default normal REG_EXTENDED
E$	\x41	A	(0,1)
E$	\xff	\xFF	(0,1)
E$	\xFF	\xff	(0,1)
# - match_default normal REG_EXTENDED REG_NO_POSIX_TEST
{Exz$	\\c[	\e	(0,1)			perl \c not supported
# - match_default normal REG_EXTENDED
E$	\\cA	\001	(0,1)
E$	\\cz	\032	(0,1)
E$	\\c=	!	NOMATCH
E$	\\c?	!	NOMATCH
}
E	=:	=:	(0,2)

# word start:
E	[[:<:]]abcd	  abcd	(2,6)
E	[[:<:]]ab	cab	NOMATCH
E$	[[:<:]]ab	\nab	(1,3)
E	[[:<:]]tag	::tag	(2,5)
#word end:
E	abc[[:>:]]	abc	(0,3)
E	abc[[:>:]]	abcd	NOMATCH
E$	abc[[:>:]]	abc\n	(0,3)
E	abc[[:>:]]	abc::	(0,3)

# collating elements and rewritten set code:
# - match_default normal REG_EXTENDED REG_STARTEND
{E	[[.zero.]]	0	(0,1)		[[.element-name.]] not supported
E	[[.one.]]	1	(0,1)
E	[[.two.]]	2	(0,1)
E	[[.three.]]	3	(0,1)
E	[[.a.]]	baa	(1,2)
#E	[[.NUL.]]	NULL	(0,1)
E	[[.right-curly-bracket.]]	}	(0,1)
E	[[=right-curly-bracket=]]	}	(0,1)
}
E	[[:<:]z]	!	ECTYPE
E	[a[:>:]]	!	ECTYPE
E	[[=a=]]	a	(0,1)
# - match_default normal REG_EXTENDED REG_STARTEND REG_ICASE
Ei	[[.A.]]	A	(0,1)
Ei	[[.A.]]	a	(0,1)
Ei	[[.A.]-b]+	AaBb	(0,4)
Ei	[A-[.b.]]+	AaBb	(0,4)
Ei	[[.a.]-B]+	AaBb	ERANGE
Eix	[[.a.]-B]+	AaBb	NOMATCH
Ei	[a-[.B.]]+	AaBb	ERANGE
Eix	[a-[.B.]]+	AaBb	NOMATCH
# - match_default normal REG_EXTENDED REG_NO_POSIX_TEST
Exz$	[\x61]	a	(0,1)
Exz$	[\x61-c]+	abcd	(0,3)
Exz$	[a-\x63]+	abcd	(0,3)
# - match_default normal REG_EXTENDED REG_STARTEND
E	[[.a.]-c]+	abcd	(0,3)
E	[a-[.c.]]+	abcd	(0,3)
E	[[:alpha:]-a]	!	ERANGE
E	[a-[:alpha:]]	!	NOMATCH

# try mutli-character ligatures:
{E	[[.ae.]]	ae	(0,2)		[[.ligature.]] not supported
E	[[.ae.]]	aE	NOMATCH
E	[[.AE.]]	AE	(0,2)
E	[[.Ae.]]	Ae	(0,2)
E	[[.ae.]-b]	a	NOMATCH
E	[[.ae.]-b]	b	(0,1)
E	[[.ae.]-b]	ae	(0,2)
E	[a-[.ae.]]	a	(0,1)
E	[a-[.ae.]]	b	NOMATCH
E	[a-[.ae.]]	ae	(0,2)
# - match_default normal REG_EXTENDED REG_STARTEND REG_ICASE
Ei	[[.ae.]]	AE	(0,2)
Ei	[[.ae.]]	Ae	(0,2)
Ei	[[.AE.]]	Ae	(0,2)
Ei	[[.Ae.]]	aE	(0,2)
Ei	[[.AE.]-B]	a	NOMATCH
Ei	[[.Ae.]-b]	b	(0,1)
Ei	[[.Ae.]-b]	B	(0,1)
Ei	[[.ae.]-b]	AE	(0,2)
}

# - match_default normal REG_EXTENDED REG_STARTEND
#extended perl style escape sequences:
{E$	\\e	\033	(0,1)		perl \e not supported
}
{E$	\\x1b	\033	(0,1)		perl \x not supported
E$	\\x{1b}	\033	(0,1)
E	\x{}	!	NOMATCH
E	\x{	!	NOMATCH
E	\x}	!	NOMATCH
E	\x	!	NOMATCH
E	\x{yy	!	NOMATCH
E	\x{1b	!	NOMATCH
}

# - match_default normal REG_EXTENDED REG_STARTEND REG_NO_POSIX_TEST
{Exz	\l+	ABabcAB	(2,5)		regex++ \l not supported
Exz	[\l]+	ABabcAB	(2,5)
Exz	[a-\l]	!	NOMATCH
E	[a-\l]	!	ERANGE
E	[\l-a]	!	ERANGE
Exz	[\L]	!	(0,1)
Exz	\L+	abABCab	(2,5)
Exz	\L+	ab,.-ab	(2,5)
Exz	\u+	abABCab	(2,5)
Exz	[\u]+	abABCab	(2,5)
Exz	[\U]	!	(0,1)
Exz	\U+	ABabcAB	(2,5)
}
{Exz	\d+	ab012ab	(2,5)		perl \d not supported
Exz	[a-\d]	!	NOMATCH
E	[a-\d]	!	ERANGE
E	[\d-a]	!	ERANGE
Exz	[\d]+	ab012ad	(6,7)
Evxz	[\d]+	ab012ad	(2,5)
Exz	[\D]	!D	(1,2)
Evxz	[\D]	!D	(0,1)
Exz	\D+	01abc01	(2,5)
Exz	\s+	ab   ab	(2,5)
Exz	[\s]+	as   as	(1,2)
Evxz	[\s]+	as   as	(2,5)
Exz	[\S]	!S	(1,2)
Evxz	[\S]	!S	(0,1)
Exz	\S+	  abc  	(2,5)
}
# - match_default normal REG_EXTENDED REG_STARTEND
{E	\Qabc	abc	(0,3)		regex++ \Q not supported
E	\Qabc\E	abcd	(0,3)
E	\Qabc\Ed	abcde	(0,4)
E	\Q+*?\\E	+*?\\	(0,4)
}

{E	\C+	abcde	(0,5)		regex++ \C not supported
}
{E	\X+	abcde	(0,5)		regex++ \X not supported

# - match_default normal REG_EXTENDED REG_STARTEND REG_UNICODE_ONLY
E	\X+	a\768\769	(0,3)
E	\X+	\2309\2307	(0,2)
E	\X+	\2489\2494	(0,2)
}

# - match_default normal REG_EXTENDED REG_STARTEND
{E	\Aabc	abc	(0,3)		regex++ \A not supported
E	\Aabc	aabc	NOMATCH
E	a\Aab	abc	NOMATCH
E	abc\z	abc	(0,3)
E	abc\z	abcd	NOMATCH
E$	abc\\z	abc\n\n	NOMATCH
E$	abc\\Z	abc\n	(0,3)
E$	abc\\Z	abc\n\n	(0,3)
E	abc\Z	abc	(0,3)
E	\Aabc	abc   abc	(0,3)
}

{E	\Gabc	abc	(0,3)		perl \G not supported
E	\G\w+\W+	abc  abc a cbbb   	(0,5)
E	\Ga+b+	aaababb  abb	(0,4)
E	\Gabc	dabcd	NOMATCH
E	a\Gbc	abc	NOMATCH
}

#
# now test grep,
# basically check all our restart types - line, word, etc
# checking each one for null and non-null matches.
#
# - match_default normal REG_EXTENDED REG_STARTEND REG_GREP
E	a	 a a a aa	(1,2)
E	a+b+	aabaabbb ab	(0,3)
E	a(b*|c|e)d	adabbdacd	(0,2)(1,1)
E$	a	\na\na\na\naa	(1,2)

E$	^	   \n\n  \n\n\n	(0,0)
E$	^ab	ab  \nab  ab\n	(0,2)
E$	^[^\n]*\n	   \n  \n\n  \n	(0,4)

E	abc	abc	(0,3)
E	abc	 abc abcabc 	(1,4)
E$	\n\n	 \n\n\n       \n      \n\n\n\n  	(1,3)

E$	$	   \n\n  \n\n\n	(10,10)
En$	$	   \n\n  \n\n\n	(3,3)

# - match_default normal REG_EXTENDED REG_STARTEND REG_GREP REG_ICASE
Ei	A	 a a a aa	(1,2)
Ei	A+B+	aabaabbb ab	(0,3)
Ei	A(B*|c|e)D	adabbdacd	(0,2)(1,1)
Ei$	A	\na\na\na\naa	(1,2)

Ei$	^aB	Ab  \nab  Ab\n	(0,2)
Ei$	\\<abc	Abcabc aBc\n\nabc	(0,3)

Ei	ABC	abc	(0,3)
Ei	abc	 ABC ABCABC 	(1,4)


#
# now test merge,
#
# - match_default normal REG_EXTENDED REG_STARTEND REG_MERGE format_no_copy
# start by testing subs:
#	a+	...aaa,,,	($`,...)
#	a+	...aaa,,,	($',,,,)
#	a+	...aaa,,,	($&,aaa)
#	a+	...aaa,,,	($0,aaa)
#	a+	...aaa,,,	($1,NULL)
#	a+	...aaa,,,	($15,NULL)
#	(a+)b+	...aaabbb,,,	($1,aaa)
#	[[:digit:]]*	123ab	(<$0>,<123><><><>)
#	[[:digit:]]*	123ab1	(<$0>,<123><><><1>)

# and now escapes:
#	a+	...aaa,,,	($x,$x)
#	a+	...aaa,,,	(\a,\a)
#	a+	...aaa,,,	(\f,\f)
#	a+	...aaa,,,	(\n,\n)
#	a+	...aaa,,,	(\r,\r)
#	a+	...aaa,,,	(\t,\t)
#	a+	...aaa,,,	(\v,\v)

#	a+	...aaa,,,	(\x21,!)
#	a+	...aaa,,,	(\x{21},!)
#	a+	...aaa,,,	(\c@,\0)
#	a+	...aaa,,,	(\e,\27)
#	a+	...aaa,,,	(\0101,A)
#	a+	...aaa,,,	((\0101),A)

# - match_default normal REG_EXTENDED REG_STARTEND REG_MERGE format_sed format_no_copy
#	(a+)(b+)	...aabb,,	(\0,aabb)
#	(a+)(b+)	...aabb,,	(\1,aa)
#	(a+)(b+)	...aabb,,	(\2,bb)
#	(a+)(b+)	...aabb,,	(&,aabb)
#	(a+)(b+)	...aabb,,	($,$)
#	(a+)(b+)	...aabb,,	($1,$1)
#	(a+)(b+)	...aabb,,	(()?:,()?:)
#	(a+)(b+)	...aabb,,	(\\,\\)
#	(a+)(b+)	...aabb,,	(\&,&)


# - match_default normal REG_EXTENDED REG_STARTEND REG_MERGE format_perl format_no_copy
#	(a+)(b+)	...aabb,,	($0,aabb)
#	(a+)(b+)	...aabb,,	($1,aa)
#	(a+)(b+)	...aabb,,	($2,bb)
#	(a+)(b+)	...aabb,,	($&,aabb)
#	(a+)(b+)	...aabb,,	(&,&)
#	(a+)(b+)	...aabb,,	(\0,\0)
#	(a+)(b+)	...aabb,,	(()?:,()?:)

# - match_default normal REG_EXTENDED REG_STARTEND REG_MERGE
# move to copying unmatched data:
#	a+	...aaa,,,	(bbb,...bbb,,,)
#	a+(b+)	...aaabb,,,	($1,...bb,,,)
#	a+(b+)	...aaabb,,,ab*abbb?	($1,...bb,,,b*bbb?)

#	(a+)|(b+)	...aaabb,,,ab*abbb?	((?1A)(?2B),...AB,,,AB*AB?)
#	(a+)|(b+)	...aaabb,,,ab*abbb?	(?1A:B,...AB,,,AB*AB?)
#	(a+)|(b+)	...aaabb,,,ab*abbb?	((?1A:B)C,...ACBC,,,ACBC*ACBC?)
#	(a+)|(b+)	...aaabb,,,ab*abbb?	(?1:B,...B,,,B*B?)

#
# changes to newline handling with 2.11:
#

# - match_default normal REG_EXTENDED REG_STARTEND REG_GREP

E$	^.	  \n  \r\n  	(0,1)
E$	.$	  \n  \r\n  	(8,9)
En$	.$	  \n  \r\n  	(1,2)

# - match_default normal REG_EXTENDED REG_STARTEND REG_GREP REG_UNICODE_ONLY
#E	^.	\8232 \8233  	(0,1)
#E	.$	\8232 \8233  	(1,2)

#
# non-greedy repeats added 21/04/00
# - match_default normal REG_EXTENDED
E	a{1,3}{1}	!	BADRPT
{E	a*?	aa	(0,0)		non-greedy repeats not supported
E	a**	aaa	(0,3)
E	a??	aa	(0,0)
E	a++	!	BADRPT
E	a+?	aa	(0,1)
E	a{1,3}?	aaa	(0,1)
E	\w+?w	...ccccccwcccccw	(3,10)
E	\W+\w+?w	...ccccccwcccccw	(0,10)
E	abc|\w+?	abd	(0,1)
E	abc|\w+?	abcd	(0,3)
E	<\s*tag[^>]*>(.*?)<\s*/tag\s*>	 <tag>here is some text</tag> <tag></tag>	(1,29)(6,23)
E	<\s*tag[^>]*>(.*?)<\s*/tag\s*>	 < tag attr=\"something\">here is some text< /tag > <tag></tag>	(1,51)(26,43)
}

#
# non-marking parenthesis added 25/04/00
# - match_default normal REG_EXTENDED
{E	(?:abc)+	xxabcabcxx	(2,8)		non-marking parens not supported
E	(?:a+)(b+)	xaaabbbx	(1,7)(4,7)
E	(a+)(?:b+)	xaaabbba	(1,7)(1,4)
E	(?:(a+)b+)	xaaabbba	(1,7)(1,4)
E	(?:a+(b+))	xaaabbba	(1,7)(4,7)
E	a+(?#b+)b+	xaaabbba	(1,7)
}

#
# try some partial matches:
# - match_partial match_default normal REG_EXTENDED REG_NO_POSIX_TEST
Exz	(xyz)(.*)abc	xyzaaab	NOMATCH
Exz	(xyz)(.*)abc	xyz	NOMATCH
Exz	(xyz)(.*)abc	xy	NOMATCH