Branch data 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
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 : 1 : START_TEST(test_debug_get_level_old_format)
119 : : {
120 : 1 : fail_unless(debug_get_level(0) == SSSDBG_FATAL_FAILURE, "Invalid conversion of 0");
121 : 1 : fail_unless(debug_get_level(1) == SSSDBG_CRIT_FAILURE, "Invalid conversion of 1");
122 : 1 : fail_unless(debug_get_level(2) == SSSDBG_OP_FAILURE, "Invalid conversion of 2");
123 : 1 : fail_unless(debug_get_level(3) == SSSDBG_MINOR_FAILURE, "Invalid conversion of 3");
124 : 1 : fail_unless(debug_get_level(4) == SSSDBG_CONF_SETTINGS, "Invalid conversion of 4");
125 : 1 : fail_unless(debug_get_level(5) == SSSDBG_FUNC_DATA, "Invalid conversion of 5");
126 : 1 : fail_unless(debug_get_level(6) == SSSDBG_TRACE_FUNC, "Invalid conversion of 6");
127 : 1 : fail_unless(debug_get_level(7) == SSSDBG_TRACE_LIBS, "Invalid conversion of 7");
128 : 1 : fail_unless(debug_get_level(8) == SSSDBG_TRACE_INTERNAL, "Invalid conversion of 8");
129 : 1 : fail_unless(debug_get_level(9) == SSSDBG_TRACE_ALL, "Invalid conversion of 9");
130 : : }
131 : 1 : END_TEST
132 : :
133 : 1 : START_TEST(test_debug_get_level_new_format)
134 : : {
135 : 1 : fail_unless(
136 : : debug_get_level(SSSDBG_UNRESOLVED) == SSSDBG_FATAL_FAILURE,
137 : : "Invalid conversion of SSSDBG_UNRESOLVED"
138 : : );
139 : 1 : fail_unless(
140 : : debug_get_level(SSSDBG_FATAL_FAILURE) == SSSDBG_FATAL_FAILURE,
141 : : "Invalid conversion of SSSDBG_FATAL_FAILURE"
142 : : );
143 : 1 : fail_unless(
144 : : debug_get_level(SSSDBG_CRIT_FAILURE) == SSSDBG_CRIT_FAILURE,
145 : : "Invalid conversion of SSSDBG_CRIT_FAILURE"
146 : : );
147 : 1 : fail_unless(
148 : : debug_get_level(SSSDBG_OP_FAILURE) == SSSDBG_OP_FAILURE,
149 : : "Invalid conversion of SSSDBG_OP_FAILURE"
150 : : );
151 : 1 : fail_unless(
152 : : debug_get_level(SSSDBG_MINOR_FAILURE) == SSSDBG_MINOR_FAILURE,
153 : : "Invalid conversion of SSSDBG_MINOR_FAILURE"
154 : : );
155 : 1 : fail_unless(
156 : : debug_get_level(SSSDBG_CONF_SETTINGS) == SSSDBG_CONF_SETTINGS,
157 : : "Invalid conversion of SSSDBG_CONF_SETTINGS"
158 : : );
159 : 1 : fail_unless(
160 : : debug_get_level(SSSDBG_FUNC_DATA) == SSSDBG_FUNC_DATA,
161 : : "Invalid conversion of SSSDBG_FUNC_DATA"
162 : : );
163 : 1 : fail_unless(
164 : : debug_get_level(SSSDBG_TRACE_FUNC) == SSSDBG_TRACE_FUNC,
165 : : "Invalid conversion of SSSDBG_TRACE_FUNC"
166 : : );
167 : 1 : fail_unless(
168 : : debug_get_level(SSSDBG_TRACE_LIBS) == SSSDBG_TRACE_LIBS,
169 : : "Invalid conversion of SSSDBG_TRACE_LIBS"
170 : : );
171 : 1 : fail_unless(
172 : : debug_get_level(SSSDBG_TRACE_INTERNAL) == SSSDBG_TRACE_INTERNAL,
173 : : "Invalid conversion of SSSDBG_TRACE_INTERNAL"
174 : : );
175 : 1 : fail_unless(
176 : : debug_get_level(SSSDBG_TRACE_ALL) == SSSDBG_TRACE_ALL,
177 : : "Invalid conversion of SSSDBG_TRACE_ALL"
178 : : );
179 : : }
180 : 1 : END_TEST
181 : :
182 : 60 : int test_helper_debug_check_message(int level, int msgmode)
183 : : {
184 : 60 : TALLOC_CTX *ctx = talloc_new(NULL);
185 : 60 : char filename[24] = {'\0'};
186 : 60 : char *msg = NULL;
187 : 60 : char *compare_to = NULL;
188 : 60 : const char *function = __FUNCTION__;
189 : 60 : const char *body = "some error\n";
190 : : int filesize;
191 : : int fsize;
192 : : int fd;
193 : : int ret;
194 : 60 : int _errno = 0;
195 : : mode_t old_umask;
196 : 60 : FILE *file = NULL;
197 : :
198 : 60 : strncpy(filename, "sssd_debug_tests.XXXXXX", 24);
199 : :
200 : 60 : old_umask = umask(077);
201 : 60 : fd = mkstemp(filename);
202 : 60 : umask(old_umask);
203 [ - + ]: 60 : if (fd == -1) {
204 : 0 : _errno = errno;
205 : 0 : talloc_free(ctx);
206 : 0 : errno = _errno;
207 : : return DEBUG_TEST_ERROR;
208 : : }
209 : :
210 : 60 : file = fdopen(fd, "r");
211 [ - + ]: 60 : if (file == NULL) {
212 : 0 : _errno = errno;
213 : 0 : ret = DEBUG_TEST_ERROR;
214 : 0 : goto done;
215 : : }
216 : :
217 : 60 : ret = set_debug_file_from_fd(fd);
218 [ + - ]: 60 : if (ret != EOK) {
219 : : _errno = ret;
220 : : ret = DEBUG_TEST_ERROR;
221 : : goto done;
222 : : }
223 : :
224 [ + + ]: 60 : if (msgmode == 0) {
225 [ - + ][ # # ]: 30 : DEBUG(level, (body));
[ # # ][ + + ]
[ + + ]
226 : : } else {
227 [ - + ][ # # ]: 30 : DEBUG_MSG(level, __FUNCTION__, "some error");
[ # # ][ + + ]
[ + + ]
228 : : }
229 : :
230 : 60 : ret = fseek(file, 0, SEEK_END);
231 [ - + ]: 60 : if (ret == -1) {
232 : 0 : _errno = errno;
233 : 0 : ret = DEBUG_TEST_ERROR;
234 : 0 : goto done;
235 : : }
236 : :
237 : 60 : filesize = ftell(file);
238 [ - + ]: 60 : if (filesize == -1) {
239 : 0 : _errno = errno;
240 : 0 : ret = DEBUG_TEST_ERROR;
241 : 0 : goto done;
242 : : }
243 : :
244 : 60 : rewind(file);
245 : :
246 : 60 : msg = talloc_array(ctx, char, filesize+1);
247 [ + - ]: 60 : if (msg == NULL) {
248 : : _errno = ENOMEM;
249 : : ret = DEBUG_TEST_ERROR;
250 : : goto done;
251 : : }
252 : 60 : fsize = fread(msg, sizeof(char), filesize, file);
253 [ + - ]: 60 : if (fsize != filesize) {
254 : : _errno = EIO;
255 : : ret = DEBUG_TEST_ERROR;
256 : : goto done;
257 : : }
258 : 60 : msg[fsize] = '\0';
259 : :
260 [ + + ]: 60 : if (debug_timestamps == 1) {
261 : 40 : char time_day[4] = {'\0', '\0', '\0', '\0'};
262 : 40 : char time_month[4] = {'\0', '\0', '\0', '\0'};
263 : 40 : int time_day_num = 0;
264 : 40 : int time_hour = 0;
265 : 40 : int time_min = 0;
266 : 40 : int time_sec = 0;
267 : 40 : int time_usec = 0;
268 : 40 : int time_year = 0;
269 : 40 : int scan_return = 0;
270 : :
271 [ + + ]: 40 : if (debug_microseconds == 0) {
272 : 20 : scan_return = sscanf(msg, "(%s %s %d %d:%d:%d %d)", time_day, time_month,
273 : : &time_day_num, &time_hour, &time_min, &time_sec, &time_year);
274 : :
275 [ + - ]: 20 : if (scan_return != 7) {
276 : : ret = DEBUG_TEST_NOK_TS;
277 : : goto done;
278 : : }
279 : 20 : compare_to = talloc_asprintf(ctx,
280 : : "(%s %s %2d %.2d:%.2d:%.2d %.4d) "
281 : : "[%s] [%s] (%#.4x): %s",
282 : : time_day, time_month, time_day_num,
283 : : time_hour, time_min, time_sec, time_year,
284 : : debug_prg_name, function, level, body);
285 [ + - ]: 20 : if (compare_to == NULL) {
286 : : _errno = ENOMEM;
287 : : ret = DEBUG_TEST_ERROR;
288 : : goto done;
289 : : }
290 : : } else {
291 : 20 : scan_return = sscanf(msg, "(%s %s %d %d:%d:%d:%d %d)", time_day, time_month,
292 : : &time_day_num, &time_hour, &time_min, &time_sec,
293 : : &time_usec, &time_year);
294 : :
295 [ + - ]: 20 : if (scan_return != 8) {
296 : : ret = DEBUG_TEST_NOK_TS;
297 : : goto done;
298 : : }
299 : 20 : compare_to = talloc_asprintf(ctx,
300 : : "(%s %s %2d %.2d:%.2d:%.2d:%.6d %.4d) "
301 : : "[%s] [%s] (%#.4x): %s",
302 : : time_day, time_month, time_day_num,
303 : : time_hour, time_min, time_sec, time_usec,
304 : : time_year, debug_prg_name, function, level, body);
305 [ + - ]: 40 : if (compare_to == NULL) {
306 : : _errno = ENOMEM;
307 : : ret = DEBUG_TEST_ERROR;
308 : : goto done;
309 : : }
310 : : }
311 : : } else {
312 : 20 : compare_to = talloc_asprintf(ctx, "[%s] [%s] (%#.4x): %s",
313 : : debug_prg_name, function, level, body);
314 [ + - ]: 20 : if (compare_to == NULL) {
315 : : _errno = ENOMEM;
316 : : ret = DEBUG_TEST_ERROR;
317 : : goto done;
318 : : }
319 : : }
320 : 60 : ret = strncmp(msg, compare_to, filesize) == 0 ? EOK : DEBUG_TEST_NOK;
321 : :
322 : : done:
323 : 60 : talloc_free(ctx);
324 [ + - ]: 60 : if (file != NULL) {
325 : 60 : fclose(file);
326 : : }
327 : 60 : remove(filename);
328 : 60 : errno = _errno;
329 : : return ret;
330 : : }
331 : :
332 : 60 : int test_helper_debug_is_empty_message(int level, int msgmode)
333 : : {
334 : 60 : char filename[24] = {'\0'};
335 : : int fd;
336 : : int filesize;
337 : : int ret;
338 : 60 : int _errno = 0;
339 : : mode_t old_umask;
340 : : FILE *file;
341 : :
342 : 60 : strncpy(filename, "sssd_debug_tests.XXXXXX", 24);
343 : :
344 : 60 : old_umask = umask(077);
345 : 60 : fd = mkstemp(filename);
346 : 60 : umask(old_umask);
347 [ + - ]: 60 : if (fd == -1) {
348 : : return DEBUG_TEST_ERROR;
349 : : }
350 : :
351 : 60 : file = fdopen(fd, "r");
352 [ - + ]: 60 : if (file == NULL) {
353 : 0 : _errno = errno;
354 : 0 : ret = DEBUG_TEST_ERROR;
355 : 0 : goto done;
356 : : }
357 : :
358 : 60 : ret = set_debug_file_from_fd(fd);
359 [ + - ]: 60 : if (ret != EOK) {
360 : : _errno = ret;
361 : : ret = DEBUG_TEST_ERROR;
362 : : goto done;
363 : : }
364 : :
365 [ + + ]: 60 : if (msgmode == 0) {
366 [ + - ][ - + ]: 30 : DEBUG(level, ("some error\n"));
[ # # ][ # # ]
[ # # ]
367 : : } else {
368 [ + - ][ - + ]: 30 : DEBUG_MSG(level, __FUNCTION__, "some error");
[ # # ][ # # ]
[ # # ]
369 : : }
370 : :
371 : 60 : ret = fseek(file, 0, SEEK_END);
372 [ - + ]: 60 : if (ret == -1) {
373 : 0 : _errno = errno;
374 : 0 : ret = DEBUG_TEST_ERROR;
375 : 0 : goto done;
376 : : }
377 : :
378 : 60 : filesize = ftell(file);
379 [ - + ]: 60 : if (filesize == -1) {
380 : 0 : _errno = errno;
381 : 0 : ret = DEBUG_TEST_ERROR;
382 : 0 : goto done;
383 : : }
384 : :
385 : 60 : ret = filesize == 0 ? EOK : DEBUG_TEST_NOK;
386 : :
387 : : done:
388 [ + - ]: 60 : if (file != NULL) {
389 : 60 : fclose(file);
390 : : }
391 : 60 : remove(filename);
392 : 60 : errno = _errno;
393 : : return ret;
394 : : }
395 : :
396 : 1 : START_TEST(test_debug_is_set_single_no_timestamp)
397 : : {
398 : : int i;
399 : : int result;
400 : 1 : int levels[] = {
401 : : SSSDBG_FATAL_FAILURE,
402 : : SSSDBG_CRIT_FAILURE,
403 : : SSSDBG_OP_FAILURE,
404 : : SSSDBG_MINOR_FAILURE,
405 : : SSSDBG_CONF_SETTINGS,
406 : : SSSDBG_FUNC_DATA,
407 : : SSSDBG_TRACE_FUNC,
408 : : SSSDBG_TRACE_LIBS,
409 : : SSSDBG_TRACE_INTERNAL,
410 : : SSSDBG_TRACE_ALL
411 : : };
412 : : char *error_msg;
413 : :
414 : 1 : debug_timestamps = 0;
415 : 1 : debug_microseconds = 0;
416 : 1 : debug_to_file = 1;
417 : 1 : debug_prg_name = "sssd";
418 : :
419 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
420 : 10 : debug_level = levels[i];
421 : :
422 : 10 : errno = 0;
423 : 10 : result = test_helper_debug_check_message(levels[i], 0);
424 : :
425 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
426 : 0 : error_msg = strerror(errno);
427 : 0 : fail(error_msg);
428 : : }
429 : :
430 : 10 : char *msg = NULL;
431 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message don't match", levels[i]);
432 : 10 : fail_unless(result == EOK, msg);
433 : 10 : talloc_free(msg);
434 : : }
435 : : }
436 : 1 : END_TEST
437 : :
438 : 1 : START_TEST(test_debug_is_set_single_timestamp)
439 : : {
440 : : int i;
441 : : int result;
442 : 1 : int levels[] = {
443 : : SSSDBG_FATAL_FAILURE,
444 : : SSSDBG_CRIT_FAILURE,
445 : : SSSDBG_OP_FAILURE,
446 : : SSSDBG_MINOR_FAILURE,
447 : : SSSDBG_CONF_SETTINGS,
448 : : SSSDBG_FUNC_DATA,
449 : : SSSDBG_TRACE_FUNC,
450 : : SSSDBG_TRACE_LIBS,
451 : : SSSDBG_TRACE_INTERNAL,
452 : : SSSDBG_TRACE_ALL
453 : : };
454 : : char *error_msg;
455 : :
456 : 1 : debug_timestamps = 1;
457 : 1 : debug_microseconds = 0;
458 : 1 : debug_to_file = 1;
459 : 1 : debug_prg_name = "sssd";
460 : :
461 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
462 : 10 : debug_level = levels[i];
463 : :
464 : 10 : errno = 0;
465 : 10 : result = test_helper_debug_check_message(levels[i], 0);
466 : :
467 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
468 : 0 : error_msg = strerror(errno);
469 : 0 : fail(error_msg);
470 : : }
471 : :
472 : 10 : char *msg = NULL;
473 : :
474 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - invalid timestamp", levels[i]);
475 : 10 : fail_if(result == DEBUG_TEST_NOK_TS, msg);
476 : 10 : talloc_free(msg);
477 : :
478 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message don't match", levels[i]);
479 : 10 : fail_unless(result == EOK, msg);
480 : 10 : talloc_free(msg);
481 : : }
482 : : }
483 : 1 : END_TEST
484 : :
485 : 1 : START_TEST(test_debug_is_set_single_timestamp_microseconds)
486 : : {
487 : : int i;
488 : : int result;
489 : 1 : int levels[] = {
490 : : SSSDBG_FATAL_FAILURE,
491 : : SSSDBG_CRIT_FAILURE,
492 : : SSSDBG_OP_FAILURE,
493 : : SSSDBG_MINOR_FAILURE,
494 : : SSSDBG_CONF_SETTINGS,
495 : : SSSDBG_FUNC_DATA,
496 : : SSSDBG_TRACE_FUNC,
497 : : SSSDBG_TRACE_LIBS,
498 : : SSSDBG_TRACE_INTERNAL,
499 : : SSSDBG_TRACE_ALL
500 : : };
501 : : char *error_msg;
502 : :
503 : 1 : debug_timestamps = 1;
504 : 1 : debug_microseconds = 1;
505 : 1 : debug_to_file = 1;
506 : 1 : debug_prg_name = "sssd";
507 : :
508 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
509 : 10 : debug_level = levels[i];
510 : :
511 : 10 : errno = 0;
512 : 10 : result = test_helper_debug_check_message(levels[i], 0);
513 : :
514 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
515 : 0 : error_msg = strerror(errno);
516 : 0 : fail(error_msg);
517 : : }
518 : :
519 : 10 : char *msg = NULL;
520 : :
521 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - invalid timestamp", levels[i]);
522 : 10 : fail_if(result == DEBUG_TEST_NOK_TS, msg);
523 : 10 : talloc_free(msg);
524 : :
525 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message don't match", levels[i]);
526 : 10 : fail_unless(result == EOK, msg);
527 : 10 : talloc_free(msg);
528 : : }
529 : : }
530 : 1 : END_TEST
531 : :
532 : 1 : START_TEST(test_debug_is_notset_no_timestamp)
533 : : {
534 : : int i;
535 : : int result;
536 : 1 : int all_set = SSSDBG_MASK_ALL;
537 : 1 : int levels[] = {
538 : : SSSDBG_FATAL_FAILURE,
539 : : SSSDBG_CRIT_FAILURE,
540 : : SSSDBG_OP_FAILURE,
541 : : SSSDBG_MINOR_FAILURE,
542 : : SSSDBG_CONF_SETTINGS,
543 : : SSSDBG_FUNC_DATA,
544 : : SSSDBG_TRACE_FUNC,
545 : : SSSDBG_TRACE_LIBS,
546 : : SSSDBG_TRACE_INTERNAL,
547 : : SSSDBG_TRACE_ALL
548 : : };
549 : : char *error_msg;
550 : :
551 : 1 : debug_timestamps = 0;
552 : 1 : debug_microseconds = 0;
553 : 1 : debug_to_file = 1;
554 : 1 : debug_prg_name = "sssd";
555 : :
556 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
557 : 10 : debug_level = all_set & ~levels[i];
558 : :
559 : 10 : errno = 0;
560 : 10 : result = test_helper_debug_is_empty_message(levels[i], 0);
561 : :
562 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
563 : 0 : error_msg = strerror(errno);
564 : 0 : fail(error_msg);
565 : : }
566 : :
567 : 10 : char *msg = NULL;
568 : 10 : msg = talloc_asprintf(NULL,
569 : : "Test of level %#.4x failed - message has been written",
570 : : levels[i]);
571 : 10 : fail_unless(result == EOK, msg);
572 : 10 : talloc_free(msg);
573 : : }
574 : : }
575 : 1 : END_TEST
576 : :
577 : 1 : START_TEST(test_debug_is_notset_timestamp)
578 : : {
579 : : int i;
580 : : int result;
581 : 1 : int all_set = SSSDBG_MASK_ALL;
582 : 1 : int levels[] = {
583 : : SSSDBG_FATAL_FAILURE,
584 : : SSSDBG_CRIT_FAILURE,
585 : : SSSDBG_OP_FAILURE,
586 : : SSSDBG_MINOR_FAILURE,
587 : : SSSDBG_CONF_SETTINGS,
588 : : SSSDBG_FUNC_DATA,
589 : : SSSDBG_TRACE_FUNC,
590 : : SSSDBG_TRACE_LIBS,
591 : : SSSDBG_TRACE_INTERNAL,
592 : : SSSDBG_TRACE_ALL
593 : : };
594 : : char *error_msg;
595 : :
596 : 1 : debug_timestamps = 0;
597 : 1 : debug_microseconds = 0;
598 : 1 : debug_to_file = 1;
599 : 1 : debug_prg_name = "sssd";
600 : :
601 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
602 : 10 : debug_level = all_set & ~levels[i];
603 : :
604 : 10 : errno = 0;
605 : 10 : result = test_helper_debug_is_empty_message(levels[i], 0);
606 : :
607 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
608 : 0 : error_msg = strerror(errno);
609 : 0 : fail(error_msg);
610 : : }
611 : :
612 : 10 : char *msg = NULL;
613 : 10 : msg = talloc_asprintf(NULL,
614 : : "Test of level %#.4x failed - message has been written",
615 : : levels[i]);
616 : 10 : fail_unless(result == EOK, msg);
617 : 10 : talloc_free(msg);
618 : : }
619 : : }
620 : 1 : END_TEST
621 : :
622 : 1 : START_TEST(test_debug_is_notset_timestamp_microseconds)
623 : : {
624 : : int i;
625 : : int result;
626 : 1 : int all_set = SSSDBG_MASK_ALL;
627 : 1 : int levels[] = {
628 : : SSSDBG_FATAL_FAILURE,
629 : : SSSDBG_CRIT_FAILURE,
630 : : SSSDBG_OP_FAILURE,
631 : : SSSDBG_MINOR_FAILURE,
632 : : SSSDBG_CONF_SETTINGS,
633 : : SSSDBG_FUNC_DATA,
634 : : SSSDBG_TRACE_FUNC,
635 : : SSSDBG_TRACE_LIBS,
636 : : SSSDBG_TRACE_INTERNAL,
637 : : SSSDBG_TRACE_ALL
638 : : };
639 : : char *error_msg;
640 : :
641 : 1 : debug_timestamps = 0;
642 : 1 : debug_microseconds = 1;
643 : 1 : debug_to_file = 1;
644 : 1 : debug_prg_name = "sssd";
645 : :
646 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
647 : 10 : debug_level = all_set & ~levels[i];
648 : :
649 : 10 : errno = 0;
650 : 10 : result = test_helper_debug_is_empty_message(levels[i], 0);
651 : :
652 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
653 : 0 : error_msg = strerror(errno);
654 : 0 : fail(error_msg);
655 : : }
656 : :
657 : 10 : char *msg = NULL;
658 : 10 : msg = talloc_asprintf(NULL,
659 : : "Test of level %#.4x failed - message has been written",
660 : : levels[i]);
661 : 10 : fail_unless(result == EOK, msg);
662 : 10 : talloc_free(msg);
663 : : }
664 : : }
665 : 1 : END_TEST
666 : :
667 : 1 : START_TEST(test_debug_msg_is_set_single_no_timestamp)
668 : : {
669 : : int i;
670 : : int result;
671 : 1 : int levels[] = {
672 : : SSSDBG_FATAL_FAILURE,
673 : : SSSDBG_CRIT_FAILURE,
674 : : SSSDBG_OP_FAILURE,
675 : : SSSDBG_MINOR_FAILURE,
676 : : SSSDBG_CONF_SETTINGS,
677 : : SSSDBG_FUNC_DATA,
678 : : SSSDBG_TRACE_FUNC,
679 : : SSSDBG_TRACE_LIBS,
680 : : SSSDBG_TRACE_INTERNAL,
681 : : SSSDBG_TRACE_ALL
682 : : };
683 : : char *error_msg;
684 : :
685 : 1 : debug_timestamps = 0;
686 : 1 : debug_microseconds = 0;
687 : 1 : debug_to_file = 1;
688 : 1 : debug_prg_name = "sssd";
689 : :
690 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
691 : 10 : debug_level = levels[i];
692 : :
693 : 10 : errno = 0;
694 : 10 : result = test_helper_debug_check_message(levels[i], 1);
695 : :
696 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
697 : 0 : error_msg = strerror(errno);
698 : 0 : fail(error_msg);
699 : : }
700 : :
701 : 10 : char *msg = NULL;
702 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message don't match", levels[i]);
703 : 10 : fail_unless(result == EOK, msg);
704 : 10 : talloc_free(msg);
705 : : }
706 : : }
707 : 1 : END_TEST
708 : :
709 : 1 : START_TEST(test_debug_msg_is_set_single_timestamp)
710 : : {
711 : : int i;
712 : : int result;
713 : 1 : int levels[] = {
714 : : SSSDBG_FATAL_FAILURE,
715 : : SSSDBG_CRIT_FAILURE,
716 : : SSSDBG_OP_FAILURE,
717 : : SSSDBG_MINOR_FAILURE,
718 : : SSSDBG_CONF_SETTINGS,
719 : : SSSDBG_FUNC_DATA,
720 : : SSSDBG_TRACE_FUNC,
721 : : SSSDBG_TRACE_LIBS,
722 : : SSSDBG_TRACE_INTERNAL,
723 : : SSSDBG_TRACE_ALL
724 : : };
725 : : char *error_msg;
726 : :
727 : 1 : debug_timestamps = 1;
728 : 1 : debug_microseconds = 0;
729 : 1 : debug_to_file = 1;
730 : 1 : debug_prg_name = "sssd";
731 : :
732 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
733 : 10 : debug_level = levels[i];
734 : :
735 : 10 : errno = 0;
736 : 10 : result = test_helper_debug_check_message(levels[i], 1);
737 : :
738 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
739 : 0 : error_msg = strerror(errno);
740 : 0 : fail(error_msg);
741 : : }
742 : :
743 : 10 : char *msg = NULL;
744 : :
745 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - invalid timestamp", levels[i]);
746 : 10 : fail_if(result == DEBUG_TEST_NOK_TS, msg);
747 : 10 : talloc_free(msg);
748 : :
749 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message don't match", levels[i]);
750 : 10 : fail_unless(result == EOK, msg);
751 : 10 : talloc_free(msg);
752 : : }
753 : : }
754 : 1 : END_TEST
755 : :
756 : 1 : START_TEST(test_debug_msg_is_set_single_timestamp_microseconds)
757 : : {
758 : : int i;
759 : : int result;
760 : 1 : int levels[] = {
761 : : SSSDBG_FATAL_FAILURE,
762 : : SSSDBG_CRIT_FAILURE,
763 : : SSSDBG_OP_FAILURE,
764 : : SSSDBG_MINOR_FAILURE,
765 : : SSSDBG_CONF_SETTINGS,
766 : : SSSDBG_FUNC_DATA,
767 : : SSSDBG_TRACE_FUNC,
768 : : SSSDBG_TRACE_LIBS,
769 : : SSSDBG_TRACE_INTERNAL,
770 : : SSSDBG_TRACE_ALL
771 : : };
772 : : char *error_msg;
773 : :
774 : 1 : debug_timestamps = 1;
775 : 1 : debug_microseconds = 1;
776 : 1 : debug_to_file = 1;
777 : 1 : debug_prg_name = "sssd";
778 : :
779 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
780 : 10 : debug_level = levels[i];
781 : :
782 : 10 : errno = 0;
783 : 10 : result = test_helper_debug_check_message(levels[i], 1);
784 : :
785 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
786 : 0 : error_msg = strerror(errno);
787 : 0 : fail(error_msg);
788 : : }
789 : :
790 : 10 : char *msg = NULL;
791 : :
792 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - invalid timestamp", levels[i]);
793 : 10 : fail_if(result == DEBUG_TEST_NOK_TS, msg);
794 : 10 : talloc_free(msg);
795 : :
796 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message don't match", levels[i]);
797 : 10 : fail_unless(result == EOK, msg);
798 : 10 : talloc_free(msg);
799 : : }
800 : : }
801 : 1 : END_TEST
802 : :
803 : 1 : START_TEST(test_debug_msg_is_notset_no_timestamp)
804 : : {
805 : : int i;
806 : : int result;
807 : 1 : int all_set = SSSDBG_MASK_ALL;
808 : 1 : int levels[] = {
809 : : SSSDBG_FATAL_FAILURE,
810 : : SSSDBG_CRIT_FAILURE,
811 : : SSSDBG_OP_FAILURE,
812 : : SSSDBG_MINOR_FAILURE,
813 : : SSSDBG_CONF_SETTINGS,
814 : : SSSDBG_FUNC_DATA,
815 : : SSSDBG_TRACE_FUNC,
816 : : SSSDBG_TRACE_LIBS,
817 : : SSSDBG_TRACE_INTERNAL,
818 : : SSSDBG_TRACE_ALL
819 : : };
820 : : char *error_msg;
821 : :
822 : 1 : debug_timestamps = 0;
823 : 1 : debug_microseconds = 0;
824 : 1 : debug_to_file = 1;
825 : 1 : debug_prg_name = "sssd";
826 : :
827 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
828 : 10 : debug_level = all_set & ~levels[i];
829 : :
830 : 10 : errno = 0;
831 : 10 : result = test_helper_debug_is_empty_message(levels[i], 1);
832 : :
833 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
834 : 0 : error_msg = strerror(errno);
835 : 0 : fail(error_msg);
836 : : }
837 : :
838 : 10 : char *msg = NULL;
839 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message has been written", levels[i]);
840 : 10 : fail_unless(result == EOK, msg);
841 : 10 : talloc_free(msg);
842 : : }
843 : : }
844 : 1 : END_TEST
845 : :
846 : 1 : START_TEST(test_debug_msg_is_notset_timestamp)
847 : : {
848 : : int i;
849 : : int result;
850 : 1 : int all_set = SSSDBG_MASK_ALL;
851 : 1 : int levels[] = {
852 : : SSSDBG_FATAL_FAILURE,
853 : : SSSDBG_CRIT_FAILURE,
854 : : SSSDBG_OP_FAILURE,
855 : : SSSDBG_MINOR_FAILURE,
856 : : SSSDBG_CONF_SETTINGS,
857 : : SSSDBG_FUNC_DATA,
858 : : SSSDBG_TRACE_FUNC,
859 : : SSSDBG_TRACE_LIBS,
860 : : SSSDBG_TRACE_INTERNAL,
861 : : SSSDBG_TRACE_ALL
862 : : };
863 : : char *error_msg;
864 : :
865 : 1 : debug_timestamps = 0;
866 : 1 : debug_microseconds = 0;
867 : 1 : debug_to_file = 1;
868 : 1 : debug_prg_name = "sssd";
869 : :
870 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
871 : 10 : debug_level = all_set & ~levels[i];
872 : :
873 : 10 : errno = 0;
874 : 10 : result = test_helper_debug_is_empty_message(levels[i], 1);
875 : :
876 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
877 : 0 : error_msg = strerror(errno);
878 : 0 : fail(error_msg);
879 : : }
880 : :
881 : 10 : char *msg = NULL;
882 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message has been written", levels[i]);
883 : 10 : fail_unless(result == EOK, msg);
884 : 10 : talloc_free(msg);
885 : : }
886 : : }
887 : 1 : END_TEST
888 : :
889 : 1 : START_TEST(test_debug_msg_is_notset_timestamp_microseconds)
890 : : {
891 : : int i;
892 : : int result;
893 : 1 : int all_set = SSSDBG_MASK_ALL;
894 : 1 : int levels[] = {
895 : : SSSDBG_FATAL_FAILURE,
896 : : SSSDBG_CRIT_FAILURE,
897 : : SSSDBG_OP_FAILURE,
898 : : SSSDBG_MINOR_FAILURE,
899 : : SSSDBG_CONF_SETTINGS,
900 : : SSSDBG_FUNC_DATA,
901 : : SSSDBG_TRACE_FUNC,
902 : : SSSDBG_TRACE_LIBS,
903 : : SSSDBG_TRACE_INTERNAL,
904 : : SSSDBG_TRACE_ALL
905 : : };
906 : : char *error_msg;
907 : :
908 : 1 : debug_timestamps = 0;
909 : 1 : debug_microseconds = 1;
910 : 1 : debug_to_file = 1;
911 : 1 : debug_prg_name = "sssd";
912 : :
913 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
914 : 10 : debug_level = all_set & ~levels[i];
915 : :
916 : 10 : errno = 0;
917 : 10 : result = test_helper_debug_is_empty_message(levels[i], 1);
918 : :
919 [ - + ]: 10 : if (result == DEBUG_TEST_ERROR) {
920 : 0 : error_msg = strerror(errno);
921 : 0 : fail(error_msg);
922 : : }
923 : :
924 : 10 : char *msg = NULL;
925 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - message has been written", levels[i]);
926 : 10 : fail_unless(result == EOK, msg);
927 : 10 : talloc_free(msg);
928 : : }
929 : : }
930 : 1 : END_TEST
931 : :
932 : 1 : START_TEST(test_debug_is_set_true)
933 : : {
934 : : int i;
935 : : int result;
936 : 1 : int levels[] = {
937 : : SSSDBG_FATAL_FAILURE,
938 : : SSSDBG_CRIT_FAILURE,
939 : : SSSDBG_OP_FAILURE,
940 : : SSSDBG_MINOR_FAILURE,
941 : : SSSDBG_CONF_SETTINGS,
942 : : SSSDBG_FUNC_DATA,
943 : : SSSDBG_TRACE_FUNC,
944 : : SSSDBG_TRACE_LIBS,
945 : : SSSDBG_TRACE_INTERNAL,
946 : : SSSDBG_TRACE_ALL
947 : : };
948 : :
949 : 1 : debug_level = SSSDBG_MASK_ALL;
950 : :
951 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
952 [ - + ][ # # ]: 10 : result = DEBUG_IS_SET(levels[i]);
[ # # ]
953 : 10 : char *msg = NULL;
954 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - result is 0x%.4x", levels[i], result);
955 : 10 : fail_unless(result > 0, msg);
956 : 10 : talloc_free(msg);
957 : : }
958 : : }
959 : 1 : END_TEST
960 : :
961 : 1 : START_TEST(test_debug_is_set_false)
962 : : {
963 : : int i;
964 : : int result;
965 : 1 : int all_set = SSSDBG_MASK_ALL;
966 : 1 : int levels[] = {
967 : : SSSDBG_FATAL_FAILURE,
968 : : SSSDBG_CRIT_FAILURE,
969 : : SSSDBG_OP_FAILURE,
970 : : SSSDBG_MINOR_FAILURE,
971 : : SSSDBG_CONF_SETTINGS,
972 : : SSSDBG_FUNC_DATA,
973 : : SSSDBG_TRACE_FUNC,
974 : : SSSDBG_TRACE_LIBS,
975 : : SSSDBG_TRACE_INTERNAL,
976 : : SSSDBG_TRACE_ALL
977 : : };
978 : :
979 [ + + ]: 11 : for (i = 0; i <= 9; i++) {
980 : 10 : debug_level = all_set & ~levels[i];
981 : :
982 [ + - ][ - + ]: 10 : result = DEBUG_IS_SET(levels[i]);
[ # # ]
983 : 10 : char *msg = NULL;
984 : 10 : msg = talloc_asprintf(NULL, "Test of level %#.4x failed - result is 0x%.4x", levels[i], result);
985 : 10 : fail_unless(result == 0, msg);
986 : 10 : talloc_free(msg);
987 : : }
988 : : }
989 : 1 : END_TEST
990 : :
991 : 19 : Suite *debug_suite(void)
992 : : {
993 : 19 : Suite *s = suite_create("debug");
994 : :
995 : 19 : TCase *tc_debug = tcase_create("debug");
996 : :
997 : 19 : tcase_add_test(tc_debug, test_debug_convert_old_level_old_format);
998 : 19 : tcase_add_test(tc_debug, test_debug_convert_old_level_new_format);
999 : 19 : tcase_add_test(tc_debug, test_debug_get_level_old_format);
1000 : 19 : tcase_add_test(tc_debug, test_debug_get_level_new_format);
1001 : 19 : tcase_add_test(tc_debug, test_debug_is_set_single_no_timestamp);
1002 : 19 : tcase_add_test(tc_debug, test_debug_is_set_single_timestamp);
1003 : 19 : tcase_add_test(tc_debug, test_debug_is_set_single_timestamp_microseconds);
1004 : 19 : tcase_add_test(tc_debug, test_debug_is_notset_no_timestamp);
1005 : 19 : tcase_add_test(tc_debug, test_debug_is_notset_timestamp);
1006 : 19 : tcase_add_test(tc_debug, test_debug_is_notset_timestamp_microseconds);
1007 : 19 : tcase_add_test(tc_debug, test_debug_msg_is_set_single_no_timestamp);
1008 : 19 : tcase_add_test(tc_debug, test_debug_msg_is_set_single_timestamp);
1009 : 19 : tcase_add_test(tc_debug, test_debug_msg_is_set_single_timestamp_microseconds);
1010 : 19 : tcase_add_test(tc_debug, test_debug_msg_is_notset_no_timestamp);
1011 : 19 : tcase_add_test(tc_debug, test_debug_msg_is_notset_timestamp);
1012 : 19 : tcase_add_test(tc_debug, test_debug_msg_is_notset_timestamp_microseconds);
1013 : 19 : tcase_add_test(tc_debug, test_debug_is_set_true);
1014 : 19 : tcase_add_test(tc_debug, test_debug_is_set_false);
1015 : 19 : tcase_set_timeout(tc_debug, 60);
1016 : :
1017 : 19 : suite_add_tcase(s, tc_debug);
1018 : :
1019 : 19 : return s;
1020 : : }
1021 : :
1022 : 19 : int main(int argc, const char *argv[])
1023 : : {
1024 : : int number_failed;
1025 : :
1026 : 19 : tests_set_cwd();
1027 : :
1028 : 19 : Suite *s = debug_suite();
1029 : 19 : SRunner *sr = srunner_create(s);
1030 : :
1031 : 19 : srunner_run_all(sr, CK_NORMAL);
1032 : 1 : number_failed = srunner_ntests_failed(sr);
1033 : 1 : srunner_free(sr);
1034 : :
1035 [ - + ]: 1 : if (number_failed == 0)
1036 : : return EXIT_SUCCESS;
1037 : :
1038 : 1 : return EXIT_FAILURE;
1039 : : }
|
