# regular expression test set

# Lines are at least three fields, separated by one or more tabs.  "" stands

# for an empty field.  First field is an RE.  Second field is flags.  If

# C flag given, regcomp() is expected to fail, and the third field is the

# error name (minus the leading REG_).

#

# Otherwise it is expected to succeed, and the third field is the string to

# try matching it against.  If there is no fourth field, the match is

# expected to fail.  If there is a fourth field, it is the substring that

# the RE is expected to match.  If there is a fifth field, it is a comma-

# separated list of what the subexpressions should match, with - indicating

# no match for that one.  In both the fourth and fifth fields, a (sub)field

# starting with @ indicates that the (sub)expression is expected to match

# a null string followed by the stuff after the @; this provides a way to

# test where null strings match.  The character `N' in REs and strings

# is newline, `S' is space, `T' is tab, `Z' is NUL.

#

# The full list of flags:

#	-	placeholder, does nothing

#	b	RE is a BRE, not an ERE

#	&	try it as both an ERE and a BRE

#	C	regcomp() error expected, third field is error name

#	i	REG_ICASE

#	m	("mundane") REG_NOSPEC

#	s	REG_NOSUB (not really testable)

#	n	REG_NEWLINE

#	^	REG_NOTBOL

#	$	REG_NOTEOL

#	#	REG_STARTEND (see below)

#	p	REG_PEND

#

# For REG_STARTEND, the start/end offsets are those of the substring

# enclosed in ().

# basics

a		&	a	a

abc		&	abc	abc

abc|de		-	abc	abc

a|b|c		-	abc	a

# parentheses and perversions thereof

a(b)c		-	abc	abc

a\(b\)c		b	abc	abc

a(		C	EPAREN

a(		b	a(	a(

a\(		-	a(	a(

a\(		bC	EPAREN

a\(b		bC	EPAREN

a(b		C	EPAREN

a(b		b	a(b	a(b

# gag me with a right parenthesis -- 1003.2 goofed here (my fault, partly)

a)		-	a)	a)

)		-	)	)

# end gagging (in a just world, those *should* give EPAREN)

a)		b	a)	a)

a\)		bC	EPAREN

\)		bC	EPAREN

a()b		-	ab	ab

a\(\)b		b	ab	ab

# anchoring and REG_NEWLINE

^abc$		&	abc	abc

a^b		-	a^b

a^b		b	a^b	a^b

a$b		-	a$b

a$b		b	a$b	a$b

^		&	abc	@abc

$		&	abc	@

^$		&	""	@

$^		-	""	@

\($\)\(^\)	b	""	@

# stop retching, those are legitimate (although disgusting)

^^		-	""	@

$$		-	""	@

b$		&	abNc

b$		&n	abNc	b

^b$		&	aNbNc

^b$		&n	aNbNc	b

^$		&n	aNNb	@Nb

^$		n	abc

^$		n	abcN	@

$^		n	aNNb	@Nb

\($\)\(^\)	bn	aNNb	@Nb

^^		n^	aNNb	@Nb

$$		n	aNNb	@NN

^a		^	a

a$		$	a

^a		^n	aNb

^b		^n	aNb	b

a$		$n	bNa

b$		$n	bNa	b

a*(^b$)c*	-	b	b

a*\(^b$\)c*	b	b	b

# certain syntax errors and non-errors

|		C	EMPTY

|		b	|	|

*		C	BADRPT

*		b	*	*

+		C	BADRPT

?		C	BADRPT

""		&C	EMPTY

()		-	abc	@abc

\(\)		b	abc	@abc

a||b		C	EMPTY

|ab		C	EMPTY

ab|		C	EMPTY

(|a)b		C	EMPTY

(a|)b		C	EMPTY

(*a)		C	BADRPT

(+a)		C	BADRPT

(?a)		C	BADRPT

({1}a)		C	BADRPT

\(\{1\}a\)	bC	BADRPT

(a|*b)		C	BADRPT

(a|+b)		C	BADRPT

(a|?b)		C	BADRPT

(a|{1}b)	C	BADRPT

^*		C	BADRPT

^*		b	*	*

^+		C	BADRPT

^?		C	BADRPT

^{1}		C	BADRPT

^\{1\}		bC	BADRPT

# metacharacters, backslashes

a.c		&	abc	abc

a[bc]d		&	abd	abd

a\*c		&	a*c	a*c

a\\b		&	a\b	a\b

a\\\*b		&	a\*b	a\*b

# The following test is wrong.  Using \b in an BRE or ERE is undefined.

# a\bc		&	abc	abc

a\		&C	EESCAPE

a\\bc		&	a\bc	a\bc

\{		bC	BADRPT

a\[b		&	a[b	a[b

a[b		&C	EBRACK

# trailing $ is a peculiar special case for the BRE code

a$		&	a	a

a$		&	a$

a\$		&	a

a\$		&	a$	a$

a\\$		&	a

a\\$		&	a$

a\\$		&	a\$

a\\$		&	a\	a\

# back references, ugh

a\(b\)\2c	bC	ESUBREG

a\(b\1\)c	bC	ESUBREG

a\(b*\)c\1d	b	abbcbbd	abbcbbd	bb

a\(b*\)c\1d	b	abbcbd

a\(b*\)c\1d	b	abbcbbbd

^\(.\)\1	b	abc

a\([bc]\)\1d	b	abcdabbd	abbd	b

a\(\([bc]\)\2\)*d	b	abbccd	abbccd

a\(\([bc]\)\2\)*d	b	abbcbd

# actually, this next one probably ought to fail, but the spec is unclear

a\(\(b\)*\2\)*d		b	abbbd	abbbd

# here is a case that no NFA implementation does right

\(ab*\)[ab]*\1	b	ababaaa	ababaaa	a

# check out normal matching in the presence of back refs

\(a\)\1bcd	b	aabcd	aabcd

\(a\)\1bc*d	b	aabcd	aabcd

\(a\)\1bc*d	b	aabd	aabd

\(a\)\1bc*d	b	aabcccd	aabcccd

\(a\)\1bc*[ce]d	b	aabcccd	aabcccd

^\(a\)\1b\(c\)*cd$	b	aabcccd	aabcccd

# ordinary repetitions

ab*c		&	abc	abc

ab+c		-	abc	abc

ab?c		-	abc	abc

a\(*\)b		b	a*b	a*b

a\(**\)b	b	ab	ab

a\(***\)b	bC	BADRPT

*a		b	*a	*a

**a		b	a	a

***a		bC	BADRPT

# the dreaded bounded repetitions

# The following two tests are not correct:

#{		&	{	{

#{abc		&	{abc	{abc

# '{' is always a special char outside bracket expressions.  So test ony BRE:

{		b	{	{

{abc		b	{abc	{abc

{1		C	BADRPT

{1}		C	BADRPT

# Same reason as for the two tests above:

#a{b		&	a{b	a{b

a{b		b	a{b	a{b

a{1}b		-	ab	ab

a\{1\}b		b	ab	ab

a{1,}b		-	ab	ab

a\{1,\}b	b	ab	ab

a{1,2}b		-	aab	aab

a\{1,2\}b	b	aab	aab

a{1		C	EBRACE

a\{1		bC	EBRACE

a{1a		C	EBRACE

a\{1a		bC	EBRACE

a{1a}		C	BADBR

a\{1a\}		bC	BADBR

# These four tests checks for undefined behavior.  Our implementation does

# something different.

#a{,2}		-	a{,2}	a{,2}

#a\{,2\}		bC	BADBR

#a{,}		-	a{,}	a{,}

#a\{,\}		bC	BADBR

a{1,x}		C	BADBR

a\{1,x\}	bC	BADBR

a{1,x		C	EBRACE

a\{1,x		bC	EBRACE

# These two tests probably fails due to an arbitrary limit on the number of

# repetitions in the other implementation.

#a{300}		C	BADBR

#a\{300\}	bC	BADBR

a{1,0}		C	BADBR

a\{1,0\}	bC	BADBR

ab{0,0}c	-	abcac	ac

ab\{0,0\}c	b	abcac	ac

ab{0,1}c	-	abcac	abc

ab\{0,1\}c	b	abcac	abc

ab{0,3}c	-	abbcac	abbc

ab\{0,3\}c	b	abbcac	abbc

ab{1,1}c	-	acabc	abc

ab\{1,1\}c	b	acabc	abc

ab{1,3}c	-	acabc	abc

ab\{1,3\}c	b	acabc	abc

ab{2,2}c	-	abcabbc	abbc

ab\{2,2\}c	b	abcabbc	abbc

ab{2,4}c	-	abcabbc	abbc

ab\{2,4\}c	b	abcabbc	abbc

((a{1,10}){1,10}){1,10}	-	a	a	a,a

# multiple repetitions

# Wow, there is serious disconnect here.  The ERE grammar is like this:

# ERE_expression : one_char_or_coll_elem_ERE

#                | '^'

#                | '$'

#                | '(' extended_reg_exp ')'

#                | ERE_expression ERE_dupl_symbol

#                ;

# where ERE_dupl_symbol is any of the repetition methods.  It is clear from

# this that consecutive repetition is OK.  On top of this, the one test not

# marked as failing must fail.  For BREs the situation is different, so we

# use the four tests.

#a**		&C	BADRPT

a**		bC	BADRPT

#a++		C	BADRPT

#a??		C	BADRPT

#a*+		C	BADRPT

#a*?		C	BADRPT

#a+*		C	BADRPT

#a+?		C	BADRPT

#a?*		C	BADRPT

#a?+		C	BADRPT

#a{1}{1}		C	BADRPT

#a*{1}		C	BADRPT

#a+{1}		C	BADRPT

#a?{1}		C	BADRPT

#a{1}*		C	BADRPT

#a{1}+		C	BADRPT

#a{1}?		C	BADRPT

#a*{b}		-	a{b}	a{b}

a\{1\}\{1\}	bC	BADRPT

a*\{1\}		bC	BADRPT

a\{1\}*		bC	BADRPT

# brackets, and numerous perversions thereof

a[b]c		&	abc	abc

a[ab]c		&	abc	abc

a[^ab]c		&	adc	adc

a[]b]c		&	a]c	a]c

a[[b]c		&	a[c	a[c

a[-b]c		&	a-c	a-c

a[^]b]c		&	adc	adc

a[^-b]c		&	adc	adc

a[b-]c		&	a-c	a-c

a[b		&C	EBRACK

a[]		&C	EBRACK

a[1-3]c		&	a2c	a2c

a[3-1]c		&C	ERANGE

a[1-3-5]c	&C	ERANGE

a[[.-.]--]c	&	a-c	a-c

# I don't thing the error value should be ERANGE since a[1-] would be

# valid, too.  Expect EBRACK.

#a[1-		&C	ERANGE

a[1-		&C	EBRACK

a[[.		&C	EBRACK

a[[.x		&C	EBRACK

a[[.x.		&C	EBRACK

a[[.x.]		&C	EBRACK

a[[.x.]]	&	ax	ax

a[[.x,.]]	&C	ECOLLATE

# This test is invalid.  "one" is no collating symbol in any standardized

# locale.

# a[[.one.]]b	&	a1b	a1b

a[[.notdef.]]b	&C	ECOLLATE

a[[.].]]b	&	a]b	a]b

a[[:alpha:]]c	&	abc	abc

a[[:notdef:]]c	&C	ECTYPE

a[[:		&C	EBRACK

a[[:alpha	&C	EBRACK

a[[:alpha:]	&C	EBRACK

a[[:alpha,:]	&C	ECTYPE

a[[:]:]]b	&C	ECTYPE

a[[:-:]]b	&C	ECTYPE

a[[:alph:]]	&C	ECTYPE

a[[:alphabet:]]	&C	ECTYPE

[[:alnum:]]+	-	-%@a0X-	a0X

[[:alpha:]]+	-	-%@aX0-	aX

[[:blank:]]+	-	aSSTb	SST

[[:cntrl:]]+	-	aNTb	NT

[[:digit:]]+	-	a019b	019

[[:graph:]]+	-	Sa%bS	a%b

[[:lower:]]+	-	AabC	ab

[[:print:]]+	-	NaSbN	aSb

[[:punct:]]+	-	S%-&T	%-&

[[:space:]]+	-	aSNTb	SNT

[[:upper:]]+	-	aBCd	BC

[[:xdigit:]]+	-	p0f3Cq	0f3C

a[[=b=]]c	&	abc	abc

a[[=		&C	EBRACK

a[[=b		&C	EBRACK

a[[=b=		&C	EBRACK

a[[=b=]		&C	EBRACK

a[[=b,=]]	&C	ECOLLATE

# This test is invalid.  "one" is no collating symbol in any standardized

# locale.

#a[[=one=]]b	&	a1b	a1b

# complexities

a(((b)))c	-	abc	abc

a(b|(c))d	-	abd	abd

a(b*|c)d	-	abbd	abbd

# just gotta have one DFA-buster, of course

a[ab]{20}	-	aaaaabaaaabaaaabaaaab	aaaaabaaaabaaaabaaaab

# and an inline expansion in case somebody gets tricky

a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab]	-	aaaaabaaaabaaaabaaaab	aaaaabaaaabaaaabaaaab

# and in case somebody just slips in an NFA...

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	aaaaabaaaabaaaabaaaabweeknights

# fish for anomalies as the number of states passes 32

12345678901234567890123456789	-	a12345678901234567890123456789b	12345678901234567890123456789

123456789012345678901234567890	-	a123456789012345678901234567890b	123456789012345678901234567890

1234567890123456789012345678901	-	a1234567890123456789012345678901b	1234567890123456789012345678901

12345678901234567890123456789012	-	a12345678901234567890123456789012b	12345678901234567890123456789012

123456789012345678901234567890123	-	a123456789012345678901234567890123b	123456789012345678901234567890123

# and one really big one, beyond any plausible word width

1234567890123456789012345678901234567890123456789012345678901234567890	-	a1234567890123456789012345678901234567890123456789012345678901234567890b	1234567890123456789012345678901234567890123456789012345678901234567890

# fish for problems as brackets go past 8

[ab][cd][ef][gh][ij][kl][mn]	-	xacegikmoq	acegikm

[ab][cd][ef][gh][ij][kl][mn][op]	-	xacegikmoq	acegikmo

[ab][cd][ef][gh][ij][kl][mn][op][qr]	-	xacegikmoqy	acegikmoq

[ab][cd][ef][gh][ij][kl][mn][op][q]	-	xacegikmoqy	acegikmoq

# subtleties of matching

abc		&	xabcy	abc

a\(b\)?c\1d	b	acd

aBc		i	Abc	Abc

a[Bc]*d		i	abBCcd	abBCcd

0[[:upper:]]1	&i	0a1	0a1

0[[:lower:]]1	&i	0A1	0A1

a[^b]c		&i	abc

a[^b]c		&i	aBc

a[^b]c		&i	adc	adc

[a]b[c]		-	abc	abc

[a]b[a]		-	aba	aba

[abc]b[abc]	-	abc	abc

[abc]b[abd]	-	abd	abd

a(b?c)+d	-	accd	accd

(wee|week)(knights|night)	-	weeknights	weeknights

(we|wee|week|frob)(knights|night|day)	-	weeknights	weeknights

a[bc]d		-	xyzaaabcaababdacd	abd

a[ab]c		-	aaabc	abc

abc		s	abc	abc

()		s	abc	@abc

a*		&	b	@b

# Let's have some fun -- try to match a C comment.

# first the obvious, which looks okay at first glance...

/\*.*\*/	-	/*x*/	/*x*/

# but...

/\*.*\*/	-	/*x*/y/*z*/	/*x*/y/*z*/

# okay, we must not match */ inside; try to do that...

/\*([^*]|\*[^/])*\*/	-	/*x*/	/*x*/

/\*([^*]|\*[^/])*\*/	-	/*x*/y/*z*/	/*x*/

# but...

/\*([^*]|\*[^/])*\*/	-	/*x**/y/*z*/	/*x**/y/*z*/

# and a still fancier version, which does it right (I think)...

/\*([^*]|\*+[^*/])*\*+/	-	/*x*/	/*x*/

/\*([^*]|\*+[^*/])*\*+/	-	/*x*/y/*z*/	/*x*/

/\*([^*]|\*+[^*/])*\*+/	-	/*x**/y/*z*/	/*x**/

/\*([^*]|\*+[^*/])*\*+/	-	/*x****/y/*z*/	/*x****/

/\*([^*]|\*+[^*/])*\*+/	-	/*x**x*/y/*z*/	/*x**x*/

/\*([^*]|\*+[^*/])*\*+/	-	/*x***x/y/*z*/	/*x***x/y/*z*/

# subexpressions

.*		-	abc	abc	-

a(b)(c)d	-	abcd	abcd	b,c

a(((b)))c	-	abc	abc	b,b,b

a(b|(c))d	-	abd	abd	b,-

a(b*|c|e)d	-	abbd	abbd	bb

a(b*|c|e)d	-	acd	acd	c

a(b*|c|e)d	-	ad	ad	@d

a(b?)c		-	abc	abc	b

a(b?)c		-	ac	ac	@c

a(b+)c		-	abc	abc	b

a(b+)c		-	abbbc	abbbc	bbb

a(b*)c		-	ac	ac	@c

(a|ab)(bc([de]+)f|cde)	-	abcdef	abcdef	a,bcdef,de

# the regression tester only asks for 9 subexpressions

a(b)(c)(d)(e)(f)(g)(h)(i)(j)k	-	abcdefghijk	abcdefghijk	b,c,d,e,f,g,h,i,j

a(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)l	-	abcdefghijkl	abcdefghijkl	b,c,d,e,f,g,h,i,j,k

a([bc]?)c	-	abc	abc	b

a([bc]?)c	-	ac	ac	@c

a([bc]+)c	-	abc	abc	b

a([bc]+)c	-	abcc	abcc	bc

a([bc]+)bc	-	abcbc	abcbc	bc

a(bb+|b)b	-	abb	abb	b

a(bbb+|bb+|b)b	-	abb	abb	b

a(bbb+|bb+|b)b	-	abbb	abbb	bb

a(bbb+|bb+|b)bb	-	abbb	abbb	b

(.*).*		-	abcdef	abcdef	abcdef

(a*)*		-	bc	@b	@b

# do we get the right subexpression when it is used more than once?

a(b|c)*d	-	ad	ad	-

a(b|c)*d	-	abcd	abcd	c

a(b|c)+d	-	abd	abd	b

a(b|c)+d	-	abcd	abcd	c

a(b|c?)+d	-	ad	ad	@d

a(b|c?)+d	-	abcd	abcd	c

a(b|c){0,0}d	-	ad	ad	-

a(b|c){0,1}d	-	ad	ad	-

a(b|c){0,1}d	-	abd	abd	b

a(b|c){0,2}d	-	ad	ad	-

a(b|c){0,2}d	-	abcd	abcd	c

a(b|c){0,}d	-	ad	ad	-

a(b|c){0,}d	-	abcd	abcd	c

a(b|c){1,1}d	-	abd	abd	b

a(b|c){1,1}d	-	acd	acd	c

a(b|c){1,2}d	-	abd	abd	b

a(b|c){1,2}d	-	abcd	abcd	c

a(b|c){1,}d	-	abd	abd	b

a(b|c){1,}d	-	abcd	abcd	c

a(b|c){2,2}d	-	acbd	acbd	b

a(b|c){2,2}d	-	abcd	abcd	c

a(b|c){2,4}d	-	abcd	abcd	c

a(b|c){2,4}d	-	abcbd	abcbd	b

a(b|c){2,4}d	-	abcbcd	abcbcd	c

a(b|c){2,}d	-	abcd	abcd	c

a(b|c){2,}d	-	abcbd	abcbd	b

a(b+|((c)*))+d	-	abd	abd	b,-,-

a(b+|((c)*))+d	-	abcd	abcd	c,c,c

# check out the STARTEND option

[abc]		&#	a(b)c	b

[abc]		&#	a(d)c

[abc]		&#	a(bc)d	b

[abc]		&#	a(dc)d	c

.		&#	a()c

b.*c		&#	b(bc)c	bc

b.*		&#	b(bc)c	bc

.*c		&#	b(bc)c	bc

# plain strings, with the NOSPEC flag

abc		m	abc	abc

abc		m	xabcy	abc

abc		m	xyz

a*b		m	aba*b	a*b

a*b		m	ab

""		mC	EMPTY

# cases involving NULs

aZb		&	a	a

aZb		&p	a

aZb		&p#	(aZb)	aZb

aZ*b		&p#	(ab)	ab

a.b		&#	(aZb)	aZb

a.*		&#	(aZb)c	aZb

# word boundaries (ick)

[[:<:]]a	&	a	a

[[:<:]]a	&	ba

[[:<:]]a	&	-a	a

a[[:>:]]	&	a	a

a[[:>:]]	&	ab

a[[:>:]]	&	a-	a

[[:<:]]a.c[[:>:]]	&	axcd-dayc-dazce-abc	abc

[[:<:]]a.c[[:>:]]	&	axcd-dayc-dazce-abc-q	abc

[[:<:]]a.c[[:>:]]	&	axc-dayc-dazce-abc	axc

[[:<:]]b.c[[:>:]]	&	a_bxc-byc_d-bzc-q	bzc

[[:<:]].x..[[:>:]]	&	y_xa_-_xb_y-_xc_-axdc	_xc_

[[:<:]]a_b[[:>:]]	&	x_a_b

# past problems, and suspected problems

(A[1])|(A[2])|(A[3])|(A[4])|(A[5])|(A[6])|(A[7])|(A[8])|(A[9])|(A[A])	-	A1	A1

abcdefghijklmnop	i	abcdefghijklmnop	abcdefghijklmnop

abcdefghijklmnopqrstuv	i	abcdefghijklmnopqrstuv	abcdefghijklmnopqrstuv

(ALAK)|(ALT[AB])|(CC[123]1)|(CM[123]1)|(GAMC)|(LC[23][EO ])|(SEM[1234])|(SL[ES][12])|(SLWW)|(SLF )|(SLDT)|(VWH[12])|(WH[34][EW])|(WP1[ESN])	-	CC11	CC11

CC[13]1|a{21}[23][EO][123][Es][12]a{15}aa[34][EW]aaaaaaa[X]a	-	CC11	CC11

Char \([a-z0-9_]*\)\[.*	b	Char xyz[k	Char xyz[k	xyz

a?b	-	ab	ab

-\{0,1\}[0-9]*$	b	-5	-5

a*a*a*a*a*a*a*	&	aaaaaa	aaaaaa

(\b){0}	-	x	@x	-

\(\b\)\{0,0\}	b	abc	@abc	-

a(\b){0}c	-	ac	ac	-

a(.*)b(\1){0}c	-	abc	abc	@bc,-

a(.*)b(\1){0}c	-	axbc	axbc	x,-

a\(\(b*\)\)c\1d	b	abbcbbd	abbcbbd	bb,bb

a\(\([bc]\)\)\2d	b	abcdabbd	abbd	b,b

a\(\(\(\([bc]\)\)\3\)\)*d	b	abbccd	abbccd	cc,cc,c,c

a(b)(c)d	-	abcd	abcd	b,c

a(((b)))c	-	abc	abc	b,b,b

a(((b|(((c))))))d	-	abd	abd	b,b,b,-,-,-

a(((b*|c|e)))d	-	abbd	abbd	bb,bb,bb

a((b|c)){0,0}d	-	ad	ad	-,-

a((b|c)){0,1}d	-	abd	abd	b,b

a((b|c)){0,2}d	-	abcd	abcd	c,c

a((b+|((c)*)))+d	-	abd	abd	b,b,-,-

a((b+|((c)*)))+d	-	abcd	abcd	c,c,c,c

(((\b))){0}	-	x	@x	-,-,-

a(((.*)))b((\2)){0}c	-	abc	abc	@bc,@bc,@bc,-,-

a(((.*)))b((\1)){0}c	-	axbc	axbc	x,x,x,-,-

\b	&	SaT	@aT

\b	&	aT	@aT

a.*\b	&	abT	ab

\b	&	STSS

\B	&	abc	@bc

\B	&	aSbTc

\B	&	SaT	@SaT

\B	&	aSTSb	@TSb

o$($|.)	-	oN

o$($|.)	-	op

o$($|.)	-	o	o