1 /*
2 Unix SMB/CIFS implementation.
3 SMB torture UI functions
4
5 Copyright (C) Jelmer Vernooij 2006
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23 #include "torture/ui.h"
24 #include "torture/torture.h"
25 #include "lib/util/dlinklist.h"
26
torture_comment(struct torture_context * context,const char * comment,...)27 void torture_comment(struct torture_context *context, const char *comment, ...)
28 {
29 va_list ap;
30 char *tmp;
31
32 if (!context->ui_ops->comment)
33 return;
34
35 va_start(ap, comment);
36 tmp = talloc_vasprintf(context, comment, ap);
37
38 context->ui_ops->comment(context, tmp);
39
40 talloc_free(tmp);
41 }
42
torture_result(struct torture_context * context,enum torture_result result,const char * fmt,...)43 void torture_result(struct torture_context *context,
44 enum torture_result result, const char *fmt, ...)
45 {
46 va_list ap;
47
48 va_start(ap, fmt);
49
50 context->last_result = result;
51 context->last_reason = talloc_vasprintf(context, fmt, ap);
52 va_end(ap);
53 }
54
torture_suite_create(TALLOC_CTX * ctx,const char * name)55 struct torture_suite *torture_suite_create(TALLOC_CTX *ctx, const char *name)
56 {
57 struct torture_suite *suite = talloc_zero(ctx, struct torture_suite);
58
59 suite->name = talloc_strdup(suite, name);
60 suite->testcases = NULL;
61 suite->children = NULL;
62
63 return suite;
64 }
65
torture_tcase_set_fixture(struct torture_tcase * tcase,BOOL (* setup)(struct torture_context *,void **),BOOL (* teardown)(struct torture_context *,void *))66 void torture_tcase_set_fixture(struct torture_tcase *tcase,
67 BOOL (*setup) (struct torture_context *, void **),
68 BOOL (*teardown) (struct torture_context *, void *))
69 {
70 tcase->setup = setup;
71 tcase->teardown = teardown;
72 }
73
wrap_test_with_testcase(struct torture_context * torture_ctx,struct torture_tcase * tcase,struct torture_test * test)74 static bool wrap_test_with_testcase(struct torture_context *torture_ctx,
75 struct torture_tcase *tcase,
76 struct torture_test *test)
77 {
78 bool (*fn) (struct torture_context *,
79 const void *tcase_data,
80 const void *test_data);
81
82 fn = test->fn;
83
84 return fn(torture_ctx, tcase->data, test->data);
85 }
86
torture_tcase_add_test(struct torture_tcase * tcase,const char * name,bool (* run)(struct torture_context *,const void * tcase_data,const void * test_data),const void * data)87 struct torture_test *torture_tcase_add_test(struct torture_tcase *tcase,
88 const char *name,
89 bool (*run) (struct torture_context *,
90 const void *tcase_data,
91 const void *test_data),
92 const void *data)
93 {
94 struct torture_test *test = talloc(tcase, struct torture_test);
95
96 test->name = talloc_strdup(test, name);
97 test->description = NULL;
98 test->run = wrap_test_with_testcase;
99 test->fn = run;
100 test->dangerous = False;
101 test->data = data;
102
103 DLIST_ADD_END(tcase->tests, test, struct torture_test *);
104
105 return test;
106 }
107
torture_suite_add_tcase(struct torture_suite * suite,const char * name)108 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite,
109 const char *name)
110 {
111 struct torture_tcase *tcase = talloc(suite, struct torture_tcase);
112
113 tcase->name = talloc_strdup(tcase, name);
114 tcase->description = NULL;
115 tcase->setup = NULL;
116 tcase->teardown = NULL;
117 tcase->fixture_persistent = True;
118 tcase->tests = NULL;
119
120 DLIST_ADD_END(suite->testcases, tcase, struct torture_tcase *);
121
122 return tcase;
123 }
124
torture_run_suite(struct torture_context * context,struct torture_suite * suite)125 BOOL torture_run_suite(struct torture_context *context,
126 struct torture_suite *suite)
127 {
128 BOOL ret = True;
129 struct torture_tcase *tcase;
130 struct torture_suite *tsuite;
131 char *old_testname;
132
133 context->level++;
134 if (context->ui_ops->suite_start)
135 context->ui_ops->suite_start(context, suite);
136
137 old_testname = context->active_testname;
138 if (old_testname != NULL)
139 context->active_testname = talloc_asprintf(context, "%s-%s",
140 old_testname, suite->name);
141 else
142 context->active_testname = talloc_strdup(context, suite->name);
143
144 if (suite->path)
145 ret &= torture_subunit_run_suite(context, suite);
146
147 for (tcase = suite->testcases; tcase; tcase = tcase->next) {
148 ret &= torture_run_tcase(context, tcase);
149 }
150
151 for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
152 ret &= torture_run_suite(context, tsuite);
153 }
154
155 talloc_free(context->active_testname);
156 context->active_testname = old_testname;
157
158 if (context->ui_ops->suite_finish)
159 context->ui_ops->suite_finish(context, suite);
160
161 context->level--;
162
163 return ret;
164 }
165
torture_ui_test_start(struct torture_context * context,struct torture_tcase * tcase,struct torture_test * test)166 void torture_ui_test_start(struct torture_context *context,
167 struct torture_tcase *tcase,
168 struct torture_test *test)
169 {
170 if (context->ui_ops->test_start)
171 context->ui_ops->test_start(context, tcase, test);
172 }
173
str_list_match(const char * name,char ** list)174 int str_list_match(const char *name, char **list)
175 {
176 int i, ret = 0;
177 if (list == NULL)
178 return 0;
179
180 for (i = 0; list[i]; i++) {
181 if (gen_fnmatch(list[i], name) == 0)
182 ret++;
183 }
184 return ret;
185 }
186
torture_ui_test_result(struct torture_context * context,enum torture_result result,const char * comment)187 void torture_ui_test_result(struct torture_context *context,
188 enum torture_result result,
189 const char *comment)
190 {
191 if (context->ui_ops->test_result)
192 context->ui_ops->test_result(context, result, comment);
193
194 if (result == TORTURE_SKIP) {
195 context->results.skipped++;
196 } else if (result == TORTURE_OK) {
197 if (str_list_match(context->active_testname,
198 context->expected_failures)) {
199 context->results.unexpected_successes = str_list_add(
200 context->results.unexpected_successes,
201 talloc_reference(context, context->active_testname));
202 }
203 context->results.success++;
204 } else if (result == TORTURE_ERROR) {
205 context->results.unexpected_errors = str_list_add(
206 context->results.unexpected_errors,
207 talloc_reference(context, context->active_testname));
208 context->results.errors++;
209 context->results.returncode = false;
210 } else if (result == TORTURE_FAIL) {
211 if (0 == str_list_match(context->active_testname,
212 context->expected_failures)) {
213 context->results.unexpected_failures = str_list_add(
214 context->results.unexpected_failures,
215 talloc_reference(context, context->active_testname));
216 context->results.returncode = false;
217 }
218 context->results.failed++;
219 }
220 }
221
internal_torture_run_test(struct torture_context * context,struct torture_tcase * tcase,struct torture_test * test,BOOL already_setup)222 static BOOL internal_torture_run_test(struct torture_context *context,
223 struct torture_tcase *tcase,
224 struct torture_test *test,
225 BOOL already_setup)
226 {
227 BOOL ret;
228 char *old_testname;
229
230 if (test->dangerous && !torture_setting_bool(context, "dangerous", False)) {
231 torture_result(context, TORTURE_SKIP,
232 "disabled %s - enable dangerous tests to use", test->name);
233 return True;
234 }
235
236 if (!already_setup && tcase->setup &&
237 !tcase->setup(context, &(tcase->data)))
238 return False;
239
240 if (tcase == NULL || strcmp(test->name, tcase->name) != 0) {
241 old_testname = context->active_testname;
242 context->active_testname = talloc_asprintf(context, "%s-%s",
243 old_testname, test->name);
244 }
245 context->active_tcase = tcase;
246 context->active_test = test;
247
248 torture_ui_test_start(context, tcase, test);
249
250
251 context->last_reason = NULL;
252 context->last_result = TORTURE_OK;
253
254 ret = test->run(context, tcase, test);
255 if (!ret && context->last_result == TORTURE_OK) {
256 if (context->last_reason == NULL)
257 context->last_reason = talloc_strdup(context, "Unknown error/failure");
258 context->last_result = TORTURE_ERROR;
259 }
260
261 torture_ui_test_result(context, context->last_result, context->last_reason);
262
263 talloc_free(context->last_reason);
264
265 if (tcase == NULL || strcmp(test->name, tcase->name) != 0) {
266 talloc_free(context->active_testname);
267 context->active_testname = old_testname;
268 }
269 context->active_test = NULL;
270 context->active_tcase = NULL;
271
272 if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data))
273 return False;
274
275 return ret;
276 }
277
torture_run_tcase(struct torture_context * context,struct torture_tcase * tcase)278 BOOL torture_run_tcase(struct torture_context *context,
279 struct torture_tcase *tcase)
280 {
281 BOOL ret = True;
282 char *old_testname;
283 struct torture_test *test;
284
285 context->level++;
286
287 context->active_tcase = tcase;
288 if (context->ui_ops->tcase_start)
289 context->ui_ops->tcase_start(context, tcase);
290
291 if (tcase->fixture_persistent && tcase->setup
292 && !tcase->setup(context, &tcase->data)) {
293 ret = False;
294 goto done;
295 }
296
297 old_testname = context->active_testname;
298 context->active_testname = talloc_asprintf(context, "%s-%s",
299 old_testname, tcase->name);
300 for (test = tcase->tests; test; test = test->next) {
301 ret &= internal_torture_run_test(context, tcase, test,
302 tcase->fixture_persistent);
303 }
304 talloc_free(context->active_testname);
305 context->active_testname = old_testname;
306
307 if (tcase->fixture_persistent && tcase->teardown &&
308 !tcase->teardown(context, tcase->data))
309 ret = False;
310
311 done:
312 context->active_tcase = NULL;
313
314 if (context->ui_ops->tcase_finish)
315 context->ui_ops->tcase_finish(context, tcase);
316
317 context->level--;
318
319 return ret;
320 }
321
torture_run_test(struct torture_context * context,struct torture_tcase * tcase,struct torture_test * test)322 BOOL torture_run_test(struct torture_context *context,
323 struct torture_tcase *tcase,
324 struct torture_test *test)
325 {
326 return internal_torture_run_test(context, tcase, test, False);
327 }
328
torture_setting_int(struct torture_context * test,const char * name,int default_value)329 int torture_setting_int(struct torture_context *test, const char *name,
330 int default_value)
331 {
332 return lp_parm_int(-1, "torture", name, default_value);
333 }
334
torture_setting_bool(struct torture_context * test,const char * name,bool default_value)335 bool torture_setting_bool(struct torture_context *test, const char *name,
336 bool default_value)
337 {
338 return lp_parm_bool(-1, "torture", name, default_value);
339 }
340
torture_setting_string(struct torture_context * test,const char * name,const char * default_value)341 const char *torture_setting_string(struct torture_context *test, const char *name,
342 const char *default_value)
343 {
344 const char *ret = lp_parm_string(-1, "torture", name);
345
346 if (ret == NULL)
347 return default_value;
348
349 return ret;
350 }
351
wrap_test_with_simple_tcase(struct torture_context * torture_ctx,struct torture_tcase * tcase,struct torture_test * test)352 static bool wrap_test_with_simple_tcase(struct torture_context *torture_ctx,
353 struct torture_tcase *tcase,
354 struct torture_test *test)
355 {
356 bool (*fn) (struct torture_context *, const void *tcase_data);
357
358 fn = test->fn;
359
360 return fn(torture_ctx, test->data);
361 }
362
torture_suite_add_simple_tcase(struct torture_suite * suite,const char * name,bool (* run)(struct torture_context * test,const void *),const void * data)363 struct torture_tcase *torture_suite_add_simple_tcase(
364 struct torture_suite *suite,
365 const char *name,
366 bool (*run) (struct torture_context *test, const void *),
367 const void *data)
368 {
369 struct torture_tcase *tcase;
370 struct torture_test *test;
371
372 tcase = torture_suite_add_tcase(suite, name);
373
374 test = talloc(tcase, struct torture_test);
375
376 test->name = talloc_strdup(test, name);
377 test->description = NULL;
378 test->run = wrap_test_with_simple_tcase;
379 test->fn = run;
380 test->data = data;
381 test->dangerous = False;
382
383 DLIST_ADD_END(tcase->tests, test, struct torture_test *);
384
385 return tcase;
386 }
387
wrap_simple_test(struct torture_context * torture_ctx,struct torture_tcase * tcase,struct torture_test * test)388 static bool wrap_simple_test(struct torture_context *torture_ctx,
389 struct torture_tcase *tcase,
390 struct torture_test *test)
391 {
392 bool (*fn) (struct torture_context *);
393
394 fn = test->fn;
395
396 return fn(torture_ctx);
397 }
398
torture_suite_add_simple_test(struct torture_suite * suite,const char * name,bool (* run)(struct torture_context * test))399 struct torture_tcase *torture_suite_add_simple_test(
400 struct torture_suite *suite,
401 const char *name,
402 bool (*run) (struct torture_context *test))
403 {
404 struct torture_test *test;
405 struct torture_tcase *tcase;
406
407 tcase = torture_suite_add_tcase(suite, name);
408
409 test = talloc(tcase, struct torture_test);
410
411 test->name = talloc_strdup(test, name);
412 test->description = NULL;
413 test->run = wrap_simple_test;
414 test->fn = run;
415 test->dangerous = false;
416
417 DLIST_ADD_END(tcase->tests, test, struct torture_test *);
418
419 return tcase;
420 }
421
torture_suite_add_suite(struct torture_suite * suite,struct torture_suite * child)422 bool torture_suite_add_suite(struct torture_suite *suite,
423 struct torture_suite *child)
424 {
425 if (child == NULL)
426 return false;
427
428 DLIST_ADD_END(suite->children, child, struct torture_suite *);
429
430 /* FIXME: Check for duplicates and return false if the
431 * added suite already exists as a child */
432
433 return true;
434 }
435
436
torture_find_suite(struct torture_suite * parent,const char * name)437 struct torture_suite *torture_find_suite(struct torture_suite *parent,
438 const char *name)
439 {
440 struct torture_suite *child;
441
442 for (child = parent->children; child; child = child->next)
443 if (!strcmp(child->name, name))
444 return child;
445
446 return NULL;
447 }
448