[thirdparty/gcc.git] / gcc / selftest.h

/* A self-testing framework, for use by -fself-test.
   Copyright (C) 2015-2017 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#ifndef GCC_SELFTEST_H
#define GCC_SELFTEST_H

/* The selftest code should entirely disappear in a production
   configuration, hence we guard all of it with #if CHECKING_P.  */

#if CHECKING_P

namespace selftest {

/* A struct describing the source-location of a selftest, to make it
   easier to track down failing tests.  */

struct location
{
  location (const char *file, int line, const char *function)
    : m_file (file), m_line (line), m_function (function) {}

  const char *m_file;
  int m_line;
  const char *m_function;
};

/* A macro for use in selftests and by the ASSERT_ macros below,
   constructing a selftest::location for the current source location.  */

#define SELFTEST_LOCATION \
  (::selftest::location (__FILE__, __LINE__, __FUNCTION__))

/* The entrypoint for running all tests.  */

extern void run_tests ();

/* Record the successful outcome of some aspect of the test.  */

extern void pass (const location &loc, const char *msg);

/* Report the failed outcome of some aspect of the test and abort.  */

extern void fail (const location &loc, const char *msg)
  ATTRIBUTE_NORETURN;

/* As "fail", but using printf-style formatted output.  */

extern void fail_formatted (const location &loc, const char *fmt, ...)
  ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;

/* Implementation detail of ASSERT_STREQ.  */

extern void assert_streq (const location &loc,
			  const char *desc_expected, const char *desc_actual,
			  const char *val_expected, const char *val_actual);

/* Implementation detail of ASSERT_STR_CONTAINS.  */

extern void assert_str_contains (const location &loc,
				 const char *desc_haystack,
				 const char *desc_needle,
				 const char *val_haystack,
				 const char *val_needle);

/* A named temporary file for use in selftests.
   Usable for writing out files, and as the base class for
   temp_source_file.
   The file is unlinked in the destructor.  */

class named_temp_file
{
 public:
  named_temp_file (const char *suffix);
  ~named_temp_file ();
  const char *get_filename () const { return m_filename; }

 private:
  char *m_filename;
};

/* A class for writing out a temporary sourcefile for use in selftests
   of input handling.  */

class temp_source_file : public named_temp_file
{
 public:
  temp_source_file (const location &loc, const char *suffix,
		    const char *content);
};

/* Various selftests involving location-handling require constructing a
   line table and one or more line maps within it.

   For maximum test coverage we want to run these tests with a variety
   of situations:
   - line_table->default_range_bits: some frontends use a non-zero value
   and others use zero
   - the fallback modes within line-map.c: there are various threshold
   values for source_location/location_t beyond line-map.c changes
   behavior (disabling of the range-packing optimization, disabling
   of column-tracking).  We can exercise these by starting the line_table
   at interesting values at or near these thresholds.

   The following struct describes a particular case within our test
   matrix.  */

struct line_table_case;

/* A class for overriding the global "line_table" within a selftest,
   restoring its value afterwards.  At most one instance of this
   class can exist at once, due to the need to keep the old value
   of line_table as a GC root.  */

class line_table_test
{
 public:
  /* Default constructor.  Override "line_table", using sane defaults
     for the temporary line_table.  */
  line_table_test ();

  /* Constructor.  Override "line_table", using the case described by C.  */
  line_table_test (const line_table_case &c);

  /* Destructor.  Restore the saved line_table.  */
  ~line_table_test ();
};

/* Run TESTCASE multiple times, once for each case in our test matrix.  */

extern void
for_each_line_table_case (void (*testcase) (const line_table_case &));

/* Read the contents of PATH into memory, returning a 0-terminated buffer
   that must be freed by the caller.
   Fail (and abort) if there are any problems, with LOC as the reported
   location of the failure.  */

extern char *read_file (const location &loc, const char *path);

/* A helper function for writing tests that interact with the
   garbage collector.  */

extern void forcibly_ggc_collect ();

/* Convert a path relative to SRCDIR/gcc/testsuite/selftests
   to a real path (either absolute, or relative to pwd).
   The result should be freed by the caller.  */

extern char *locate_file (const char *path);

/* The path of SRCDIR/testsuite/selftests.  */

extern const char *path_to_selftest_files;

/* Declarations for specific families of tests (by source file), in
   alphabetical order.  */
extern void bitmap_c_tests ();
extern void sbitmap_c_tests ();
extern void diagnostic_c_tests ();
extern void diagnostic_show_locus_c_tests ();
extern void edit_context_c_tests ();
extern void et_forest_c_tests ();
extern void fold_const_c_tests ();
extern void fibonacci_heap_c_tests ();
extern void function_tests_c_tests ();
extern void gimple_c_tests ();
extern void ggc_tests_c_tests ();
extern void hash_map_tests_c_tests ();
extern void hash_set_tests_c_tests ();
extern void input_c_tests ();
extern void pretty_print_c_tests ();
extern void read_rtl_function_c_tests ();
extern void rtl_tests_c_tests ();
extern void selftest_c_tests ();
extern void spellcheck_c_tests ();
extern void spellcheck_tree_c_tests ();
extern void sreal_c_tests ();
extern void store_merging_c_tests ();
extern void typed_splay_tree_c_tests ();
extern void tree_c_tests ();
extern void tree_cfg_c_tests ();
extern void unique_ptr_tests_cc_tests ();
extern void vec_c_tests ();
extern void wide_int_cc_tests ();
extern void predict_c_tests ();

extern int num_passes;

} /* end of namespace selftest.  */

/* Macros for writing tests.  */

/* Evaluate EXPR and coerce to bool, calling
   ::selftest::pass if it is true,
   ::selftest::fail if it false.  */

#define ASSERT_TRUE(EXPR)				\
  ASSERT_TRUE_AT (SELFTEST_LOCATION, (EXPR))

/* Like ASSERT_TRUE, but treat LOC as the effective location of the
   selftest.  */

#define ASSERT_TRUE_AT(LOC, EXPR)			\
  SELFTEST_BEGIN_STMT					\
  const char *desc = "ASSERT_TRUE (" #EXPR ")";		\
  bool actual = (EXPR);					\
  if (actual)						\
    ::selftest::pass ((LOC), desc);			\
  else							\
    ::selftest::fail ((LOC), desc);			\
  SELFTEST_END_STMT

/* Evaluate EXPR and coerce to bool, calling
   ::selftest::pass if it is false,
   ::selftest::fail if it true.  */

#define ASSERT_FALSE(EXPR)					\
  ASSERT_FALSE_AT (SELFTEST_LOCATION, (EXPR))

/* Like ASSERT_FALSE, but treat LOC as the effective location of the
   selftest.  */

#define ASSERT_FALSE_AT(LOC, EXPR)				\
  SELFTEST_BEGIN_STMT						\
  const char *desc = "ASSERT_FALSE (" #EXPR ")";			\
  bool actual = (EXPR);							\
  if (actual)								\
    ::selftest::fail ((LOC), desc);			\
  else									\
    ::selftest::pass ((LOC), desc);					\
  SELFTEST_END_STMT

/* Evaluate EXPECTED and ACTUAL and compare them with ==, calling
   ::selftest::pass if they are equal,
   ::selftest::fail if they are non-equal.  */

#define ASSERT_EQ(EXPECTED, ACTUAL) \
  ASSERT_EQ_AT ((SELFTEST_LOCATION), (EXPECTED), (ACTUAL))

/* Like ASSERT_EQ, but treat LOC as the effective location of the
   selftest.  */

#define ASSERT_EQ_AT(LOC, EXPECTED, ACTUAL)		       \
  SELFTEST_BEGIN_STMT					       \
  const char *desc = "ASSERT_EQ (" #EXPECTED ", " #ACTUAL ")"; \
  if ((EXPECTED) == (ACTUAL))				       \
    ::selftest::pass ((LOC), desc);			       \
  else							       \
    ::selftest::fail ((LOC), desc);			       \
  SELFTEST_END_STMT

/* Evaluate EXPECTED and ACTUAL and compare them with !=, calling
   ::selftest::pass if they are non-equal,
   ::selftest::fail if they are equal.  */

#define ASSERT_NE(EXPECTED, ACTUAL)			       \
  SELFTEST_BEGIN_STMT					       \
  const char *desc = "ASSERT_NE (" #EXPECTED ", " #ACTUAL ")"; \
  if ((EXPECTED) != (ACTUAL))				       \
    ::selftest::pass (SELFTEST_LOCATION, desc);			       \
  else							       \
    ::selftest::fail (SELFTEST_LOCATION, desc);			       \
  SELFTEST_END_STMT

/* Evaluate EXPECTED and ACTUAL and compare them with strcmp, calling
   ::selftest::pass if they are equal,
   ::selftest::fail if they are non-equal.  */

#define ASSERT_STREQ(EXPECTED, ACTUAL)				    \
  SELFTEST_BEGIN_STMT						    \
  ::selftest::assert_streq (SELFTEST_LOCATION, #EXPECTED, #ACTUAL, \
			    (EXPECTED), (ACTUAL));		    \
  SELFTEST_END_STMT

/* Like ASSERT_STREQ, but treat LOC as the effective location of the
   selftest.  */

#define ASSERT_STREQ_AT(LOC, EXPECTED, ACTUAL)			    \
  SELFTEST_BEGIN_STMT						    \
  ::selftest::assert_streq ((LOC), #EXPECTED, #ACTUAL,		    \
			    (EXPECTED), (ACTUAL));		    \
  SELFTEST_END_STMT

/* Evaluate HAYSTACK and NEEDLE and use strstr to determine if NEEDLE
   is within HAYSTACK.
   ::selftest::pass if NEEDLE is found.
   ::selftest::fail if it is not found.  */

#define ASSERT_STR_CONTAINS(HAYSTACK, NEEDLE)				\
  SELFTEST_BEGIN_STMT							\
  ::selftest::assert_str_contains (SELFTEST_LOCATION, #HAYSTACK, #NEEDLE, \
				   (HAYSTACK), (NEEDLE));		\
  SELFTEST_END_STMT

/* Evaluate PRED1 (VAL1), calling ::selftest::pass if it is true,
   ::selftest::fail if it is false.  */

#define ASSERT_PRED1(PRED1, VAL1)			\
  SELFTEST_BEGIN_STMT					\
  const char *desc = "ASSERT_PRED1 (" #PRED1 ", " #VAL1 ")";	\
  bool actual = (PRED1) (VAL1);				\
  if (actual)						\
    ::selftest::pass (SELFTEST_LOCATION, desc);			\
  else							\
    ::selftest::fail (SELFTEST_LOCATION, desc);			\
  SELFTEST_END_STMT

#define SELFTEST_BEGIN_STMT do {
#define SELFTEST_END_STMT   } while (0)

#endif /* #if CHECKING_P */

#endif /* GCC_SELFTEST_H */
Commit	Line	Data
d9b950dd	1	/* A self-testing framework, for use by -fself-test.
cbe34bb5	2	Copyright (C) 2015-2017 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	#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
09765e3a DM	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
d9b950dd DM	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
09765e3a	55	extern void pass (const location &loc, const char *msg);
d9b950dd DM	56
	57	/* Report the failed outcome of some aspect of the test and abort. */
	58
6ac852d1 DM	59	extern void fail (const location &loc, const char *msg)
6ac852d1 DM	60	ATTRIBUTE_NORETURN;
d9b950dd	61
755fa666 DM	62	/* As "fail", but using printf-style formatted output. */
755fa666 DM	63
09765e3a	64	extern void fail_formatted (const location &loc, const char *fmt, ...)
6ac852d1	65	ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
755fa666 DM	66
	67	/* Implementation detail of ASSERT_STREQ. */
	68
09765e3a	69	extern void assert_streq (const location &loc,
755fa666 DM	70	const char desc_expected, const char desc_actual,
	71	const char val_expected, const char val_actual);
	72
9f589786 DM	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
4ecfc453 DM	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. */
eb3a5bcc	85
4ecfc453	86	class named_temp_file
eb3a5bcc DM	87	{
eb3a5bcc DM	88	public:
4ecfc453 DM	89	named_temp_file (const char *suffix);
4ecfc453 DM	90	~named_temp_file ();
eb3a5bcc DM	91	const char *get_filename () const { return m_filename; }
	92
	93	private:
	94	char *m_filename;
	95	};
	96
4ecfc453 DM	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
f87e22c5 DM	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
7d37ffee DM	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
6c3b5bf0 DM	156	/* A helper function for writing tests that interact with the
	157	garbage collector. */
	158
	159	extern void forcibly_ggc_collect ();
	160
ecfc21ff DM	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
d9b950dd DM	171	/* Declarations for specific families of tests (by source file), in
	172	alphabetical order. */
	173	extern void bitmap_c_tests ();
0af377c1	174	extern void sbitmap_c_tests ();
a93eac6a	175	extern void diagnostic_c_tests ();
d9b950dd	176	extern void diagnostic_show_locus_c_tests ();
c65236d6	177	extern void edit_context_c_tests ();
d9b950dd DM	178	extern void et_forest_c_tests ();
d9b950dd DM	179	extern void fold_const_c_tests ();
ba1a7a0f	180	extern void fibonacci_heap_c_tests ();
d9b950dd DM	181	extern void function_tests_c_tests ();
d9b950dd DM	182	extern void gimple_c_tests ();
8c4294b2	183	extern void ggc_tests_c_tests ();
d9b950dd DM	184	extern void hash_map_tests_c_tests ();
	185	extern void hash_set_tests_c_tests ();
	186	extern void input_c_tests ();
4ccab56d	187	extern void pretty_print_c_tests ();
51b86113	188	extern void read_rtl_function_c_tests ();
d9b950dd	189	extern void rtl_tests_c_tests ();
5714dbda	190	extern void selftest_c_tests ();
d9b950dd	191	extern void spellcheck_c_tests ();
f254671f	192	extern void spellcheck_tree_c_tests ();
dcbdb17a	193	extern void sreal_c_tests ();
c22d8787	194	extern void store_merging_c_tests ();
950f6c85	195	extern void typed_splay_tree_c_tests ();
d9b950dd DM	196	extern void tree_c_tests ();
d9b950dd DM	197	extern void tree_cfg_c_tests ();
46d2b77d	198	extern void unique_ptr_tests_cc_tests ();
d9b950dd DM	199	extern void vec_c_tests ();
d9b950dd DM	200	extern void wide_int_cc_tests ();
d8838217	201	extern void predict_c_tests ();
d9b950dd DM	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) \
d4f7837c DM	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) \
d9b950dd DM	220	SELFTEST_BEGIN_STMT \
	221	const char *desc = "ASSERT_TRUE (" #EXPR ")"; \
	222	bool actual = (EXPR); \
	223	if (actual) \
d4f7837c	224	::selftest::pass ((LOC), desc); \
d9b950dd	225	else \
d4f7837c	226	::selftest::fail ((LOC), desc); \
d9b950dd DM	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) \
d4f7837c DM	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) \
d9b950dd	240	SELFTEST_BEGIN_STMT \
d4f7837c DM	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); \
d9b950dd DM	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
741d3be5 DM	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) \
d9b950dd DM	260	SELFTEST_BEGIN_STMT \
	261	const char *desc = "ASSERT_EQ (" #EXPECTED ", " #ACTUAL ")"; \
	262	if ((EXPECTED) == (ACTUAL)) \
741d3be5	263	::selftest::pass ((LOC), desc); \
d9b950dd	264	else \
741d3be5	265	::selftest::fail ((LOC), desc); \
d9b950dd DM	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)) \
09765e3a	276	::selftest::pass (SELFTEST_LOCATION, desc); \
d9b950dd	277	else \
09765e3a	278	::selftest::fail (SELFTEST_LOCATION, desc); \
d9b950dd DM	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
755fa666 DM	285	#define ASSERT_STREQ(EXPECTED, ACTUAL) \
755fa666 DM	286	SELFTEST_BEGIN_STMT \
09765e3a DM	287	::selftest::assert_streq (SELFTEST_LOCATION, #EXPECTED, #ACTUAL, \
	288	(EXPECTED), (ACTUAL)); \
	289	SELFTEST_END_STMT
	290
d4f7837c	291	/* Like ASSERT_STREQ, but treat LOC as the effective location of the
09765e3a DM	292	selftest. */
	293
	294	#define ASSERT_STREQ_AT(LOC, EXPECTED, ACTUAL) \
	295	SELFTEST_BEGIN_STMT \
	296	::selftest::assert_streq ((LOC), #EXPECTED, #ACTUAL, \
755fa666	297	(EXPECTED), (ACTUAL)); \
d9b950dd DM	298	SELFTEST_END_STMT
d9b950dd DM	299
9f589786 DM	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
d9b950dd DM	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) \
09765e3a	319	::selftest::pass (SELFTEST_LOCATION, desc); \
d9b950dd	320	else \
09765e3a	321	::selftest::fail (SELFTEST_LOCATION, desc); \
d9b950dd DM	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 */