787 lines
22 KiB
C
787 lines
22 KiB
C
/* test.c: testing routines for regex.c. */
|
|
|
|
#ifndef lint
|
|
static char rcsid[] = "$Id: test.c,v 1.2 1993/08/02 17:24:32 mycroft Exp $";
|
|
#endif /* not lint */
|
|
|
|
#include <assert.h>
|
|
|
|
#ifdef STDC_HEADERS
|
|
#include <stdlib.h>
|
|
#else
|
|
char *malloc ();
|
|
char *realloc ();
|
|
#endif
|
|
|
|
/* Just to be complete, we make both the system V/ANSI and the BSD
|
|
versions of the string functions available. */
|
|
#if USG || STDC_HEADERS
|
|
#include <string.h>
|
|
#define index strchr
|
|
#define rindex strrchr
|
|
#define bcmp(s1, s2, len) memcmp ((s1), (s2), (len))
|
|
#define bcopy(from, to, len) memcpy ((to), (from), (len))
|
|
#define bzero(s, len) memset ((s), 0, (len))
|
|
#else
|
|
#include <strings.h>
|
|
#define strchr index
|
|
#define strrchr rindex
|
|
#ifndef NEED_MEMORY_H
|
|
#define memcmp(s1, s2, n) bcmp ((s1), (s2), (n))
|
|
#define memcpy(to, from, len) bcopy ((from), (to), (len))
|
|
#endif
|
|
extern char *strtok ();
|
|
extern char *strstr ();
|
|
#endif /* not USG or STDC_HEADERS */
|
|
|
|
/* SunOS 4.1 declares memchr in <memory.h>, not <string.h>. I don't
|
|
understand why. */
|
|
#if NEED_MEMORY_H
|
|
#include <memory.h>
|
|
#endif
|
|
|
|
#include "test.h"
|
|
|
|
#define BYTEWIDTH 8
|
|
|
|
extern void print_partial_compiled_pattern ();
|
|
extern void print_compiled_pattern ();
|
|
extern void print_double_string ();
|
|
|
|
/* If nonzero, the results of every test are displayed. */
|
|
boolean verbose = false;
|
|
|
|
/* If nonzero, don't do register testing. */
|
|
boolean omit_register_tests = true;
|
|
|
|
/* Says whether the current test should match or fail to match. */
|
|
boolean test_should_match;
|
|
|
|
|
|
static void
|
|
set_all_registers (start0, end0, start1, end1,
|
|
start2, end2, start3, end3,
|
|
start4, end4, start5, end5,
|
|
start6, end6, start7, end7,
|
|
start8, end8, start9, end9, regs)
|
|
|
|
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;
|
|
struct re_registers *regs;
|
|
|
|
{
|
|
unsigned r;
|
|
|
|
regs->start[0] = start0; regs->end[0] = end0;
|
|
regs->start[1] = start1; regs->end[1] = end1;
|
|
regs->start[2] = start2; regs->end[2] = end2;
|
|
regs->start[3] = start3; regs->end[3] = end3;
|
|
regs->start[4] = start4; regs->end[4] = end4;
|
|
regs->start[5] = start5; regs->end[5] = end5;
|
|
regs->start[6] = start6; regs->end[6] = end6;
|
|
regs->start[7] = start7; regs->end[7] = end7;
|
|
regs->start[8] = start8; regs->end[8] = end8;
|
|
regs->start[9] = start9; regs->end[9] = end9;
|
|
for (r = 10; r < regs->num_regs; r++)
|
|
{
|
|
regs->start[r] = -1;
|
|
regs->end[r] = -1;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* Return the concatenation of S1 and S2. This would be a prime place
|
|
to use varargs. */
|
|
|
|
char *
|
|
concat (s1, s2)
|
|
char *s1;
|
|
char *s2;
|
|
{
|
|
char *answer = xmalloc (strlen (s1) + strlen (s2) + 1);
|
|
|
|
strcpy (answer, s1);
|
|
strcat (answer, s2);
|
|
|
|
return answer;
|
|
}
|
|
|
|
|
|
#define OK_TO_SEARCH (nonconst_buf.fastmap_accurate && (str1 || str2))
|
|
|
|
/* We ignore the `can_be_null' argument. Should just be removed. */
|
|
|
|
void
|
|
general_test (pattern_should_be_valid, match_whole_string,
|
|
pat, str1, str2, start, range, end, correct_fastmap,
|
|
correct_regs, can_be_null)
|
|
unsigned pattern_should_be_valid;
|
|
unsigned match_whole_string;
|
|
const char *pat;
|
|
char *str1, *str2;
|
|
int start, range, end;
|
|
char *correct_fastmap;
|
|
struct re_registers *correct_regs;
|
|
int can_be_null;
|
|
{
|
|
struct re_pattern_buffer nonconst_buf;
|
|
struct re_pattern_buffer old_buf;
|
|
struct re_registers regs;
|
|
const char *r;
|
|
char fastmap[1 << BYTEWIDTH];
|
|
unsigned *regs_correct = NULL;
|
|
unsigned all_regs_correct = 1;
|
|
boolean fastmap_internal_error = false;
|
|
unsigned match = 0;
|
|
unsigned match_1 = 0;
|
|
unsigned match_2 = 0;
|
|
unsigned invalid_pattern = 0;
|
|
boolean internal_error_1 = false;
|
|
boolean internal_error_2 = false;
|
|
|
|
|
|
nonconst_buf.allocated = 8;
|
|
nonconst_buf.buffer = xmalloc (nonconst_buf.allocated);
|
|
nonconst_buf.fastmap = fastmap;
|
|
nonconst_buf.translate = 0;
|
|
|
|
assert (pat != NULL);
|
|
r = re_compile_pattern (pat, strlen (pat), &nonconst_buf);
|
|
|
|
/* Kludge: if we are doing POSIX testing, we really should have
|
|
called regcomp, not re_compile_pattern. As it happens, the only
|
|
way in which it matters is that re_compile_pattern sets the
|
|
newline/anchor field for matching (part of what happens when
|
|
REG_NEWLINE is given to regcomp). We have to undo that for POSIX
|
|
matching. */
|
|
if (t == posix_basic_test || t == posix_extended_test)
|
|
nonconst_buf.newline_anchor = 0;
|
|
|
|
invalid_pattern = r != NULL;
|
|
|
|
if (!r)
|
|
{
|
|
int r;
|
|
|
|
if (!pattern_should_be_valid)
|
|
printf ("\nShould have been an invalid pattern but wasn't:\n");
|
|
else
|
|
{
|
|
fastmap_internal_error = (re_compile_fastmap (&nonconst_buf) == -2);
|
|
|
|
if (correct_fastmap)
|
|
nonconst_buf.fastmap_accurate =
|
|
memcmp (nonconst_buf.fastmap, correct_fastmap, 1 << BYTEWIDTH)
|
|
== 0;
|
|
|
|
if (OK_TO_SEARCH)
|
|
{
|
|
old_buf = nonconst_buf;
|
|
old_buf.buffer = (unsigned char *) xmalloc (nonconst_buf.used);
|
|
memcpy (old_buf.buffer, nonconst_buf.buffer, nonconst_buf.used);
|
|
|
|
/* If only one string is null, call re_match or re_search,
|
|
which is what the user would probably do. */
|
|
if (str1 == NULL && str2 != NULL
|
|
|| str2 == NULL && str1 != NULL)
|
|
{
|
|
char *the_str = str1 == NULL ? str2 : str1;
|
|
|
|
match_1
|
|
= match_whole_string
|
|
? (r = re_match (&nonconst_buf, the_str,
|
|
strlen (the_str), start, ®s))
|
|
== strlen (the_str)
|
|
: (r = re_search (&nonconst_buf,
|
|
the_str, strlen (the_str),
|
|
start, range, ®s))
|
|
>= 0;
|
|
|
|
if (r == -2)
|
|
internal_error_1 = true;
|
|
}
|
|
else
|
|
match_1 = 1;
|
|
|
|
/* Also call with re_match_2 or re_search_2, as they might
|
|
do this. (Also can check calling with either string1
|
|
or string2 or both null.) */
|
|
if (match_whole_string)
|
|
{
|
|
r = re_match_2 (&nonconst_buf,
|
|
str1, SAFE_STRLEN (str1),
|
|
str2, SAFE_STRLEN (str2),
|
|
start, ®s, end);
|
|
match_2 = r == SAFE_STRLEN (str1) + SAFE_STRLEN (str2);
|
|
}
|
|
else
|
|
{
|
|
r = re_search_2 (&nonconst_buf,
|
|
str1, SAFE_STRLEN (str1),
|
|
str2, SAFE_STRLEN (str2),
|
|
start, range, ®s, end);
|
|
match_2 = r >= 0;
|
|
}
|
|
|
|
if (r == -2)
|
|
internal_error_2 = true;
|
|
|
|
match = match_1 & match_2;
|
|
|
|
if (correct_regs)
|
|
{
|
|
unsigned reg;
|
|
if (regs_correct != NULL)
|
|
free (regs_correct);
|
|
|
|
regs_correct
|
|
= (unsigned *) xmalloc (regs.num_regs * sizeof (unsigned));
|
|
|
|
for (reg = 0;
|
|
reg < regs.num_regs && reg < correct_regs->num_regs;
|
|
reg++)
|
|
{
|
|
regs_correct[reg]
|
|
= (regs.start[reg] == correct_regs->start[reg]
|
|
&& regs.end[reg] == correct_regs->end[reg])
|
|
#ifdef EMPTY_REGS_CONFUSED
|
|
/* There is confusion in the standard about
|
|
the registers in some patterns which can
|
|
match either the empty string or not match.
|
|
For example, in `((a*))*' against the empty
|
|
string, the two registers can either match
|
|
the empty string (be 0/0), or not match
|
|
(because of the outer *) (be -1/-1). (Or
|
|
one can do one and one can do the other.) */
|
|
|| (regs.start[reg] == -1 && regs.end[reg] == -1
|
|
&& correct_regs->start[reg]
|
|
== correct_regs->end[reg])
|
|
#endif
|
|
;
|
|
|
|
all_regs_correct &= regs_correct[reg];
|
|
}
|
|
}
|
|
} /* OK_TO_SEARCH */
|
|
}
|
|
}
|
|
|
|
if (fastmap_internal_error)
|
|
printf ("\n\nInternal error in re_compile_fastmap:");
|
|
|
|
if (internal_error_1)
|
|
{
|
|
if (!fastmap_internal_error)
|
|
printf ("\n");
|
|
|
|
printf ("\nInternal error in re_match or re_search:");
|
|
}
|
|
|
|
if (internal_error_2)
|
|
{
|
|
if (!internal_error_1)
|
|
printf ("\n");
|
|
|
|
printf ("\nInternal error in re_match_2 or re_search_2:");
|
|
}
|
|
|
|
if ((OK_TO_SEARCH && ((match && !test_should_match)
|
|
|| (!match && test_should_match))
|
|
|| (correct_regs && !all_regs_correct))
|
|
|| !nonconst_buf.fastmap_accurate
|
|
|| invalid_pattern
|
|
|| !pattern_should_be_valid
|
|
|| internal_error_1 || internal_error_2
|
|
|| verbose)
|
|
{
|
|
if (OK_TO_SEARCH && match && !test_should_match)
|
|
{
|
|
printf ("\n\nMatched but shouldn't have:\n");
|
|
if (match_1)
|
|
printf ("The single match/search succeeded.\n");
|
|
|
|
if (match_2)
|
|
printf ("The double match/search succeeded.\n");
|
|
}
|
|
else if (OK_TO_SEARCH && !match && test_should_match)
|
|
{
|
|
printf ("\n\nDidn't match but should have:\n");
|
|
if (!match_1)
|
|
printf ("The single match/search failed.\n");
|
|
|
|
if (!match_2)
|
|
printf ("The double match/search failed.\n");
|
|
}
|
|
else if (invalid_pattern && pattern_should_be_valid)
|
|
printf ("\n\nInvalid pattern (%s):\n", r);
|
|
else if (!nonconst_buf.fastmap_accurate && pattern_should_be_valid)
|
|
printf ("\n\nIncorrect fastmap:\n");
|
|
else if (OK_TO_SEARCH && correct_regs && !all_regs_correct)
|
|
printf ("\n\nNot all registers were correct:\n");
|
|
else if (verbose)
|
|
printf ("\n\nTest was OK:\n");
|
|
|
|
|
|
if ((!(invalid_pattern && !pattern_should_be_valid)) || verbose)
|
|
printf (" Pattern: `%s'.\n", pat);
|
|
|
|
if (pattern_should_be_valid || verbose
|
|
|| internal_error_1 || internal_error_2)
|
|
{
|
|
printf(" Strings: ");
|
|
printf ("`%s' and ", str1 == NULL ? "NULL" : str1);
|
|
printf ("`%s'.\n", str2 == NULL ? "NULL" : str2);
|
|
|
|
if ((OK_TO_SEARCH || verbose || internal_error_1 || internal_error_2)
|
|
&& !invalid_pattern)
|
|
{
|
|
if (memcmp (old_buf.buffer, nonconst_buf.buffer,
|
|
nonconst_buf.used) != 0
|
|
&& !invalid_pattern)
|
|
{
|
|
printf(" (%s)\n", r ? r : "Valid regular expression");
|
|
printf ("\n Compiled pattern before matching: ");
|
|
print_compiled_pattern (&old_buf);
|
|
printf ("\n Compiled pattern after matching: ");
|
|
}
|
|
else
|
|
printf ("\n Compiled pattern: ");
|
|
|
|
print_compiled_pattern (&nonconst_buf);
|
|
}
|
|
|
|
if (correct_fastmap && (!nonconst_buf.fastmap_accurate || verbose))
|
|
{
|
|
printf ("\n The fastmap should have been: ");
|
|
print_fastmap (correct_fastmap);
|
|
|
|
printf ("\n Fastmap: ");
|
|
print_fastmap (fastmap);
|
|
|
|
printf ("\n Compiled pattern before matching: ");
|
|
print_compiled_pattern (&nonconst_buf);
|
|
}
|
|
|
|
if ((!all_regs_correct || verbose) && correct_regs)
|
|
{
|
|
unsigned this_reg;
|
|
printf ("\n Incorrect registers:");
|
|
|
|
for (this_reg = 0; this_reg < regs.num_regs; this_reg++)
|
|
{
|
|
if (!regs_correct[this_reg])
|
|
{
|
|
printf ("\n Register %d's start was %2d. ", this_reg,
|
|
regs.start[this_reg]);
|
|
printf ("\tIt should have been %d.\n",
|
|
correct_regs->start[this_reg]);
|
|
printf (" Register %d's end was %2d. ", this_reg,
|
|
regs.end[this_reg]);
|
|
printf ("\tIt should have been %d.\n",
|
|
correct_regs->end[this_reg]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nonconst_buf.buffer != NULL)
|
|
free (nonconst_buf.buffer);
|
|
|
|
if (OK_TO_SEARCH)
|
|
{
|
|
free (old_buf.buffer);
|
|
|
|
if (correct_regs)
|
|
free (regs_correct);
|
|
|
|
}
|
|
|
|
nonconst_buf.buffer = old_buf.buffer = NULL;
|
|
regs_correct = NULL;
|
|
regs.start = regs.end = NULL;
|
|
|
|
} /* general_test */
|
|
|
|
|
|
void
|
|
test_search_return (match_start_wanted, pattern, string)
|
|
int match_start_wanted;
|
|
const char *pattern;
|
|
char *string;
|
|
{
|
|
struct re_pattern_buffer buf;
|
|
char fastmap[1 << BYTEWIDTH];
|
|
const char *compile_return;
|
|
int match_start;
|
|
static num_times_called = 0;
|
|
|
|
num_times_called++;
|
|
buf.allocated = 1;
|
|
buf.buffer = xmalloc (buf.allocated);
|
|
|
|
assert (pattern != NULL);
|
|
buf.translate = 0;
|
|
compile_return = re_compile_pattern (pattern, strlen (pattern), &buf);
|
|
|
|
if (compile_return)
|
|
{
|
|
printf ("\n\nInvalid pattern in test_match_start:\n");
|
|
printf ("%s\n", compile_return);
|
|
}
|
|
else
|
|
{
|
|
buf.fastmap = fastmap;
|
|
match_start = re_search (&buf, string, strlen (string),
|
|
0, strlen (string), 0);
|
|
|
|
if (match_start != match_start_wanted)
|
|
printf ("\nWanted search to start at %d but started at %d.\n",
|
|
match_start, match_start_wanted);
|
|
}
|
|
free (buf.buffer);
|
|
buf.buffer = NULL;
|
|
}
|
|
|
|
|
|
#define SET_FASTMAP() \
|
|
{ \
|
|
unsigned this_char; \
|
|
\
|
|
memset (correct_fastmap, invert, (1 << BYTEWIDTH)); \
|
|
\
|
|
for (this_char = 0; this_char < strlen (fastmap_string); this_char++)\
|
|
correct_fastmap[fastmap_string[this_char]] = !invert; \
|
|
correct_fastmap['\n'] = match_newline; \
|
|
}
|
|
|
|
|
|
void
|
|
test_fastmap (pat, fastmap_string, invert, match_newline)
|
|
const char *pat;
|
|
char *fastmap_string;
|
|
unsigned invert;
|
|
unsigned match_newline;
|
|
{
|
|
char correct_fastmap[(1 << BYTEWIDTH)];
|
|
|
|
SET_FASTMAP ();
|
|
general_test (1, 0, pat, NULL, NULL, -1, 0, -1, correct_fastmap, 0, -1);
|
|
}
|
|
|
|
|
|
void
|
|
test_fastmap_search (pat, str, fastmap_string, invert, match_newline,
|
|
can_be_null, start0, end0)
|
|
const char *pat;
|
|
char *str;
|
|
char *fastmap_string;
|
|
unsigned invert;
|
|
unsigned match_newline;
|
|
int can_be_null;
|
|
int start0;
|
|
int end0;
|
|
{
|
|
char correct_fastmap[(1 << BYTEWIDTH)];
|
|
struct re_registers correct_regs;
|
|
|
|
correct_regs.num_regs = RE_NREGS;
|
|
correct_regs.start = (int *) xmalloc (RE_NREGS * sizeof (int));
|
|
correct_regs.end = (int *) xmalloc (RE_NREGS * sizeof (int));
|
|
|
|
set_all_registers (start0, end0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, &correct_regs);
|
|
SET_FASTMAP ();
|
|
general_test (1, 0, pat, str, NULL, 0, SAFE_STRLEN (str), SAFE_STRLEN (str),
|
|
correct_fastmap, &correct_regs, can_be_null);
|
|
|
|
free (correct_regs.start);
|
|
free (correct_regs.end);
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
test_all_registers (pat, str1, str2,
|
|
start0, end0, start1, end1,
|
|
start2, end2, start3, end3,
|
|
start4, end4, start5, end5,
|
|
start6, end6, start7, end7,
|
|
start8, end8, start9, end9)
|
|
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;
|
|
{
|
|
struct re_registers correct_regs;
|
|
|
|
if (omit_register_tests) return;
|
|
|
|
correct_regs.num_regs = RE_NREGS;
|
|
correct_regs.start = (int *) xmalloc (RE_NREGS * sizeof (int));
|
|
correct_regs.end = (int *) xmalloc (RE_NREGS * sizeof (int));
|
|
|
|
set_all_registers (start0, end0, start1, end1, start2, end2, start3, end3,
|
|
start4, end4, start5, end5, start6, end6, start7, end7,
|
|
start8, end8, start9, end9, &correct_regs);
|
|
|
|
general_test (1, 0, pat, str1, str2, 0,
|
|
SAFE_STRLEN (str1) + SAFE_STRLEN (str2),
|
|
SAFE_STRLEN (str1) + SAFE_STRLEN (str2),
|
|
NULL, &correct_regs, -1);
|
|
|
|
free (correct_regs.start);
|
|
free (correct_regs.end);
|
|
}
|
|
|
|
|
|
void
|
|
invalid_pattern (error_code_expected, pattern)
|
|
int error_code_expected;
|
|
char *pattern;
|
|
{
|
|
regex_t pattern_buffer;
|
|
int cflags
|
|
= re_syntax_options == RE_SYNTAX_POSIX_EXTENDED
|
|
|| re_syntax_options == RE_SYNTAX_POSIX_MINIMAL_EXTENDED
|
|
? REG_EXTENDED : 0;
|
|
|
|
test_compile (0, error_code_expected, pattern, &pattern_buffer, cflags);
|
|
}
|
|
|
|
|
|
void
|
|
valid_pattern (pattern)
|
|
char *pattern;
|
|
{
|
|
regex_t pattern_buffer;
|
|
int cflags
|
|
= re_syntax_options == RE_SYNTAX_POSIX_EXTENDED
|
|
|| re_syntax_options == RE_SYNTAX_POSIX_MINIMAL_EXTENDED
|
|
? REG_EXTENDED : 0;
|
|
|
|
test_compile (1, 0, pattern, &pattern_buffer, cflags);
|
|
}
|
|
|
|
|
|
char *
|
|
delimiters_to_ops (source, left_delimiter, right_delimiter)
|
|
char *source;
|
|
char left_delimiter;
|
|
char right_delimiter;
|
|
{
|
|
static char *answer = NULL;
|
|
char *tmp = NULL;
|
|
boolean double_size = false;
|
|
unsigned source_char;
|
|
unsigned answer_char = 0;
|
|
|
|
assert (source != NULL);
|
|
|
|
switch (left_delimiter)
|
|
{
|
|
case '(': if (!(re_syntax_options & RE_NO_BK_PARENS))
|
|
double_size = true;
|
|
break;
|
|
case '{': if (!(re_syntax_options & RE_NO_BK_BRACES))
|
|
double_size = true;
|
|
break;
|
|
default: printf ("Found strange delimiter %c in delimiter_to_ops.\n",
|
|
left_delimiter);
|
|
printf ("The source was `%s'\n", source);
|
|
exit (0);
|
|
}
|
|
|
|
if (answer == source)
|
|
{
|
|
tmp = (char *) xmalloc (strlen (source) + 1);
|
|
strcpy (tmp, source);
|
|
source = tmp;
|
|
}
|
|
|
|
if (answer)
|
|
{
|
|
free (answer);
|
|
answer = NULL;
|
|
}
|
|
|
|
answer = (char *) xmalloc ((double_size
|
|
? strlen (source) << 1
|
|
: strlen (source))
|
|
+ 1);
|
|
if (!double_size)
|
|
strcpy (answer, source);
|
|
else
|
|
{
|
|
for (source_char = 0; source_char < strlen (source); source_char++)
|
|
{
|
|
if (source[source_char] == left_delimiter
|
|
|| source[source_char] == right_delimiter)
|
|
answer[answer_char++] = '\\';
|
|
|
|
answer[answer_char++] = source[source_char];
|
|
}
|
|
answer[answer_char] = 0;
|
|
}
|
|
|
|
return answer;
|
|
}
|
|
|
|
|
|
void
|
|
print_pattern_info (pattern, pattern_buffer_ptr)
|
|
const char *pattern;
|
|
regex_t *pattern_buffer_ptr;
|
|
{
|
|
printf (" Pattern: `%s'.\n", pattern);
|
|
printf (" Compiled pattern: ");
|
|
print_compiled_pattern (pattern_buffer_ptr);
|
|
}
|
|
|
|
|
|
void
|
|
valid_nonposix_pattern (pattern)
|
|
char *pattern;
|
|
{
|
|
struct re_pattern_buffer nonconst_buf;
|
|
|
|
nonconst_buf.allocated = 0;
|
|
nonconst_buf.buffer = NULL;
|
|
nonconst_buf.translate = NULL;
|
|
|
|
assert (pattern != NULL);
|
|
|
|
if (re_compile_pattern (pattern, strlen (pattern), &nonconst_buf))
|
|
{
|
|
printf ("Couldn't compile the pattern.\n");
|
|
print_pattern_info (pattern, &nonconst_buf);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
compile_and_print_pattern (pattern)
|
|
char *pattern;
|
|
{
|
|
struct re_pattern_buffer nonconst_buf;
|
|
|
|
nonconst_buf.allocated = 0;
|
|
nonconst_buf.buffer = NULL;
|
|
|
|
if (re_compile_pattern (pattern, strlen (pattern), &nonconst_buf))
|
|
printf ("Couldn't compile the pattern.\n");
|
|
|
|
print_pattern_info (pattern, &nonconst_buf);
|
|
}
|
|
|
|
|
|
void
|
|
test_case_fold (pattern, string)
|
|
const char *pattern;
|
|
char* string;
|
|
{
|
|
struct re_pattern_buffer nonconst_buf;
|
|
const char *ret;
|
|
|
|
init_pattern_buffer (&nonconst_buf);
|
|
nonconst_buf.translate = upcase;
|
|
|
|
assert (pattern != NULL);
|
|
ret = re_compile_pattern (pattern, strlen (pattern), &nonconst_buf);
|
|
|
|
if (ret)
|
|
{
|
|
printf ("\nShould have been a valid pattern but wasn't.\n");
|
|
print_pattern_info (pattern, &nonconst_buf);
|
|
}
|
|
else
|
|
{
|
|
if (test_should_match
|
|
&& re_match (&nonconst_buf, string, strlen (string), 0, 0)
|
|
!= strlen (string))
|
|
{
|
|
printf ("Match failed for case fold.\n");
|
|
printf (" Pattern: `%s'.\n", pattern);
|
|
printf (" String: `%s'.\n", string == NULL ? "NULL" : string);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
test_match_n_times (n, pattern, string)
|
|
unsigned n;
|
|
char* pattern;
|
|
char* string;
|
|
{
|
|
struct re_pattern_buffer buf;
|
|
const char *r;
|
|
unsigned match = 0;
|
|
unsigned this_match;
|
|
|
|
buf.allocated = 0;
|
|
buf.buffer = NULL;
|
|
buf.translate = 0;
|
|
|
|
assert (pattern != NULL);
|
|
|
|
r = re_compile_pattern (pattern, strlen (pattern), &buf);
|
|
if (r)
|
|
{
|
|
printf ("Didn't compile.\n");
|
|
printf (" Pattern: %s.\n", pattern);
|
|
}
|
|
else
|
|
{
|
|
for (this_match = 1; this_match <= n; this_match++)
|
|
match = (re_match (&buf, string, strlen (string),
|
|
0, 0)
|
|
== strlen (string));
|
|
|
|
if (match && !test_should_match)
|
|
printf ("\n\nMatched but shouldn't have:\n");
|
|
else if (!match && test_should_match)
|
|
printf ("\n\nDidn't match but should have:\n");
|
|
|
|
if ((match && !test_should_match) || (!match && test_should_match))
|
|
{
|
|
printf(" The string to match was: ");
|
|
if (string)
|
|
printf ("`%s' and ", string);
|
|
else
|
|
printf ("`'");
|
|
|
|
printf (" Pattern: %s.\n", pattern);
|
|
printf (" Compiled pattern: %s.\n", pattern);
|
|
print_compiled_pattern (&buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
test_match_2 (pat, str1, str2)
|
|
const char *pat;
|
|
char *str1;
|
|
char *str2;
|
|
{
|
|
general_test (1, 1, pat, str1, str2, 0, 1,
|
|
SAFE_STRLEN (str1) + SAFE_STRLEN (str2), NULL, 0, -1);
|
|
}
|
|
|
|
void
|
|
test_match (pat, str)
|
|
const char *pat;
|
|
char *str;
|
|
{
|
|
test_match_2 (pat, str, NULL);
|
|
test_match_2 (pat, NULL, str);
|
|
}
|