Line data Source code
1 : /*
2 : SSSD
3 :
4 : debug-tests.c
5 :
6 : Authors:
7 : Pavel Březina <pbrezina@redhat.com>
8 :
9 : Copyright (C) 2011 Red Hat
10 :
11 : This program is free software; you can redistribute it and/or modify
12 : it under the terms of the GNU General Public License as published by
13 : the Free Software Foundation; either version 3 of the License, or
14 : (at your option) any later version.
15 :
16 : This program is distributed in the hope that it will be useful,
17 : but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : GNU General Public License for more details.
20 :
21 : You should have received a copy of the GNU General Public License
22 : along with this program. If not, see <http://www.gnu.org/licenses/>.
23 : */
24 :
25 : #include <check.h>
26 : #include <stdio.h>
27 : #include <talloc.h>
28 : #include <errno.h>
29 : #include <string.h>
30 : #include "util/util.h"
31 : #include "tests/common.h"
32 :
33 : #define DEBUG_TEST_ERROR -1
34 : #define DEBUG_TEST_NOK 1
35 : #define DEBUG_TEST_NOK_TS 2
36 :
37 1 : START_TEST(test_debug_convert_old_level_old_format)
38 : {
39 1 : int expected_level = 0x0000;
40 : int old_level;
41 1 : int levels[] = {
42 : SSSDBG_FATAL_FAILURE,
43 : SSSDBG_CRIT_FAILURE,
44 : SSSDBG_OP_FAILURE,
45 : SSSDBG_MINOR_FAILURE,
46 : SSSDBG_CONF_SETTINGS,
47 : SSSDBG_FUNC_DATA,
48 : SSSDBG_TRACE_FUNC,
49 : SSSDBG_TRACE_LIBS,
50 : SSSDBG_TRACE_INTERNAL,
51 : SSSDBG_TRACE_ALL | SSSDBG_BE_FO
52 : };
53 :
54 11 : for (old_level = 0; old_level <= 9; old_level++) {
55 10 : expected_level |= levels[old_level];
56 :
57 10 : char *msg = NULL;
58 10 : msg = talloc_asprintf(NULL, "Invalid conversion of %d", old_level);
59 10 : fail_unless(debug_convert_old_level(old_level) == expected_level, msg);
60 10 : talloc_free(msg);
61 : }
62 : }
63 1 : END_TEST
64 :
65 1 : START_TEST(test_debug_convert_old_level_new_format)
66 : {
67 1 : fail_unless(
68 : debug_convert_old_level(SSSDBG_UNRESOLVED) == SSSDBG_FATAL_FAILURE,
69 : "Invalid conversion of SSSDBG_UNRESOLVED"
70 : );
71 1 : fail_unless(
72 : debug_convert_old_level(SSSDBG_FATAL_FAILURE) == SSSDBG_FATAL_FAILURE,
73 : "Invalid conversion of SSSDBG_FATAL_FAILURE"
74 : );
75 1 : fail_unless(
76 : debug_convert_old_level(SSSDBG_CRIT_FAILURE) == SSSDBG_CRIT_FAILURE,
77 : "Invalid conversion of SSSDBG_CRIT_FAILURE"
78 : );
79 1 : fail_unless(
80 : debug_convert_old_level(SSSDBG_OP_FAILURE) == SSSDBG_OP_FAILURE,
81 : "Invalid conversion of SSSDBG_OP_FAILURE"
82 : );
83 1 : fail_unless(
84 : debug_convert_old_level(SSSDBG_MINOR_FAILURE) == SSSDBG_MINOR_FAILURE,
85 : "Invalid conversion of SSSDBG_MINOR_FAILURE"
86 : );
87 1 : fail_unless(
88 : debug_convert_old_level(SSSDBG_CONF_SETTINGS) == SSSDBG_CONF_SETTINGS,
89 : "Invalid conversion of SSSDBG_CONF_SETTINGS"
90 : );
91 1 : fail_unless(
92 : debug_convert_old_level(SSSDBG_FUNC_DATA) == SSSDBG_FUNC_DATA,
93 : "Invalid conversion of SSSDBG_FUNC_DATA"
94 : );
95 1 : fail_unless(
96 : debug_convert_old_level(SSSDBG_TRACE_FUNC) == SSSDBG_TRACE_FUNC,
97 : "Invalid conversion of SSSDBG_TRACE_FUNC"
98 : );
99 1 : fail_unless(
100 : debug_convert_old_level(SSSDBG_TRACE_LIBS) == SSSDBG_TRACE_LIBS,
101 : "Invalid conversion of SSSDBG_TRACE_LIBS"
102 : );
103 1 : fail_unless(
104 : debug_convert_old_level(SSSDBG_TRACE_INTERNAL) == SSSDBG_TRACE_INTERNAL,
105 : "Invalid conversion of SSSDBG_TRACE_INTERNAL"
106 : );
107 1 : fail_unless(
108 : debug_convert_old_level(SSSDBG_TRACE_ALL) == SSSDBG_TRACE_ALL,
109 : "Invalid conversion of SSSDBG_TRACE_ALL"
110 : );
111 1 : fail_unless(
112 : debug_convert_old_level(SSSDBG_MASK_ALL) == SSSDBG_MASK_ALL,
113 : "Invalid conversion of SSSDBG_MASK_ALL"
114 : );
115 : }
116 1 : END_TEST
117 :
118 30 : int test_helper_debug_check_message(int level)
119 : {
120 30 : TALLOC_CTX *ctx = talloc_new(NULL);
121 30 : char filename[24] = {'\0'};
122 30 : char *msg = NULL;
123 30 : char *compare_to = NULL;
124 30 : const char *function = __FUNCTION__;
125 30 : const char *body = "some error";
126 : int filesize;
127 : int fsize;
128 : int fd;
129 : int ret;
130 30 : int _errno = 0;
131 : mode_t old_umask;
132 30 : FILE *file = NULL;
133 :
134 30 : strncpy(filename, "sssd_debug_tests.XXXXXX", 24);
135 :
136 30 : old_umask = umask(SSS_DFL_UMASK);
137 30 : fd = mkstemp(filename);
138 30 : umask(old_umask);
139 30 : if (fd == -1) {
140 0 : _errno = errno;
141 0 : talloc_free(ctx);
142 0 : errno = _errno;
143 0 : return DEBUG_TEST_ERROR;
144 : }
145 :
146 30 : file = fdopen(fd, "r");
147 30 : if (file == NULL) {
148 0 : _errno = errno;
149 0 : ret = DEBUG_TEST_ERROR;
150 0 : goto done;
151 : }
152 :
153 30 : ret = set_debug_file_from_fd(fd);
154 30 : if (ret != EOK) {
155 0 : _errno = ret;
156 0 : ret = DEBUG_TEST_ERROR;
157 0 : goto done;
158 : }
159 :
160 30 : DEBUG(level, "%s\n", body);
161 :
162 30 : ret = fseek(file, 0, SEEK_END);
163 30 : if (ret == -1) {
164 0 : _errno = errno;
165 0 : ret = DEBUG_TEST_ERROR;
166 0 : goto done;
167 : }
168 :
169 30 : filesize = ftell(file);
170 30 : if (filesize == -1) {
171 0 : _errno = errno;
172 0 : ret = DEBUG_TEST_ERROR;
173 0 : goto done;
174 : }
175 :
176 30 : rewind(file);
177 :
178 30 : msg = talloc_array(ctx, char, filesize+1);
179 30 : if (msg == NULL) {
180 0 : _errno = ENOMEM;
181 0 : ret = DEBUG_TEST_ERROR;
182 0 : goto done;
183 : }
184 30 : fsize = fread(msg, sizeof(char), filesize, file);
185 30 : if (fsize != filesize) {
186 0 : _errno = EIO;
187 0 : ret = DEBUG_TEST_ERROR;
188 0 : goto done;
189 : }
190 30 : msg[fsize] = '\0';
191 :
192 30 : if (debug_timestamps == 1) {
193 20 : char time_day[4] = {'\0', '\0', '\0', '\0'};
194 20 : char time_month[4] = {'\0', '\0', '\0', '\0'};
195 20 : int time_day_num = 0;
196 20 : int time_hour = 0;
197 20 : int time_min = 0;
198 20 : int time_sec = 0;
199 20 : int time_usec = 0;
200 20 : int time_year = 0;
201 20 : int scan_return = 0;
202 :
203 20 : if (debug_microseconds == 0) {
204 10 : scan_return = sscanf(msg, "(%s %s %d %d:%d:%d %d)", time_day, time_month,
205 : &time_day_num, &time_hour, &time_min, &time_sec, &time_year);
206 :
207 10 : if (scan_return != 7) {
208 0 : ret = DEBUG_TEST_NOK_TS;
209 0 : goto done;
210 : }
211 10 : compare_to = talloc_asprintf(ctx,
212 : "(%s %s %2d %.2d:%.2d:%.2d %.4d) "
213 : "[%s] [%s] (%#.4x): %s\n",
214 : time_day, time_month, time_day_num,
215 : time_hour, time_min, time_sec, time_year,
216 : debug_prg_name, function, level, body);
217 10 : if (compare_to == NULL) {
218 0 : _errno = ENOMEM;
219 0 : ret = DEBUG_TEST_ERROR;
220 0 : goto done;
221 : }
222 : } else {
223 10 : scan_return = sscanf(msg, "(%s %s %d %d:%d:%d:%d %d)", time_day, time_month,
224 : &time_day_num, &time_hour, &time_min, &time_sec,
225 : &time_usec, &time_year);
226 :
227 10 : if (scan_return != 8) {
228 0 : ret = DEBUG_TEST_NOK_TS;
229 0 : goto done;
230 : }
231 10 : compare_to = talloc_asprintf(ctx,
232 : "(%s %s %2d %.2d:%.2d:%.2d:%.6d %.4d) "
233 : "[%s] [%s] (%#.4x): %s\n",
234 : time_day, time_month, time_day_num,
235 : time_hour, time_min, time_sec, time_usec,
236 : time_year, debug_prg_name, function, level, body);
237 10 : if (compare_to == NULL) {
238 0 : _errno = ENOMEM;
239 0 : ret = DEBUG_TEST_ERROR;
240 0 : goto done;
241 : }
242 : }
243 : } else {
244 10 : compare_to = talloc_asprintf(ctx, "[%s] [%s] (%#.4x): %s\n",
245 : debug_prg_name, function, level, body);
246 10 : if (compare_to == NULL) {
247 0 : _errno = ENOMEM;
248 0 : ret = DEBUG_TEST_ERROR;
249 0 : goto done;
250 : }
251 : }
252 30 : ret = strncmp(msg, compare_to, filesize) == 0 ? EOK : DEBUG_TEST_NOK;
253 :
254 : done:
255 30 : talloc_free(ctx);
256 30 : if (file != NULL) {
257 30 : fclose(file);
258 : }
259 30 : remove(filename);
260 30 : errno = _errno;
261 30 : return ret;
262 : }
263 :
264 30 : int test_helper_debug_is_empty_message(int level)
265 : {
266 30 : char filename[24] = {'\0'};
267 : int fd;
268 : int filesize;
269 : int ret;
270 30 : int _errno = 0;
271 : mode_t old_umask;
272 : FILE *file;
273 :
274 30 : strncpy(filename, "sssd_debug_tests.XXXXXX", 24);
275 :
276 30 : old_umask = umask(SSS_DFL_UMASK);
277 30 : fd = mkstemp(filename);
278 30 : umask(old_umask);
279 30 : if (fd == -1) {
280 0 : return DEBUG_TEST_ERROR;
281 : }
282 :
283 30 : file = fdopen(fd, "r");
284 30 : if (file == NULL) {
285 0 : _errno = errno;
286 0 : ret = DEBUG_TEST_ERROR;
287 0 : goto done;
288 : }
289 :
290 30 : ret = set_debug_file_from_fd(fd);
291 30 : if (ret != EOK) {
292 0 : _errno = ret;
293 0 : ret = DEBUG_TEST_ERROR;
294 0 : goto done;
295 : }
296 :
297 30 : DEBUG(level, "some error\n");
298 :
299 30 : ret = fseek(file, 0, SEEK_END);
300 30 : if (ret == -1) {
301 0 : _errno = errno;
302 0 : ret = DEBUG_TEST_ERROR;
303 0 : goto done;
304 : }
305 :
306 30 : filesize = ftell(file);
307 30 : if (filesize == -1) {
308 0 : _errno = errno;
309 0 : ret = DEBUG_TEST_ERROR;
310 0 : goto done;
311 : }
312 :
313 30 : ret = filesize == 0 ? EOK : DEBUG_TEST_NOK;
314 :
315 : done:
316 30 : if (file != NULL) {
317 30 : fclose(file);
318 : }
319 30 : remove(filename);
320 30 : errno = _errno;
321 30 : return ret;
322 : }
323 :
324 1 : START_TEST(test_debug_is_set_single_no_timestamp)
325 : {
326 : int i;
327 : int result;
328 1 : int levels[] = {
329 : SSSDBG_FATAL_FAILURE,
330 : SSSDBG_CRIT_FAILURE,
331 : SSSDBG_OP_FAILURE,
332 : SSSDBG_MINOR_FAILURE,
333 : SSSDBG_CONF_SETTINGS,
334 : SSSDBG_FUNC_DATA,
335 : SSSDBG_TRACE_FUNC,
336 : SSSDBG_TRACE_LIBS,
337 : SSSDBG_TRACE_INTERNAL,
338 : SSSDBG_TRACE_ALL
339 : };
340 : char *error_msg;
341 :
342 1 : debug_timestamps = 0;
343 1 : debug_microseconds = 0;
344 1 : debug_to_file = 1;
345 1 : debug_prg_name = "sssd";
346 :
347 11 : for (i = 0; i <= 9; i++) {
348 10 : debug_level = levels[i];
349 :
350 10 : errno = 0;
351 10 : result = test_helper_debug_check_message(levels[i]);
352 :
353 10 : if (result == DEBUG_TEST_ERROR) {
354 0 : error_msg = strerror(errno);
355 0 : fail(error_msg);
356 : }
357 :
358 10 : char *msg = NULL;
359 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message don't match", levels[i]);
360 10 : fail_unless(result == EOK, msg);
361 10 : talloc_free(msg);
362 : }
363 : }
364 1 : END_TEST
365 :
366 1 : START_TEST(test_debug_is_set_single_timestamp)
367 : {
368 : int i;
369 : int result;
370 1 : int levels[] = {
371 : SSSDBG_FATAL_FAILURE,
372 : SSSDBG_CRIT_FAILURE,
373 : SSSDBG_OP_FAILURE,
374 : SSSDBG_MINOR_FAILURE,
375 : SSSDBG_CONF_SETTINGS,
376 : SSSDBG_FUNC_DATA,
377 : SSSDBG_TRACE_FUNC,
378 : SSSDBG_TRACE_LIBS,
379 : SSSDBG_TRACE_INTERNAL,
380 : SSSDBG_TRACE_ALL
381 : };
382 : char *error_msg;
383 :
384 1 : debug_timestamps = 1;
385 1 : debug_microseconds = 0;
386 1 : debug_to_file = 1;
387 1 : debug_prg_name = "sssd";
388 :
389 11 : for (i = 0; i <= 9; i++) {
390 10 : debug_level = levels[i];
391 :
392 10 : errno = 0;
393 10 : result = test_helper_debug_check_message(levels[i]);
394 :
395 10 : if (result == DEBUG_TEST_ERROR) {
396 0 : error_msg = strerror(errno);
397 0 : fail(error_msg);
398 : }
399 :
400 10 : char *msg = NULL;
401 :
402 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - invalid timestamp", levels[i]);
403 10 : fail_if(result == DEBUG_TEST_NOK_TS, msg);
404 10 : talloc_free(msg);
405 :
406 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message don't match", levels[i]);
407 10 : fail_unless(result == EOK, msg);
408 10 : talloc_free(msg);
409 : }
410 : }
411 1 : END_TEST
412 :
413 1 : START_TEST(test_debug_is_set_single_timestamp_microseconds)
414 : {
415 : int i;
416 : int result;
417 1 : int levels[] = {
418 : SSSDBG_FATAL_FAILURE,
419 : SSSDBG_CRIT_FAILURE,
420 : SSSDBG_OP_FAILURE,
421 : SSSDBG_MINOR_FAILURE,
422 : SSSDBG_CONF_SETTINGS,
423 : SSSDBG_FUNC_DATA,
424 : SSSDBG_TRACE_FUNC,
425 : SSSDBG_TRACE_LIBS,
426 : SSSDBG_TRACE_INTERNAL,
427 : SSSDBG_TRACE_ALL
428 : };
429 : char *error_msg;
430 :
431 1 : debug_timestamps = 1;
432 1 : debug_microseconds = 1;
433 1 : debug_to_file = 1;
434 1 : debug_prg_name = "sssd";
435 :
436 11 : for (i = 0; i <= 9; i++) {
437 10 : debug_level = levels[i];
438 :
439 10 : errno = 0;
440 10 : result = test_helper_debug_check_message(levels[i]);
441 :
442 10 : if (result == DEBUG_TEST_ERROR) {
443 0 : error_msg = strerror(errno);
444 0 : fail(error_msg);
445 : }
446 :
447 10 : char *msg = NULL;
448 :
449 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - invalid timestamp", levels[i]);
450 10 : fail_if(result == DEBUG_TEST_NOK_TS, msg);
451 10 : talloc_free(msg);
452 :
453 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message don't match", levels[i]);
454 10 : fail_unless(result == EOK, msg);
455 10 : talloc_free(msg);
456 : }
457 : }
458 1 : END_TEST
459 :
460 1 : START_TEST(test_debug_is_notset_no_timestamp)
461 : {
462 : int i;
463 : int result;
464 1 : int all_set = SSSDBG_MASK_ALL;
465 1 : int levels[] = {
466 : SSSDBG_FATAL_FAILURE,
467 : SSSDBG_CRIT_FAILURE,
468 : SSSDBG_OP_FAILURE,
469 : SSSDBG_MINOR_FAILURE,
470 : SSSDBG_CONF_SETTINGS,
471 : SSSDBG_FUNC_DATA,
472 : SSSDBG_TRACE_FUNC,
473 : SSSDBG_TRACE_LIBS,
474 : SSSDBG_TRACE_INTERNAL,
475 : SSSDBG_TRACE_ALL
476 : };
477 : char *error_msg;
478 :
479 1 : debug_timestamps = 0;
480 1 : debug_microseconds = 0;
481 1 : debug_to_file = 1;
482 1 : debug_prg_name = "sssd";
483 :
484 11 : for (i = 0; i <= 9; i++) {
485 10 : debug_level = all_set & ~levels[i];
486 :
487 10 : errno = 0;
488 10 : result = test_helper_debug_is_empty_message(levels[i]);
489 :
490 10 : if (result == DEBUG_TEST_ERROR) {
491 0 : error_msg = strerror(errno);
492 0 : fail(error_msg);
493 : }
494 :
495 10 : char *msg = NULL;
496 10 : msg = talloc_asprintf(NULL,
497 : "Test of level %#.4x failed - message has been written",
498 : levels[i]);
499 10 : fail_unless(result == EOK, msg);
500 10 : talloc_free(msg);
501 : }
502 : }
503 1 : END_TEST
504 :
505 1 : START_TEST(test_debug_is_notset_timestamp)
506 : {
507 : int i;
508 : int result;
509 1 : int all_set = SSSDBG_MASK_ALL;
510 1 : int levels[] = {
511 : SSSDBG_FATAL_FAILURE,
512 : SSSDBG_CRIT_FAILURE,
513 : SSSDBG_OP_FAILURE,
514 : SSSDBG_MINOR_FAILURE,
515 : SSSDBG_CONF_SETTINGS,
516 : SSSDBG_FUNC_DATA,
517 : SSSDBG_TRACE_FUNC,
518 : SSSDBG_TRACE_LIBS,
519 : SSSDBG_TRACE_INTERNAL,
520 : SSSDBG_TRACE_ALL
521 : };
522 : char *error_msg;
523 :
524 1 : debug_timestamps = 0;
525 1 : debug_microseconds = 0;
526 1 : debug_to_file = 1;
527 1 : debug_prg_name = "sssd";
528 :
529 11 : for (i = 0; i <= 9; i++) {
530 10 : debug_level = all_set & ~levels[i];
531 :
532 10 : errno = 0;
533 10 : result = test_helper_debug_is_empty_message(levels[i]);
534 :
535 10 : if (result == DEBUG_TEST_ERROR) {
536 0 : error_msg = strerror(errno);
537 0 : fail(error_msg);
538 : }
539 :
540 10 : char *msg = NULL;
541 10 : msg = talloc_asprintf(NULL,
542 : "Test of level %#.4x failed - message has been written",
543 : levels[i]);
544 10 : fail_unless(result == EOK, msg);
545 10 : talloc_free(msg);
546 : }
547 : }
548 1 : END_TEST
549 :
550 1 : START_TEST(test_debug_is_notset_timestamp_microseconds)
551 : {
552 : int i;
553 : int result;
554 1 : int all_set = SSSDBG_MASK_ALL;
555 1 : int levels[] = {
556 : SSSDBG_FATAL_FAILURE,
557 : SSSDBG_CRIT_FAILURE,
558 : SSSDBG_OP_FAILURE,
559 : SSSDBG_MINOR_FAILURE,
560 : SSSDBG_CONF_SETTINGS,
561 : SSSDBG_FUNC_DATA,
562 : SSSDBG_TRACE_FUNC,
563 : SSSDBG_TRACE_LIBS,
564 : SSSDBG_TRACE_INTERNAL,
565 : SSSDBG_TRACE_ALL
566 : };
567 : char *error_msg;
568 :
569 1 : debug_timestamps = 0;
570 1 : debug_microseconds = 1;
571 1 : debug_to_file = 1;
572 1 : debug_prg_name = "sssd";
573 :
574 11 : for (i = 0; i <= 9; i++) {
575 10 : debug_level = all_set & ~levels[i];
576 :
577 10 : errno = 0;
578 10 : result = test_helper_debug_is_empty_message(levels[i]);
579 :
580 10 : if (result == DEBUG_TEST_ERROR) {
581 0 : error_msg = strerror(errno);
582 0 : fail(error_msg);
583 : }
584 :
585 10 : char *msg = NULL;
586 10 : msg = talloc_asprintf(NULL,
587 : "Test of level %#.4x failed - message has been written",
588 : levels[i]);
589 10 : fail_unless(result == EOK, msg);
590 10 : talloc_free(msg);
591 : }
592 : }
593 1 : END_TEST
594 :
595 1 : START_TEST(test_debug_is_set_true)
596 : {
597 : int i;
598 : int result;
599 1 : int levels[] = {
600 : SSSDBG_FATAL_FAILURE,
601 : SSSDBG_CRIT_FAILURE,
602 : SSSDBG_OP_FAILURE,
603 : SSSDBG_MINOR_FAILURE,
604 : SSSDBG_CONF_SETTINGS,
605 : SSSDBG_FUNC_DATA,
606 : SSSDBG_TRACE_FUNC,
607 : SSSDBG_TRACE_LIBS,
608 : SSSDBG_TRACE_INTERNAL,
609 : SSSDBG_TRACE_ALL
610 : };
611 :
612 1 : debug_level = SSSDBG_MASK_ALL;
613 :
614 11 : for (i = 0; i <= 9; i++) {
615 10 : result = DEBUG_IS_SET(levels[i]);
616 10 : char *msg = NULL;
617 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - result is 0x%.4x", levels[i], result);
618 10 : fail_unless(result > 0, msg);
619 10 : talloc_free(msg);
620 : }
621 : }
622 1 : END_TEST
623 :
624 1 : START_TEST(test_debug_is_set_false)
625 : {
626 : int i;
627 : int result;
628 1 : int all_set = SSSDBG_MASK_ALL;
629 1 : int levels[] = {
630 : SSSDBG_FATAL_FAILURE,
631 : SSSDBG_CRIT_FAILURE,
632 : SSSDBG_OP_FAILURE,
633 : SSSDBG_MINOR_FAILURE,
634 : SSSDBG_CONF_SETTINGS,
635 : SSSDBG_FUNC_DATA,
636 : SSSDBG_TRACE_FUNC,
637 : SSSDBG_TRACE_LIBS,
638 : SSSDBG_TRACE_INTERNAL,
639 : SSSDBG_TRACE_ALL
640 : };
641 :
642 11 : for (i = 0; i <= 9; i++) {
643 10 : debug_level = all_set & ~levels[i];
644 :
645 10 : result = DEBUG_IS_SET(levels[i]);
646 10 : char *msg = NULL;
647 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - result is 0x%.4x", levels[i], result);
648 10 : fail_unless(result == 0, msg);
649 10 : talloc_free(msg);
650 : }
651 : }
652 1 : END_TEST
653 :
654 1 : Suite *debug_suite(void)
655 : {
656 1 : Suite *s = suite_create("debug");
657 :
658 1 : TCase *tc_debug = tcase_create("debug");
659 :
660 1 : tcase_add_test(tc_debug, test_debug_convert_old_level_old_format);
661 1 : tcase_add_test(tc_debug, test_debug_convert_old_level_new_format);
662 1 : tcase_add_test(tc_debug, test_debug_is_set_single_no_timestamp);
663 1 : tcase_add_test(tc_debug, test_debug_is_set_single_timestamp);
664 1 : tcase_add_test(tc_debug, test_debug_is_set_single_timestamp_microseconds);
665 1 : tcase_add_test(tc_debug, test_debug_is_notset_no_timestamp);
666 1 : tcase_add_test(tc_debug, test_debug_is_notset_timestamp);
667 1 : tcase_add_test(tc_debug, test_debug_is_notset_timestamp_microseconds);
668 1 : tcase_add_test(tc_debug, test_debug_is_set_true);
669 1 : tcase_add_test(tc_debug, test_debug_is_set_false);
670 1 : tcase_set_timeout(tc_debug, 60);
671 :
672 1 : suite_add_tcase(s, tc_debug);
673 :
674 1 : return s;
675 : }
676 :
677 1 : int main(int argc, const char *argv[])
678 : {
679 : int number_failed;
680 :
681 1 : tests_set_cwd();
682 :
683 1 : Suite *s = debug_suite();
684 1 : SRunner *sr = srunner_create(s);
685 :
686 1 : srunner_run_all(sr, CK_NORMAL);
687 1 : number_failed = srunner_ntests_failed(sr);
688 1 : srunner_free(sr);
689 :
690 1 : if (number_failed == 0)
691 1 : return EXIT_SUCCESS;
692 :
693 0 : return EXIT_FAILURE;
694 : }
|
