]>
Commit | Line | Data |
---|---|---|
d9b950dd | 1 | /* A self-testing framework, for use by -fself-test. |
a945c346 | 2 | Copyright (C) 2015-2024 Free Software Foundation, Inc. |
d9b950dd DM |
3 | |
4 | This file is part of GCC. | |
5 | ||
6 | GCC is free software; you can redistribute it and/or modify it under | |
7 | the terms of the GNU General Public License as published by the Free | |
8 | Software Foundation; either version 3, or (at your option) any later | |
9 | version. | |
10 | ||
11 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
12 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
14 | for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with GCC; see the file COPYING3. If not see | |
18 | <http://www.gnu.org/licenses/>. */ | |
19 | ||
20 | #include "config.h" | |
21 | #include "system.h" | |
22 | #include "coretypes.h" | |
23 | #include "selftest.h" | |
dbf96d49 | 24 | #include "intl.h" |
d9b950dd DM |
25 | |
26 | #if CHECKING_P | |
27 | ||
96f14006 DM |
28 | namespace selftest { |
29 | ||
30 | int num_passes; | |
d9b950dd DM |
31 | |
32 | /* Record the successful outcome of some aspect of a test. */ | |
33 | ||
34 | void | |
96f14006 | 35 | pass (const location &/*loc*/, const char */*msg*/) |
d9b950dd DM |
36 | { |
37 | num_passes++; | |
38 | } | |
39 | ||
40 | /* Report the failed outcome of some aspect of a test and abort. */ | |
41 | ||
42 | void | |
96f14006 | 43 | fail (const location &loc, const char *msg) |
d9b950dd | 44 | { |
09765e3a DM |
45 | fprintf (stderr,"%s:%i: %s: FAIL: %s\n", loc.m_file, loc.m_line, |
46 | loc.m_function, msg); | |
d9b950dd DM |
47 | abort (); |
48 | } | |
49 | ||
755fa666 DM |
50 | /* As "fail", but using printf-style formatted output. */ |
51 | ||
52 | void | |
96f14006 | 53 | fail_formatted (const location &loc, const char *fmt, ...) |
755fa666 DM |
54 | { |
55 | va_list ap; | |
56 | ||
09765e3a DM |
57 | fprintf (stderr, "%s:%i: %s: FAIL: ", loc.m_file, loc.m_line, |
58 | loc.m_function); | |
755fa666 DM |
59 | va_start (ap, fmt); |
60 | vfprintf (stderr, fmt, ap); | |
61 | va_end (ap); | |
62 | fprintf (stderr, "\n"); | |
63 | abort (); | |
64 | } | |
65 | ||
5989388c | 66 | /* Implementation detail of ASSERT_STREQ. |
47ae164c DM |
67 | Compare val1 and val2 with strcmp. They ought |
68 | to be non-NULL; fail gracefully if either or both are NULL. */ | |
755fa666 DM |
69 | |
70 | void | |
96f14006 | 71 | assert_streq (const location &loc, |
47ae164c DM |
72 | const char *desc_val1, const char *desc_val2, |
73 | const char *val1, const char *val2) | |
755fa666 | 74 | { |
47ae164c DM |
75 | /* If val1 or val2 are NULL, fail with a custom error message. */ |
76 | if (val1 == NULL) | |
77 | if (val2 == NULL) | |
78 | fail_formatted (loc, "ASSERT_STREQ (%s, %s) val1=NULL val2=NULL", | |
79 | desc_val1, desc_val2); | |
80 | else | |
81 | fail_formatted (loc, "ASSERT_STREQ (%s, %s) val1=NULL val2=\"%s\"", | |
82 | desc_val1, desc_val2, val2); | |
755fa666 | 83 | else |
47ae164c DM |
84 | if (val2 == NULL) |
85 | fail_formatted (loc, "ASSERT_STREQ (%s, %s) val1=\"%s\" val2=NULL", | |
86 | desc_val1, desc_val2, val1); | |
87 | else | |
88 | { | |
89 | if (strcmp (val1, val2) == 0) | |
90 | pass (loc, "ASSERT_STREQ"); | |
91 | else | |
ebfc3a23 | 92 | fail_formatted (loc, "ASSERT_STREQ (%s, %s)\n val1=\"%s\"\n val2=\"%s\"\n", |
47ae164c DM |
93 | desc_val1, desc_val2, val1, val2); |
94 | } | |
755fa666 DM |
95 | } |
96 | ||
9f589786 | 97 | /* Implementation detail of ASSERT_STR_CONTAINS. |
700d4cb0 | 98 | Use strstr to determine if val_needle is within val_haystack. |
9f589786 DM |
99 | ::selftest::pass if it is found. |
100 | ::selftest::fail if it is not found. */ | |
101 | ||
102 | void | |
96f14006 DM |
103 | assert_str_contains (const location &loc, |
104 | const char *desc_haystack, | |
105 | const char *desc_needle, | |
106 | const char *val_haystack, | |
107 | const char *val_needle) | |
9f589786 DM |
108 | { |
109 | /* If val_haystack is NULL, fail with a custom error message. */ | |
110 | if (val_haystack == NULL) | |
96f14006 DM |
111 | fail_formatted (loc, "ASSERT_STR_CONTAINS (%s, %s) haystack=NULL", |
112 | desc_haystack, desc_needle); | |
9f589786 DM |
113 | |
114 | /* If val_needle is NULL, fail with a custom error message. */ | |
115 | if (val_needle == NULL) | |
96f14006 DM |
116 | fail_formatted (loc, |
117 | "ASSERT_STR_CONTAINS (%s, %s) haystack=\"%s\" needle=NULL", | |
118 | desc_haystack, desc_needle, val_haystack); | |
9f589786 DM |
119 | |
120 | const char *test = strstr (val_haystack, val_needle); | |
121 | if (test) | |
96f14006 | 122 | pass (loc, "ASSERT_STR_CONTAINS"); |
9f589786 | 123 | else |
96f14006 | 124 | fail_formatted |
9f589786 DM |
125 | (loc, "ASSERT_STR_CONTAINS (%s, %s) haystack=\"%s\" needle=\"%s\"", |
126 | desc_haystack, desc_needle, val_haystack, val_needle); | |
127 | } | |
128 | ||
d86c7648 ML |
129 | /* Implementation detail of ASSERT_STR_STARTSWITH. |
130 | Determine if VAL_STR starts with VAL_PREFIX. | |
131 | ::selftest::pass if VAL_STR does start with VAL_PREFIX. | |
132 | ::selftest::fail if it does not, or either is NULL (using | |
133 | DESC_STR and DESC_PREFIX in the error message). */ | |
134 | ||
135 | void | |
136 | assert_str_startswith (const location &loc, | |
137 | const char *desc_str, | |
138 | const char *desc_prefix, | |
139 | const char *val_str, | |
140 | const char *val_prefix) | |
141 | { | |
142 | /* If val_str is NULL, fail with a custom error message. */ | |
143 | if (val_str == NULL) | |
144 | fail_formatted (loc, "ASSERT_STR_STARTSWITH (%s, %s) str=NULL", | |
145 | desc_str, desc_prefix); | |
146 | ||
147 | /* If val_prefix is NULL, fail with a custom error message. */ | |
148 | if (val_prefix == NULL) | |
149 | fail_formatted (loc, | |
150 | "ASSERT_STR_STARTSWITH (%s, %s) str=\"%s\" prefix=NULL", | |
151 | desc_str, desc_prefix, val_str); | |
152 | ||
6ba3079d | 153 | if (startswith (val_str, val_prefix)) |
d86c7648 ML |
154 | pass (loc, "ASSERT_STR_STARTSWITH"); |
155 | else | |
156 | fail_formatted | |
157 | (loc, "ASSERT_STR_STARTSWITH (%s, %s) str=\"%s\" prefix=\"%s\"", | |
158 | desc_str, desc_prefix, val_str, val_prefix); | |
159 | } | |
160 | ||
161 | ||
4ecfc453 | 162 | /* Constructor. Generate a name for the file. */ |
eb3a5bcc | 163 | |
1bdd665a DM |
164 | named_temp_file::named_temp_file (const char *suffix, |
165 | file_cache *fc) | |
eb3a5bcc DM |
166 | { |
167 | m_filename = make_temp_file (suffix); | |
168 | ASSERT_NE (m_filename, NULL); | |
1bdd665a | 169 | m_file_cache = fc; |
eb3a5bcc DM |
170 | } |
171 | ||
172 | /* Destructor. Delete the tempfile. */ | |
173 | ||
96f14006 | 174 | named_temp_file::~named_temp_file () |
eb3a5bcc DM |
175 | { |
176 | unlink (m_filename); | |
1bdd665a DM |
177 | if (m_file_cache) |
178 | m_file_cache->forcibly_evict_file (m_filename); | |
eb3a5bcc DM |
179 | free (m_filename); |
180 | } | |
755fa666 | 181 | |
4ecfc453 DM |
182 | /* Constructor. Create a tempfile using SUFFIX, and write CONTENT to |
183 | it. Abort if anything goes wrong, using LOC as the effective | |
184 | location in the problem report. */ | |
185 | ||
96f14006 DM |
186 | temp_source_file::temp_source_file (const location &loc, |
187 | const char *suffix, | |
1bdd665a DM |
188 | const char *content, |
189 | file_cache *fc) | |
190 | : named_temp_file (suffix, fc) | |
4ecfc453 DM |
191 | { |
192 | FILE *out = fopen (get_filename (), "w"); | |
193 | if (!out) | |
96f14006 | 194 | fail_formatted (loc, "unable to open tempfile: %s", get_filename ()); |
4ecfc453 DM |
195 | fprintf (out, "%s", content); |
196 | fclose (out); | |
197 | } | |
198 | ||
bd5e882c DM |
199 | /* As above, but with a size, to allow for NUL bytes in CONTENT. */ |
200 | ||
201 | temp_source_file::temp_source_file (const location &loc, | |
202 | const char *suffix, | |
203 | const char *content, | |
204 | size_t sz) | |
205 | : named_temp_file (suffix) | |
206 | { | |
207 | FILE *out = fopen (get_filename (), "w"); | |
208 | if (!out) | |
209 | fail_formatted (loc, "unable to open tempfile: %s", get_filename ()); | |
210 | fwrite (content, sz, 1, out); | |
211 | fclose (out); | |
212 | } | |
213 | ||
dbf96d49 DM |
214 | /* Avoid introducing locale-specific differences in the results |
215 | by hardcoding open_quote and close_quote. */ | |
216 | ||
217 | auto_fix_quotes::auto_fix_quotes () | |
218 | { | |
219 | m_saved_open_quote = open_quote; | |
220 | m_saved_close_quote = close_quote; | |
221 | open_quote = "`"; | |
222 | close_quote = "'"; | |
223 | } | |
224 | ||
225 | /* Restore old values of open_quote and close_quote. */ | |
226 | ||
227 | auto_fix_quotes::~auto_fix_quotes () | |
228 | { | |
229 | open_quote = m_saved_open_quote; | |
230 | close_quote = m_saved_close_quote; | |
231 | } | |
232 | ||
7d37ffee DM |
233 | /* Read the contents of PATH into memory, returning a 0-terminated buffer |
234 | that must be freed by the caller. | |
235 | Fail (and abort) if there are any problems, with LOC as the reported | |
236 | location of the failure. */ | |
237 | ||
238 | char * | |
239 | read_file (const location &loc, const char *path) | |
240 | { | |
241 | FILE *f_in = fopen (path, "r"); | |
242 | if (!f_in) | |
243 | fail_formatted (loc, "unable to open file: %s", path); | |
244 | ||
245 | /* Read content, allocating FIXME. */ | |
246 | char *result = NULL; | |
247 | size_t total_sz = 0; | |
248 | size_t alloc_sz = 0; | |
249 | char buf[4096]; | |
250 | size_t iter_sz_in; | |
251 | ||
252 | while ( (iter_sz_in = fread (buf, 1, sizeof (buf), f_in)) ) | |
253 | { | |
254 | gcc_assert (alloc_sz >= total_sz); | |
255 | size_t old_total_sz = total_sz; | |
256 | total_sz += iter_sz_in; | |
257 | /* Allow 1 extra byte for 0-termination. */ | |
258 | if (alloc_sz < (total_sz + 1)) | |
259 | { | |
260 | size_t new_alloc_sz = alloc_sz ? alloc_sz * 2: total_sz + 1; | |
261 | result = (char *)xrealloc (result, new_alloc_sz); | |
262 | alloc_sz = new_alloc_sz; | |
263 | } | |
264 | memcpy (result + old_total_sz, buf, iter_sz_in); | |
265 | } | |
266 | ||
267 | if (!feof (f_in)) | |
268 | fail_formatted (loc, "error reading from %s: %s", path, | |
269 | xstrerror (errno)); | |
270 | ||
271 | fclose (f_in); | |
272 | ||
273 | /* 0-terminate the buffer. */ | |
274 | gcc_assert (total_sz < alloc_sz); | |
275 | result[total_sz] = '\0'; | |
276 | ||
277 | return result; | |
278 | } | |
279 | ||
ecfc21ff DM |
280 | /* The path of SRCDIR/testsuite/selftests. */ |
281 | ||
282 | const char *path_to_selftest_files = NULL; | |
283 | ||
284 | /* Convert a path relative to SRCDIR/testsuite/selftests | |
285 | to a real path (either absolute, or relative to pwd). | |
286 | The result should be freed by the caller. */ | |
287 | ||
288 | char * | |
289 | locate_file (const char *name) | |
290 | { | |
291 | ASSERT_NE (NULL, path_to_selftest_files); | |
292 | return concat (path_to_selftest_files, "/", name, NULL); | |
293 | } | |
294 | ||
421b29d6 DM |
295 | /* selftest::test_runner's ctor. */ |
296 | ||
297 | test_runner::test_runner (const char *name) | |
298 | : m_name (name), | |
299 | m_start_time (get_run_time ()) | |
300 | { | |
301 | } | |
302 | ||
303 | /* selftest::test_runner's dtor. Print a summary line to stderr. */ | |
304 | ||
305 | test_runner::~test_runner () | |
306 | { | |
307 | /* Finished running tests. */ | |
308 | long finish_time = get_run_time (); | |
309 | long elapsed_time = finish_time - m_start_time; | |
310 | ||
311 | fprintf (stderr, | |
312 | "%s: %i pass(es) in %ld.%06ld seconds\n", | |
313 | m_name, num_passes, | |
314 | elapsed_time / 1000000, elapsed_time % 1000000); | |
315 | } | |
316 | ||
e613205c DM |
317 | /* Selftests for libiberty. */ |
318 | ||
bf7f70ff | 319 | /* Verify that xstrndup generates EXPECTED when called on SRC and N. */ |
e613205c DM |
320 | |
321 | static void | |
bf7f70ff | 322 | assert_xstrndup_eq (const char *expected, const char *src, size_t n) |
e613205c | 323 | { |
bf7f70ff | 324 | char *buf = xstrndup (src, n); |
e613205c DM |
325 | ASSERT_STREQ (expected, buf); |
326 | free (buf); | |
327 | } | |
328 | ||
bf7f70ff | 329 | /* Verify that xstrndup works as expected. */ |
e613205c DM |
330 | |
331 | static void | |
bf7f70ff | 332 | test_xstrndup () |
e613205c | 333 | { |
bf7f70ff DM |
334 | assert_xstrndup_eq ("", "test", 0); |
335 | assert_xstrndup_eq ("t", "test", 1); | |
336 | assert_xstrndup_eq ("te", "test", 2); | |
337 | assert_xstrndup_eq ("tes", "test", 3); | |
338 | assert_xstrndup_eq ("test", "test", 4); | |
339 | assert_xstrndup_eq ("test", "test", 5); | |
e613205c DM |
340 | |
341 | /* Test on an string without zero termination. */ | |
342 | const char src[4] = {'t', 'e', 's', 't'}; | |
bf7f70ff DM |
343 | assert_xstrndup_eq ("", src, 0); |
344 | assert_xstrndup_eq ("t", src, 1); | |
345 | assert_xstrndup_eq ("te", src, 2); | |
346 | assert_xstrndup_eq ("tes", src, 3); | |
347 | assert_xstrndup_eq ("test", src, 4); | |
e613205c DM |
348 | } |
349 | ||
350 | /* Run selftests for libiberty. */ | |
351 | ||
352 | static void | |
353 | test_libiberty () | |
354 | { | |
bf7f70ff | 355 | test_xstrndup (); |
e613205c DM |
356 | } |
357 | ||
5714dbda DM |
358 | /* Selftests for the selftest system itself. */ |
359 | ||
5714dbda DM |
360 | /* Sanity-check the ASSERT_ macros with various passing cases. */ |
361 | ||
362 | static void | |
363 | test_assertions () | |
364 | { | |
365 | ASSERT_TRUE (true); | |
366 | ASSERT_FALSE (false); | |
367 | ASSERT_EQ (1, 1); | |
368 | ASSERT_EQ_AT (SELFTEST_LOCATION, 1, 1); | |
369 | ASSERT_NE (1, 2); | |
082284da DM |
370 | ASSERT_GT (2, 1); |
371 | ASSERT_GT_AT (SELFTEST_LOCATION, 2, 1); | |
372 | ASSERT_LT (1, 2); | |
373 | ASSERT_LT_AT (SELFTEST_LOCATION, 1, 2); | |
5714dbda DM |
374 | ASSERT_STREQ ("test", "test"); |
375 | ASSERT_STREQ_AT (SELFTEST_LOCATION, "test", "test"); | |
9f589786 | 376 | ASSERT_STR_CONTAINS ("foo bar baz", "bar"); |
5714dbda DM |
377 | } |
378 | ||
4ecfc453 DM |
379 | /* Verify named_temp_file. */ |
380 | ||
381 | static void | |
382 | test_named_temp_file () | |
383 | { | |
384 | named_temp_file t (".txt"); | |
385 | FILE *f = fopen (t.get_filename (), "w"); | |
386 | if (!f) | |
96f14006 DM |
387 | fail_formatted (SELFTEST_LOCATION, |
388 | "unable to open %s for writing", t.get_filename ()); | |
4ecfc453 DM |
389 | fclose (f); |
390 | } | |
391 | ||
7d37ffee DM |
392 | /* Verify read_file (and also temp_source_file). */ |
393 | ||
394 | static void | |
395 | test_read_file () | |
396 | { | |
397 | temp_source_file t (SELFTEST_LOCATION, "test1.s", | |
398 | "\tjmp\t.L2\n"); | |
399 | char *buf = read_file (SELFTEST_LOCATION, t.get_filename ()); | |
400 | ASSERT_STREQ ("\tjmp\t.L2\n", buf); | |
401 | free (buf); | |
402 | } | |
403 | ||
ecfc21ff DM |
404 | /* Verify locate_file (and read_file). */ |
405 | ||
406 | static void | |
407 | test_locate_file () | |
408 | { | |
409 | char *path = locate_file ("example.txt"); | |
410 | char *buf = read_file (SELFTEST_LOCATION, path); | |
411 | ASSERT_STREQ ("example of a selftest file\n", buf); | |
412 | free (buf); | |
413 | free (path); | |
414 | } | |
415 | ||
5714dbda DM |
416 | /* Run all of the selftests within this file. */ |
417 | ||
418 | void | |
d5148d4f | 419 | selftest_cc_tests () |
5714dbda | 420 | { |
e613205c | 421 | test_libiberty (); |
5714dbda | 422 | test_assertions (); |
4ecfc453 | 423 | test_named_temp_file (); |
7d37ffee | 424 | test_read_file (); |
ecfc21ff | 425 | test_locate_file (); |
5714dbda DM |
426 | } |
427 | ||
428 | } // namespace selftest | |
429 | ||
d9b950dd | 430 | #endif /* #if CHECKING_P */ |