X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=tools%2Fccanlint%2Fccanlint.c;h=78518721ef30726c7baf29bf80bd2e6625c472b1;hp=a65c64106d2799fbfb7ba5deb8fffccf2acd7307;hb=63bceea014e091a2f2907e49f7c3b33f042106f4;hpb=304652023042670b3173de0ad5dc0eb7c836618c diff --git a/tools/ccanlint/ccanlint.c b/tools/ccanlint/ccanlint.c index a65c6410..78518721 100644 --- a/tools/ccanlint/ccanlint.c +++ b/tools/ccanlint/ccanlint.c @@ -31,24 +31,26 @@ #include #include -static unsigned int verbose = 0; +unsigned int verbose = 0; static LIST_HEAD(compulsory_tests); static LIST_HEAD(normal_tests); static LIST_HEAD(finished_tests); bool safe_mode = false; -static struct btree *exclude; -static bool fastmode = false; +static struct btree *cmdline_exclude; +static struct btree *info_exclude; +static unsigned int timeout; static void usage(const char *name) { - fprintf(stderr, "Usage: %s [-s] [-n] [-v] [-t] [-d ]\n" - " -v: verbose mode\n" + fprintf(stderr, "Usage: %s [-s] [-n] [-v] [-t ] [-d ] [-x ]* [-k ]*\n" + " -v: verbose mode (can specify more than once)\n" " -s: simply give one line summary\n" " -d: use this directory instead of the current one\n" " -n: do not compile anything\n" " -l: list tests ccanlint performs\n" - " -x: exclude tests (e.g. -x trailing_whitespace,valgrind)\n" - " -t: ignore (terminate) tests that are slow\n", + " -k: keep results of this test (can be used multiple times)\n" + " -x: exclude tests (can be used multiple times)\n" + " -t: ignore (terminate) tests that are slower than this\n", name); exit(1); } @@ -81,8 +83,11 @@ bool ask(const char *question) static const char *should_skip(struct manifest *m, struct ccanlint *i) { - if (btree_lookup(exclude, i->key)) + 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"; @@ -105,6 +110,7 @@ static bool run_test(struct ccanlint *i, unsigned int this_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) @@ -130,58 +136,56 @@ static bool run_test(struct ccanlint *i, return true; } - timeleft = fastmode ? 1000 : default_timeout_ms; - result = i->check(m, &timeleft); - if (fastmode && timeleft == 0) { + timeleft = timeout ? timeout : default_timeout_ms; + result = i->check(m, i->keep_results, &timeleft); + if (timeout && timeleft == 0) { skip = "timeout"; goto skip; } - if (!result) { - if (verbose) { - printf(" %s: OK", i->name); - if (i->total_score) - printf(" (+%u/%u)", - i->total_score, i->total_score); - printf("\n"); - } - 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; - } - - if (i->score) + if (!result) + this_score = i->total_score ? i->total_score : 1; + 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 >= i->total_score); - *total_score += i->total_score; - *score += this_score; - if (verbose) { - printf(" %s: FAIL (+%u/%u)\n", - i->name, this_score, i->total_score); + if (verbose || (bad && !quiet)) { + printf(" %s: %s", i->name, + bad ? "FAIL" : good ? "PASS" : "PARTIAL"); + if (i->total_score) + printf(" (+%u/%u)", + this_score, i->total_score); + printf("\n"); } - if (!quiet) { - printf("%s\n", i->describe(m, result)); + 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, ...) @@ -284,6 +288,29 @@ 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 void keep_test(const char *testname) +{ + struct ccanlint *i = find_test(testname); + if (!i) + errx(1, "No test %s to --keep", testname); + i->keep_results = true; +} + static void print_tests(struct list_head *tests, const char *type) { struct ccanlint *i; @@ -301,12 +328,32 @@ static void print_tests(struct list_head *tests, const char *type) static void list_tests(void) { - init_tests(); 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; @@ -314,16 +361,23 @@ int main(int argc, char *argv[]) unsigned int score = 0, total_score = 0; struct manifest *m; struct ccanlint *i; - const char *prefix = "", *dir = "."; + const char *prefix = "", *dir = talloc_getcwd(NULL); - exclude = btree_new(btree_strcmp); + init_tests(); + + cmdline_exclude = btree_new(btree_strcmp); + info_exclude = btree_new(btree_strcmp); /* I'd love to use long options, but that's not standard. */ - /* FIXME: getopt_long ccan package? */ - while ((c = getopt(argc, argv, "sd:vnlx:t")) != -1) { + /* FIXME: popt ccan package? */ + while ((c = getopt(argc, argv, "sd:vnlx:t:k:")) != -1) { switch (c) { case 'd': - dir = optarg; + if (optarg[0] != '/') + dir = talloc_asprintf_append(NULL, "%s/%s", + dir, optarg); + else + dir = optarg; prefix = talloc_append_string(talloc_basename(NULL, optarg), ": "); @@ -339,14 +393,17 @@ int main(int argc, char *argv[]) case 'n': safe_mode = true; break; - case 'x': { - char **exclude_strs = strsplit(NULL, optarg, ",", NULL); - size_t i; - for (i = 0; exclude_strs[i]; i++) - btree_insert(exclude, exclude_strs[i]); - } break; + case 'k': + keep_test(optarg); + break; + case 'x': + btree_insert(cmdline_exclude, optarg); + break; case 't': - fastmode = true; + timeout = atoi(optarg); + if (!timeout) + errx(1, "Invalid timeout %s: 1 ms minumum", + optarg); break; default: usage(argv[0]); @@ -356,9 +413,21 @@ int main(int argc, char *argv[]) if (optind < argc) usage(argv[0]); + 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) @@ -370,6 +439,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)