Grid Community Toolkit  6.2.1653033972 (tag: v6.2.20220524)
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
test_helper.h
1 /* $OpenBSD: test_helper.h,v 1.9 2018/10/17 23:28:05 djm Exp $ */
2 /*
3  * Copyright (c) 2011 Damien Miller <[email protected]>
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 #ifdef WITH_OPENSSL
31 #include <openssl/bn.h>
32 #include <openssl/err.h>
33 #endif
34 
35 enum test_predicate {
36  TEST_EQ, TEST_NE, TEST_LT, TEST_LE, TEST_GT, TEST_GE
37 };
38 typedef void (test_onerror_func_t)(void *);
39 
40 /* Supplied by test suite */
41 void tests(void);
42 
43 const char *test_data_file(const char *name);
44 void test_start(const char *n);
45 void test_info(char *s, size_t len);
46 void set_onerror_func(test_onerror_func_t *f, void *ctx);
47 void test_done(void);
48 int test_is_verbose(void);
49 int test_is_quiet(void);
50 int test_is_fast(void);
51 int test_is_slow(void);
52 void test_subtest_info(const char *fmt, ...)
53  __attribute__((format(printf, 1, 2)));
54 void ssl_err_check(const char *file, int line);
55 #ifdef WITH_OPENSSL
56 void assert_bignum(const char *file, int line,
57  const char *a1, const char *a2,
58  const BIGNUM *aa1, const BIGNUM *aa2, enum test_predicate pred);
59 #endif
60 void assert_string(const char *file, int line,
61  const char *a1, const char *a2,
62  const char *aa1, const char *aa2, enum test_predicate pred);
63 void assert_mem(const char *file, int line,
64  const char *a1, const char *a2,
65  const void *aa1, const void *aa2, size_t l, enum test_predicate pred);
66 void assert_mem_filled(const char *file, int line,
67  const char *a1,
68  const void *aa1, u_char v, size_t l, enum test_predicate pred);
69 void assert_int(const char *file, int line,
70  const char *a1, const char *a2,
71  int aa1, int aa2, enum test_predicate pred);
72 void assert_size_t(const char *file, int line,
73  const char *a1, const char *a2,
74  size_t aa1, size_t aa2, enum test_predicate pred);
75 void assert_u_int(const char *file, int line,
76  const char *a1, const char *a2,
77  u_int aa1, u_int aa2, enum test_predicate pred);
78 void assert_long(const char *file, int line,
79  const char *a1, const char *a2,
80  long aa1, long aa2, enum test_predicate pred);
81 void assert_long_long(const char *file, int line,
82  const char *a1, const char *a2,
83  long long aa1, long long aa2, enum test_predicate pred);
84 void assert_char(const char *file, int line,
85  const char *a1, const char *a2,
86  char aa1, char aa2, enum test_predicate pred);
87 void assert_ptr(const char *file, int line,
88  const char *a1, const char *a2,
89  const void *aa1, const void *aa2, enum test_predicate pred);
90 void assert_u8(const char *file, int line,
91  const char *a1, const char *a2,
92  u_int8_t aa1, u_int8_t aa2, enum test_predicate pred);
93 void assert_u16(const char *file, int line,
94  const char *a1, const char *a2,
95  u_int16_t aa1, u_int16_t aa2, enum test_predicate pred);
96 void assert_u32(const char *file, int line,
97  const char *a1, const char *a2,
98  u_int32_t aa1, u_int32_t aa2, enum test_predicate pred);
99 void assert_u64(const char *file, int line,
100  const char *a1, const char *a2,
101  u_int64_t aa1, u_int64_t aa2, enum test_predicate pred);
102 
103 #define TEST_START(n) test_start(n)
104 #define TEST_DONE() test_done()
105 #define TEST_ONERROR(f, c) set_onerror_func(f, c)
106 #define SSL_ERR_CHECK() ssl_err_check(__FILE__, __LINE__)
107 
108 #define ASSERT_BIGNUM_EQ(a1, a2) \
109  assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
110 #define ASSERT_STRING_EQ(a1, a2) \
111  assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
112 #define ASSERT_MEM_EQ(a1, a2, l) \
113  assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_EQ)
114 #define ASSERT_MEM_FILLED_EQ(a1, c, l) \
115  assert_mem_filled(__FILE__, __LINE__, #a1, a1, c, l, TEST_EQ)
116 #define ASSERT_MEM_ZERO_EQ(a1, l) \
117  assert_mem_filled(__FILE__, __LINE__, #a1, a1, '\0', l, TEST_EQ)
118 #define ASSERT_INT_EQ(a1, a2) \
119  assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
120 #define ASSERT_SIZE_T_EQ(a1, a2) \
121  assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
122 #define ASSERT_U_INT_EQ(a1, a2) \
123  assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
124 #define ASSERT_LONG_EQ(a1, a2) \
125  assert_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
126 #define ASSERT_LONG_LONG_EQ(a1, a2) \
127  assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
128 #define ASSERT_CHAR_EQ(a1, a2) \
129  assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
130 #define ASSERT_PTR_EQ(a1, a2) \
131  assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
132 #define ASSERT_U8_EQ(a1, a2) \
133  assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
134 #define ASSERT_U16_EQ(a1, a2) \
135  assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
136 #define ASSERT_U32_EQ(a1, a2) \
137  assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
138 #define ASSERT_U64_EQ(a1, a2) \
139  assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_EQ)
140 
141 #define ASSERT_BIGNUM_NE(a1, a2) \
142  assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
143 #define ASSERT_STRING_NE(a1, a2) \
144  assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
145 #define ASSERT_MEM_NE(a1, a2, l) \
146  assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_NE)
147 #define ASSERT_MEM_ZERO_NE(a1, l) \
148  assert_mem_filled(__FILE__, __LINE__, #a1, a1, '\0', l, TEST_NE)
149 #define ASSERT_INT_NE(a1, a2) \
150  assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
151 #define ASSERT_SIZE_T_NE(a1, a2) \
152  assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
153 #define ASSERT_U_INT_NE(a1, a2) \
154  assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
155 #define ASSERT_LONG_NE(a1, a2) \
156  assert_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
157 #define ASSERT_LONG_LONG_NE(a1, a2) \
158  assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
159 #define ASSERT_CHAR_NE(a1, a2) \
160  assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
161 #define ASSERT_PTR_NE(a1, a2) \
162  assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
163 #define ASSERT_U8_NE(a1, a2) \
164  assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
165 #define ASSERT_U16_NE(a1, a2) \
166  assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
167 #define ASSERT_U32_NE(a1, a2) \
168  assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
169 #define ASSERT_U64_NE(a1, a2) \
170  assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_NE)
171 
172 #define ASSERT_BIGNUM_LT(a1, a2) \
173  assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
174 #define ASSERT_STRING_LT(a1, a2) \
175  assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
176 #define ASSERT_MEM_LT(a1, a2, l) \
177  assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_LT)
178 #define ASSERT_INT_LT(a1, a2) \
179  assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
180 #define ASSERT_SIZE_T_LT(a1, a2) \
181  assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
182 #define ASSERT_U_INT_LT(a1, a2) \
183  assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
184 #define ASSERT_LONG_LT(a1, a2) \
185  assert_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
186 #define ASSERT_LONG_LONG_LT(a1, a2) \
187  assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
188 #define ASSERT_CHAR_LT(a1, a2) \
189  assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
190 #define ASSERT_PTR_LT(a1, a2) \
191  assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
192 #define ASSERT_U8_LT(a1, a2) \
193  assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
194 #define ASSERT_U16_LT(a1, a2) \
195  assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
196 #define ASSERT_U32_LT(a1, a2) \
197  assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
198 #define ASSERT_U64_LT(a1, a2) \
199  assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LT)
200 
201 #define ASSERT_BIGNUM_LE(a1, a2) \
202  assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
203 #define ASSERT_STRING_LE(a1, a2) \
204  assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
205 #define ASSERT_MEM_LE(a1, a2, l) \
206  assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_LE)
207 #define ASSERT_INT_LE(a1, a2) \
208  assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
209 #define ASSERT_SIZE_T_LE(a1, a2) \
210  assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
211 #define ASSERT_U_INT_LE(a1, a2) \
212  assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
213 #define ASSERT_LONG_LE(a1, a2) \
214  assert_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
215 #define ASSERT_LONG_LONG_LE(a1, a2) \
216  assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
217 #define ASSERT_CHAR_LE(a1, a2) \
218  assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
219 #define ASSERT_PTR_LE(a1, a2) \
220  assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
221 #define ASSERT_U8_LE(a1, a2) \
222  assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
223 #define ASSERT_U16_LE(a1, a2) \
224  assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
225 #define ASSERT_U32_LE(a1, a2) \
226  assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
227 #define ASSERT_U64_LE(a1, a2) \
228  assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_LE)
229 
230 #define ASSERT_BIGNUM_GT(a1, a2) \
231  assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
232 #define ASSERT_STRING_GT(a1, a2) \
233  assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
234 #define ASSERT_MEM_GT(a1, a2, l) \
235  assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_GT)
236 #define ASSERT_INT_GT(a1, a2) \
237  assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
238 #define ASSERT_SIZE_T_GT(a1, a2) \
239  assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
240 #define ASSERT_U_INT_GT(a1, a2) \
241  assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
242 #define ASSERT_LONG_GT(a1, a2) \
243  assert_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
244 #define ASSERT_LONG_LONG_GT(a1, a2) \
245  assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
246 #define ASSERT_CHAR_GT(a1, a2) \
247  assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
248 #define ASSERT_PTR_GT(a1, a2) \
249  assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
250 #define ASSERT_U8_GT(a1, a2) \
251  assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
252 #define ASSERT_U16_GT(a1, a2) \
253  assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
254 #define ASSERT_U32_GT(a1, a2) \
255  assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
256 #define ASSERT_U64_GT(a1, a2) \
257  assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GT)
258 
259 #define ASSERT_BIGNUM_GE(a1, a2) \
260  assert_bignum(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
261 #define ASSERT_STRING_GE(a1, a2) \
262  assert_string(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
263 #define ASSERT_MEM_GE(a1, a2, l) \
264  assert_mem(__FILE__, __LINE__, #a1, #a2, a1, a2, l, TEST_GE)
265 #define ASSERT_INT_GE(a1, a2) \
266  assert_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
267 #define ASSERT_SIZE_T_GE(a1, a2) \
268  assert_size_t(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
269 #define ASSERT_U_INT_GE(a1, a2) \
270  assert_u_int(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
271 #define ASSERT_LONG_GE(a1, a2) \
272  assert_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
273 #define ASSERT_LONG_LONG_GE(a1, a2) \
274  assert_long_long(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
275 #define ASSERT_CHAR_GE(a1, a2) \
276  assert_char(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
277 #define ASSERT_PTR_GE(a1, a2) \
278  assert_ptr(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
279 #define ASSERT_U8_GE(a1, a2) \
280  assert_u8(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
281 #define ASSERT_U16_GE(a1, a2) \
282  assert_u16(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
283 #define ASSERT_U32_GE(a1, a2) \
284  assert_u32(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
285 #define ASSERT_U64_GE(a1, a2) \
286  assert_u64(__FILE__, __LINE__, #a1, #a2, a1, a2, TEST_GE)
287 
288 /* Fuzzing support */
289 
290 struct fuzz;
291 #define FUZZ_1_BIT_FLIP 0x00000001 /* Flip one bit at a time */
292 #define FUZZ_2_BIT_FLIP 0x00000002 /* Flip two bits at a time */
293 #define FUZZ_1_BYTE_FLIP 0x00000004 /* Flip one byte at a time */
294 #define FUZZ_2_BYTE_FLIP 0x00000008 /* Flip two bytes at a time */
295 #define FUZZ_TRUNCATE_START 0x00000010 /* Truncate from beginning */
296 #define FUZZ_TRUNCATE_END 0x00000020 /* Truncate from end */
297 #define FUZZ_BASE64 0x00000040 /* Try all base64 chars */
298 #define FUZZ_MAX FUZZ_BASE64
299 
300 /* Start fuzzing a blob of data with selected strategies (bitmask) */
301 struct fuzz *fuzz_begin(u_int strategies, const void *p, size_t l);
302 
303 /* Free a fuzz context */
304 void fuzz_cleanup(struct fuzz *fuzz);
305 
306 /* Prepare the next fuzz case in the series */
307 void fuzz_next(struct fuzz *fuzz);
308 
309 /*
310  * Check whether this fuzz case is identical to the original
311  * This is slow, but useful if the caller needs to ensure that all tests
312  * generated change the input (e.g. when fuzzing signatures).
313  */
314 int fuzz_matches_original(struct fuzz *fuzz);
315 
316 /* Determine whether the current fuzz sequence is exhausted (nonzero = yes) */
317 int fuzz_done(struct fuzz *fuzz);
318 
319 /* Return the length and a pointer to the current fuzzed case */
320 size_t fuzz_len(struct fuzz *fuzz);
321 u_char *fuzz_ptr(struct fuzz *fuzz);
322 
323 /* Dump the current fuzz case to stderr */
324 void fuzz_dump(struct fuzz *fuzz);
325 
326 #endif /* _TEST_HELPER_H */
Generated by   doxygen 1.8.5