1/* GLib testing utilities
2 * Copyright (C) 2007 Imendio AB
3 * Authors: Tim Janik
4 *
5 * SPDX-License-Identifier: LGPL-2.1-or-later
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21#ifndef __G_TEST_UTILS_H__
22#define __G_TEST_UTILS_H__
23
24#if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
25#error "Only <glib.h> can be included directly."
26#endif
27
28#include <glib/gmessages.h>
29#include <glib/gstring.h>
30#include <glib/gerror.h>
31#include <glib/gslist.h>
32#include <errno.h>
33#include <stdlib.h>
34#include <string.h>
35
36G_BEGIN_DECLS
37
38typedef struct GTestCase GTestCase;
39typedef struct GTestSuite GTestSuite;
40typedef void (*GTestFunc) (void);
41typedef void (*GTestDataFunc) (gconstpointer user_data);
42typedef void (*GTestFixtureFunc) (gpointer fixture,
43 gconstpointer user_data);
44
45/* assertion API */
46#define g_assert_cmpstr(s1, cmp, s2) G_STMT_START { \
47 const char *__s1 = (s1), *__s2 = (s2); \
48 if (g_strcmp0 (__s1, __s2) cmp 0) ; else \
49 g_assertion_message_cmpstr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
50 #s1 " " #cmp " " #s2, __s1, #cmp, __s2); \
51 } G_STMT_END
52#if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_78
53#define g_assert_cmpint(n1, cmp, n2) G_STMT_START { \
54 gint64 __n1 = (n1), __n2 = (n2); \
55 if (__n1 cmp __n2) ; else \
56 g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
57 #n1 " " #cmp " " #n2, (guint64)__n1, #cmp, (guint64)__n2, 'i'); \
58 } G_STMT_END
59#define g_assert_cmpuint(n1, cmp, n2) G_STMT_START { \
60 guint64 __n1 = (n1), __n2 = (n2); \
61 if (__n1 cmp __n2) ; else \
62 g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
63 #n1 " " #cmp " " #n2, __n1, #cmp, __n2, 'u'); \
64 } G_STMT_END
65#define g_assert_cmphex(n1, cmp, n2) G_STMT_START { \
66 guint64 __n1 = (n1), __n2 = (n2); \
67 if (__n1 cmp __n2) ; else \
68 g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
69 #n1 " " #cmp " " #n2, __n1, #cmp, __n2, 'x'); \
70 } G_STMT_END
71#else /* GLIB_VERSION_MIN_REQUIRED < GLIB_VERSION_2_78 */
72#define g_assert_cmpint(n1, cmp, n2) G_STMT_START { \
73 gint64 __n1 = (n1), __n2 = (n2); \
74 if (__n1 cmp __n2) ; else \
75 g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
76 #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'i'); \
77 } G_STMT_END
78#define g_assert_cmpuint(n1, cmp, n2) G_STMT_START { \
79 guint64 __n1 = (n1), __n2 = (n2); \
80 if (__n1 cmp __n2) ; else \
81 g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
82 #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'i'); \
83 } G_STMT_END
84#define g_assert_cmphex(n1, cmp, n2) G_STMT_START {\
85 guint64 __n1 = (n1), __n2 = (n2); \
86 if (__n1 cmp __n2) ; else \
87 g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
88 #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'x'); \
89 } G_STMT_END
90#endif /* GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_78 */
91#define g_assert_cmpfloat(n1,cmp,n2) G_STMT_START { \
92 long double __n1 = (long double) (n1), __n2 = (long double) (n2); \
93 if (__n1 cmp __n2) ; else \
94 g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
95 #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'f'); \
96 } G_STMT_END
97#define g_assert_cmpfloat_with_epsilon(n1,n2,epsilon) \
98 G_STMT_START { \
99 double __n1 = (n1), __n2 = (n2), __epsilon = (epsilon); \
100 if (G_APPROX_VALUE (__n1, __n2, __epsilon)) ; else \
101 g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
102 #n1 " == " #n2 " (+/- " #epsilon ")", __n1, "==", __n2, 'f'); \
103 } G_STMT_END
104#if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_78
105#define g_assert_cmpmem(m1, l1, m2, l2) G_STMT_START {\
106 gconstpointer __m1 = m1, __m2 = m2; \
107 size_t __l1 = (size_t) l1, __l2 = (size_t) l2; \
108 if (__l1 != 0 && __m1 == NULL) \
109 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
110 "assertion failed (" #l1 " == 0 || " #m1 " != NULL)"); \
111 else if (__l2 != 0 && __m2 == NULL) \
112 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
113 "assertion failed (" #l2 " == 0 || " #m2 " != NULL)"); \
114 else if (__l1 != __l2) \
115 g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
116 #l1 " (len(" #m1 ")) == " #l2 " (len(" #m2 "))", \
117 __l1, "==", __l2, 'u'); \
118 else if (__l1 != 0 && __m2 != NULL && memcmp (__m1, __m2, __l1) != 0) \
119 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
120 "assertion failed (" #m1 " == " #m2 ")"); \
121 } G_STMT_END
122#else /* GLIB_VERSION_MIN_REQUIRED < GLIB_VERSION_2_78 */
123#define g_assert_cmpmem(m1, l1, m2, l2) G_STMT_START {\
124 gconstpointer __m1 = m1, __m2 = m2; \
125 size_t __l1 = (size_t) l1, __l2 = (size_t) l2; \
126 if (__l1 != 0 && __m1 == NULL) \
127 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
128 "assertion failed (" #l1 " == 0 || " #m1 " != NULL)"); \
129 else if (__l2 != 0 && __m2 == NULL) \
130 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
131 "assertion failed (" #l2 " == 0 || " #m2 " != NULL)"); \
132 else if (__l1 != __l2) \
133 g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
134 #l1 " (len(" #m1 ")) == " #l2 " (len(" #m2 "))", \
135 (long double) __l1, "==", (long double) __l2, 'i'); \
136 else if (__l1 != 0 && __m2 != NULL && memcmp (__m1, __m2, __l1) != 0) \
137 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
138 "assertion failed (" #m1 " == " #m2 ")"); \
139 } G_STMT_END
140#endif /* GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_78 */
141#define g_assert_cmpvariant(v1, v2) \
142 G_STMT_START \
143 { \
144 GVariant *__v1 = (v1), *__v2 = (v2); \
145 if (!g_variant_equal (__v1, __v2)) \
146 { \
147 gchar *__s1, *__s2, *__msg; \
148 __s1 = g_variant_print (__v1, TRUE); \
149 __s2 = g_variant_print (__v2, TRUE); \
150 __msg = g_strdup_printf ("assertion failed (" #v1 " == " #v2 "): %s does not equal %s", __s1, __s2); \
151 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, __msg); \
152 g_free (__s1); \
153 g_free (__s2); \
154 g_free (__msg); \
155 } \
156 } \
157 G_STMT_END
158#define g_assert_cmpstrv(strv1, strv2) \
159 G_STMT_START \
160 { \
161 const char * const *__strv1 = (const char * const *) (strv1); \
162 const char * const *__strv2 = (const char * const *) (strv2); \
163 if (!__strv1 || !__strv2) \
164 { \
165 if (__strv1) \
166 { \
167 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
168 "assertion failed (" #strv1 " == " #strv2 "): " #strv2 " is NULL, but " #strv1 " is not"); \
169 } \
170 else if (__strv2) \
171 { \
172 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
173 "assertion failed (" #strv1 " == " #strv2 "): " #strv1 " is NULL, but " #strv2 " is not"); \
174 } \
175 } \
176 else \
177 { \
178 guint __l1 = g_strv_length ((char **) __strv1); \
179 guint __l2 = g_strv_length ((char **) __strv2); \
180 if (__l1 != __l2) \
181 { \
182 char *__msg; \
183 __msg = g_strdup_printf ("assertion failed (" #strv1 " == " #strv2 "): length %u does not equal length %u", __l1, __l2); \
184 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, __msg); \
185 g_free (__msg); \
186 } \
187 else \
188 { \
189 guint __i; \
190 for (__i = 0; __i < __l1; __i++) \
191 { \
192 if (g_strcmp0 (__strv1[__i], __strv2[__i]) != 0) \
193 { \
194 g_assertion_message_cmpstrv (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
195 #strv1 " == " #strv2, \
196 __strv1, __strv2, __i); \
197 } \
198 } \
199 } \
200 } \
201 } \
202 G_STMT_END
203#define g_assert_no_errno(expr) G_STMT_START { \
204 int __ret, __errsv; \
205 errno = 0; \
206 __ret = expr; \
207 __errsv = errno; \
208 if (__ret < 0) \
209 { \
210 gchar *__msg; \
211 __msg = g_strdup_printf ("assertion failed (" #expr " >= 0): errno %i: %s", __errsv, g_strerror (__errsv)); \
212 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, __msg); \
213 g_free (__msg); \
214 } \
215 } G_STMT_END \
216 GLIB_AVAILABLE_MACRO_IN_2_66
217#define g_assert_no_error(err) G_STMT_START { \
218 if (err) \
219 g_assertion_message_error (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
220 #err, err, 0, 0); \
221 } G_STMT_END
222#define g_assert_error(err, dom, c) G_STMT_START { \
223 if (!err || (err)->domain != dom || (err)->code != c) \
224 g_assertion_message_error (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
225 #err, err, dom, c); \
226 } G_STMT_END
227#define g_assert_true(expr) G_STMT_START { \
228 if G_LIKELY (expr) ; else \
229 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
230 "'" #expr "' should be TRUE"); \
231 } G_STMT_END
232#define g_assert_false(expr) G_STMT_START { \
233 if G_LIKELY (!(expr)) ; else \
234 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
235 "'" #expr "' should be FALSE"); \
236 } G_STMT_END
237
238/* Use nullptr in C++ to catch misuse of these macros. */
239#if G_CXX_STD_CHECK_VERSION (11)
240#define g_assert_null(expr) G_STMT_START { if G_LIKELY ((expr) == nullptr) ; else \
241 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
242 "'" #expr "' should be nullptr"); \
243 } G_STMT_END
244#define g_assert_nonnull(expr) G_STMT_START { \
245 if G_LIKELY ((expr) != nullptr) ; else \
246 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
247 "'" #expr "' should not be nullptr"); \
248 } G_STMT_END
249#else /* not C++ */
250#define g_assert_null(expr) G_STMT_START { if G_LIKELY ((expr) == NULL) ; else \
251 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
252 "'" #expr "' should be NULL"); \
253 } G_STMT_END
254#define g_assert_nonnull(expr) G_STMT_START { \
255 if G_LIKELY ((expr) != NULL) ; else \
256 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
257 "'" #expr "' should not be NULL"); \
258 } G_STMT_END
259#endif
260
261#ifdef G_DISABLE_ASSERT
262/* https://gcc.gnu.org/onlinedocs/gcc-8.3.0/gcc/Other-Builtins.html#index-_005f_005fbuiltin_005funreachable
263 * GCC 5 is not a strict lower bound for versions of GCC which provide __builtin_unreachable(). */
264#if __GNUC__ >= 5 || g_macro__has_builtin(__builtin_unreachable)
265#define g_assert_not_reached() G_STMT_START { (void) 0; __builtin_unreachable (); } G_STMT_END
266#elif defined (_MSC_VER)
267#define g_assert_not_reached() G_STMT_START { (void) 0; __assume (0); } G_STMT_END
268#else /* if __builtin_unreachable() is not supported: */
269#define g_assert_not_reached() G_STMT_START { (void) 0; } G_STMT_END
270#endif
271
272#define g_assert(expr) G_STMT_START { (void) 0; } G_STMT_END
273#else /* !G_DISABLE_ASSERT */
274#define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END
275#define g_assert(expr) G_STMT_START { \
276 if G_LIKELY (expr) ; else \
277 g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
278 #expr); \
279 } G_STMT_END
280#endif /* !G_DISABLE_ASSERT */
281
282GLIB_AVAILABLE_IN_ALL
283int g_strcmp0 (const char *str1,
284 const char *str2);
285
286/* report performance results */
287GLIB_AVAILABLE_IN_ALL
288void g_test_minimized_result (double minimized_quantity,
289 const char *format,
290 ...) G_GNUC_PRINTF (2, 3);
291GLIB_AVAILABLE_IN_ALL
292void g_test_maximized_result (double maximized_quantity,
293 const char *format,
294 ...) G_GNUC_PRINTF (2, 3);
295
296/* initialize testing framework */
297GLIB_AVAILABLE_IN_ALL
298void g_test_init (int *argc,
299 char ***argv,
300 ...) G_GNUC_NULL_TERMINATED;
301
302/**
303 * G_TEST_OPTION_ISOLATE_DIRS:
304 *
305 * A value that can be passed as an option to [func@GLib.test_init].
306 *
307 * Creates a unique temporary directory for each unit test and uses sets
308 * XDG directories to point into subdirectories of it for the duration of
309 * the unit test. The directory tree is cleaned up after the test finishes
310 * successfully.
311 *
312 * Note that this doesn’t take effect until [func@GLib.test_run] is called,
313 * so calls to (for example) [func@GLib.get_home_dir] will return the
314 * system-wide value when made in a test program’s main() function.
315 *
316 * The following functions will return subdirectories of the temporary directory
317 * when this option is used. The specific subdirectory paths in use are not
318 * guaranteed to be stable API — always use a getter function to retrieve them.
319 *
320 * - [func@GLib.get_home_dir]
321 * - [func@GLib.get_user_cache_dir]
322 * - [func@GLib.get_system_config_dirs]
323 * - [func@GLib.get_user_config_dir]
324 * - [func@GLib.get_system_data_dirs]
325 * - [func@GLib.get_user_data_dir]
326 * - [func@GLib.get_user_state_dir]
327 * - [func@GLib.get_user_runtime_dir]
328 *
329 * The subdirectories may not be created by the test harness; as with normal
330 * calls to functions like [func@GLib.get_user_cache_dir], the caller must
331 * be prepared to create the directory if it doesn’t exist.
332 *
333 * Since: 2.60
334 */
335#define G_TEST_OPTION_ISOLATE_DIRS "isolate_dirs"
336
337/**
338 * G_TEST_OPTION_NO_PRGNAME:
339 *
340 * A value that can be passed as an option to [func@GLib.test_init].
341 *
342 * If this option is given, [func@GLib.test_init] will not call [func@GLib.set_prgname].
343 *
344 * Since: 2.84
345 */
346#define G_TEST_OPTION_NO_PRGNAME "no_g_set_prgname"
347
348/**
349 * G_TEST_OPTION_NONFATAL_ASSERTIONS:
350 *
351 * A value that can be passed as an option to [func@GLib.test_init].
352 *
353 * If this option is given, assertions will not abort the process, but
354 * call [func@GLib.test_fail]. Equivalent to [func@GLib.test_set_nonfatal_assertions].
355 *
356 * Since: 2.84
357 */
358#define G_TEST_OPTION_NONFATAL_ASSERTIONS "nonfatal-assertions"
359
360/* While we discourage its use, g_assert() is often used in unit tests
361 * (especially in legacy code). g_assert_*() should really be used instead.
362 * g_assert() can be disabled at client program compile time, which can render
363 * tests useless. Highlight that to the user. */
364#ifdef G_DISABLE_ASSERT
365#if defined(G_HAVE_ISO_VARARGS)
366#define g_test_init(argc, argv, ...) \
367 G_STMT_START { \
368 g_printerr ("Tests were compiled with G_DISABLE_ASSERT and are likely no-ops. Aborting.\n"); \
369 exit (1); \
370 } G_STMT_END
371#elif defined(G_HAVE_GNUC_VARARGS)
372#define g_test_init(argc, argv...) \
373 G_STMT_START { \
374 g_printerr ("Tests were compiled with G_DISABLE_ASSERT and are likely no-ops. Aborting.\n"); \
375 exit (1); \
376 } G_STMT_END
377#else /* no varargs */
378 /* do nothing */
379#endif /* varargs support */
380#endif /* G_DISABLE_ASSERT */
381
382/* query testing framework config */
383#define g_test_initialized() (g_test_config_vars->test_initialized)
384#define g_test_quick() (g_test_config_vars->test_quick)
385#define g_test_slow() (!g_test_config_vars->test_quick)
386#define g_test_thorough() (!g_test_config_vars->test_quick)
387#define g_test_perf() (g_test_config_vars->test_perf)
388#define g_test_verbose() (g_test_config_vars->test_verbose)
389#define g_test_quiet() (g_test_config_vars->test_quiet)
390#define g_test_undefined() (g_test_config_vars->test_undefined)
391GLIB_AVAILABLE_IN_2_38
392gboolean g_test_subprocess (void);
393
394/* run all tests under toplevel suite (path: /) */
395GLIB_AVAILABLE_IN_ALL
396int g_test_run (void);
397/* hook up a test functions under test path */
398GLIB_AVAILABLE_IN_ALL
399void g_test_add_func (const char *testpath,
400 GTestFunc test_func);
401
402GLIB_AVAILABLE_IN_ALL
403void g_test_add_data_func (const char *testpath,
404 gconstpointer test_data,
405 GTestDataFunc test_func);
406
407GLIB_AVAILABLE_IN_2_34
408void g_test_add_data_func_full (const char *testpath,
409 gpointer test_data,
410 GTestDataFunc test_func,
411 GDestroyNotify data_free_func);
412
413/* tell about currently run test */
414GLIB_AVAILABLE_IN_2_68
415const char * g_test_get_path (void);
416
417/* tell about failure */
418GLIB_AVAILABLE_IN_2_30
419void g_test_fail (void);
420GLIB_AVAILABLE_IN_2_70
421void g_test_fail_printf (const char *format,
422 ...) G_GNUC_PRINTF (1, 2);
423GLIB_AVAILABLE_IN_2_38
424void g_test_incomplete (const gchar *msg);
425GLIB_AVAILABLE_IN_2_70
426void g_test_incomplete_printf (const char *format,
427 ...) G_GNUC_PRINTF (1, 2);
428GLIB_AVAILABLE_IN_2_38
429void g_test_skip (const gchar *msg);
430GLIB_AVAILABLE_IN_2_70
431void g_test_skip_printf (const char *format,
432 ...) G_GNUC_PRINTF (1, 2);
433GLIB_AVAILABLE_IN_2_38
434gboolean g_test_failed (void);
435GLIB_AVAILABLE_IN_2_38
436void g_test_set_nonfatal_assertions (void);
437GLIB_AVAILABLE_IN_2_78
438void g_test_disable_crash_reporting (void);
439
440/**
441 * g_test_add:
442 * @testpath: the test path for a new test case
443 * @Fixture: the type of a fixture data structure
444 * @tdata: data argument for the test functions
445 * @fsetup: the function to set up the fixture data
446 * @ftest: the actual test function
447 * @fteardown: the function to tear down the fixture data
448 *
449 * Hooks up a new test case at @testpath.
450 *
451 * This function is similar to [func@GLib.test_add_func].
452 *
453 * A fixture data structure with setup and teardown functions
454 * may be provided, similar to [func@GLib.test_create_case].
455 *
456 * `g_test_add()` is implemented as a macro, so that the @fsetup,
457 * @ftest and @fteardown callbacks can expect a @Fixture pointer
458 * as their first argument in a type safe manner. They otherwise
459 * have type `GTestFixtureFunc`.
460 *
461 * Since: 2.16
462 */
463#define g_test_add(testpath, Fixture, tdata, fsetup, ftest, fteardown) \
464 G_STMT_START { \
465 void (*add_vtable) (const char*, \
466 gsize, \
467 gconstpointer, \
468 void (*) (Fixture*, gconstpointer), \
469 void (*) (Fixture*, gconstpointer), \
470 void (*) (Fixture*, gconstpointer)) = (void (*) (const gchar *, gsize, gconstpointer, void (*) (Fixture*, gconstpointer), void (*) (Fixture*, gconstpointer), void (*) (Fixture*, gconstpointer))) g_test_add_vtable; \
471 add_vtable \
472 (testpath, sizeof (Fixture), tdata, fsetup, ftest, fteardown); \
473 } G_STMT_END
474
475/* add test messages to the test report */
476GLIB_AVAILABLE_IN_ALL
477void g_test_message (const char *format,
478 ...) G_GNUC_PRINTF (1, 2);
479GLIB_AVAILABLE_IN_ALL
480void g_test_bug_base (const char *uri_pattern);
481GLIB_AVAILABLE_IN_ALL
482void g_test_bug (const char *bug_uri_snippet);
483GLIB_AVAILABLE_IN_2_62
484void g_test_summary (const char *summary);
485/* measure test timings */
486GLIB_AVAILABLE_IN_ALL
487void g_test_timer_start (void);
488GLIB_AVAILABLE_IN_ALL
489double g_test_timer_elapsed (void); /* elapsed seconds */
490GLIB_AVAILABLE_IN_ALL
491double g_test_timer_last (void); /* repeat last elapsed() result */
492
493/* automatically g_free or g_object_unref upon teardown */
494GLIB_AVAILABLE_IN_ALL
495void g_test_queue_free (gpointer gfree_pointer);
496GLIB_AVAILABLE_IN_ALL
497void g_test_queue_destroy (GDestroyNotify destroy_func,
498 gpointer destroy_data);
499#define g_test_queue_unref(gobject) g_test_queue_destroy (g_object_unref, gobject)
500
501/**
502 * GTestTrapFlags:
503 * @G_TEST_TRAP_DEFAULT: Default behaviour. Since: 2.74
504 * @G_TEST_TRAP_SILENCE_STDOUT: Redirect stdout of the test child to
505 * `/dev/null` so it cannot be observed on the console during test
506 * runs. The actual output is still captured though to allow later
507 * tests with g_test_trap_assert_stdout().
508 * @G_TEST_TRAP_SILENCE_STDERR: Redirect stderr of the test child to
509 * `/dev/null` so it cannot be observed on the console during test
510 * runs. The actual output is still captured though to allow later
511 * tests with g_test_trap_assert_stderr().
512 * @G_TEST_TRAP_INHERIT_STDIN: If this flag is given, stdin of the
513 * child process is shared with stdin of its parent process.
514 * It is redirected to `/dev/null` otherwise.
515 *
516 * Flags to pass to [func@GLib.test_trap_fork] to control input and output.
517 *
518 * Test traps are guards around forked tests. These flags determine what traps to set.
519 *
520 * Deprecated: 2.38: `GTestTrapFlags` is used only with [func@GLib.test_trap_fork],
521 * which is deprecated. Its replacement, [func@GLib.test_trap_subprocess] uses
522 * [flags@GLib.TestSubprocessFlags].
523 */
524typedef enum {
525 G_TEST_TRAP_DEFAULT GLIB_AVAILABLE_ENUMERATOR_IN_2_74 = 0,
526 G_TEST_TRAP_SILENCE_STDOUT = 1 << 7,
527 G_TEST_TRAP_SILENCE_STDERR = 1 << 8,
528 G_TEST_TRAP_INHERIT_STDIN = 1 << 9
529} GTestTrapFlags GLIB_DEPRECATED_TYPE_IN_2_38_FOR(GTestSubprocessFlags);
530
531G_GNUC_BEGIN_IGNORE_DEPRECATIONS
532
533GLIB_DEPRECATED_IN_2_38_FOR (g_test_trap_subprocess)
534gboolean g_test_trap_fork (guint64 usec_timeout,
535 GTestTrapFlags test_trap_flags);
536
537G_GNUC_END_IGNORE_DEPRECATIONS
538
539typedef enum {
540 G_TEST_SUBPROCESS_DEFAULT GLIB_AVAILABLE_ENUMERATOR_IN_2_74 = 0,
541 G_TEST_SUBPROCESS_INHERIT_STDIN = 1 << 0,
542 G_TEST_SUBPROCESS_INHERIT_STDOUT = 1 << 1,
543 G_TEST_SUBPROCESS_INHERIT_STDERR = 1 << 2
544} GTestSubprocessFlags;
545
546GLIB_AVAILABLE_IN_2_38
547void g_test_trap_subprocess (const char *test_path,
548 guint64 usec_timeout,
549 GTestSubprocessFlags test_flags);
550GLIB_AVAILABLE_IN_2_80
551void g_test_trap_subprocess_with_envp (const char *test_path,
552 const char * const *envp,
553 guint64 usec_timeout,
554 GTestSubprocessFlags test_flags);
555
556GLIB_AVAILABLE_IN_ALL
557gboolean g_test_trap_has_passed (void);
558GLIB_AVAILABLE_IN_ALL
559gboolean g_test_trap_reached_timeout (void);
560#define g_test_trap_assert_passed() g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 0, 0)
561#define g_test_trap_assert_failed() g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 1, 0)
562#define g_test_trap_assert_stdout(soutpattern) g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 2, soutpattern)
563#define g_test_trap_assert_stdout_unmatched(soutpattern) g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 3, soutpattern)
564#define g_test_trap_assert_stderr(serrpattern) g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 4, serrpattern)
565#define g_test_trap_assert_stderr_unmatched(serrpattern) g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 5, serrpattern)
566
567/* provide seed-able random numbers for tests */
568#define g_test_rand_bit() (0 != (g_test_rand_int() & (1 << 15)))
569GLIB_AVAILABLE_IN_ALL
570gint32 g_test_rand_int (void);
571GLIB_AVAILABLE_IN_ALL
572gint32 g_test_rand_int_range (gint32 begin,
573 gint32 end);
574GLIB_AVAILABLE_IN_ALL
575double g_test_rand_double (void);
576GLIB_AVAILABLE_IN_ALL
577double g_test_rand_double_range (double range_start,
578 double range_end);
579
580/*
581 * semi-internal API: non-documented symbols with stable ABI. You
582 * should use the non-internal helper macros instead. However, for
583 * compatibility reason, you may use this semi-internal API.
584 */
585GLIB_AVAILABLE_IN_ALL
586GTestCase* g_test_create_case (const char *test_name,
587 gsize data_size,
588 gconstpointer test_data,
589 GTestFixtureFunc data_setup,
590 GTestFixtureFunc data_test,
591 GTestFixtureFunc data_teardown);
592GLIB_AVAILABLE_IN_ALL
593GTestSuite* g_test_create_suite (const char *suite_name);
594GLIB_AVAILABLE_IN_ALL
595GTestSuite* g_test_get_root (void);
596GLIB_AVAILABLE_IN_ALL
597void g_test_suite_add (GTestSuite *suite,
598 GTestCase *test_case);
599GLIB_AVAILABLE_IN_ALL
600void g_test_suite_add_suite (GTestSuite *suite,
601 GTestSuite *nestedsuite);
602GLIB_AVAILABLE_IN_ALL
603int g_test_run_suite (GTestSuite *suite);
604
605GLIB_AVAILABLE_IN_2_70
606void g_test_case_free (GTestCase *test_case);
607
608GLIB_AVAILABLE_IN_2_70
609void g_test_suite_free (GTestSuite *suite);
610
611GLIB_AVAILABLE_IN_ALL
612void g_test_trap_assertions (const char *domain,
613 const char *file,
614 int line,
615 const char *func,
616 guint64 assertion_flags, /* 0-pass, 1-fail, 2-outpattern, 4-errpattern */
617 const char *pattern);
618GLIB_AVAILABLE_IN_ALL
619void g_assertion_message (const char *domain,
620 const char *file,
621 int line,
622 const char *func,
623 const char *message) G_ANALYZER_NORETURN;
624G_NORETURN
625GLIB_AVAILABLE_IN_ALL
626void g_assertion_message_expr (const char *domain,
627 const char *file,
628 int line,
629 const char *func,
630 const char *expr);
631GLIB_AVAILABLE_IN_ALL
632void g_assertion_message_cmpstr (const char *domain,
633 const char *file,
634 int line,
635 const char *func,
636 const char *expr,
637 const char *arg1,
638 const char *cmp,
639 const char *arg2) G_ANALYZER_NORETURN;
640
641GLIB_AVAILABLE_IN_2_68
642void g_assertion_message_cmpstrv (const char *domain,
643 const char *file,
644 int line,
645 const char *func,
646 const char *expr,
647 const char * const *arg1,
648 const char * const *arg2,
649 gsize first_wrong_idx) G_ANALYZER_NORETURN;
650GLIB_AVAILABLE_IN_2_78
651void g_assertion_message_cmpint (const char *domain,
652 const char *file,
653 int line,
654 const char *func,
655 const char *expr,
656 guint64 arg1,
657 const char *cmp,
658 guint64 arg2,
659 char numtype) G_ANALYZER_NORETURN;
660GLIB_AVAILABLE_IN_ALL
661void g_assertion_message_cmpnum (const char *domain,
662 const char *file,
663 int line,
664 const char *func,
665 const char *expr,
666 long double arg1,
667 const char *cmp,
668 long double arg2,
669 char numtype) G_ANALYZER_NORETURN;
670GLIB_AVAILABLE_IN_ALL
671void g_assertion_message_error (const char *domain,
672 const char *file,
673 int line,
674 const char *func,
675 const char *expr,
676 const GError *error,
677 GQuark error_domain,
678 int error_code) G_ANALYZER_NORETURN;
679GLIB_AVAILABLE_IN_ALL
680void g_test_add_vtable (const char *testpath,
681 gsize data_size,
682 gconstpointer test_data,
683 GTestFixtureFunc data_setup,
684 GTestFixtureFunc data_test,
685 GTestFixtureFunc data_teardown);
686typedef struct {
687 gboolean test_initialized;
688 gboolean test_quick; /* disable thorough tests */
689 gboolean test_perf; /* run performance tests */
690 gboolean test_verbose; /* extra info */
691 gboolean test_quiet; /* reduce output */
692 gboolean test_undefined; /* run tests that are meant to assert */
693} GTestConfig;
694GLIB_VAR const GTestConfig * const g_test_config_vars;
695
696/* internal logging API */
697typedef enum {
698 G_TEST_RUN_SUCCESS,
699 G_TEST_RUN_SKIPPED,
700 G_TEST_RUN_FAILURE,
701 G_TEST_RUN_INCOMPLETE
702} GTestResult;
703
704typedef enum {
705 G_TEST_LOG_NONE,
706 G_TEST_LOG_ERROR, /* s:msg */
707 G_TEST_LOG_START_BINARY, /* s:binaryname s:seed */
708 G_TEST_LOG_LIST_CASE, /* s:testpath */
709 G_TEST_LOG_SKIP_CASE, /* s:testpath */
710 G_TEST_LOG_START_CASE, /* s:testpath */
711 G_TEST_LOG_STOP_CASE, /* d:status d:nforks d:elapsed */
712 G_TEST_LOG_MIN_RESULT, /* s:blurb d:result */
713 G_TEST_LOG_MAX_RESULT, /* s:blurb d:result */
714 G_TEST_LOG_MESSAGE, /* s:blurb */
715 G_TEST_LOG_START_SUITE,
716 G_TEST_LOG_STOP_SUITE
717} GTestLogType;
718
719typedef struct {
720 GTestLogType log_type;
721 guint n_strings;
722 gchar **strings; /* NULL terminated */
723 guint n_nums;
724 long double *nums;
725} GTestLogMsg;
726typedef struct {
727 /*< private >*/
728 GString *data;
729 GSList *msgs;
730} GTestLogBuffer;
731
732GLIB_AVAILABLE_IN_ALL
733const char* g_test_log_type_name (GTestLogType log_type);
734GLIB_AVAILABLE_IN_ALL
735GTestLogBuffer* g_test_log_buffer_new (void);
736GLIB_AVAILABLE_IN_ALL
737void g_test_log_buffer_free (GTestLogBuffer *tbuffer);
738GLIB_AVAILABLE_IN_ALL
739void g_test_log_buffer_push (GTestLogBuffer *tbuffer,
740 guint n_bytes,
741 const guint8 *bytes);
742GLIB_AVAILABLE_IN_ALL
743GTestLogMsg* g_test_log_buffer_pop (GTestLogBuffer *tbuffer);
744GLIB_AVAILABLE_IN_ALL
745void g_test_log_msg_free (GTestLogMsg *tmsg);
746
747/**
748 * GTestLogFatalFunc:
749 * @log_domain: the log domain of the message
750 * @log_level: the log level of the message (including the fatal and recursion flags)
751 * @message: the message to process
752 * @user_data: user data, set in g_test_log_set_fatal_handler()
753 *
754 * Specifies the prototype of fatal log handler functions.
755 *
756 * Returns: %TRUE if the program should abort, %FALSE otherwise
757 *
758 * Since: 2.22
759 */
760typedef gboolean (*GTestLogFatalFunc) (const gchar *log_domain,
761 GLogLevelFlags log_level,
762 const gchar *message,
763 gpointer user_data);
764GLIB_AVAILABLE_IN_ALL
765void
766g_test_log_set_fatal_handler (GTestLogFatalFunc log_func,
767 gpointer user_data);
768
769GLIB_AVAILABLE_IN_2_34
770void g_test_expect_message (const gchar *log_domain,
771 GLogLevelFlags log_level,
772 const gchar *pattern);
773GLIB_AVAILABLE_IN_2_34
774void g_test_assert_expected_messages_internal (const char *domain,
775 const char *file,
776 int line,
777 const char *func);
778
779typedef enum
780{
781 G_TEST_DIST,
782 G_TEST_BUILT
783} GTestFileType;
784
785GLIB_AVAILABLE_IN_2_38
786gchar * g_test_build_filename (GTestFileType file_type,
787 const gchar *first_path,
788 ...) G_GNUC_NULL_TERMINATED;
789GLIB_AVAILABLE_IN_2_38
790const gchar *g_test_get_dir (GTestFileType file_type);
791GLIB_AVAILABLE_IN_2_38
792const gchar *g_test_get_filename (GTestFileType file_type,
793 const gchar *first_path,
794 ...) G_GNUC_NULL_TERMINATED;
795
796#define g_test_assert_expected_messages() g_test_assert_expected_messages_internal (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC)
797
798G_END_DECLS
799
800#endif /* __G_TEST_UTILS_H__ */
801