diff options
Diffstat (limited to 'regress/unittests/test_helper')
-rw-r--r-- | regress/unittests/test_helper/Makefile | 13 | ||||
-rw-r--r-- | regress/unittests/test_helper/fuzz.c | 378 | ||||
-rw-r--r-- | regress/unittests/test_helper/test_helper.c | 471 | ||||
-rw-r--r-- | regress/unittests/test_helper/test_helper.h | 292 |
4 files changed, 1154 insertions, 0 deletions
diff --git a/regress/unittests/test_helper/Makefile b/regress/unittests/test_helper/Makefile new file mode 100644 index 000000000..3e90903ef --- /dev/null +++ b/regress/unittests/test_helper/Makefile | |||
@@ -0,0 +1,13 @@ | |||
1 | # $OpenBSD: Makefile,v 1.1 2014/04/30 05:32:00 djm Exp $ | ||
2 | |||
3 | LIB= test_helper | ||
4 | SRCS= test_helper.c fuzz.c | ||
5 | |||
6 | DEBUGLIBS= no | ||
7 | NOPROFILE= yes | ||
8 | NOPIC= yes | ||
9 | |||
10 | install: | ||
11 | @echo -n | ||
12 | |||
13 | .include <bsd.lib.mk> | ||
diff --git a/regress/unittests/test_helper/fuzz.c b/regress/unittests/test_helper/fuzz.c new file mode 100644 index 000000000..77c6e7cad --- /dev/null +++ b/regress/unittests/test_helper/fuzz.c | |||
@@ -0,0 +1,378 @@ | |||
1 | /* $OpenBSD: fuzz.c,v 1.3 2014/05/02 09:41:32 andre Exp $ */ | ||
2 | /* | ||
3 | * Copyright (c) 2011 Damien Miller <djm@mindrot.org> | ||
4 | * | ||
5 | * Permission to use, copy, modify, and distribute this software for any | ||
6 | * purpose with or without fee is hereby granted, provided that the above | ||
7 | * copyright notice and this permission notice appear in all copies. | ||
8 | * | ||
9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
16 | */ | ||
17 | |||
18 | /* Utility functions/framework for fuzz tests */ | ||
19 | |||
20 | #include "includes.h" | ||
21 | |||
22 | #include <sys/types.h> | ||
23 | |||
24 | #include <assert.h> | ||
25 | #include <ctype.h> | ||
26 | #include <stdio.h> | ||
27 | #ifdef HAVE_STDINT_H | ||
28 | # include <stdint.h> | ||
29 | #endif | ||
30 | #include <stdlib.h> | ||
31 | #include <string.h> | ||
32 | #include <assert.h> | ||
33 | |||
34 | #include "test_helper.h" | ||
35 | |||
36 | /* #define FUZZ_DEBUG */ | ||
37 | |||
38 | #ifdef FUZZ_DEBUG | ||
39 | # define FUZZ_DBG(x) do { \ | ||
40 | printf("%s:%d %s: ", __FILE__, __LINE__, __func__); \ | ||
41 | printf x; \ | ||
42 | printf("\n"); \ | ||
43 | fflush(stdout); \ | ||
44 | } while (0) | ||
45 | #else | ||
46 | # define FUZZ_DBG(x) | ||
47 | #endif | ||
48 | |||
49 | /* For brevity later */ | ||
50 | typedef unsigned long long fuzz_ullong; | ||
51 | |||
52 | /* For base-64 fuzzing */ | ||
53 | static const char fuzz_b64chars[] = | ||
54 | "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; | ||
55 | |||
56 | struct fuzz { | ||
57 | /* Fuzz method currently in use */ | ||
58 | int strategy; | ||
59 | |||
60 | /* Fuzz methods remaining */ | ||
61 | int strategies; | ||
62 | |||
63 | /* Original seed data blob */ | ||
64 | void *seed; | ||
65 | size_t slen; | ||
66 | |||
67 | /* Current working copy of seed with fuzz mutations applied */ | ||
68 | u_char *fuzzed; | ||
69 | |||
70 | /* Used by fuzz methods */ | ||
71 | size_t o1, o2; | ||
72 | }; | ||
73 | |||
74 | static const char * | ||
75 | fuzz_ntop(u_int n) | ||
76 | { | ||
77 | switch (n) { | ||
78 | case 0: | ||
79 | return "NONE"; | ||
80 | case FUZZ_1_BIT_FLIP: | ||
81 | return "FUZZ_1_BIT_FLIP"; | ||
82 | case FUZZ_2_BIT_FLIP: | ||
83 | return "FUZZ_2_BIT_FLIP"; | ||
84 | case FUZZ_1_BYTE_FLIP: | ||
85 | return "FUZZ_1_BYTE_FLIP"; | ||
86 | case FUZZ_2_BYTE_FLIP: | ||
87 | return "FUZZ_2_BYTE_FLIP"; | ||
88 | case FUZZ_TRUNCATE_START: | ||
89 | return "FUZZ_TRUNCATE_START"; | ||
90 | case FUZZ_TRUNCATE_END: | ||
91 | return "FUZZ_TRUNCATE_END"; | ||
92 | case FUZZ_BASE64: | ||
93 | return "FUZZ_BASE64"; | ||
94 | default: | ||
95 | abort(); | ||
96 | } | ||
97 | } | ||
98 | |||
99 | void | ||
100 | fuzz_dump(struct fuzz *fuzz) | ||
101 | { | ||
102 | u_char *p = fuzz_ptr(fuzz); | ||
103 | size_t i, j, len = fuzz_len(fuzz); | ||
104 | |||
105 | switch (fuzz->strategy) { | ||
106 | case FUZZ_1_BIT_FLIP: | ||
107 | fprintf(stderr, "%s case %zu of %zu (bit: %zu)\n", | ||
108 | fuzz_ntop(fuzz->strategy), | ||
109 | fuzz->o1, fuzz->slen * 8, fuzz->o1); | ||
110 | break; | ||
111 | case FUZZ_2_BIT_FLIP: | ||
112 | fprintf(stderr, "%s case %llu of %llu (bits: %zu, %zu)\n", | ||
113 | fuzz_ntop(fuzz->strategy), | ||
114 | (((fuzz_ullong)fuzz->o2) * fuzz->slen * 8) + fuzz->o1, | ||
115 | ((fuzz_ullong)fuzz->slen * 8) * fuzz->slen * 8, | ||
116 | fuzz->o1, fuzz->o2); | ||
117 | break; | ||
118 | case FUZZ_1_BYTE_FLIP: | ||
119 | fprintf(stderr, "%s case %zu of %zu (byte: %zu)\n", | ||
120 | fuzz_ntop(fuzz->strategy), | ||
121 | fuzz->o1, fuzz->slen, fuzz->o1); | ||
122 | break; | ||
123 | case FUZZ_2_BYTE_FLIP: | ||
124 | fprintf(stderr, "%s case %llu of %llu (bytes: %zu, %zu)\n", | ||
125 | fuzz_ntop(fuzz->strategy), | ||
126 | (((fuzz_ullong)fuzz->o2) * fuzz->slen) + fuzz->o1, | ||
127 | ((fuzz_ullong)fuzz->slen) * fuzz->slen, | ||
128 | fuzz->o1, fuzz->o2); | ||
129 | break; | ||
130 | case FUZZ_TRUNCATE_START: | ||
131 | fprintf(stderr, "%s case %zu of %zu (offset: %zu)\n", | ||
132 | fuzz_ntop(fuzz->strategy), | ||
133 | fuzz->o1, fuzz->slen, fuzz->o1); | ||
134 | break; | ||
135 | case FUZZ_TRUNCATE_END: | ||
136 | fprintf(stderr, "%s case %zu of %zu (offset: %zu)\n", | ||
137 | fuzz_ntop(fuzz->strategy), | ||
138 | fuzz->o1, fuzz->slen, fuzz->o1); | ||
139 | break; | ||
140 | case FUZZ_BASE64: | ||
141 | assert(fuzz->o2 < sizeof(fuzz_b64chars) - 1); | ||
142 | fprintf(stderr, "%s case %llu of %llu (offset: %zu char: %c)\n", | ||
143 | fuzz_ntop(fuzz->strategy), | ||
144 | (fuzz->o1 * (fuzz_ullong)64) + fuzz->o2, | ||
145 | fuzz->slen * (fuzz_ullong)64, fuzz->o1, | ||
146 | fuzz_b64chars[fuzz->o2]); | ||
147 | break; | ||
148 | default: | ||
149 | abort(); | ||
150 | } | ||
151 | |||
152 | fprintf(stderr, "fuzz context %p len = %zu\n", fuzz, len); | ||
153 | for (i = 0; i < len; i += 16) { | ||
154 | fprintf(stderr, "%.4zd: ", i); | ||
155 | for (j = i; j < i + 16; j++) { | ||
156 | if (j < len) | ||
157 | fprintf(stderr, "%02x ", p[j]); | ||
158 | else | ||
159 | fprintf(stderr, " "); | ||
160 | } | ||
161 | fprintf(stderr, " "); | ||
162 | for (j = i; j < i + 16; j++) { | ||
163 | if (j < len) { | ||
164 | if (isascii(p[j]) && isprint(p[j])) | ||
165 | fprintf(stderr, "%c", p[j]); | ||
166 | else | ||
167 | fprintf(stderr, "."); | ||
168 | } | ||
169 | } | ||
170 | fprintf(stderr, "\n"); | ||
171 | } | ||
172 | } | ||
173 | |||
174 | struct fuzz * | ||
175 | fuzz_begin(u_int strategies, const void *p, size_t l) | ||
176 | { | ||
177 | struct fuzz *ret = calloc(sizeof(*ret), 1); | ||
178 | |||
179 | assert(p != NULL); | ||
180 | assert(ret != NULL); | ||
181 | ret->seed = malloc(l); | ||
182 | assert(ret->seed != NULL); | ||
183 | memcpy(ret->seed, p, l); | ||
184 | ret->slen = l; | ||
185 | ret->strategies = strategies; | ||
186 | |||
187 | assert(ret->slen < SIZE_MAX / 8); | ||
188 | assert(ret->strategies <= (FUZZ_MAX|(FUZZ_MAX-1))); | ||
189 | |||
190 | FUZZ_DBG(("begin, ret = %p", ret)); | ||
191 | |||
192 | fuzz_next(ret); | ||
193 | return ret; | ||
194 | } | ||
195 | |||
196 | void | ||
197 | fuzz_cleanup(struct fuzz *fuzz) | ||
198 | { | ||
199 | FUZZ_DBG(("cleanup, fuzz = %p", fuzz)); | ||
200 | assert(fuzz != NULL); | ||
201 | assert(fuzz->seed != NULL); | ||
202 | assert(fuzz->fuzzed != NULL); | ||
203 | free(fuzz->seed); | ||
204 | free(fuzz->fuzzed); | ||
205 | free(fuzz); | ||
206 | } | ||
207 | |||
208 | static int | ||
209 | fuzz_strategy_done(struct fuzz *fuzz) | ||
210 | { | ||
211 | FUZZ_DBG(("fuzz = %p, strategy = %s, o1 = %zu, o2 = %zu, slen = %zu", | ||
212 | fuzz, fuzz_ntop(fuzz->strategy), fuzz->o1, fuzz->o2, fuzz->slen)); | ||
213 | |||
214 | switch (fuzz->strategy) { | ||
215 | case FUZZ_1_BIT_FLIP: | ||
216 | return fuzz->o1 >= fuzz->slen * 8; | ||
217 | case FUZZ_2_BIT_FLIP: | ||
218 | return fuzz->o2 >= fuzz->slen * 8; | ||
219 | case FUZZ_2_BYTE_FLIP: | ||
220 | return fuzz->o2 >= fuzz->slen; | ||
221 | case FUZZ_1_BYTE_FLIP: | ||
222 | case FUZZ_TRUNCATE_START: | ||
223 | case FUZZ_TRUNCATE_END: | ||
224 | case FUZZ_BASE64: | ||
225 | return fuzz->o1 >= fuzz->slen; | ||
226 | default: | ||
227 | abort(); | ||
228 | } | ||
229 | } | ||
230 | |||
231 | void | ||
232 | fuzz_next(struct fuzz *fuzz) | ||
233 | { | ||
234 | u_int i; | ||
235 | |||
236 | FUZZ_DBG(("start, fuzz = %p, strategy = %s, strategies = 0x%lx, " | ||
237 | "o1 = %zu, o2 = %zu, slen = %zu", fuzz, fuzz_ntop(fuzz->strategy), | ||
238 | (u_long)fuzz->strategies, fuzz->o1, fuzz->o2, fuzz->slen)); | ||
239 | |||
240 | if (fuzz->strategy == 0 || fuzz_strategy_done(fuzz)) { | ||
241 | /* If we are just starting out, we need to allocate too */ | ||
242 | if (fuzz->fuzzed == NULL) { | ||
243 | FUZZ_DBG(("alloc")); | ||
244 | fuzz->fuzzed = calloc(fuzz->slen, 1); | ||
245 | } | ||
246 | /* Pick next strategy */ | ||
247 | FUZZ_DBG(("advance")); | ||
248 | for (i = 1; i <= FUZZ_MAX; i <<= 1) { | ||
249 | if ((fuzz->strategies & i) != 0) { | ||
250 | fuzz->strategy = i; | ||
251 | break; | ||
252 | } | ||
253 | } | ||
254 | FUZZ_DBG(("selected = %u", fuzz->strategy)); | ||
255 | if (fuzz->strategy == 0) { | ||
256 | FUZZ_DBG(("done, no more strategies")); | ||
257 | return; | ||
258 | } | ||
259 | fuzz->strategies &= ~(fuzz->strategy); | ||
260 | fuzz->o1 = fuzz->o2 = 0; | ||
261 | } | ||
262 | |||
263 | assert(fuzz->fuzzed != NULL); | ||
264 | |||
265 | switch (fuzz->strategy) { | ||
266 | case FUZZ_1_BIT_FLIP: | ||
267 | assert(fuzz->o1 / 8 < fuzz->slen); | ||
268 | memcpy(fuzz->fuzzed, fuzz->seed, fuzz->slen); | ||
269 | fuzz->fuzzed[fuzz->o1 / 8] ^= 1 << (fuzz->o1 % 8); | ||
270 | fuzz->o1++; | ||
271 | break; | ||
272 | case FUZZ_2_BIT_FLIP: | ||
273 | assert(fuzz->o1 / 8 < fuzz->slen); | ||
274 | assert(fuzz->o2 / 8 < fuzz->slen); | ||
275 | memcpy(fuzz->fuzzed, fuzz->seed, fuzz->slen); | ||
276 | fuzz->fuzzed[fuzz->o1 / 8] ^= 1 << (fuzz->o1 % 8); | ||
277 | fuzz->fuzzed[fuzz->o2 / 8] ^= 1 << (fuzz->o2 % 8); | ||
278 | fuzz->o1++; | ||
279 | if (fuzz->o1 >= fuzz->slen * 8) { | ||
280 | fuzz->o1 = 0; | ||
281 | fuzz->o2++; | ||
282 | } | ||
283 | break; | ||
284 | case FUZZ_1_BYTE_FLIP: | ||
285 | assert(fuzz->o1 < fuzz->slen); | ||
286 | memcpy(fuzz->fuzzed, fuzz->seed, fuzz->slen); | ||
287 | fuzz->fuzzed[fuzz->o1] ^= 0xff; | ||
288 | fuzz->o1++; | ||
289 | break; | ||
290 | case FUZZ_2_BYTE_FLIP: | ||
291 | assert(fuzz->o1 < fuzz->slen); | ||
292 | assert(fuzz->o2 < fuzz->slen); | ||
293 | memcpy(fuzz->fuzzed, fuzz->seed, fuzz->slen); | ||
294 | fuzz->fuzzed[fuzz->o1] ^= 0xff; | ||
295 | fuzz->fuzzed[fuzz->o2] ^= 0xff; | ||
296 | fuzz->o1++; | ||
297 | if (fuzz->o1 >= fuzz->slen) { | ||
298 | fuzz->o1 = 0; | ||
299 | fuzz->o2++; | ||
300 | } | ||
301 | break; | ||
302 | case FUZZ_TRUNCATE_START: | ||
303 | case FUZZ_TRUNCATE_END: | ||
304 | assert(fuzz->o1 < fuzz->slen); | ||
305 | memcpy(fuzz->fuzzed, fuzz->seed, fuzz->slen); | ||
306 | fuzz->o1++; | ||
307 | break; | ||
308 | case FUZZ_BASE64: | ||
309 | assert(fuzz->o1 < fuzz->slen); | ||
310 | assert(fuzz->o2 < sizeof(fuzz_b64chars) - 1); | ||
311 | memcpy(fuzz->fuzzed, fuzz->seed, fuzz->slen); | ||
312 | fuzz->fuzzed[fuzz->o1] = fuzz_b64chars[fuzz->o2]; | ||
313 | fuzz->o2++; | ||
314 | if (fuzz->o2 >= sizeof(fuzz_b64chars) - 1) { | ||
315 | fuzz->o2 = 0; | ||
316 | fuzz->o1++; | ||
317 | } | ||
318 | break; | ||
319 | default: | ||
320 | abort(); | ||
321 | } | ||
322 | |||
323 | FUZZ_DBG(("done, fuzz = %p, strategy = %s, strategies = 0x%lx, " | ||
324 | "o1 = %zu, o2 = %zu, slen = %zu", fuzz, fuzz_ntop(fuzz->strategy), | ||
325 | (u_long)fuzz->strategies, fuzz->o1, fuzz->o2, fuzz->slen)); | ||
326 | } | ||
327 | |||
328 | int | ||
329 | fuzz_done(struct fuzz *fuzz) | ||
330 | { | ||
331 | FUZZ_DBG(("fuzz = %p, strategies = 0x%lx", fuzz, | ||
332 | (u_long)fuzz->strategies)); | ||
333 | |||
334 | return fuzz_strategy_done(fuzz) && fuzz->strategies == 0; | ||
335 | } | ||
336 | |||
337 | size_t | ||
338 | fuzz_len(struct fuzz *fuzz) | ||
339 | { | ||
340 | assert(fuzz->fuzzed != NULL); | ||
341 | switch (fuzz->strategy) { | ||
342 | case FUZZ_1_BIT_FLIP: | ||
343 | case FUZZ_2_BIT_FLIP: | ||
344 | case FUZZ_1_BYTE_FLIP: | ||
345 | case FUZZ_2_BYTE_FLIP: | ||
346 | case FUZZ_BASE64: | ||
347 | return fuzz->slen; | ||
348 | case FUZZ_TRUNCATE_START: | ||
349 | case FUZZ_TRUNCATE_END: | ||
350 | assert(fuzz->o1 <= fuzz->slen); | ||
351 | return fuzz->slen - fuzz->o1; | ||
352 | default: | ||
353 | abort(); | ||
354 | } | ||
355 | } | ||
356 | |||
357 | u_char * | ||
358 | fuzz_ptr(struct fuzz *fuzz) | ||
359 | { | ||
360 | assert(fuzz->fuzzed != NULL); | ||
361 | switch (fuzz->strategy) { | ||
362 | case FUZZ_1_BIT_FLIP: | ||
363 | case FUZZ_2_BIT_FLIP: | ||
364 | case FUZZ_1_BYTE_FLIP: | ||
365 | case FUZZ_2_BYTE_FLIP: | ||
366 | case FUZZ_BASE64: | ||
367 | return fuzz->fuzzed; | ||
368 | case FUZZ_TRUNCATE_START: | ||
369 | assert(fuzz->o1 <= fuzz->slen); | ||
370 | return fuzz->fuzzed + fuzz->o1; | ||
371 | case FUZZ_TRUNCATE_END: | ||
372 | assert(fuzz->o1 <= fuzz->slen); | ||
373 | return fuzz->fuzzed; | ||
374 | default: | ||
375 | abort(); | ||
376 | } | ||
377 | } | ||
378 | |||
diff --git a/regress/unittests/test_helper/test_helper.c b/regress/unittests/test_helper/test_helper.c new file mode 100644 index 000000000..d0bc67833 --- /dev/null +++ b/regress/unittests/test_helper/test_helper.c | |||
@@ -0,0 +1,471 @@ | |||
1 | /* $OpenBSD: test_helper.c,v 1.2 2014/05/02 09:41:32 andre Exp $ */ | ||
2 | /* | ||
3 | * Copyright (c) 2011 Damien Miller <djm@mindrot.org> | ||
4 | * | ||
5 | * Permission to use, copy, modify, and distribute this software for any | ||
6 | * purpose with or without fee is hereby granted, provided that the above | ||
7 | * copyright notice and this permission notice appear in all copies. | ||
8 | * | ||
9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
16 | */ | ||
17 | |||
18 | /* Utility functions/framework for regress tests */ | ||
19 | |||
20 | #include "includes.h" | ||
21 | |||
22 | #include <sys/types.h> | ||
23 | #include <sys/param.h> | ||
24 | |||
25 | #include <fcntl.h> | ||
26 | #include <stdio.h> | ||
27 | #ifdef HAVE_STDINT_H | ||
28 | # include <stdint.h> | ||
29 | #endif | ||
30 | #include <stdlib.h> | ||
31 | #include <string.h> | ||
32 | #include <assert.h> | ||
33 | #include <unistd.h> | ||
34 | |||
35 | #include <openssl/bn.h> | ||
36 | |||
37 | #if defined(HAVE_STRNVIS) && defined(HAVE_VIS_H) && !defined(BROKEN_STRNVIS) | ||
38 | # include <vis.h> | ||
39 | #endif | ||
40 | |||
41 | #include "test_helper.h" | ||
42 | |||
43 | #define TEST_CHECK_INT(r, pred) do { \ | ||
44 | switch (pred) { \ | ||
45 | case TEST_EQ: \ | ||
46 | if (r == 0) \ | ||
47 | return; \ | ||
48 | break; \ | ||
49 | case TEST_NE: \ | ||
50 | if (r != 0) \ | ||
51 | return; \ | ||
52 | break; \ | ||
53 | case TEST_LT: \ | ||
54 | if (r < 0) \ | ||
55 | return; \ | ||
56 | break; \ | ||
57 | case TEST_LE: \ | ||
58 | if (r <= 0) \ | ||
59 | return; \ | ||
60 | break; \ | ||
61 | case TEST_GT: \ | ||
62 | if (r > 0) \ | ||
63 | return; \ | ||
64 | break; \ | ||
65 | case TEST_GE: \ | ||
66 | if (r >= 0) \ | ||
67 | return; \ | ||
68 | break; \ | ||
69 | default: \ | ||
70 | abort(); \ | ||
71 | } \ | ||
72 | } while (0) | ||
73 | |||
74 | #define TEST_CHECK(x1, x2, pred) do { \ | ||
75 | switch (pred) { \ | ||
76 | case TEST_EQ: \ | ||
77 | if (x1 == x2) \ | ||
78 | return; \ | ||
79 | break; \ | ||
80 | case TEST_NE: \ | ||
81 | if (x1 != x2) \ | ||
82 | return; \ | ||
83 | break; \ | ||
84 | case TEST_LT: \ | ||
85 | if (x1 < x2) \ | ||
86 | return; \ | ||
87 | break; \ | ||
88 | case TEST_LE: \ | ||
89 | if (x1 <= x2) \ | ||
90 | return; \ | ||
91 | break; \ | ||
92 | case TEST_GT: \ | ||
93 | if (x1 > x2) \ | ||
94 | return; \ | ||
95 | break; \ | ||
96 | case TEST_GE: \ | ||
97 | if (x1 >= x2) \ | ||
98 | return; \ | ||
99 | break; \ | ||
100 | default: \ | ||
101 | abort(); \ | ||
102 | } \ | ||
103 | } while (0) | ||
104 | |||
105 | extern char *__progname; | ||
106 | |||
107 | static int verbose_mode = 0; | ||
108 | static int quiet_mode = 0; | ||
109 | static char *active_test_name = NULL; | ||
110 | static u_int test_number = 0; | ||
111 | static test_onerror_func_t *test_onerror = NULL; | ||
112 | static void *onerror_ctx = NULL; | ||
113 | static const char *data_dir = NULL; | ||
114 | |||
115 | int | ||
116 | main(int argc, char **argv) | ||
117 | { | ||
118 | int ch; | ||
119 | |||
120 | /* Handle systems without __progname */ | ||
121 | if (__progname == NULL) { | ||
122 | __progname = strrchr(argv[0], '/'); | ||
123 | if (__progname == NULL || __progname[1] == '\0') | ||
124 | __progname = argv[0]; | ||
125 | else | ||
126 | __progname++; | ||
127 | if ((__progname = strdup(__progname)) == NULL) { | ||
128 | fprintf(stderr, "strdup failed\n"); | ||
129 | exit(1); | ||
130 | } | ||
131 | } | ||
132 | |||
133 | while ((ch = getopt(argc, argv, "vqd:")) != -1) { | ||
134 | switch (ch) { | ||
135 | case 'd': | ||
136 | data_dir = optarg; | ||
137 | break; | ||
138 | case 'q': | ||
139 | verbose_mode = 0; | ||
140 | quiet_mode = 1; | ||
141 | break; | ||
142 | case 'v': | ||
143 | verbose_mode = 1; | ||
144 | quiet_mode = 0; | ||
145 | break; | ||
146 | default: | ||
147 | fprintf(stderr, "Unrecognised command line option\n"); | ||
148 | fprintf(stderr, "Usage: %s [-v]\n", __progname); | ||
149 | exit(1); | ||
150 | } | ||
151 | } | ||
152 | setvbuf(stdout, NULL, _IONBF, 0); | ||
153 | if (!quiet_mode) | ||
154 | printf("%s: ", __progname); | ||
155 | if (verbose_mode) | ||
156 | printf("\n"); | ||
157 | |||
158 | tests(); | ||
159 | |||
160 | if (!quiet_mode) | ||
161 | printf(" %u tests ok\n", test_number); | ||
162 | return 0; | ||
163 | } | ||
164 | |||
165 | const char * | ||
166 | test_data_file(const char *name) | ||
167 | { | ||
168 | static char ret[PATH_MAX]; | ||
169 | |||
170 | if (data_dir != NULL) | ||
171 | snprintf(ret, sizeof(ret), "%s/%s", data_dir, name); | ||
172 | else | ||
173 | strlcpy(ret, name, sizeof(ret)); | ||
174 | if (access(ret, F_OK) != 0) { | ||
175 | fprintf(stderr, "Cannot access data file %s: %s\n", | ||
176 | ret, strerror(errno)); | ||
177 | exit(1); | ||
178 | } | ||
179 | return ret; | ||
180 | } | ||
181 | |||
182 | void | ||
183 | test_start(const char *n) | ||
184 | { | ||
185 | assert(active_test_name == NULL); | ||
186 | assert((active_test_name = strdup(n)) != NULL); | ||
187 | if (verbose_mode) | ||
188 | printf("test %u - \"%s\": ", test_number, active_test_name); | ||
189 | test_number++; | ||
190 | } | ||
191 | |||
192 | void | ||
193 | set_onerror_func(test_onerror_func_t *f, void *ctx) | ||
194 | { | ||
195 | test_onerror = f; | ||
196 | onerror_ctx = ctx; | ||
197 | } | ||
198 | |||
199 | void | ||
200 | test_done(void) | ||
201 | { | ||
202 | assert(active_test_name != NULL); | ||
203 | free(active_test_name); | ||
204 | active_test_name = NULL; | ||
205 | if (verbose_mode) | ||
206 | printf("OK\n"); | ||
207 | else if (!quiet_mode) { | ||
208 | printf("."); | ||
209 | fflush(stdout); | ||
210 | } | ||
211 | } | ||
212 | |||
213 | void | ||
214 | ssl_err_check(const char *file, int line) | ||
215 | { | ||
216 | long openssl_error = ERR_get_error(); | ||
217 | |||
218 | if (openssl_error == 0) | ||
219 | return; | ||
220 | |||
221 | fprintf(stderr, "\n%s:%d: uncaught OpenSSL error: %s", | ||
222 | file, line, ERR_error_string(openssl_error, NULL)); | ||
223 | abort(); | ||
224 | } | ||
225 | |||
226 | static const char * | ||
227 | pred_name(enum test_predicate p) | ||
228 | { | ||
229 | switch (p) { | ||
230 | case TEST_EQ: | ||
231 | return "EQ"; | ||
232 | case TEST_NE: | ||
233 | return "NE"; | ||
234 | case TEST_LT: | ||
235 | return "LT"; | ||
236 | case TEST_LE: | ||
237 | return "LE"; | ||
238 | case TEST_GT: | ||
239 | return "GT"; | ||
240 | case TEST_GE: | ||
241 | return "GE"; | ||
242 | default: | ||
243 | return "UNKNOWN"; | ||
244 | } | ||
245 | } | ||
246 | |||
247 | static void | ||
248 | test_die(void) | ||
249 | { | ||
250 | if (test_onerror != NULL) | ||
251 | test_onerror(onerror_ctx); | ||
252 | abort(); | ||
253 | } | ||
254 | |||
255 | static void | ||
256 | test_header(const char *file, int line, const char *a1, const char *a2, | ||
257 | const char *name, enum test_predicate pred) | ||
258 | { | ||
259 | fprintf(stderr, "\n%s:%d test #%u \"%s\"\n", | ||
260 | file, line, test_number, active_test_name); | ||
261 | fprintf(stderr, "ASSERT_%s_%s(%s%s%s) failed:\n", | ||
262 | name, pred_name(pred), a1, | ||
263 | a2 != NULL ? ", " : "", a2 != NULL ? a2 : ""); | ||
264 | } | ||
265 | |||
266 | void | ||
267 | assert_bignum(const char *file, int line, const char *a1, const char *a2, | ||
268 | const BIGNUM *aa1, const BIGNUM *aa2, enum test_predicate pred) | ||
269 | { | ||
270 | int r = BN_cmp(aa1, aa2); | ||
271 | |||
272 | TEST_CHECK_INT(r, pred); | ||
273 | test_header(file, line, a1, a2, "BIGNUM", pred); | ||
274 | fprintf(stderr, "%12s = 0x%s\n", a1, BN_bn2hex(aa1)); | ||
275 | fprintf(stderr, "%12s = 0x%s\n", a2, BN_bn2hex(aa2)); | ||
276 | test_die(); | ||
277 | } | ||
278 | |||
279 | void | ||
280 | assert_string(const char *file, int line, const char *a1, const char *a2, | ||
281 | const char *aa1, const char *aa2, enum test_predicate pred) | ||
282 | { | ||
283 | int r = strcmp(aa1, aa2); | ||
284 | |||
285 | TEST_CHECK_INT(r, pred); | ||
286 | test_header(file, line, a1, a2, "STRING", pred); | ||
287 | fprintf(stderr, "%12s = %s (len %zu)\n", a1, aa1, strlen(aa1)); | ||
288 | fprintf(stderr, "%12s = %s (len %zu)\n", a2, aa2, strlen(aa2)); | ||
289 | test_die(); | ||
290 | } | ||
291 | |||
292 | static char * | ||
293 | tohex(const void *_s, size_t l) | ||
294 | { | ||
295 | u_int8_t *s = (u_int8_t *)_s; | ||
296 | size_t i, j; | ||
297 | const char *hex = "0123456789abcdef"; | ||
298 | char *r = malloc((l * 2) + 1); | ||
299 | |||
300 | assert(r != NULL); | ||
301 | for (i = j = 0; i < l; i++) { | ||
302 | r[j++] = hex[(s[i] >> 4) & 0xf]; | ||
303 | r[j++] = hex[s[i] & 0xf]; | ||
304 | } | ||
305 | r[j] = '\0'; | ||
306 | return r; | ||
307 | } | ||
308 | |||
309 | void | ||
310 | assert_mem(const char *file, int line, const char *a1, const char *a2, | ||
311 | const void *aa1, const void *aa2, size_t l, enum test_predicate pred) | ||
312 | { | ||
313 | int r = memcmp(aa1, aa2, l); | ||
314 | |||
315 | TEST_CHECK_INT(r, pred); | ||
316 | test_header(file, line, a1, a2, "STRING", pred); | ||
317 | fprintf(stderr, "%12s = %s (len %zu)\n", a1, tohex(aa1, MIN(l, 256)), l); | ||
318 | fprintf(stderr, "%12s = %s (len %zu)\n", a2, tohex(aa2, MIN(l, 256)), l); | ||
319 | test_die(); | ||
320 | } | ||
321 | |||
322 | static int | ||
323 | memvalcmp(const u_int8_t *s, u_char v, size_t l, size_t *where) | ||
324 | { | ||
325 | size_t i; | ||
326 | |||
327 | for (i = 0; i < l; i++) { | ||
328 | if (s[i] != v) { | ||
329 | *where = i; | ||
330 | return 1; | ||
331 | } | ||
332 | } | ||
333 | return 0; | ||
334 | } | ||
335 | |||
336 | void | ||
337 | assert_mem_filled(const char *file, int line, const char *a1, | ||
338 | const void *aa1, u_char v, size_t l, enum test_predicate pred) | ||
339 | { | ||
340 | size_t where = -1; | ||
341 | int r = memvalcmp(aa1, v, l, &where); | ||
342 | char tmp[64]; | ||
343 | |||
344 | if (l == 0) | ||
345 | return; | ||
346 | TEST_CHECK_INT(r, pred); | ||
347 | test_header(file, line, a1, NULL, "MEM_ZERO", pred); | ||
348 | fprintf(stderr, "%20s = %s%s (len %zu)\n", a1, | ||
349 | tohex(aa1, MIN(l, 20)), l > 20 ? "..." : "", l); | ||
350 | snprintf(tmp, sizeof(tmp), "(%s)[%zu]", a1, where); | ||
351 | fprintf(stderr, "%20s = 0x%02x (expected 0x%02x)\n", tmp, | ||
352 | ((u_char *)aa1)[where], v); | ||
353 | test_die(); | ||
354 | } | ||
355 | |||
356 | void | ||
357 | assert_int(const char *file, int line, const char *a1, const char *a2, | ||
358 | int aa1, int aa2, enum test_predicate pred) | ||
359 | { | ||
360 | TEST_CHECK(aa1, aa2, pred); | ||
361 | test_header(file, line, a1, a2, "INT", pred); | ||
362 | fprintf(stderr, "%12s = %d\n", a1, aa1); | ||
363 | fprintf(stderr, "%12s = %d\n", a2, aa2); | ||
364 | test_die(); | ||
365 | } | ||
366 | |||
367 | void | ||
368 | assert_size_t(const char *file, int line, const char *a1, const char *a2, | ||
369 | size_t aa1, size_t aa2, enum test_predicate pred) | ||
370 | { | ||
371 | TEST_CHECK(aa1, aa2, pred); | ||
372 | test_header(file, line, a1, a2, "SIZE_T", pred); | ||
373 | fprintf(stderr, "%12s = %zu\n", a1, aa1); | ||
374 | fprintf(stderr, "%12s = %zu\n", a2, aa2); | ||
375 | test_die(); | ||
376 | } | ||
377 | |||
378 | void | ||
379 | assert_u_int(const char *file, int line, const char *a1, const char *a2, | ||
380 | u_int aa1, u_int aa2, enum test_predicate pred) | ||
381 | { | ||
382 | TEST_CHECK(aa1, aa2, pred); | ||
383 | test_header(file, line, a1, a2, "U_INT", pred); | ||
384 | fprintf(stderr, "%12s = %u / 0x%x\n", a1, aa1, aa1); | ||
385 | fprintf(stderr, "%12s = %u / 0x%x\n", a2, aa2, aa2); | ||
386 | test_die(); | ||
387 | } | ||
388 | |||
389 | void | ||
390 | assert_long_long(const char *file, int line, const char *a1, const char *a2, | ||
391 | long long aa1, long long aa2, enum test_predicate pred) | ||
392 | { | ||
393 | TEST_CHECK(aa1, aa2, pred); | ||
394 | test_header(file, line, a1, a2, "LONG LONG", pred); | ||
395 | fprintf(stderr, "%12s = %lld / 0x%llx\n", a1, aa1, aa1); | ||
396 | fprintf(stderr, "%12s = %lld / 0x%llx\n", a2, aa2, aa2); | ||
397 | test_die(); | ||
398 | } | ||
399 | |||
400 | void | ||
401 | assert_char(const char *file, int line, const char *a1, const char *a2, | ||
402 | char aa1, char aa2, enum test_predicate pred) | ||
403 | { | ||
404 | char buf[8]; | ||
405 | |||
406 | TEST_CHECK(aa1, aa2, pred); | ||
407 | test_header(file, line, a1, a2, "CHAR", pred); | ||
408 | fprintf(stderr, "%12s = '%s' / 0x02%x\n", a1, | ||
409 | vis(buf, aa1, VIS_SAFE|VIS_NL|VIS_TAB|VIS_OCTAL, 0), aa1); | ||
410 | fprintf(stderr, "%12s = '%s' / 0x02%x\n", a1, | ||
411 | vis(buf, aa2, VIS_SAFE|VIS_NL|VIS_TAB|VIS_OCTAL, 0), aa2); | ||
412 | test_die(); | ||
413 | } | ||
414 | |||
415 | void | ||
416 | assert_u8(const char *file, int line, const char *a1, const char *a2, | ||
417 | u_int8_t aa1, u_int8_t aa2, enum test_predicate pred) | ||
418 | { | ||
419 | TEST_CHECK(aa1, aa2, pred); | ||
420 | test_header(file, line, a1, a2, "U8", pred); | ||
421 | fprintf(stderr, "%12s = 0x%02x %u\n", a1, aa1, aa1); | ||
422 | fprintf(stderr, "%12s = 0x%02x %u\n", a2, aa2, aa2); | ||
423 | test_die(); | ||
424 | } | ||
425 | |||
426 | void | ||
427 | assert_u16(const char *file, int line, const char *a1, const char *a2, | ||
428 | u_int16_t aa1, u_int16_t aa2, enum test_predicate pred) | ||
429 | { | ||
430 | TEST_CHECK(aa1, aa2, pred); | ||
431 | test_header(file, line, a1, a2, "U16", pred); | ||
432 | fprintf(stderr, "%12s = 0x%04x %u\n", a1, aa1, aa1); | ||
433 | fprintf(stderr, "%12s = 0x%04x %u\n", a2, aa2, aa2); | ||
434 | test_die(); | ||
435 | } | ||
436 | |||
437 | void | ||
438 | assert_u32(const char *file, int line, const char *a1, const char *a2, | ||
439 | u_int32_t aa1, u_int32_t aa2, enum test_predicate pred) | ||
440 | { | ||
441 | TEST_CHECK(aa1, aa2, pred); | ||
442 | test_header(file, line, a1, a2, "U32", pred); | ||
443 | fprintf(stderr, "%12s = 0x%08x %u\n", a1, aa1, aa1); | ||
444 | fprintf(stderr, "%12s = 0x%08x %u\n", a2, aa2, aa2); | ||
445 | test_die(); | ||
446 | } | ||
447 | |||
448 | void | ||
449 | assert_u64(const char *file, int line, const char *a1, const char *a2, | ||
450 | u_int64_t aa1, u_int64_t aa2, enum test_predicate pred) | ||
451 | { | ||
452 | TEST_CHECK(aa1, aa2, pred); | ||
453 | test_header(file, line, a1, a2, "U64", pred); | ||
454 | fprintf(stderr, "%12s = 0x%016llx %llu\n", a1, | ||
455 | (unsigned long long)aa1, (unsigned long long)aa1); | ||
456 | fprintf(stderr, "%12s = 0x%016llx %llu\n", a2, | ||
457 | (unsigned long long)aa2, (unsigned long long)aa2); | ||
458 | test_die(); | ||
459 | } | ||
460 | |||
461 | void | ||
462 | assert_ptr(const char *file, int line, const char *a1, const char *a2, | ||
463 | const void *aa1, const void *aa2, enum test_predicate pred) | ||
464 | { | ||
465 | TEST_CHECK(aa1, aa2, pred); | ||
466 | test_header(file, line, a1, a2, "PTR", pred); | ||
467 | fprintf(stderr, "%12s = %p\n", a1, aa1); | ||
468 | fprintf(stderr, "%12s = %p\n", a2, aa2); | ||
469 | test_die(); | ||
470 | } | ||
471 | |||
diff --git a/regress/unittests/test_helper/test_helper.h b/regress/unittests/test_helper/test_helper.h new file mode 100644 index 000000000..a398c615f --- /dev/null +++ b/regress/unittests/test_helper/test_helper.h | |||
@@ -0,0 +1,292 @@ | |||
1 | /* $OpenBSD: test_helper.h,v 1.3 2014/05/02 09:41:32 andre Exp $ */ | ||
2 | /* | ||
3 | * Copyright (c) 2011 Damien Miller <djm@mindrot.org> | ||
4 | * | ||
5 | * Permission to use, copy, modify, and distribute this software for any | ||
6 | * purpose with or without fee is hereby granted, provided that the above | ||
7 | * copyright notice and this permission notice appear in all copies. | ||
8 | * | ||
9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
16 | */ | ||
17 | |||
18 | /* Utility functions/framework for regress tests */ | ||
19 | |||
20 | #ifndef _TEST_HELPER_H | ||
21 | #define _TEST_HELPER_H | ||
22 | |||
23 | #include "includes.h" | ||
24 | |||
25 | #include <sys/types.h> | ||
26 | #ifdef HAVE_STDINT_H | ||
27 | # include <stdint.h> | ||
28 | #endif | ||
29 | |||
30 | #include <openssl/bn.h> | ||
31 | #include <openssl/err.h> | ||
32 | |||
33 | enum test_predicate { | ||
34 | TEST_EQ, TEST_NE, TEST_LT, TEST_LE, TEST_GT, TEST_GE | ||
35 | }; | ||
36 | typedef void (test_onerror_func_t)(void *); | ||
37 | |||
38 | /* Supplied by test suite */ | ||
39 | void tests(void); | ||
40 | |||
41 | const char *test_data_file(const char *name); | ||
42 | void test_start(const char *n); | ||
43 | void set_onerror_func(test_onerror_func_t *f, void *ctx); | ||
44 | void test_done(void); | ||
45 | void ssl_err_check(const char *file, int line); | ||
46 | void assert_bignum(const char *file, int line, | ||
47 | const char *a1, const char *a2, | ||
48 | const BIGNUM *aa1, const BIGNUM *aa2, enum test_predicate pred); | ||
49 | void assert_string(const char *file, int line, | ||
50 | const char *a1, const char *a2, | ||
51 | const char *aa1, const char *aa2, enum test_predicate pred); | ||
52 | void assert_mem(const char *file, int line, | ||
53 | const char *a1, const char *a2, | ||
54 | const void *aa1, const void *aa2, size_t l, enum test_predicate pred); | ||
55 | void assert_mem_filled(const char *file, int line, | ||
56 | const char *a1, | ||
57 | const void *aa1, u_char v, size_t l, enum test_predicate pred); | ||
58 | void assert_int(const char *file, int line, | ||
59 | const char *a1, const char *a2, | ||
60 | int aa1, int aa2, enum test_predicate pred); | ||
61 | void assert_size_t(const char *file, int line, | ||
62 | const char *a1, const char *a2, | ||
63 | size_t aa1, size_t aa2, enum test_predicate pred); | ||
64 | void assert_u_int(const char *file, int line, | ||
65 | const char *a1, const char *a2, | ||
66 | u_int aa1, u_int aa2, enum test_predicate pred); | ||
67 | void assert_long_long(const char *file, int line, | ||
68 | const char *a1, const char *a2, | ||
69 | long long aa1, long long aa2, enum test_predicate pred); | ||
70 | void assert_char(const char *file, int line, | ||
71 | const char *a1, const char *a2, | ||
72 | char aa1, char aa2, enum test_predicate pred); | ||
73 | void assert_ptr(const char *file, int line, | ||
74 | const char *a1, const char *a2, | ||
75 | const void *aa1, const void *aa2, enum test_predicate pred); | ||
76 | void assert_u8(const char *file, int line, | ||
77 | const char *a1, const char *a2, | ||
78 | u_int8_t aa1, u_int8_t aa2, enum test_predicate pred); | ||
79 | void assert_u16(const char *file, int line, | ||
80 | const char *a1, const char *a2, | ||
81 | u_int16_t aa1, u_int16_t aa2, enum test_predicate pred); | ||
82 | void assert_u32(const char *file, int line, | ||
83 | const char *a1, const char *a2, | ||
84 | u_int32_t aa1, u_int32_t aa2, enum test_predicate pred); | ||
85 | void assert_u64(const char *file, int line, | ||
86 | const char *a1, const char *a2, | ||
87 | u_int64_t aa1, u_int64_t aa2, enum test_predicate pred); | ||
88 | |||
89 | #define TEST_START(n) test_start(n) | ||
90 | #define TEST_DONE() test_done() | ||
91 | #define TEST_ONERROR(f, c) set_onerror_func(f, c) | ||
92 | #define SSL_ERR_CHECK() ssl_err_check(__FILE__, __LINE__) | ||
93 | |||
94 | #define ASSERT_BIGNUM_EQ(a1, a2) \ | ||
95 | assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
96 | #define ASSERT_STRING_EQ(a1, a2) \ | ||
97 | assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
98 | #define ASSERT_MEM_EQ(a1, a2, l) \ | ||
99 | assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_EQ) | ||
100 | #define ASSERT_MEM_FILLED_EQ(a1, c, l) \ | ||
101 | assert_mem_filled(__FILE__, __LINE__, #a1, a1, c, l, TEST_EQ) | ||
102 | #define ASSERT_MEM_ZERO_EQ(a1, l) \ | ||
103 | assert_mem_filled(__FILE__, __LINE__, #a1, a1, '\0', l, TEST_EQ) | ||
104 | #define ASSERT_INT_EQ(a1, a2) \ | ||
105 | assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
106 | #define ASSERT_SIZE_T_EQ(a1, a2) \ | ||
107 | assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
108 | #define ASSERT_U_INT_EQ(a1, a2) \ | ||
109 | assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
110 | #define ASSERT_LONG_LONG_EQ(a1, a2) \ | ||
111 | assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
112 | #define ASSERT_CHAR_EQ(a1, a2) \ | ||
113 | assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
114 | #define ASSERT_PTR_EQ(a1, a2) \ | ||
115 | assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
116 | #define ASSERT_U8_EQ(a1, a2) \ | ||
117 | assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
118 | #define ASSERT_U16_EQ(a1, a2) \ | ||
119 | assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
120 | #define ASSERT_U32_EQ(a1, a2) \ | ||
121 | assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
122 | #define ASSERT_U64_EQ(a1, a2) \ | ||
123 | assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ) | ||
124 | |||
125 | #define ASSERT_BIGNUM_NE(a1, a2) \ | ||
126 | assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
127 | #define ASSERT_STRING_NE(a1, a2) \ | ||
128 | assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
129 | #define ASSERT_MEM_NE(a1, a2, l) \ | ||
130 | assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_NE) | ||
131 | #define ASSERT_MEM_ZERO_NE(a1, l) \ | ||
132 | assert_mem_filled(__FILE__, __LINE__, #a1, a1, '\0', l, TEST_NE) | ||
133 | #define ASSERT_INT_NE(a1, a2) \ | ||
134 | assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
135 | #define ASSERT_SIZE_T_NE(a1, a2) \ | ||
136 | assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
137 | #define ASSERT_U_INT_NE(a1, a2) \ | ||
138 | assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
139 | #define ASSERT_LONG_LONG_NE(a1, a2) \ | ||
140 | assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
141 | #define ASSERT_CHAR_NE(a1, a2) \ | ||
142 | assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
143 | #define ASSERT_PTR_NE(a1, a2) \ | ||
144 | assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
145 | #define ASSERT_U8_NE(a1, a2) \ | ||
146 | assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
147 | #define ASSERT_U16_NE(a1, a2) \ | ||
148 | assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
149 | #define ASSERT_U32_NE(a1, a2) \ | ||
150 | assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
151 | #define ASSERT_U64_NE(a1, a2) \ | ||
152 | assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE) | ||
153 | |||
154 | #define ASSERT_BIGNUM_LT(a1, a2) \ | ||
155 | assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
156 | #define ASSERT_STRING_LT(a1, a2) \ | ||
157 | assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
158 | #define ASSERT_MEM_LT(a1, a2, l) \ | ||
159 | assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_LT) | ||
160 | #define ASSERT_INT_LT(a1, a2) \ | ||
161 | assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
162 | #define ASSERT_SIZE_T_LT(a1, a2) \ | ||
163 | assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
164 | #define ASSERT_U_INT_LT(a1, a2) \ | ||
165 | assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
166 | #define ASSERT_LONG_LONG_LT(a1, a2) \ | ||
167 | assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
168 | #define ASSERT_CHAR_LT(a1, a2) \ | ||
169 | assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
170 | #define ASSERT_PTR_LT(a1, a2) \ | ||
171 | assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
172 | #define ASSERT_U8_LT(a1, a2) \ | ||
173 | assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
174 | #define ASSERT_U16_LT(a1, a2) \ | ||
175 | assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
176 | #define ASSERT_U32_LT(a1, a2) \ | ||
177 | assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
178 | #define ASSERT_U64_LT(a1, a2) \ | ||
179 | assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT) | ||
180 | |||
181 | #define ASSERT_BIGNUM_LE(a1, a2) \ | ||
182 | assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
183 | #define ASSERT_STRING_LE(a1, a2) \ | ||
184 | assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
185 | #define ASSERT_MEM_LE(a1, a2, l) \ | ||
186 | assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_LE) | ||
187 | #define ASSERT_INT_LE(a1, a2) \ | ||
188 | assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
189 | #define ASSERT_SIZE_T_LE(a1, a2) \ | ||
190 | assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
191 | #define ASSERT_U_INT_LE(a1, a2) \ | ||
192 | assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
193 | #define ASSERT_LONG_LONG_LE(a1, a2) \ | ||
194 | assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
195 | #define ASSERT_CHAR_LE(a1, a2) \ | ||
196 | assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
197 | #define ASSERT_PTR_LE(a1, a2) \ | ||
198 | assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
199 | #define ASSERT_U8_LE(a1, a2) \ | ||
200 | assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
201 | #define ASSERT_U16_LE(a1, a2) \ | ||
202 | assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
203 | #define ASSERT_U32_LE(a1, a2) \ | ||
204 | assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
205 | #define ASSERT_U64_LE(a1, a2) \ | ||
206 | assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE) | ||
207 | |||
208 | #define ASSERT_BIGNUM_GT(a1, a2) \ | ||
209 | assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
210 | #define ASSERT_STRING_GT(a1, a2) \ | ||
211 | assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
212 | #define ASSERT_MEM_GT(a1, a2, l) \ | ||
213 | assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_GT) | ||
214 | #define ASSERT_INT_GT(a1, a2) \ | ||
215 | assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
216 | #define ASSERT_SIZE_T_GT(a1, a2) \ | ||
217 | assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
218 | #define ASSERT_U_INT_GT(a1, a2) \ | ||
219 | assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
220 | #define ASSERT_LONG_LONG_GT(a1, a2) \ | ||
221 | assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
222 | #define ASSERT_CHAR_GT(a1, a2) \ | ||
223 | assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
224 | #define ASSERT_PTR_GT(a1, a2) \ | ||
225 | assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
226 | #define ASSERT_U8_GT(a1, a2) \ | ||
227 | assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
228 | #define ASSERT_U16_GT(a1, a2) \ | ||
229 | assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
230 | #define ASSERT_U32_GT(a1, a2) \ | ||
231 | assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
232 | #define ASSERT_U64_GT(a1, a2) \ | ||
233 | assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT) | ||
234 | |||
235 | #define ASSERT_BIGNUM_GE(a1, a2) \ | ||
236 | assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
237 | #define ASSERT_STRING_GE(a1, a2) \ | ||
238 | assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
239 | #define ASSERT_MEM_GE(a1, a2, l) \ | ||
240 | assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_GE) | ||
241 | #define ASSERT_INT_GE(a1, a2) \ | ||
242 | assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
243 | #define ASSERT_SIZE_T_GE(a1, a2) \ | ||
244 | assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
245 | #define ASSERT_U_INT_GE(a1, a2) \ | ||
246 | assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
247 | #define ASSERT_LONG_LONG_GE(a1, a2) \ | ||
248 | assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
249 | #define ASSERT_CHAR_GE(a1, a2) \ | ||
250 | assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
251 | #define ASSERT_PTR_GE(a1, a2) \ | ||
252 | assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
253 | #define ASSERT_U8_GE(a1, a2) \ | ||
254 | assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
255 | #define ASSERT_U16_GE(a1, a2) \ | ||
256 | assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
257 | #define ASSERT_U32_GE(a1, a2) \ | ||
258 | assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
259 | #define ASSERT_U64_GE(a1, a2) \ | ||
260 | assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE) | ||
261 | |||
262 | /* Fuzzing support */ | ||
263 | |||
264 | struct fuzz; | ||
265 | #define FUZZ_1_BIT_FLIP 0x00000001 /* Flip one bit at a time */ | ||
266 | #define FUZZ_2_BIT_FLIP 0x00000002 /* Flip two bits at a time */ | ||
267 | #define FUZZ_1_BYTE_FLIP 0x00000004 /* Flip one byte at a time */ | ||
268 | #define FUZZ_2_BYTE_FLIP 0x00000008 /* Flip two bytes at a time */ | ||
269 | #define FUZZ_TRUNCATE_START 0x00000010 /* Truncate from beginning */ | ||
270 | #define FUZZ_TRUNCATE_END 0x00000020 /* Truncate from end */ | ||
271 | #define FUZZ_BASE64 0x00000040 /* Try all base64 chars */ | ||
272 | #define FUZZ_MAX FUZZ_BASE64 | ||
273 | |||
274 | /* Start fuzzing a blob of data with selected strategies (bitmask) */ | ||
275 | struct fuzz *fuzz_begin(u_int strategies, const void *p, size_t l); | ||
276 | |||
277 | /* Free a fuzz context */ | ||
278 | void fuzz_cleanup(struct fuzz *fuzz); | ||
279 | |||
280 | /* Prepare the next fuzz case in the series */ | ||
281 | void fuzz_next(struct fuzz *fuzz); | ||
282 | |||
283 | /* Determine whether the current fuzz sequence is exhausted (nonzero = yes) */ | ||
284 | int fuzz_done(struct fuzz *fuzz); | ||
285 | |||
286 | /* Return the length and a pointer to the current fuzzed case */ | ||
287 | size_t fuzz_len(struct fuzz *fuzz); | ||
288 | u_char *fuzz_ptr(struct fuzz *fuzz); | ||
289 | |||
290 | /* Dump the current fuzz case to stderr */ | ||
291 | void fuzz_dump(struct fuzz *fuzz); | ||
292 | #endif /* _TEST_HELPER_H */ | ||