List:Commits« Previous MessageNext Message »
From:Tor Didriksen Date:March 3 2011 8:08am
Subject:bzr commit into mysql-trunk branch (tor.didriksen:3722)
View as plain text  
#At file:///export/home/didrik/repo/trunk-regex/ based on revid:anitha.gopi@strippedx

 3722 Tor Didriksen	2011-03-03
      Rewrite test to run inline, rather than depending on external data file

    renamed:
      regex/tests => regex/tests_include.h
    modified:
      regex/CMakeLists.txt
      regex/main.c
      regex/tests_include.h
=== modified file 'regex/CMakeLists.txt'
--- a/regex/CMakeLists.txt	2010-10-05 06:33:15 +0000
+++ b/regex/CMakeLists.txt	2011-03-03 08:08:23 +0000
@@ -18,9 +18,11 @@ INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/
 SET(REGEX_SOURCES regcomp.c regerror.c regexec.c regfree.c reginit.c)
 ADD_CONVENIENCE_LIBRARY(regex ${REGEX_SOURCES})
 
-ADD_EXECUTABLE(re main.c split.c debug.c)
-TARGET_LINK_LIBRARIES(re regex strings mysys)
+IF(WITH_UNIT_TESTS)
+  ADD_EXECUTABLE(re main.c split.c debug.c)
+  TARGET_LINK_LIBRARIES(re regex strings mysys)
 
-ADD_TEST(regex1 re     -i${CMAKE_CURRENT_SOURCE_DIR}/tests)
-ADD_TEST(regex2 re -el -i${CMAKE_CURRENT_SOURCE_DIR}/tests)
-ADD_TEST(regex3 re -er -i${CMAKE_CURRENT_SOURCE_DIR}/tests)
+  ADD_TEST(regex1 re     -I)
+  ADD_TEST(regex2 re -el -I)
+  ADD_TEST(regex3 re -er -I)
+ENDIF()

=== modified file 'regex/main.c'
--- a/regex/main.c	2010-10-19 22:58:36 +0000
+++ b/regex/main.c	2011-03-03 08:08:23 +0000
@@ -5,6 +5,7 @@
 
 #include "my_regex.h"
 #include "main.ih"
+#include "tests_include.h"
 
 char *progname;
 int debug = 0;
@@ -65,6 +66,7 @@ char *argv[];
 	size_t len;
 	int c;
 	int errflg = 0;
+	int opt_inline = 0;
 	register int i;
         char *input_file_name= NULL;
 	extern int optind;
@@ -72,7 +74,7 @@ char *argv[];
 
 	progname = argv[0];
 
-	while ((c = getopt(argc, argv, "c:e:i:S:E:x")) != EOF)
+	while ((c = getopt(argc, argv, "c:e:i:S:E:xI")) != EOF)
 		switch (c) {
 		case 'c':	/* compile options */
 			copts = options('c', optarg);
@@ -92,6 +94,9 @@ char *argv[];
 		case 'x':	/* Debugging. */
 			debug++;
 			break;
+		case 'I':	/* Inline. */
+			opt_inline= 1;
+			break;
 		case '?':
 		default:
 			errflg++;
@@ -100,10 +105,15 @@ char *argv[];
 	if (errflg) {
 		fprintf(stderr, "usage: %s ", progname);
 		fprintf(stderr,
-                        "[-c copt][-e eopt][-i filename][-S][-E][-x] [re]\n");
+                        "[-c copt][-e eopt][-i filename][-S][-E][-x][-I] [re]\n");
 		exit(2);
 	}
 
+        if (opt_inline) {
+          regress(NULL);
+          exit(status);
+        }
+
 	if (optind >= argc && !input_file_name) {
 		regress(stdin);
 		exit(status);
@@ -165,9 +175,24 @@ char *argv[];
 	exit(status);
 }
 
+char*
+get_next_line(s, size, stream)
+char *s;
+int size;
+FILE *stream;
+{
+  if (stream)
+    return fgets(s, size, stream);
+  if (test_array[line])
+    return strncpy(s, test_array[line], size);
+  return NULL;
+}
+
 /*
  - regress - main loop of regression test
  == void regress(FILE *in);
+    Reads file, line-by-line.
+    If in == NULL, we read data from test_array instead.
  */
 void
 regress(in)
@@ -185,13 +210,14 @@ FILE *in;
 	const char *bpname = "MY_REG_BADPAT";
 	my_regex_t re;
 
-	while (fgets(inbuf, sizeof(inbuf), in) != NULL) {
+	while (get_next_line(inbuf, sizeof(inbuf), in) != NULL) {
 		line++;
-		if (inbuf[0] == '#' || inbuf[0] == '\n')
+		if (inbuf[0] == '#' || inbuf[0] == '\n' || inbuf[0] == '\0')
 			continue;			/* NOTE CONTINUE */
-		inbuf[strlen(inbuf)-1] = '\0';	/* get rid of stupid \n */
+		if (inbuf[strlen(inbuf)-1] == '\n')
+		  inbuf[strlen(inbuf)-1] = '\0';  /* get rid of stupid \n */
 		if (debug)
-			fprintf(stdout, "%d:\n", line);
+                  fprintf(stdout, "%d: <%s>\n", line, inbuf);
 		nf = split(inbuf, f, MAXF, (char*) "\t\t");
 		if (nf < 3) {
 			fprintf(stderr, "bad input, line %d\n", line);

=== renamed file 'regex/tests' => 'regex/tests_include.h'
--- a/regex/tests	2010-07-26 10:39:38 +0000
+++ b/regex/tests_include.h	2011-03-03 08:08:23 +0000
@@ -1,477 +1,482 @@
-# 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
-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
-{		&	{	{
-{abc		&	{abc	{abc
-{1		C	BADRPT
-{1}		C	BADRPT
-a{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
-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
-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
-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?+		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
-a[1-		&C	ERANGE
-a[[.		&C	EBRACK
-a[[.x		&C	EBRACK
-a[[.x.		&C	EBRACK
-a[[.x.]		&C	EBRACK
-a[[.x.]]	&	ax	ax
-a[[.x,.]]	&C	ECOLLATE
-a[[.one.]]b	&	a1b	a1b
-a[[.notdef.]]b	&C	ECOLLATE
-a[[.].]]b	&	a]b	a]b
-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:]]+	-	-%@a�-	a�
-[[:alpha:]]+	-	-%@aX0-	aX
-# ctype_latin1 does not tag '\t' as blank, so we will match only two spaces.
-# See: Bug #55427 REGEXP does not recognize '\t' as [:blank:]
-#[[:blank:]]+	-	aSSTb	SST
-[[:blank:]]+	-	aSSTb	SS
-[[: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
-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
-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
-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	@d
-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	@d,@d,-
-a(b+|((c)*))+d	-	abcd	abcd	@d,@d,-
-
-# 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
+const char *test_array[] =
+{
+  "# 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",
+  "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",
+  "{		&	{	{",
+  "{abc		&	{abc	{abc",
+  "{1		C	BADRPT",
+  "{1}		C	BADRPT",
+  "a{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",
+  "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",
+  "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",
+  "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?+		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",
+  "a[1-		&C	ERANGE",
+  "a[[.		&C	EBRACK",
+  "a[[.x		&C	EBRACK",
+  "a[[.x.		&C	EBRACK",
+  "a[[.x.]		&C	EBRACK",
+  "a[[.x.]]	&	ax	ax",
+  "a[[.x,.]]	&C	ECOLLATE",
+  "a[[.one.]]b	&	a1b	a1b",
+  "a[[.notdef.]]b	&C	ECOLLATE",
+  "a[[.].]]b	&	a]b	a]b",
+  "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:]]+	-	-%@a�-	a�",
+  "[[:alpha:]]+	-	-%@aX0-	aX",
+  "# ctype_latin1 does not tag '\\t' as blank, so we will match only two spaces.",
+  "# See: Bug #55427 REGEXP does not recognize '\\t' as [:blank:]",
+  "#[[:blank:]]+	-	aSSTb	SST",
+  "[[:blank:]]+	-	aSSTb	SS",
+  "[[: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",
+  "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",
+  "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",
+  "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	@d",
+  "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	@d,@d,-",
+  "a(b+|((c)*))+d	-	abcd	abcd	@d,@d,-",
+  "",
+  "# 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",
+  "",
+  NULL
+};

Attachment: [text/bzr-bundle] bzr/tor.didriksen@oracle.com-20110303080823-cl4m7urt6dy4yqai.bundle
Thread
bzr commit into mysql-trunk branch (tor.didriksen:3722) Tor Didriksen3 Mar