diff --git a/gobject/tests/Makefile.am b/gobject/tests/Makefile.am index ed63a82fd..33b3e0b01 100644 --- a/gobject/tests/Makefile.am +++ b/gobject/tests/Makefile.am @@ -5,6 +5,8 @@ INCLUDES = -g -I$(top_srcdir) -I$(top_srcdir)/glib $(GLIB_DEBUG_FLAGS) noinst_PROGRAMS = $(TEST_PROGS) libgobject_LDADD = ../libgobject-2.0.la $(top_builddir)/gthread/libgthread-2.0.la $(top_builddir)/glib/libglib-2.0.la -TEST_PROGS += threadtests +TEST_PROGS += threadtests dynamictests threadtests_SOURCES = threadtests.c threadtests_LDADD = $(libgobject_LDADD) +dynamictests_SOURCES = dynamictests.c +dynamictests_LDADD = $(libgobject_LDADD) diff --git a/gobject/tests/dynamictests.c b/gobject/tests/dynamictests.c new file mode 100644 index 000000000..1f2a5b7bf --- /dev/null +++ b/gobject/tests/dynamictests.c @@ -0,0 +1,235 @@ +/* GLib testing framework examples and tests + * Copyright (C) 2008 Imendio AB + * Authors: Tim Janik + * + * This work is provided "as is"; redistribution and modification + * in whole or in part, in any medium, physical or electronic is + * permitted without restriction. + * + * This work is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * In no event shall the authors or contributors be liable for any + * direct, indirect, incidental, special, exemplary, or consequential + * damages (including, but not limited to, procurement of substitute + * goods or services; loss of use, data, or profits; or business + * interruption) however caused and on any theory of liability, whether + * in contract, strict liability, or tort (including negligence or + * otherwise) arising in any way out of the use of this software, even + * if advised of the possibility of such damage. + */ +#include +#include + +/* This test tests the macros for defining dynamic types. + */ + +static GMutex *sync_mutex = NULL; +static gboolean loaded = FALSE; + +/* MODULE */ +typedef struct _TestModule TestModule; +typedef struct _TestModuleClass TestModuleClass; + +#define TEST_TYPE_MODULE (test_module_get_type ()) +#define TEST_MODULE(module) (G_TYPE_CHECK_INSTANCE_CAST ((module), TEST_TYPE_MODULE, TestModule)) +#define TEST_MODULE_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), TEST_TYPE_MODULE, TestModuleClass)) +#define TEST_IS_MODULE(module) (G_TYPE_CHECK_INSTANCE_TYPE ((module), TEST_TYPE_MODULE)) +#define TEST_IS_MODULE_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), TEST_TYPE_MODULE)) +#define TEST_MODULE_GET_CLASS(module) (G_TYPE_INSTANCE_GET_CLASS ((module), TEST_TYPE_MODULE, TestModuleClass)) +typedef void (*TestModuleRegisterFunc) (GTypeModule *module); + +struct _TestModule +{ + GTypeModule parent_instance; + + TestModuleRegisterFunc register_func; +}; + +struct _TestModuleClass +{ + GTypeModuleClass parent_class; +}; + +static GType test_module_get_type (void); + +static gboolean +test_module_load (GTypeModule *module) +{ + TestModule *test_module = TEST_MODULE (module); + + test_module->register_func (module); + + return TRUE; +} + +static void +test_module_unload (GTypeModule *module) +{ +} + +static void +test_module_class_init (TestModuleClass *class) +{ + GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (class); + + module_class->load = test_module_load; + module_class->unload = test_module_unload; +} + +static GType test_module_get_type (void) +{ + static GType object_type = 0; + + if (!object_type) { + static const GTypeInfo object_info = + { + sizeof (TestModuleClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) test_module_class_init, + (GClassFinalizeFunc) NULL, + NULL, + sizeof (TestModule), + 0, + (GInstanceInitFunc)NULL + }; + object_type = g_type_register_static (G_TYPE_TYPE_MODULE, "TestModule", &object_info, 0); + } + return object_type; +} + + +GTypeModule * +test_module_new (TestModuleRegisterFunc register_func) +{ + TestModule *test_module = g_object_new (TEST_TYPE_MODULE, NULL); + GTypeModule *module = G_TYPE_MODULE (test_module); + + test_module->register_func = register_func; + + /* Register the types initially */ + g_type_module_use (module); + g_type_module_unuse (module); + + return G_TYPE_MODULE (module); +} + + + +#define DYNAMIC_OBJECT_TYPE (dynamic_object_get_type ()) + +typedef GObject DynamicObject; +typedef struct _DynamicObjectClass DynamicObjectClass; + +struct _DynamicObjectClass +{ + GObjectClass parent_class; + guint val; +}; + +G_DEFINE_DYNAMIC_TYPE(DynamicObject, dynamic_object, G_TYPE_OBJECT); + +static void +dynamic_object_class_init (DynamicObjectClass *class) +{ + class->val = 42; + g_assert (loaded == FALSE); + loaded = TRUE; +} + +static void +dynamic_object_class_finalize (DynamicObjectClass *class) +{ + g_assert (loaded == TRUE); + loaded = FALSE; +} + +static void +dynamic_object_init (DynamicObject *dynamic_object) +{ +} + + +static void +module_register (GTypeModule *module) +{ + dynamic_object_register_type (module); +} + +#define N_THREADS 100 +#define N_REFS 10000 + +static gpointer +ref_unref_thread (gpointer data) +{ + gint i; + /* first, syncronize with other threads, + */ + if (g_test_verbose()) + g_print ("WAITING!\n"); + g_mutex_lock (sync_mutex); + g_mutex_unlock (sync_mutex); + if (g_test_verbose ()) + g_print ("STARTING\n"); + + /* ref/unref the klass 10000000 times */ + for (i = N_REFS; i; i--) { + if (g_test_verbose ()) + if (i % 10) + g_print ("%d\n", i); + g_type_class_unref (g_type_class_ref ((GType) data)); + } + + if (g_test_verbose()) + g_print ("DONE !\n"); + + return NULL; +} + +static void +test_multithreaded_dynamic_type_init (void) +{ + GTypeModule *module; + DynamicObjectClass *class; + /* Create N_THREADS threads that are going to just ref/unref a class */ + GThread *threads[N_THREADS]; + guint i; + + module = test_module_new (module_register); + /* Not loaded until we call ref for the first time */ + class = g_type_class_peek (DYNAMIC_OBJECT_TYPE); + g_assert (class == NULL); + g_assert (!loaded); + + /* pause newly created threads */ + g_mutex_lock (sync_mutex); + + /* create threads */ + for (i = 0; i < N_THREADS; i++) { + threads[i] = g_thread_create (ref_unref_thread, (gpointer) DYNAMIC_OBJECT_TYPE, TRUE, NULL); + } + + /* execute threads */ + g_mutex_unlock (sync_mutex); + + for (i = 0; i < N_THREADS; i++) { + g_thread_join (threads[i]); + } +} + +int +main (int argc, + char *argv[]) +{ + g_thread_init (NULL); + g_test_init (&argc, &argv, NULL); + g_type_init (); + + sync_mutex = g_mutex_new(); + + g_test_add_func ("/GObject/threaded-dynamic-ref-unref-init", test_multithreaded_dynamic_type_init); + + return g_test_run(); +}