/* GLib testing framework examples and tests * Copyright (C) 2008 Imendio AB * Authors: Tim Janik * * SPDX-License-Identifier: LicenseRef-old-glib-tests * * 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. */ #ifndef GLIB_DISABLE_DEPRECATION_WARNINGS #define GLIB_DISABLE_DEPRECATION_WARNINGS #endif #include #include static int mtsafe_call_counter = 0; /* multi thread safe call counter, must be accessed atomically */ static int unsafe_call_counter = 0; /* single-threaded call counter */ static GCond sync_cond; static GMutex sync_mutex; #define NUM_COUNTER_INCREMENTS 100000 static void call_counter_init (gpointer tclass) { int i; for (i = 0; i < NUM_COUNTER_INCREMENTS; i++) { int saved_unsafe_call_counter = unsafe_call_counter; g_atomic_int_add (&mtsafe_call_counter, 1); /* real call count update */ g_thread_yield(); /* let concurrent threads corrupt the unsafe_call_counter state */ unsafe_call_counter = 1 + saved_unsafe_call_counter; /* non-atomic counter update */ } } static void interface_per_class_init (void) { call_counter_init (NULL); } /* define 3 test interfaces */ typedef GTypeInterface MyFace0Interface; static GType my_face0_get_type (void); G_DEFINE_INTERFACE (MyFace0, my_face0, G_TYPE_OBJECT) static void my_face0_default_init (MyFace0Interface *iface) { call_counter_init (iface); } typedef GTypeInterface MyFace1Interface; static GType my_face1_get_type (void); G_DEFINE_INTERFACE (MyFace1, my_face1, G_TYPE_OBJECT) static void my_face1_default_init (MyFace1Interface *iface) { call_counter_init (iface); } /* define 3 test objects, adding interfaces 0 & 1, and adding interface 2 after class initialization */ typedef GObject MyTester0; typedef GObjectClass MyTester0Class; static GType my_tester0_get_type (void); G_DEFINE_TYPE_WITH_CODE (MyTester0, my_tester0, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (my_face0_get_type(), interface_per_class_init) G_IMPLEMENT_INTERFACE (my_face1_get_type(), interface_per_class_init)) static void my_tester0_init (MyTester0*t) {} static void my_tester0_class_init (MyTester0Class*c) { call_counter_init (c); } typedef GObject MyTester1; typedef GObjectClass MyTester1Class; /* Disabled for now (see https://bugzilla.gnome.org/show_bug.cgi?id=687659) */ #if 0 typedef GTypeInterface MyFace2Interface; static GType my_face2_get_type (void); G_DEFINE_INTERFACE (MyFace2, my_face2, G_TYPE_OBJECT) static void my_face2_default_init (MyFace2Interface *iface) { call_counter_init (iface); } static GType my_tester1_get_type (void); G_DEFINE_TYPE_WITH_CODE (MyTester1, my_tester1, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (my_face0_get_type(), interface_per_class_init) G_IMPLEMENT_INTERFACE (my_face1_get_type(), interface_per_class_init)) static void my_tester1_init (MyTester1*t) {} static void my_tester1_class_init (MyTester1Class*c) { call_counter_init (c); } typedef GObject MyTester2; typedef GObjectClass MyTester2Class; static GType my_tester2_get_type (void); G_DEFINE_TYPE_WITH_CODE (MyTester2, my_tester2, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (my_face0_get_type(), interface_per_class_init) G_IMPLEMENT_INTERFACE (my_face1_get_type(), interface_per_class_init)) static void my_tester2_init (MyTester2*t) {} static void my_tester2_class_init (MyTester2Class*c) { call_counter_init (c); } static gpointer tester_init_thread (gpointer data) { const GInterfaceInfo face2_interface_info = { (GInterfaceInitFunc) interface_per_class_init, NULL, NULL }; gpointer klass; /* first, synchronize with other threads, * then run interface and class initializers, * using unsafe_call_counter concurrently */ g_mutex_lock (&sync_mutex); g_mutex_unlock (&sync_mutex); /* test default interface initialization for face0 */ g_type_default_interface_unref (g_type_default_interface_ref (my_face0_get_type())); /* test class initialization, face0 per-class initializer, face1 default and per-class initializer */ klass = g_type_class_ref ((GType) data); /* test face2 default and per-class initializer, after class_init */ g_type_add_interface_static (G_TYPE_FROM_CLASS (klass), my_face2_get_type(), &face2_interface_info); /* cleanups */ g_type_class_unref (klass); return NULL; } static void test_threaded_class_init (void) { GThread *t1, *t2, *t3; /* pause newly created threads */ g_mutex_lock (&sync_mutex); /* create threads */ t1 = g_thread_create (tester_init_thread, (gpointer) my_tester0_get_type(), TRUE, NULL); t2 = g_thread_create (tester_init_thread, (gpointer) my_tester1_get_type(), TRUE, NULL); t3 = g_thread_create (tester_init_thread, (gpointer) my_tester2_get_type(), TRUE, NULL); /* execute threads */ g_mutex_unlock (&sync_mutex); while (g_atomic_int_get (&mtsafe_call_counter) < (3 + 3 + 3 * 3) * NUM_COUNTER_INCREMENTS) { if (g_test_verbose()) g_printerr ("Initializers counted: %u\n", g_atomic_int_get (&mtsafe_call_counter)); g_usleep (50 * 1000); /* wait for threads to complete */ } if (g_test_verbose()) g_printerr ("Total initializers: %u\n", g_atomic_int_get (&mtsafe_call_counter)); /* ensure non-corrupted counter updates */ g_assert_cmpint (g_atomic_int_get (&mtsafe_call_counter), ==, unsafe_call_counter); g_thread_join (t1); g_thread_join (t2); g_thread_join (t3); } #endif typedef struct { GObject parent; char *name; } PropTester; typedef GObjectClass PropTesterClass; static GType prop_tester_get_type (void); G_DEFINE_TYPE (PropTester, prop_tester, G_TYPE_OBJECT) #define PROP_NAME 1 static void prop_tester_init (PropTester* t) { if (t->name == NULL) { } /* needs unit test framework initialization: g_test_bug ("race initializing properties"); */ } static void prop_tester_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) {} static void prop_tester_class_init (PropTesterClass *c) { int i; GParamSpec *param; GObjectClass *gobject_class = G_OBJECT_CLASS (c); gobject_class->set_property = prop_tester_set_property; /* silence GObject checks */ g_mutex_lock (&sync_mutex); g_cond_signal (&sync_cond); g_mutex_unlock (&sync_mutex); for (i = 0; i < 100; i++) /* wait a bit. */ g_thread_yield(); call_counter_init (c); param = g_param_spec_string ("name", "name_i18n", "yet-more-wasteful-i18n", NULL, G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK); g_object_class_install_property (gobject_class, PROP_NAME, param); } static gpointer object_create (gpointer data) { GObject *obj = g_object_new (prop_tester_get_type(), "name", "fish", NULL); g_object_unref (obj); return NULL; } static void test_threaded_object_init (void) { GThread *creator; g_mutex_lock (&sync_mutex); creator = g_thread_create (object_create, NULL, TRUE, NULL); /* really provoke the race */ g_cond_wait (&sync_cond, &sync_mutex); object_create (NULL); g_mutex_unlock (&sync_mutex); g_thread_join (creator); } typedef struct { MyTester0 *strong; guint unref_delay; } UnrefInThreadData; static gpointer unref_in_thread (gpointer p) { UnrefInThreadData *data = p; g_usleep (data->unref_delay); g_object_unref (data->strong); return NULL; } /* undefine to see this test fail without GWeakRef */ #define HAVE_G_WEAK_REF #define SLEEP_MIN_USEC 1 #define SLEEP_MAX_USEC 10 static void test_threaded_weak_ref (void) { guint i; guint get_wins = 0, unref_wins = 0; guint n; if (g_test_thorough ()) n = NUM_COUNTER_INCREMENTS; else n = NUM_COUNTER_INCREMENTS / 20; #ifdef G_OS_WIN32 /* On Windows usleep has millisecond resolution and gets rounded up * leading to the test running for a long time. */ n /= 10; #endif for (i = 0; i < n; i++) { UnrefInThreadData data; #ifdef HAVE_G_WEAK_REF /* GWeakRef in C++ terms */ GWeakRef weak; #else gpointer weak; #endif MyTester0 *strengthened; guint get_delay; GThread *thread; GError *error = NULL; if (g_test_verbose () && (i % (n/20)) == 0) g_printerr ("%u%%\n", ((i * 100) / n)); /* Have an object and a weak ref to it */ data.strong = g_object_new (my_tester0_get_type (), NULL); #ifdef HAVE_G_WEAK_REF g_weak_ref_init (&weak, data.strong); #else weak = data.strong; g_object_add_weak_pointer ((GObject *) weak, &weak); #endif /* Delay for a random time on each side of the race, to perturb the * timing. Ideally, we want each side to win half the races; on * smcv's laptop, these timings are about right. */ data.unref_delay = g_random_int_range (SLEEP_MIN_USEC / 2, SLEEP_MAX_USEC / 2); get_delay = g_random_int_range (SLEEP_MIN_USEC, SLEEP_MAX_USEC); /* One half of the race is to unref the shared object */ thread = g_thread_create (unref_in_thread, &data, TRUE, &error); g_assert_no_error (error); /* The other half of the race is to get the object from the "global * singleton" */ g_usleep (get_delay); #ifdef HAVE_G_WEAK_REF strengthened = g_weak_ref_get (&weak); #else /* Spot the unsafe pointer access! In GDBusConnection this is rather * better-hidden, but ends up with essentially the same thing, albeit * cleared in dispose() rather than by a traditional weak pointer */ strengthened = weak; if (strengthened != NULL) g_object_ref (strengthened); #endif if (strengthened != NULL) g_assert (G_IS_OBJECT (strengthened)); /* Wait for the thread to run */ g_thread_join (thread); if (strengthened != NULL) { get_wins++; g_assert (G_IS_OBJECT (strengthened)); g_object_unref (strengthened); } else { unref_wins++; } #ifdef HAVE_G_WEAK_REF g_weak_ref_clear (&weak); #else if (weak != NULL) g_object_remove_weak_pointer (weak, &weak); #endif } if (g_test_verbose ()) g_printerr ("Race won by get %u times, unref %u times\n", get_wins, unref_wins); } typedef struct { GObject *object; GWeakRef *weak; gint started; /* (atomic) */ gint finished; /* (atomic) */ gint disposing; /* (atomic) */ } ThreadedWeakRefData; static void on_weak_ref_disposed (gpointer data, GObject *gobj) { ThreadedWeakRefData *thread_data = data; /* Wait until the thread has started */ while (!g_atomic_int_get (&thread_data->started)) continue; g_atomic_int_set (&thread_data->disposing, 1); /* Wait for the thread to act, so that the object is still valid */ while (!g_atomic_int_get (&thread_data->finished)) continue; g_atomic_int_set (&thread_data->disposing, 0); } static gpointer on_other_thread_weak_ref (gpointer user_data) { ThreadedWeakRefData *thread_data = user_data; GObject *object = thread_data->object; g_atomic_int_set (&thread_data->started, 1); /* Ensure we've started disposal */ while (!g_atomic_int_get (&thread_data->disposing)) continue; g_object_ref (object); g_weak_ref_set (thread_data->weak, object); g_object_unref (object); g_assert_cmpint (thread_data->disposing, ==, 1); g_atomic_int_set (&thread_data->finished, 1); return NULL; } static void test_threaded_weak_ref_finalization (void) { GObject *obj = g_object_new (G_TYPE_OBJECT, NULL); GWeakRef weak = { { GUINT_TO_POINTER (0xDEADBEEFU) } }; ThreadedWeakRefData thread_data = { .object = obj, .weak = &weak, .started = 0, .finished = 0 }; g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/2390"); g_test_summary ("Test that a weak ref added by another thread during dispose " "of a GObject is cleared during finalisation. " "Use on_weak_ref_disposed() to synchronize the other thread " "with the dispose vfunc."); g_weak_ref_init (&weak, NULL); g_object_weak_ref (obj, on_weak_ref_disposed, &thread_data); g_assert_cmpint (obj->ref_count, ==, 1); g_thread_unref (g_thread_new ("on_other_thread", on_other_thread_weak_ref, &thread_data)); g_object_unref (obj); /* This is what this test is about: at this point the weak reference * should have been unset (and not point to a dead object either). */ g_assert_null (g_weak_ref_get (&weak)); } typedef struct { GObject *object; int done; /* (atomic) */ int toggles; /* (atomic) */ } ToggleNotifyThreadData; static gpointer on_reffer_thread (gpointer user_data) { ToggleNotifyThreadData *thread_data = user_data; while (!g_atomic_int_get (&thread_data->done)) { g_object_ref (thread_data->object); g_object_unref (thread_data->object); } return NULL; } static void on_toggle_notify (gpointer data, GObject *object, gboolean is_last_ref) { /* Anything could be put here, but we don't care for this test. * Actually having this empty made the bug to happen more frequently (being * timing related). */ } static gpointer on_toggler_thread (gpointer user_data) { ToggleNotifyThreadData *thread_data = user_data; while (!g_atomic_int_get (&thread_data->done)) { g_object_ref (thread_data->object); g_object_remove_toggle_ref (thread_data->object, on_toggle_notify, thread_data); g_object_add_toggle_ref (thread_data->object, on_toggle_notify, thread_data); g_object_unref (thread_data->object); g_atomic_int_add (&thread_data->toggles, 1); } return NULL; } static void test_threaded_toggle_notify (void) { GObject *object = g_object_new (G_TYPE_OBJECT, NULL); ToggleNotifyThreadData data = { object, FALSE, 0 }; GThread *threads[3]; gsize i; g_test_bug ("https://gitlab.gnome.org/GNOME/glib/issues/2394"); g_test_summary ("Test that toggle reference notifications can be changed " "safely from another (the main) thread without causing the " "notifying thread to abort"); g_object_add_toggle_ref (object, on_toggle_notify, &data); g_object_unref (object); g_assert_cmpint (object->ref_count, ==, 1); threads[0] = g_thread_new ("on_reffer_thread", on_reffer_thread, &data); threads[1] = g_thread_new ("on_another_reffer_thread", on_reffer_thread, &data); threads[2] = g_thread_new ("on_main_toggler_thread", on_toggler_thread, &data); /* We need to wait here for the threads to run for a bit in order to make the * race to happen, so we wait for an high number of toggle changes to be met * so that we can be consistent on each platform. */ while (g_atomic_int_get (&data.toggles) < 1000000) ; g_atomic_int_set (&data.done, TRUE); for (i = 0; i < G_N_ELEMENTS (threads); i++) g_thread_join (threads[i]); g_assert_cmpint (object->ref_count, ==, 1); g_clear_object (&object); } int main (int argc, char *argv[]) { g_test_init (&argc, &argv, NULL); /* g_test_add_func ("/GObject/threaded-class-init", test_threaded_class_init); */ g_test_add_func ("/GObject/threaded-object-init", test_threaded_object_init); g_test_add_func ("/GObject/threaded-weak-ref", test_threaded_weak_ref); g_test_add_func ("/GObject/threaded-weak-ref/on-finalization", test_threaded_weak_ref_finalization); g_test_add_func ("/GObject/threaded-toggle-notify", test_threaded_toggle_notify); return g_test_run(); }