RubyGems - glib2 - Versions diffs - 1.1.8-x86-mingw32 → 1.1.9-x86-mingw32 - Mend

glib2 1.1.8-x86-mingw32 → 1.1.9-x86-mingw32

Files changed (1810) hide show

data/vendor/local/share/gtk-doc/html/glib/glib-Testing.html CHANGED

@@ -3,12 +3,12 @@
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Testing</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.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-Windows-Compatibility-Functions.html" title="Windows Compatibility Functions">
-<meta name="generator" content="GTK-Doc V1.17 (XML mode)">
+<link rel="next" href="glib-UNIX-specific-utilities-and-integration.html" title="UNIX-specific utilities and integration">
+<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -18,7 +18,7 @@
 <td><a accesskey="u" href="glib-utilities.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
 <td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
 <th width="100%" align="center">GLib Reference Manual</th>
-<td><a accesskey="n" href="glib-Windows-Compatibility-Functions.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
+<td><a accesskey="n" href="glib-UNIX-specific-utilities-and-integration.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
 </tr>
 <tr><td colspan="5" class="shortcuts">
 <a href="#glib-Testing.synopsis" class="shortcut">Top</a>
@@ -49,11 +49,13 @@
 <span class="returnvalue">void</span>                <a class="link" href="glib-Testing.html#g-test-init" title="g_test_init ()">g_test_init</a>                         (<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>);
+#define             <a class="link" href="glib-Testing.html#g-test-initialized" title="g_test_initialized">g_test_initialized</a>
 #define             <a class="link" href="glib-Testing.html#g-test-quick" title="g_test_quick">g_test_quick</a>
 #define             <a class="link" href="glib-Testing.html#g-test-slow" title="g_test_slow">g_test_slow</a>
 #define             <a class="link" href="glib-Testing.html#g-test-thorough" title="g_test_thorough">g_test_thorough</a>
 #define             <a class="link" href="glib-Testing.html#g-test-perf" title="g_test_perf">g_test_perf</a>
 #define             <a class="link" href="glib-Testing.html#g-test-verbose" title="g_test_verbose">g_test_verbose</a>
+#define             <a class="link" href="glib-Testing.html#g-test-undefined" title="g_test_undefined">g_test_undefined</a>
 #define             <a class="link" href="glib-Testing.html#g-test-quiet" title="g_test_quiet">g_test_quiet</a>
 <span class="returnvalue">int</span>                 <a class="link" href="glib-Testing.html#g-test-run" title="g_test_run ()">g_test_run</a>                          (<em class="parameter"><code><span class="type">void</span></code></em>);
 <span class="returnvalue">void</span>                (<a class="link" href="glib-Testing.html#GTestFunc" title="GTestFunc ()">*GTestFunc</a>)                        (<em class="parameter"><code><span class="type">void</span></code></em>);
@@ -63,12 +65,17 @@
 <span class="returnvalue">void</span>                <a class="link" href="glib-Testing.html#g-test-add-data-func" title="g_test_add_data_func ()">g_test_add_data_func</a>                (<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>);
+<span class="returnvalue">void</span>                <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>           (<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>);
 #define             <a class="link" href="glib-Testing.html#g-test-add" title="g_test_add()">g_test_add</a>                          (testpath,
                                                          Fixture,
                                                          tdata,
                                                          fsetup,
                                                          ftest,
                                                          fteardown)
+<span class="returnvalue">void</span>                <a class="link" href="glib-Testing.html#g-test-fail" title="g_test_fail ()">g_test_fail</a>                         (<em class="parameter"><code><span class="type">void</span></code></em>);
 <span class="returnvalue">void</span>                <a class="link" href="glib-Testing.html#g-test-message" title="g_test_message ()">g_test_message</a>                      (<em class="parameter"><code>const <span class="type">char</span> *format</code></em>,
                                                          <em class="parameter"><code>...</code></em>);
 <span class="returnvalue">void</span>                <a class="link" href="glib-Testing.html#g-test-bug-base" title="g_test_bug_base ()">g_test_bug_base</a>                     (<em class="parameter"><code>const <span class="type">char</span> *uri_pattern</code></em>);
@@ -86,6 +93,10 @@
 <span class="returnvalue">void</span>                <a class="link" href="glib-Testing.html#g-test-queue-destroy" title="g_test_queue_destroy ()">g_test_queue_destroy</a>                (<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>);
 #define             <a class="link" href="glib-Testing.html#g-test-queue-unref" title="g_test_queue_unref()">g_test_queue_unref</a>                  (gobject)
+<span class="returnvalue">void</span>                <a class="link" href="glib-Testing.html#g-test-expect-message" title="g_test_expect_message ()">g_test_expect_message</a>               (<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>);
+#define             <a class="link" href="glib-Testing.html#g-test-assert-expected-messages" title="g_test_assert_expected_messages">g_test_assert_expected_messages</a>
 enum                <a class="link" href="glib-Testing.html#GTestTrapFlags" title="enum GTestTrapFlags">GTestTrapFlags</a>;
 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-Testing.html#g-test-trap-fork" title="g_test_trap_fork ()">g_test_trap_fork</a>                    (<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>);
@@ -152,38 +163,38 @@ 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="variablelist"><table border="0">
+<p>
+</p>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term">Test case</span></p></td>
-<td><p>
-      Tests (test methods) are grouped together with their
-      fixture into test cases.
-    </p></td>
+<td>Tests (test methods) are grouped together with their
+      fixture into test cases.</td>
 </tr>
 <tr>
 <td><p><span class="term">Fixture</span></p></td>
-<td><p>
-      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></td>
+<td>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.</td>
 </tr>
 <tr>
 <td><p><span class="term">Test suite</span></p></td>
-<td><p>
-      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></td>
+<td>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.</td>
 </tr>
 </tbody>
 </table></div>
 <p>
-The API is designed to handle creation and registration of test suites and
-test cases implicitly. A simple call like
+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">
@@ -197,16 +208,16 @@ test cases implicitly. A simple call like
 </div>
 <p>
-creates a test suite called "misc" with a single test case named "assertions",
-which consists of running the test_assertions function.
+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" title="g_assert()"><code class="function">g_assert()</code></a>, the test framework provides
 an extended set of assertions for string and numerical 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-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>. The advantage of these variants over plain <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a>
-is that the assertion messages can be more elaborate, and include the
-values of the compared entities.
+<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-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>. The advantage of these variants
+over plain <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a> is that the assertion messages can be more
+elaborate, and include the values of the compared entities.
 </p>
 <p>
 GLib ships with two utilities called gtester and gtester-report to
@@ -227,8 +238,11 @@ 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>minimized_quantity</code></em> :</span></p></td>
@@ -259,8 +273,11 @@ 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>maximized_quantity</code></em> :</span></p></td>
@@ -290,61 +307,81 @@ test random number generator, the name for <a class="link" href="glib-Miscellane
 and parsing test related command line args.
 So far, the following arguments are understood:
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><code class="option">-l</code></span></p></td>
 <td><p>
-      list test cases available in a test executable.
+      List test cases available in a test executable.
     </p></td>
 </tr>
 <tr>
 <td><p><span class="term"><code class="option">--seed=<em class="replaceable"><code>RANDOMSEED</code></em></code></span></p></td>
 <td><p>
-      provide a random seed to reproduce test runs using random numbers.
+      Provide a random seed to reproduce test runs using random numbers.
     </p></td>
 </tr>
 <tr>
 <td><p><span class="term"><code class="option">--verbose</code></span></p></td>
-<td><p>run tests verbosely.</p></td>
+<td><p>Run tests verbosely.</p></td>
 </tr>
 <tr>
 <td><p><span class="term"><code class="option">-q</code>, <code class="option">--quiet</code></span></p></td>
-<td><p>run tests quietly.</p></td>
+<td><p>Run tests quietly.</p></td>
 </tr>
 <tr>
 <td><p><span class="term"><code class="option">-p <em class="replaceable"><code>TESTPATH</code></em></code></span></p></td>
 <td><p>
-        execute all tests matching <em class="replaceable"><code>TESTPATH</code></em>.
+        Execute all tests matching <em class="replaceable"><code>TESTPATH</code></em>.
       </p></td>
 </tr>
 <tr>
-<td><p><span class="term"><code class="option">-m {perf|slow|thorough|quick}</code></span></p></td>
+<td><p><span class="term"><code class="option">-m {perf|slow|thorough|quick|undefined|no-undefined}</code></span></p></td>
 <td>
 <p>
-        execute tests according to these test modes:
+        Execute tests according to these test modes:
         </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term">perf</span></p></td>
 <td><p>
-              performance tests, may take long and report results.
+              Performance tests, may take long and report results.
             </p></td>
 </tr>
 <tr>
 <td><p><span class="term">slow, thorough</span></p></td>
 <td><p>
-              slow and thorough tests, may take quite long and
+              Slow and thorough tests, may take quite long and
               maximize coverage.
             </p></td>
 </tr>
 <tr>
 <td><p><span class="term">quick</span></p></td>
 <td><p>
-              quick tests, should run really quickly and give good coverage.
+              Quick tests, should run really quickly and give good coverage.
+            </p></td>
+</tr>
+<tr>
+<td><p><span class="term">undefined</span></p></td>
+<td><p>
+              Tests for undefined behaviour, may provoke programming errors
+              under <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> to check that appropriate assertions
+              or warnings are given
+            </p></td>
+</tr>
+<tr>
+<td><p><span class="term">no-undefined</span></p></td>
+<td><p>
+              Avoid tests for undefined behaviour
             </p></td>
 </tr>
 </tbody>
@@ -355,26 +392,17 @@ So far, the following arguments are understood:
 </tr>
 <tr>
 <td><p><span class="term"><code class="option">--debug-log</code></span></p></td>
-<td><p>debug test logging output.</p></td>
-</tr>
-<tr>
-<td><p><span class="term"><code class="option">-k</code>, <code class="option">--keep-going</code></span></p></td>
-<td><p>gtester-specific argument.</p></td>
-</tr>
-<tr>
-<td><p><span class="term"><code class="option">--GTestLogFD <em class="replaceable"><code>N</code></em></code></span></p></td>
-<td><p>gtester-specific argument.</p></td>
-</tr>
-<tr>
-<td><p><span class="term"><code class="option">--GTestSkipCount <em class="replaceable"><code>N</code></em></code></span></p></td>
-<td><p>gtester-specific argument.</p></td>
+<td><p>Debug test logging output.</p></td>
 </tr>
 </tbody>
 </table></div>
 <p>
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>argc</code></em> :</span></p></td>
@@ -396,11 +424,44 @@ Any parameters understood by <a class="link" href="glib-Testing.html#g-test-init
 </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="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody><tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<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.</td>
+</tr></tbody>
+</table></div>
+<p class="since">Since 2.36</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>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody><tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if in quick mode</td>
+</tr></tbody>
+</table></div>
 </div>
 <hr>
 <div class="refsect2">
@@ -408,15 +469,40 @@ Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE">
 <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>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody><tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>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>
+</td>
+</tr></tbody>
+</table></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.
+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>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody><tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>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>
+</td>
+</tr></tbody>
+</table></div>
 </div>
 <hr>
 <div class="refsect2">
@@ -425,6 +511,17 @@ Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE">
 <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>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody><tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if in performance mode</td>
+</tr></tbody>
+</table></div>
 </div>
 <hr>
 <div class="refsect2">
@@ -432,7 +529,41 @@ Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE">
 <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.
+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="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody><tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if in verbose mode</td>
+</tr></tbody>
+</table></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 under <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>, to verify that appropriate warnings
+are given. It can be useful to turn this off if running tests under
+valgrind.
+</p>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody><tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if tests may provoke programming errors</td>
+</tr></tbody>
+</table></div>
 </div>
 <hr>
 <div class="refsect2">
@@ -440,7 +571,19 @@ Returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE">
 <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.
+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="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody><tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if in quiet mode</td>
+</tr></tbody>
+</table></div>
 </div>
 <hr>
 <div class="refsect2">
@@ -455,8 +598,11 @@ parsed by <a class="link" href="glib-Testing.html#g-test-init" title="g_test_ini
 <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>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 <td>0 on success</td>
@@ -471,6 +617,7 @@ in a program.
 <p>
 The type used for test case functions.
 </p>
+<p class="since">Since 2.28</p>
 </div>
 <hr>
 <div class="refsect2">
@@ -483,12 +630,15 @@ 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>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>testpath</code></em> :</span></p></td>
-<td>Slash-separated test case path name for the test.</td>
+<td>/-separated test case path name for the test.</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>test_func</code></em> :</span></p></td>
@@ -506,13 +656,17 @@ slash-separated portions of <em class="parameter"><code>testpath</code></em>.
 The type used for test case functions that take an extra pointer
 argument.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>user_data</code></em> :</span></p></td>
 <td>the data provided when registering the test</td>
 </tr></tbody>
 </table></div>
+<p class="since">Since 2.28</p>
 </div>
 <hr>
 <div class="refsect2">
@@ -527,12 +681,15 @@ 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>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>testpath</code></em> :</span></p></td>
-<td>Slash-separated test case path name for the test.</td>
+<td>/-separated test case path name for the test.</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>test_data</code></em> :</span></p></td>
@@ -548,6 +705,44 @@ will be passed as first argument to <em class="parameter"><code>test_func</code>
 </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="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>testpath</code></em> :</span></p></td>
+<td>/-separated test case path name for the test.</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>test_data</code></em> :</span></p></td>
+<td>Test data argument for the test function.</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>test_func</code></em> :</span></p></td>
+<td>The test function to invoke for this test.</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>data_free_func</code></em> :</span></p></td>
+<td>
+<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>.</td>
+</tr>
+</tbody>
+</table></div>
+<p class="since">Since 2.34</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>
@@ -558,8 +753,11 @@ though, similar to <a class="link" href="glib-Testing.html#g-test-create-case" t
 <code class="function">fteardown()</code> callbacks can expect a <em class="parameter"><code>Fixture</code></em> pointer as first argument in
 a type safe manner.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>testpath</code></em> :</span></p></td>
@@ -591,14 +789,41 @@ a type safe manner.
 </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 2.30</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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>format</code></em> :</span></p></td>
@@ -629,10 +854,13 @@ 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
-'<code class="literal">s</code>' within <em class="parameter"><code>uri_pattern</code></em> if that is present.
+'%s' within <em class="parameter"><code>uri_pattern</code></em> if that is present.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>uri_pattern</code></em> :</span></p></td>
 <td>the base pattern for bug URIs</td>
@@ -650,8 +878,11 @@ 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>.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>bug_uri_snippet</code></em> :</span></p></td>
 <td>Bug specific bug tracker URI portion.</td>
@@ -669,8 +900,11 @@ and <em class="parameter"><code>bug_uri_snippet</code></em>.
 <p>
 Specifies the prototype of fatal log handler functions.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_domain</code></em> :</span></p></td>
@@ -723,8 +957,11 @@ function which needs the special behavior.
 <p>
 This handler has no effect on g_error messages.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_func</code></em> :</span></p></td>
@@ -755,8 +992,11 @@ to be done. Call this function again to restart the timer.
 <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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 <td>the time since the last start of the timer, as a double</td>
@@ -771,8 +1011,11 @@ Get the time since the last start of the timer with <a class="link" href="glib-T
 <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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 <td>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</td>
@@ -789,8 +1032,11 @@ Enqueue a pointer to be released with <a class="link" href="glib-Memory-Allocati
 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>gfree_pointer</code></em> :</span></p></td>
 <td>the pointer to be stored.</td>
@@ -804,15 +1050,18 @@ with a destroy callback of <a class="link" href="glib-Memory-Allocation.html#g-f
 <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 @<code class="function">destroy_func()</code> to be executed
+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 allocted 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>destroy_func</code></em> :</span></p></td>
@@ -831,12 +1080,15 @@ callback A before callback B will cause <code class="function">B()</code> to be
 <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 <a href="http://library.gnome.org/devel/gobject/unstable/gobject-The-Base-Object-Type.html#g-object-unref"><code class="function">g_object_unref()</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 href="http://library.gnome.org/devel/gobject/unstable/gobject-The-Base-Object-Type.html#g-object-unref"><code class="function">g_object_unref()</code></a>.
+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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>gobject</code></em> :</span></p></td>
 <td>the object to unref</td>
@@ -846,6 +1098,98 @@ with a destroy callback of <a href="http://library.gnome.org/devel/gobject/unsta
 </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>
+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>
+<p>
+</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="comment">/* g_main_context_push_thread_default() should fail if the</span>
+<span class="comment"> * context is already owned by another thread.</span>
+<span class="comment"> */</span>
+<span class="function"><a href="glib-Testing.html#g-test-expect-message">g_test_expect_message</a></span><span class="normal"> </span><span class="symbol">(</span><span class="normal"><a href="glib-Message-Logging.html#G-LOG-DOMAIN:CAPS">G_LOG_DOMAIN</a></span><span class="symbol">,</span>
+<span class="normal">                       <a href="glib-Message-Logging.html#G-LOG-LEVEL-CRITICAL:CAPS">G_LOG_LEVEL_CRITICAL</a></span><span class="symbol">,</span>
+<span class="normal">                       </span><span class="string">"assertion*acquired_context*failed"</span><span class="symbol">);</span>
+<span class="function"><a href="glib-The-Main-Event-Loop.html#g-main-context-push-thread-default">g_main_context_push_thread_default</a></span><span class="normal"> </span><span class="symbol">(</span><span class="normal">bad_context</span><span class="symbol">);</span>
+<span class="function"><a href="glib-Testing.html#g-test-assert-expected-messages">g_test_assert_expected_messages</a></span><span class="normal"> </span><span class="symbol">();</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-fork" title="g_test_trap_fork ()"><code class="function">g_test_trap_fork()</code></a> in this case.
+</p>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>log_domain</code></em> :</span></p></td>
+<td>the log domain of the message</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>log_level</code></em> :</span></p></td>
+<td>the log level of the message</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>pattern</code></em> :</span></p></td>
+<td>a glob-style
+<a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a>
+</td>
+</tr>
+</tbody>
+</table></div>
+<p class="since">Since 2.34</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 class="since">Since 2.34</p>
+</div>
+<hr>
+<div class="refsect2">
 <a name="GTestTrapFlags"></a><h3>enum GTestTrapFlags</h3>
 <pre class="programlisting">typedef enum {
   G_TEST_TRAP_SILENCE_STDOUT    = 1 &lt;&lt; 7,
@@ -854,15 +1198,18 @@ with a destroy callback of <a href="http://library.gnome.org/devel/gobject/unsta
 } GTestTrapFlags;
 </pre>
 <p>
-Test traps are guards around forked tests. These flags
-determine what traps to set.
+Test traps are guards around forked tests.
+These flags determine what traps to set.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><a name="G-TEST-TRAP-SILENCE-STDOUT:CAPS"></a><span class="term"><code class="literal">G_TEST_TRAP_SILENCE_STDOUT</code></span></p></td>
-<td>Redirect stdout of the test child to
+<td>Redirect stdout of the test child to
     <code class="filename">/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>.
@@ -870,7 +1217,7 @@ determine what traps to set.
 </tr>
 <tr>
 <td><p><a name="G-TEST-TRAP-SILENCE-STDERR:CAPS"></a><span class="term"><code class="literal">G_TEST_TRAP_SILENCE_STDERR</code></span></p></td>
-<td>Redirect stderr of the test child to
+<td>Redirect stderr of the test child to
     <code class="filename">/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>.
@@ -878,9 +1225,9 @@ determine what traps to set.
 </tr>
 <tr>
 <td><p><a name="G-TEST-TRAP-INHERIT-STDIN:CAPS"></a><span class="term"><code class="literal">G_TEST_TRAP_INHERIT_STDIN</code></span></p></td>
-<td>If this flag is given, stdin of the forked
-    child process is shared with stdin of its parent process. It is
-    redirected to <code class="filename">/dev/null</code> otherwise.
+<td>If this flag is given, stdin of the
+    forked child process is shared with stdin of its parent process.
+    It is redirected to <code class="filename">/dev/null</code> otherwise.
 </td>
 </tr>
 </tbody>
@@ -947,8 +1294,11 @@ termination and validates child program outputs.
 <p>
 This function is implemented only on Unix platforms.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>usec_timeout</code></em> :</span></p></td>
@@ -974,8 +1324,11 @@ This function is implemented only on Unix platforms.
 <p>
 Check the result of the last <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> call.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 <td>
@@ -991,8 +1344,11 @@ Check the result of the last <a class="link" href="glib-Testing.html#g-test-trap
 <p>
 Check the result of the last <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> call.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 <td>
@@ -1006,7 +1362,8 @@ Check the result of the last <a class="link" href="glib-Testing.html#g-test-trap
 <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 forked test passed. See <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>.
+Assert that the last forked test passed.
+See <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>.
 </p>
 <p class="since">Since 2.16</p>
 </div>
@@ -1015,7 +1372,15 @@ Assert that the last forked test passed. See <a class="link" href="glib-Testing.
 <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 forked test failed. See <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>.
+Assert that the last forked test failed.
+See <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>.
+</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-fork" title="g_test_trap_fork ()"><code class="function">g_test_trap_fork()</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 2.16</p>
 </div>
@@ -1024,14 +1389,18 @@ Assert that the last forked test failed. See <a class="link" href="glib-Testing.
 <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 forked test matches <em class="parameter"><code>soutpattern</code></em>.
-See <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>.
+Assert that the stdout output of the last forked test matches
+<em class="parameter"><code>soutpattern</code></em>. See <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>.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>soutpattern</code></em> :</span></p></td>
-<td>a glob-style <a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a>
+<td>a glob-style
+<a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a>
 </td>
 </tr></tbody>
 </table></div>
@@ -1042,14 +1411,18 @@ See <a class="link" href="glib-Testing.html#g-test-trap-fork" title="g_test_trap
 <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 forked test does not match
-<em class="parameter"><code>soutpattern</code></em>.  See <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>.
+Assert that the stdout output of the last forked test
+does not match <em class="parameter"><code>soutpattern</code></em>. See <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>.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>soutpattern</code></em> :</span></p></td>
-<td>a glob-style <a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a>
+<td>a glob-style
+<a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a>
 </td>
 </tr></tbody>
 </table></div>
@@ -1060,14 +1433,25 @@ Assert that the stdout output of the last forked test does not match
 <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 forked test matches <em class="parameter"><code>serrpattern</code></em>.
-See <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>.
+Assert that the stderr output of the last forked test
+matches <em class="parameter"><code>serrpattern</code></em>. See  <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>.
+</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-fork" title="g_test_trap_fork ()"><code class="function">g_test_trap_fork()</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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>serrpattern</code></em> :</span></p></td>
-<td>a glob-style <a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a>
+<td>a glob-style
+<a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a>
 </td>
 </tr></tbody>
 </table></div>
@@ -1078,14 +1462,18 @@ See <a class="link" href="glib-Testing.html#g-test-trap-fork" title="g_test_trap
 <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 forked test does not match
-<em class="parameter"><code>serrpattern</code></em>.  See <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>.
+Assert that the stderr output of the last forked test
+does not match <em class="parameter"><code>serrpattern</code></em>. See <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>.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>serrpattern</code></em> :</span></p></td>
-<td>a glob-style <a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a>
+<td>a glob-style
+<a class="link" href="glib-Glob-style-pattern-matching.html" title="Glob-style pattern matching">pattern</a>
 </td>
 </tr></tbody>
 </table></div>
@@ -1096,8 +1484,8 @@ Assert that the stderr output of the last forked test does not match
 <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.
+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 2.16</p>
 </div>
@@ -1118,8 +1506,11 @@ 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 <td>a random number from the seeded random number generator.</td>
@@ -1136,8 +1527,11 @@ effective for all test cases.
 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>begin</code></em> :</span></p></td>
@@ -1163,8 +1557,11 @@ see <a class="link" href="glib-Testing.html#g-test-rand-int" title="g_test_rand_
 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 <td>a random number from the seeded random number generator.</td>
@@ -1181,8 +1578,11 @@ see <a class="link" href="glib-Testing.html#g-test-rand-int" title="g_test_rand_
 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>range_start</code></em> :</span></p></td>
@@ -1205,19 +1605,22 @@ see <a class="link" href="glib-Testing.html#g-test-rand-int" title="g_test_rand_
 <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.
+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
-<span class="type">G_DISABLE_ASSERT</span> when compiling the application.
+<code class="envar">G_DISABLE_ASSERT</code> when compiling the application.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>expr</code></em> :</span></p></td>
-<td>the expression to check.</td>
+<td>the expression to check</td>
 </tr></tbody>
 </table></div>
 </div>
@@ -1226,12 +1629,13 @@ The macro can be turned off in final releases of code by defining
 <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.
+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
-<span class="type">G_DISABLE_ASSERT</span> when compiling the application.
+<code class="envar">G_DISABLE_ASSERT</code> when compiling the application.
 </p>
 </div>
 <hr>
@@ -1239,15 +1643,17 @@ The macro can be turned off in final releases of code by defining
 <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 terminate the application with a warning message
-if a string comparison fails.
-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>.
+Debugging macro to terminate the application with a warning
+message if a string comparison fails. 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 (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>
 <p>
-The effect of <code class="literal">g_assert_cmpstr (s1, op, s2)</code> is the same
-as <code class="literal">g_assert (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">
@@ -1260,8 +1666,13 @@ and <em class="parameter"><code>s2</code></em>.
   </table>
 </div>
-<div class="variablelist"><table border="0">
+<p>
+</p>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>s1</code></em> :</span></p></td>
@@ -1269,7 +1680,8 @@ and <em class="parameter"><code>s2</code></em>.
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>cmp</code></em> :</span></p></td>
-<td>The comparison operator to use. One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
+<td>The comparison operator to use.
+One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>s2</code></em> :</span></p></td>
@@ -1284,17 +1696,20 @@ and <em class="parameter"><code>s2</code></em>.
 <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 terminate the application with a warning message
-if an integer comparison fails.
+Debugging macro to terminate the application with a warning
+message if an integer comparison fails.
 </p>
 <p>
-The effect of <code class="literal">g_assert_cmpint (n1, op, n2)</code> is the same
-as <code class="literal">g_assert (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>.
+The effect of <code class="literal">g_assert_cmpint (n1, op, n2)</code> is
+the same as <code class="literal">g_assert (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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>n1</code></em> :</span></p></td>
@@ -1302,7 +1717,8 @@ and <em class="parameter"><code>n2</code></em>.
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>cmp</code></em> :</span></p></td>
-<td>The comparison operator to use. One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
+<td>The comparison operator to use.
+One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>n2</code></em> :</span></p></td>
@@ -1317,17 +1733,20 @@ and <em class="parameter"><code>n2</code></em>.
 <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 terminate the application with a warning message
-if an unsigned integer comparison fails.
+Debugging macro to terminate the application with a warning
+message if an unsigned integer comparison fails.
 </p>
 <p>
-The effect of <code class="literal">g_assert_cmpuint (n1, op, n2)</code> is the same
-as <code class="literal">g_assert (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>.
+The effect of <code class="literal">g_assert_cmpuint (n1, op, n2)</code> is
+the same as <code class="literal">g_assert (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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>n1</code></em> :</span></p></td>
@@ -1335,7 +1754,8 @@ and <em class="parameter"><code>n2</code></em>.
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>cmp</code></em> :</span></p></td>
-<td>The comparison operator to use. One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
+<td>The comparison operator to use.
+One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>n2</code></em> :</span></p></td>
@@ -1350,13 +1770,18 @@ and <em class="parameter"><code>n2</code></em>.
 <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 terminate the application with a warning message
-if an unsigned integer comparison fails. 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.
+Debugging macro to terminate the application with a warning
+message if an unsigned integer comparison fails.
 </p>
-<div class="variablelist"><table border="0">
+<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="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>n1</code></em> :</span></p></td>
@@ -1364,7 +1789,8 @@ in the message.
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>cmp</code></em> :</span></p></td>
-<td>The comparison operator to use. One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
+<td>The comparison operator to use.
+One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>n2</code></em> :</span></p></td>
@@ -1379,17 +1805,20 @@ in the message.
 <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 terminate the application with a warning message
-if a floating point number comparison fails.
+Debugging macro to terminate the application with a warning
+message if a floating point number comparison fails.
 </p>
 <p>
-The effect of <code class="literal">g_assert_cmpfloat (n1, op, n2)</code> is the same
-as <code class="literal">g_assert (n1 op n2)</code>. The advantage of this function
-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>.
+The effect of <code class="literal">g_assert_cmpfloat (n1, op, n2)</code> is
+the same as <code class="literal">g_assert (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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>n1</code></em> :</span></p></td>
@@ -1397,7 +1826,8 @@ and <em class="parameter"><code>n2</code></em>.
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>cmp</code></em> :</span></p></td>
-<td>The comparison operator to use. One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
+<td>The comparison operator to use.
+One of ==, !=, &lt;, &gt;, &lt;=, &gt;=.</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>n2</code></em> :</span></p></td>
@@ -1412,16 +1842,20 @@ and <em class="parameter"><code>n2</code></em>.
 <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 terminate the application with a warning message
-if a method has returned a <a class="link" href="glib-Error-Reporting.html#GError" title="struct GError"><span class="type">GError</span></a>.
+Debugging macro to terminate the application with a warning
+message if a method has returned a <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_no_error (err)</code> is the same
-as <code class="literal">g_assert (err == NULL)</code>. The advantage of this macro
-is that it can produce a message that includes the error message and code.
+The effect of <code class="literal">g_assert_no_error (err)</code> is
+the same as <code class="literal">g_assert (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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>err</code></em> :</span></p></td>
 <td>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>
@@ -1435,22 +1869,26 @@ is that it can produce a message that includes the error message and code.
 <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 terminate the application with a warning message
-if a method has not returned the correct <a class="link" href="glib-Error-Reporting.html#GError" title="struct GError"><span class="type">GError</span></a>.
+Debugging macro to terminate the application with a warning
+message if a method has not 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 (err != NULL &amp;&amp; err-&gt;domain == dom &amp;&amp; err-&gt;code == c)</code>.
-The advantage of this macro is that it can produce a message that
-includes the incorrect error message and code.
+The effect of <code class="literal">g_assert_error (err, dom, c)</code> is
+the same as <code class="literal">g_assert (err != NULL &amp;&amp; err-&gt;domain
+== dom &amp;&amp; err-&gt;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 (err != NULL)</code>
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>err</code></em> :</span></p></td>
@@ -1506,8 +1944,11 @@ the test case.
 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>fixture</code></em> :</span></p></td>
@@ -1519,6 +1960,7 @@ zero then <em class="parameter"><code>fixture</code></em> will be equal to <em c
 </tr>
 </tbody>
 </table></div>
+<p class="since">Since 2.28</p>
 </div>
 <hr>
 <div class="refsect2">
@@ -1533,10 +1975,10 @@ zero then <em class="parameter"><code>fixture</code></em> will be equal to <em c
 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 allocated and filled with 0s. Then <code class="function">data_setup()</code> is called
+will be allocated and filled with 0s. Then <em class="parameter"><code>data_setup</code></em> is called
 to initialize the fixture. After fixture setup, the actual test
-function <code class="function">data_test()</code> is called. Once the test run completed, the
-fixture structure is torn down  by calling <code class="function">data_teardown()</code> and
+function <em class="parameter"><code>data_test</code></em> is called. Once the test run completed, the
+fixture structure is torn down  by calling <em class="parameter"><code>data_teardown</code></em> and
 after that the memory is released.
 </p>
 <p>
@@ -1546,8 +1988,11 @@ multiple tests. In this cases, <a class="link" href="glib-Testing.html#g-test-cr
 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="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>test_name</code></em> :</span></p></td>
@@ -1588,8 +2033,11 @@ called with the same fixture, but varying <em class="parameter"><code>test_name<
 <p>
 Create a new test suite with the name <em class="parameter"><code>suite_name</code></em>.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>suite_name</code></em> :</span></p></td>
@@ -1610,8 +2058,11 @@ Create a new test suite with the name <em class="parameter"><code>suite_name</co
 <p>
 Get the toplevel test suite for the test path API.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 <td>the toplevel <a class="link" href="glib-Testing.html#GTestSuite" title="GTestSuite"><span class="type">GTestSuite</span></a>
@@ -1628,8 +2079,11 @@ Get the toplevel test suite for the test path API.
 <p>
 Adds <em class="parameter"><code>test_case</code></em> to <em class="parameter"><code>suite</code></em>.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>suite</code></em> :</span></p></td>
@@ -1653,8 +2107,11 @@ Adds <em class="parameter"><code>test_case</code></em> to <em class="parameter">
 <p>
 Adds <em class="parameter"><code>nestedsuite</code></em> to <em class="parameter"><code>suite</code></em>.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>suite</code></em> :</span></p></td>
@@ -1682,8 +2139,11 @@ as parsed by <a class="link" href="glib-Testing.html#g-test-init" title="g_test_
 <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>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>suite</code></em> :</span></p></td>
@@ -1701,14 +2161,12 @@ in a program.
 </div>
 <div class="refsect1">
 <a name="glib-Testing.see-also"></a><h2>See Also</h2>
-<p>
 <a href="gtester.html">gtester</a>,
-<a href="gtester-report.html">gtester-report</a>
-</p>
+           <a href="gtester-report.html">gtester-report</a>
 </div>
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.17</div>
+          Generated by GTK-Doc V1.18</div>
 </body>
 </html>