X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=tools%2Fccanlint%2Fccanlint.c;h=51962de8582f9a290b272e95b75cc19347065c51;hp=064e40d869d6703da46270ce16e67a95488d3895;hb=8d70667887ba081d76075e8959adafb22983b03a;hpb=747a69435d9f83c0968d9689c4951bc0233ffc5e diff --git a/tools/ccanlint/ccanlint.c b/tools/ccanlint/ccanlint.c index 064e40d8..51962de8 100644 --- a/tools/ccanlint/ccanlint.c +++ b/tools/ccanlint/ccanlint.c @@ -19,31 +19,26 @@ #include "ccanlint.h" #include "../tools.h" #include -#include #include #include #include #include #include #include +#include +#include +#include #include +#include -static unsigned int verbose = 0; +int verbose = 0; static LIST_HEAD(compulsory_tests); static LIST_HEAD(normal_tests); static LIST_HEAD(finished_tests); bool safe_mode = false; - -static void usage(const char *name) -{ - fprintf(stderr, "Usage: %s [-s] [-n] [-v] [-d ]\n" - " -v: verbose mode\n" - " -s: simply give one line summary\n" - " -d: use this directory instead of the current one\n" - " -n: do not compile anything\n", - name); - exit(1); -} +static struct btree *cmdline_exclude; +static struct btree *info_exclude; +static unsigned int timeout; #if 0 static void indent_print(const char *string) @@ -73,6 +68,12 @@ bool ask(const char *question) static const char *should_skip(struct manifest *m, struct ccanlint *i) { + if (btree_lookup(cmdline_exclude, i->key)) + return "excluded on command line"; + + if (btree_lookup(info_exclude, i->key)) + return "excluded in _info file"; + if (i->skip_fail) return "dependency failed"; @@ -91,16 +92,19 @@ static bool run_test(struct ccanlint *i, struct manifest *m) { void *result; - unsigned int this_score; + unsigned int this_score, max_score, timeleft; const struct dependent *d; const char *skip; + bool bad, good; //one less test to run through list_for_each(&i->dependencies, d, node) d->dependent->num_depends--; skip = should_skip(m, i); + if (skip) { + skip: if (verbose) printf(" %s: skipped (%s)\n", i->name, skip); @@ -117,44 +121,59 @@ static bool run_test(struct ccanlint *i, return true; } - result = i->check(m); - if (!result) { - if (verbose) - printf(" %s: OK\n", i->name); - if (i->total_score) { - *score += i->total_score; - *total_score += i->total_score; - } - - list_del(&i->list); - list_add_tail(&finished_tests, &i->list); - return true; + timeleft = timeout ? timeout : default_timeout_ms; + result = i->check(m, i->keep_results, &timeleft); + if (timeout && timeleft == 0) { + skip = "timeout"; + goto skip; } - if (i->score) + max_score = i->total_score; + if (!max_score) + max_score = 1; + + if (!result) + this_score = max_score; + else if (i->score) this_score = i->score(m, result); else this_score = 0; - list_del(&i->list); - list_add_tail(&finished_tests, &i->list); + bad = (this_score == 0); + good = (this_score >= max_score); - *total_score += i->total_score; - *score += this_score; - if (!quiet) { - printf("%s\n", i->describe(m, result)); + if (verbose || (!good && !quiet)) { + printf(" %s: %s", i->name, + bad ? "FAIL" : good ? "PASS" : "PARTIAL"); + if (max_score > 1) + printf(" (+%u/%u)", this_score, max_score); + printf("\n"); + } + if (!quiet && result) { + const char *desc; + if (i->describe && (desc = i->describe(m, result)) != NULL) + printf(" %s\n", desc); if (i->handle) i->handle(m, result); } - /* Skip any tests which depend on this one. */ - list_for_each(&i->dependencies, d, node) { - d->dependent->skip = true; - d->dependent->skip_fail = true; + if (i->total_score) { + *score += this_score; + *total_score += i->total_score; } - return false; + list_del(&i->list); + list_add_tail(&finished_tests, &i->list); + + if (bad) { + /* Skip any tests which depend on this one. */ + list_for_each(&i->dependencies, d, node) { + d->dependent->skip = true; + d->dependent->skip_fail = true; + } + } + return good; } static void register_test(struct list_head *h, struct ccanlint *test, ...) @@ -203,14 +222,34 @@ static inline struct ccanlint *get_next_test(struct list_head *test) static void init_tests(void) { const struct ccanlint *i; + struct btree *keys, *names; #undef REGISTER_TEST -#define REGISTER_TEST(name, ...) register_test(&normal_tests, &name, __VA_ARGS__) +#define REGISTER_TEST(name, ...) register_test(&normal_tests, &name, __VA_ARGS__, NULL) #include "generated-normal-tests" #undef REGISTER_TEST -#define REGISTER_TEST(name, ...) register_test(&compulsory_tests, &name, __VA_ARGS__) +#define REGISTER_TEST(name, ...) register_test(&compulsory_tests, &name, __VA_ARGS__, NULL) #include "generated-compulsory-tests" + /* Self-consistency check: make sure no two tests + have the same key or name. */ + keys = btree_new(btree_strcmp); + names = btree_new(btree_strcmp); + list_for_each(&compulsory_tests, i, list) { + if (!btree_insert(keys, i->key)) + errx(1, "BUG: Duplicate test key '%s'", i->key); + if (!btree_insert(keys, i->name)) + errx(1, "BUG: Duplicate test name '%s'", i->name); + } + list_for_each(&normal_tests, i, list) { + if (!btree_insert(keys, i->key)) + errx(1, "BUG: Duplicate test key '%s'", i->key); + if (!btree_insert(keys, i->name)) + errx(1, "BUG: Duplicate test name '%s'", i->name); + } + btree_delete(keys); + btree_delete(names); + if (!verbose) return; @@ -237,45 +276,136 @@ static void init_tests(void) } } +static struct ccanlint *find_test(const char *key) +{ + struct ccanlint *i; + + list_for_each(&compulsory_tests, i, list) + if (streq(i->key, key)) + return i; + + list_for_each(&normal_tests, i, list) + if (streq(i->key, key)) + return i; + + return NULL; +} + +static char *keep_test(const char *testname, void *unused) +{ + struct ccanlint *i = find_test(testname); + if (!i) + errx(1, "No test %s to --keep", testname); + i->keep_results = true; + return NULL; +} + +static char *skip_test(const char *testname, void *unused) +{ + btree_insert(cmdline_exclude, optarg); + return NULL; +} + +static void print_tests(struct list_head *tests, const char *type) +{ + struct ccanlint *i; + + printf("%s tests:\n", type); + /* This makes them print in topological order. */ + while ((i = get_next_test(tests)) != NULL) { + const struct dependent *d; + printf(" %-25s %s\n", i->key, i->name); + list_del(&i->list); + list_for_each(&i->dependencies, d, node) + d->dependent->num_depends--; + } +} + +static char *list_tests(void *arg) +{ + print_tests(&compulsory_tests, "Compulsory"); + print_tests(&normal_tests, "Normal"); + exit(0); +} + +static char *strip(const void *ctx, const char *line) +{ + line += strcspn(line, IDENT_CHARS "-"); + return talloc_strndup(ctx, line, strspn(line, IDENT_CHARS "-")); +} + +static void add_info_fails(struct ccan_file *info) +{ + struct doc_section *d; + unsigned int i; + + list_for_each(get_ccan_file_docs(info), d, list) { + if (!streq(d->type, "fails")) + continue; + + for (i = 0; i < d->num_lines; i++) + btree_insert(info_exclude, strip(info, d->lines[i])); + break; + } +} + int main(int argc, char *argv[]) { - int c; bool summary = false; unsigned int score = 0, total_score = 0; struct manifest *m; struct ccanlint *i; - const char *prefix = "", *dir = "."; - - /* I'd love to use long options, but that's not standard. */ - /* FIXME: getopt_long ccan package? */ - while ((c = getopt(argc, argv, "sd:vn")) != -1) { - switch (c) { - case 'd': - dir = optarg; - prefix = talloc_append_string(talloc_basename(NULL, - optarg), - ": "); - break; - case 's': - summary = true; - break; - case 'v': - verbose++; - break; - case 'n': - safe_mode = true; - break; - default: - usage(argv[0]); - } - } + const char *prefix = ""; + char *dir = talloc_getcwd(NULL), *base_dir = dir; + + init_tests(); - if (optind < argc) - usage(argv[0]); + cmdline_exclude = btree_new(btree_strcmp); + info_exclude = btree_new(btree_strcmp); + + opt_register_arg("--dir/-d", opt_set_charp, opt_show_charp, &dir, + "use this directory"); + opt_register_noarg("-n/--safe-mode", opt_set_bool, &safe_mode, + "do not compile anything"); + opt_register_noarg("-l/--list-tests", list_tests, NULL, + "list tests ccanlint performs (and exit)"); + opt_register_arg("-k/--keep ", keep_test, NULL, NULL, + "keep results of (can be used multiple times)"); + opt_register_noarg("--summary/-s", opt_set_bool, &summary, + "simply give one line summary"); + opt_register_noarg("--verbose/-v", opt_inc_intval, &verbose, + "verbose mode (can specify more than once)"); + opt_register_arg("-x/--exclude ", skip_test, NULL, NULL, + "exclude (can be used multiple times)"); + opt_register_arg("-t/--timeout ", opt_set_uintval, + NULL, &timeout, + "ignore (terminate) tests that are slower than this"); + opt_register_noarg("-?/-h/--help", opt_usage_and_exit, + "\nA program for checking and guiding development" + " of CCAN modules.", + "This usage message"); + + opt_parse(&argc, argv, opt_log_stderr_exit); + + if (dir[0] != '/') + dir = talloc_asprintf_append(NULL, "%s/%s", base_dir, dir); + if (dir != base_dir) + prefix = talloc_append_string(talloc_basename(NULL, dir), ": "); + if (verbose >= 2) + compile_verbose = true; + if (verbose >= 3) + tools_verbose = true; + + /* We move into temporary directory, so gcov dumps its files there. */ + if (chdir(temp_dir(talloc_autofree_context())) != 0) + err(1, "Error changing to %s temporary dir", temp_dir(NULL)); m = get_manifest(talloc_autofree_context(), dir); - init_tests(); + /* Create a symlink from temp dir back to src dir's test directory. */ + if (symlink(talloc_asprintf(m, "%s/test", dir), + talloc_asprintf(m, "%s/test", temp_dir(NULL))) != 0) + err(1, "Creating test symlink in %s", temp_dir(NULL)); /* If you don't pass the compulsory tests, you don't even get a score */ if (verbose) @@ -287,6 +417,8 @@ int main(int argc, char *argv[]) } } + add_info_fails(m->info_file); + if (verbose) printf("\nNormal tests:\n"); while ((i = get_next_test(&normal_tests)) != NULL)