Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
Per Cederqvist
lyskom-server-ceder-1616-generations-topgit
Commits
acbc1991
Commit
acbc1991
authored
Dec 18, 1992
by
Per Cederqvist
Browse files
Initial revision
parent
fb51f598
Changes
6
Expand all
Hide whitespace changes
Inline
Side-by-side
src/libraries/regex/test/getpagesize.h
0 → 100644
View file @
acbc1991
#ifdef BSD
#ifndef BSD4_1
#define HAVE_GETPAGESIZE
#endif
#endif
#ifndef HAVE_GETPAGESIZE
#include
<sys/param.h>
#ifdef EXEC_PAGESIZE
#define getpagesize() EXEC_PAGESIZE
#else
#ifdef NBPG
#define getpagesize() NBPG * CLSIZE
#ifndef CLSIZE
#define CLSIZE 1
#endif
/* no CLSIZE */
#else
/* no NBPG */
#define getpagesize() NBPC
#endif
/* no NBPG */
#endif
/* no EXEC_PAGESIZE */
#endif
/* not HAVE_GETPAGESIZE */
src/libraries/regex/test/test.c
0 → 100644
View file @
acbc1991
This diff is collapsed.
Click to expand it.
src/libraries/regex/test/test.h
0 → 100644
View file @
acbc1991
/* test.h: for Regex testing. */
#ifndef TEST_H
#define TEST_H
#include
<stdio.h>
#include
<assert.h>
#include
<sys/types.h>
#include
"regex.h"
/* A strlen that works even on a null pointer. */
#define SAFE_STRLEN(s) (s == NULL ? 0 : strlen (s))
typedef
enum
{
false
=
0
,
true
=
1
}
boolean
;
extern
boolean
test_should_match
;
extern
boolean
omit_register_tests
;
extern
void
*
xmalloc
();
/* Defined in upcase.c. */
extern
char
upcase
[];
typedef
enum
{
all_test
,
other_test
,
posix_basic_test
,
posix_extended_test
,
posix_interface_test
,
regress_test
}
test_type
;
extern
test_type
t
;
#if __STDC__
extern
char
*
concat
(
char
*
,
char
*
);
extern
void
general_test
(
unsigned
pattern_should_be_valid
,
unsigned
match_whole_string
,
const
char
*
pat
,
char
*
str1
,
char
*
str2
,
int
start
,
int
range
,
int
end
,
char
*
correct_fastmap
,
struct
re_registers
*
correct_regs
,
int
can_be_null
);
extern
void
init_pattern_buffer
(
regex_t
*
pattern_buffer_ptr
);
extern
void
test_compile
(
unsigned
valid_pattern
,
int
error_code_expected
,
const
char
*
pattern
,
regex_t
*
pattern_buffer_ptr
,
int
cflags
);
extern
char
*
delimiter_to_ops
(
char
*
source
,
char
left_delimiter
,
char
right_delimiter
);
extern
void
test_search_return
(
int
,
const
char
*
,
char
*
);
extern
void
test_berk_search
(
const
char
*
pattern
,
char
*
string
);
extern
void
test_fastmap
(
const
char
*
pat
,
char
*
fastmap_string
,
unsigned
invert
,
unsigned
match_newline
);
extern
void
test_fastmap_search
(
const
char
*
pat
,
char
*
str
,
char
*
fastmap_string
,
unsigned
invert
,
unsigned
match_newline
,
int
can_be_null
,
int
start0
,
int
end0
);
extern
void
test_all_registers
(
char
*
pat
,
char
*
str1
,
char
*
str2
,
int
start0
,
int
end0
,
int
start1
,
int
end1
,
int
start2
,
int
end2
,
int
start3
,
int
end3
,
int
start4
,
int
end4
,
int
start5
,
int
end5
,
int
start6
,
int
end6
,
int
start7
,
int
end7
,
int
start8
,
int
end8
,
int
start9
,
int
end9
);
extern
void
print_pattern_info
(
const
char
*
pattern
,
regex_t
*
pattern_buffer_ptr
);
extern
void
compile_and_print_pattern
(
char
*
pattern
);
extern
void
test_case_fold
(
const
char
*
pattern
,
char
*
string
);
extern
void
test_posix_generic
();
extern
void
test_grouping
();
extern
void
invalid_pattern
(
int
error_code_expected
,
char
*
pattern
);
extern
void
valid_nonposix_pattern
(
char
*
pattern
);
extern
void
valid_pattern
(
char
*
pattern
);
extern
void
test_match_2
(
const
char
*
pat
,
char
*
str1
,
char
*
str2
);
extern
void
test_match
(
const
char
*
pat
,
char
*
str
);
#endif
/* __STDC__ */
#define TEST_REGISTERS_2(pat, str1, str2, start0, end0, start1, end1, start2, end2)\
if (!omit_register_tests) \
test_all_registers (pat, str1, str2, start0, end0, start1, end1, \
start2, end2, -1, -1, -1, -1, -1, -1, -1, -1,\
-1, -1, -1, -1, -1, -1) \
#define TEST_REGISTERS(pat, str, start0, end0, start1, end1, start2, end2) \
TEST_REGISTERS_2 (pat, str, NULL, start0, end0, start1, end1, start2, end2)\
#define BRACES_TO_OPS(string) ((char *) delimiters_to_ops (string, '{', '}'))
#define PARENS_TO_OPS(string) ((char *) delimiters_to_ops (string, '(', ')'))
#define INVALID_PATTERN(pat) \
general_test (0, 0, pat, NULL, NULL, -1, 0, -1, NULL, 0, -1)
#define MATCH_SELF(p) test_match (p, p)
#define TEST_POSITIONED_MATCH(pat, str, start) \
general_test (1, 0, pat, str, NULL, start, 1, SAFE_STRLEN (str), \
NULL, 0, -1)
#define TEST_TRUNCATED_MATCH(pat, str, end) \
general_test (1, 0, pat, str, NULL, 0, 1, end, NULL, 0, -1)
#define TEST_SEARCH_2(pat, str1, str2, start, range, one_past_end) \
general_test (1, 0, pat, str1, str2, start, range, one_past_end, \
NULL, 0, -1)
#define TEST_SEARCH(pat, str, start, range) \
{ \
TEST_SEARCH_2 (pat, str, NULL, start, range, SAFE_STRLEN (str)); \
TEST_SEARCH_2 (pat, NULL, str, start, range, SAFE_STRLEN (str)); \
}
#endif
/* TEST_H */
/*
Local variables:
make-backup-files: t
version-control: t
trim-versions-without-asking: nil
End:
*/
src/libraries/regex/test/tregress.c
0 → 100644
View file @
acbc1991
/* tregress.c: reported bugs. The `t' just makes the filename not have
a common prefix with `regex.c', so completion works better. */
#include
"test.h"
boolean
pause_at_error
=
true
;
char
*
itoa
(
i
)
int
i
;
{
char
*
a
=
xmalloc
(
21
);
/* sign + 19 digits (enough for 64 bits) + null */
sprintf
(
a
,
"%d"
,
i
);
return
a
;
}
static
void
simple_fail
(
routine
,
pat
,
buf
,
str
,
ret
)
const
char
*
routine
;
const
char
*
pat
;
struct
re_pattern_buffer
*
buf
;
const
char
*
str
;
char
*
ret
;
{
fprintf
(
stderr
,
"Failed %s (return = %s).
\n
"
,
routine
,
ret
);
if
(
str
&&
*
str
)
fprintf
(
stderr
,
" String = %s
\n
"
,
str
);
fprintf
(
stderr
,
" Pattern = %s
\n
"
,
pat
);
print_compiled_pattern
(
buf
);
if
(
pause_at_error
)
{
fprintf
(
stderr
,
"RET to continue: "
);
(
void
)
getchar
();
}
}
/* Abbreviate the most common calls. */
static
void
simple_compile
(
pat
,
buf
)
const
char
*
pat
;
struct
re_pattern_buffer
*
buf
;
{
const
char
*
ret
=
re_compile_pattern
(
pat
,
strlen
(
pat
),
buf
);
if
(
ret
!=
NULL
)
simple_fail
(
"compile"
,
pat
,
buf
,
NULL
,
ret
);
}
static
void
simple_fastmap
(
pat
)
const
char
*
pat
;
{
struct
re_pattern_buffer
buf
;
char
fastmap
[
256
];
int
ret
;
buf
.
allocated
=
0
;
buf
.
buffer
=
buf
.
translate
=
NULL
;
buf
.
fastmap
=
fastmap
;
simple_compile
(
pat
,
&
buf
);
ret
=
re_compile_fastmap
(
&
buf
);
if
(
ret
!=
0
)
simple_fail
(
"fastmap compile"
,
pat
,
&
buf
,
NULL
,
itoa
(
ret
));
}
#define SIMPLE_MATCH(pat, str) do_match (pat, str, strlen (str))
#define SIMPLE_NONMATCH(pat, str) do_match (pat, str, -1)
static
void
do_match
(
pat
,
str
,
expected
)
const
char
*
pat
,
*
str
;
int
expected
;
{
int
ret
;
unsigned
len
;
struct
re_pattern_buffer
buf
;
buf
.
allocated
=
0
;
buf
.
buffer
=
buf
.
translate
=
buf
.
fastmap
=
NULL
;
simple_compile
(
pat
,
&
buf
);
len
=
strlen
(
str
);
ret
=
re_match_2
(
&
buf
,
NULL
,
0
,
str
,
len
,
0
,
NULL
,
len
);
if
(
ret
!=
expected
)
simple_fail
(
"match"
,
pat
,
&
buf
,
str
,
itoa
(
ret
));
}
static
void
simple_search
(
pat
,
str
,
correct_startpos
)
const
char
*
pat
,
*
str
;
int
correct_startpos
;
{
int
ret
;
unsigned
len
;
struct
re_pattern_buffer
buf
;
buf
.
allocated
=
0
;
buf
.
buffer
=
buf
.
translate
=
buf
.
fastmap
=
NULL
;
simple_compile
(
pat
,
&
buf
);
len
=
strlen
(
str
);
ret
=
re_search_2
(
&
buf
,
NULL
,
0
,
str
,
len
,
0
,
len
,
NULL
,
len
);
if
(
ret
!=
correct_startpos
)
simple_fail
(
"match"
,
pat
,
&
buf
,
str
,
itoa
(
ret
));
}
/* Past bugs people have reported. */
void
test_regress
()
{
extern
char
upcase
[];
struct
re_pattern_buffer
buf
;
struct
re_registers
regs
;
char
*
fastmap
=
xmalloc
(
256
);
buf
.
translate
=
NULL
;
buf
.
fastmap
=
NULL
;
buf
.
allocated
=
0
;
buf
.
buffer
=
NULL
;
printf
(
"
\n
Starting regression tests.
\n
"
);
t
=
regress_test
;
test_should_match
=
true
;
re_set_syntax
(
RE_SYNTAX_EMACS
);
/* jimb@occs.cs.oberlin.edu 10 Sep 92 00:42:33 */
buf
.
translate
=
upcase
;
SIMPLE_MATCH
(
"[
\001
-
\377
]"
,
"
\001
"
);
SIMPLE_MATCH
(
"[
\001
-
\377
]"
,
"a"
);
SIMPLE_MATCH
(
"[
\001
-
\377
]"
,
"
\377
"
);
buf
.
translate
=
NULL
;
/* mike@skinner.cs.uoregon.edu 1 Sep 92 01:45:22 */
SIMPLE_MATCH
(
"^^$"
,
"^"
);
/* pclink@qld.tne.oz.au Sep 7 22:42:36 1992 */
re_set_syntax
(
RE_INTERVALS
);
SIMPLE_MATCH
(
"^a
\\
{3
\\
}$"
,
"aaa"
);
SIMPLE_NONMATCH
(
"^a
\\
{3
\\
}$"
,
"aa"
);
re_set_syntax
(
RE_SYNTAX_EMACS
);
/* pclink@qld.tne.oz.au, 31 Aug 92. (conjecture) */
re_set_syntax
(
RE_INTERVALS
);
simple_search
(
"a
\\
{1,3
\\
}b"
,
"aaab"
,
0
);
simple_search
(
"a
\\
{1,3
\\
}b"
,
"aaaab"
,
1
);
re_set_syntax
(
RE_SYNTAX_EMACS
);
/* trq@dionysos.thphys.ox.ac.uk, 31 Aug 92. (simplified) */
simple_fastmap
(
"^.*
\n
[ ]*"
);
/* wind!greg@plains.NoDak.edu, 25 Aug 92. (simplified) */
re_set_syntax
(
RE_INTERVALS
);
SIMPLE_MATCH
(
"[a-zA-Z]*.
\\
{5
\\
}"
,
"xN0000"
);
SIMPLE_MATCH
(
"[a-zA-Z]*.
\\
{5
\\
}$"
,
"systemxN0000"
);
SIMPLE_MATCH
(
"
\\
([a-zA-Z]*
\\
).
\\
{5
\\
}$"
,
"systemxN0000"
);
re_set_syntax
(
RE_SYNTAX_EMACS
);
/* jimb, 18 Aug 92. Don't use \000, so `strlen' (in our testing
routines) will work. (This still tickles the bug jimb reported.) */
SIMPLE_MATCH
(
"[
\001
-
\377
]"
,
"
\001
"
);
SIMPLE_MATCH
(
"[
\001
-
\377
]"
,
"a"
);
SIMPLE_MATCH
(
"[
\001
-
\377
]"
,
"
\377
"
);
/* jimb, 13 Aug 92. */
SIMPLE_MATCH
(
"[
\001
-
\177
]"
,
"
\177
"
);
/* Tests based on bwoelfel's below. */
SIMPLE_MATCH
(
"
\\
(a
\\
|ab
\\
)*"
,
"aab"
);
SIMPLE_MATCH
(
"
\\
(a
\\
|ab
\\
)+"
,
"aab"
);
SIMPLE_MATCH
(
"
\\
(a*
\\
|ab
\\
)+"
,
"aab"
);
SIMPLE_MATCH
(
"
\\
(a+
\\
|ab
\\
)+"
,
"aab"
);
SIMPLE_MATCH
(
"
\\
(a?
\\
|ab
\\
)+"
,
"aab"
);
/* bwoelfel@widget.seas.upenn.edu, 25 Jul 92. */
SIMPLE_MATCH
(
"^
\\
([ab]+
\\
|bc
\\
)+"
,
"abc"
);
/* jla, 3 Jul 92. Core dump in re_search_2. */
buf
.
fastmap
=
fastmap
;
buf
.
translate
=
upcase
;
#define DATEDUMP_PATTERN " *[0-9]*:"
if
(
re_compile_pattern
(
DATEDUMP_PATTERN
,
strlen
(
DATEDUMP_PATTERN
),
&
buf
)
!=
NULL
)
printf
(
"date dump compile failed.
\n
"
);
regs
.
num_regs
=
0
;
regs
.
start
=
regs
.
end
=
NULL
;
if
(
re_search_2
(
&
buf
,
NULL
,
0
,
"Thu Jul 2 18:34:18 1992"
,
24
,
3
,
21
,
&
regs
,
24
)
!=
10
)
printf
(
"date dump search failed.
\n
"
);
buf
.
fastmap
=
0
;
buf
.
translate
=
0
;
/* rms, 4 Jul 1992. Pattern is much slower in Emacs 19. Fastmap
should be only a backslash. */
#define BEGINEND_PATTERN "\\(\\\\begin\\s *{\\)\\|\\(\\\\end\\s *{\\)"
test_fastmap
(
BEGINEND_PATTERN
,
"
\\
"
,
false
,
0
);
/* kaoru@is.s.u-tokyo.ac.jp, 27 Jun 1992. Code for [a-z] (in regex.c)
should translate the whole set. */
buf
.
translate
=
upcase
;
#define CASE_SET_PATTERN "[ -`]"
if
(
re_compile_pattern
(
CASE_SET_PATTERN
,
strlen
(
CASE_SET_PATTERN
),
&
buf
)
!=
NULL
)
printf
(
"case set compile failed.
\n
"
);
if
(
re_match_2
(
&
buf
,
"K"
,
1
,
""
,
0
,
0
,
NULL
,
1
)
!=
1
)
printf
(
"case set match failed.
\n
"
);
#define CASE_SET_PATTERN2 "[`-|]"
if
(
re_compile_pattern
(
CASE_SET_PATTERN2
,
strlen
(
CASE_SET_PATTERN2
),
&
buf
)
!=
NULL
)
printf
(
"case set2 compile failed.
\n
"
);
if
(
re_match_2
(
&
buf
,
"K"
,
1
,
""
,
0
,
0
,
NULL
,
1
)
!=
1
)
printf
(
"case set2 match failed.
\n
"
);
buf
.
translate
=
NULL
;
/* jimb, 27 Jun 92. Problems with gaps in the string. */
#define GAP_PATTERN "x.*y.*z"
if
(
re_compile_pattern
(
GAP_PATTERN
,
strlen
(
GAP_PATTERN
),
&
buf
)
!=
NULL
)
printf
(
"gap didn't compile.
\n
"
);
if
(
re_match_2
(
&
buf
,
"x-"
,
2
,
"y-z-"
,
4
,
0
,
NULL
,
6
)
!=
5
)
printf
(
"gap match failed.
\n
"
);
/* jimb, 19 Jun 92. Since `beginning of word' matches at the
beginning of the string, then searching ought to find it there.
If `re_compile_fastmap' is not called, then it works ok. */
buf
.
fastmap
=
fastmap
;
#define BOW_BEG_PATTERN "\\<"
if
(
re_compile_pattern
(
BOW_BEG_PATTERN
,
strlen
(
BOW_BEG_PATTERN
),
&
buf
)
!=
NULL
)
printf
(
"begword-begstring didn't compile.
\n
"
);
if
(
re_search
(
&
buf
,
"foo"
,
3
,
0
,
3
,
NULL
)
!=
0
)
printf
(
"begword-begstring search failed.
\n
"
);
/* Same bug report, different null-matching pattern. */
#define EMPTY_ANCHOR_PATTERN "^$"
if
(
re_compile_pattern
(
EMPTY_ANCHOR_PATTERN
,
strlen
(
EMPTY_ANCHOR_PATTERN
),
&
buf
)
!=
NULL
)
printf
(
"empty anchor didn't compile.
\n
"
);
if
(
re_search
(
&
buf
,
"foo
\n\n
bar"
,
8
,
0
,
8
,
NULL
)
!=
4
)
printf
(
"empty anchor search failed.
\n
"
);
/* jimb@occs.cs.oberlin.edu, 21 Apr 92. After we first allocate
registers for a particular re_pattern_buffer, we might have to
reallocate more registers on subsequent calls -- and we should be
reusing the same memory. */
#define ALLOC_REG_PATTERN "\\(abc\\)"
free
(
buf
.
fastmap
);
buf
.
fastmap
=
0
;
if
(
re_compile_pattern
(
ALLOC_REG_PATTERN
,
strlen
(
ALLOC_REG_PATTERN
),
&
buf
)
!=
NULL
)
printf
(
"register allocation didn't compile.
\n
"
);
if
(
re_match
(
&
buf
,
"abc"
,
3
,
0
,
&
regs
)
!=
3
)
printf
(
"register allocation didn't match.
\n
"
);
if
(
regs
.
start
[
1
]
!=
0
||
regs
.
end
[
1
]
!=
3
)
printf
(
"register allocation reg #1 wrong.
\n
"
);
{
int
*
old_regstart
=
regs
.
start
;
int
*
old_regend
=
regs
.
end
;
if
(
re_match
(
&
buf
,
"abc"
,
3
,
0
,
&
regs
)
!=
3
)
printf
(
"register reallocation didn't match.
\n
"
);
if
(
regs
.
start
[
1
]
!=
0
||
regs
.
end
[
1
]
!=
3
||
old_regstart
[
1
]
!=
0
||
old_regend
[
1
]
!=
3
||
regs
.
start
!=
old_regstart
||
regs
.
end
!=
old_regend
)
printf
(
"register reallocation registers wrong.
\n
"
);
}
/* jskudlarek@std.MENTORG.COM, 21 Apr 92 (string-match). */
#define JSKUD_PATTERN "[^/]+\\(/[^/.]+\\)?/[0-9]+$"
if
(
re_compile_pattern
(
JSKUD_PATTERN
,
strlen
(
JSKUD_PATTERN
),
&
buf
)
!=
NULL
)
printf
(
"jskud test didn't compile.
\n
"
);
if
(
re_search
(
&
buf
,
"a/1"
,
3
,
0
,
3
,
&
regs
)
!=
0
)
printf
(
"jskud test didn't match.
\n
"
);
if
(
regs
.
start
[
1
]
!=
-
1
||
regs
.
end
[
1
]
!=
-
1
)
printf
(
"jskud test, reg #1 wrong.
\n
"
);
/* jla's bug (with string-match), 5 Feb 92. */
TEST_SEARCH
(
"
\\
`[
\t\n
]*"
,
"jla@challenger (Joseph Arceneaux)"
,
0
,
100
);
/* jwz@lucid.com, 8 March 1992 (re-search-forward). (His is the
second.) These are not supposed to match. */
#if 0
/* This one fails quickly, because we can change the maybe_pop_jump
from the + to a pop_failure_pop, because of the c's. */
TEST_SEARCH ("^\\(To\\|CC\\):\\([^c]*\\)+co",
"To: hbs%titanic@lucid.com (Harlan Sexton)\n\
Cc: eb@thalidomide, jlm@thalidomide\n\
Subject: Re: so is this really as horrible an idea as it seems to me?\n\
In-Reply-To: Harlan Sexton's message of Sun 8-Mar-92 11:00:06 PST <9203081900.AA24794@titanic.lucid>\n\
References: <9203080736.AA05869@thalidomide.lucid>\n\
<9203081900.AA24794@titanic.lucid>", 0, 5000);
/* This one takes a long, long time to complete, because we have to
keep the failure points around because we might backtrack. */
TEST_SEARCH ("^\\(To\\|CC\\):\\(.*\n.*\\)+co",
/* "X-Windows: The joke that kills.\n\
FCC: /u/jwz/VM/inbox\n\
From: Jamie Zawinski <jwz@lucid.com>\n\ */
"To: hbs%titanic@lucid.com (Harlan Sexton)\n\
Cc: eb@thalidomide, jlm@thalidomide\n\
Subject: Re: so is this really as horrible an idea as it seems to me?\n\
In-Reply-To: Harlan Sexton's message of Sun 8-Mar-92 11:00:06 PST <9203081900.AA24794@titanic.lucid>\n\
References: <9203080736.AA05869@thalidomide.lucid>\n\
<9203081900.AA24794@titanic.lucid>", 0, 5000);
#endif /* 0 [failed searches] */
/* macrakis' bugs. */
buf
.
translate
=
upcase
;
/* message of 24 Jan 91 */
if
(
re_compile_pattern
(
"[!-`]"
,
5
,
&
buf
)
!=
NULL
)
printf
(
"Range test didn't compile.
\n
"
);
if
(
re_match
(
&
buf
,
"A"
,
1
,
0
,
NULL
)
!=
1
)
printf
(
"Range test #1 didn't match.
\n
"
);
if
(
re_match
(
&
buf
,
"a"
,
1
,
0
,
NULL
)
!=
1
)
printf
(
"Range test #2 didn't match.
\n
"
);
buf
.
translate
=
0
;
#define FAO_PATTERN "\\(f\\(.\\)o\\)+"
if
(
re_compile_pattern
(
FAO_PATTERN
,
strlen
(
FAO_PATTERN
),
&
buf
)
!=
NULL
)
printf
(
"faofdx test didn't compile.
\n
"
);
if
(
re_search
(
&
buf
,
"faofdx"
,
6
,
0
,
6
,
&
regs
)
!=
0
)
printf
(
"faofdx test didn't match.
\n
"
);
if
(
regs
.
start
[
1
]
!=
0
||
regs
.
end
[
1
]
!=
3
)
printf
(
"faofdx test, reg #1 wrong.
\n
"
);
if
(
regs
.
start
[
2
]
!=
1
||
regs
.
end
[
2
]
!=
2
)
printf
(
"faofdx test, reg #2 wrong.
\n
"
);
TEST_REGISTERS
(
"
\\
(a
\\
)*a"
,
"aaa"
,
0
,
3
,
1
,
2
,
-
1
,
-
1
);
test_fastmap
(
"^
\\
([^
\n
]+:
\n\\
)+
\\
([^
\n
]+:
\\
)"
,
"
\n
"
,
1
,
0
);
/* 40 lines, 48 a's in each line. */
test_match
(
"^
\\
([^
\n
]+:
\n\\
)+
\\
([^
\n
]+:
\\
)"
,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
\n
\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:"
);
/* 640 a's followed by one b, twice. */
test_match
(
"
\\
(.*
\\
)
\\
1"
,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"
);
/* 640 a's followed by two b's, twice. */
test_match
(
"
\\
(.*
\\
)
\\
1"
,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabb"
);
/* Dave G. bug: Reference to a subexpression which didn't match.
Should fail. */
re_set_syntax
(
RE_NO_BK_PARENS
|
RE_NO_BK_VBAR
);
test_match
(
"(ooooooooooone())-annnnnnnnnnnd-(twooooooooooo
\\
2)"
,
"ooooooooooone-annnnnnnnnnnd-twooooooooooo"
);
test_match
(
"(o|t)"
,
"o"
);
test_match
(
"(o()|t)"
,
"o"
);
test_match
(
"(o|t)"
,
"o"
);
test_match
(
"(ooooooooooooooo|tttttttttttttttt())"
,
"ooooooooooooooo"
);
test_match
(
"(o|t())"
,
"o"
);
test_match
(
"(o()|t())"
,
"o"
);
test_match
(
"(ooooooooooooooooooooooooone()|twooooooooooooooooooooooooo())"
,
"ooooooooooooooooooooooooone"
);
test_match
(
"(o()|t())-a-(t
\\
2|f
\\
3)"
,
"o-a-t"
);
test_match
(
"(o()|t())-a-(t
\\
2|f
\\
3)"
,
"t-a-f"
);
test_should_match
=
0
;
test_match
(
"(foo(bar)|second)
\\
2"
,
"second"
);
test_match
(
"(o()|t())-a-(t
\\
2|f
\\
3)"
,
"t-a-t"
);
test_match
(
"(o()|t())-a-(t
\\
2|f
\\
3)"
,
"o-a-f"
);
re_set_syntax
(
RE_SYNTAX_EMACS
);
test_match
(
"
\\
(foo
\\
(bar
\\
)
\\
|second
\\
)
\\
2"
,
"secondbar"
);
test_match
(
"
\\
(one
\\
(
\\
)
\\
|two
\\
(
\\
)
\\
)-and-
\\
(three
\\
2
\\
|four
\\
3
\\
)"
,
"one-and-four"
);
test_match
(
"
\\
(one
\\
(
\\
)
\\
|two
\\
(
\\
)
\\
)-and-
\\
(three
\\
2
\\
|four
\\
3
\\
)"
,
"two-and-three"
);
test_should_match
=
1
;
re_set_syntax
(
RE_SYNTAX_EMACS
);
test_match
(
"
\\
(one
\\
(
\\
)
\\
|two
\\
(
\\
)
\\
)-and-
\\
(three
\\
2
\\
|four
\\
3
\\
)"
,
"one-and-three"
);
test_match
(
"
\\
(one
\\
(
\\
)
\\
|two
\\
(
\\
)
\\
)-and-
\\
(three
\\
2
\\
|four
\\
3
\\
)"
,
"two-and-four"
);