ccanlint: rename files to match keys
[ccan] / tools / ccanlint / tests / tests_compile_coverage.c
1 #include <tools/ccanlint/ccanlint.h>
2 #include <tools/tools.h>
3 #include <ccan/talloc/talloc.h>
4 #include <ccan/str/str.h>
5 #include <sys/types.h>
6 #include <sys/stat.h>
7 #include <fcntl.h>
8 #include <unistd.h>
9 #include <limits.h>
10 #include <errno.h>
11 #include <stdlib.h>
12 #include <stdio.h>
13 #include <err.h>
14 #include <string.h>
15 #include <ctype.h>
16
17 /* Note: we already test safe_mode in run_tests.c */
18 static const char *can_run_coverage(struct manifest *m)
19 {
20         unsigned int timeleft = default_timeout_ms;
21         char *output;
22
23         if (!run_command(m, &timeleft, &output, "gcov -h"))
24                 return talloc_asprintf(m, "No gcov support: %s", output);
25         return NULL;
26 }
27
28 static bool build_module_objs_with_coverage(struct manifest *m, bool keep,
29                                             struct score *score,
30                                             char **modobjs)
31 {
32         struct ccan_file *i;
33
34         *modobjs = talloc_strdup(m, "");
35         list_for_each(&m->c_files, i, list) {
36                 char *err;
37                 char *fullfile = talloc_asprintf(m, "%s/%s", m->dir, i->name);
38
39                 i->cov_compiled = maybe_temp_file(m, "", keep, fullfile);
40                 if (!compile_object(m, fullfile, ccan_dir, "",
41                                     i->cov_compiled, &err)) {
42                         score_file_error(score, i, 0, err);
43                         talloc_free(i->cov_compiled);
44                         i->cov_compiled = NULL;
45                         return false;
46                 }
47                 *modobjs = talloc_asprintf_append(*modobjs,
48                                                   " %s", i->cov_compiled);
49         }
50         return true;
51 }
52
53 /* FIXME: Merge this into one place. */
54 static char *obj_list(const struct manifest *m, const char *modobjs)
55 {
56         char *list = talloc_strdup(m, "");
57         struct ccan_file *i;
58         struct manifest *subm;
59
60         /* Objects from any other C files. */
61         list_for_each(&m->other_test_c_files, i, list)
62                 list = talloc_asprintf_append(list, " %s", i->compiled);
63
64         if (modobjs)
65                 list = talloc_append_string(list, modobjs);
66
67         /* Other ccan modules (don't need coverage versions of those). */
68         list_for_each(&m->deps, subm, list) {
69                 if (subm->compiled)
70                         list = talloc_asprintf_append(list, " %s",
71                                                       subm->compiled);
72         }
73
74         return list;
75 }
76
77 static char *lib_list(const struct manifest *m)
78 {
79         unsigned int i, num;
80         char **libs = get_libs(m, m->dir, &num, &m->info_file->compiled);
81         char *ret = talloc_strdup(m, "");
82
83         for (i = 0; i < num; i++)
84                 ret = talloc_asprintf_append(ret, "-l%s ", libs[i]);
85         return ret;
86 }
87
88 static char *cov_compile(const void *ctx,
89                          struct manifest *m,
90                          struct ccan_file *file,
91                          const char *modobjs,
92                          bool keep)
93 {
94         char *output;
95
96         file->cov_compiled = maybe_temp_file(ctx, "", keep, file->fullname);
97         if (!compile_and_link(ctx, file->fullname, ccan_dir,
98                               obj_list(m, modobjs),
99                               COVERAGE_CFLAGS,
100                               lib_list(m), file->cov_compiled, &output)) {
101                 talloc_free(file->cov_compiled);
102                 file->cov_compiled = NULL;
103                 return output;
104         }
105         talloc_free(output);
106         return NULL;
107 }
108
109 /* FIXME: Coverage from testable examples as well. */
110 static void do_compile_coverage_tests(struct manifest *m,
111                                       bool keep,
112                                       unsigned int *timeleft,
113                                       struct score *score)
114 {
115         char *cmdout, *modobjs = NULL;
116         struct ccan_file *i;
117
118         if (!list_empty(&m->api_tests)
119             && !build_module_objs_with_coverage(m, keep, score, &modobjs)) {
120                 score->error = "Failed to compile module objects with coverage";
121                 return;
122         }
123
124         list_for_each(&m->run_tests, i, list) {
125                 cmdout = cov_compile(m, m, i, NULL, keep);
126                 if (cmdout) {
127                         score->error = "Failed to compile test with coverage";
128                         score_file_error(score, i, 0, cmdout);
129                 }
130         }
131
132         list_for_each(&m->api_tests, i, list) {
133                 cmdout = cov_compile(m, m, i, modobjs, keep);
134                 if (cmdout) {
135                         score->error = "Failed to compile test with coverage";
136                         score_file_error(score, i, 0, cmdout);
137                 }
138         }
139         if (!score->error) {
140                 score->pass = true;
141                 score->score = score->total;
142         }
143 }
144
145 struct ccanlint tests_compile_coverage = {
146         .key = "tests_compile_coverage",
147         .name = "Module tests compile with " COVERAGE_CFLAGS,
148         .check = do_compile_coverage_tests,
149         .can_run = can_run_coverage,
150         .needs = "tests_compile"
151 };
152
153 REGISTER_TEST(tests_compile_coverage);