luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-03-03 06:32:10 +01:00
Code Issues Packages Projects Releases Wiki Activity

tests: port from g_test_trap_subprocess() to g_test_trap_fork()

Browse Source 
https://bugzilla.gnome.org/show_bug.cgi?id=679683
This commit is contained in:
Dan Winship 2012-11-24 15:58:36 -05:00
parent 467f9ea1bc
commit e3d1869ee3
20 changed files with 1243 additions and 893 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
gio/tests/gdbus-exit-on-close.c
View File

@ -108,79 +108,85 @@ close_async_cb (GObject *source G_GNUC_UNUSED,
}
}
static void
test_exit_on_close_subprocess (gconstpointer test_data)
{
const TestData *td = test_data;
GDBusConnection *c;
loop = g_main_loop_new (NULL, FALSE);
session_bus_up ();
c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
g_assert (c != NULL);
/* the default is meant to be TRUE */
if (td->exit_on_close != IMPLICITLY_TRUE)
g_dbus_connection_set_exit_on_close (c, td->exit_on_close);
g_assert_cmpint (g_dbus_connection_get_exit_on_close (c), ==,
(td->exit_on_close != EXPLICITLY_FALSE));
g_assert (!g_dbus_connection_is_closed (c));
g_timeout_add (50, quit_later_cb, NULL);
g_main_loop_run (loop);
g_signal_connect (c, "closed", G_CALLBACK (closed_cb), (gpointer) td);
if (td->who_closes == LOCAL)
{
GVariant *v;
GError *error = NULL;
v = g_dbus_connection_call_sync (c, "org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"ListNames",
NULL,
G_VARIANT_TYPE ("(as)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
g_assert_no_error (error);
g_assert (v != NULL);
g_variant_unref (v);
g_dbus_connection_close (c, NULL, close_async_cb, NULL);
}
else
{
session_bus_stop ();
}
g_main_loop_run (loop);
/* this is only reached when we turn off exit-on-close */
g_main_loop_unref (loop);
g_object_unref (c);
session_bus_down ();
exit (0);
}
static void
test_exit_on_close (gconstpointer test_data)
{
const TestData *td = test_data;
GTestTrapFlags silence;
/* all the tests rely on a shared main loop */
loop = g_main_loop_new (NULL, FALSE);
GTestSubprocessFlags flags;
char *child_name;
g_test_dbus_unset ();
if (g_test_verbose ())
silence = 0;
flags = G_TEST_SUBPROCESS_INHERIT_STDOUT | G_TEST_SUBPROCESS_INHERIT_STDERR;
else
silence = G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR;
flags = 0;
if (g_test_trap_fork (0, silence))
{
GDBusConnection *c;
session_bus_up ();
c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
g_assert (c != NULL);
/* the default is meant to be TRUE */
if (td->exit_on_close != IMPLICITLY_TRUE)
g_dbus_connection_set_exit_on_close (c, td->exit_on_close);
g_assert_cmpint (g_dbus_connection_get_exit_on_close (c), ==,
(td->exit_on_close != EXPLICITLY_FALSE));
g_assert (!g_dbus_connection_is_closed (c));
g_timeout_add (50, quit_later_cb, NULL);
g_main_loop_run (loop);
g_signal_connect (c, "closed", G_CALLBACK (closed_cb), (gpointer) td);
if (td->who_closes == LOCAL)
{
GVariant *v;
GError *error = NULL;
v = g_dbus_connection_call_sync (c, "org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"ListNames",
NULL,
G_VARIANT_TYPE ("(as)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
g_assert_no_error (error);
g_assert (v != NULL);
g_variant_unref (v);
g_dbus_connection_close (c, NULL, close_async_cb, NULL);
}
else
{
session_bus_stop ();
}
g_main_loop_run (loop);
/* this is only reached when we turn off exit-on-close */
g_main_loop_unref (loop);
g_object_unref (c);
session_bus_down ();
exit (0);
}
child_name = g_strdup_printf ("/gdbus/exit-on-close/%s/subprocess", td->name);
g_test_trap_subprocess (child_name, 0, flags);
g_free (child_name);
if (td->exit_on_close == EXPLICITLY_FALSE ||
td->who_closes == LOCAL)
@ -207,10 +213,15 @@ main (int argc,
for (i = 0; cases[i].name != NULL; i++)
{
gchar *name = g_strdup_printf ("/gdbus/exit-on-close/%s", cases[i].name);
gchar *name;
name = g_strdup_printf ("/gdbus/exit-on-close/%s", cases[i].name);
g_test_add_data_func (name, &cases[i], test_exit_on_close);
g_free (name);
name = g_strdup_printf ("/gdbus/exit-on-close/%s/subprocess", cases[i].name);
g_test_add_data_func (name, &cases[i], test_exit_on_close_subprocess);
g_free (name);
}
return g_test_run();

1
gio/tests/gdbus-non-socket.c
View File

@ -219,6 +219,7 @@ test_non_socket (void)
break;
}
/* This is #ifdef G_OS_UNIX anyway, so just use g_test_trap_fork() */
if (!g_test_trap_fork (0, 0))
{
/* parent */

20
gio/tests/gdbus-proxy.c
View File

@ -620,12 +620,10 @@ test_expected_interface (GDBusProxy *proxy)
if (g_test_undefined ())
{
/* Also check that we complain if setting a cached property of the wrong type */
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
{
g_dbus_proxy_set_cached_property (proxy, "y", g_variant_new_string ("error_me_out!"));
}
g_test_trap_assert_stderr ("*Trying to set property y of type s but according to the expected interface the type is y*");
g_test_trap_assert_failed();
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*Trying to set property y of type s but according to the expected interface the type is y*");
g_dbus_proxy_set_cached_property (proxy, "y", g_variant_new_string ("error_me_out!"));
g_test_assert_expected_messages ();
}
/* this should work, however (since the type is correct) */
@ -636,12 +634,10 @@ test_expected_interface (GDBusProxy *proxy)
/* Try to get the value of a property where the type we expect is different from
* what we have in our cache (e.g. what the service returned)
*/
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
{
value = g_dbus_proxy_get_cached_property (proxy, "i");
}
g_test_trap_assert_stderr ("*Trying to get property i with type i but according to the expected interface the type is u*");
g_test_trap_assert_failed();
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*Trying to get property i with type i but according to the expected interface the type is u*");
value = g_dbus_proxy_get_cached_property (proxy, "i");
g_test_assert_expected_messages ();
}
/* Even if a property does not exist in expected_interface, looking it

50
gio/tests/gschema-compile.c
View File

@ -11,28 +11,36 @@ typedef struct {
const gchar *err;
} SchemaTest;
static void
test_schema_do_compile (gpointer data)
{
SchemaTest *test = (SchemaTest *) data;
gchar *filename = g_strconcat (test->name, ".gschema.xml", NULL);
gchar *path = g_build_filename (SRCDIR, "schema-tests", filename, NULL);
gchar *argv[] = {
"../glib-compile-schemas",
"--strict",
"--dry-run",
"--schema-file", path,
(gchar *)test->opt,
NULL
};
gchar *envp[] = { NULL };
execve (argv[0], argv, envp);
g_assert_not_reached ();
}
static void
test_schema (gpointer data)
{
SchemaTest *test = (SchemaTest *) data;
gchar *child_name;
child_name = g_strdup_printf ("/gschema/%s%s/subprocess/do_compile", test->name, test->opt ? "/opt" : "");
g_test_trap_subprocess (child_name, 0, 0);
g_free (child_name);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
gchar *filename = g_strconcat (test->name, ".gschema.xml", NULL);
gchar *path = g_build_filename (SRCDIR, "schema-tests", filename, NULL);
gchar *argv[] = {
"../glib-compile-schemas",
"--strict",
"--dry-run",
"--schema-file", path,
(gchar *)test->opt,
NULL
};
gchar *envp[] = { NULL };
execve (argv[0], argv, envp);
g_free (filename);
g_free (path);
}
if (test->err)
{
g_test_trap_assert_failed ();
@ -135,9 +143,15 @@ main (int argc, char *argv[])
for (i = 0; i < G_N_ELEMENTS (tests); ++i)
{
gchar *name = g_strdup_printf ("/gschema/%s%s", tests[i].name, tests[i].opt ? "/opt" : "");
gchar *name;
name = g_strdup_printf ("/gschema/%s%s", tests[i].name, tests[i].opt ? "/opt" : "");
g_test_add_data_func (name, &tests[i], (gpointer) test_schema);
g_free (name);
name = g_strdup_printf ("/gschema/%s%s/subprocess/do_compile", tests[i].name, tests[i].opt ? "/opt" : "");
g_test_add_data_func (name, &tests[i], (gpointer) test_schema_do_compile);
g_free (name);
}
return g_test_run ();

418
gio/tests/gsettings.c
View File

@ -82,24 +82,27 @@ test_basic (void)
/* Check that we get an error when getting a key
* that is not in the schema
*/
static void
test_unknown_key_subprocess (void)
{
GSettings *settings;
GVariant *value;
settings = g_settings_new ("org.gtk.test");
value = g_settings_get_value (settings, "no_such_key");
g_assert (value == NULL);
g_object_unref (settings);
}
static void
test_unknown_key (void)
{
if (!g_test_undefined ())
return;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
GSettings *settings;
GVariant *value;
settings = g_settings_new ("org.gtk.test");
value = g_settings_get_value (settings, "no_such_key");
g_assert (value == NULL);
g_object_unref (settings);
}
g_test_trap_subprocess ("/gsettings/unknown-key/subprocess", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*does not contain*");
}
@ -107,21 +110,23 @@ test_unknown_key (void)
/* Check that we get an error when the schema
* has not been installed
*/
static void
test_no_schema_subprocess (void)
{
GSettings *settings;
settings = g_settings_new ("no.such.schema");
g_assert (settings == NULL);
}
static void
test_no_schema (void)
{
if (!g_test_undefined ())
return;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
GSettings *settings;
settings = g_settings_new ("no.such.schema");
g_assert (settings == NULL);
}
g_test_trap_subprocess ("/gsettings/no-schema/subprocess", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*Settings schema 'no.such.schema' is not installed*");
}
@ -158,36 +163,40 @@ test_wrong_type (void)
}
/* Check errors with explicit paths */
static void
test_wrong_path_subprocess (void)
{
GSettings *settings G_GNUC_UNUSED;
settings = g_settings_new_with_path ("org.gtk.test", "/wrong-path/");
}
static void
test_wrong_path (void)
{
if (!g_test_undefined ())
return;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
GSettings *settings G_GNUC_UNUSED;
settings = g_settings_new_with_path ("org.gtk.test", "/wrong-path/");
}
g_test_trap_subprocess ("/gsettings/wrong-path/subprocess", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*but path * specified by schema*");
}
static void
test_no_path_subprocess (void)
{
GSettings *settings G_GNUC_UNUSED;
settings = g_settings_new ("org.gtk.test.no-path");
}
static void
test_no_path (void)
{
if (!g_test_undefined ())
return;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
GSettings *settings G_GNUC_UNUSED;
settings = g_settings_new ("org.gtk.test.no-path");
}
g_test_trap_subprocess ("/gsettings/no-path/subprocess", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*attempting to create schema * without a path**");
}
@ -1298,25 +1307,28 @@ test_directional_binding (void)
/* Test that type mismatch is caught when creating a binding
*/
static void
test_typesafe_binding_subprocess (void)
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "int", G_SETTINGS_BIND_DEFAULT);
g_object_unref (obj);
g_object_unref (settings);
}
static void
test_typesafe_binding (void)
{
if (!g_test_undefined ())
return;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "int", G_SETTINGS_BIND_DEFAULT);
g_object_unref (obj);
g_object_unref (settings);
}
g_test_trap_subprocess ("/gsettings/typesafe-binding/subprocess", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*not compatible*");
}
@ -1424,74 +1436,86 @@ test_no_change_binding (void)
/* Test that binding a non-readable property only
* works in 'GET' mode.
*/
static void
test_no_read_binding_fail (void)
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "no-read", 0);
}
static void
test_no_read_binding_pass (void)
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "no-read", G_SETTINGS_BIND_GET);
exit (0);
}
static void
test_no_read_binding (void)
{
if (g_test_undefined ())
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "no-read", 0);
}
g_test_trap_subprocess ("/gsettings/no-read-binding/subprocess/fail", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*property*is not readable*");
}
if (g_test_trap_fork (0, 0))
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "no-read", G_SETTINGS_BIND_GET);
exit (0);
}
g_test_trap_subprocess ("/gsettings/no-read-binding/subprocess/pass", 0, 0);
g_test_trap_assert_passed ();
}
/* Test that binding a non-writable property only
* works in 'SET' mode.
*/
static void
test_no_write_binding_fail (void)
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "no-write", 0);
}
static void
test_no_write_binding_pass (void)
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "no-write", G_SETTINGS_BIND_SET);
exit (0);
}
static void
test_no_write_binding (void)
{
if (g_test_undefined ())
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "no-write", 0);
}
g_test_trap_subprocess ("/gsettings/no-write-binding/subprocess/fail", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*property*is not writable*");
}
if (g_test_trap_fork (0, 0))
{
TestObject *obj;
GSettings *settings;
settings = g_settings_new ("org.gtk.test.binding");
obj = test_object_new ();
g_settings_bind (settings, "string", obj, "no-write", G_SETTINGS_BIND_SET);
exit (0);
}
g_test_trap_subprocess ("/gsettings/no-write-binding/subprocess/pass", 0, 0);
g_test_trap_assert_passed ();
}
@ -1630,6 +1654,46 @@ test_strinfo (void)
g_assert (!strinfo_is_string_valid (strinfo, length, "quux"));
}
static void
test_enums_non_enum_key (void)
{
GSettings *direct;
direct = g_settings_new ("org.gtk.test.enums.direct");
g_settings_get_enum (direct, "test");
g_assert_not_reached ();
}
static void
test_enums_non_enum_value (void)
{
GSettings *settings;
settings = g_settings_new ("org.gtk.test.enums");
g_settings_set_enum (settings, "test", 42);
g_assert_not_reached ();
}
static void
test_enums_range (void)
{
GSettings *settings;
settings = g_settings_new ("org.gtk.test.enums");
g_settings_set_string (settings, "test", "qux");
g_assert_not_reached ();
}
static void
test_enums_non_flags (void)
{
GSettings *settings;
settings = g_settings_new ("org.gtk.test.enums");
g_settings_get_flags (settings, "test");
g_assert_not_reached ();
}
static void
test_enums (void)
{
@ -1641,23 +1705,19 @@ test_enums (void)
if (g_test_undefined () && !backend_set)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_get_enum (direct, "test");
g_test_trap_subprocess ("/gsettings/enums/subprocess/non-enum-key", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*not associated with an enum*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_set_enum (settings, "test", 42);
g_test_trap_subprocess ("/gsettings/enums/subprocess/non-enum-value", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*invalid enum value 42*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_set_string (settings, "test", "qux");
g_test_trap_subprocess ("/gsettings/enums/subprocess/range", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*g_settings_set_value*valid range*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_get_flags (settings, "test");
g_test_trap_subprocess ("/gsettings/enums/subprocess/non-flags", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*not associated with a flags*");
}
@ -1687,6 +1747,47 @@ test_enums (void)
g_assert_cmpint (g_settings_get_enum (settings, "test"), ==, TEST_ENUM_QUUX);
}
static void
test_flags_non_flags_key (void)
{
GSettings *direct;
direct = g_settings_new ("org.gtk.test.enums.direct");
g_settings_get_flags (direct, "test");
g_assert_not_reached ();
}
static void
test_flags_non_flags_value (void)
{
GSettings *settings;
settings = g_settings_new ("org.gtk.test.enums");
g_settings_set_flags (settings, "f-test", 0x42);
g_assert_not_reached ();
}
static void
test_flags_range (void)
{
GSettings *settings;
settings = g_settings_new ("org.gtk.test.enums");
g_settings_set_strv (settings, "f-test",
(const gchar **) g_strsplit ("rock", ",", 0));
g_assert_not_reached ();
}
static void
test_flags_non_enum (void)
{
GSettings *settings;
settings = g_settings_new ("org.gtk.test.enums");
g_settings_get_enum (settings, "f-test");
g_assert_not_reached ();
}
static void
test_flags (void)
{
@ -1699,24 +1800,19 @@ test_flags (void)
if (g_test_undefined () && !backend_set)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_get_flags (direct, "test");
g_test_trap_subprocess ("/gsettings/flags/subprocess/non-flags-key", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*not associated with a flags*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_set_flags (settings, "f-test", 0x42);
g_test_trap_subprocess ("/gsettings/flags/subprocess/non-flags-value", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*invalid flags value 0x00000042*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_set_strv (settings, "f-test",
(const gchar **) g_strsplit ("rock", ",", 0));
g_test_trap_subprocess ("/gsettings/flags/subprocess/range", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*g_settings_set_value*valid range*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_get_enum (settings, "f-test");
g_test_trap_subprocess ("/gsettings/flags/subprocess/non-enum", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*not associated with an enum*");
}
@ -1759,6 +1855,26 @@ test_flags (void)
TEST_FLAGS_TALKING | TEST_FLAGS_LAUGHING);
}
static void
test_range_high (void)
{
GSettings *settings;
settings = g_settings_new ("org.gtk.test.range");
g_settings_set_int (settings, "val", 45);
g_assert_not_reached ();
}
static void
test_range_low (void)
{
GSettings *settings;
settings = g_settings_new ("org.gtk.test.range");
g_settings_set_int (settings, "val", 1);
g_assert_not_reached ();
}
static void
test_range (void)
{
@ -1770,13 +1886,11 @@ test_range (void)
if (g_test_undefined () && !backend_set)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_set_int (settings, "val", 45);
g_test_trap_subprocess ("/gsettings/range/subprocess/high", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*g_settings_set_value*valid range*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_settings_set_int (settings, "val", 1);
g_test_trap_subprocess ("/gsettings/range/subprocess/low", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*g_settings_set_value*valid range*");
}
@ -2133,48 +2247,55 @@ main (int argc, char *argv[])
setlocale (LC_ALL, "");
backend_set = g_getenv ("GSETTINGS_BACKEND") != NULL;
g_setenv ("XDG_DATA_DIRS", ".", TRUE);
g_setenv ("GSETTINGS_SCHEMA_DIR", ".", TRUE);
if (!backend_set)
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
g_test_init (&argc, &argv, NULL);
g_remove ("org.gtk.test.enums.xml");
g_assert (g_spawn_command_line_sync ("../../gobject/glib-mkenums "
"--template " SRCDIR "/enums.xml.template "
SRCDIR "/testenum.h",
&enums, NULL, &result, NULL));
g_assert (result == 0);
g_assert (g_file_set_contents ("org.gtk.test.enums.xml", enums, -1, NULL));
g_free (enums);
if (!g_test_subprocess ())
{
backend_set = g_getenv ("GSETTINGS_BACKEND") != NULL;
g_remove ("gschemas.compiled");
g_assert (g_spawn_command_line_sync ("../glib-compile-schemas --targetdir=. "
"--schema-file=org.gtk.test.enums.xml "
"--schema-file=" SRCDIR "/org.gtk.test.gschema.xml",
NULL, NULL, &result, NULL));
g_assert (result == 0);
g_setenv ("XDG_DATA_DIRS", ".", TRUE);
g_setenv ("GSETTINGS_SCHEMA_DIR", ".", TRUE);
g_remove ("schema-source/gschemas.compiled");
g_mkdir ("schema-source", 0777);
g_assert (g_spawn_command_line_sync ("../glib-compile-schemas --targetdir=schema-source "
"--schema-file=" SRCDIR "/org.gtk.schemasourcecheck.gschema.xml",
NULL, NULL, &result, NULL));
g_assert (result == 0);
if (!backend_set)
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
g_remove ("org.gtk.test.enums.xml");
g_assert (g_spawn_command_line_sync ("../../gobject/glib-mkenums "
"--template " SRCDIR "/enums.xml.template "
SRCDIR "/testenum.h",
&enums, NULL, &result, NULL));
g_assert (result == 0);
g_assert (g_file_set_contents ("org.gtk.test.enums.xml", enums, -1, NULL));
g_free (enums);
g_remove ("gschemas.compiled");
g_assert (g_spawn_command_line_sync ("../glib-compile-schemas --targetdir=. "
"--schema-file=org.gtk.test.enums.xml "
"--schema-file=" SRCDIR "/org.gtk.test.gschema.xml",
NULL, NULL, &result, NULL));
g_assert (result == 0);
g_remove ("schema-source/gschemas.compiled");
g_mkdir ("schema-source", 0777);
g_assert (g_spawn_command_line_sync ("../glib-compile-schemas --targetdir=schema-source "
"--schema-file=" SRCDIR "/org.gtk.schemasourcecheck.gschema.xml",
NULL, NULL, &result, NULL));
g_assert (result == 0);
}
g_test_add_func ("/gsettings/basic", test_basic);
if (!backend_set)
{
g_test_add_func ("/gsettings/no-schema", test_no_schema);
g_test_add_func ("/gsettings/no-schema/subprocess", test_no_schema_subprocess);
g_test_add_func ("/gsettings/unknown-key", test_unknown_key);
g_test_add_func ("/gsettings/unknown-key/subprocess", test_unknown_key_subprocess);
g_test_add_func ("/gsettings/wrong-type", test_wrong_type);
g_test_add_func ("/gsettings/wrong-path", test_wrong_path);
g_test_add_func ("/gsettings/wrong-path/subprocess", test_wrong_path_subprocess);
g_test_add_func ("/gsettings/no-path", test_no_path);
g_test_add_func ("/gsettings/no-path/subprocess", test_no_path_subprocess);
}
g_test_add_func ("/gsettings/basic-types", test_basic_types);
@ -2201,16 +2322,31 @@ main (int argc, char *argv[])
if (!backend_set)
{
g_test_add_func ("/gsettings/typesafe-binding", test_typesafe_binding);
g_test_add_func ("/gsettings/typesafe-binding/subprocess", test_typesafe_binding_subprocess);
g_test_add_func ("/gsettings/no-read-binding", test_no_read_binding);
g_test_add_func ("/gsettings/no-read-binding/subprocess/fail", test_no_read_binding_fail);
g_test_add_func ("/gsettings/no-read-binding/subprocess/pass", test_no_read_binding_pass);
g_test_add_func ("/gsettings/no-write-binding", test_no_write_binding);
g_test_add_func ("/gsettings/no-write-binding/subprocess/fail", test_no_write_binding_fail);
g_test_add_func ("/gsettings/no-write-binding/subprocess/pass", test_no_write_binding_pass);
}
g_test_add_func ("/gsettings/keyfile", test_keyfile);
g_test_add_func ("/gsettings/child-schema", test_child_schema);
g_test_add_func ("/gsettings/strinfo", test_strinfo);
g_test_add_func ("/gsettings/enums", test_enums);
g_test_add_func ("/gsettings/enums/subprocess/non-enum-key", test_enums_non_enum_key);
g_test_add_func ("/gsettings/enums/subprocess/non-enum-value", test_enums_non_enum_value);
g_test_add_func ("/gsettings/enums/subprocess/range", test_enums_range);
g_test_add_func ("/gsettings/enums/subprocess/non-flags", test_enums_non_flags);
g_test_add_func ("/gsettings/flags", test_flags);
g_test_add_func ("/gsettings/flags/subprocess/non-flags-key", test_flags_non_flags_key);
g_test_add_func ("/gsettings/flags/subprocess/non-flags-value", test_flags_non_flags_value);
g_test_add_func ("/gsettings/flags/subprocess/range", test_flags_range);
g_test_add_func ("/gsettings/flags/subprocess/non-enum", test_flags_non_enum);
g_test_add_func ("/gsettings/range", test_range);
g_test_add_func ("/gsettings/range/subprocess/high", test_range_high);
g_test_add_func ("/gsettings/range/subprocess/low", test_range_low);
g_test_add_func ("/gsettings/list-items", test_list_items);
g_test_add_func ("/gsettings/list-schemas", test_list_schemas);
g_test_add_func ("/gsettings/mapped", test_get_mapped);

27
glib/tests/array-test.c
View File

@ -216,23 +216,25 @@ static GMemVTable array_large_size_mem_vtable = {
};
static void
array_large_size (void)
array_large_size_subprocess (void)
{
GArray* array;
g_test_bug ("568760");
GArray *array;
array = g_array_new (FALSE, FALSE, sizeof (char));
if (g_test_trap_fork (5 /* s */ * 1000 /* ms */ * 1000 /* µs */, 0))
{
g_mem_set_vtable (&array_large_size_mem_vtable);
g_array_set_size (array, 1073750016);
g_assert_not_reached ();
}
g_test_trap_assert_passed ();
g_mem_set_vtable (&array_large_size_mem_vtable);
g_array_set_size (array, 1073750016);
g_assert_not_reached ();
}
g_array_free (array, TRUE);
static void
array_large_size (void)
{
g_test_bug ("568760");
g_test_trap_subprocess ("/array/large-size/subprocess",
5 /* s */ * 1000 /* ms */ * 1000 /* µs */, 0);
g_test_trap_assert_passed ();
}
static int
@ -851,6 +853,7 @@ main (int argc, char *argv[])
g_test_add_func ("/array/remove-range", array_remove_range);
g_test_add_func ("/array/ref-count", array_ref_count);
g_test_add_func ("/array/large-size", array_large_size);
g_test_add_func ("/array/large-size/subprocess", array_large_size_subprocess);
g_test_add_func ("/array/sort", array_sort);
g_test_add_func ("/array/sort-with-data", array_sort_with_data);
g_test_add_func ("/array/clear-func", array_clear_func);

22
glib/tests/dataset.c
View File

@ -182,18 +182,21 @@ free_one (gpointer data)
g_datalist_clear (&list);
}
static void
test_datalist_clear_subprocess (void)
{
g_datalist_init (&list);
g_datalist_set_data_full (&list, "one", GINT_TO_POINTER (1), free_one);
g_datalist_set_data_full (&list, "two", GINT_TO_POINTER (2), NULL);
g_datalist_clear (&list);
g_assert (list == NULL);
}
static void
test_datalist_clear (void)
{
if (g_test_trap_fork (500000, 0))
{
g_datalist_init (&list);
g_datalist_set_data_full (&list, "one", GINT_TO_POINTER (1), free_one);
g_datalist_set_data_full (&list, "two", GINT_TO_POINTER (2), NULL);
g_datalist_clear (&list);
g_assert (list == NULL);
exit (0);
}
/* Need to use a subprocess because it will deadlock if it fails */
g_test_trap_subprocess ("/datalist/recursive-clear/subprocess", 500000, 0);
g_test_trap_assert_passed ();
}
@ -210,6 +213,7 @@ main (int argc, char *argv[])
g_test_add_func ("/dataset/foreach", test_dataset_foreach);
g_test_add_func ("/dataset/destroy", test_dataset_destroy);
g_test_add_func ("/datalist/recursive-clear", test_datalist_clear);
g_test_add_func ("/datalist/recursive-clear/subprocess", test_datalist_clear_subprocess);
return g_test_run ();
}

79
glib/tests/gvariant.c
View File

@ -2809,24 +2809,12 @@ test_format_strings (void)
}
static void
exit_on_abort (int signal)
do_failed_test (const char *test,
const gchar *pattern)
{
exit (signal);
}
static gboolean
do_failed_test (const gchar *pattern)
{
if (g_test_trap_fork (1000000, G_TEST_TRAP_SILENCE_STDERR))
{
signal (SIGABRT, exit_on_abort);
return TRUE;
}
g_test_trap_subprocess (test, 1000000, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr (pattern);
return FALSE;
}
static void
@ -2874,6 +2862,14 @@ check_and_free (GVariant *value,
g_free (valstr);
}
static void
test_varargs_empty_array (void)
{
g_variant_new ("(a{s*})", NULL);
g_assert_not_reached ();
}
static void
test_varargs (void)
{
@ -3406,8 +3402,8 @@ test_varargs (void)
g_variant_unref (value);
g_free (str);
if (do_failed_test ("*which type of empty array*"))
g_variant_new ("(a{s*})", NULL);
do_failed_test ("/gvariant/varargs/subprocess/empty-array",
"*which type of empty array*");
}
g_variant_type_info_assert_no_infos ();
@ -3868,6 +3864,30 @@ test_parse_failures (void)
}
}
static void
test_parse_bad_format_char (void)
{
g_variant_new_parsed ("%z");
g_assert_not_reached ();
}
static void
test_parse_bad_format_string (void)
{
g_variant_new_parsed ("uint32 %i", 2);
g_assert_not_reached ();
}
static void
test_parse_bad_args (void)
{
g_variant_new_parsed ("%@i", g_variant_new_uint32 (2));
g_assert_not_reached ();
}
static void
test_parse_positional (void)
{
@ -3883,23 +3903,14 @@ test_parse_positional (void)
if (g_test_undefined ())
{
if (do_failed_test ("*GVariant format string*"))
{
g_variant_new_parsed ("%z");
abort ();
}
do_failed_test ("/gvariant/parse/subprocess/bad-format-char",
"*GVariant format string*");
if (do_failed_test ("*can not parse as*"))
{
g_variant_new_parsed ("uint32 %i", 2);
abort ();
}
do_failed_test ("/gvariant/parse/subprocess/bad-format-string",
"*can not parse as*");
if (do_failed_test ("*expected GVariant of type `i'*"))
{
g_variant_new_parsed ("%@i", g_variant_new_uint32 (2));
abort ();
}
do_failed_test ("/gvariant/parse/subprocess/bad-args",
"*expected GVariant of type `i'*");
}
}
@ -4326,6 +4337,7 @@ main (int argc, char **argv)
g_test_add_func ("/gvariant/format-strings", test_format_strings);
g_test_add_func ("/gvariant/invalid-varargs", test_invalid_varargs);
g_test_add_func ("/gvariant/varargs", test_varargs);
g_test_add_func ("/gvariant/varargs/subprocess/empty-array", test_varargs_empty_array);
g_test_add_func ("/gvariant/valist", test_valist);
g_test_add_func ("/gvariant/builder-memory", test_builder_memory);
g_test_add_func ("/gvariant/hashing", test_hashing);
@ -4333,6 +4345,9 @@ main (int argc, char **argv)
g_test_add_func ("/gvariant/parser", test_parses);
g_test_add_func ("/gvariant/parse-failures", test_parse_failures);
g_test_add_func ("/gvariant/parse-positional", test_parse_positional);
g_test_add_func ("/gvariant/parse/subprocess/bad-format-char", test_parse_bad_format_char);
g_test_add_func ("/gvariant/parse/subprocess/bad-format-string", test_parse_bad_format_string);
g_test_add_func ("/gvariant/parse/subprocess/bad-args", test_parse_bad_args);
g_test_add_func ("/gvariant/floating", test_floating);
g_test_add_func ("/gvariant/bytestring", test_bytestring);
g_test_add_func ("/gvariant/lookup-value", test_lookup_value);

39
glib/tests/list.c
View File

@ -489,27 +489,29 @@ test_position (void)
g_list_free (ll);
}
static void
test_double_free_subprocess (void)
{
GList *list, *link;
GList intruder = { NULL, (gpointer)0xDEADBEEF, (gpointer)0xDEADBEEF };
list = NULL;
list = g_list_append (list, "a");
link = list = g_list_append (list, "b");
list = g_list_append (list, "c");
list = g_list_remove_link (list, link);
link->prev = list;
link->next = &intruder;
list = g_list_remove_link (list, link);
g_list_free (list);
}
static void
test_double_free (void)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
GList *list, *link;
GList intruder = { NULL, (gpointer)0xDEADBEEF, (gpointer)0xDEADBEEF };
list = NULL;
list = g_list_append (list, "a");
link = list = g_list_append (list, "b");
list = g_list_append (list, "c");
list = g_list_remove_link (list, link);
link->prev = list;
link->next = &intruder;
list = g_list_remove_link (list, link);
g_list_free (list);
exit (0);
}
g_test_trap_subprocess ("/list/double-free/subprocess", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*corrupted double-linked list detected*");
}
@ -543,6 +545,7 @@ main (int argc, char *argv[])
g_test_add_func ("/list/prepend", test_prepend);
g_test_add_func ("/list/position", test_position);
g_test_add_func ("/list/double-free", test_double_free);
g_test_add_func ("/list/double-free/subprocess", test_double_free_subprocess);
return g_test_run ();
}

213
glib/tests/logging.c
View File

@ -5,19 +5,15 @@
static void
test_warnings (void)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_warn_if_reached ();
}
g_test_trap_assert_failed();
g_test_trap_assert_stderr ("*WARNING*test_warnings*should not be reached*");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*test_warnings*should not be reached*");
g_warn_if_reached ();
g_test_assert_expected_messages ();
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_warn_if_fail (FALSE);
}
g_test_trap_assert_failed();
g_test_trap_assert_stderr ("*WARNING*test_warnings*runtime check failed*");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*test_warnings*runtime check failed*");
g_warn_if_fail (FALSE);
g_test_assert_expected_messages ();
}
static guint log_count = 0;
@ -44,122 +40,155 @@ test_set_handler (void)
id = g_log_set_handler ("bu", G_LOG_LEVEL_INFO, log_handler, NULL);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
g_log ("bu", G_LOG_LEVEL_DEBUG, "message");
g_log ("ba", G_LOG_LEVEL_DEBUG, "message");
g_log ("bu", G_LOG_LEVEL_INFO, "message");
g_log ("ba", G_LOG_LEVEL_INFO, "message");
g_log ("bu", G_LOG_LEVEL_DEBUG, "message");
g_log ("ba", G_LOG_LEVEL_DEBUG, "message");
g_log ("bu", G_LOG_LEVEL_INFO, "message");
g_log ("ba", G_LOG_LEVEL_INFO, "message");
g_assert_cmpint (log_count, ==, 1);
exit (0);
}
g_test_trap_assert_passed ();
g_assert_cmpint (log_count, ==, 1);
g_log_remove_handler ("bu", id);
}
static void
test_default_handler_error (void)
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_error ("message1");
exit (0);
}
static void
test_default_handler_critical (void)
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_critical ("message2");
exit (0);
}
static void
test_default_handler_warning (void)
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_warning ("message3");
exit (0);
}
static void
test_default_handler_message (void)
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_message ("message4");
exit (0);
}
static void
test_default_handler_info (void)
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "message5");
exit (0);
}
static void
test_default_handler_bar_info (void)
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_setenv ("G_MESSAGES_DEBUG", "foo bar baz", TRUE);
g_log ("bar", G_LOG_LEVEL_INFO, "message5");
exit (0);
}
static void
test_default_handler_baz_debug (void)
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_setenv ("G_MESSAGES_DEBUG", "foo bar baz", TRUE);
g_log ("baz", G_LOG_LEVEL_DEBUG, "message6");
exit (0);
}
static void
test_default_handler_debug (void)
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
g_log ("foo", G_LOG_LEVEL_DEBUG, "6");
g_log ("bar", G_LOG_LEVEL_DEBUG, "6");
g_log ("baz", G_LOG_LEVEL_DEBUG, "6");
exit (0);
}
static void
test_default_handler_0x400 (void)
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_log (G_LOG_DOMAIN, 1<<10, "message7");
exit (0);
}
static void
test_default_handler (void)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_error ("message1");
exit (0);
}
g_test_trap_subprocess ("/logging/default-handler/subprocess/error", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*ERROR*message1*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_critical ("message2");
exit (0);
}
g_test_trap_subprocess ("/logging/default-handler/subprocess/critical", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*CRITICAL*message2*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_warning ("message3");
exit (0);
}
g_test_trap_subprocess ("/logging/default-handler/subprocess/warning", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*WARNING*message3*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_message ("message4");
exit (0);
}
g_test_trap_subprocess ("/logging/default-handler/subprocess/message", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stderr ("*Message*message4*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "message5");
exit (0);
}
g_test_trap_subprocess ("/logging/default-handler/subprocess/info", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stdout_unmatched ("*INFO*message5*");
g_setenv ("G_MESSAGES_DEBUG", "foo bar baz", TRUE);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_log ("bar", G_LOG_LEVEL_INFO, "message5");
exit (0);
}
g_test_trap_subprocess ("/logging/default-handler/subprocess/bar-info", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*INFO*message5*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_log ("baz", G_LOG_LEVEL_DEBUG, "message6");
exit (0);
}
g_test_trap_subprocess ("/logging/default-handler/subprocess/baz-debug", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*DEBUG*message6*");
g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_log ("foo", G_LOG_LEVEL_DEBUG, "6");
g_log ("bar", G_LOG_LEVEL_DEBUG, "6");
g_log ("baz", G_LOG_LEVEL_DEBUG, "6");
exit (0);
}
g_test_trap_subprocess ("/logging/default-handler/subprocess/debug", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*DEBUG*6*6*6*");
g_unsetenv ("G_MESSAGES_DEBUG");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
g_log_set_default_handler (g_log_default_handler, NULL);
g_log (G_LOG_DOMAIN, 1<<10, "message7");
exit (0);
}
g_test_trap_subprocess ("/logging/default-handler/subprocess/0x400", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*LOG-0x400*message7*");
}
/* test that setting levels as fatal works */
static void
test_fatal_log_mask_subprocess (void)
{
g_log_set_fatal_mask ("bu", G_LOG_LEVEL_INFO);
g_log ("bu", G_LOG_LEVEL_INFO, "fatal");
exit (0);
}
static void
test_fatal_log_mask (void)
{
GLogLevelFlags flags;
flags = g_log_set_fatal_mask ("bu", G_LOG_LEVEL_INFO);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
g_log ("bu", G_LOG_LEVEL_INFO, "fatal");
g_test_trap_subprocess ("/logging/fatal-log-mask/subprocess", 0, 0);
g_test_trap_assert_failed ();
g_log_set_fatal_mask ("bu", flags);
/* G_LOG_LEVEL_INFO isn't printed by default */
g_test_trap_assert_stdout_unmatched ("*fatal*");
}
static gint my_print_count = 0;
@ -264,8 +293,18 @@ main (int argc, char *argv[])
g_test_bug_base ("http://bugzilla.gnome.org/");
g_test_add_func ("/logging/default-handler", test_default_handler);
g_test_add_func ("/logging/default-handler/subprocess/error", test_default_handler_error);
g_test_add_func ("/logging/default-handler/subprocess/critical", test_default_handler_critical);
g_test_add_func ("/logging/default-handler/subprocess/warning", test_default_handler_warning);
g_test_add_func ("/logging/default-handler/subprocess/message", test_default_handler_message);
g_test_add_func ("/logging/default-handler/subprocess/info", test_default_handler_info);
g_test_add_func ("/logging/default-handler/subprocess/bar-info", test_default_handler_bar_info);
g_test_add_func ("/logging/default-handler/subprocess/baz-debug", test_default_handler_baz_debug);
g_test_add_func ("/logging/default-handler/subprocess/debug", test_default_handler_debug);
g_test_add_func ("/logging/default-handler/subprocess/0x400", test_default_handler_0x400);
g_test_add_func ("/logging/warnings", test_warnings);
g_test_add_func ("/logging/fatal-log-mask", test_fatal_log_mask);
g_test_add_func ("/logging/fatal-log-mask/subprocess", test_fatal_log_mask_subprocess);
g_test_add_func ("/logging/set-handler", test_set_handler);
g_test_add_func ("/logging/print-handler", test_print_handler);
g_test_add_func ("/logging/printerr-handler", test_printerr_handler);

143
glib/tests/mem-overflow.c
View File

@ -26,13 +26,48 @@
#include "glib.h"
#include <stdlib.h>
static gsize a = G_MAXSIZE / 10 + 10;
static gsize b = 10;
typedef char X[10];
#define MEM_OVERFLOW_TEST(name, code) \
static void \
mem_overflow_ ## name (void) \
{ \
gpointer p; \
code; \
g_free (p); \
exit (0); \
}
MEM_OVERFLOW_TEST (malloc_n_a_a, p = g_malloc_n (a, a))
MEM_OVERFLOW_TEST (malloc_n_a_b, p = g_malloc_n (a, b))
MEM_OVERFLOW_TEST (malloc_n_b_a, p = g_malloc_n (b, a))
MEM_OVERFLOW_TEST (malloc_n_b_b, p = g_malloc_n (b, b))
MEM_OVERFLOW_TEST (malloc0_n_a_a, p = g_malloc0_n (a, a))
MEM_OVERFLOW_TEST (malloc0_n_a_b, p = g_malloc0_n (a, b))
MEM_OVERFLOW_TEST (malloc0_n_b_a, p = g_malloc0_n (b, a))
MEM_OVERFLOW_TEST (malloc0_n_b_b, p = g_malloc0_n (b, b))
MEM_OVERFLOW_TEST (realloc_n_a_a, p = g_malloc (1); p = g_realloc_n (p, a, a))
MEM_OVERFLOW_TEST (realloc_n_a_b, p = g_malloc (1); p = g_realloc_n (p, a, b))
MEM_OVERFLOW_TEST (realloc_n_b_a, p = g_malloc (1); p = g_realloc_n (p, b, a))
MEM_OVERFLOW_TEST (realloc_n_b_b, p = g_malloc (1); p = g_realloc_n (p, b, b))
MEM_OVERFLOW_TEST (new_a, p = g_new (X, a))
MEM_OVERFLOW_TEST (new_b, p = g_new (X, b))
MEM_OVERFLOW_TEST (new0_a, p = g_new0 (X, a))
MEM_OVERFLOW_TEST (new0_b, p = g_new0 (X, b))
MEM_OVERFLOW_TEST (renew_a, p = g_malloc (1); p = g_renew (X, p, a))
MEM_OVERFLOW_TEST (renew_b, p = g_malloc (1); p = g_renew (X, p, b))
static void
mem_overflow (void)
{
gsize a = G_MAXSIZE / 10 + 10;
gsize b = 10;
gpointer p, q;
typedef char X[10];
/* "FAIL" here apparently means "fail to overflow"... */
#define CHECK_PASS(P) p = (P); g_assert (p == NULL);
@ -70,66 +105,61 @@ mem_overflow (void)
CHECK_FAIL (g_try_renew (X, q, b));
free (p);
#undef CHECK_FAIL
#undef CHECK_PASS
#define CHECK_FAIL(P) do { \
#define CHECK_SUBPROCESS_FAIL(name) do { \
if (g_test_undefined ()) \
{ \
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR)) \
{ \
p = (P); \
exit (0); \
} \
\
g_test_trap_subprocess ("/mem/overflow/subprocess/" #name, 0, 0); \
g_test_trap_assert_failed(); \
} \
} while (0)
#define CHECK_PASS(P) do { \
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR)) \
#define CHECK_SUBPROCESS_PASS(name) do { \
if (g_test_undefined ()) \
{ \
p = (P); \
g_free (p); \
exit (0); \
g_test_trap_subprocess ("/mem/overflow/subprocess/" #name, 0, 0); \
g_test_trap_assert_passed(); \
} \
\
g_test_trap_assert_passed(); \
} while (0)
CHECK_FAIL (g_malloc_n (a, a));
CHECK_FAIL (g_malloc_n (a, b));
CHECK_FAIL (g_malloc_n (b, a));
CHECK_PASS (g_malloc_n (b, b));
CHECK_SUBPROCESS_FAIL (malloc_n_a_a);
CHECK_SUBPROCESS_FAIL (malloc_n_a_b);
CHECK_SUBPROCESS_FAIL (malloc_n_b_a);
CHECK_SUBPROCESS_PASS (malloc_n_b_b);
CHECK_FAIL (g_malloc0_n (a, a));
CHECK_FAIL (g_malloc0_n (a, b));
CHECK_FAIL (g_malloc0_n (b, a));
CHECK_PASS (g_malloc0_n (b, b));
CHECK_SUBPROCESS_FAIL (malloc0_n_a_a);
CHECK_SUBPROCESS_FAIL (malloc0_n_a_b);
CHECK_SUBPROCESS_FAIL (malloc0_n_b_a);
CHECK_SUBPROCESS_PASS (malloc0_n_b_b);
q = g_malloc (1);
CHECK_FAIL (g_realloc_n (q, a, a));
CHECK_FAIL (g_realloc_n (q, a, b));
CHECK_FAIL (g_realloc_n (q, b, a));
CHECK_PASS (g_realloc_n (q, b, b));
g_free (q);
CHECK_SUBPROCESS_FAIL (realloc_n_a_a);
CHECK_SUBPROCESS_FAIL (realloc_n_a_b);
CHECK_SUBPROCESS_FAIL (realloc_n_b_a);
CHECK_SUBPROCESS_PASS (realloc_n_b_b);
CHECK_FAIL (g_new (X, a));
CHECK_PASS (g_new (X, b));
CHECK_SUBPROCESS_FAIL (new_a);
CHECK_SUBPROCESS_PASS (new_b);
CHECK_FAIL (g_new0 (X, a));
CHECK_PASS (g_new0 (X, b));
CHECK_SUBPROCESS_FAIL (new0_a);
CHECK_SUBPROCESS_PASS (new0_b);
q = g_malloc (1);
CHECK_FAIL (g_renew (X, q, a));
CHECK_PASS (g_renew (X, q, b));
g_free (q);
CHECK_SUBPROCESS_FAIL (renew_a);
CHECK_SUBPROCESS_PASS (renew_b);
}
typedef struct
{
} Empty;
static void
empty_alloc_subprocess (void)
{
Empty *empty;
empty = g_new0 (Empty, 1);
g_assert (empty == NULL);
exit (0);
}
static void
empty_alloc (void)
{
@ -137,14 +167,7 @@ empty_alloc (void)
g_assert_cmpint (sizeof (Empty), ==, 0);
if (g_test_trap_fork (0, 0))
{
Empty *empty;
empty = g_new0 (Empty, 1);
g_assert (empty == NULL);
exit (0);
}
g_test_trap_subprocess ("/mem/empty-alloc/subprocess", 0, 0);
g_test_trap_assert_passed ();
}
@ -157,7 +180,27 @@ main (int argc,
g_test_bug_base ("http://bugzilla.gnome.org/");
g_test_add_func ("/mem/overflow", mem_overflow);
g_test_add_func ("/mem/overflow/subprocess/malloc_n_a_a", mem_overflow_malloc_n_a_a);
g_test_add_func ("/mem/overflow/subprocess/malloc_n_a_b", mem_overflow_malloc_n_a_b);
g_test_add_func ("/mem/overflow/subprocess/malloc_n_b_a", mem_overflow_malloc_n_b_a);
g_test_add_func ("/mem/overflow/subprocess/malloc_n_b_b", mem_overflow_malloc_n_b_b);
g_test_add_func ("/mem/overflow/subprocess/malloc0_n_a_a", mem_overflow_malloc0_n_a_a);
g_test_add_func ("/mem/overflow/subprocess/malloc0_n_a_b", mem_overflow_malloc0_n_a_b);
g_test_add_func ("/mem/overflow/subprocess/malloc0_n_b_a", mem_overflow_malloc0_n_b_a);
g_test_add_func ("/mem/overflow/subprocess/malloc0_n_b_b", mem_overflow_malloc0_n_b_b);
g_test_add_func ("/mem/overflow/subprocess/realloc_n_a_a", mem_overflow_realloc_n_a_a);
g_test_add_func ("/mem/overflow/subprocess/realloc_n_a_b", mem_overflow_realloc_n_a_b);
g_test_add_func ("/mem/overflow/subprocess/realloc_n_b_a", mem_overflow_realloc_n_b_a);
g_test_add_func ("/mem/overflow/subprocess/realloc_n_b_b", mem_overflow_realloc_n_b_b);
g_test_add_func ("/mem/overflow/subprocess/new_a", mem_overflow_new_a);
g_test_add_func ("/mem/overflow/subprocess/new_b", mem_overflow_new_b);
g_test_add_func ("/mem/overflow/subprocess/new0_a", mem_overflow_new0_a);
g_test_add_func ("/mem/overflow/subprocess/new0_b", mem_overflow_new0_b);
g_test_add_func ("/mem/overflow/subprocess/renew_a", mem_overflow_renew_a);
g_test_add_func ("/mem/overflow/subprocess/renew_b", mem_overflow_renew_b);
g_test_add_func ("/mem/empty-alloc", empty_alloc);
g_test_add_func ("/mem/empty-alloc/subprocess", empty_alloc_subprocess);
return g_test_run();
}

364
glib/tests/option-context.c
View File

@ -27,25 +27,92 @@
#include <string.h>
#include <locale.h>
static GOptionEntry main_entries[] = {
{ "main-switch", 0, 0,
G_OPTION_ARG_NONE, NULL,
"A switch that is in the main group", NULL },
{ NULL }
};
static GOptionEntry group_entries[] = {
{ "test-switch", 0, 0,
G_OPTION_ARG_NONE, NULL,
"A switch that is in the test group", NULL },
{ NULL }
};
static GOptionContext *
make_options (int test_number)
{
GOptionContext *options;
GOptionGroup *group = NULL;
gboolean have_main_entries = (0 != (test_number & 1));
gboolean have_test_entries = (0 != (test_number & 2));
options = g_option_context_new (NULL);
if (have_main_entries)
g_option_context_add_main_entries (options, main_entries, NULL);
if (have_test_entries)
{
group = g_option_group_new ("test", "Test Options",
"Show all test options",
NULL, NULL);
g_option_context_add_group (options, group);
g_option_group_add_entries (group, group_entries);
}
return options;
}
static void
print_help (GOptionContext *options, gchar **argv)
{
gint argc = 3;
GError *error = NULL;
g_setenv ("LANG", "C", TRUE);
g_option_context_parse (options, &argc, &argv, &error);
g_option_context_free (options);
exit(0);
}
static void
test_group_captions_help (gconstpointer test_number)
{
GOptionContext *options;
gchar *argv[] = { __FILE__, "--help", NULL };
options = make_options (GPOINTER_TO_INT (test_number));
print_help (options, argv);
}
static void
test_group_captions_help_all (gconstpointer test_number)
{
GOptionContext *options;
gchar *argv[] = { __FILE__, "--help-all", NULL };
options = make_options (GPOINTER_TO_INT (test_number));
print_help (options, argv);
}
static void
test_group_captions_help_test (gconstpointer test_number)
{
GOptionContext *options;
gchar *argv[] = { __FILE__, "--help-test", NULL };
options = make_options (GPOINTER_TO_INT (test_number));
print_help (options, argv);
}
static void
test_group_captions (void)
{
gchar *help_variants[] = { "--help", "--help-all", "--help-test" };
GOptionEntry main_entries[] = {
{ "main-switch", 0, 0,
G_OPTION_ARG_NONE, NULL,
"A switch that is in the main group", NULL },
{ NULL }
};
GOptionEntry group_entries[] = {
{ "test-switch", 0, 0,
G_OPTION_ARG_NONE, NULL,
"A switch that is in the test group", NULL },
{ NULL }
};
const gchar *test_name_base[] = { "help", "help-all", "help-test" };
gchar *test_name;
gint i, j;
g_test_bug ("504142");
@ -55,115 +122,76 @@ test_group_captions (void)
gboolean have_main_entries = (0 != (i & 1));
gboolean have_test_entries = (0 != (i & 2));
GOptionContext *options;
GOptionGroup *group = NULL;
options = g_option_context_new (NULL);
if (have_main_entries)
g_option_context_add_main_entries (options, main_entries, NULL);
if (have_test_entries)
for (j = 0; j < G_N_ELEMENTS (test_name_base); ++j)
{
group = g_option_group_new ("test", "Test Options",
"Show all test options",
NULL, NULL);
g_option_context_add_group (options, group);
g_option_group_add_entries (group, group_entries);
}
GTestSubprocessFlags trap_flags = 0;
gboolean expect_main_description = FALSE;
gboolean expect_main_switch = FALSE;
gboolean expect_test_description = FALSE;
gboolean expect_test_switch = FALSE;
gboolean expect_test_group = FALSE;
for (j = 0; j < G_N_ELEMENTS (help_variants); ++j)
{
GTestTrapFlags trap_flags = 0;
gchar *args[3];
if (g_test_verbose ())
trap_flags |= G_TEST_SUBPROCESS_INHERIT_STDOUT | G_TEST_SUBPROCESS_INHERIT_STDERR;
args[0] = __FILE__;
args[1] = help_variants[j];
args[2] = NULL;
test_name = g_strdup_printf ("/option/group/captions/subprocess/%s-%d",
test_name_base[j], i);
g_test_trap_subprocess (test_name, 0, trap_flags);
g_free (test_name);
g_test_trap_assert_passed ();
g_test_trap_assert_stderr ("");
if (!g_test_verbose ())
trap_flags |= G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR;
g_test_message ("test setup: args='%s', main-entries=%d, test-entries=%d",
args[1], have_main_entries, have_test_entries);
if (g_test_trap_fork (0, trap_flags))
switch (j)
{
gchar **argv = args;
gint argc = 2;
GError *error = NULL;
case 0:
g_assert_cmpstr ("help", ==, test_name_base[j]);
expect_main_switch = have_main_entries;
expect_test_group = have_test_entries;
break;
g_setenv ("LANG", "C", TRUE);
case 1:
g_assert_cmpstr ("help-all", ==, test_name_base[j]);
expect_main_switch = have_main_entries;
expect_test_switch = have_test_entries;
expect_test_group = have_test_entries;
break;
g_option_context_parse (options, &argc, &argv, &error);
g_option_context_free (options);
exit(0);
case 2:
g_assert_cmpstr ("help-test", ==, test_name_base[j]);
expect_test_switch = have_test_entries;
break;
default:
g_assert_not_reached ();
break;
}
expect_main_description |= expect_main_switch;
expect_test_description |= expect_test_switch;
if (expect_main_description)
g_test_trap_assert_stdout ("*Application Options*");
else
{
gboolean expect_main_description = FALSE;
gboolean expect_main_switch = FALSE;
g_test_trap_assert_stdout_unmatched ("*Application Options*");
if (expect_main_switch)
g_test_trap_assert_stdout ("*--main-switch*");
else
g_test_trap_assert_stdout_unmatched ("*--main-switch*");
gboolean expect_test_description = FALSE;
gboolean expect_test_switch = FALSE;
gboolean expect_test_group = FALSE;
if (expect_test_description)
g_test_trap_assert_stdout ("*Test Options*");
else
g_test_trap_assert_stdout_unmatched ("*Test Options*");
if (expect_test_switch)
g_test_trap_assert_stdout ("*--test-switch*");
else
g_test_trap_assert_stdout_unmatched ("*--test-switch*");
g_test_trap_assert_passed ();
g_test_trap_assert_stderr ("");
switch (j)
{
case 0:
g_assert_cmpstr ("--help", ==, args[1]);
expect_main_switch = have_main_entries;
expect_test_group = have_test_entries;
break;
case 1:
g_assert_cmpstr ("--help-all", ==, args[1]);
expect_main_switch = have_main_entries;
expect_test_switch = have_test_entries;
expect_test_group = have_test_entries;
break;
case 2:
g_assert_cmpstr ("--help-test", ==, args[1]);
expect_test_switch = have_test_entries;
break;
default:
g_assert_not_reached ();
break;
}
expect_main_description |= expect_main_switch;
expect_test_description |= expect_test_switch;
if (expect_main_description)
g_test_trap_assert_stdout ("*Application Options*");
else
g_test_trap_assert_stdout_unmatched ("*Application Options*");
if (expect_main_switch)
g_test_trap_assert_stdout ("*--main-switch*");
else
g_test_trap_assert_stdout_unmatched ("*--main-switch*");
if (expect_test_description)
g_test_trap_assert_stdout ("*Test Options*");
else
g_test_trap_assert_stdout_unmatched ("*Test Options*");
if (expect_test_switch)
g_test_trap_assert_stdout ("*--test-switch*");
else
g_test_trap_assert_stdout_unmatched ("*--test-switch*");
if (expect_test_group)
g_test_trap_assert_stdout ("*--help-test*");
else
g_test_trap_assert_stdout_unmatched ("*--help-test*");
}
if (expect_test_group)
g_test_trap_assert_stdout ("*--help-test*");
else
g_test_trap_assert_stdout_unmatched ("*--help-test*");
}
g_option_context_free (options);
}
}
@ -2216,74 +2244,74 @@ test_group_parse (void)
static void
flag_reverse_string (void)
{
GOptionContext *context;
gchar *arg = NULL;
GOptionEntry entries [] =
{ { "test", 't', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_STRING, &arg, NULL, NULL },
{ NULL } };
gchar **argv;
gint argc;
gboolean retval;
GError *error = NULL;
if (!g_test_undefined ())
return;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
GOptionContext *context;
gchar *arg = NULL;
GOptionEntry entries [] =
{ { "test", 't', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_STRING, &arg, NULL, NULL },
{ NULL } };
gchar **argv;
gint argc;
gboolean retval;
GError *error = NULL;
context = g_option_context_new (NULL);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*ignoring reverse flag*");
g_option_context_add_main_entries (context, entries, NULL);
g_test_assert_expected_messages ();
argv = split_string ("program --test bla", &argc);
argv = split_string ("program --test bla", &argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == FALSE);
g_clear_error (&error);
g_strfreev (argv);
g_option_context_free (context);
exit (0);
}
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*ignoring reverse flag*");
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == TRUE);
g_assert_no_error (error);
g_strfreev (argv);
g_option_context_free (context);
}
static void
flag_optional_int (void)
{
GOptionContext *context;
gint arg = 0;
GOptionEntry entries [] =
{ { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_INT, &arg, NULL, NULL },
{ NULL } };
gchar **argv;
gint argc;
gboolean retval;
GError *error = NULL;
if (!g_test_undefined ())
return;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
GOptionContext *context;
gint arg = 0;
GOptionEntry entries [] =
{ { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_INT, &arg, NULL, NULL },
{ NULL } };
gchar **argv;
gint argc;
gboolean retval;
GError *error = NULL;
context = g_option_context_new (NULL);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*ignoring no-arg, optional-arg or filename flags*");
g_option_context_add_main_entries (context, entries, NULL);
g_test_assert_expected_messages ();
argv = split_string ("program --test 5", &argc);
argv = split_string ("program --test 5", &argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == FALSE);
g_clear_error (&error);
g_strfreev (argv);
g_option_context_free (context);
exit (0);
}
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*ignoring no-arg, optional-arg or filename flags*");
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == TRUE);
g_assert_no_error (error);
g_strfreev (argv);
g_option_context_free (context);
}
int
main (int argc,
char *argv[])
{
int i;
gchar *test_name;
g_test_init (&argc, &argv, NULL);
g_test_bug_base ("http://bugzilla.gnome.org/");
@ -2292,7 +2320,25 @@ main (int argc,
g_test_add_func ("/option/help/no-help-options", test_help_no_help_options);
g_test_add_func ("/option/basic", test_basic);
g_test_add_func ("/option/group/captions", test_group_captions);
for (i = 0; i < 4; i++)
{
test_name = g_strdup_printf ("/option/group/captions/subprocess/help-%d", i);
g_test_add_data_func (test_name, GINT_TO_POINTER (i),
test_group_captions_help);
g_free (test_name);
test_name = g_strdup_printf ("/option/group/captions/subprocess/help-all-%d", i);
g_test_add_data_func (test_name, GINT_TO_POINTER (i),
test_group_captions_help_all);
g_free (test_name);
test_name = g_strdup_printf ("/option/group/captions/subprocess/help-test-%d", i);
g_test_add_data_func (test_name, GINT_TO_POINTER (i),
test_group_captions_help_test);
g_free (test_name);
}
g_test_add_func ("/option/group/main", test_main_group);
g_test_add_func ("/option/group/error-hook", test_error_hook);
g_test_add_func ("/option/group/parse", test_group_parse);

21
glib/tests/scannerapi.c
View File

@ -58,18 +58,22 @@ test_scanner_warn (ScannerFixture *fix,
g_scanner_warn (fix->scanner, "test");
}
static void
test_scanner_error_subprocess (ScannerFixture *fix,
gconstpointer test_data)
{
int pe = fix->scanner->parse_errors;
g_scanner_error (fix->scanner, "scanner-error-message-test");
g_assert_cmpint (fix->scanner->parse_errors, ==, pe + 1);
exit (0);
}
static void
test_scanner_error (ScannerFixture *fix,
gconstpointer test_data)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
{
int pe = fix->scanner->parse_errors;
g_scanner_error (fix->scanner, "scanner-error-message-test");
g_assert_cmpint (fix->scanner->parse_errors, ==, pe + 1);
exit (0);
}
g_test_trap_assert_passed();
g_test_trap_subprocess ("/scanner/error/subprocess", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stderr ("*scanner-error-message-test*");
}
@ -135,6 +139,7 @@ main (int argc,
g_test_add ("/scanner/warn", ScannerFixture, 0, scanner_fixture_setup, test_scanner_warn, scanner_fixture_teardown);
g_test_add ("/scanner/error", ScannerFixture, 0, scanner_fixture_setup, test_scanner_error, scanner_fixture_teardown);
g_test_add ("/scanner/error/subprocess", ScannerFixture, 0, scanner_fixture_setup, test_scanner_error_subprocess, scanner_fixture_teardown);
g_test_add ("/scanner/symbols", ScannerFixture, 0, scanner_fixture_setup, test_scanner_symbols, scanner_fixture_teardown);
g_test_add ("/scanner/tokens", ScannerFixture, 0, scanner_fixture_setup, test_scanner_tokens, scanner_fixture_teardown);

14
glib/tests/slice.c
View File

@ -3,15 +3,16 @@
/* We test deprecated functionality here */
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
static void
test_slice_config_subprocess (void)
{
g_slice_set_config (G_SLICE_CONFIG_ALWAYS_MALLOC, TRUE);
}
static void
test_slice_config (void)
{
if (!g_test_undefined ())
return;
if (g_test_trap_fork (1000000, G_TEST_TRAP_SILENCE_STDERR))
g_slice_set_config (G_SLICE_CONFIG_ALWAYS_MALLOC, TRUE);
g_test_trap_subprocess ("/slice/config/subprocess", 1000000, 0);
g_test_trap_assert_failed ();
}
@ -29,6 +30,7 @@ main (int argc, char **argv)
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/slice/config", test_slice_config);
g_test_add_func ("/slice/config/subprocess", test_slice_config_subprocess);
return g_test_run ();
}

245
glib/tests/test-printf.c
View File

@ -609,36 +609,26 @@ test_positional_params (void)
}
static void
test_positional_params2 (void)
test_positional_params2_subprocess (void)
{
gint res;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%2$c %1$c", 'b', 'a');
g_assert_cmpint (res, ==, 3);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*a b*");
res = g_printf ("%2$c %1$c\n", 'b', 'a');
g_assert_cmpint (res, ==, 4);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%1$*2$.*3$s", "abc", 5, 2);
g_assert_cmpint (res, ==, 5);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("* ab*");
res = g_printf ("%1$*2$.*3$s\n", "abc", 5, 2);
g_assert_cmpint (res, ==, 6);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%1$s%1$s", "abc");
g_assert_cmpint (res, ==, 6);
exit (0);
}
res = g_printf ("%1$s%1$s\n", "abc");
g_assert_cmpint (res, ==, 7);
}
static void
test_positional_params2 (void)
{
g_test_trap_subprocess ("/printf/test-positional-params/subprocess", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*abcabc*");
g_test_trap_assert_stdout ("a b\n ab\nabcabc\n");
}
static void
@ -661,16 +651,18 @@ test_positional_params3 (void)
}
static void
test_percent2 (void)
test_percent2_subprocess (void)
{
gint res;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%%");
g_assert_cmpint (res, ==, 1);
exit (0);
}
res = g_printf ("%%");
g_assert_cmpint (res, ==, 1);
}
static void
test_percent2 (void)
{
g_test_trap_subprocess ("/printf/test-percent/subprocess", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*%*");
}
@ -770,83 +762,41 @@ _Pragma ("GCC diagnostic pop")
}
static void
test_64bit2 (void)
test_64bit2_base (void)
{
gint res;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" G_GINT64_FORMAT, (gint64)123456);
g_assert_cmpint (res, ==, 6);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*123456*");
res = g_printf ("%" G_GINT64_FORMAT "\n", (gint64)123456);
g_assert_cmpint (res, ==, 7);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" G_GINT64_FORMAT, (gint64)-123456);
g_assert_cmpint (res, ==, 7);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*-123456*");
res = g_printf ("%" G_GINT64_FORMAT "\n", (gint64)-123456);
g_assert_cmpint (res, ==, 8);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" G_GUINT64_FORMAT, (guint64)123456);
g_assert_cmpint (res, ==, 6);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*123456*");
res = g_printf ("%" G_GUINT64_FORMAT "\n", (guint64)123456);
g_assert_cmpint (res, ==, 7);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" G_GINT64_MODIFIER "o", (gint64)123456);
g_assert_cmpint (res, ==, 6);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*361100*");
res = g_printf ("%" G_GINT64_MODIFIER "o\n", (gint64)123456);
g_assert_cmpint (res, ==, 7);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%#" G_GINT64_MODIFIER "o", (gint64)123456);
g_assert_cmpint (res, ==, 7);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*0361100*");
res = g_printf ("%#" G_GINT64_MODIFIER "o\n", (gint64)123456);
g_assert_cmpint (res, ==, 8);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" G_GINT64_MODIFIER "x", (gint64)123456);
g_assert_cmpint (res, ==, 5);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*1e240*");
res = g_printf ("%" G_GINT64_MODIFIER "x\n", (gint64)123456);
g_assert_cmpint (res, ==, 6);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%#" G_GINT64_MODIFIER "x", (gint64)123456);
g_assert_cmpint (res, ==, 7);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*0x1e240*");
res = g_printf ("%#" G_GINT64_MODIFIER "x\n", (gint64)123456);
g_assert_cmpint (res, ==, 8);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" G_GINT64_MODIFIER "X", (gint64)123456);
g_assert_cmpint (res, ==, 5);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*1E240*");
res = g_printf ("%" G_GINT64_MODIFIER "X\n", (gint64)123456);
g_assert_cmpint (res, ==, 6);
}
#ifdef G_OS_WIN32
static void
test_64bit2_win32 (void)
{
gint res;
/* On Win32, test that the "ll" modifier also works, for backward
* compatibility. One really should use the G_GINT64_MODIFIER (which
* on Win32 is the "I64" that the (msvcrt) C library's printf uses),
@ -863,82 +813,51 @@ _Pragma ("GCC diagnostic ignored \"-Wformat\"")
_Pragma ("GCC diagnostic ignored \"-Wformat-extra-args\"")
#endif
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" "lli", (gint64)123456);
g_assert_cmpint (res, ==, 6);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*123456*");
res = g_printf ("%" "lli\n", (gint64)123456);
g_assert_cmpint (res, ==, 7);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" "lli", (gint64)-123456);
g_assert_cmpint (res, ==, 7);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*-123456*");
res = g_printf ("%" "lli\n", (gint64)-123456);
g_assert_cmpint (res, ==, 8);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" "llu", (guint64)123456);
g_assert_cmpint (res, ==, 6);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*123456*");
res = g_printf ("%" "llu\n", (guint64)123456);
g_assert_cmpint (res, ==, 7);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" "ll" "o", (gint64)123456);
g_assert_cmpint (res, ==, 6);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*361100*");
res = g_printf ("%" "ll" "o\n", (gint64)123456);
g_assert_cmpint (res, ==, 7);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%#" "ll" "o", (gint64)123456);
g_assert_cmpint (res, ==, 7);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*0361100*");
res = g_printf ("%#" "ll" "o\n", (gint64)123456);
g_assert_cmpint (res, ==, 8);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" "ll" "x", (gint64)123456);
g_assert_cmpint (res, ==, 5);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*1e240*");
res = g_printf ("%" "ll" "x\n", (gint64)123456);
g_assert_cmpint (res, ==, 6);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%#" "ll" "x", (gint64)123456);
g_assert_cmpint (res, ==, 7);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*0x1e240*");
res = g_printf ("%#" "ll" "x\n", (gint64)123456);
g_assert_cmpint (res, ==, 8);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
{
res = g_printf ("%" "ll" "X", (gint64)123456);
g_assert_cmpint (res, ==, 5);
exit (0);
}
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("*1E240*");
res = g_printf ("%" "ll" "X\n", (gint64)123456);
g_assert_cmpint (res, ==, 6);
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
_Pragma ("GCC diagnostic pop")
#endif
}
#endif
static void
test_64bit2 (void)
{
g_test_trap_subprocess ("/printf/test-64bit/subprocess/base", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("123456\n-123456\n123456\n"
"361100\n0361100\n1e240\n"
"0x1e240\n1E240\n");
#ifdef G_OS_WIN32
g_test_trap_subprocess ("/printf/test-64bit/subprocess/win32", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stdout ("123456\n-123456\n123456\n"
"361100\n0361100\n1e240\n"
"0x1e240\n1E240\n");
#endif
}
@ -987,8 +906,14 @@ main (int argc,
g_test_add_func ("/snprintf/test-64bit", test_64bit);
g_test_add_func ("/printf/test-percent", test_percent2);
g_test_add_func ("/printf/test-percent/subprocess", test_percent2_subprocess);
g_test_add_func ("/printf/test-positional-params", test_positional_params2);
g_test_add_func ("/printf/test-positional-params/subprocess", test_positional_params2_subprocess);
g_test_add_func ("/printf/test-64bit", test_64bit2);
g_test_add_func ("/printf/test-64bit/subprocess/base", test_64bit2_base);
#ifdef G_OS_WIN32
g_test_add_func ("/printf/test-64bit/subprocess/win32", test_64bit2_win32);
#endif
g_test_add_func ("/sprintf/test-positional-params", test_positional_params3);
g_test_add_func ("/sprintf/upper-bound", test_upper_bound);

214
glib/tests/testing.c
View File

@ -23,8 +23,23 @@
#include <glib.h>
#include <stdlib.h>
#include <string.h>
/* test assertion variants */
static void
test_assertions_bad_cmpstr (void)
{
g_assert_cmpstr ("fzz", !=, "fzz");
exit (0);
}
static void
test_assertions_bad_cmpint (void)
{
g_assert_cmpint (4, !=, 4);
exit (0);
}
static void
test_assertions (void)
{
@ -46,17 +61,11 @@ test_assertions (void)
g_assert_cmpstr ("fzz", >, "faa");
g_assert_cmpstr ("fzz", ==, "fzz");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_assert_cmpstr ("fzz", !=, "fzz");
}
g_test_trap_subprocess ("/misc/assertions/subprocess/bad_cmpstr", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*assertion failed*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_assert_cmpint (4, !=, 4);
}
g_test_trap_subprocess ("/misc/assertions/subprocess/bad_cmpint", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*assertion failed*");
}
@ -279,108 +288,143 @@ fatal_handler (const gchar *log_domain,
}
static void
test_fatal_log_handler (void)
test_fatal_log_handler_critical_pass (void)
{
g_test_log_set_fatal_handler (fatal_handler, NULL);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_str_has_prefix (NULL, "file://");
g_critical ("Test passing");
exit (0);
}
g_test_trap_assert_passed ();
g_test_log_set_fatal_handler (NULL, NULL);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_error ("Test failing");
g_test_trap_assert_failed ();
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
g_str_has_prefix (NULL, "file://");
g_test_trap_assert_failed ();
g_str_has_prefix (NULL, "file://");
g_critical ("Test passing");
exit (0);
}
static void
expected_messages_helper (void)
test_fatal_log_handler_error_fail (void)
{
g_error ("Test failing");
exit (0);
}
static void
test_fatal_log_handler_critical_fail (void)
{
g_str_has_prefix (NULL, "file://");
g_critical ("Test passing");
exit (0);
}
static void
test_fatal_log_handler (void)
{
g_test_trap_subprocess ("/misc/fatal-log-handler/subprocess/critical-pass", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stderr ("*CRITICAL*g_str_has_prefix*");
g_test_trap_assert_stderr ("*CRITICAL*Test passing*");
g_test_trap_subprocess ("/misc/fatal-log-handler/subprocess/error-fail", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*ERROR*Test failing*");
g_test_trap_subprocess ("/misc/fatal-log-handler/subprocess/critical-fail", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*CRITICAL*g_str_has_prefix*");
g_test_trap_assert_stderr_unmatched ("*CRITICAL*Test passing*");
}
static void
test_expected_messages_warning (void)
{
g_warning ("This is a %d warning", g_random_int ());
g_return_if_reached ();
}
static void
test_expected_messages_expect_warning (void)
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"This is a * warning");
test_expected_messages_warning ();
}
static void
test_expected_messages_wrong_warning (void)
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*should not be *");
test_expected_messages_warning ();
}
static void
test_expected_messages_expected (void)
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"This is a * warning");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*should not be reached");
test_expected_messages_warning ();
g_test_assert_expected_messages ();
exit (0);
}
static void
test_expected_messages_extra_warning (void)
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"This is a * warning");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*should not be reached");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"nope");
test_expected_messages_warning ();
/* If we don't assert, it won't notice the missing message */
exit (0);
}
static void
test_expected_messages_unexpected_extra_warning (void)
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"This is a * warning");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*should not be reached");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"nope");
test_expected_messages_warning ();
g_test_assert_expected_messages ();
exit (0);
}
static void
test_expected_messages (void)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
expected_messages_helper ();
exit (0);
}
g_test_trap_subprocess ("/misc/expected-messages/subprocess/warning", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*This is a * warning*");
g_test_trap_assert_stderr_unmatched ("*should not be reached*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"This is a * warning");
expected_messages_helper ();
exit (0);
}
g_test_trap_subprocess ("/misc/expected-messages/subprocess/expect-warning", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr_unmatched ("*This is a * warning*");
g_test_trap_assert_stderr ("*should not be reached*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*should not be *");
expected_messages_helper ();
exit (0);
}
g_test_trap_subprocess ("/misc/expected-messages/subprocess/wrong-warning", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr_unmatched ("*should not be reached*");
g_test_trap_assert_stderr ("*Did not see expected message CRITICAL*should not be *WARNING*This is a * warning*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"This is a * warning");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*should not be reached");
expected_messages_helper ();
g_test_assert_expected_messages ();
exit (0);
}
g_test_trap_subprocess ("/misc/expected-messages/subprocess/expected", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stderr ("");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"This is a * warning");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*should not be reached");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"nope");
expected_messages_helper ();
/* If we don't assert, it won't notice the missing message */
exit (0);
}
g_test_trap_subprocess ("/misc/expected-messages/subprocess/extra-warning", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stderr ("");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"This is a * warning");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*should not be reached");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"nope");
expected_messages_helper ();
g_test_assert_expected_messages ();
exit (0);
}
g_test_trap_subprocess ("/misc/expected-messages/subprocess/unexpected-extra-warning", 0, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*Did not see expected message CRITICAL*nope*");
}
@ -489,6 +533,8 @@ main (int argc,
g_test_add_func ("/random-generator/rand-2", test_rand2);
g_test_add_func ("/random-generator/random-conversions", test_random_conversions);
g_test_add_func ("/misc/assertions", test_assertions);
g_test_add_func ("/misc/assertions/subprocess/bad_cmpstr", test_assertions_bad_cmpstr);
g_test_add_func ("/misc/assertions/subprocess/bad_cmpint", test_assertions_bad_cmpint);
g_test_add_data_func ("/misc/test-data", (void*) 0xc0c0baba, test_data_test);
g_test_add ("/misc/primetoul", Fixturetest, (void*) 0xc0cac01a, fixturetest_setup, fixturetest_test, fixturetest_teardown);
if (g_test_perf())
@ -514,7 +560,17 @@ main (int argc,
g_test_add_func ("/trap_subprocess/patterns/subprocess", test_subprocess_patterns_child);
g_test_add_func ("/misc/fatal-log-handler", test_fatal_log_handler);
g_test_add_func ("/misc/fatal-log-handler/subprocess/critical-pass", test_fatal_log_handler_critical_pass);
g_test_add_func ("/misc/fatal-log-handler/subprocess/error-fail", test_fatal_log_handler_error_fail);
g_test_add_func ("/misc/fatal-log-handler/subprocess/critical-fail", test_fatal_log_handler_critical_fail);
g_test_add_func ("/misc/expected-messages", test_expected_messages);
g_test_add_func ("/misc/expected-messages/subprocess/warning", test_expected_messages_warning);
g_test_add_func ("/misc/expected-messages/subprocess/expect-warning", test_expected_messages_expect_warning);
g_test_add_func ("/misc/expected-messages/subprocess/wrong-warning", test_expected_messages_wrong_warning);
g_test_add_func ("/misc/expected-messages/subprocess/expected", test_expected_messages_expected);
g_test_add_func ("/misc/expected-messages/subprocess/extra-warning", test_expected_messages_extra_warning);
g_test_add_func ("/misc/expected-messages/subprocess/unexpected-extra-warning", test_expected_messages_unexpected_extra_warning);
g_test_add_func ("/misc/dash-p", test_dash_p);
g_test_add_func ("/misc/dash-p/child", test_dash_p_child);

22
glib/tests/utils.c
View File

@ -260,6 +260,20 @@ test_find_program (void)
g_assert (res == NULL);
}
static void
test_debug_help (void)
{
GDebugKey keys[] = {
{ "key1", 1 },
{ "key2", 2 },
{ "key3", 4 },
};
guint res;
res = g_parse_debug_string ("help", keys, G_N_ELEMENTS (keys));
g_assert_cmpint (res, ==, 0);
}
static void
test_debug (void)
{
@ -294,12 +308,7 @@ test_debug (void)
res = g_parse_debug_string ("all", keys, G_N_ELEMENTS (keys));
g_assert_cmpint (res, ==, 7);
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
res = g_parse_debug_string ("help", keys, G_N_ELEMENTS (keys));
g_assert_cmpint (res, ==, 0);
exit (0);
}
g_test_trap_subprocess ("/utils/debug/subprocess/help", 0, 0);
g_test_trap_assert_passed ();
g_test_trap_assert_stderr ("*Supported debug values: key1 key2 key3 all help*");
}
@ -535,6 +544,7 @@ main (int argc,
g_test_add_func ("/utils/swap", test_swap);
g_test_add_func ("/utils/find-program", test_find_program);
g_test_add_func ("/utils/debug", test_debug);
g_test_add_func ("/utils/debug/subprocess/help", test_debug_help);
g_test_add_func ("/utils/codeset", test_codeset);
g_test_add_func ("/utils/basename", test_basename);
g_test_add_func ("/utils/gettext", test_gettext);

54
gobject/tests/param.c
View File

@ -695,9 +695,18 @@ static void test_implementation_class_init (TestImplementationClass *class)
g_object_class_install_property (class, 1, pspec);
}
typedef struct {
gint change_this_flag;
gint change_this_type;
gint use_this_flag;
gint use_this_type;
} TestParamImplementData;
static void
test_param_implement (void)
test_param_implement_child (gconstpointer user_data)
{
TestParamImplementData *data = (gpointer) user_data;
/* GObject oddity: GObjectClass must be initialised before we can
* initialise a GTypeInterface.
*/
@ -706,6 +715,22 @@ test_param_implement (void)
/* Bring up the interface first. */
g_type_default_interface_ref (test_interface_get_type ());
/* Copy the flags into the global vars so
* test_implementation_class_init() will see them.
*/
change_this_flag = data->change_this_flag;
change_this_type = data->change_this_type;
use_this_flag = data->use_this_flag;
use_this_type = data->use_this_type;
g_type_class_ref (test_implementation_get_type ());
}
static void
test_param_implement (void)
{
gchar *test_path;
for (change_this_flag = 0; change_this_flag < 16; change_this_flag++)
for (change_this_type = 0; change_this_type < 3; change_this_type++)
for (use_this_flag = 0; use_this_flag < 16; use_this_flag++)
@ -721,11 +746,11 @@ test_param_implement (void)
continue;
}
if (g_test_trap_fork (G_TIME_SPAN_SECOND, G_TEST_TRAP_SILENCE_STDERR))
{
g_type_class_ref (test_implementation_get_type ());
exit (0);
}
test_path = g_strdup_printf ("/param/implement/subprocess/%d-%d-%d-%d",
change_this_flag, change_this_type,
use_this_flag, use_this_type);
g_test_trap_subprocess (test_path, G_TIME_SPAN_SECOND, 0);
g_free (test_path);
/* We want to ensure that any flags mismatch problems are reported first. */
switch (valid_impl_flags[change_this_flag][use_this_flag])
@ -804,6 +829,9 @@ test_param_default (void)
int
main (int argc, char *argv[])
{
TestParamImplementData data, *test_data;
gchar *test_path;
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/param/value", test_param_value);
@ -811,7 +839,21 @@ main (int argc, char *argv[])
g_test_add_func ("/param/qdata", test_param_qdata);
g_test_add_func ("/param/validate", test_param_validate);
g_test_add_func ("/param/convert", test_param_convert);
g_test_add_func ("/param/implement", test_param_implement);
for (data.change_this_flag = 0; data.change_this_flag < 16; data.change_this_flag++)
for (data.change_this_type = 0; data.change_this_type < 3; data.change_this_type++)
for (data.use_this_flag = 0; data.use_this_flag < 16; data.use_this_flag++)
for (data.use_this_type = 0; data.use_this_type < 4; data.use_this_type++)
{
test_path = g_strdup_printf ("/param/implement/subprocess/%d-%d-%d-%d",
data.change_this_flag, data.change_this_type,
data.use_this_flag, data.use_this_type);
test_data = g_memdup (&data, sizeof (TestParamImplementData));
g_test_add_data_func_full (test_path, test_data, test_param_implement_child, g_free);
g_free (test_path);
}
g_test_add_func ("/value/transform", test_value_transform);
g_test_add_func ("/param/default", test_param_default);

1
tests/Makefile.am
View File

@ -5,6 +5,7 @@ SUBDIRS=gobject refcount
AM_CPPFLAGS = \
$(gmodule_INCLUDES) \
-DGLIB_DISABLE_DEPRECATION_WARNINGS \
-DG_LOG_DOMAIN=\"GLib\" \
$(GLIB_DEBUG_FLAGS)
AM_CFLAGS = -g

50
tests/testglib.c
View File

@ -552,32 +552,30 @@ test_g_parse_debug_string (void)
static void
log_warning_error_tests (void)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
{
g_message ("this is a g_message test.");
g_message ("non-printable UTF-8: \"\xc3\xa4\xda\x85\"");
g_message ("unsafe chars: \"\x10\x11\x12\n\t\x7f\x81\x82\x83\"");
exit (0);
}
g_test_trap_assert_passed();
g_test_trap_assert_stderr ("*is a g_message test*");
g_test_trap_assert_stderr ("*non-printable UTF-8*");
g_test_trap_assert_stderr ("*unsafe chars*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
{
g_warning ("harmless warning with parameters: %d %s %#x", 42, "Boo", 12345);
exit (0);
}
g_test_trap_assert_failed(); /* we have fatal-warnings enabled */
g_test_trap_assert_stderr ("*harmless warning*");
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
{
g_print (NULL);
exit (0);
}
g_test_trap_assert_failed(); /* we have fatal-warnings enabled */
g_test_trap_assert_stderr ("*g_print*assertion*failed*");
g_test_trap_assert_stderr ("*NULL*");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE,
"*is a g_message test*");
g_message ("this is a g_message test.");
g_test_assert_expected_messages ();
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE,
"*non-printable UTF-8*");
g_message ("non-printable UTF-8: \"\xc3\xa4\xda\x85\"");
g_test_assert_expected_messages ();
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE,
"*unsafe chars*");
g_message ("unsafe chars: \"\x10\x11\x12\n\t\x7f\x81\x82\x83\"");
g_test_assert_expected_messages ();
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*harmless warning*");
g_warning ("harmless warning with parameters: %d %s %#x", 42, "Boo", 12345);
g_test_assert_expected_messages ();
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*g_print*assertion*failed*");
g_print (NULL);
g_test_assert_expected_messages ();
}
static void