X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=tools%2Fccanlint%2Fccanlint.c;h=158195cbdef04adf4c6ca1323ccc68c3862b1f1b;hp=7a7f5b8be17d3187f51b29d19de71c448471db0d;hb=9e207bca5bf5e0a1e3653a91649414fab793c801;hpb=43ea89157d6cf730d44050548cb60407da60cb0f diff --git a/tools/ccanlint/ccanlint.c b/tools/ccanlint/ccanlint.c index 7a7f5b8b..158195cb 100644 --- a/tools/ccanlint/ccanlint.c +++ b/tools/ccanlint/ccanlint.c @@ -19,21 +19,20 @@ */ #include "ccanlint.h" #include "../tools.h" +#include "../read_config_header.h" #include #include #include #include #include #include -#include #include -#include -#include +#include #include #include -#include #include #include +#include #include struct ccanlint_map { @@ -43,17 +42,16 @@ struct ccanlint_map { int verbose = 0; static struct ccanlint_map tests; bool safe_mode = false; +bool keep_results = false; +bool non_ccan_deps = false; +bool build_failed = false; static bool targeting = false; -static struct btree *cmdline_exclude; -static struct btree *info_exclude; static unsigned int timeout; -/* These are overridden at runtime if we can find config.h */ -const char *compiler = NULL; -const char *cflags = NULL; - const char *config_header; +const char *ccan_dir; + #if 0 static void indent_print(const char *string) { @@ -80,125 +78,141 @@ 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 *all) { - 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; } -static bool run_test(struct ccanlint *i, - bool quiet, - unsigned int *running_score, - unsigned int *running_total, - struct manifest *m, - const char *prefix) +struct run_info { + bool quiet; + unsigned int score, total; + struct manifest *m; + const char *prefix; + bool pass; +}; + +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; - strmap_del(&tests, i->key, NULL); - - if (!i->should_run) { - dgraph_clear_node(&i->node); + if (i->done) return true; - } - score = talloc(m, struct score); + score = tal(run->m, struct score); list_head_init(&score->per_file_errors); score->error = NULL; score->pass = false; score->score = 0; score->total = 1; - skip = should_skip(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", 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) - (*running_total)++; + printf("%s%s: skipped (%s)\n", + run->prefix, i->name, i->skip); + /* Pass us up to the test which failed, not us. */ + score->pass = true; + goto out; + } - dgraph_traverse_from(&i->node, skip_node, - i->skip_fail ? "dependency failed" : NULL); - dgraph_clear_node(&i->node); - return i->skip_fail ? false : true; + 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(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); - if ((!score->pass && !quiet) + if ((!score->pass && !run->quiet) || (score->score < score->total && verbose) || verbose > 1) { printf("%s%s (%s): %s", - prefix, i->name, i->key, score->pass ? "PASS" : "FAIL"); + run->prefix, i->name, i->key, + score->pass ? "PASS" : "FAIL"); if (score->total > 1) printf(" (+%u/%u)", score->score, score->total); printf("\n"); } - if ((!quiet && !score->pass) || verbose) { + if ((!run->quiet && !score->pass) || verbose) { if (score->error) { printf("%s%s", score->error, strends(score->error, "\n") ? "" : "\n"); } } - if (!quiet && score->score < score->total && i->handle) - i->handle(m, score); - - *running_score += score->score; - *running_total += score->total; + if (!run->quiet && score->score < score->total && i->handle) + i->handle(run->m, score); 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"); + } + +out: + run->score += score->score; + run->total += score->total; + + /* FIXME: Free score. */ + run->pass &= score->pass; + i->done = true; + + if (!score->pass && i->compulsory) { + warnx("%s%s failed", run->prefix, i->name); + run->score = 0; + return false; } - dgraph_clear_node(&i->node); - return score->pass; + return true; } static void register_test(struct ccanlint *test) { if (!strmap_add(&tests, test->key, test)) err(1, "Adding test %s", test->key); - test->options = talloc_array(NULL, char *, 1); + test->options = tal_arr(NULL, char *, 1); test->options[0] = NULL; dgraph_init_node(&test->node); } @@ -237,18 +251,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, " "); + char **deps = tal_strsplit(NULL, c->needs, " ", STR_EMPTY_OK); unsigned int i; - c->skip = NULL; - c->skip_fail = false; for (i = 0; deps[i]; i++) { struct ccanlint *dep; @@ -258,7 +268,7 @@ static bool reset_deps(const char *member, struct ccanlint *c, void *unused) deps[i], c->key); dgraph_add_edge(&dep->node, &c->node); } - talloc_free(deps); + tal_free(deps); return true; } @@ -270,21 +280,20 @@ static bool check_names(const char *member, struct ccanlint *c, return true; } -#undef REGISTER_TEST -#define REGISTER_TEST(name, ...) extern struct ccanlint name -#include "generated-testlist" - static void init_tests(void) { struct ccanlint_map names; + struct ccanlint **table; + size_t i, num; strmap_init(&tests); -#undef REGISTER_TEST -#define REGISTER_TEST(name) register_test(&name) -#include "generated-testlist" + table = autodata_get(ccanlint_tests, &num); + for (i = 0; i < num; i++) + register_test(table[i]); + autodata_free(table); - strmap_iterate(&tests, reset_deps, NULL); + strmap_iterate(&tests, init_deps, NULL); /* Check for duplicate names. */ strmap_init(&names); @@ -292,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])) { @@ -316,38 +338,46 @@ static void print_test_depends(void) } -static int show_tmpdir(const char *dir) +static void show_tmpdir(const char *dir) { printf("You can find ccanlint working files in '%s'\n", 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. */ + keep_temp_dir(); + tal_add_destructor(temp_dir(), 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 tal_fmt(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) @@ -409,21 +439,6 @@ static char *test_dependency_graph(void *arg) exit(0); } -/* Remove empty lines. */ -static char **collapse(char **lines, unsigned int *nump) -{ - unsigned int i, j; - for (i = j = 0; lines[i]; i++) { - if (lines[i][0]) - lines[j++] = lines[i]; - } - lines[j] = NULL; - if (nump) - *nump = j; - return lines; -} - - static void add_options(struct ccanlint *test, char **options, unsigned int num_options) { @@ -433,11 +448,9 @@ static void add_options(struct ccanlint *test, char **options, num = 0; else /* -1, because last one is NULL. */ - num = talloc_array_length(test->options) - 1; + num = tal_count(test->options) - 1; - test->options = talloc_realloc(NULL, test->options, - char *, - num + num_options + 1); + tal_resize(&test->options, num + num_options + 1); memcpy(&test->options[num], options, (num_options + 1)*sizeof(char *)); } @@ -452,10 +465,9 @@ void add_info_options(struct ccan_file *info) continue; for (i = 0; i < d->num_lines; i++) { - unsigned int num_words; - char **words = collapse(strsplit(d, d->lines[i], " \t"), - &num_words); - if (num_words == 0) + char **words = tal_strsplit(d, d->lines[i], " \t", + STR_NO_EMPTY); + if (!words[0]) continue; if (strncmp(words[0], "//", 2) == 0) @@ -477,12 +489,14 @@ 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", info->fullname, words[0]); - add_options(test, words+1, num_words-1); + add_options(test, words+1, tal_count(words)-1); } } } @@ -498,7 +512,7 @@ char **per_file_options(const struct ccanlint *test, struct ccan_file *f) if (!test->options[0]) return test->options; - ret = talloc_array(f, char *, talloc_array_length(test->options)); + ret = tal_arr(f, char *, tal_count(test->options)); for (i = 0; test->options[i]; i++) { char *optname; @@ -512,7 +526,7 @@ char **per_file_options(const struct ccanlint *test, struct ccan_file *f) /* FAIL overrides anything else. */ if (streq(optname, "FAIL")) { - ret = talloc_array(f, char *, 2); + ret = tal_arr(f, char *, 2); ret[0] = (char *)"FAIL"; ret[1] = NULL; return ret; @@ -521,145 +535,93 @@ char **per_file_options(const struct ccanlint *test, struct ccan_file *f) } ret[j] = NULL; - /* Shrink it to size so talloc_array_length() works as expected. */ - return talloc_realloc(NULL, ret, char *, j + 1); + /* Shrink it to size so tal_array_length() works as expected. */ + tal_resize(&ret, j + 1); + return ret; } -static char *demangle_string(char *string) +static char *opt_set_const_charp(const char *arg, const char **p) { - unsigned int i; - const char mapfrom[] = "abfnrtv"; - const char mapto[] = "\a\b\f\n\r\t\v"; - - if (!strchr(string, '"')) - return NULL; - string = strchr(string, '"') + 1; - if (!strrchr(string, '"')) - return NULL; - *strrchr(string, '"') = '\0'; - - for (i = 0; i < strlen(string); i++) { - if (string[i] == '\\') { - char repl; - unsigned len = 0; - const char *p = strchr(mapfrom, string[i+1]); - if (p) { - repl = mapto[p - mapfrom]; - len = 1; - } else if (strlen(string+i+1) >= 3) { - if (string[i+1] == 'x') { - repl = (string[i+2]-'0')*16 - + string[i+3]-'0'; - len = 3; - } else if (cisdigit(string[i+1])) { - repl = (string[i+2]-'0')*8*8 - + (string[i+3]-'0')*8 - + (string[i+4]-'0'); - len = 3; - } - } - if (len == 0) { - repl = string[i+1]; - len = 1; - } + return opt_set_charp(arg, cast_const2(char **, p)); +} - string[i] = repl; - memmove(string + i + 1, string + i + len + 1, - strlen(string + i + len + 1) + 1); - } - } +static char *opt_set_target(const char *arg, struct dgraph_node *all) +{ + struct ccanlint *t = find_test(arg); + if (!t) + return tal_fmt(NULL, "unknown --target %s", arg); - return string; + targeting = true; + dgraph_add_edge(&t->node, all); + return NULL; } - -static void read_config_header(void) +static bool run_tests(struct dgraph_node *all, + bool summary, + bool deps_fail_ignore, + struct manifest *m, + const char *prefix) { - char *fname = talloc_asprintf(NULL, "%s/config.h", ccan_dir); - char **lines; - unsigned int i; + struct run_info run; + const char *comment = ""; - config_header = grab_file(NULL, fname, NULL); - if (!config_header) { - talloc_free(fname); - return; - } + run.quiet = summary; + run.m = m; + run.prefix = prefix; + run.score = run.total = 0; + run.pass = true; - lines = strsplit(config_header, config_header, "\n"); - for (i = 0; i < talloc_array_length(lines) - 1; i++) { - char *sym; - const char **line = (const char **)&lines[i]; + non_ccan_deps = build_failed = false; - if (!get_token(line, "#")) - continue; - if (!get_token(line, "define")) - continue; - sym = get_symbol_token(lines, line); - if (streq(sym, "CCAN_COMPILER") && !compiler) { - compiler = demangle_string(lines[i]); - if (!compiler) - errx(1, "%s:%u:could not parse CCAN_COMPILER", - fname, i+1); - if (verbose > 1) - printf("%s: compiler set to '%s'\n", - fname, compiler); - } else if (streq(sym, "CCAN_CFLAGS") && !cflags) { - cflags = demangle_string(lines[i]); - if (!cflags) - errx(1, "%s:%u:could not parse CCAN_CFLAGS", - fname, i+1); - if (verbose > 1) - printf("%s: compiler flags set to '%s'\n", - fname, cflags); - } + dgraph_traverse_to(all, run_test, &run); + + /* We can completely fail if we're missing external stuff: ignore */ + if (deps_fail_ignore && non_ccan_deps && build_failed) { + comment = " (missing non-ccan dependencies?)"; + run.pass = true; } - if (!compiler) - compiler = CCAN_COMPILER; - if (!cflags) - compiler = CCAN_CFLAGS; -} + printf("%sTotal score: %u/%u%s\n", + prefix, run.score, run.total, comment); -static char *opt_set_const_charp(const char *arg, const char **p) -{ - return opt_set_charp(arg, cast_const2(char **, p)); + return run.pass; } -static bool should_run_ccanlint(const char *name, struct ccanlint *c, - void *unused) +static bool add_to_all(const char *member, struct ccanlint *c, + struct dgraph_node *all) { - c->should_run = true; + /* If we're excluded on cmdline, don't add. */ + if (!c->skip) + dgraph_add_edge(&c->node, all); return true; } -static bool should_run_node(struct dgraph_node *to, void *unused) +static bool test_module(struct dgraph_node *all, + const char *dir, const char *prefix, bool summary, + bool deps_fail_ignore) { - should_run_ccanlint(NULL, container_of(to, struct ccanlint, node), - unused); - return true; -} + struct manifest *m = get_manifest(autofree(), dir); + char *testlink = path_join(NULL, temp_dir(), "test"); -static char *add_target(const char *arg, bool *targeting) -{ - struct ccanlint *c = find_test(arg); - if (!c) - return talloc_asprintf(NULL, "Unknown test %s", arg); + /* Create a symlink from temp dir back to src dir's + * test directory. */ + unlink(testlink); + if (symlink(path_join(m, dir, "test"), testlink) != 0) + err(1, "Creating test symlink in %s", temp_dir()); - dgraph_traverse_to(&c->node, should_run_node, NULL); - *targeting = true; - return NULL; + return run_tests(all, summary, deps_fail_ignore, m, prefix); } int main(int argc, char *argv[]) { - bool summary = false, pass = true, targeting = false; + bool summary = false, pass = true, deps_fail_ignore = false; unsigned int i; - struct manifest *m; - struct ccanlint *t; const char *prefix = ""; - char *dir = talloc_getcwd(NULL), *base_dir = dir, *testlink; + char *cwd = path_cwd(NULL), *dir; + struct ccanlint top; /* cannot_run may try to set ->can_run */ + const char *override_compiler = NULL, *override_cflags = NULL; - cmdline_exclude = btree_new(btree_strcmp); - info_exclude = btree_new(btree_strcmp); + /* Empty graph node to which we attach everything else. */ + dgraph_init_node(&top.node); opt_register_early_noarg("--verbose|-v", opt_inc_intval, &verbose, "verbose mode (up to -vvvv)"); @@ -669,22 +631,25 @@ 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 ", add_target, NULL, &targeting, - "run this test and prerequisites (can specify multiple times)"); + opt_register_arg("-t|--target ", opt_set_target, NULL, + &top.node, + "only run one test (and its prerequisites)"); opt_register_arg("--compiler ", opt_set_const_charp, - NULL, &compiler, "set the compiler"); + NULL, &override_compiler, "set the compiler"); opt_register_arg("--cflags ", opt_set_const_charp, - NULL, &cflags, "set the compiler flags"); + NULL, &override_cflags, "set the compiler flags"); + opt_register_noarg("--deps-fail-ignore", opt_set_bool, + &deps_fail_ignore, + "don't fail if external dependencies are missing"); opt_register_noarg("-?|-h|--help", opt_usage_and_exit, "\nA program for checking and guiding development" " of CCAN modules.", @@ -694,8 +659,8 @@ int main(int argc, char *argv[]) opt_early_parse(argc, argv, opt_log_stderr_exit); /* 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)); + if (chdir(temp_dir()) != 0) + err(1, "Error changing to %s temporary dir", temp_dir()); init_tests(); @@ -708,65 +673,44 @@ int main(int argc, char *argv[]) opt_parse(&argc, argv, opt_log_stderr_exit); - /* This links back to the module's test dir. */ - testlink = talloc_asprintf(NULL, "%s/test", temp_dir(NULL)); - - /* If no --target, run all tests. */ if (!targeting) - strmap_iterate(&tests, should_run_ccanlint, NULL); + strmap_iterate(&tests, add_to_all, &top.node); - /* Defaults to pwd. */ - if (argc == 1) { - i = 1; - goto got_dir; - } - - for (i = 1; i < argc; i++) { - unsigned int score, total_score; - - dir = argv[i]; - - if (dir[0] != '/') - dir = talloc_asprintf_append(NULL, "%s/%s", - base_dir, dir); - while (strends(dir, "/")) - dir[strlen(dir)-1] = '\0'; - - got_dir: - if (dir != base_dir) - 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. */ - if (i == 1) - read_config_header(); - - /* Create a symlink from temp dir back to src dir's - * test directory. */ - unlink(testlink); - if (symlink(talloc_asprintf(m, "%s/test", dir), testlink) != 0) - err(1, "Creating test symlink in %s", temp_dir(NULL)); - - score = total_score = 0; - while ((t = get_next_test()) != NULL) { - if (!run_test(t, summary, &score, &total_score, m, - prefix)) { - pass = false; - if (t->compulsory) { - warnx("%s%s failed", prefix, t->name); - printf("%sTotal score: 0/%u\n", - prefix, total_score); - goto next; - } - } + if (argc == 1) + dir = cwd; + else + dir = path_simplify(NULL, take(path_join(NULL, cwd, argv[1]))); + + ccan_dir = find_ccan_dir(dir); + if (!ccan_dir) + errx(1, "Cannot find ccan/ base directory in %s", dir); + config_header = read_config_header(ccan_dir, verbose > 1); + + /* We do this after read_config_header has set compiler & cflags */ + if (override_cflags) + cflags = override_cflags; + if (override_compiler) + compiler = override_compiler; + + if (argc == 1) + pass = test_module(&top.node, cwd, "", + summary, deps_fail_ignore); + else { + for (i = 1; i < argc; i++) { + dir = path_canon(NULL, + take(path_join(NULL, cwd, argv[i]))); + if (!dir) + err(1, "Cannot get canonical name of '%s'", + argv[i]); + + prefix = path_join(NULL, ccan_dir, "ccan"); + prefix = path_rel(NULL, take(prefix), dir); + prefix = tal_strcat(NULL, take(prefix), ": "); + + pass &= test_module(&top.node, dir, prefix, summary, + deps_fail_ignore); + reset_tests(&top.node); } - - printf("%sTotal score: %u/%u\n", prefix, score, total_score); - next: ; } return pass ? 0 : 1; }