⚝
One Hat Cyber Team
⚝
Your IP:
216.73.216.0
Server IP:
157.245.101.34
Server:
Linux skvinfotech-website 5.4.0-131-generic #147-Ubuntu SMP Fri Oct 14 17:07:22 UTC 2022 x86_64
Server Software:
Apache/2.4.41 (Ubuntu)
PHP Version:
7.4.33
Buat File
|
Buat Folder
Eksekusi
Dir :
~
/
usr
/
share
/
gtk-doc
/
html
/
glib
/
View File Name :
glib-Testing.html
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Testing: GLib Reference Manual</title> <meta name="generator" content="DocBook XSL Stylesheets V1.79.1"> <link rel="home" href="index.html" title="GLib Reference Manual"> <link rel="up" href="glib-utilities.html" title="GLib Utilities"> <link rel="prev" href="glib-Bookmark-file-parser.html" title="Bookmark file parser"> <link rel="next" href="glib-UNIX-specific-utilities-and-integration.html" title="UNIX-specific utilities and integration"> <meta name="generator" content="GTK-Doc V1.32 (XML mode)"> <link rel="stylesheet" href="style.css" type="text/css"> </head> <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> <table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="5"><tr valign="middle"> <td width="100%" align="left" class="shortcuts"> <a href="#" class="shortcut">Top</a><span id="nav_description"> <span class="dim">|</span> <a href="#glib-Testing.description" class="shortcut">Description</a></span> </td> <td><a accesskey="h" href="index.html"><img src="home.png" width="16" height="16" border="0" alt="Home"></a></td> <td><a accesskey="u" href="glib-utilities.html"><img src="up.png" width="16" height="16" border="0" alt="Up"></a></td> <td><a accesskey="p" href="glib-Bookmark-file-parser.html"><img src="left.png" width="16" height="16" border="0" alt="Prev"></a></td> <td><a accesskey="n" href="glib-UNIX-specific-utilities-and-integration.html"><img src="right.png" width="16" height="16" border="0" alt="Next"></a></td> </tr></table> <div class="refentry"> <a name="glib-Testing"></a><div class="titlepage"></div> <div class="refnamediv"><table width="100%"><tr> <td valign="top"> <h2><span class="refentrytitle"><a name="glib-Testing.top_of_page"></a>Testing</span></h2> <p>Testing — a test framework</p> </td> <td class="gallery_image" valign="top" align="right"></td> </tr></table></div> <div class="refsect1"> <a name="glib-Testing.functions"></a><h2>Functions</h2> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="functions_proto_type"> <col class="functions_proto_name"> </colgroup> <tbody> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-minimized-result" title="g_test_minimized_result ()">g_test_minimized_result</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-maximized-result" title="g_test_maximized_result ()">g_test_maximized_result</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()">g_test_init</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-initialized" title="g_test_initialized">g_test_initialized</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-quick" title="g_test_quick">g_test_quick</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-slow" title="g_test_slow">g_test_slow</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-thorough" title="g_test_thorough">g_test_thorough</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-perf" title="g_test_perf">g_test_perf</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-verbose" title="g_test_verbose">g_test_verbose</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-undefined" title="g_test_undefined">g_test_undefined</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-quiet" title="g_test_quiet">g_test_quiet</a></td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-subprocess" title="g_test_subprocess ()">g_test_subprocess</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">int</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-run" title="g_test_run ()">g_test_run</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <span class="c_punctuation">(</span><a class="link" href="glib-Testing.html#GTestFunc" title="GTestFunc ()">*GTestFunc</a><span class="c_punctuation">)</span> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-add-func" title="g_test_add_func ()">g_test_add_func</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <span class="c_punctuation">(</span><a class="link" href="glib-Testing.html#GTestDataFunc" title="GTestDataFunc ()">*GTestDataFunc</a><span class="c_punctuation">)</span> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-add-data-func" title="g_test_add_data_func ()">g_test_add_data_func</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-add-data-func-full" title="g_test_add_data_func_full ()">g_test_add_data_func_full</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-add" title="g_test_add()">g_test_add</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> * </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-build-filename" title="g_test_build_filename ()">g_test_build_filename</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type">const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> * </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-get-filename" title="g_test_get_filename ()">g_test_get_filename</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type">const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> * </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-get-dir" title="g_test_get_dir ()">g_test_get_dir</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-fail" title="g_test_fail ()">g_test_fail</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-skip" title="g_test_skip ()">g_test_skip</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-incomplete" title="g_test_incomplete ()">g_test_incomplete</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-failed" title="g_test_failed ()">g_test_failed</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-message" title="g_test_message ()">g_test_message</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-bug-base" title="g_test_bug_base ()">g_test_bug_base</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-bug" title="g_test_bug ()">g_test_bug</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-summary" title="g_test_summary ()">g_test_summary</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> </td> <td class="function_name"> <span class="c_punctuation">(</span><a class="link" href="glib-Testing.html#GTestLogFatalFunc" title="GTestLogFatalFunc ()">*GTestLogFatalFunc</a><span class="c_punctuation">)</span> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-log-set-fatal-handler" title="g_test_log_set_fatal_handler ()">g_test_log_set_fatal_handler</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-timer-start" title="g_test_timer_start ()">g_test_timer_start</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">double</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-timer-elapsed" title="g_test_timer_elapsed ()">g_test_timer_elapsed</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">double</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-timer-last" title="g_test_timer_last ()">g_test_timer_last</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-queue-free" title="g_test_queue_free ()">g_test_queue_free</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-queue-destroy" title="g_test_queue_destroy ()">g_test_queue_destroy</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-queue-unref" title="g_test_queue_unref()">g_test_queue_unref</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-expect-message" title="g_test_expect_message ()">g_test_expect_message</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-assert-expected-messages" title="g_test_assert_expected_messages">g_test_assert_expected_messages</a></td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()">g_test_trap_subprocess</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-trap-has-passed" title="g_test_trap_has_passed ()">g_test_trap_has_passed</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-trap-reached-timeout" title="g_test_trap_reached_timeout ()">g_test_trap_reached_timeout</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-trap-assert-passed" title="g_test_trap_assert_passed">g_test_trap_assert_passed</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-trap-assert-failed" title="g_test_trap_assert_failed">g_test_trap_assert_failed</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-trap-assert-stdout" title="g_test_trap_assert_stdout()">g_test_trap_assert_stdout</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-trap-assert-stdout-unmatched" title="g_test_trap_assert_stdout_unmatched()">g_test_trap_assert_stdout_unmatched</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-trap-assert-stderr" title="g_test_trap_assert_stderr()">g_test_trap_assert_stderr</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-trap-assert-stderr-unmatched" title="g_test_trap_assert_stderr_unmatched()">g_test_trap_assert_stderr_unmatched</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-trap-fork" title="g_test_trap_fork ()">g_test_trap_fork</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-test-rand-bit" title="g_test_rand_bit">g_test_rand_bit</a></td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Basic-Types.html#gint32" title="gint32"><span class="returnvalue">gint32</span></a> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-rand-int" title="g_test_rand_int ()">g_test_rand_int</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Basic-Types.html#gint32" title="gint32"><span class="returnvalue">gint32</span></a> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-rand-int-range" title="g_test_rand_int_range ()">g_test_rand_int_range</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">double</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-rand-double" title="g_test_rand_double ()">g_test_rand_double</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">double</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-rand-double-range" title="g_test_rand_double_range ()">g_test_rand_double_range</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert" title="g_assert()">g_assert</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#g-assert-not-reached" title="g_assert_not_reached">g_assert_not_reached</a></td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-cmpstr" title="g_assert_cmpstr()">g_assert_cmpstr</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-cmpint" title="g_assert_cmpint()">g_assert_cmpint</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-cmpuint" title="g_assert_cmpuint()">g_assert_cmpuint</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-cmphex" title="g_assert_cmphex()">g_assert_cmphex</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-cmpfloat" title="g_assert_cmpfloat()">g_assert_cmpfloat</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-cmpfloat-with-epsilon" title="g_assert_cmpfloat_with_epsilon()">g_assert_cmpfloat_with_epsilon</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-cmpmem" title="g_assert_cmpmem()">g_assert_cmpmem</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-cmpvariant" title="g_assert_cmpvariant()">g_assert_cmpvariant</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-no-error" title="g_assert_no_error()">g_assert_no_error</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-error" title="g_assert_error()">g_assert_error</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-true" title="g_assert_true()">g_assert_true</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-false" title="g_assert_false()">g_assert_false</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-null" title="g_assert_null()">g_assert_null</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="define_keyword">#define</td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-assert-nonnull" title="g_assert_nonnull()">g_assert_nonnull</a><span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-set-nonfatal-assertions" title="g_test_set_nonfatal_assertions ()">g_test_set_nonfatal_assertions</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <span class="c_punctuation">(</span><a class="link" href="glib-Testing.html#GTestFixtureFunc" title="GTestFixtureFunc ()">*GTestFixtureFunc</a><span class="c_punctuation">)</span> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Testing.html#GTestCase" title="GTestCase"><span class="returnvalue">GTestCase</span></a> * </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-create-case" title="g_test_create_case ()">g_test_create_case</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="returnvalue">GTestSuite</span></a> * </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-create-suite" title="g_test_create_suite ()">g_test_create_suite</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="returnvalue">GTestSuite</span></a> * </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-get-root" title="g_test_get_root ()">g_test_get_root</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-suite-add" title="g_test_suite_add ()">g_test_suite_add</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">void</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-suite-add-suite" title="g_test_suite_add_suite ()">g_test_suite_add_suite</a> <span class="c_punctuation">()</span> </td> </tr> <tr> <td class="function_type"> <span class="returnvalue">int</span> </td> <td class="function_name"> <a class="link" href="glib-Testing.html#g-test-run-suite" title="g_test_run_suite ()">g_test_run_suite</a> <span class="c_punctuation">()</span> </td> </tr> </tbody> </table></div> </div> <div class="refsect1"> <a name="glib-Testing.other"></a><h2>Types and Values</h2> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="other_proto_type"> <col class="other_proto_name"> </colgroup> <tbody> <tr> <td class="define_keyword">#define</td> <td class="function_name"><a class="link" href="glib-Testing.html#G-TEST-OPTION-ISOLATE-DIRS:CAPS" title="G_TEST_OPTION_ISOLATE_DIRS">G_TEST_OPTION_ISOLATE_DIRS</a></td> </tr> <tr> <td class="datatype_keyword">enum</td> <td class="function_name"><a class="link" href="glib-Testing.html#GTestFileType" title="enum GTestFileType">GTestFileType</a></td> </tr> <tr> <td class="datatype_keyword">enum</td> <td class="function_name"><a class="link" href="glib-Testing.html#GTestTrapFlags" title="enum GTestTrapFlags">GTestTrapFlags</a></td> </tr> <tr> <td class="datatype_keyword">enum</td> <td class="function_name"><a class="link" href="glib-Testing.html#GTestSubprocessFlags" title="enum GTestSubprocessFlags">GTestSubprocessFlags</a></td> </tr> <tr> <td class="typedef_keyword">typedef</td> <td class="function_name"><a class="link" href="glib-Testing.html#GTestCase" title="GTestCase">GTestCase</a></td> </tr> <tr> <td class="typedef_keyword">typedef</td> <td class="function_name"><a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite">GTestSuite</a></td> </tr> </tbody> </table></div> </div> <div class="refsect1"> <a name="glib-Testing.includes"></a><h2>Includes</h2> <pre class="synopsis">#include <glib.h> #include <glib/gi18n.h> </pre> </div> <div class="refsect1"> <a name="glib-Testing.description"></a><h2>Description</h2> <p>GLib provides a framework for writing and maintaining unit tests in parallel to the code they are testing. The API is designed according to established concepts found in the other test frameworks (JUnit, NUnit, RUnit), which in turn is based on smalltalk unit testing concepts.</p> <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"><p>Test case: Tests (test methods) are grouped together with their fixture into test cases.</p></li> <li class="listitem"><p>Fixture: A test fixture consists of fixture data and setup and teardown methods to establish the environment for the test functions. We use fresh fixtures, i.e. fixtures are newly set up and torn down around each test invocation to avoid dependencies between tests.</p></li> <li class="listitem"><p>Test suite: Test cases can be grouped into test suites, to allow subsets of the available tests to be run. Test suites can be grouped into other test suites as well.</p></li> </ul></div> <p>The API is designed to handle creation and registration of test suites and test cases implicitly. A simple call like</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1</pre></td> <td class="listing_code"><pre class="programlisting"><span class="n">g_test_add_func</span> <span class="p">(</span><span class="s">"/misc/assertions"</span><span class="p">,</span> <span class="n">test_assertions</span><span class="p">);</span></pre></td> </tr> </tbody> </table> </div> <p> creates a test suite called "misc" with a single test case named "assertions", which consists of running the test_assertions function.</p> <p>In addition to the traditional <a class="link" href="glib-Testing.html#g-assert-true" title="g_assert_true()"><code class="function">g_assert_true()</code></a>, the test framework provides an extended set of assertions for comparisons: <a class="link" href="glib-Testing.html#g-assert-cmpfloat" title="g_assert_cmpfloat()"><code class="function">g_assert_cmpfloat()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmpfloat-with-epsilon" title="g_assert_cmpfloat_with_epsilon()"><code class="function">g_assert_cmpfloat_with_epsilon()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmpint" title="g_assert_cmpint()"><code class="function">g_assert_cmpint()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmpuint" title="g_assert_cmpuint()"><code class="function">g_assert_cmpuint()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmphex" title="g_assert_cmphex()"><code class="function">g_assert_cmphex()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmpstr" title="g_assert_cmpstr()"><code class="function">g_assert_cmpstr()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmpmem" title="g_assert_cmpmem()"><code class="function">g_assert_cmpmem()</code></a> and <a class="link" href="glib-Testing.html#g-assert-cmpvariant" title="g_assert_cmpvariant()"><code class="function">g_assert_cmpvariant()</code></a>. The advantage of these variants over plain <a class="link" href="glib-Testing.html#g-assert-true" title="g_assert_true()"><code class="function">g_assert_true()</code></a> is that the assertion messages can be more elaborate, and include the values of the compared entities.</p> <p>Note that <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> should not be used in unit tests, since it is a no-op when compiling with <code class="literal">G_DISABLE_ASSERT</code>. Use <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> in production code, and <a class="link" href="glib-Testing.html#g-assert-true" title="g_assert_true()"><code class="function">g_assert_true()</code></a> in unit tests.</p> <p>A full example of creating a test suite with two tests using fixtures:</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59</pre></td> <td class="listing_code"><pre class="programlisting"><span class="cp">#include</span> <span class="cpf"><glib.h></span><span class="cp"></span> <span class="cp">#include</span> <span class="cpf"><locale.h></span><span class="cp"></span> <span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span> <span class="n">MyObject</span> <span class="o">*</span><span class="n">obj</span><span class="p">;</span> <span class="n">OtherObject</span> <span class="o">*</span><span class="n">helper</span><span class="p">;</span> <span class="p">}</span> <span class="n">MyObjectFixture</span><span class="p">;</span> <span class="k">static</span> <span class="kt">void</span> <span class="nf">my_object_fixture_set_up</span> <span class="p">(</span><span class="n">MyObjectFixture</span> <span class="o">*</span><span class="n">fixture</span><span class="p">,</span> <span class="n">gconstpointer</span> <span class="n">user_data</span><span class="p">)</span> <span class="p">{</span> <span class="n">fixture</span><span class="o">-></span><span class="n">obj</span> <span class="o">=</span> <span class="n">my_object_new</span> <span class="p">();</span> <span class="n">my_object_set_prop1</span> <span class="p">(</span><span class="n">fixture</span><span class="o">-></span><span class="n">obj</span><span class="p">,</span> <span class="s">"some-value"</span><span class="p">);</span> <span class="n">my_object_do_some_complex_setup</span> <span class="p">(</span><span class="n">fixture</span><span class="o">-></span><span class="n">obj</span><span class="p">,</span> <span class="n">user_data</span><span class="p">);</span> <span class="n">fixture</span><span class="o">-></span><span class="n">helper</span> <span class="o">=</span> <span class="n">other_object_new</span> <span class="p">();</span> <span class="p">}</span> <span class="k">static</span> <span class="kt">void</span> <span class="nf">my_object_fixture_tear_down</span> <span class="p">(</span><span class="n">MyObjectFixture</span> <span class="o">*</span><span class="n">fixture</span><span class="p">,</span> <span class="n">gconstpointer</span> <span class="n">user_data</span><span class="p">)</span> <span class="p">{</span> <span class="n">g_clear_object</span> <span class="p">(</span><span class="o">&</span><span class="n">fixture</span><span class="o">-></span><span class="n">helper</span><span class="p">);</span> <span class="n">g_clear_object</span> <span class="p">(</span><span class="o">&</span><span class="n">fixture</span><span class="o">-></span><span class="n">obj</span><span class="p">);</span> <span class="p">}</span> <span class="k">static</span> <span class="kt">void</span> <span class="nf">test_my_object_test1</span> <span class="p">(</span><span class="n">MyObjectFixture</span> <span class="o">*</span><span class="n">fixture</span><span class="p">,</span> <span class="n">gconstpointer</span> <span class="n">user_data</span><span class="p">)</span> <span class="p">{</span> <span class="n">g_assert_cmpstr</span> <span class="p">(</span><span class="n">my_object_get_property</span> <span class="p">(</span><span class="n">fixture</span><span class="o">-></span><span class="n">obj</span><span class="p">),</span> <span class="o">==</span><span class="p">,</span> <span class="s">"initial-value"</span><span class="p">);</span> <span class="p">}</span> <span class="k">static</span> <span class="kt">void</span> <span class="nf">test_my_object_test2</span> <span class="p">(</span><span class="n">MyObjectFixture</span> <span class="o">*</span><span class="n">fixture</span><span class="p">,</span> <span class="n">gconstpointer</span> <span class="n">user_data</span><span class="p">)</span> <span class="p">{</span> <span class="n">my_object_do_some_work_using_helper</span> <span class="p">(</span><span class="n">fixture</span><span class="o">-></span><span class="n">obj</span><span class="p">,</span> <span class="n">fixture</span><span class="o">-></span><span class="n">helper</span><span class="p">);</span> <span class="n">g_assert_cmpstr</span> <span class="p">(</span><span class="n">my_object_get_property</span> <span class="p">(</span><span class="n">fixture</span><span class="o">-></span><span class="n">obj</span><span class="p">),</span> <span class="o">==</span><span class="p">,</span> <span class="s">"updated-value"</span><span class="p">);</span> <span class="p">}</span> <span class="kt">int</span> <span class="nf">main</span> <span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">*</span><span class="n">argv</span><span class="p">[])</span> <span class="p">{</span> <span class="n">setlocale</span> <span class="p">(</span><span class="n">LC_ALL</span><span class="p">,</span> <span class="s">""</span><span class="p">);</span> <span class="n">g_test_init</span> <span class="p">(</span><span class="o">&</span><span class="n">argc</span><span class="p">,</span> <span class="o">&</span><span class="n">argv</span><span class="p">,</span> <span class="nb">NULL</span><span class="p">);</span> <span class="c1">// Define the tests.</span> <span class="n">g_test_add</span> <span class="p">(</span><span class="s">"/my-object/test1"</span><span class="p">,</span> <span class="n">MyObjectFixture</span><span class="p">,</span> <span class="s">"some-user-data"</span><span class="p">,</span> <span class="n">my_object_fixture_set_up</span><span class="p">,</span> <span class="n">test_my_object_test1</span><span class="p">,</span> <span class="n">my_object_fixture_tear_down</span><span class="p">);</span> <span class="n">g_test_add</span> <span class="p">(</span><span class="s">"/my-object/test2"</span><span class="p">,</span> <span class="n">MyObjectFixture</span><span class="p">,</span> <span class="s">"some-user-data"</span><span class="p">,</span> <span class="n">my_object_fixture_set_up</span><span class="p">,</span> <span class="n">test_my_object_test2</span><span class="p">,</span> <span class="n">my_object_fixture_tear_down</span><span class="p">);</span> <span class="k">return</span> <span class="n">g_test_run</span> <span class="p">();</span> <span class="p">}</span></pre></td> </tr> </tbody> </table> </div> <p></p> <p>### Integrating GTest in your project</p> <p>If you are using the <a class="ulink" href="http://mesonbuild.com" target="_top">Meson</a> build system, you will typically use the provided <code class="literal"><code class="function">test()</code></code> primitive to call the test binaries, e.g.:</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17</pre></td> <td class="listing_code"><pre class="programlisting"><span class="n">test</span><span class="p">(</span> <span class="err">'</span><span class="n">foo</span><span class="err">'</span><span class="p">,</span> <span class="n">executable</span><span class="p">(</span><span class="err">'</span><span class="n">foo</span><span class="err">'</span><span class="p">,</span> <span class="err">'</span><span class="n">foo</span><span class="p">.</span><span class="n">c</span><span class="err">'</span><span class="p">,</span> <span class="nl">dependencies</span><span class="p">:</span> <span class="n">deps</span><span class="p">),</span> <span class="nl">env</span><span class="p">:</span> <span class="p">[</span> <span class="err">'</span><span class="n">G_TEST_SRCDIR</span><span class="o">=</span><span class="err">@</span><span class="mi">0</span><span class="err">@'</span><span class="p">.</span><span class="n">format</span><span class="p">(</span><span class="n">meson</span><span class="p">.</span><span class="n">current_source_dir</span><span class="p">()),</span> <span class="err">'</span><span class="n">G_TEST_BUILDDIR</span><span class="o">=</span><span class="err">@</span><span class="mi">0</span><span class="err">@'</span><span class="p">.</span><span class="n">format</span><span class="p">(</span><span class="n">meson</span><span class="p">.</span><span class="n">current_build_dir</span><span class="p">()),</span> <span class="p">],</span> <span class="p">)</span> <span class="n">test</span><span class="p">(</span> <span class="err">'</span><span class="n">bar</span><span class="err">'</span><span class="p">,</span> <span class="n">executable</span><span class="p">(</span><span class="err">'</span><span class="n">bar</span><span class="err">'</span><span class="p">,</span> <span class="err">'</span><span class="n">bar</span><span class="p">.</span><span class="n">c</span><span class="err">'</span><span class="p">,</span> <span class="nl">dependencies</span><span class="p">:</span> <span class="n">deps</span><span class="p">),</span> <span class="nl">env</span><span class="p">:</span> <span class="p">[</span> <span class="err">'</span><span class="n">G_TEST_SRCDIR</span><span class="o">=</span><span class="err">@</span><span class="mi">0</span><span class="err">@'</span><span class="p">.</span><span class="n">format</span><span class="p">(</span><span class="n">meson</span><span class="p">.</span><span class="n">current_source_dir</span><span class="p">()),</span> <span class="err">'</span><span class="n">G_TEST_BUILDDIR</span><span class="o">=</span><span class="err">@</span><span class="mi">0</span><span class="err">@'</span><span class="p">.</span><span class="n">format</span><span class="p">(</span><span class="n">meson</span><span class="p">.</span><span class="n">current_build_dir</span><span class="p">()),</span> <span class="p">],</span> <span class="p">)</span></pre></td> </tr> </tbody> </table> </div> <p></p> <p>If you are using Autotools, you're strongly encouraged to use the Automake <a class="ulink" href="https://testanything.org/" target="_top">TAP</a> harness; GLib provides template files for easily integrating with it:</p> <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"><p><a class="ulink" href="https://gitlab.gnome.org/GNOME/glib/blob/glib-2-58/glib-tap.mk" target="_top">glib-tap.mk</a></p></li> <li class="listitem"><p><a class="ulink" href="https://gitlab.gnome.org/GNOME/glib/blob/glib-2-58/tap-test" target="_top">tap-test</a></p></li> <li class="listitem"><p><a class="ulink" href="https://gitlab.gnome.org/GNOME/glib/blob/glib-2-58/tap-driver.sh" target="_top">tap-driver.sh</a></p></li> </ul></div> <p>You can copy these files in your own project's root directory, and then set up your <code class="literal">Makefile.am</code> file to reference them, for instance:</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15</pre></td> <td class="listing_code"><pre class="programlisting"><span class="n">include</span> <span class="err">$</span><span class="p">(</span><span class="n">top_srcdir</span><span class="p">)</span><span class="o">/</span><span class="n">glib</span><span class="o">-</span><span class="n">tap</span><span class="p">.</span><span class="n">mk</span> <span class="cp"># test binaries</span> <span class="n">test_programs</span> <span class="o">=</span> \ <span class="n">foo</span> \ <span class="n">bar</span> <span class="cp"># data distributed in the tarball</span> <span class="n">dist_test_data</span> <span class="o">=</span> \ <span class="n">foo</span><span class="p">.</span><span class="n">data</span><span class="p">.</span><span class="n">txt</span> \ <span class="n">bar</span><span class="p">.</span><span class="n">data</span><span class="p">.</span><span class="n">txt</span> <span class="cp"># data not distributed in the tarball</span> <span class="n">test_data</span> <span class="o">=</span> \ <span class="n">blah</span><span class="p">.</span><span class="n">data</span><span class="p">.</span><span class="n">txt</span></pre></td> </tr> </tbody> </table> </div> <p></p> <p>Make sure to distribute the TAP files, using something like the following in your top-level <code class="literal">Makefile.am</code>:</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1 2 3</pre></td> <td class="listing_code"><pre class="programlisting"><span class="n">EXTRA_DIST</span> <span class="o">+=</span> \ <span class="n">tap</span><span class="o">-</span><span class="n">driver</span><span class="p">.</span><span class="n">sh</span> \ <span class="n">tap</span><span class="o">-</span><span class="n">test</span></pre></td> </tr> </tbody> </table> </div> <p></p> <p><code class="literal">glib-tap.mk</code> will be distributed implicitly due to being included in a <code class="literal">Makefile.am</code>. All three files should be added to version control.</p> <p>If you don't have access to the Autotools TAP harness, you can use the gtester and gtester-report tools, and use the <a class="ulink" href="https://gitlab.gnome.org/GNOME/glib/blob/glib-2-58/glib.mk" target="_top">glib.mk</a> Automake template provided by GLib. Note, however, that since GLib 2.62, gtester and gtester-report have been deprecated in favour of using TAP. The <code class="literal">--tap</code> argument to tests is enabled by default as of GLib 2.62.</p> </div> <div class="refsect1"> <a name="glib-Testing.functions_details"></a><h2>Functions</h2> <div class="refsect2"> <a name="g-test-minimized-result"></a><h3>g_test_minimized_result ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_minimized_result (<em class="parameter"><code><span class="type">double</span> minimized_quantity</code></em>, <em class="parameter"><code>const <span class="type">char</span> *format</code></em>, <em class="parameter"><code>...</code></em>);</pre> <p>Report the result of a performance or measurement test. The test should generally strive to minimize the reported quantities (smaller values are better than larger ones), this and <em class="parameter"><code>minimized_quantity</code></em> can determine sorting order for test result reports.</p> <div class="refsect3"> <a name="g-test-minimized-result.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>minimized_quantity</p></td> <td class="parameter_description"><p>the reported value</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>format</p></td> <td class="parameter_description"><p>the format string of the report message</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>...</p></td> <td class="parameter_description"><p>arguments to pass to the <code class="function">printf()</code> function</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-maximized-result"></a><h3>g_test_maximized_result ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_maximized_result (<em class="parameter"><code><span class="type">double</span> maximized_quantity</code></em>, <em class="parameter"><code>const <span class="type">char</span> *format</code></em>, <em class="parameter"><code>...</code></em>);</pre> <p>Report the result of a performance or measurement test. The test should generally strive to maximize the reported quantities (larger values are better than smaller ones), this and <em class="parameter"><code>maximized_quantity</code></em> can determine sorting order for test result reports.</p> <div class="refsect3"> <a name="g-test-maximized-result.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>maximized_quantity</p></td> <td class="parameter_description"><p>the reported value</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>format</p></td> <td class="parameter_description"><p>the format string of the report message</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>...</p></td> <td class="parameter_description"><p>arguments to pass to the <code class="function">printf()</code> function</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-init"></a><h3>g_test_init ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_init (<em class="parameter"><code><span class="type">int</span> *argc</code></em>, <em class="parameter"><code><span class="type">char</span> ***argv</code></em>, <em class="parameter"><code>...</code></em>);</pre> <p>Initialize the GLib testing framework, e.g. by seeding the test random number generator, the name for <a class="link" href="glib-Miscellaneous-Utility-Functions.html#g-get-prgname" title="g_get_prgname ()"><code class="function">g_get_prgname()</code></a> and parsing test related command line args.</p> <p>So far, the following arguments are understood:</p> <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"><p><code class="literal">-l</code>: List test cases available in a test executable.</p></li> <li class="listitem"><p><code class="literal">--seed=SEED</code>: Provide a random seed to reproduce test runs using random numbers.</p></li> <li class="listitem"><p><code class="literal">--verbose</code>: Run tests verbosely.</p></li> <li class="listitem"><p><code class="literal">-q</code>, <code class="literal">--quiet</code>: Run tests quietly.</p></li> <li class="listitem"><p><code class="literal">-p PATH</code>: Execute all tests matching the given path.</p></li> <li class="listitem"><p><code class="literal">-s PATH</code>: Skip all tests matching the given path. This can also be used to force a test to run that would otherwise be skipped (ie, a test whose name contains "/subprocess").</p></li> <li class="listitem"> <p><code class="literal">-m {perf|slow|thorough|quick|undefined|no-undefined}</code>: Execute tests according to these test modes:</p> <p><code class="literal">perf</code>: Performance tests, may take long and report results (off by default).</p> <p><code class="literal">slow</code>, <code class="literal">thorough</code>: Slow and thorough tests, may take quite long and maximize coverage (off by default).</p> <p><code class="literal">quick</code>: Quick tests, should run really quickly and give good coverage (the default).</p> <p><code class="literal">undefined</code>: Tests for undefined behaviour, may provoke programming errors under <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a> or <a class="link" href="glib-Testing.html#g-test-expect-message" title="g_test_expect_message ()"><code class="function">g_test_expect_message()</code></a> to check that appropriate assertions or warnings are given (the default).</p> <p><code class="literal">no-undefined</code>: Avoid tests for undefined behaviour</p> </li> <li class="listitem"><p><code class="literal">--debug-log</code>: Debug test logging output.</p></li> </ul></div> <p>Options which can be passed to @... are:</p> <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"><p><code class="literal">"no_g_set_prgname"</code>: Causes <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a> to not call <a class="link" href="glib-Miscellaneous-Utility-Functions.html#g-set-prgname" title="g_set_prgname ()"><code class="function">g_set_prgname()</code></a>.</p></li> <li class="listitem"><p><a class="link" href="glib-Testing.html#G-TEST-OPTION-ISOLATE-DIRS:CAPS" title="G_TEST_OPTION_ISOLATE_DIRS"><code class="literal">G_TEST_OPTION_ISOLATE_DIRS</code></a>: Creates a unique temporary directory for each unit test and uses <code class="function">g_set_user_dirs()</code> to set XDG directories to point into that temporary directory for the duration of the unit test. See the documentation for <a class="link" href="glib-Testing.html#G-TEST-OPTION-ISOLATE-DIRS:CAPS" title="G_TEST_OPTION_ISOLATE_DIRS"><code class="literal">G_TEST_OPTION_ISOLATE_DIRS</code></a>.</p></li> </ul></div> <p>Since 2.58, if tests are compiled with <code class="literal">G_DISABLE_ASSERT</code> defined, <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a> will print an error and exit. This is to prevent no-op tests from being executed, as <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> is commonly (erroneously) used in unit tests, and is a no-op when compiled with <code class="literal">G_DISABLE_ASSERT</code>. Ensure your tests are compiled without <code class="literal">G_DISABLE_ASSERT</code> defined.</p> <div class="refsect3"> <a name="g-test-init.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>argc</p></td> <td class="parameter_description"><p>Address of the <em class="parameter"><code>argc</code></em> parameter of the <code class="function">main()</code> function. Changed if any arguments were handled.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>argv</p></td> <td class="parameter_description"><p>Address of the <em class="parameter"><code>argv</code></em> parameter of <code class="function">main()</code>. Any parameters understood by <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a> stripped before return.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>...</p></td> <td class="parameter_description"><p><a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>-terminated list of special options, documented below.</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-initialized"></a><h3>g_test_initialized</h3> <pre class="programlisting">#define g_test_initialized()</pre> <p>Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a> has been called.</p> <div class="refsect3"> <a name="g-test-initialized.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a> has been called.</p> </div> <p class="since">Since: <a class="link" href="api-index-2-36.html#api-index-2.36">2.36</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-quick"></a><h3>g_test_quick</h3> <pre class="programlisting">#define g_test_quick()</pre> <p>Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if tests are run in quick mode. Exactly one of <a class="link" href="glib-Testing.html#g-test-quick" title="g_test_quick"><code class="function">g_test_quick()</code></a> and <a class="link" href="glib-Testing.html#g-test-slow" title="g_test_slow"><code class="function">g_test_slow()</code></a> is active in any run; there is no "medium speed".</p> <p>By default, tests are run in quick mode. In tests that use <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>, the options <code class="literal">-m quick</code>, <code class="literal">-m slow</code> and <code class="literal">-m thorough</code> can be used to change this.</p> <div class="refsect3"> <a name="g-test-quick.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if in quick mode</p> </div> </div> <hr> <div class="refsect2"> <a name="g-test-slow"></a><h3>g_test_slow</h3> <pre class="programlisting">#define g_test_slow()</pre> <p>Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if tests are run in slow mode. Exactly one of <a class="link" href="glib-Testing.html#g-test-quick" title="g_test_quick"><code class="function">g_test_quick()</code></a> and <a class="link" href="glib-Testing.html#g-test-slow" title="g_test_slow"><code class="function">g_test_slow()</code></a> is active in any run; there is no "medium speed".</p> <p>By default, tests are run in quick mode. In tests that use <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>, the options <code class="literal">-m quick</code>, <code class="literal">-m slow</code> and <code class="literal">-m thorough</code> can be used to change this.</p> <div class="refsect3"> <a name="g-test-slow.returns"></a><h4>Returns</h4> <p> the opposite of <a class="link" href="glib-Testing.html#g-test-quick" title="g_test_quick"><code class="function">g_test_quick()</code></a></p> </div> </div> <hr> <div class="refsect2"> <a name="g-test-thorough"></a><h3>g_test_thorough</h3> <pre class="programlisting">#define g_test_thorough()</pre> <p>Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if tests are run in thorough mode, equivalent to <a class="link" href="glib-Testing.html#g-test-slow" title="g_test_slow"><code class="function">g_test_slow()</code></a>.</p> <p>By default, tests are run in quick mode. In tests that use <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>, the options <code class="literal">-m quick</code>, <code class="literal">-m slow</code> and <code class="literal">-m thorough</code> can be used to change this.</p> <div class="refsect3"> <a name="g-test-thorough.returns"></a><h4>Returns</h4> <p> the same thing as <a class="link" href="glib-Testing.html#g-test-slow" title="g_test_slow"><code class="function">g_test_slow()</code></a></p> </div> </div> <hr> <div class="refsect2"> <a name="g-test-perf"></a><h3>g_test_perf</h3> <pre class="programlisting">#define g_test_perf()</pre> <p>Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if tests are run in performance mode.</p> <p>By default, tests are run in quick mode. In tests that use <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>, the option <code class="literal">-m perf</code> enables performance tests, while <code class="literal">-m quick</code> disables them.</p> <div class="refsect3"> <a name="g-test-perf.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if in performance mode</p> </div> </div> <hr> <div class="refsect2"> <a name="g-test-verbose"></a><h3>g_test_verbose</h3> <pre class="programlisting">#define g_test_verbose()</pre> <p>Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if tests are run in verbose mode. In tests that use <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>, the option <code class="literal">--verbose</code> enables this, while <code class="literal">-q</code> or <code class="literal">--quiet</code> disables it. The default is neither <a class="link" href="glib-Testing.html#g-test-verbose" title="g_test_verbose"><code class="function">g_test_verbose()</code></a> nor <a class="link" href="glib-Testing.html#g-test-quiet" title="g_test_quiet"><code class="function">g_test_quiet()</code></a>.</p> <div class="refsect3"> <a name="g-test-verbose.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if in verbose mode</p> </div> </div> <hr> <div class="refsect2"> <a name="g-test-undefined"></a><h3>g_test_undefined</h3> <pre class="programlisting">#define g_test_undefined()</pre> <p>Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if tests may provoke assertions and other formally-undefined behaviour, to verify that appropriate warnings are given. It might, in some cases, be useful to turn this off with if running tests under valgrind; in tests that use <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>, the option <code class="literal">-m no-undefined</code> disables those tests, while <code class="literal">-m undefined</code> explicitly enables them (the default behaviour).</p> <div class="refsect3"> <a name="g-test-undefined.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if tests may provoke programming errors</p> </div> </div> <hr> <div class="refsect2"> <a name="g-test-quiet"></a><h3>g_test_quiet</h3> <pre class="programlisting">#define g_test_quiet()</pre> <p>Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if tests are run in quiet mode. In tests that use <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>, the option <code class="literal">-q</code> or <code class="literal">--quiet</code> enables this, while <code class="literal">--verbose</code> disables it. The default is neither <a class="link" href="glib-Testing.html#g-test-verbose" title="g_test_verbose"><code class="function">g_test_verbose()</code></a> nor <a class="link" href="glib-Testing.html#g-test-quiet" title="g_test_quiet"><code class="function">g_test_quiet()</code></a>.</p> <div class="refsect3"> <a name="g-test-quiet.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if in quiet mode</p> </div> </div> <hr> <div class="refsect2"> <a name="g-test-subprocess"></a><h3>g_test_subprocess ()</h3> <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> g_test_subprocess (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> (after <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a> has been called) if the test program is running under <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> <div class="refsect3"> <a name="g-test-subprocess.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the test program is running under <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-run"></a><h3>g_test_run ()</h3> <pre class="programlisting"><span class="returnvalue">int</span> g_test_run (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Runs all tests under the toplevel suite which can be retrieved with <a class="link" href="glib-Testing.html#g-test-get-root" title="g_test_get_root ()"><code class="function">g_test_get_root()</code></a>. Similar to <a class="link" href="glib-Testing.html#g-test-run-suite" title="g_test_run_suite ()"><code class="function">g_test_run_suite()</code></a>, the test cases to be run are filtered according to test path arguments (<code class="literal">-p testpath</code> and <code class="literal">-s testpath</code>) as parsed by <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>. <a class="link" href="glib-Testing.html#g-test-run-suite" title="g_test_run_suite ()"><code class="function">g_test_run_suite()</code></a> or <a class="link" href="glib-Testing.html#g-test-run" title="g_test_run ()"><code class="function">g_test_run()</code></a> may only be called once in a program.</p> <p>In general, the tests and sub-suites within each suite are run in the order in which they are defined. However, note that prior to GLib 2.36, there was a bug in the <code class="literal">g_test_add_*</code> functions which caused them to create multiple suites with the same name, meaning that if you created tests "/foo/simple", "/bar/simple", and "/foo/using-bar" in that order, they would get run in that order (since <a class="link" href="glib-Testing.html#g-test-run" title="g_test_run ()"><code class="function">g_test_run()</code></a> would run the first "/foo" suite, then the "/bar" suite, then the second "/foo" suite). As of 2.36, this bug is fixed, and adding the tests in that order would result in a running order of "/foo/simple", "/foo/using-bar", "/bar/simple". If this new ordering is sub-optimal (because it puts more-complicated tests before simpler ones, making it harder to figure out exactly what has failed), you can fix it by changing the test paths to group tests by suite in a way that will result in the desired running order. Eg, "/simple/foo", "/simple/bar", "/complex/foo-using-bar".</p> <p>However, you should never make the actual result of a test depend on the order that tests are run in. If you need to ensure that some particular code runs before or after a given test case, use <a class="link" href="glib-Testing.html#g-test-add" title="g_test_add()"><code class="function">g_test_add()</code></a>, which lets you specify setup and teardown functions.</p> <p>If all tests are skipped or marked as incomplete (expected failures), this function will return 0 if producing TAP output, or 77 (treated as "skip test" by Automake) otherwise.</p> <div class="refsect3"> <a name="g-test-run.returns"></a><h4>Returns</h4> <p> 0 on success, 1 on failure (assuming it returns at all), 0 or 77 if all tests were skipped with <a class="link" href="glib-Testing.html#g-test-skip" title="g_test_skip ()"><code class="function">g_test_skip()</code></a> and/or <a class="link" href="glib-Testing.html#g-test-incomplete" title="g_test_incomplete ()"><code class="function">g_test_incomplete()</code></a></p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="GTestFunc"></a><h3>GTestFunc ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> <span class="c_punctuation">(</span>*GTestFunc<span class="c_punctuation">)</span> (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>The type used for test case functions.</p> <p class="since">Since: <a class="link" href="api-index-2-28.html#api-index-2.28">2.28</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-add-func"></a><h3>g_test_add_func ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_add_func (<em class="parameter"><code>const <span class="type">char</span> *testpath</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestFunc" title="GTestFunc ()"><span class="type">GTestFunc</span></a> test_func</code></em>);</pre> <p>Create a new test case, similar to <a class="link" href="glib-Testing.html#g-test-create-case" title="g_test_create_case ()"><code class="function">g_test_create_case()</code></a>. However the test is assumed to use no fixture, and test suites are automatically created on the fly and added to the root fixture, based on the slash-separated portions of <em class="parameter"><code>testpath</code></em> .</p> <p>If <em class="parameter"><code>testpath</code></em> includes the component "subprocess" anywhere in it, the test will be skipped by default, and only run if explicitly required via the <code class="literal">-p</code> command-line option or <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> <p>No component of <em class="parameter"><code>testpath</code></em> may start with a dot (<code class="literal">.</code>) if the <a class="link" href="glib-Testing.html#G-TEST-OPTION-ISOLATE-DIRS:CAPS" title="G_TEST_OPTION_ISOLATE_DIRS"><code class="literal">G_TEST_OPTION_ISOLATE_DIRS</code></a> option is being used; and it is recommended to do so even if it isn’t.</p> <div class="refsect3"> <a name="g-test-add-func.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>testpath</p></td> <td class="parameter_description"><p>/-separated test case path name for the test.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>test_func</p></td> <td class="parameter_description"><p>The test function to invoke for this test. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="The callback is valid until first called."><span class="acronym">scope async</span></acronym>]</span></td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="GTestDataFunc"></a><h3>GTestDataFunc ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> <span class="c_punctuation">(</span>*GTestDataFunc<span class="c_punctuation">)</span> (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> user_data</code></em>);</pre> <p>The type used for test case functions that take an extra pointer argument.</p> <div class="refsect3"> <a name="GTestDataFunc.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>user_data</p></td> <td class="parameter_description"><p>the data provided when registering the test</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-28.html#api-index-2.28">2.28</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-add-data-func"></a><h3>g_test_add_data_func ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_add_data_func (<em class="parameter"><code>const <span class="type">char</span> *testpath</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> test_data</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestDataFunc" title="GTestDataFunc ()"><span class="type">GTestDataFunc</span></a> test_func</code></em>);</pre> <p>Create a new test case, similar to <a class="link" href="glib-Testing.html#g-test-create-case" title="g_test_create_case ()"><code class="function">g_test_create_case()</code></a>. However the test is assumed to use no fixture, and test suites are automatically created on the fly and added to the root fixture, based on the slash-separated portions of <em class="parameter"><code>testpath</code></em> . The <em class="parameter"><code>test_data</code></em> argument will be passed as first argument to <em class="parameter"><code>test_func</code></em> .</p> <p>If <em class="parameter"><code>testpath</code></em> includes the component "subprocess" anywhere in it, the test will be skipped by default, and only run if explicitly required via the <code class="literal">-p</code> command-line option or <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> <p>No component of <em class="parameter"><code>testpath</code></em> may start with a dot (<code class="literal">.</code>) if the <a class="link" href="glib-Testing.html#G-TEST-OPTION-ISOLATE-DIRS:CAPS" title="G_TEST_OPTION_ISOLATE_DIRS"><code class="literal">G_TEST_OPTION_ISOLATE_DIRS</code></a> option is being used; and it is recommended to do so even if it isn’t.</p> <div class="refsect3"> <a name="g-test-add-data-func.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>testpath</p></td> <td class="parameter_description"><p>/-separated test case path name for the test.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>test_data</p></td> <td class="parameter_description"><p>Test data argument for the test function.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>test_func</p></td> <td class="parameter_description"><p>The test function to invoke for this test. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="The callback is valid until first called."><span class="acronym">scope async</span></acronym>]</span></td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-add-data-func-full"></a><h3>g_test_add_data_func_full ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_add_data_func_full (<em class="parameter"><code>const <span class="type">char</span> *testpath</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> test_data</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestDataFunc" title="GTestDataFunc ()"><span class="type">GTestDataFunc</span></a> test_func</code></em>, <em class="parameter"><code><a class="link" href="glib-Datasets.html#GDestroyNotify" title="GDestroyNotify ()"><span class="type">GDestroyNotify</span></a> data_free_func</code></em>);</pre> <p>Create a new test case, as with <a class="link" href="glib-Testing.html#g-test-add-data-func" title="g_test_add_data_func ()"><code class="function">g_test_add_data_func()</code></a>, but freeing <em class="parameter"><code>test_data</code></em> after the test run is complete.</p> <div class="refsect3"> <a name="g-test-add-data-func-full.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>testpath</p></td> <td class="parameter_description"><p>/-separated test case path name for the test.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>test_data</p></td> <td class="parameter_description"><p>Test data argument for the test function.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>test_func</p></td> <td class="parameter_description"><p>The test function to invoke for this test.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>data_free_func</p></td> <td class="parameter_description"><p><a class="link" href="glib-Datasets.html#GDestroyNotify" title="GDestroyNotify ()"><span class="type">GDestroyNotify</span></a> for <em class="parameter"><code>test_data</code></em> .</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-34.html#api-index-2.34">2.34</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-add"></a><h3>g_test_add()</h3> <pre class="programlisting">#define g_test_add(testpath, Fixture, tdata, fsetup, ftest, fteardown)</pre> <p>Hook up a new test case at <em class="parameter"><code>testpath</code></em> , similar to <a class="link" href="glib-Testing.html#g-test-add-func" title="g_test_add_func ()"><code class="function">g_test_add_func()</code></a>. A fixture data structure with setup and teardown functions may be provided, similar to <a class="link" href="glib-Testing.html#g-test-create-case" title="g_test_create_case ()"><code class="function">g_test_create_case()</code></a>.</p> <p>g_test_add() is implemented as a macro, so that the <code class="function">fsetup()</code>, <code class="function">ftest()</code> and <code class="function">fteardown()</code> callbacks can expect a <em class="parameter"><code>Fixture</code></em> pointer as their first argument in a type safe manner. They otherwise have type <a class="link" href="glib-Testing.html#GTestFixtureFunc" title="GTestFixtureFunc ()"><span class="type">GTestFixtureFunc</span></a>.</p> <div class="refsect3"> <a name="g-test-add.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>testpath</p></td> <td class="parameter_description"><p>The test path for a new test case.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>Fixture</p></td> <td class="parameter_description"><p>The type of a fixture data structure.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>tdata</p></td> <td class="parameter_description"><p>Data argument for the test functions.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>fsetup</p></td> <td class="parameter_description"><p>The function to set up the fixture data.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>ftest</p></td> <td class="parameter_description"><p>The actual test function.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>fteardown</p></td> <td class="parameter_description"><p>The function to tear down the fixture data.</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-build-filename"></a><h3>g_test_build_filename ()</h3> <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> * g_test_build_filename (<em class="parameter"><code><a class="link" href="glib-Testing.html#GTestFileType" title="enum GTestFileType"><span class="type">GTestFileType</span></a> file_type</code></em>, <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *first_path</code></em>, <em class="parameter"><code>...</code></em>);</pre> <p>Creates the pathname to a data file that is required for a test.</p> <p>This function is conceptually similar to <a class="link" href="glib-Miscellaneous-Utility-Functions.html#g-build-filename" title="g_build_filename ()"><code class="function">g_build_filename()</code></a> except that the first argument has been replaced with a <a class="link" href="glib-Testing.html#GTestFileType" title="enum GTestFileType"><span class="type">GTestFileType</span></a> argument.</p> <p>The data file should either have been distributed with the module containing the test (<a class="link" href="glib-Testing.html#G-TEST-DIST:CAPS"><code class="literal">G_TEST_DIST</code></a>) or built as part of the build system of that module (<a class="link" href="glib-Testing.html#G-TEST-BUILT:CAPS"><code class="literal">G_TEST_BUILT</code></a>).</p> <p>In order for this function to work in srcdir != builddir situations, the G_TEST_SRCDIR and G_TEST_BUILDDIR environment variables need to have been defined. As of 2.38, this is done by the glib.mk included in GLib. Please ensure that your copy is up to date before using this function.</p> <p>In case neither variable is set, this function will fall back to using the dirname portion of argv[0], possibly removing ".libs". This allows for casual running of tests directly from the commandline in the srcdir == builddir case and should also support running of installed tests, assuming the data files have been installed in the same relative path as the test binary.</p> <div class="refsect3"> <a name="g-test-build-filename.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>file_type</p></td> <td class="parameter_description"><p>the type of file (built vs. distributed)</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>first_path</p></td> <td class="parameter_description"><p>the first segment of the pathname</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>...</p></td> <td class="parameter_description"><p><a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>-terminated additional path segments</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <div class="refsect3"> <a name="g-test-build-filename.returns"></a><h4>Returns</h4> <p> the path of the file, to be freed using <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a></p> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-get-filename"></a><h3>g_test_get_filename ()</h3> <pre class="programlisting">const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> * g_test_get_filename (<em class="parameter"><code><a class="link" href="glib-Testing.html#GTestFileType" title="enum GTestFileType"><span class="type">GTestFileType</span></a> file_type</code></em>, <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *first_path</code></em>, <em class="parameter"><code>...</code></em>);</pre> <p>Gets the pathname to a data file that is required for a test.</p> <p>This is the same as <a class="link" href="glib-Testing.html#g-test-build-filename" title="g_test_build_filename ()"><code class="function">g_test_build_filename()</code></a> with two differences. The first difference is that must only use this function from within a testcase function. The second difference is that you need not free the return value -- it will be automatically freed when the testcase finishes running.</p> <p>It is safe to use this function from a thread inside of a testcase but you must ensure that all such uses occur before the main testcase function returns (ie: it is best to ensure that all threads have been joined).</p> <div class="refsect3"> <a name="g-test-get-filename.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>file_type</p></td> <td class="parameter_description"><p>the type of file (built vs. distributed)</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>first_path</p></td> <td class="parameter_description"><p>the first segment of the pathname</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>...</p></td> <td class="parameter_description"><p><a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>-terminated additional path segments</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <div class="refsect3"> <a name="g-test-get-filename.returns"></a><h4>Returns</h4> <p> the path, automatically freed at the end of the testcase</p> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-get-dir"></a><h3>g_test_get_dir ()</h3> <pre class="programlisting">const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> * g_test_get_dir (<em class="parameter"><code><a class="link" href="glib-Testing.html#GTestFileType" title="enum GTestFileType"><span class="type">GTestFileType</span></a> file_type</code></em>);</pre> <p>Gets the pathname of the directory containing test files of the type specified by <em class="parameter"><code>file_type</code></em> .</p> <p>This is approximately the same as calling g_test_build_filename("."), but you don't need to free the return value.</p> <div class="refsect3"> <a name="g-test-get-dir.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>file_type</p></td> <td class="parameter_description"><p>the type of file (built vs. distributed)</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <div class="refsect3"> <a name="g-test-get-dir.returns"></a><h4>Returns</h4> <p>the path of the directory, owned by GLib. </p> <p><span class="annotation">[<acronym title="Override the parsed C type with given type."><span class="acronym">type</span></acronym> filename]</span></p> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-fail"></a><h3>g_test_fail ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_fail (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Indicates that a test failed. This function can be called multiple times from the same test. You can use this function if your test failed in a recoverable way.</p> <p>Do not use this function if the failure of a test could cause other tests to malfunction.</p> <p>Calling this function will not stop the test from running, you need to return from the test function yourself. So you can produce additional diagnostic messages or even continue running the test.</p> <p>If not called from inside a test, this function does nothing.</p> <p class="since">Since: <a class="link" href="api-index-2-30.html#api-index-2.30">2.30</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-skip"></a><h3>g_test_skip ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_skip (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *msg</code></em>);</pre> <p>Indicates that a test was skipped.</p> <p>Calling this function will not stop the test from running, you need to return from the test function yourself. So you can produce additional diagnostic messages or even continue running the test.</p> <p>If not called from inside a test, this function does nothing.</p> <div class="refsect3"> <a name="g-test-skip.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>msg</p></td> <td class="parameter_description"><p>explanation. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="NULL may be passed as the value in, out, in-out; or as a return value."><span class="acronym">nullable</span></acronym>]</span></td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-incomplete"></a><h3>g_test_incomplete ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_incomplete (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *msg</code></em>);</pre> <p>Indicates that a test failed because of some incomplete functionality. This function can be called multiple times from the same test.</p> <p>Calling this function will not stop the test from running, you need to return from the test function yourself. So you can produce additional diagnostic messages or even continue running the test.</p> <p>If not called from inside a test, this function does nothing.</p> <div class="refsect3"> <a name="g-test-incomplete.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>msg</p></td> <td class="parameter_description"><p>explanation. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="NULL may be passed as the value in, out, in-out; or as a return value."><span class="acronym">nullable</span></acronym>]</span></td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-failed"></a><h3>g_test_failed ()</h3> <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> g_test_failed (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Returns whether a test has already failed. This will be the case when <a class="link" href="glib-Testing.html#g-test-fail" title="g_test_fail ()"><code class="function">g_test_fail()</code></a>, <a class="link" href="glib-Testing.html#g-test-incomplete" title="g_test_incomplete ()"><code class="function">g_test_incomplete()</code></a> or <a class="link" href="glib-Testing.html#g-test-skip" title="g_test_skip ()"><code class="function">g_test_skip()</code></a> have been called, but also if an assertion has failed.</p> <p>This can be useful to return early from a test if continuing after a failed assertion might be harmful.</p> <p>The return value of this function is only meaningful if it is called from inside a test function.</p> <div class="refsect3"> <a name="g-test-failed.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the test has failed</p> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-message"></a><h3>g_test_message ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_message (<em class="parameter"><code>const <span class="type">char</span> *format</code></em>, <em class="parameter"><code>...</code></em>);</pre> <p>Add a message to the test report.</p> <div class="refsect3"> <a name="g-test-message.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>format</p></td> <td class="parameter_description"><p>the format string</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>...</p></td> <td class="parameter_description"><p>printf-like arguments to <em class="parameter"><code>format</code></em> </p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-bug-base"></a><h3>g_test_bug_base ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_bug_base (<em class="parameter"><code>const <span class="type">char</span> *uri_pattern</code></em>);</pre> <p>Specify the base URI for bug reports.</p> <p>The base URI is used to construct bug report messages for <a class="link" href="glib-Testing.html#g-test-message" title="g_test_message ()"><code class="function">g_test_message()</code></a> when <a class="link" href="glib-Testing.html#g-test-bug" title="g_test_bug ()"><code class="function">g_test_bug()</code></a> is called. Calling this function outside of a test case sets the default base URI for all test cases. Calling it from within a test case changes the base URI for the scope of the test case only. Bug URIs are constructed by appending a bug specific URI portion to <em class="parameter"><code>uri_pattern</code></em> , or by replacing the special string '%s' within <em class="parameter"><code>uri_pattern</code></em> if that is present.</p> <p>If <a class="link" href="glib-Testing.html#g-test-bug-base" title="g_test_bug_base ()"><code class="function">g_test_bug_base()</code></a> is not called, bug URIs are formed solely from the value provided by <a class="link" href="glib-Testing.html#g-test-bug" title="g_test_bug ()"><code class="function">g_test_bug()</code></a>.</p> <div class="refsect3"> <a name="g-test-bug-base.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>uri_pattern</p></td> <td class="parameter_description"><p>the base pattern for bug URIs</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-bug"></a><h3>g_test_bug ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_bug (<em class="parameter"><code>const <span class="type">char</span> *bug_uri_snippet</code></em>);</pre> <p>This function adds a message to test reports that associates a bug URI with a test case. Bug URIs are constructed from a base URI set with <a class="link" href="glib-Testing.html#g-test-bug-base" title="g_test_bug_base ()"><code class="function">g_test_bug_base()</code></a> and <em class="parameter"><code>bug_uri_snippet</code></em> . If <a class="link" href="glib-Testing.html#g-test-bug-base" title="g_test_bug_base ()"><code class="function">g_test_bug_base()</code></a> has not been called, it is assumed to be the empty string, so a full URI can be provided to <a class="link" href="glib-Testing.html#g-test-bug" title="g_test_bug ()"><code class="function">g_test_bug()</code></a> instead.</p> <div class="refsect3"> <a name="g-test-bug.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>bug_uri_snippet</p></td> <td class="parameter_description"><p>Bug specific bug tracker URI portion.</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-summary"></a><h3>g_test_summary ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_summary (<em class="parameter"><code>const <span class="type">char</span> *summary</code></em>);</pre> <p>Set the summary for a test, which describes what the test checks, and how it goes about checking it. This may be included in test report output, and is useful documentation for anyone reading the source code or modifying a test in future. It must be a single line.</p> <p>This should be called at the top of a test function.</p> <p>For example:</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1 2 3 4 5 6 7 8</pre></td> <td class="listing_code"><pre class="programlisting"><span class="k">static</span> <span class="kt">void</span> <span class="nf">test_array_sort</span> <span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="p">{</span> <span class="n">g_test_summary</span> <span class="p">(</span><span class="s">"Test my_array_sort() sorts the array correctly and stably, "</span> <span class="s">"including testing zero length and one-element arrays."</span><span class="p">);</span> <span class="err">…</span> <span class="p">}</span></pre></td> </tr> </tbody> </table> </div> <p></p> <div class="refsect3"> <a name="g-test-summary.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>summary</p></td> <td class="parameter_description"><p>One or two sentences summarising what the test checks, and how it checks it.</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-62.html#api-index-2.62">2.62</a></p> </div> <hr> <div class="refsect2"> <a name="GTestLogFatalFunc"></a><h3>GTestLogFatalFunc ()</h3> <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> <span class="c_punctuation">(</span>*GTestLogFatalFunc<span class="c_punctuation">)</span> (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *log_domain</code></em>, <em class="parameter"><code><a class="link" href="glib-Message-Logging.html#GLogLevelFlags" title="enum GLogLevelFlags"><span class="type">GLogLevelFlags</span></a> log_level</code></em>, <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *message</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> user_data</code></em>);</pre> <p>Specifies the prototype of fatal log handler functions.</p> <div class="refsect3"> <a name="GTestLogFatalFunc.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>log_domain</p></td> <td class="parameter_description"><p>the log domain of the message</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>log_level</p></td> <td class="parameter_description"><p>the log level of the message (including the fatal and recursion flags)</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>message</p></td> <td class="parameter_description"><p>the message to process</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>user_data</p></td> <td class="parameter_description"><p>user data, set in <a class="link" href="glib-Testing.html#g-test-log-set-fatal-handler" title="g_test_log_set_fatal_handler ()"><code class="function">g_test_log_set_fatal_handler()</code></a></p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <div class="refsect3"> <a name="GTestLogFatalFunc.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the program should abort, <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> otherwise</p> </div> <p class="since">Since: <a class="link" href="api-index-2-22.html#api-index-2.22">2.22</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-log-set-fatal-handler"></a><h3>g_test_log_set_fatal_handler ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_log_set_fatal_handler (<em class="parameter"><code><a class="link" href="glib-Testing.html#GTestLogFatalFunc" title="GTestLogFatalFunc ()"><span class="type">GTestLogFatalFunc</span></a> log_func</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> user_data</code></em>);</pre> <p>Installs a non-error fatal log handler which can be used to decide whether log messages which are counted as fatal abort the program.</p> <p>The use case here is that you are running a test case that depends on particular libraries or circumstances and cannot prevent certain known critical or warning messages. So you install a handler that compares the domain and message to precisely not abort in such a case.</p> <p>Note that the handler is reset at the beginning of any test case, so you have to set it inside each test function which needs the special behavior.</p> <p>This handler has no effect on g_error messages.</p> <p>This handler also has no effect on structured log messages (using <a class="link" href="glib-Message-Logging.html#g-log-structured" title="g_log_structured ()"><code class="function">g_log_structured()</code></a> or <a class="link" href="glib-Message-Logging.html#g-log-structured-array" title="g_log_structured_array ()"><code class="function">g_log_structured_array()</code></a>). To change the fatal behaviour for specific log messages, programs must install a custom log writer function using <a class="link" href="glib-Message-Logging.html#g-log-set-writer-func" title="g_log_set_writer_func ()"><code class="function">g_log_set_writer_func()</code></a>.See <a class="link" href="glib-Message-Logging.html#using-structured-logging" title="Using Structured Logging">Using Structured Logging</a>.</p> <div class="refsect3"> <a name="g-test-log-set-fatal-handler.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>log_func</p></td> <td class="parameter_description"><p>the log handler function.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>user_data</p></td> <td class="parameter_description"><p>data passed to the log handler.</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-22.html#api-index-2.22">2.22</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-timer-start"></a><h3>g_test_timer_start ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_timer_start (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Start a timing test. Call <a class="link" href="glib-Testing.html#g-test-timer-elapsed" title="g_test_timer_elapsed ()"><code class="function">g_test_timer_elapsed()</code></a> when the task is supposed to be done. Call this function again to restart the timer.</p> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-timer-elapsed"></a><h3>g_test_timer_elapsed ()</h3> <pre class="programlisting"><span class="returnvalue">double</span> g_test_timer_elapsed (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Get the time since the last start of the timer with <a class="link" href="glib-Testing.html#g-test-timer-start" title="g_test_timer_start ()"><code class="function">g_test_timer_start()</code></a>.</p> <div class="refsect3"> <a name="g-test-timer-elapsed.returns"></a><h4>Returns</h4> <p> the time since the last start of the timer, as a double</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-timer-last"></a><h3>g_test_timer_last ()</h3> <pre class="programlisting"><span class="returnvalue">double</span> g_test_timer_last (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Report the last result of <a class="link" href="glib-Testing.html#g-test-timer-elapsed" title="g_test_timer_elapsed ()"><code class="function">g_test_timer_elapsed()</code></a>.</p> <div class="refsect3"> <a name="g-test-timer-last.returns"></a><h4>Returns</h4> <p> the last result of <a class="link" href="glib-Testing.html#g-test-timer-elapsed" title="g_test_timer_elapsed ()"><code class="function">g_test_timer_elapsed()</code></a>, as a double</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-queue-free"></a><h3>g_test_queue_free ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_queue_free (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> gfree_pointer</code></em>);</pre> <p>Enqueue a pointer to be released with <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a> during the next teardown phase. This is equivalent to calling <a class="link" href="glib-Testing.html#g-test-queue-destroy" title="g_test_queue_destroy ()"><code class="function">g_test_queue_destroy()</code></a> with a destroy callback of <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a>.</p> <div class="refsect3"> <a name="g-test-queue-free.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>gfree_pointer</p></td> <td class="parameter_description"><p>the pointer to be stored.</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-queue-destroy"></a><h3>g_test_queue_destroy ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_queue_destroy (<em class="parameter"><code><a class="link" href="glib-Datasets.html#GDestroyNotify" title="GDestroyNotify ()"><span class="type">GDestroyNotify</span></a> destroy_func</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> destroy_data</code></em>);</pre> <p>This function enqueus a callback <em class="parameter"><code>destroy_func</code></em> to be executed during the next test case teardown phase. This is most useful to auto destruct allocated test resources at the end of a test run. Resources are released in reverse queue order, that means enqueueing callback A before callback B will cause <code class="function">B()</code> to be called before <code class="function">A()</code> during teardown.</p> <div class="refsect3"> <a name="g-test-queue-destroy.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>destroy_func</p></td> <td class="parameter_description"><p>Destroy callback for teardown phase.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>destroy_data</p></td> <td class="parameter_description"><p>Destroy callback data.</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-queue-unref"></a><h3>g_test_queue_unref()</h3> <pre class="programlisting">#define g_test_queue_unref(gobject)</pre> <p>Enqueue an object to be released with <code class="function">g_object_unref()</code> during the next teardown phase. This is equivalent to calling <a class="link" href="glib-Testing.html#g-test-queue-destroy" title="g_test_queue_destroy ()"><code class="function">g_test_queue_destroy()</code></a> with a destroy callback of <code class="function">g_object_unref()</code>.</p> <div class="refsect3"> <a name="g-test-queue-unref.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>gobject</p></td> <td class="parameter_description"><p>the object to unref</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-expect-message"></a><h3>g_test_expect_message ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_expect_message (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *log_domain</code></em>, <em class="parameter"><code><a class="link" href="glib-Message-Logging.html#GLogLevelFlags" title="enum GLogLevelFlags"><span class="type">GLogLevelFlags</span></a> log_level</code></em>, <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *pattern</code></em>);</pre> <p>Indicates that a message with the given <em class="parameter"><code>log_domain</code></em> and <em class="parameter"><code>log_level</code></em> , with text matching <em class="parameter"><code>pattern</code></em> , is expected to be logged. When this message is logged, it will not be printed, and the test case will not abort.</p> <p>This API may only be used with the old logging API (<a class="link" href="glib-Message-Logging.html#g-log" title="g_log ()"><code class="function">g_log()</code></a> without <code class="literal">G_LOG_USE_STRUCTURED</code> defined). It will not work with the structured logging API. See <a class="link" href="glib-Message-Logging.html#testing-for-messages" title="Testing for Messages">Testing for Messages</a>.</p> <p>Use <a class="link" href="glib-Testing.html#g-test-assert-expected-messages" title="g_test_assert_expected_messages"><code class="function">g_test_assert_expected_messages()</code></a> to assert that all previously-expected messages have been seen and suppressed.</p> <p>You can call this multiple times in a row, if multiple messages are expected as a result of a single call. (The messages must appear in the same order as the calls to <a class="link" href="glib-Testing.html#g-test-expect-message" title="g_test_expect_message ()"><code class="function">g_test_expect_message()</code></a>.)</p> <p>For example:</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1 2 3 4 5 6 7</pre></td> <td class="listing_code"><pre class="programlisting"><span class="c1">// g_main_context_push_thread_default() should fail if the</span> <span class="c1">// context is already owned by another thread.</span> <span class="n">g_test_expect_message</span> <span class="p">(</span><span class="n">G_LOG_DOMAIN</span><span class="p">,</span> <span class="n">G_LOG_LEVEL_CRITICAL</span><span class="p">,</span> <span class="s">"assertion*acquired_context*failed"</span><span class="p">);</span> <span class="n">g_main_context_push_thread_default</span> <span class="p">(</span><span class="n">bad_context</span><span class="p">);</span> <span class="n">g_test_assert_expected_messages</span> <span class="p">();</span></pre></td> </tr> </tbody> </table> </div> <p></p> <p>Note that you cannot use this to test <a class="link" href="glib-Message-Logging.html#g-error" title="g_error()"><code class="function">g_error()</code></a> messages, since <a class="link" href="glib-Message-Logging.html#g-error" title="g_error()"><code class="function">g_error()</code></a> intentionally never returns even if the program doesn't abort; use <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a> in this case.</p> <p>If messages at <a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-DEBUG:CAPS"><code class="literal">G_LOG_LEVEL_DEBUG</code></a> are emitted, but not explicitly expected via <a class="link" href="glib-Testing.html#g-test-expect-message" title="g_test_expect_message ()"><code class="function">g_test_expect_message()</code></a> then they will be ignored.</p> <div class="refsect3"> <a name="g-test-expect-message.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>log_domain</p></td> <td class="parameter_description"><p>the log domain of the message. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="NULL may be passed as the value in, out, in-out; or as a return value."><span class="acronym">nullable</span></acronym>]</span></td> </tr> <tr> <td class="parameter_name"><p>log_level</p></td> <td class="parameter_description"><p>the log level of the message</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>pattern</p></td> <td class="parameter_description"><p>a glob-style <a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a></p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-34.html#api-index-2.34">2.34</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-assert-expected-messages"></a><h3>g_test_assert_expected_messages</h3> <pre class="programlisting">#define g_test_assert_expected_messages()</pre> <p>Asserts that all messages previously indicated via <a class="link" href="glib-Testing.html#g-test-expect-message" title="g_test_expect_message ()"><code class="function">g_test_expect_message()</code></a> have been seen and suppressed.</p> <p>This API may only be used with the old logging API (<a class="link" href="glib-Message-Logging.html#g-log" title="g_log ()"><code class="function">g_log()</code></a> without <code class="literal">G_LOG_USE_STRUCTURED</code> defined). It will not work with the structured logging API. See <a class="link" href="glib-Message-Logging.html#testing-for-messages" title="Testing for Messages">Testing for Messages</a>.</p> <p>If messages at <a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-DEBUG:CAPS"><code class="literal">G_LOG_LEVEL_DEBUG</code></a> are emitted, but not explicitly expected via <a class="link" href="glib-Testing.html#g-test-expect-message" title="g_test_expect_message ()"><code class="function">g_test_expect_message()</code></a> then they will be ignored.</p> <p class="since">Since: <a class="link" href="api-index-2-34.html#api-index-2.34">2.34</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-subprocess"></a><h3>g_test_trap_subprocess ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_trap_subprocess (<em class="parameter"><code>const <span class="type">char</span> *test_path</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint64" title="guint64"><span class="type">guint64</span></a> usec_timeout</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestSubprocessFlags" title="enum GTestSubprocessFlags"><span class="type">GTestSubprocessFlags</span></a> test_flags</code></em>);</pre> <p>Respawns the test program to run only <em class="parameter"><code>test_path</code></em> in a subprocess. This can be used for a test case that might not return, or that might abort.</p> <p>If <em class="parameter"><code>test_path</code></em> is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> then the same test is re-run in a subprocess. You can use <a class="link" href="glib-Testing.html#g-test-subprocess" title="g_test_subprocess ()"><code class="function">g_test_subprocess()</code></a> to determine whether the test is in a subprocess or not.</p> <p><em class="parameter"><code>test_path</code></em> can also be the name of the parent test, followed by "<code class="literal">/subprocess/</code>" and then a name for the specific subtest (or just ending with "<code class="literal">/subprocess</code>" if the test only has one child test); tests with names of this form will automatically be skipped in the parent process.</p> <p>If <em class="parameter"><code>usec_timeout</code></em> is non-0, the test subprocess is aborted and considered failing if its run time exceeds it.</p> <p>The subprocess behavior can be configured with the <a class="link" href="glib-Testing.html#GTestSubprocessFlags" title="enum GTestSubprocessFlags"><span class="type">GTestSubprocessFlags</span></a> flags.</p> <p>You can use methods such as <a class="link" href="glib-Testing.html#g-test-trap-assert-passed" title="g_test_trap_assert_passed"><code class="function">g_test_trap_assert_passed()</code></a>, <a class="link" href="glib-Testing.html#g-test-trap-assert-failed" title="g_test_trap_assert_failed"><code class="function">g_test_trap_assert_failed()</code></a>, and <a class="link" href="glib-Testing.html#g-test-trap-assert-stderr" title="g_test_trap_assert_stderr()"><code class="function">g_test_trap_assert_stderr()</code></a> to check the results of the subprocess. (But note that <a class="link" href="glib-Testing.html#g-test-trap-assert-stdout" title="g_test_trap_assert_stdout()"><code class="function">g_test_trap_assert_stdout()</code></a> and <a class="link" href="glib-Testing.html#g-test-trap-assert-stderr" title="g_test_trap_assert_stderr()"><code class="function">g_test_trap_assert_stderr()</code></a> cannot be used if <em class="parameter"><code>test_flags</code></em> specifies that the child should inherit the parent stdout/stderr.) </p> <p>If your <code class="literal"><code class="function">main()</code></code> needs to behave differently in the subprocess, you can call <a class="link" href="glib-Testing.html#g-test-subprocess" title="g_test_subprocess ()"><code class="function">g_test_subprocess()</code></a> (after calling <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>) to see whether you are in a subprocess.</p> <p>The following example tests that calling <code class="literal">my_object_new(1000000)</code> will abort with an error message.</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24</pre></td> <td class="listing_code"><pre class="programlisting"><span class="k">static</span> <span class="kt">void</span> <span class="nf">test_create_large_object</span> <span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="p">{</span> <span class="k">if</span> <span class="p">(</span><span class="n">g_test_subprocess</span> <span class="p">())</span> <span class="p">{</span> <span class="n">my_object_new</span> <span class="p">(</span><span class="mi">1000000</span><span class="p">);</span> <span class="k">return</span><span class="p">;</span> <span class="p">}</span> <span class="c1">// Reruns this same test in a subprocess</span> <span class="n">g_test_trap_subprocess</span> <span class="p">(</span><span class="nb">NULL</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span> <span class="n">g_test_trap_assert_failed</span> <span class="p">();</span> <span class="n">g_test_trap_assert_stderr</span> <span class="p">(</span><span class="s">"*ERROR*too large*"</span><span class="p">);</span> <span class="p">}</span> <span class="kt">int</span> <span class="nf">main</span> <span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">**</span><span class="n">argv</span><span class="p">)</span> <span class="p">{</span> <span class="n">g_test_init</span> <span class="p">(</span><span class="o">&</span><span class="n">argc</span><span class="p">,</span> <span class="o">&</span><span class="n">argv</span><span class="p">,</span> <span class="nb">NULL</span><span class="p">);</span> <span class="n">g_test_add_func</span> <span class="p">(</span><span class="s">"/myobject/create_large_object"</span><span class="p">,</span> <span class="n">test_create_large_object</span><span class="p">);</span> <span class="k">return</span> <span class="n">g_test_run</span> <span class="p">();</span> <span class="p">}</span></pre></td> </tr> </tbody> </table> </div> <p></p> <div class="refsect3"> <a name="g-test-trap-subprocess.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>test_path</p></td> <td class="parameter_description"><p>Test to run in a subprocess. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="NULL may be passed as the value in, out, in-out; or as a return value."><span class="acronym">nullable</span></acronym>]</span></td> </tr> <tr> <td class="parameter_name"><p>usec_timeout</p></td> <td class="parameter_description"><p>Timeout for the subprocess test in micro seconds.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>test_flags</p></td> <td class="parameter_description"><p>Flags to modify subprocess behaviour.</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-has-passed"></a><h3>g_test_trap_has_passed ()</h3> <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> g_test_trap_has_passed (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Check the result of the last <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a> call.</p> <div class="refsect3"> <a name="g-test-trap-has-passed.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the last test subprocess terminated successfully.</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-reached-timeout"></a><h3>g_test_trap_reached_timeout ()</h3> <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> g_test_trap_reached_timeout (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Check the result of the last <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a> call.</p> <div class="refsect3"> <a name="g-test-trap-reached-timeout.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the last test subprocess got killed due to a timeout.</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-assert-passed"></a><h3>g_test_trap_assert_passed</h3> <pre class="programlisting">#define g_test_trap_assert_passed()</pre> <p>Assert that the last test subprocess passed. See <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-assert-failed"></a><h3>g_test_trap_assert_failed</h3> <pre class="programlisting">#define g_test_trap_assert_failed()</pre> <p>Assert that the last test subprocess failed. See <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> <p>This is sometimes used to test situations that are formally considered to be undefined behaviour, like inputs that fail a <a class="link" href="glib-Warnings-and-Assertions.html#g-return-if-fail" title="g_return_if_fail()"><code class="function">g_return_if_fail()</code></a> check. In these situations you should skip the entire test, including the call to <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>, unless <a class="link" href="glib-Testing.html#g-test-undefined" title="g_test_undefined"><code class="function">g_test_undefined()</code></a> returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> to indicate that undefined behaviour may be tested.</p> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-assert-stdout"></a><h3>g_test_trap_assert_stdout()</h3> <pre class="programlisting">#define g_test_trap_assert_stdout(soutpattern)</pre> <p>Assert that the stdout output of the last test subprocess matches <em class="parameter"><code>soutpattern</code></em> . See <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> <div class="refsect3"> <a name="g-test-trap-assert-stdout.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>soutpattern</p></td> <td class="parameter_description"><p>a glob-style <a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a></p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-assert-stdout-unmatched"></a><h3>g_test_trap_assert_stdout_unmatched()</h3> <pre class="programlisting">#define g_test_trap_assert_stdout_unmatched(soutpattern)</pre> <p>Assert that the stdout output of the last test subprocess does not match <em class="parameter"><code>soutpattern</code></em> . See <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> <div class="refsect3"> <a name="g-test-trap-assert-stdout-unmatched.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>soutpattern</p></td> <td class="parameter_description"><p>a glob-style <a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a></p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-assert-stderr"></a><h3>g_test_trap_assert_stderr()</h3> <pre class="programlisting">#define g_test_trap_assert_stderr(serrpattern)</pre> <p>Assert that the stderr output of the last test subprocess matches <em class="parameter"><code>serrpattern</code></em> . See <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> <p>This is sometimes used to test situations that are formally considered to be undefined behaviour, like code that hits a <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> or <a class="link" href="glib-Message-Logging.html#g-error" title="g_error()"><code class="function">g_error()</code></a>. In these situations you should skip the entire test, including the call to <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>, unless <a class="link" href="glib-Testing.html#g-test-undefined" title="g_test_undefined"><code class="function">g_test_undefined()</code></a> returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> to indicate that undefined behaviour may be tested.</p> <div class="refsect3"> <a name="g-test-trap-assert-stderr.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>serrpattern</p></td> <td class="parameter_description"><p>a glob-style <a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a></p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-assert-stderr-unmatched"></a><h3>g_test_trap_assert_stderr_unmatched()</h3> <pre class="programlisting">#define g_test_trap_assert_stderr_unmatched(serrpattern)</pre> <p>Assert that the stderr output of the last test subprocess does not match <em class="parameter"><code>serrpattern</code></em> . See <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a>.</p> <div class="refsect3"> <a name="g-test-trap-assert-stderr-unmatched.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>serrpattern</p></td> <td class="parameter_description"><p>a glob-style <a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a></p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-trap-fork"></a><h3>g_test_trap_fork ()</h3> <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a> g_test_trap_fork (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint64" title="guint64"><span class="type">guint64</span></a> usec_timeout</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestTrapFlags" title="enum GTestTrapFlags"><span class="type">GTestTrapFlags</span></a> test_trap_flags</code></em>);</pre> <div class="warning"> <p><code class="literal">g_test_trap_fork</code> is deprecated and should not be used in newly-written code.</p> <p>This function is implemented only on Unix platforms, and is not always reliable due to problems inherent in fork-without-exec. Use <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a> instead.</p> </div> <p>Fork the current test program to execute a test case that might not return or that might abort.</p> <p>If <em class="parameter"><code>usec_timeout</code></em> is non-0, the forked test case is aborted and considered failing if its run time exceeds it.</p> <p>The forking behavior can be configured with the <a class="link" href="glib-Testing.html#GTestTrapFlags" title="enum GTestTrapFlags"><span class="type">GTestTrapFlags</span></a> flags.</p> <p>In the following example, the test code forks, the forked child process produces some sample output and exits successfully. The forking parent process then asserts successful child program termination and validates child program outputs.</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13</pre></td> <td class="listing_code"><pre class="programlisting"><span class="k">static</span> <span class="kt">void</span> <span class="nf">test_fork_patterns</span> <span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="p">{</span> <span class="k">if</span> <span class="p">(</span><span class="n">g_test_trap_fork</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">G_TEST_TRAP_SILENCE_STDOUT</span> <span class="o">|</span> <span class="n">G_TEST_TRAP_SILENCE_STDERR</span><span class="p">))</span> <span class="p">{</span> <span class="n">g_print</span> <span class="p">(</span><span class="s">"some stdout text: somagic17</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span> <span class="n">g_printerr</span> <span class="p">(</span><span class="s">"some stderr text: semagic43</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span> <span class="n">exit</span> <span class="p">(</span><span class="mi">0</span><span class="p">);</span> <span class="c1">// successful test run</span> <span class="p">}</span> <span class="n">g_test_trap_assert_passed</span> <span class="p">();</span> <span class="n">g_test_trap_assert_stdout</span> <span class="p">(</span><span class="s">"*somagic17*"</span><span class="p">);</span> <span class="n">g_test_trap_assert_stderr</span> <span class="p">(</span><span class="s">"*semagic43*"</span><span class="p">);</span> <span class="p">}</span></pre></td> </tr> </tbody> </table> </div> <p></p> <div class="refsect3"> <a name="g-test-trap-fork.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>usec_timeout</p></td> <td class="parameter_description"><p>Timeout for the forked test in micro seconds.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>test_trap_flags</p></td> <td class="parameter_description"><p>Flags to modify forking behaviour.</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <div class="refsect3"> <a name="g-test-trap-fork.returns"></a><h4>Returns</h4> <p> <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for the forked child and <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> for the executing parent process.</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-rand-bit"></a><h3>g_test_rand_bit</h3> <pre class="programlisting">#define g_test_rand_bit()</pre> <p>Get a reproducible random bit (0 or 1), see <a class="link" href="glib-Testing.html#g-test-rand-int" title="g_test_rand_int ()"><code class="function">g_test_rand_int()</code></a> for details on test case random numbers.</p> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-rand-int"></a><h3>g_test_rand_int ()</h3> <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gint32" title="gint32"><span class="returnvalue">gint32</span></a> g_test_rand_int (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Get a reproducible random integer number.</p> <p>The random numbers generated by the g_test_rand_*() family of functions change with every new test program start, unless the --seed option is given when starting test programs.</p> <p>For individual test cases however, the random number generator is reseeded, to avoid dependencies between tests and to make --seed effective for all test cases.</p> <div class="refsect3"> <a name="g-test-rand-int.returns"></a><h4>Returns</h4> <p> a random number from the seeded random number generator.</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-rand-int-range"></a><h3>g_test_rand_int_range ()</h3> <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gint32" title="gint32"><span class="returnvalue">gint32</span></a> g_test_rand_int_range (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gint32" title="gint32"><span class="type">gint32</span></a> begin</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gint32" title="gint32"><span class="type">gint32</span></a> end</code></em>);</pre> <p>Get a reproducible random integer number out of a specified range, see <a class="link" href="glib-Testing.html#g-test-rand-int" title="g_test_rand_int ()"><code class="function">g_test_rand_int()</code></a> for details on test case random numbers.</p> <div class="refsect3"> <a name="g-test-rand-int-range.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>begin</p></td> <td class="parameter_description"><p>the minimum value returned by this function</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>end</p></td> <td class="parameter_description"><p>the smallest value not to be returned by this function</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <div class="refsect3"> <a name="g-test-rand-int-range.returns"></a><h4>Returns</h4> <p> a number with <em class="parameter"><code>begin</code></em> <= number < <em class="parameter"><code>end</code></em> .</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-rand-double"></a><h3>g_test_rand_double ()</h3> <pre class="programlisting"><span class="returnvalue">double</span> g_test_rand_double (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Get a reproducible random floating point number, see <a class="link" href="glib-Testing.html#g-test-rand-int" title="g_test_rand_int ()"><code class="function">g_test_rand_int()</code></a> for details on test case random numbers.</p> <div class="refsect3"> <a name="g-test-rand-double.returns"></a><h4>Returns</h4> <p> a random number from the seeded random number generator.</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-rand-double-range"></a><h3>g_test_rand_double_range ()</h3> <pre class="programlisting"><span class="returnvalue">double</span> g_test_rand_double_range (<em class="parameter"><code><span class="type">double</span> range_start</code></em>, <em class="parameter"><code><span class="type">double</span> range_end</code></em>);</pre> <p>Get a reproducible random floating pointer number out of a specified range, see <a class="link" href="glib-Testing.html#g-test-rand-int" title="g_test_rand_int ()"><code class="function">g_test_rand_int()</code></a> for details on test case random numbers.</p> <div class="refsect3"> <a name="g-test-rand-double-range.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>range_start</p></td> <td class="parameter_description"><p>the minimum value returned by this function</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>range_end</p></td> <td class="parameter_description"><p>the minimum value not returned by this function</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <div class="refsect3"> <a name="g-test-rand-double-range.returns"></a><h4>Returns</h4> <p> a number with <em class="parameter"><code>range_start</code></em> <= number < <em class="parameter"><code>range_end</code></em> .</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert"></a><h3>g_assert()</h3> <pre class="programlisting">#define g_assert(expr)</pre> <p>Debugging macro to terminate the application if the assertion fails. If the assertion fails (i.e. the expression is not true), an error message is logged and the application is terminated.</p> <p>The macro can be turned off in final releases of code by defining <code class="literal">G_DISABLE_ASSERT</code> when compiling the application, so code must not depend on any side effects from <em class="parameter"><code>expr</code></em> . Similarly, it must not be used in unit tests, otherwise the unit tests will be ineffective if compiled with <code class="literal">G_DISABLE_ASSERT</code>. Use <a class="link" href="glib-Testing.html#g-assert-true" title="g_assert_true()"><code class="function">g_assert_true()</code></a> and related macros in unit tests instead.</p> <div class="refsect3"> <a name="g-assert.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>expr</p></td> <td class="parameter_description"><p>the expression to check</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> </div> <hr> <div class="refsect2"> <a name="g-assert-not-reached"></a><h3>g_assert_not_reached</h3> <pre class="programlisting">#define g_assert_not_reached()</pre> <p>Debugging macro to terminate the application if it is ever reached. If it is reached, an error message is logged and the application is terminated.</p> <p>The macro can be turned off in final releases of code by defining <code class="literal">G_DISABLE_ASSERT</code> when compiling the application. Hence, it should not be used in unit tests, where assertions should always be effective.</p> </div> <hr> <div class="refsect2"> <a name="g-assert-cmpstr"></a><h3>g_assert_cmpstr()</h3> <pre class="programlisting">#define g_assert_cmpstr(s1, cmp, s2)</pre> <p>Debugging macro to compare two strings. If the comparison fails, an error message is logged and the application is either terminated or the testcase marked as failed. The strings are compared using <a class="link" href="glib-String-Utility-Functions.html#g-strcmp0" title="g_strcmp0 ()"><code class="function">g_strcmp0()</code></a>.</p> <p>The effect of <code class="literal">g_assert_cmpstr (s1, op, s2)</code> is the same as <code class="literal">g_assert_true (g_strcmp0 (s1, s2) op 0)</code>. The advantage of this macro is that it can produce a message that includes the actual values of <em class="parameter"><code>s1</code></em> and <em class="parameter"><code>s2</code></em> .</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1</pre></td> <td class="listing_code"><pre class="programlisting"><span class="n">g_assert_cmpstr</span> <span class="p">(</span><span class="n">mystring</span><span class="p">,</span> <span class="o">==</span><span class="p">,</span> <span class="s">"fubar"</span><span class="p">);</span></pre></td> </tr> </tbody> </table> </div> <p></p> <div class="refsect3"> <a name="g-assert-cmpstr.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>s1</p></td> <td class="parameter_description"><p>a string (may be <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>)</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>cmp</p></td> <td class="parameter_description"><p>The comparison operator to use. One of <code class="literal">==</code>, <code class="literal">!=</code>, <code class="literal"><</code>, <code class="literal">&gt;</code>, <code class="literal"><=</code>, <code class="literal">&gt;=</code>.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>s2</p></td> <td class="parameter_description"><p>another string (may be <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>)</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-cmpint"></a><h3>g_assert_cmpint()</h3> <pre class="programlisting">#define g_assert_cmpint(n1, cmp, n2)</pre> <p>Debugging macro to compare two integers.</p> <p>The effect of <code class="literal">g_assert_cmpint (n1, op, n2)</code> is the same as <code class="literal">g_assert_true (n1 op n2)</code>. The advantage of this macro is that it can produce a message that includes the actual values of <em class="parameter"><code>n1</code></em> and <em class="parameter"><code>n2</code></em> .</p> <div class="refsect3"> <a name="g-assert-cmpint.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>n1</p></td> <td class="parameter_description"><p>an integer</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>cmp</p></td> <td class="parameter_description"><p>The comparison operator to use. One of <code class="literal">==</code>, <code class="literal">!=</code>, <code class="literal"><</code>, <code class="literal">&gt;</code>, <code class="literal"><=</code>, <code class="literal">&gt;=</code>.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>n2</p></td> <td class="parameter_description"><p>another integer</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-cmpuint"></a><h3>g_assert_cmpuint()</h3> <pre class="programlisting">#define g_assert_cmpuint(n1, cmp, n2)</pre> <p>Debugging macro to compare two unsigned integers.</p> <p>The effect of <code class="literal">g_assert_cmpuint (n1, op, n2)</code> is the same as <code class="literal">g_assert_true (n1 op n2)</code>. The advantage of this macro is that it can produce a message that includes the actual values of <em class="parameter"><code>n1</code></em> and <em class="parameter"><code>n2</code></em> .</p> <div class="refsect3"> <a name="g-assert-cmpuint.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>n1</p></td> <td class="parameter_description"><p>an unsigned integer</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>cmp</p></td> <td class="parameter_description"><p>The comparison operator to use. One of <code class="literal">==</code>, <code class="literal">!=</code>, <code class="literal"><</code>, <code class="literal">&gt;</code>, <code class="literal"><=</code>, <code class="literal">&gt;=</code>.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>n2</p></td> <td class="parameter_description"><p>another unsigned integer</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-cmphex"></a><h3>g_assert_cmphex()</h3> <pre class="programlisting">#define g_assert_cmphex(n1, cmp, n2)</pre> <p>Debugging macro to compare to unsigned integers.</p> <p>This is a variant of <a class="link" href="glib-Testing.html#g-assert-cmpuint" title="g_assert_cmpuint()"><code class="function">g_assert_cmpuint()</code></a> that displays the numbers in hexadecimal notation in the message.</p> <div class="refsect3"> <a name="g-assert-cmphex.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>n1</p></td> <td class="parameter_description"><p>an unsigned integer</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>cmp</p></td> <td class="parameter_description"><p>The comparison operator to use. One of <code class="literal">==</code>, <code class="literal">!=</code>, <code class="literal"><</code>, <code class="literal">&gt;</code>, <code class="literal"><=</code>, <code class="literal">&gt;=</code>.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>n2</p></td> <td class="parameter_description"><p>another unsigned integer</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-cmpfloat"></a><h3>g_assert_cmpfloat()</h3> <pre class="programlisting">#define g_assert_cmpfloat(n1,cmp,n2)</pre> <p>Debugging macro to compare two floating point numbers.</p> <p>The effect of <code class="literal">g_assert_cmpfloat (n1, op, n2)</code> is the same as <code class="literal">g_assert_true (n1 op n2)</code>. The advantage of this macro is that it can produce a message that includes the actual values of <em class="parameter"><code>n1</code></em> and <em class="parameter"><code>n2</code></em> .</p> <div class="refsect3"> <a name="g-assert-cmpfloat.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>n1</p></td> <td class="parameter_description"><p>a floating point number</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>cmp</p></td> <td class="parameter_description"><p>The comparison operator to use. One of <code class="literal">==</code>, <code class="literal">!=</code>, <code class="literal"><</code>, <code class="literal">&gt;</code>, <code class="literal"><=</code>, <code class="literal">&gt;=</code>.</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>n2</p></td> <td class="parameter_description"><p>another floating point number</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-cmpfloat-with-epsilon"></a><h3>g_assert_cmpfloat_with_epsilon()</h3> <pre class="programlisting">#define g_assert_cmpfloat_with_epsilon(n1,n2,epsilon)</pre> <p>Debugging macro to compare two floating point numbers within an epsilon.</p> <p>The effect of <code class="literal">g_assert_cmpfloat_with_epsilon (n1, n2, epsilon)</code> is the same as <code class="literal">g_assert_true (abs (n1 - n2) &lt; epsilon)</code>. The advantage of this macro is that it can produce a message that includes the actual values of <em class="parameter"><code>n1</code></em> and <em class="parameter"><code>n2</code></em> .</p> <div class="refsect3"> <a name="g-assert-cmpfloat-with-epsilon.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>n1</p></td> <td class="parameter_description"><p>a floating point number</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>n2</p></td> <td class="parameter_description"><p>another floating point number</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>epsilon</p></td> <td class="parameter_description"><p>a numeric value that expresses the expected tolerance between <em class="parameter"><code>n1</code></em> and <em class="parameter"><code>n2</code></em> </p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-58.html#api-index-2.58">2.58</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-cmpmem"></a><h3>g_assert_cmpmem()</h3> <pre class="programlisting">#define g_assert_cmpmem(m1, l1, m2, l2)</pre> <p>Debugging macro to compare memory regions. If the comparison fails, an error message is logged and the application is either terminated or the testcase marked as failed.</p> <p>The effect of <code class="literal">g_assert_cmpmem (m1, l1, m2, l2)</code> is the same as <code class="literal">g_assert_true (l1 == l2 &amp;&amp; memcmp (m1, m2, l1) == 0)</code>. The advantage of this macro is that it can produce a message that includes the actual values of <em class="parameter"><code>l1</code></em> and <em class="parameter"><code>l2</code></em> .</p> <p><em class="parameter"><code>m1</code></em> may be <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> if (and only if) <em class="parameter"><code>l1</code></em> is zero; similarly for <em class="parameter"><code>m2</code></em> and <em class="parameter"><code>l2</code></em> .</p> <div class="informalexample"> <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> <tbody> <tr> <td class="listing_lines" align="right"><pre>1</pre></td> <td class="listing_code"><pre class="programlisting"><span class="n">g_assert_cmpmem</span> <span class="p">(</span><span class="n">buf</span><span class="o">-></span><span class="n">data</span><span class="p">,</span> <span class="n">buf</span><span class="o">-></span><span class="n">len</span><span class="p">,</span> <span class="n">expected</span><span class="p">,</span> <span class="k">sizeof</span> <span class="p">(</span><span class="n">expected</span><span class="p">));</span></pre></td> </tr> </tbody> </table> </div> <p></p> <div class="refsect3"> <a name="g-assert-cmpmem.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>m1</p></td> <td class="parameter_description"><p>pointer to a buffer. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="NULL may be passed as the value in, out, in-out; or as a return value."><span class="acronym">nullable</span></acronym>]</span></td> </tr> <tr> <td class="parameter_name"><p>l1</p></td> <td class="parameter_description"><p>length of <em class="parameter"><code>m1</code></em> </p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>m2</p></td> <td class="parameter_description"><p>pointer to another buffer. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="NULL may be passed as the value in, out, in-out; or as a return value."><span class="acronym">nullable</span></acronym>]</span></td> </tr> <tr> <td class="parameter_name"><p>l2</p></td> <td class="parameter_description"><p>length of <em class="parameter"><code>m2</code></em> </p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-46.html#api-index-2.46">2.46</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-cmpvariant"></a><h3>g_assert_cmpvariant()</h3> <pre class="programlisting">#define g_assert_cmpvariant(v1, v2)</pre> <p>Debugging macro to compare two <a href="glib-GVariant.html#GVariant"><span class="type">GVariants</span></a>. If the comparison fails, an error message is logged and the application is either terminated or the testcase marked as failed. The variants are compared using <a class="link" href="glib-GVariant.html#g-variant-equal" title="g_variant_equal ()"><code class="function">g_variant_equal()</code></a>.</p> <p>The effect of <code class="literal">g_assert_cmpvariant (v1, v2)</code> is the same as <code class="literal">g_assert_true (g_variant_equal (v1, v2))</code>. The advantage of this macro is that it can produce a message that includes the actual values of <em class="parameter"><code>v1</code></em> and <em class="parameter"><code>v2</code></em> .</p> <div class="refsect3"> <a name="g-assert-cmpvariant.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>v1</p></td> <td class="parameter_description"><p>pointer to a <a class="link" href="glib-GVariant.html#GVariant" title="GVariant"><span class="type">GVariant</span></a></p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>v2</p></td> <td class="parameter_description"><p>pointer to another <a class="link" href="glib-GVariant.html#GVariant" title="GVariant"><span class="type">GVariant</span></a></p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-60.html#api-index-2.60">2.60</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-no-error"></a><h3>g_assert_no_error()</h3> <pre class="programlisting">#define g_assert_no_error(err)</pre> <p>Debugging macro to check that a <a class="link" href="glib-Error-Reporting.html#GError" title="struct GError"><span class="type">GError</span></a> is not set.</p> <p>The effect of <code class="literal">g_assert_no_error (err)</code> is the same as <code class="literal">g_assert_true (err == NULL)</code>. The advantage of this macro is that it can produce a message that includes the error message and code.</p> <div class="refsect3"> <a name="g-assert-no-error.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>err</p></td> <td class="parameter_description"><p>a <a class="link" href="glib-Error-Reporting.html#GError" title="struct GError"><span class="type">GError</span></a>, possibly <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a></p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-20.html#api-index-2.20">2.20</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-error"></a><h3>g_assert_error()</h3> <pre class="programlisting">#define g_assert_error(err, dom, c)</pre> <p>Debugging macro to check that a method has returned the correct <a class="link" href="glib-Error-Reporting.html#GError" title="struct GError"><span class="type">GError</span></a>.</p> <p>The effect of <code class="literal">g_assert_error (err, dom, c)</code> is the same as <code class="literal">g_assert_true (err != NULL &amp;&amp; err->domain == dom &amp;&amp; err->code == c)</code>. The advantage of this macro is that it can produce a message that includes the incorrect error message and code.</p> <p>This can only be used to test for a specific error. If you want to test that <em class="parameter"><code>err</code></em> is set, but don't care what it's set to, just use <code class="literal">g_assert_nonnull (err)</code>.</p> <div class="refsect3"> <a name="g-assert-error.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>err</p></td> <td class="parameter_description"><p>a <a class="link" href="glib-Error-Reporting.html#GError" title="struct GError"><span class="type">GError</span></a>, possibly <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a></p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>dom</p></td> <td class="parameter_description"><p>the expected error domain (a <a class="link" href="glib-Quarks.html#GQuark" title="GQuark"><span class="type">GQuark</span></a>)</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>c</p></td> <td class="parameter_description"><p>the expected error code</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-20.html#api-index-2.20">2.20</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-true"></a><h3>g_assert_true()</h3> <pre class="programlisting">#define g_assert_true(expr)</pre> <p>Debugging macro to check that an expression is true.</p> <p>If the assertion fails (i.e. the expression is not true), an error message is logged and the application is either terminated or the testcase marked as failed.</p> <p>Note that unlike <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a>, this macro is unaffected by whether <code class="literal">G_DISABLE_ASSERT</code> is defined. Hence it should only be used in tests and, conversely, <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> should not be used in tests.</p> <p>See <a class="link" href="glib-Testing.html#g-test-set-nonfatal-assertions" title="g_test_set_nonfatal_assertions ()"><code class="function">g_test_set_nonfatal_assertions()</code></a>.</p> <div class="refsect3"> <a name="g-assert-true.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>expr</p></td> <td class="parameter_description"><p>the expression to check</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-false"></a><h3>g_assert_false()</h3> <pre class="programlisting">#define g_assert_false(expr)</pre> <p>Debugging macro to check an expression is false.</p> <p>If the assertion fails (i.e. the expression is not false), an error message is logged and the application is either terminated or the testcase marked as failed.</p> <p>Note that unlike <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a>, this macro is unaffected by whether <code class="literal">G_DISABLE_ASSERT</code> is defined. Hence it should only be used in tests and, conversely, <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> should not be used in tests.</p> <p>See <a class="link" href="glib-Testing.html#g-test-set-nonfatal-assertions" title="g_test_set_nonfatal_assertions ()"><code class="function">g_test_set_nonfatal_assertions()</code></a>.</p> <div class="refsect3"> <a name="g-assert-false.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>expr</p></td> <td class="parameter_description"><p>the expression to check</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-null"></a><h3>g_assert_null()</h3> <pre class="programlisting">#define g_assert_null(expr)</pre> <p>Debugging macro to check an expression is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.</p> <p>If the assertion fails (i.e. the expression is not <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>), an error message is logged and the application is either terminated or the testcase marked as failed.</p> <p>Note that unlike <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a>, this macro is unaffected by whether <code class="literal">G_DISABLE_ASSERT</code> is defined. Hence it should only be used in tests and, conversely, <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> should not be used in tests.</p> <p>See <a class="link" href="glib-Testing.html#g-test-set-nonfatal-assertions" title="g_test_set_nonfatal_assertions ()"><code class="function">g_test_set_nonfatal_assertions()</code></a>.</p> <div class="refsect3"> <a name="g-assert-null.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>expr</p></td> <td class="parameter_description"><p>the expression to check</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="g-assert-nonnull"></a><h3>g_assert_nonnull()</h3> <pre class="programlisting">#define g_assert_nonnull(expr)</pre> <p>Debugging macro to check an expression is not <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.</p> <p>If the assertion fails (i.e. the expression is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>), an error message is logged and the application is either terminated or the testcase marked as failed.</p> <p>Note that unlike <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a>, this macro is unaffected by whether <code class="literal">G_DISABLE_ASSERT</code> is defined. Hence it should only be used in tests and, conversely, <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> should not be used in tests.</p> <p>See <a class="link" href="glib-Testing.html#g-test-set-nonfatal-assertions" title="g_test_set_nonfatal_assertions ()"><code class="function">g_test_set_nonfatal_assertions()</code></a>.</p> <div class="refsect3"> <a name="g-assert-nonnull.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>expr</p></td> <td class="parameter_description"><p>the expression to check</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-40.html#api-index-2.40">2.40</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-set-nonfatal-assertions"></a><h3>g_test_set_nonfatal_assertions ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_set_nonfatal_assertions (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Changes the behaviour of <a class="link" href="glib-Testing.html#g-assert-cmpstr" title="g_assert_cmpstr()"><code class="function">g_assert_cmpstr()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmpint" title="g_assert_cmpint()"><code class="function">g_assert_cmpint()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmpuint" title="g_assert_cmpuint()"><code class="function">g_assert_cmpuint()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmphex" title="g_assert_cmphex()"><code class="function">g_assert_cmphex()</code></a>, <a class="link" href="glib-Testing.html#g-assert-cmpfloat" title="g_assert_cmpfloat()"><code class="function">g_assert_cmpfloat()</code></a>, <a class="link" href="glib-Testing.html#g-assert-true" title="g_assert_true()"><code class="function">g_assert_true()</code></a>, <a class="link" href="glib-Testing.html#g-assert-false" title="g_assert_false()"><code class="function">g_assert_false()</code></a>, <a class="link" href="glib-Testing.html#g-assert-null" title="g_assert_null()"><code class="function">g_assert_null()</code></a>, <a class="link" href="glib-Testing.html#g-assert-no-error" title="g_assert_no_error()"><code class="function">g_assert_no_error()</code></a>, <a class="link" href="glib-Testing.html#g-assert-error" title="g_assert_error()"><code class="function">g_assert_error()</code></a>, <a class="link" href="glib-Testing.html#g-test-assert-expected-messages" title="g_test_assert_expected_messages"><code class="function">g_test_assert_expected_messages()</code></a> and the various g_test_trap_assert_*() macros to not abort to program, but instead call <a class="link" href="glib-Testing.html#g-test-fail" title="g_test_fail ()"><code class="function">g_test_fail()</code></a> and continue. (This also changes the behavior of <a class="link" href="glib-Testing.html#g-test-fail" title="g_test_fail ()"><code class="function">g_test_fail()</code></a> so that it will not cause the test program to abort after completing the failed test.)</p> <p>Note that the <a class="link" href="glib-Testing.html#g-assert-not-reached" title="g_assert_not_reached"><code class="function">g_assert_not_reached()</code></a> and <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> are not affected by this.</p> <p>This function can only be called after <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>.</p> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="GTestFixtureFunc"></a><h3>GTestFixtureFunc ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> <span class="c_punctuation">(</span>*GTestFixtureFunc<span class="c_punctuation">)</span> (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> fixture</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> user_data</code></em>);</pre> <p>The type used for functions that operate on test fixtures. This is used for the fixture setup and teardown functions as well as for the testcases themselves.</p> <p><em class="parameter"><code>user_data</code></em> is a pointer to the data that was given when registering the test case.</p> <p><em class="parameter"><code>fixture</code></em> will be a pointer to the area of memory allocated by the test framework, of the size requested. If the requested size was zero then <em class="parameter"><code>fixture</code></em> will be equal to <em class="parameter"><code>user_data</code></em> .</p> <div class="refsect3"> <a name="GTestFixtureFunc.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>fixture</p></td> <td class="parameter_description"><p>the test fixture. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="NULL must not be passed as the value in, out, in-out; or as a return value."><span class="acronym">not nullable</span></acronym>]</span></td> </tr> <tr> <td class="parameter_name"><p>user_data</p></td> <td class="parameter_description"><p>the data provided when registering the test</p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-28.html#api-index-2.28">2.28</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-create-case"></a><h3>g_test_create_case ()</h3> <pre class="programlisting"><a class="link" href="glib-Testing.html#GTestCase" title="GTestCase"><span class="returnvalue">GTestCase</span></a> * g_test_create_case (<em class="parameter"><code>const <span class="type">char</span> *test_name</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> data_size</code></em>, <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> test_data</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestFixtureFunc" title="GTestFixtureFunc ()"><span class="type">GTestFixtureFunc</span></a> data_setup</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestFixtureFunc" title="GTestFixtureFunc ()"><span class="type">GTestFixtureFunc</span></a> data_test</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestFixtureFunc" title="GTestFixtureFunc ()"><span class="type">GTestFixtureFunc</span></a> data_teardown</code></em>);</pre> <p>Create a new <a class="link" href="glib-Testing.html#GTestCase" title="GTestCase"><span class="type">GTestCase</span></a>, named <em class="parameter"><code>test_name</code></em> , this API is fairly low level, calling <a class="link" href="glib-Testing.html#g-test-add" title="g_test_add()"><code class="function">g_test_add()</code></a> or <a class="link" href="glib-Testing.html#g-test-add-func" title="g_test_add_func ()"><code class="function">g_test_add_func()</code></a> is preferable. When this test is executed, a fixture structure of size <em class="parameter"><code>data_size</code></em> will be automatically allocated and filled with zeros. Then <em class="parameter"><code>data_setup</code></em> is called to initialize the fixture. After fixture setup, the actual test function <em class="parameter"><code>data_test</code></em> is called. Once the test run completes, the fixture structure is torn down by calling <em class="parameter"><code>data_teardown</code></em> and after that the memory is automatically released by the test framework.</p> <p>Splitting up a test run into fixture setup, test function and fixture teardown is most useful if the same fixture is used for multiple tests. In this cases, <a class="link" href="glib-Testing.html#g-test-create-case" title="g_test_create_case ()"><code class="function">g_test_create_case()</code></a> will be called with the same fixture, but varying <em class="parameter"><code>test_name</code></em> and <em class="parameter"><code>data_test</code></em> arguments.</p> <div class="refsect3"> <a name="g-test-create-case.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>test_name</p></td> <td class="parameter_description"><p>the name for the test case</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>data_size</p></td> <td class="parameter_description"><p>the size of the fixture data structure</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>test_data</p></td> <td class="parameter_description"><p>test data argument for the test functions</p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>data_setup</p></td> <td class="parameter_description"><p>the function to set up the fixture data. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="The callback is valid until first called."><span class="acronym">scope async</span></acronym>]</span></td> </tr> <tr> <td class="parameter_name"><p>data_test</p></td> <td class="parameter_description"><p>the actual test function. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="The callback is valid until first called."><span class="acronym">scope async</span></acronym>]</span></td> </tr> <tr> <td class="parameter_name"><p>data_teardown</p></td> <td class="parameter_description"><p>the function to teardown the fixture data. </p></td> <td class="parameter_annotations"><span class="annotation">[<acronym title="The callback is valid until first called."><span class="acronym">scope async</span></acronym>]</span></td> </tr> </tbody> </table></div> </div> <div class="refsect3"> <a name="g-test-create-case.returns"></a><h4>Returns</h4> <p> a newly allocated <a class="link" href="glib-Testing.html#GTestCase" title="GTestCase"><span class="type">GTestCase</span></a>.</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-create-suite"></a><h3>g_test_create_suite ()</h3> <pre class="programlisting"><a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="returnvalue">GTestSuite</span></a> * g_test_create_suite (<em class="parameter"><code>const <span class="type">char</span> *suite_name</code></em>);</pre> <p>Create a new test suite with the name <em class="parameter"><code>suite_name</code></em> .</p> <div class="refsect3"> <a name="g-test-create-suite.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>suite_name</p></td> <td class="parameter_description"><p>a name for the suite</p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <div class="refsect3"> <a name="g-test-create-suite.returns"></a><h4>Returns</h4> <p> A newly allocated <a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a> instance.</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-get-root"></a><h3>g_test_get_root ()</h3> <pre class="programlisting"><a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="returnvalue">GTestSuite</span></a> * g_test_get_root (<em class="parameter"><code><span class="type">void</span></code></em>);</pre> <p>Get the toplevel test suite for the test path API.</p> <div class="refsect3"> <a name="g-test-get-root.returns"></a><h4>Returns</h4> <p> the toplevel <a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a></p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-suite-add"></a><h3>g_test_suite_add ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_suite_add (<em class="parameter"><code><a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a> *suite</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestCase" title="GTestCase"><span class="type">GTestCase</span></a> *test_case</code></em>);</pre> <p>Adds <em class="parameter"><code>test_case</code></em> to <em class="parameter"><code>suite</code></em> .</p> <div class="refsect3"> <a name="g-test-suite-add.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>suite</p></td> <td class="parameter_description"><p>a <a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a></p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>test_case</p></td> <td class="parameter_description"><p>a <a class="link" href="glib-Testing.html#GTestCase" title="GTestCase"><span class="type">GTestCase</span></a></p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-suite-add-suite"></a><h3>g_test_suite_add_suite ()</h3> <pre class="programlisting"><span class="returnvalue">void</span> g_test_suite_add_suite (<em class="parameter"><code><a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a> *suite</code></em>, <em class="parameter"><code><a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a> *nestedsuite</code></em>);</pre> <p>Adds <em class="parameter"><code>nestedsuite</code></em> to <em class="parameter"><code>suite</code></em> .</p> <div class="refsect3"> <a name="g-test-suite-add-suite.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody> <tr> <td class="parameter_name"><p>suite</p></td> <td class="parameter_description"><p>a <a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a></p></td> <td class="parameter_annotations"> </td> </tr> <tr> <td class="parameter_name"><p>nestedsuite</p></td> <td class="parameter_description"><p>another <a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a></p></td> <td class="parameter_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> <hr> <div class="refsect2"> <a name="g-test-run-suite"></a><h3>g_test_run_suite ()</h3> <pre class="programlisting"><span class="returnvalue">int</span> g_test_run_suite (<em class="parameter"><code><a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a> *suite</code></em>);</pre> <p>Execute the tests within <em class="parameter"><code>suite</code></em> and all nested <span class="type">GTestSuites</span>. The test suites to be executed are filtered according to test path arguments (<code class="literal">-p testpath</code> and <code class="literal">-s testpath</code>) as parsed by <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()"><code class="function">g_test_init()</code></a>. See the <a class="link" href="glib-Testing.html#g-test-run" title="g_test_run ()"><code class="function">g_test_run()</code></a> documentation for more information on the order that tests are run in.</p> <p>g_test_run_suite() or <a class="link" href="glib-Testing.html#g-test-run" title="g_test_run ()"><code class="function">g_test_run()</code></a> may only be called once in a program.</p> <div class="refsect3"> <a name="g-test-run-suite.parameters"></a><h4>Parameters</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="150px" class="parameters_name"> <col class="parameters_description"> <col width="200px" class="parameters_annotations"> </colgroup> <tbody><tr> <td class="parameter_name"><p>suite</p></td> <td class="parameter_description"><p>a <a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a></p></td> <td class="parameter_annotations"> </td> </tr></tbody> </table></div> </div> <div class="refsect3"> <a name="g-test-run-suite.returns"></a><h4>Returns</h4> <p> 0 on success</p> </div> <p class="since">Since: <a class="link" href="api-index-2-16.html#api-index-2.16">2.16</a></p> </div> </div> <div class="refsect1"> <a name="glib-Testing.other_details"></a><h2>Types and Values</h2> <div class="refsect2"> <a name="G-TEST-OPTION-ISOLATE-DIRS:CAPS"></a><h3>G_TEST_OPTION_ISOLATE_DIRS</h3> <pre class="programlisting">#define G_TEST_OPTION_ISOLATE_DIRS "isolate_dirs" </pre> <p>Creates a unique temporary directory for each unit test and uses <code class="function">g_set_user_dirs()</code> to set XDG directories to point into subdirectories of it for the duration of the unit test. The directory tree is cleaned up after the test finishes successfully. Note that this doesn’t take effect until <a class="link" href="glib-Testing.html#g-test-run" title="g_test_run ()"><code class="function">g_test_run()</code></a> is called, so calls to (for example) <code class="function">g_get_user_home_dir()</code> will return the system-wide value when made in a test program’s <code class="function">main()</code> function.</p> <p>The following functions will return subdirectories of the temporary directory when this option is used. The specific subdirectory paths in use are not guaranteed to be stable API — always use a getter function to retrieve them.</p> <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"><p>g_get_home_dir()</p></li> <li class="listitem"><p>g_get_user_cache_dir()</p></li> <li class="listitem"><p>g_get_system_config_dirs()</p></li> <li class="listitem"><p>g_get_user_config_dir()</p></li> <li class="listitem"><p>g_get_system_data_dirs()</p></li> <li class="listitem"><p>g_get_user_data_dir()</p></li> <li class="listitem"><p>g_get_user_runtime_dir()</p></li> </ul></div> <p>The subdirectories may not be created by the test harness; as with normal calls to functions like <a class="link" href="glib-Miscellaneous-Utility-Functions.html#g-get-user-cache-dir" title="g_get_user_cache_dir ()"><code class="function">g_get_user_cache_dir()</code></a>, the caller must be prepared to create the directory if it doesn’t exist.</p> <p class="since">Since: <a class="link" href="api-index-2-60.html#api-index-2.60">2.60</a></p> </div> <hr> <div class="refsect2"> <a name="GTestFileType"></a><h3>enum GTestFileType</h3> <p>The type of file to return the filename for, when used with <a class="link" href="glib-Testing.html#g-test-build-filename" title="g_test_build_filename ()"><code class="function">g_test_build_filename()</code></a>.</p> <p>These two options correspond rather directly to the 'dist' and 'built' terminology that automake uses and are explicitly used to distinguish between the 'srcdir' and 'builddir' being separate. All files in your project should either be dist (in the <code class="literal">EXTRA_DIST</code> or <code class="literal">dist_schema_DATA</code> sense, in which case they will always be in the srcdir) or built (in the <code class="literal">BUILT_SOURCES</code> sense, in which case they will always be in the builddir).</p> <p>Note: as a general rule of automake, files that are generated only as part of the build-from-git process (but then are distributed with the tarball) always go in srcdir (even if doing a srcdir != builddir build from git) and are considered as distributed files.</p> <div class="refsect3"> <a name="GTestFileType.members"></a><h4>Members</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="300px" class="enum_members_name"> <col class="enum_members_description"> <col width="200px" class="enum_members_annotations"> </colgroup> <tbody> <tr> <td class="enum_member_name"><p><a name="G-TEST-DIST:CAPS"></a>G_TEST_DIST</p></td> <td class="enum_member_description"> <p>a file that was included in the distribution tarball</p> </td> <td class="enum_member_annotations"> </td> </tr> <tr> <td class="enum_member_name"><p><a name="G-TEST-BUILT:CAPS"></a>G_TEST_BUILT</p></td> <td class="enum_member_description"> <p>a file that was built on the compiling machine</p> </td> <td class="enum_member_annotations"> </td> </tr> </tbody> </table></div> </div> <p class="since">Since: <a class="link" href="api-index-2-38.html#api-index-2.38">2.38</a></p> </div> <hr> <div class="refsect2"> <a name="GTestTrapFlags"></a><h3>enum GTestTrapFlags</h3> <div class="warning"> <p><code class="literal">GTestTrapFlags</code> has been deprecated since version 2.38 and should not be used in newly-written code.</p> <p><a class="link" href="glib-Testing.html#GTestTrapFlags" title="enum GTestTrapFlags"><span class="type">GTestTrapFlags</span></a> is used only with <a class="link" href="glib-Testing.html#g-test-trap-fork" title="g_test_trap_fork ()"><code class="function">g_test_trap_fork()</code></a>, which is deprecated. <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a> uses <a class="link" href="glib-Testing.html#GTestSubprocessFlags" title="enum GTestSubprocessFlags"><span class="type">GTestSubprocessFlags</span></a>.</p> </div> <p>Test traps are guards around forked tests. These flags determine what traps to set.</p> <div class="refsect3"> <a name="GTestTrapFlags.members"></a><h4>Members</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="300px" class="enum_members_name"> <col class="enum_members_description"> <col width="200px" class="enum_members_annotations"> </colgroup> <tbody> <tr> <td class="enum_member_name"><p><a name="G-TEST-TRAP-SILENCE-STDOUT:CAPS"></a>G_TEST_TRAP_SILENCE_STDOUT</p></td> <td class="enum_member_description"> <p>Redirect stdout of the test child to <code class="literal">/dev/null</code> so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with <a class="link" href="glib-Testing.html#g-test-trap-assert-stdout" title="g_test_trap_assert_stdout()"><code class="function">g_test_trap_assert_stdout()</code></a>.</p> </td> <td class="enum_member_annotations"> </td> </tr> <tr> <td class="enum_member_name"><p><a name="G-TEST-TRAP-SILENCE-STDERR:CAPS"></a>G_TEST_TRAP_SILENCE_STDERR</p></td> <td class="enum_member_description"> <p>Redirect stderr of the test child to <code class="literal">/dev/null</code> so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with <a class="link" href="glib-Testing.html#g-test-trap-assert-stderr" title="g_test_trap_assert_stderr()"><code class="function">g_test_trap_assert_stderr()</code></a>.</p> </td> <td class="enum_member_annotations"> </td> </tr> <tr> <td class="enum_member_name"><p><a name="G-TEST-TRAP-INHERIT-STDIN:CAPS"></a>G_TEST_TRAP_INHERIT_STDIN</p></td> <td class="enum_member_description"> <p>If this flag is given, stdin of the child process is shared with stdin of its parent process. It is redirected to <code class="literal">/dev/null</code> otherwise.</p> </td> <td class="enum_member_annotations"> </td> </tr> </tbody> </table></div> </div> </div> <hr> <div class="refsect2"> <a name="GTestSubprocessFlags"></a><h3>enum GTestSubprocessFlags</h3> <p>Flags to pass to <a class="link" href="glib-Testing.html#g-test-trap-subprocess" title="g_test_trap_subprocess ()"><code class="function">g_test_trap_subprocess()</code></a> to control input and output.</p> <p>Note that in contrast with <a class="link" href="glib-Testing.html#g-test-trap-fork" title="g_test_trap_fork ()"><code class="function">g_test_trap_fork()</code></a>, the default is to not show stdout and stderr.</p> <div class="refsect3"> <a name="GTestSubprocessFlags.members"></a><h4>Members</h4> <div class="informaltable"><table class="informaltable" width="100%" border="0"> <colgroup> <col width="300px" class="enum_members_name"> <col class="enum_members_description"> <col width="200px" class="enum_members_annotations"> </colgroup> <tbody> <tr> <td class="enum_member_name"><p><a name="G-TEST-SUBPROCESS-INHERIT-STDIN:CAPS"></a>G_TEST_SUBPROCESS_INHERIT_STDIN</p></td> <td class="enum_member_description"> <p>If this flag is given, the child process will inherit the parent's stdin. Otherwise, the child's stdin is redirected to <code class="literal">/dev/null</code>.</p> </td> <td class="enum_member_annotations"> </td> </tr> <tr> <td class="enum_member_name"><p><a name="G-TEST-SUBPROCESS-INHERIT-STDOUT:CAPS"></a>G_TEST_SUBPROCESS_INHERIT_STDOUT</p></td> <td class="enum_member_description"> <p>If this flag is given, the child process will inherit the parent's stdout. Otherwise, the child's stdout will not be visible, but it will be captured to allow later tests with <a class="link" href="glib-Testing.html#g-test-trap-assert-stdout" title="g_test_trap_assert_stdout()"><code class="function">g_test_trap_assert_stdout()</code></a>.</p> </td> <td class="enum_member_annotations"> </td> </tr> <tr> <td class="enum_member_name"><p><a name="G-TEST-SUBPROCESS-INHERIT-STDERR:CAPS"></a>G_TEST_SUBPROCESS_INHERIT_STDERR</p></td> <td class="enum_member_description"> <p>If this flag is given, the child process will inherit the parent's stderr. Otherwise, the child's stderr will not be visible, but it will be captured to allow later tests with <a class="link" href="glib-Testing.html#g-test-trap-assert-stderr" title="g_test_trap_assert_stderr()"><code class="function">g_test_trap_assert_stderr()</code></a>.</p> </td> <td class="enum_member_annotations"> </td> </tr> </tbody> </table></div> </div> </div> <hr> <div class="refsect2"> <a name="GTestCase"></a><h3>GTestCase</h3> <pre class="programlisting">typedef struct GTestCase GTestCase; </pre> <p>An opaque structure representing a test case.</p> </div> <hr> <div class="refsect2"> <a name="GTestSuite"></a><h3>GTestSuite</h3> <pre class="programlisting">typedef struct GTestSuite GTestSuite; </pre> <p>An opaque structure representing a test suite.</p> </div> </div> </div> <div class="footer"> <hr>Generated by GTK-Doc V1.32</div> </body> </html>