1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
/*************************************************
* PCRE2 POSIX interface test program *
*************************************************/
/*
Written by Philip Hazel, December 2022
Copyright (c) 2022
File last edited: December 2022
This program tests the POSIX wrapper to the PCRE2 regular expression library.
The main PCRE2 test program is pcre2test, which also tests these function
calls. This little program is needed to test the case where the client includes
pcre2posix.h but not pcre2.h, mainly to make sure that it builds successfully.
However, the code is written as a flexible test program to which extra tests
can be added.
Compile with -lpcre2-posix -lpcre2-8
If run with no options, there is no output on success, and the return code is
zero. If any test fails there is output to stderr, and the return code is 1.
For testing purposes, the "-v" option causes verification output to be written
to stdout. */
#include <stdio.h>
#include <string.h>
#include <pcre2posix.h>
#define CAPCOUNT 5 /* Number of captures supported */
#define PRINTF if (v) printf /* Shorthand for testing output */
/* This vector contains compiler flags for each pattern that is tested. */
static int cflags[] = {
0, /* Test 0 */
REG_ICASE, /* Test 1 */
0, /* Test 2 */
REG_NEWLINE, /* Test 3 */
0 /* Test 4 */
};
/* This vector contains match flags for each pattern that is tested. */
static int mflags[] = {
0, /* Test 0 */
0, /* Test 1 */
0, /* Test 2 */
REG_NOTBOL, /* Test 3 */
0 /* Test 4 */
};
/* Automate the number of patterns */
#define count (int)(sizeof(cflags)/sizeof(int))
/* The data for each pattern consists of a pattern string, followed by any
number of subject strings, terminated by NULL. Some tests share data, but use
different flags. */
static const char *data0_1[] = { "posix", "lower posix", "upper POSIX", NULL };
static const char *data2_3[] = { "^(cat|dog)", "catastrophic\ncataclysm",
"dogfight", "no animals", NULL };
static const char *data4[] = { "*badpattern", NULL };
/* Index the data strings */
static char **data[] = {
(char **)(&data0_1),
(char **)(&data0_1),
(char **)(&data2_3),
(char **)(&data2_3),
(char **)(&data4)
};
/* The expected results for each pattern consist of a compiler return code,
optionally followed, for each subject string, by a match return code and, for a
successful match, up to CAPCOUNT pairs of returned match data. */
static int results0[] = {
0, /* Compiler rc */
0, 6, 11, /* 1st match */
REG_NOMATCH /* 2nd match */
};
static int results1[] = {
0, /* Compiler rc */
0, 6, 11, /* 1st match */
0, 6, 11 /* 2nd match */
};
static int results2[] = {
0, /* Compiler rc */
0, 0, 3, 0, 3, /* 1st match */
0, 0, 3, 0, 3, /* 2nd match */
REG_NOMATCH /* 3rd match */
};
static int results3[] = {
0, /* Compiler rc */
0, 13, 16, 13, 16, /* 1st match */
REG_NOMATCH, /* 2nd match */
REG_NOMATCH /* 3rd match */
};
static int results4[] = {
REG_BADRPT /* Compiler rc */
};
/* Index the result vectors */
static int *results[] = {
(int *)(&results0),
(int *)(&results1),
(int *)(&results2),
(int *)(&results3),
(int *)(&results4)
};
/* And here is the program */
int main(int argc, char **argv)
{
regex_t re;
regmatch_t match[CAPCOUNT];
int v = argc > 1 && strcmp(argv[1], "-v") == 0;
PRINTF("Test of pcre2posix.h without pcre2.h\n");
for (int i = 0; i < count; i++)
{
char *pattern = data[i][0];
char **subjects = data[i] + 1;
int *rd = results[i];
int rc = regcomp(&re, pattern, cflags[i]);
PRINTF("Pattern: %s flags=0x%02x\n", pattern, cflags[i]);
if (rc != *rd)
{
fprintf(stderr, "Unexpected compile error %d (expected %d)\n", rc, *rd);
fprintf(stderr, "Pattern is: %s\n", pattern);
return 1;
}
if (rc != 0)
{
if (v)
{
char buffer[256];
(void)regerror(rc, &re, buffer, sizeof(buffer));
PRINTF("Compile error %d: %s (expected)\n", rc, buffer);
}
continue;
}
for (; *subjects != NULL; subjects++)
{
rc = regexec(&re, *subjects, CAPCOUNT, match, mflags[i]);
PRINTF("Subject: %s\n", *subjects);
PRINTF("Return: %d", rc);
if (rc != *(++rd))
{
PRINTF("\n");
fprintf(stderr, "Unexpected match error %d (expected %d)\n", rc, *rd);
fprintf(stderr, "Pattern is: %s\n", pattern);
fprintf(stderr, "Subject is: %s\n", *subjects);
return 1;
}
if (rc == 0)
{
for (int j = 0; j < CAPCOUNT; j++)
{
regmatch_t *m = match + j;
if (m->rm_so < 0) continue;
if (m->rm_so != *(++rd) || m->rm_eo != *(++rd))
{
PRINTF("\n");
fprintf(stderr, "Mismatched results for successful match\n");
fprintf(stderr, "Pattern is: %s\n", pattern);
fprintf(stderr, "Subject is: %s\n", *subjects);
fprintf(stderr, "Result %d: expected %d %d received %d %d\n",
j, rd[-1], rd[0], m->rm_so, m->rm_eo);
return 1;
}
PRINTF(" (%d %d %d)", j, m->rm_so, m->rm_eo);
}
}
else if (v)
{
char buffer[256];
(void)regerror(rc, &re, buffer, sizeof(buffer));
PRINTF(": %s (expected)", buffer);
}
PRINTF("\n");
}
regfree(&re);
}
PRINTF("End of test\n");
return 0;
}
/* End of pcre2posix_test.c */
|
