1/* A self-testing framework, for use by -fself-test.
2 Copyright (C) 2015-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#ifndef GCC_SELFTEST_H
21#define GCC_SELFTEST_H
22
23/* The selftest code should entirely disappear in a production
24 configuration, hence we guard all of it with #if CHECKING_P. */
25
26#if CHECKING_P
27
28namespace selftest {
29
30/* A struct describing the source-location of a selftest, to make it
31 easier to track down failing tests. */
32
33struct location
34{
35 location (const char *file, int line, const char *function)
36 : m_file (file), m_line (line), m_function (function) {}
37
38 const char *m_file;
39 int m_line;
40 const char *m_function;
41};
42
43/* A macro for use in selftests and by the ASSERT_ macros below,
44 constructing a selftest::location for the current source location. */
45
46#define SELFTEST_LOCATION \
47 (::selftest::location (__FILE__, __LINE__, __FUNCTION__))
48
49/* The entrypoint for running all tests. */
50
51extern void run_tests ();
52
53/* Record the successful outcome of some aspect of the test. */
54
55extern void pass (const location &loc, const char *msg);
56
57/* Report the failed outcome of some aspect of the test and abort. */
58
59extern void fail (const location &loc, const char *msg)
60 ATTRIBUTE_NORETURN;
61
62/* As "fail", but using printf-style formatted output. */
63
64extern void fail_formatted (const location &loc, const char *fmt, ...)
65 ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
66
67/* Implementation detail of ASSERT_STREQ. */
68
69extern void assert_streq (const location &loc,
70 const char *desc_expected, const char *desc_actual,
71 const char *val_expected, const char *val_actual);
72
73/* Implementation detail of ASSERT_STR_CONTAINS. */
74
75extern void assert_str_contains (const location &loc,
76 const char *desc_haystack,
77 const char *desc_needle,
78 const char *val_haystack,
79 const char *val_needle);
80
81/* A named temporary file for use in selftests.
82 Usable for writing out files, and as the base class for
83 temp_source_file.
84 The file is unlinked in the destructor. */
85
86class named_temp_file
87{
88 public:
89 named_temp_file (const char *suffix);
90 ~named_temp_file ();
91 const char *get_filename () const { return m_filename; }
92
93 private:
94 char *m_filename;
95};
96
97/* A class for writing out a temporary sourcefile for use in selftests
98 of input handling. */
99
100class temp_source_file : public named_temp_file
101{
102 public:
103 temp_source_file (const location &loc, const char *suffix,
104 const char *content);
105};
106
107/* Various selftests involving location-handling require constructing a
108 line table and one or more line maps within it.
109
110 For maximum test coverage we want to run these tests with a variety
111 of situations:
112 - line_table->default_range_bits: some frontends use a non-zero value
113 and others use zero
114 - the fallback modes within line-map.c: there are various threshold
115 values for source_location/location_t beyond line-map.c changes
116 behavior (disabling of the range-packing optimization, disabling
117 of column-tracking). We can exercise these by starting the line_table
118 at interesting values at or near these thresholds.
119
120 The following struct describes a particular case within our test
121 matrix. */
122
123struct line_table_case;
124
125/* A class for overriding the global "line_table" within a selftest,
126 restoring its value afterwards. At most one instance of this
127 class can exist at once, due to the need to keep the old value
128 of line_table as a GC root. */
129
130class line_table_test
131{
132 public:
133 /* Default constructor. Override "line_table", using sane defaults
134 for the temporary line_table. */
135 line_table_test ();
136
137 /* Constructor. Override "line_table", using the case described by C. */
138 line_table_test (const line_table_case &c);
139
140 /* Destructor. Restore the saved line_table. */
141 ~line_table_test ();
142};
143
144/* Run TESTCASE multiple times, once for each case in our test matrix. */
145
146extern void
147for_each_line_table_case (void (*testcase) (const line_table_case &));
148
149/* Read the contents of PATH into memory, returning a 0-terminated buffer
150 that must be freed by the caller.
151 Fail (and abort) if there are any problems, with LOC as the reported
152 location of the failure. */
153
154extern char *read_file (const location &loc, const char *path);
155
156/* A helper function for writing tests that interact with the
157 garbage collector. */
158
159extern void forcibly_ggc_collect ();
160
161/* Convert a path relative to SRCDIR/gcc/testsuite/selftests
162 to a real path (either absolute, or relative to pwd).
163 The result should be freed by the caller. */
164
165extern char *locate_file (const char *path);
166
167/* The path of SRCDIR/testsuite/selftests. */
168
169extern const char *path_to_selftest_files;
170
171/* selftest::test_runner is an implementation detail of selftest::run_tests,
172 exposed here to allow plugins to run their own suites of tests. */
173
174class test_runner
175{
176 public:
177 test_runner (const char *name);
178 ~test_runner ();
179
180 private:
181 const char *m_name;
182 long m_start_time;
183};
184
185/* Declarations for specific families of tests (by source file), in
186 alphabetical order. */
187extern void attribute_c_tests ();
188extern void bitmap_c_tests ();
189extern void sbitmap_c_tests ();
190extern void diagnostic_c_tests ();
191extern void diagnostic_show_locus_c_tests ();
192extern void edit_context_c_tests ();
193extern void et_forest_c_tests ();
194extern void fold_const_c_tests ();
195extern void fibonacci_heap_c_tests ();
196extern void function_tests_c_tests ();
197extern void gimple_c_tests ();
198extern void ggc_tests_c_tests ();
199extern void hash_map_tests_c_tests ();
200extern void hash_set_tests_c_tests ();
201extern void input_c_tests ();
202extern void pretty_print_c_tests ();
203extern void read_rtl_function_c_tests ();
204extern void rtl_tests_c_tests ();
205extern void selftest_c_tests ();
206extern void spellcheck_c_tests ();
207extern void spellcheck_tree_c_tests ();
208extern void sreal_c_tests ();
209extern void store_merging_c_tests ();
210extern void typed_splay_tree_c_tests ();
211extern void tree_c_tests ();
212extern void tree_cfg_c_tests ();
213extern void unique_ptr_tests_cc_tests ();
214extern void vec_c_tests ();
215extern void wide_int_cc_tests ();
216extern void predict_c_tests ();
217extern void simplify_rtx_c_tests ();
218
219extern int num_passes;
220
221} /* end of namespace selftest. */
222
223/* Macros for writing tests. */
224
225/* Evaluate EXPR and coerce to bool, calling
226 ::selftest::pass if it is true,
227 ::selftest::fail if it false. */
228
229#define ASSERT_TRUE(EXPR) \
230 ASSERT_TRUE_AT (SELFTEST_LOCATION, (EXPR))
231
232/* Like ASSERT_TRUE, but treat LOC as the effective location of the
233 selftest. */
234
235#define ASSERT_TRUE_AT(LOC, EXPR) \
236 SELFTEST_BEGIN_STMT \
237 const char *desc_ = "ASSERT_TRUE (" #EXPR ")"; \
238 bool actual_ = (EXPR); \
239 if (actual_) \
240 ::selftest::pass ((LOC), desc_); \
241 else \
242 ::selftest::fail ((LOC), desc_); \
243 SELFTEST_END_STMT
244
245/* Evaluate EXPR and coerce to bool, calling
246 ::selftest::pass if it is false,
247 ::selftest::fail if it true. */
248
249#define ASSERT_FALSE(EXPR) \
250 ASSERT_FALSE_AT (SELFTEST_LOCATION, (EXPR))
251
252/* Like ASSERT_FALSE, but treat LOC as the effective location of the
253 selftest. */
254
255#define ASSERT_FALSE_AT(LOC, EXPR) \
256 SELFTEST_BEGIN_STMT \
257 const char *desc_ = "ASSERT_FALSE (" #EXPR ")"; \
258 bool actual_ = (EXPR); \
259 if (actual_) \
260 ::selftest::fail ((LOC), desc_); \
261 else \
262 ::selftest::pass ((LOC), desc_); \
263 SELFTEST_END_STMT
264
265/* Evaluate EXPECTED and ACTUAL and compare them with ==, calling
266 ::selftest::pass if they are equal,
267 ::selftest::fail if they are non-equal. */
268
269#define ASSERT_EQ(EXPECTED, ACTUAL) \
270 ASSERT_EQ_AT ((SELFTEST_LOCATION), (EXPECTED), (ACTUAL))
271
272/* Like ASSERT_EQ, but treat LOC as the effective location of the
273 selftest. */
274
275#define ASSERT_EQ_AT(LOC, EXPECTED, ACTUAL) \
276 SELFTEST_BEGIN_STMT \
277 const char *desc_ = "ASSERT_EQ (" #EXPECTED ", " #ACTUAL ")"; \
278 if ((EXPECTED) == (ACTUAL)) \
279 ::selftest::pass ((LOC), desc_); \
280 else \
281 ::selftest::fail ((LOC), desc_); \
282 SELFTEST_END_STMT
283
284/* Evaluate EXPECTED and ACTUAL and compare them with !=, calling
285 ::selftest::pass if they are non-equal,
286 ::selftest::fail if they are equal. */
287
288#define ASSERT_NE(EXPECTED, ACTUAL) \
289 SELFTEST_BEGIN_STMT \
290 const char *desc_ = "ASSERT_NE (" #EXPECTED ", " #ACTUAL ")"; \
291 if ((EXPECTED) != (ACTUAL)) \
292 ::selftest::pass (SELFTEST_LOCATION, desc_); \
293 else \
294 ::selftest::fail (SELFTEST_LOCATION, desc_); \
295 SELFTEST_END_STMT
296
297/* Evaluate EXPECTED and ACTUAL and compare them with strcmp, calling
298 ::selftest::pass if they are equal,
299 ::selftest::fail if they are non-equal. */
300
301#define ASSERT_STREQ(EXPECTED, ACTUAL) \
302 SELFTEST_BEGIN_STMT \
303 ::selftest::assert_streq (SELFTEST_LOCATION, #EXPECTED, #ACTUAL, \
304 (EXPECTED), (ACTUAL)); \
305 SELFTEST_END_STMT
306
307/* Like ASSERT_STREQ, but treat LOC as the effective location of the
308 selftest. */
309
310#define ASSERT_STREQ_AT(LOC, EXPECTED, ACTUAL) \
311 SELFTEST_BEGIN_STMT \
312 ::selftest::assert_streq ((LOC), #EXPECTED, #ACTUAL, \
313 (EXPECTED), (ACTUAL)); \
314 SELFTEST_END_STMT
315
316/* Evaluate HAYSTACK and NEEDLE and use strstr to determine if NEEDLE
317 is within HAYSTACK.
318 ::selftest::pass if NEEDLE is found.
319 ::selftest::fail if it is not found. */
320
321#define ASSERT_STR_CONTAINS(HAYSTACK, NEEDLE) \
322 SELFTEST_BEGIN_STMT \
323 ::selftest::assert_str_contains (SELFTEST_LOCATION, #HAYSTACK, #NEEDLE, \
324 (HAYSTACK), (NEEDLE)); \
325 SELFTEST_END_STMT
326
327/* Evaluate PRED1 (VAL1), calling ::selftest::pass if it is true,
328 ::selftest::fail if it is false. */
329
330#define ASSERT_PRED1(PRED1, VAL1) \
331 SELFTEST_BEGIN_STMT \
332 const char *desc_ = "ASSERT_PRED1 (" #PRED1 ", " #VAL1 ")"; \
333 bool actual_ = (PRED1) (VAL1); \
334 if (actual_) \
335 ::selftest::pass (SELFTEST_LOCATION, desc_); \
336 else \
337 ::selftest::fail (SELFTEST_LOCATION, desc_); \
338 SELFTEST_END_STMT
339
340#define SELFTEST_BEGIN_STMT do {
341#define SELFTEST_END_STMT } while (0)
342
343#endif /* #if CHECKING_P */
344
345#endif /* GCC_SELFTEST_H */
346