diff options
Diffstat (limited to 'libmailutils/tests/logstr.c')
-rw-r--r-- | libmailutils/tests/logstr.c | 729 |
1 files changed, 729 insertions, 0 deletions
diff --git a/libmailutils/tests/logstr.c b/libmailutils/tests/logstr.c new file mode 100644 index 000000000..bf65e21b3 --- /dev/null +++ b/libmailutils/tests/logstr.c @@ -0,0 +1,729 @@ +/* This file is part of GNU Mailutils test suite + Copyright (C) 2017 Free Software Foundation, Inc. + + GNU Mailutils is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + GNU Mailutils is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNU Mailutils. If not, see <http://www.gnu.org/licenses/>. */ + +#include <mailutils/mailutils.h> +#include <mailutils/locus.h> + +/* Check normal operation. + Expected output: hello world +*/ +static void +simple_print (mu_stream_t str) +{ + mu_stream_printf (str, "hello world\n"); +} + +/* Check severity control. + Expected output: + info: one + emerg: two + mode was: 0x0001 +*/ +static void +check_severity (mu_stream_t str) +{ + unsigned severity = MU_DIAG_INFO; + int mode = MU_LOGMODE_SEVERITY, old_mode; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + mu_stream_printf (str, "one\n"); + + severity = MU_DIAG_EMERG; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + mu_stream_printf (str, "two\n"); + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_GET_MODE, &old_mode); + + mode = 0; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + mu_stream_printf (str, "mode was: 0x%04X\n", old_mode); +} + +/* Check severity suppression mechanism. + Expected output: + info: this message is seen + emerg: and this one as well +*/ +static void +check_suppress (mu_stream_t str) +{ + unsigned severity; + int mode = MU_LOGMODE_SEVERITY; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + severity = MU_DIAG_INFO; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SUPPRESS_SEVERITY, + &severity); + + severity = MU_DIAG_DEBUG; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + + mu_stream_printf (str, "this message is not seen\n"); + + severity = MU_DIAG_INFO; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + mu_stream_printf (str, "this message is seen\n"); + + severity = MU_DIAG_EMERG; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + mu_stream_printf (str, "and this one as well\n"); +} + +/* Check suppression by severity name. + Expected output: + info: this message is seen + emerg: and this one as well +*/ +static void +check_suppress_name (mu_stream_t str) +{ + int mode = MU_LOGMODE_SEVERITY, severity; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SUPPRESS_SEVERITY_NAME, + "info"); + + severity = MU_DIAG_DEBUG; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + + mu_stream_printf (str, "this message is not seen\n"); + + severity = MU_DIAG_INFO; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + mu_stream_printf (str, "this message is seen\n"); + + severity = MU_DIAG_EMERG; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + mu_stream_printf (str, "and this one as well\n"); +} + +static void +comp_range (mu_stream_t str, struct mu_locus_range *lr1, + char const *file, int line) +{ + struct mu_locus_range lr2; + + MU_ASSERT (mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_GET_LOCUS_RANGE, &lr2)); + if (strcmp (lr1->beg.mu_file, lr2.beg.mu_file)) + mu_error ("%s:%d: beg.mu_file differs", file, line); + if (lr1->beg.mu_line != lr2.beg.mu_line) + mu_error ("%s:%d: beg.mu_line differs", file, line); + if (lr1->beg.mu_col != lr2.beg.mu_col) + mu_error ("%s:%d: beg.mu_col differs", file, line); + mu_ident_deref (lr2.beg.mu_file); + + if (strcmp (lr1->end.mu_file, lr2.end.mu_file)) + mu_error ("%s:%d: end.mu_file differs", __FILE__, __LINE__); + if (lr1->end.mu_line != lr2.end.mu_line) + mu_error ("%s:%d: end.mu_line differs", __FILE__, __LINE__); + if (lr1->end.mu_col != lr2.end.mu_col) + mu_error ("%s:%d: end.mu_col differs", __FILE__, __LINE__); + + mu_ident_deref (lr2.end.mu_file); +} + +/* Check MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE. + Passed: file, line. + Expected output: + input:1: file, line +*/ +static void +lr_file_line (mu_stream_t str) +{ + int mode = MU_LOGMODE_LOCUS; + struct mu_locus_range lr; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 0; + + lr.end.mu_file = "input"; + lr.end.mu_line = 1; + lr.end.mu_col = 0; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + + mu_stream_printf (str, "file, line\n"); + + comp_range (str, &lr, __FILE__, __LINE__); +} + +/* Check MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE. + Passed: file, line, col. + Expected output: + input:1.1-10: file, line, col +*/ +static void +lr_file_line_col (mu_stream_t str) +{ + int mode = MU_LOGMODE_LOCUS; + struct mu_locus_range lr; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "input"; + lr.end.mu_line = 1; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + + mu_stream_printf (str, "file, line, col\n"); + + comp_range (str, &lr, __FILE__, __LINE__); +} + +/* Check MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE. + Passed: file, line-range + Expected output: + input:1-2: file, line-range +*/ +static void +lr_file_line2 (mu_stream_t str) +{ + int mode = MU_LOGMODE_LOCUS; + struct mu_locus_range lr; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 0; + + lr.end.mu_file = "input"; + lr.end.mu_line = 2; + lr.end.mu_col = 0; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + + mu_stream_printf (str, "file, line-range\n"); + + comp_range (str, &lr, __FILE__, __LINE__); +} + +/* Check MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE. + Passed: file, line-range, column + Expected output: + input:1.1-2.10: file, line-range, col +*/ +static void +lr_file_line2_col (mu_stream_t str) +{ + int mode = MU_LOGMODE_LOCUS; + struct mu_locus_range lr; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "input"; + lr.end.mu_line = 2; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + + mu_stream_printf (str, "file, line-range, col\n"); + + comp_range (str, &lr, __FILE__, __LINE__); +} + +/* Check MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE. + Passed: file-range, line-range, column-range + Expected output: + input:1.1-next:2.10: file-range, line-range, col-range +*/ +static void +lr_file2_line_col (mu_stream_t str) +{ + int mode = MU_LOGMODE_LOCUS; + struct mu_locus_range lr; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "next"; + lr.end.mu_line = 2; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + + mu_stream_printf (str, "file-range, line-range, col-range\n"); + + comp_range (str, &lr, __FILE__, __LINE__); +} + +/* Check MU_IOCTL_LOGSTREAM_SET_LOCUS_LINE. + Expected output: + input:1.1-next:2.10: initial + input:8.1-next:2.10: locus line changed +*/ +static void +set_locus_line (mu_stream_t str) +{ + int mode = MU_LOGMODE_LOCUS; + struct mu_locus_range lr; + unsigned line; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "next"; + lr.end.mu_line = 2; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + mu_stream_printf (str, "initial\n"); + line = 8; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_LINE, &line); + mu_stream_printf (str, "locus line changed\n"); + lr.beg.mu_line = line; + comp_range (str, &lr, __FILE__, __LINE__); +} + +/* Check MU_IOCTL_LOGSTREAM_ADVANCE_LOCUS_LINE. + Expected output: + input:1.1-next:5.10: initial + input:3.1-next:5.10: locus line advanced +*/ +static void +advance_locus_line (mu_stream_t str) +{ + int mode = MU_LOGMODE_LOCUS; + struct mu_locus_range lr; + unsigned line; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "next"; + lr.end.mu_line = 5; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + mu_stream_printf (str, "initial\n"); + line = 2; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_ADVANCE_LOCUS_LINE, &line); + mu_stream_printf (str, "locus line advanced\n"); + + lr.beg.mu_line += line; + comp_range (str, &lr, __FILE__, __LINE__); +} + +/* Check MU_IOCTL_LOGSTREAM_SET_LOCUS_COL. + Expected output: + input:1.1-next:2.10: initial + input:1.8-next:2.10: locus column changed +*/ +static void +set_locus_col (mu_stream_t str) +{ + int mode = MU_LOGMODE_LOCUS; + struct mu_locus_range lr; + unsigned col; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "next"; + lr.end.mu_line = 2; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + mu_stream_printf (str, "initial\n"); + col = 8; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_COL, &col); + mu_stream_printf (str, "locus column changed\n"); + lr.beg.mu_col = col; + comp_range (str, &lr, __FILE__, __LINE__); +} + +/* Check MU_IOCTL_LOGSTREAM_ADVANCE_LOCUS_COL. + Expected output: + input:1.1-next:5.10: initial + input:1.5-next:5.10: locus line advanced +*/ +static void +advance_locus_col (mu_stream_t str) +{ + int mode = MU_LOGMODE_LOCUS; + struct mu_locus_range lr; + unsigned col; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "next"; + lr.end.mu_line = 5; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + mu_stream_printf (str, "initial\n"); + col = 4; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_ADVANCE_LOCUS_COL, &col); + mu_stream_printf (str, "locus line advanced\n"); + + lr.beg.mu_col += col; + comp_range (str, &lr, __FILE__, __LINE__); +} + +/* Check severity mask. + Expected output: + one + two + emerg: two + */ +static void +check_severity_mask (mu_stream_t str) +{ + unsigned severity; + int mode = MU_LOGMODE_SEVERITY, mask; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + + mask = MU_DEBUG_LEVEL_UPTO (MU_DIAG_NOTICE); + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY_MASK, &mask); + + severity = MU_DIAG_INFO; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + mu_stream_printf (str, "one\n"); + + severity = MU_DIAG_NOTICE; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + mu_stream_printf (str, "two\n"); + + severity = MU_DIAG_EMERG; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity); + mu_stream_printf (str, "three\n"); +} + +/* Check ESC-s & ESC-O format specifiers. + Expected output: + info: severity +*/ +static void +fmt_severity (mu_stream_t str) +{ + mu_stream_printf (str, "\033s<%d>\033O<%d>severity\n", + MU_DIAG_INFO, MU_LOGMODE_SEVERITY); +} + +/* Check ESC-f and ESC-l format specifiers. + Expected output: + a:10: one +*/ +static void +fmt_locus1 (mu_stream_t str) +{ + char *file = "a"; + mu_stream_printf (str, "\033f<%d>%s\033l<%d>one\n", + (int) strlen (file), file, 10); +} + +/* Check ESC-f, ESC-l, and ESC-c format specifiers. + Expected output: + a:10.5: one +*/ +static void +fmt_locus2 (mu_stream_t str) +{ + char *file = "a"; + mu_stream_printf (str, "\033f<%d>%s\033l<%d>\033c<%d>one\n", + (int) strlen (file), file, 10, 5); +} + +/* Check setting range with ESC-f, ESC-l, and ESC-c format specifiers. + Expected output: + a:10.5-b:14.8: one +*/ +static void +fmt_locus3 (mu_stream_t str) +{ + char *file[] = { "a", "b" }; + mu_stream_printf (str, "\033f<%d>%s\033l<%d>\033c<%d>" + "\033f<%d>%s\033l<%d>\033c<%d>one\n", + (int) strlen (file[0]), file[0], 10, 5, + (int) strlen (file[1]), file[1], 14, 8); +} + +/* Check that ESC-f, ESC-l, and ESC-c format specifiers don't clobber + default stream settings. + Expected output: + a:10.5-b:14.8: one + default +*/ +static void +fmt_locus4 (mu_stream_t str) +{ + char *file[] = { "a", "b" }; + struct mu_locus_range lr; + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "next"; + lr.end.mu_line = 5; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + + mu_stream_printf (str, "\033f<%d>%s\033l<%d>\033c<%d>" + "\033f<%d>%s\033l<%d>\033c<%d>one\n", + (int) strlen (file[0]), file[0], 10, 5, + (int) strlen (file[1]), file[1], 14, 8); + mu_stream_printf (str, "default\n"); +} + +/* Check that ESC-f, ESC-l, and ESC-c format specifiers don't clobber + default stream settings and locus. + Expected output: + a:10.5-b:14.8: one + input:1.1-next:5.10: default +*/ +static void +fmt_locus5 (mu_stream_t str) +{ + char *file[] = { "a", "b" }; + struct mu_locus_range lr; + int mode; + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "next"; + lr.end.mu_line = 5; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + + mode = MU_LOGMODE_LOCUS; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + mu_stream_printf (str, "\033f<%d>%s\033l<%d>\033c<%d>" + "\033f<%d>%s\033l<%d>\033c<%d>one\n", + (int) strlen (file[0]), file[0], 10, 5, + (int) strlen (file[1]), file[1], 14, 8); + mu_stream_printf (str, "default\n"); +} + +/* Check the ESC-S specifier (store locus). + Expected output: + a:10.5-b:14.8: one + a:10.5-b:14.8: default +*/ +static void +fmt_locus6 (mu_stream_t str) +{ + char *file[] = { "a", "b" }; + struct mu_locus_range lr; + int mode; + + lr.beg.mu_file = "input"; + lr.beg.mu_line = 1; + lr.beg.mu_col = 1; + + lr.end.mu_file = "next"; + lr.end.mu_line = 5; + lr.end.mu_col = 10; + + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, &lr); + + mode = MU_LOGMODE_LOCUS; + mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode); + mu_stream_printf (str, "\033S\033f<%d>%s\033l<%d>\033c<%d>" + "\033f<%d>%s\033l<%d>\033c<%d>one\n", + (int) strlen (file[0]), file[0], 10, 5, + (int) strlen (file[1]), file[1], 14, 8); + mu_stream_printf (str, "default\n"); +} + + +struct testcase +{ + char const *id; + void (*handler) (mu_stream_t); + int enabled; +}; + +struct testcase testcases[] = { + { "simple print", simple_print }, + { "severity", check_severity }, + { "suppress severity", check_suppress }, + { "suppress severity name", check_suppress_name }, + { "severity mask", check_severity_mask }, + { "locus: file, line", lr_file_line }, + { "locus: file, line, col", lr_file_line_col }, + { "locus: file, line-range", lr_file_line2 }, + { "locus: file, line-range, col", lr_file_line2_col }, + { "locus: file-range, line-range, col-range", lr_file2_line_col }, + { "set locus line", set_locus_line }, + { "advance locus line", advance_locus_line }, + { "set locus column", set_locus_col }, + { "advance locus column", advance_locus_col }, + { "fmt: severity", fmt_severity }, + { "fmt: locus (file, line)", fmt_locus1 }, + { "fmt: locus (file, line, column)", fmt_locus2 }, + { "fmt: locus (range)", fmt_locus3 }, + { "fmt: locus; restore defaults", fmt_locus4 }, + { "fmt: locus; restore defaults, display locus", fmt_locus5 }, + { "fmt: set locus", fmt_locus6 }, + { NULL } +}; + +static mu_stream_t +create_log (void) +{ + mu_stream_t str, transport; + int yes = 1; + + MU_ASSERT (mu_stdio_stream_create (&transport, MU_STDOUT_FD, 0)); + mu_stream_ioctl (transport, MU_IOCTL_FD, MU_IOCTL_FD_SET_BORROW, &yes); + MU_ASSERT (mu_log_stream_create (&str, transport)); + mu_stream_unref (transport); + return str; +} + +static void +log_reset (mu_stream_t str) +{ + int mode = 0; + MU_ASSERT (mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_MODE, &mode)); + MU_ASSERT (mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_LOCUS_RANGE, NULL)); + mode = 0; + MU_ASSERT (mu_stream_ioctl (str, MU_IOCTL_LOGSTREAM, + MU_IOCTL_LOGSTREAM_SET_SEVERITY_MASK, + &mode)); +} + +int +main (int argc, char **argv) +{ + mu_stream_t log; + struct testcase *tp; + int i; + int ena = 0; + + mu_set_program_name (argv[0]); + mu_stdstream_setup (MU_STDSTREAM_RESET_NONE); + + if (argc > 1) + { + ena = 1; + for (i = 1; i < argc; i++) + { + char *p; + int n = strtol (argv[i], &p, 10); + if (! (*p == 0 && n >= 0) ) + { + mu_error ("erroneous argument %s\n", argv[i]); + return 1; + } + testcases[n].enabled = ena; + } + } + + log = create_log (); + + for (i = 0, tp = testcases; tp->id; tp++, i++) + { + if (tp->enabled == ena) + { + mu_stream_printf (log, "%02d. %s\n", i, tp->id); + tp->handler (log); + log_reset (log); + } + } + + return 0; +} + + |