|
111
|
1 /* A self-testing framework, for use by -fself-test.
|
|
|
2 Copyright (C) 2015-2017 Free Software Foundation, Inc.
|
|
|
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 #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
|
|
|
28 namespace selftest {
|
|
|
29
|
|
|
30 /* A struct describing the source-location of a selftest, to make it
|
|
|
31 easier to track down failing tests. */
|
|
|
32
|
|
|
33 struct 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
|
|
|
51 extern void run_tests ();
|
|
|
52
|
|
|
53 /* Record the successful outcome of some aspect of the test. */
|
|
|
54
|
|
|
55 extern void pass (const location &loc, const char *msg);
|
|
|
56
|
|
|
57 /* Report the failed outcome of some aspect of the test and abort. */
|
|
|
58
|
|
|
59 extern void fail (const location &loc, const char *msg)
|
|
|
60 ATTRIBUTE_NORETURN;
|
|
|
61
|
|
|
62 /* As "fail", but using printf-style formatted output. */
|
|
|
63
|
|
|
64 extern void fail_formatted (const location &loc, const char *fmt, ...)
|
|
|
65 ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
|
|
|
66
|
|
|
67 /* Implementation detail of ASSERT_STREQ. */
|
|
|
68
|
|
|
69 extern 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
|
|
|
75 extern 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
|
|
|
86 class 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
|
|
|
100 class 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
|
|
|
123 struct 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
|
|
|
130 class 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
|
|
|
146 extern void
|
|
|
147 for_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
|
|
|
154 extern 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
|
|
|
159 extern 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
|
|
|
165 extern char *locate_file (const char *path);
|
|
|
166
|
|
|
167 /* The path of SRCDIR/testsuite/selftests. */
|
|
|
168
|
|
|
169 extern const char *path_to_selftest_files;
|
|
|
170
|
|
|
171 /* Declarations for specific families of tests (by source file), in
|
|
|
172 alphabetical order. */
|
|
|
173 extern void bitmap_c_tests ();
|
|
|
174 extern void sbitmap_c_tests ();
|
|
|
175 extern void diagnostic_c_tests ();
|
|
|
176 extern void diagnostic_show_locus_c_tests ();
|
|
|
177 extern void edit_context_c_tests ();
|
|
|
178 extern void et_forest_c_tests ();
|
|
|
179 extern void fold_const_c_tests ();
|
|
|
180 extern void fibonacci_heap_c_tests ();
|
|
|
181 extern void function_tests_c_tests ();
|
|
|
182 extern void gimple_c_tests ();
|
|
|
183 extern void ggc_tests_c_tests ();
|
|
|
184 extern void hash_map_tests_c_tests ();
|
|
|
185 extern void hash_set_tests_c_tests ();
|
|
|
186 extern void input_c_tests ();
|
|
|
187 extern void pretty_print_c_tests ();
|
|
|
188 extern void read_rtl_function_c_tests ();
|
|
|
189 extern void rtl_tests_c_tests ();
|
|
|
190 extern void selftest_c_tests ();
|
|
|
191 extern void spellcheck_c_tests ();
|
|
|
192 extern void spellcheck_tree_c_tests ();
|
|
|
193 extern void sreal_c_tests ();
|
|
|
194 extern void store_merging_c_tests ();
|
|
|
195 extern void typed_splay_tree_c_tests ();
|
|
|
196 extern void tree_c_tests ();
|
|
|
197 extern void tree_cfg_c_tests ();
|
|
|
198 extern void unique_ptr_tests_cc_tests ();
|
|
|
199 extern void vec_c_tests ();
|
|
|
200 extern void wide_int_cc_tests ();
|
|
|
201 extern void predict_c_tests ();
|
|
|
202
|
|
|
203 extern int num_passes;
|
|
|
204
|
|
|
205 } /* end of namespace selftest. */
|
|
|
206
|
|
|
207 /* Macros for writing tests. */
|
|
|
208
|
|
|
209 /* Evaluate EXPR and coerce to bool, calling
|
|
|
210 ::selftest::pass if it is true,
|
|
|
211 ::selftest::fail if it false. */
|
|
|
212
|
|
|
213 #define ASSERT_TRUE(EXPR) \
|
|
|
214 ASSERT_TRUE_AT (SELFTEST_LOCATION, (EXPR))
|
|
|
215
|
|
|
216 /* Like ASSERT_TRUE, but treat LOC as the effective location of the
|
|
|
217 selftest. */
|
|
|
218
|
|
|
219 #define ASSERT_TRUE_AT(LOC, EXPR) \
|
|
|
220 SELFTEST_BEGIN_STMT \
|
|
|
221 const char *desc = "ASSERT_TRUE (" #EXPR ")"; \
|
|
|
222 bool actual = (EXPR); \
|
|
|
223 if (actual) \
|
|
|
224 ::selftest::pass ((LOC), desc); \
|
|
|
225 else \
|
|
|
226 ::selftest::fail ((LOC), desc); \
|
|
|
227 SELFTEST_END_STMT
|
|
|
228
|
|
|
229 /* Evaluate EXPR and coerce to bool, calling
|
|
|
230 ::selftest::pass if it is false,
|
|
|
231 ::selftest::fail if it true. */
|
|
|
232
|
|
|
233 #define ASSERT_FALSE(EXPR) \
|
|
|
234 ASSERT_FALSE_AT (SELFTEST_LOCATION, (EXPR))
|
|
|
235
|
|
|
236 /* Like ASSERT_FALSE, but treat LOC as the effective location of the
|
|
|
237 selftest. */
|
|
|
238
|
|
|
239 #define ASSERT_FALSE_AT(LOC, EXPR) \
|
|
|
240 SELFTEST_BEGIN_STMT \
|
|
|
241 const char *desc = "ASSERT_FALSE (" #EXPR ")"; \
|
|
|
242 bool actual = (EXPR); \
|
|
|
243 if (actual) \
|
|
|
244 ::selftest::fail ((LOC), desc); \
|
|
|
245 else \
|
|
|
246 ::selftest::pass ((LOC), desc); \
|
|
|
247 SELFTEST_END_STMT
|
|
|
248
|
|
|
249 /* Evaluate EXPECTED and ACTUAL and compare them with ==, calling
|
|
|
250 ::selftest::pass if they are equal,
|
|
|
251 ::selftest::fail if they are non-equal. */
|
|
|
252
|
|
|
253 #define ASSERT_EQ(EXPECTED, ACTUAL) \
|
|
|
254 ASSERT_EQ_AT ((SELFTEST_LOCATION), (EXPECTED), (ACTUAL))
|
|
|
255
|
|
|
256 /* Like ASSERT_EQ, but treat LOC as the effective location of the
|
|
|
257 selftest. */
|
|
|
258
|
|
|
259 #define ASSERT_EQ_AT(LOC, EXPECTED, ACTUAL) \
|
|
|
260 SELFTEST_BEGIN_STMT \
|
|
|
261 const char *desc = "ASSERT_EQ (" #EXPECTED ", " #ACTUAL ")"; \
|
|
|
262 if ((EXPECTED) == (ACTUAL)) \
|
|
|
263 ::selftest::pass ((LOC), desc); \
|
|
|
264 else \
|
|
|
265 ::selftest::fail ((LOC), desc); \
|
|
|
266 SELFTEST_END_STMT
|
|
|
267
|
|
|
268 /* Evaluate EXPECTED and ACTUAL and compare them with !=, calling
|
|
|
269 ::selftest::pass if they are non-equal,
|
|
|
270 ::selftest::fail if they are equal. */
|
|
|
271
|
|
|
272 #define ASSERT_NE(EXPECTED, ACTUAL) \
|
|
|
273 SELFTEST_BEGIN_STMT \
|
|
|
274 const char *desc = "ASSERT_NE (" #EXPECTED ", " #ACTUAL ")"; \
|
|
|
275 if ((EXPECTED) != (ACTUAL)) \
|
|
|
276 ::selftest::pass (SELFTEST_LOCATION, desc); \
|
|
|
277 else \
|
|
|
278 ::selftest::fail (SELFTEST_LOCATION, desc); \
|
|
|
279 SELFTEST_END_STMT
|
|
|
280
|
|
|
281 /* Evaluate EXPECTED and ACTUAL and compare them with strcmp, calling
|
|
|
282 ::selftest::pass if they are equal,
|
|
|
283 ::selftest::fail if they are non-equal. */
|
|
|
284
|
|
|
285 #define ASSERT_STREQ(EXPECTED, ACTUAL) \
|
|
|
286 SELFTEST_BEGIN_STMT \
|
|
|
287 ::selftest::assert_streq (SELFTEST_LOCATION, #EXPECTED, #ACTUAL, \
|
|
|
288 (EXPECTED), (ACTUAL)); \
|
|
|
289 SELFTEST_END_STMT
|
|
|
290
|
|
|
291 /* Like ASSERT_STREQ, but treat LOC as the effective location of the
|
|
|
292 selftest. */
|
|
|
293
|
|
|
294 #define ASSERT_STREQ_AT(LOC, EXPECTED, ACTUAL) \
|
|
|
295 SELFTEST_BEGIN_STMT \
|
|
|
296 ::selftest::assert_streq ((LOC), #EXPECTED, #ACTUAL, \
|
|
|
297 (EXPECTED), (ACTUAL)); \
|
|
|
298 SELFTEST_END_STMT
|
|
|
299
|
|
|
300 /* Evaluate HAYSTACK and NEEDLE and use strstr to determine if NEEDLE
|
|
|
301 is within HAYSTACK.
|
|
|
302 ::selftest::pass if NEEDLE is found.
|
|
|
303 ::selftest::fail if it is not found. */
|
|
|
304
|
|
|
305 #define ASSERT_STR_CONTAINS(HAYSTACK, NEEDLE) \
|
|
|
306 SELFTEST_BEGIN_STMT \
|
|
|
307 ::selftest::assert_str_contains (SELFTEST_LOCATION, #HAYSTACK, #NEEDLE, \
|
|
|
308 (HAYSTACK), (NEEDLE)); \
|
|
|
309 SELFTEST_END_STMT
|
|
|
310
|
|
|
311 /* Evaluate PRED1 (VAL1), calling ::selftest::pass if it is true,
|
|
|
312 ::selftest::fail if it is false. */
|
|
|
313
|
|
|
314 #define ASSERT_PRED1(PRED1, VAL1) \
|
|
|
315 SELFTEST_BEGIN_STMT \
|
|
|
316 const char *desc = "ASSERT_PRED1 (" #PRED1 ", " #VAL1 ")"; \
|
|
|
317 bool actual = (PRED1) (VAL1); \
|
|
|
318 if (actual) \
|
|
|
319 ::selftest::pass (SELFTEST_LOCATION, desc); \
|
|
|
320 else \
|
|
|
321 ::selftest::fail (SELFTEST_LOCATION, desc); \
|
|
|
322 SELFTEST_END_STMT
|
|
|
323
|
|
|
324 #define SELFTEST_BEGIN_STMT do {
|
|
|
325 #define SELFTEST_END_STMT } while (0)
|
|
|
326
|
|
|
327 #endif /* #if CHECKING_P */
|
|
|
328
|
|
|
329 #endif /* GCC_SELFTEST_H */
|
