X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=tools%2Fccanlint%2Fccanlint.c;h=d31ef94058f6d63b0030f5e85c6e971edbc60189;hp=e17b772540bd16679bbb69085791dc432d02f619;hb=af5b1a18948345c5f9f9abf4eda3ab9fe0aa9a9f;hpb=1e755481cb2d7eb439c51e3522a18ec6d3885829 diff --git a/tools/ccanlint/ccanlint.c b/tools/ccanlint/ccanlint.c index e17b7725..d31ef940 100644 --- a/tools/ccanlint/ccanlint.c +++ b/tools/ccanlint/ccanlint.c @@ -25,7 +25,6 @@ #include #include #include -#include #include #include #include @@ -43,11 +42,9 @@ struct ccanlint_map { int verbose = 0; static struct ccanlint_map tests; bool safe_mode = false; +bool keep_results = false; static bool targeting = false; -static struct btree *cmdline_exclude; -static struct btree *info_exclude; static unsigned int timeout; -static struct dgraph_node all; /* These are overridden at runtime if we can find config.h */ const char *compiler = NULL; @@ -81,36 +78,23 @@ bool ask(const char *question) && toupper(reply[0]) == 'Y'; } -static const char *should_skip(struct manifest *m, struct ccanlint *i) +/* Skip, but don't remove. */ +static bool skip_test(struct dgraph_node *node, const char *why) { - 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) - return i->skip; - - if (i->skip_fail) - return "dependency failed"; + struct ccanlint *c = container_of(node, struct ccanlint, node); + c->skip = why; + return true; +} - if (i->can_run) - return i->can_run(m); - return NULL; +static const char *dep_failed(struct manifest *m) +{ + return "dependency couldn't run"; } -static bool skip_node(struct dgraph_node *to, const char *failmsg) +static bool cannot_run(struct dgraph_node *node, void *unused) { - struct ccanlint *c = container_of(to, struct ccanlint, node); - if (!c->skip) { - if (failmsg) { - c->skip = failmsg; - c->skip_fail = true; - } else { - c->skip = "dependency was skipped"; - } - } + struct ccanlint *c = container_of(node, struct ccanlint, node); + c->can_run = dep_failed; return true; } @@ -126,7 +110,6 @@ static bool run_test(struct dgraph_node *n, struct run_info *run) { struct ccanlint *i = container_of(n, struct ccanlint, node); unsigned int timeleft; - const char *skip; struct score *score; if (i->done) @@ -139,31 +122,47 @@ static bool run_test(struct dgraph_node *n, struct run_info *run) score->score = 0; score->total = 1; - skip = should_skip(run->m, i); - - if (skip) { - skip: + /* We can see skipped things in two cases: + * (1) _info excluded them (presumably because they fail). + * (2) A prerequisite failed. + */ + if (i->skip) { if (verbose) printf("%s%s: skipped (%s)\n", - run->prefix, i->name, skip); - - /* If we're skipping this because a prereq failed, we fail: - * count it as a score of 1. */ - if (i->skip_fail) - run->total++; - - dgraph_traverse_from(&i->node, skip_node, - i->skip_fail ? "dependency failed" : NULL); - dgraph_clear_node(&i->node); - score->pass = i->skip_fail ? false : true; + run->prefix, i->name, i->skip); + /* Pass us up to the test which failed, not us. */ + score->pass = true; goto out; } + if (i->can_run) { + i->skip = i->can_run(run->m); + if (i->skip) { + /* Test doesn't apply, or can't run? That's OK. */ + if (verbose > 1) + printf("%s%s: skipped (%s)\n", + run->prefix, i->name, i->skip); + /* Mark our dependencies to skip. */ + dgraph_traverse_from(&i->node, cannot_run, NULL); + score->pass = true; + score->total = 0; + goto out; + } + } + timeleft = timeout ? timeout : default_timeout_ms; - i->check(run->m, i->keep_results, &timeleft, score); + i->check(run->m, &timeleft, score); if (timeout && timeleft == 0) { - skip = "timeout"; - goto skip; + i->skip = "timeout"; + if (verbose) + printf("%s%s: skipped (%s)\n", + run->prefix, i->name, i->skip); + /* Mark our dependencies to skip. */ + dgraph_traverse_from(&i->node, skip_test, + "dependency timed out"); + score->pass = true; + score->total = 0; + goto out; } assert(score->score <= score->total); @@ -187,16 +186,15 @@ static bool run_test(struct dgraph_node *n, struct run_info *run) if (!run->quiet && score->score < score->total && i->handle) i->handle(run->m, score); - run->score += score->score; - run->total += score->total; - if (!score->pass) { /* Skip any tests which depend on this one. */ - dgraph_traverse_from(&i->node, skip_node, "dependency failed"); + dgraph_traverse_from(&i->node, skip_test, "dependency failed"); } - dgraph_clear_node(&i->node); out: + run->score += score->score; + run->total += score->total; + /* FIXME: Free score. */ run->pass &= score->pass; i->done = true; @@ -216,8 +214,6 @@ static void register_test(struct ccanlint *test) test->options = talloc_array(NULL, char *, 1); test->options[0] = NULL; dgraph_init_node(&test->node); - dgraph_add_edge(&test->node, &all); - test->done = false; } static bool get_test(const char *member, struct ccanlint *i, @@ -254,18 +250,14 @@ static struct ccanlint *find_test(const char *key) bool is_excluded(const char *name) { - return btree_lookup(cmdline_exclude, name) != NULL - || btree_lookup(info_exclude, name) != NULL - || find_test(name)->skip != NULL; + return find_test(name)->skip != NULL; } -static bool reset_deps(const char *member, struct ccanlint *c, void *unused) +static bool init_deps(const char *member, struct ccanlint *c, void *unused) { char **deps = strsplit(NULL, c->needs, " "); unsigned int i; - c->skip = NULL; - c->skip_fail = false; for (i = 0; deps[i]; i++) { struct ccanlint *dep; @@ -295,16 +287,13 @@ static void init_tests(void) { struct ccanlint_map names; - /* This is the default target. */ - dgraph_init_node(&all); - strmap_init(&tests); #undef REGISTER_TEST #define REGISTER_TEST(name) register_test(&name) #include "generated-testlist" - strmap_iterate(&tests, reset_deps, NULL); + strmap_iterate(&tests, init_deps, NULL); /* Check for duplicate names. */ strmap_init(&names); @@ -312,6 +301,19 @@ static void init_tests(void) strmap_clear(&names); } +static bool reset_test(struct dgraph_node *node, void *unused) +{ + struct ccanlint *c = container_of(node, struct ccanlint, node); + c->skip = NULL; + c->done = false; + return true; +} + +static void reset_tests(struct dgraph_node *all) +{ + dgraph_traverse_to(all, reset_test, NULL); +} + static bool print_deps(const char *member, struct ccanlint *c, void *unused) { if (!tlist_empty(&c->node.edge[DGRAPH_FROM])) { @@ -342,32 +344,41 @@ static int show_tmpdir(const char *dir) return 0; } -static bool keep_one_test(const char *member, struct ccanlint *c, void *unused) +static char *keep_tests(void *unused) +{ + keep_results = true; + + /* Don't automatically destroy temporary dir. */ + talloc_set_destructor(temp_dir(NULL), show_tmpdir); + return NULL; +} + +static bool remove_test(struct dgraph_node *node, const char *why) { - c->keep_results = true; + struct ccanlint *c = container_of(node, struct ccanlint, node); + c->skip = why; + dgraph_clear_node(node); return true; } -static char *keep_test(const char *testname, void *unused) +static char *exclude_test(const char *testname, void *unused) { - if (streq(testname, "all")) { - strmap_iterate(&tests, keep_one_test, NULL); - } else { - struct ccanlint *i = find_test(testname); - if (!i) - errx(1, "No test %s to --keep", testname); - keep_one_test(testname, i, NULL); - } + struct ccanlint *i = find_test(testname); + if (!i) + return talloc_asprintf(NULL, "No test %s to --exclude", + testname); - /* Don't automatically destroy temporary dir. */ - talloc_set_destructor(temp_dir(NULL), show_tmpdir); + /* Remove this, and everything which depends on it. */ + dgraph_traverse_from(&i->node, remove_test, "excluded on command line"); + remove_test(&i->node, "excluded on command line"); return NULL; } -static char *skip_test(const char *testname, void *unused) +static void skip_test_and_deps(struct ccanlint *c, const char *why) { - btree_insert(cmdline_exclude, testname); - return NULL; + /* Skip this, and everything which depends on us. */ + dgraph_traverse_from(&c->node, skip_test, why); + skip_test(&c->node, why); } static char *list_tests(void *arg) @@ -497,7 +508,9 @@ void add_info_options(struct ccan_file *info) /* Known failure? */ if (strcasecmp(words[1], "FAIL") == 0) { if (!targeting) - btree_insert(info_exclude, words[0]); + skip_test_and_deps(test, + "excluded in _info" + " file"); } else { if (!test->takes_options) warnx("%s: %s doesn't take options", @@ -644,15 +657,18 @@ static char *opt_set_const_charp(const char *arg, const char **p) return opt_set_charp(arg, cast_const2(char **, p)); } -static char *opt_set_target(const char *arg, struct ccanlint **t) +static char *opt_set_target(const char *arg, struct dgraph_node *all) { - *t = find_test(arg); - if (!*t) + struct ccanlint *t = find_test(arg); + if (!t) return talloc_asprintf(NULL, "unknown --target %s", arg); + + targeting = true; + dgraph_add_edge(&t->node, all); return NULL; } -static bool run_tests(struct ccanlint *target, +static bool run_tests(struct dgraph_node *all, bool summary, struct manifest *m, const char *prefix) @@ -665,30 +681,30 @@ static bool run_tests(struct ccanlint *target, run.score = run.total = 0; run.pass = true; - if (target) { - dgraph_traverse_to(&target->node, run_test, &run); - if (run.pass) - run_test(&target->node, &run); - } else - dgraph_traverse_to(&all, run_test, &run); - - printf("%sTotal score: %u/%u\n", - prefix, run.score, run.total); + dgraph_traverse_to(all, run_test, &run); + printf("%sTotal score: %u/%u\n", prefix, run.score, run.total); return run.pass; } +static bool add_to_all(const char *member, struct ccanlint *c, + struct dgraph_node *all) +{ + dgraph_add_edge(&c->node, all); + return true; +} + int main(int argc, char *argv[]) { bool summary = false, pass = true; unsigned int i; struct manifest *m; - struct ccanlint *target = NULL; const char *prefix = ""; char *dir = talloc_getcwd(NULL), *base_dir = dir, *testlink; + struct dgraph_node all; - cmdline_exclude = btree_new(btree_strcmp); - info_exclude = btree_new(btree_strcmp); + /* Empty graph node to which we attach everything else. */ + dgraph_init_node(&all); opt_register_early_noarg("--verbose|-v", opt_inc_intval, &verbose, "verbose mode (up to -vvvv)"); @@ -698,18 +714,16 @@ int main(int argc, char *argv[]) "list tests ccanlint performs (and exit)"); opt_register_noarg("--test-dep-graph", test_dependency_graph, NULL, "print dependency graph of tests in Graphviz .dot format"); - opt_register_arg("-k|--keep ", keep_test, NULL, NULL, - "keep results of " - " (can be used multiple times, or 'all')"); + opt_register_noarg("-k|--keep", keep_tests, NULL, + "do not delete ccanlint working files"); opt_register_noarg("--summary|-s", opt_set_bool, &summary, "simply give one line summary"); - opt_register_arg("-x|--exclude ", skip_test, NULL, NULL, + opt_register_arg("-x|--exclude ", exclude_test, NULL, NULL, "exclude (can be used multiple times)"); - opt_register_arg("-t|--timeout ", opt_set_uintval, + opt_register_arg("--timeout ", opt_set_uintval, NULL, &timeout, "ignore (terminate) tests that are slower than this"); - opt_register_arg("--target ", opt_set_target, - NULL, &target, + opt_register_arg("-t|--target ", opt_set_target, NULL, &all, "only run one test (and its prerequisites)"); opt_register_arg("--compiler ", opt_set_const_charp, NULL, &compiler, "set the compiler"); @@ -738,6 +752,9 @@ int main(int argc, char *argv[]) opt_parse(&argc, argv, opt_log_stderr_exit); + if (!targeting) + strmap_iterate(&tests, add_to_all, &all); + /* This links back to the module's test dir. */ testlink = talloc_asprintf(NULL, "%s/test", temp_dir(NULL)); @@ -763,8 +780,6 @@ int main(int argc, char *argv[]) prefix = talloc_append_string(talloc_basename(NULL,dir), ": "); - init_tests(); - m = get_manifest(talloc_autofree_context(), dir); /* FIXME: This has to come after we've got manifest. */ @@ -778,8 +793,10 @@ int main(int argc, char *argv[]) err(1, "Creating test symlink in %s", temp_dir(NULL)); score = total_score = 0; - if (!run_tests(target, summary, m, prefix)) + if (!run_tests(&all, summary, m, prefix)) pass = false; + + reset_tests(&all); } return pass ? 0 : 1; }