| blob | f1e91c2ea6a363e851e6cfbb1a33dea126f55bc1 |
1 /*-
2 * Copyright (c) 2006 Michael Bushkov <bushman@freebsd.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD$
27 */
29 #include <sys/queue.h>
31 #define DECLARE_TEST_DATA(ent) \
32 struct ent##_entry { \
33 struct ent data; \
34 STAILQ_ENTRY(ent##_entry) entries; \
35 }; \
36 \
37 struct ent##_test_data { \
38 void (*clone_func)(struct ent *, struct ent const *); \
39 void (*free_func)(struct ent *); \
40 \
41 STAILQ_HEAD(ent_head, ent##_entry) snapshot_data; \
42 }; \
43 \
44 void __##ent##_test_data_init(struct ent##_test_data *, \
45 void (*)(struct ent *, struct ent const *), \
46 void (*freef)(struct ent *)); \
47 void __##ent##_test_data_destroy(struct ent##_test_data *); \
48 \
49 void __##ent##_test_data_append(struct ent##_test_data *, struct ent *data);\
50 int __##ent##_test_data_foreach(struct ent##_test_data *, \
51 int (*)(struct ent *, void *), void *); \
52 int __##ent##_test_data_compare(struct ent##_test_data *, \
53 struct ent##_test_data *, int (*)(struct ent *, struct ent *, \
54 void *), void *); \
55 struct ent *__##ent##_test_data_find(struct ent##_test_data *, struct ent *,\
56 int (*)(struct ent *, struct ent *, void *), void *); \
57 void __##ent##_test_data_clear(struct ent##_test_data *);
59 #define TEST_DATA_INIT(ent, td, clonef, freef)\
60 __##ent##_test_data_init(td, clonef, freef)
61 #define TEST_DATA_DESTROY(ent, td) __##ent##_test_data_destroy(td)
62 #define TEST_DATA_APPEND(ent, td, d) __##ent##_test_data_append(td, d)
63 #define TEST_DATA_FOREACH(ent, td, f, mdata)\
64 __##ent##_test_data_foreach(td, f, mdata)
65 #define TEST_DATA_COMPARE(ent, td1, td2, fcmp, mdata)\
66 __##ent##_test_data_compare(td1, td2, fcmp, mdata);
67 #define TEST_DATA_FIND(ent, td, d, fcmp, mdata)\
68 __##ent##_test_data_find(td, d, fcmp, mdata)
69 #define TEST_DATA_CLEAR(ent, td) __##ent##_test_data_clear(td)
71 #define IMPLEMENT_TEST_DATA(ent) \
72 void \
73 __##ent##_test_data_init(struct ent##_test_data *td, \
74 void (*clonef)(struct ent *, struct ent const *), \
75 void (*freef)(struct ent *)) \
76 { \
77 assert(td != NULL); \
78 assert(clonef != NULL); \
79 assert(freef != NULL); \
80 \
81 memset(td, 0, sizeof(*td)); \
82 td->clone_func = clonef; \
83 td->free_func = freef; \
84 STAILQ_INIT(&td->snapshot_data); \
85 } \
86 \
87 void \
88 __##ent##_test_data_destroy(struct ent##_test_data *td) \
89 { \
90 __##ent##_test_data_clear(td); \
91 } \
92 \
93 void \
94 __##ent##_test_data_append(struct ent##_test_data *td, struct ent *app_data)\
95 { \
96 struct ent##_entry *e; \
97 \
98 assert(td != NULL); \
99 assert(app_data != NULL); \
100 \
101 e = (struct ent##_entry *)malloc(sizeof(struct ent##_entry)); \
102 assert(e != NULL); \
103 memset(e, 0, sizeof(struct ent##_entry)); \
104 \
105 td->clone_func(&e->data, app_data); \
106 STAILQ_INSERT_TAIL(&td->snapshot_data, e, entries); \
107 } \
108 \
109 int \
110 __##ent##_test_data_foreach(struct ent##_test_data *td, \
111 int (*forf)(struct ent *, void *), void *mdata) \
112 { \
113 struct ent##_entry *e; \
114 int rv; \
115 \
116 assert(td != NULL); \
117 assert(forf != NULL); \
118 \
119 rv = 0; \
120 STAILQ_FOREACH(e, &td->snapshot_data, entries) { \
121 rv = forf(&e->data, mdata); \
122 if (rv != 0) \
123 break; \
124 } \
125 \
126 return (rv); \
127 } \
128 \
129 int \
130 __##ent##_test_data_compare(struct ent##_test_data *td1, struct ent##_test_data *td2,\
131 int (*cmp_func)(struct ent *, struct ent *, void *), void *mdata)\
132 { \
133 struct ent##_entry *e1, *e2; \
134 int rv; \
135 \
136 assert(td1 != NULL); \
137 assert(td2 != NULL); \
138 assert(cmp_func != NULL); \
139 \
140 e1 = STAILQ_FIRST(&td1->snapshot_data); \
141 e2 = STAILQ_FIRST(&td2->snapshot_data); \
142 \
143 rv = 0; \
144 do { \
145 if ((e1 == NULL) || (e2 == NULL)) { \
146 if (e1 == e2) \
147 return (0); \
148 else \
149 return (-1); \
150 } \
151 \
152 rv = cmp_func(&e1->data, &e2->data, mdata); \
153 e1 = STAILQ_NEXT(e1, entries); \
154 e2 = STAILQ_NEXT(e2, entries); \
155 } while (rv == 0); \
156 \
157 return (rv); \
158 } \
159 \
160 struct ent * \
161 __##ent##_test_data_find(struct ent##_test_data *td, struct ent *data, \
162 int (*cmp)(struct ent *, struct ent *, void *), void *mdata) \
163 { \
164 struct ent##_entry *e; \
165 struct ent *result; \
166 \
167 assert(td != NULL); \
168 assert(cmp != NULL); \
169 \
170 result = NULL; \
171 STAILQ_FOREACH(e, &td->snapshot_data, entries) { \
172 if (cmp(&e->data, data, mdata) == 0) { \
173 result = &e->data; \
174 break; \
175 } \
176 } \
177 \
178 return (result); \
179 } \
180 \
181 \
182 void \
183 __##ent##_test_data_clear(struct ent##_test_data *td) \
184 { \
185 struct ent##_entry *e; \
186 assert(td != NULL); \
187 \
188 while (!STAILQ_EMPTY(&td->snapshot_data)) { \
189 e = STAILQ_FIRST(&td->snapshot_data); \
190 STAILQ_REMOVE_HEAD(&td->snapshot_data, entries); \
191 \
192 td->free_func(&e->data); \
193 free(e); \
194 } \
195 }
197 \
198 #define DECLARE_TEST_FILE_SNAPSHOT(ent) \
199 struct ent##_snp_param { \
200 FILE *fp; \
201 void (*sdump_func)(struct ent *, char *, size_t); \
202 }; \
203 \
204 int __##ent##_snapshot_write_func(struct ent *, void *); \
205 int __##ent##_snapshot_write(char const *, struct ent##_test_data *, \
206 void (*)(struct ent *, char *, size_t)); \
207 int __##ent##_snapshot_read(char const *, struct ent##_test_data *, \
208 int (*)(struct ent *, char *));
210 #define TEST_SNAPSHOT_FILE_WRITE(ent, fname, td, f) \
211 __##ent##_snapshot_write(fname, td, f)
212 #define TEST_SNAPSHOT_FILE_READ(ent, fname, td, f) \
213 __##ent##_snapshot_read(fname, td, f)
215 #define IMPLEMENT_TEST_FILE_SNAPSHOT(ent) \
216 int \
217 __##ent##_snapshot_write_func(struct ent *data, void *mdata) \
218 { \
219 char buffer[1024]; \
220 struct ent##_snp_param *param; \
221 \
222 assert(data != NULL); \
223 \
224 param = (struct ent##_snp_param *)mdata; \
225 param->sdump_func(data, buffer, sizeof(buffer)); \
226 fputs(buffer, param->fp); \
228 \
229 return (0); \
230 } \
231 \
232 int \
233 __##ent##_snapshot_write(char const *fname, struct ent##_test_data *td, \
234 void (*sdump_func)(struct ent *, char *, size_t)) \
235 { \
236 struct ent##_snp_param param; \
237 \
238 assert(fname != NULL); \
239 assert(td != NULL); \
240 \
242 if (param.fp == NULL) \
243 return (-1); \
244 \
245 param.sdump_func = sdump_func; \
246 __##ent##_test_data_foreach(td, __##ent##_snapshot_write_func, ¶m);\
247 fclose(param.fp); \
248 \
249 return (0); \
250 } \
251 \
252 int \
253 __##ent##_snapshot_read(char const *fname, struct ent##_test_data *td, \
254 int (*read_func)(struct ent *, char *)) \
255 { \
256 char buffer[1024]; \
257 struct ent data; \
258 char *s; \
259 FILE *fi; \
260 size_t len; \
261 int rv; \
262 \
263 assert(fname != NULL); \
264 assert(td != NULL); \
265 \
267 if (fi == NULL) \
268 return (-1); \
269 \
270 rv = 0; \
271 memset(buffer, 0, sizeof(buffer)); \
272 while (!feof(fi)) { \
273 s = fgets(buffer, sizeof(buffer), fi); \
275 len = strlen(s); \
276 if (len == 0) \
277 continue; \
280 \
281 rv = read_func(&data, s); \
282 if (rv == 0) { \
283 __##ent##_test_data_append(td, &data); \
284 td->free_func(&data); \
285 } else \
286 goto fin; \
287 } \
288 } \
289 \
290 fin: \
291 fclose(fi); \
292 return (rv); \
293 }
295 #define DECLARE_1PASS_TEST(ent) \
296 int __##ent##_1pass_test(struct ent##_test_data *, \
297 int (*)(struct ent *, void *), \
298 void *);
300 #define DO_1PASS_TEST(ent, td, f, mdata) \
301 __##ent##_1pass_test(td, f, mdata)
303 #define IMPLEMENT_1PASS_TEST(ent) \
304 int \
305 __##ent##_1pass_test(struct ent##_test_data *td, \
306 int (*tf)(struct ent *, void *), \
307 void *mdata) \
308 { \
309 int rv; \
310 rv = __##ent##_test_data_foreach(td, tf, mdata); \
311 \
312 return (rv); \
313 }
315 #define DECLARE_2PASS_TEST(ent) \
316 int __##ent##_2pass_test(struct ent##_test_data *, \
317 struct ent##_test_data *, \
318 int (*)(struct ent *, struct ent *, void *), void *);
320 #define DO_2PASS_TEST(ent, td1, td2, f, mdata) \
321 __##ent##_2pass_test(td1, td2, f, mdata)
323 #define IMPLEMENT_2PASS_TEST(ent) \
324 int \
325 __##ent##_2pass_test(struct ent##_test_data *td1, \
326 struct ent##_test_data *td2, \
327 int (*cmp_func)(struct ent *, struct ent *, void *), \
328 void *cmp_mdata) \
329 { \
330 int rv; \
331 \
332 rv = __##ent##_test_data_compare(td1, td2, cmp_func, cmp_mdata); \
333 return (rv); \
334 }