1 /* A self-testing framework, for use by -fself-test.
2 Copyright (C) 2015-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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/>. */
20 #ifndef GCC_SELFTEST_H
21 #define GCC_SELFTEST_H
23 /* The selftest code should entirely disappear in a production
24 configuration, hence we guard all of it with #if CHECKING_P. */
30 /* A struct describing the source-location of a selftest, to make it
31 easier to track down failing tests. */
35 location (const char *file
, int line
, const char *function
)
36 : m_file (file
), m_line (line
), m_function (function
) {}
40 const char *m_function
;
43 /* A macro for use in selftests and by the ASSERT_ macros below,
44 constructing a selftest::location for the current source location. */
46 #define SELFTEST_LOCATION \
47 (::selftest::location (__FILE__, __LINE__, __FUNCTION__))
49 /* The entrypoint for running all tests. */
51 extern void run_tests ();
53 /* Record the successful outcome of some aspect of the test. */
55 extern void pass (const location
&loc
, const char *msg
);
57 /* Report the failed outcome of some aspect of the test and abort. */
59 extern void fail (const location
&loc
, const char *msg
)
62 /* As "fail", but using printf-style formatted output. */
64 extern void fail_formatted (const location
&loc
, const char *fmt
, ...)
65 ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN
;
67 /* Implementation detail of ASSERT_STREQ. */
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
);
73 /* Implementation detail of ASSERT_STR_CONTAINS. */
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
);
81 /* A named temporary file for use in selftests.
82 Usable for writing out files, and as the base class for
84 The file is unlinked in the destructor. */
89 named_temp_file (const char *suffix
);
91 const char *get_filename () const { return m_filename
; }
97 /* A class for writing out a temporary sourcefile for use in selftests
100 class temp_source_file
: public named_temp_file
103 temp_source_file (const location
&loc
, const char *suffix
,
104 const char *content
);
107 /* Various selftests involving location-handling require constructing a
108 line table and one or more line maps within it.
110 For maximum test coverage we want to run these tests with a variety
112 - line_table->default_range_bits: some frontends use a non-zero value
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.
120 The following struct describes a particular case within our test
123 struct line_table_case
;
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. */
130 class line_table_test
133 /* Default constructor. Override "line_table", using sane defaults
134 for the temporary line_table. */
137 /* Constructor. Override "line_table", using the case described by C. */
138 line_table_test (const line_table_case
&c
);
140 /* Destructor. Restore the saved line_table. */
144 /* Run TESTCASE multiple times, once for each case in our test matrix. */
147 for_each_line_table_case (void (*testcase
) (const line_table_case
&));
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. */
154 extern char *read_file (const location
&loc
, const char *path
);
156 /* A helper function for writing tests that interact with the
157 garbage collector. */
159 extern void forcibly_ggc_collect ();
161 /* Declarations for specific families of tests (by source file), in
162 alphabetical order. */
163 extern void bitmap_c_tests ();
164 extern void diagnostic_c_tests ();
165 extern void diagnostic_show_locus_c_tests ();
166 extern void edit_context_c_tests ();
167 extern void et_forest_c_tests ();
168 extern void fold_const_c_tests ();
169 extern void fibonacci_heap_c_tests ();
170 extern void function_tests_c_tests ();
171 extern void gimple_c_tests ();
172 extern void ggc_tests_c_tests ();
173 extern void hash_map_tests_c_tests ();
174 extern void hash_set_tests_c_tests ();
175 extern void input_c_tests ();
176 extern void pretty_print_c_tests ();
177 extern void rtl_tests_c_tests ();
178 extern void selftest_c_tests ();
179 extern void spellcheck_c_tests ();
180 extern void spellcheck_tree_c_tests ();
181 extern void sreal_c_tests ();
182 extern void store_merging_c_tests ();
183 extern void typed_splay_tree_c_tests ();
184 extern void tree_c_tests ();
185 extern void tree_cfg_c_tests ();
186 extern void vec_c_tests ();
187 extern void wide_int_cc_tests ();
189 extern int num_passes
;
191 } /* end of namespace selftest. */
193 /* Macros for writing tests. */
195 /* Evaluate EXPR and coerce to bool, calling
196 ::selftest::pass if it is true,
197 ::selftest::fail if it false. */
199 #define ASSERT_TRUE(EXPR) \
200 ASSERT_TRUE_AT (SELFTEST_LOCATION, (EXPR))
202 /* Like ASSERT_TRUE, but treat LOC as the effective location of the
205 #define ASSERT_TRUE_AT(LOC, EXPR) \
206 SELFTEST_BEGIN_STMT \
207 const char *desc = "ASSERT_TRUE (" #EXPR ")"; \
208 bool actual = (EXPR); \
210 ::selftest::pass ((LOC), desc); \
212 ::selftest::fail ((LOC), desc); \
215 /* Evaluate EXPR and coerce to bool, calling
216 ::selftest::pass if it is false,
217 ::selftest::fail if it true. */
219 #define ASSERT_FALSE(EXPR) \
220 ASSERT_FALSE_AT (SELFTEST_LOCATION, (EXPR))
222 /* Like ASSERT_FALSE, but treat LOC as the effective location of the
225 #define ASSERT_FALSE_AT(LOC, EXPR) \
226 SELFTEST_BEGIN_STMT \
227 const char *desc = "ASSERT_FALSE (" #EXPR ")"; \
228 bool actual = (EXPR); \
230 ::selftest::fail ((LOC), desc); \
232 ::selftest::pass ((LOC), desc); \
235 /* Evaluate EXPECTED and ACTUAL and compare them with ==, calling
236 ::selftest::pass if they are equal,
237 ::selftest::fail if they are non-equal. */
239 #define ASSERT_EQ(EXPECTED, ACTUAL) \
240 ASSERT_EQ_AT ((SELFTEST_LOCATION), (EXPECTED), (ACTUAL))
242 /* Like ASSERT_EQ, but treat LOC as the effective location of the
245 #define ASSERT_EQ_AT(LOC, EXPECTED, ACTUAL) \
246 SELFTEST_BEGIN_STMT \
247 const char *desc = "ASSERT_EQ (" #EXPECTED ", " #ACTUAL ")"; \
248 if ((EXPECTED) == (ACTUAL)) \
249 ::selftest::pass ((LOC), desc); \
251 ::selftest::fail ((LOC), desc); \
254 /* Evaluate EXPECTED and ACTUAL and compare them with !=, calling
255 ::selftest::pass if they are non-equal,
256 ::selftest::fail if they are equal. */
258 #define ASSERT_NE(EXPECTED, ACTUAL) \
259 SELFTEST_BEGIN_STMT \
260 const char *desc = "ASSERT_NE (" #EXPECTED ", " #ACTUAL ")"; \
261 if ((EXPECTED) != (ACTUAL)) \
262 ::selftest::pass (SELFTEST_LOCATION, desc); \
264 ::selftest::fail (SELFTEST_LOCATION, desc); \
267 /* Evaluate EXPECTED and ACTUAL and compare them with strcmp, calling
268 ::selftest::pass if they are equal,
269 ::selftest::fail if they are non-equal. */
271 #define ASSERT_STREQ(EXPECTED, ACTUAL) \
272 SELFTEST_BEGIN_STMT \
273 ::selftest::assert_streq (SELFTEST_LOCATION, #EXPECTED, #ACTUAL, \
274 (EXPECTED), (ACTUAL)); \
277 /* Like ASSERT_STREQ, but treat LOC as the effective location of the
280 #define ASSERT_STREQ_AT(LOC, EXPECTED, ACTUAL) \
281 SELFTEST_BEGIN_STMT \
282 ::selftest::assert_streq ((LOC), #EXPECTED, #ACTUAL, \
283 (EXPECTED), (ACTUAL)); \
286 /* Evaluate HAYSTACK and NEEDLE and use strstr to determine if NEEDLE
288 ::selftest::pass if NEEDLE is found.
289 ::selftest::fail if it is not found. */
291 #define ASSERT_STR_CONTAINS(HAYSTACK, NEEDLE) \
292 SELFTEST_BEGIN_STMT \
293 ::selftest::assert_str_contains (SELFTEST_LOCATION, #HAYSTACK, #NEEDLE, \
294 (HAYSTACK), (NEEDLE)); \
297 /* Evaluate PRED1 (VAL1), calling ::selftest::pass if it is true,
298 ::selftest::fail if it is false. */
300 #define ASSERT_PRED1(PRED1, VAL1) \
301 SELFTEST_BEGIN_STMT \
302 const char *desc = "ASSERT_PRED1 (" #PRED1 ", " #VAL1 ")"; \
303 bool actual = (PRED1) (VAL1); \
305 ::selftest::pass (SELFTEST_LOCATION, desc); \
307 ::selftest::fail (SELFTEST_LOCATION, desc); \
310 #define SELFTEST_BEGIN_STMT do {
311 #define SELFTEST_END_STMT } while (0)
313 #endif /* #if CHECKING_P */
315 #endif /* GCC_SELFTEST_H */