[glib] Remove g_mutex_new()/g_cond_new() in testcases

[Ryan Lortie <ryanl src gnome org>]

commit 6f343ca548af912e7ea6b0a35f5e12c8cb820126
Author: Ryan Lortie <desrt desrt ca>
Date:   Tue Oct 4 19:04:41 2011 -0400

    Remove g_mutex_new()/g_cond_new() in testcases
    
    These were the last users of the dynamic allocation API.
    
    Keep the uses in glib/tests/mutex.c since this is actually meant to test
    the API (which has to continue working, even if it is deprecated).
    
    https://bugzilla.gnome.org/show_bug.cgi?id=660739

 gio/tests/contexts.c         |   30 +++++++++++++++---------------
 gio/tests/tls-interaction.c  |   28 ++++++++++++++++------------
 gobject/tests/dynamictests.c |   12 +++++-------
 gobject/tests/threadtests.c  |   27 ++++++++++++---------------
 tests/mainloop-test.c        |   30 ++++++++++++++----------------
 tests/memchunks.c            |   25 +++++++++----------------
 tests/onceinit.c             |   31 +++++++++++++++----------------
 tests/slice-concurrent.c     |   13 +++++--------
 tests/slice-test.c           |    2 --
 tests/thread-test.c          |   14 ++++++--------
 10 files changed, 97 insertions(+), 115 deletions(-)
---
diff --git a/gio/tests/contexts.c b/gio/tests/contexts.c
index 5ddb54f..0e9b1af 100644
--- a/gio/tests/contexts.c
+++ b/gio/tests/contexts.c
@@ -52,24 +52,19 @@ opened_for_read (GObject *source, GAsyncResult *result, gpointer loop)
 static gboolean idle_start_test1_thread (gpointer loop);
 static gpointer test1_thread (gpointer user_data);
 
-static GCond *test1_cond;
-static GMutex *test1_mutex;
+static gboolean test1_done;
+static GCond test1_cond;
+static GMutex test1_mutex;
 
 static void
 test_thread_independence (void)
 {
   GMainLoop *loop;
 
-  test1_cond = g_cond_new ();
-  test1_mutex = g_mutex_new ();
-
   loop = g_main_loop_new (NULL, FALSE);
   g_idle_add (idle_start_test1_thread, loop);
   g_main_loop_run (loop);
   g_main_loop_unref (loop);
-
-  g_mutex_free (test1_mutex);
-  g_cond_free (test1_cond);
 }
 
 static gboolean
@@ -79,16 +74,19 @@ idle_start_test1_thread (gpointer loop)
   GThread *thread;
   gboolean io_completed;
 
-  g_mutex_lock (test1_mutex);
+  g_mutex_lock (&test1_mutex);
   thread = g_thread_create (test1_thread, NULL, TRUE, NULL);
 
   g_get_current_time (&time);
   time.tv_sec += 2;
-  io_completed = g_cond_timed_wait (test1_cond, test1_mutex, &time);
-  g_assert (io_completed);
+  while (!test1_done)
+    {
+      io_completed = g_cond_timed_wait (&test1_cond, &test1_mutex, &time);
+      g_assert (io_completed);
+    }
   g_thread_join (thread);
 
-  g_mutex_unlock (test1_mutex);
+  g_mutex_unlock (&test1_mutex);
   g_main_loop_quit (loop);
   return FALSE;
 }
@@ -101,8 +99,7 @@ test1_thread (gpointer user_data)
   GFile *file;
 
   /* Wait for main thread to be waiting on test1_cond */
-  g_mutex_lock (test1_mutex);
-  g_mutex_unlock (test1_mutex);
+  g_mutex_lock (&test1_mutex);
 
   context = g_main_context_new ();
   g_assert (g_main_context_get_thread_default () == NULL);
@@ -119,7 +116,10 @@ test1_thread (gpointer user_data)
   g_main_loop_run (loop);
   g_main_loop_unref (loop);
 
-  g_cond_signal (test1_cond);
+  test1_done = TRUE;
+  g_cond_signal (&test1_cond);
+  g_mutex_unlock (&test1_mutex);
+
   return NULL;
 }
 
diff --git a/gio/tests/tls-interaction.c b/gio/tests/tls-interaction.c
index 45b613c..f619e03 100644
--- a/gio/tests/tls-interaction.c
+++ b/gio/tests/tls-interaction.c
@@ -391,8 +391,9 @@ teardown_without_loop (Test            *test,
 }
 
 typedef struct {
-  GMutex *loop_mutex;
-  GCond *loop_started;
+  GMutex loop_mutex;
+  GCond loop_started;
+  gboolean started;
   Test *test;
 } ThreadLoop;
 
@@ -403,15 +404,16 @@ thread_loop (gpointer user_data)
   ThreadLoop *closure = user_data;
   Test *test = closure->test;
 
-  g_mutex_lock (closure->loop_mutex);
+  g_mutex_lock (&closure->loop_mutex);
 
   g_assert (test->loop_thread == g_thread_self ());
   g_assert (test->loop == NULL);
   test->loop = g_main_loop_new (context, TRUE);
 
   g_main_context_acquire (context);
-  g_cond_signal (closure->loop_started);
-  g_mutex_unlock (closure->loop_mutex);
+  closure->started = TRUE;
+  g_cond_signal (&closure->loop_started);
+  g_mutex_unlock (&closure->loop_mutex);
 
   while (g_main_loop_is_running (test->loop))
     g_main_context_iteration (context, TRUE);
@@ -429,14 +431,16 @@ setup_with_thread_loop (Test            *test,
 
   setup_without_loop (test, user_data);
 
-  closure.loop_mutex = g_mutex_new ();
-  closure.loop_started = g_cond_new ();
+  g_mutex_init (&closure.loop_mutex);
+  g_cond_init (&closure.loop_started);
+  closure.started = FALSE;
   closure.test = test;
 
-  g_mutex_lock (closure.loop_mutex);
+  g_mutex_lock (&closure.loop_mutex);
   test->loop_thread = g_thread_create (thread_loop, &closure, TRUE, &error);
-  g_cond_wait (closure.loop_started, closure.loop_mutex);
-  g_mutex_unlock (closure.loop_mutex);
+  while (!closure.started)
+    g_cond_wait (&closure.loop_started, &closure.loop_mutex);
+  g_mutex_unlock (&closure.loop_mutex);
 
   /*
    * When a loop is running then interaction should always occur in the main
@@ -444,8 +448,8 @@ setup_with_thread_loop (Test            *test,
    */
   test->interaction_thread = test->loop_thread;
 
-  g_mutex_free (closure.loop_mutex);
-  g_cond_free (closure.loop_started);
+  g_mutex_clear (&closure.loop_mutex);
+  g_cond_clear (&closure.loop_started);
 }
 
 static void
diff --git a/gobject/tests/dynamictests.c b/gobject/tests/dynamictests.c
index bff92e2..a72ad89 100644
--- a/gobject/tests/dynamictests.c
+++ b/gobject/tests/dynamictests.c
@@ -25,7 +25,7 @@
 /* This test tests the macros for defining dynamic types.
  */
 
-static GMutex *sync_mutex = NULL;
+static GMutex sync_mutex;
 static gboolean loaded = FALSE;
 
 /* MODULE */
@@ -169,8 +169,8 @@ ref_unref_thread (gpointer data)
    */
   if (g_test_verbose())
     g_print ("WAITING!\n");
-  g_mutex_lock (sync_mutex);
-  g_mutex_unlock (sync_mutex);
+  g_mutex_lock (&sync_mutex);
+  g_mutex_unlock (&sync_mutex);
   if (g_test_verbose ())
     g_print ("STARTING\n");
 
@@ -206,7 +206,7 @@ test_multithreaded_dynamic_type_init (void)
   g_assert (!loaded);
 
   /* pause newly created threads */
-  g_mutex_lock (sync_mutex);
+  g_mutex_lock (&sync_mutex);
 
   /* create threads */
   for (i = 0; i < N_THREADS; i++) {
@@ -214,7 +214,7 @@ test_multithreaded_dynamic_type_init (void)
   }
 
   /* execute threads */
-  g_mutex_unlock (sync_mutex);
+  g_mutex_unlock (&sync_mutex);
 
   for (i = 0; i < N_THREADS; i++) {
     g_thread_join (threads[i]);
@@ -356,8 +356,6 @@ main (int   argc,
   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);
   g_test_add_func ("/GObject/dynamic-interface-properties", test_dynamic_interface_properties);
 
diff --git a/gobject/tests/threadtests.c b/gobject/tests/threadtests.c
index ae88750..1352932 100644
--- a/gobject/tests/threadtests.c
+++ b/gobject/tests/threadtests.c
@@ -79,8 +79,8 @@ G_DEFINE_TYPE_WITH_CODE (MyTester2, my_tester2, G_TYPE_OBJECT,
 static void my_tester2_init (MyTester2*t) {}
 static void my_tester2_class_init (MyTester2Class*c) { call_counter_init (c); }
 
-static GCond *sync_cond = NULL;
-static GMutex *sync_mutex = NULL;
+static GCond sync_cond;
+static GMutex sync_mutex;
 
 static gpointer
 tester_init_thread (gpointer data)
@@ -91,8 +91,8 @@ tester_init_thread (gpointer data)
    * then run interface and class initializers,
    * using unsafe_call_counter concurrently
    */
-  g_mutex_lock (sync_mutex);
-  g_mutex_unlock (sync_mutex);
+  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 */
@@ -108,13 +108,13 @@ static void
 test_threaded_class_init (void)
 {
   /* pause newly created threads */
-  g_mutex_lock (sync_mutex);
+  g_mutex_lock (&sync_mutex);
   /* create threads */
   g_thread_create (tester_init_thread, (gpointer) my_tester0_get_type(), TRUE, NULL);
   g_thread_create (tester_init_thread, (gpointer) my_tester1_get_type(), TRUE, NULL);
   g_thread_create (tester_init_thread, (gpointer) my_tester2_get_type(), TRUE, NULL);
   /* execute threads */
-  g_mutex_unlock (sync_mutex);
+  g_mutex_unlock (&sync_mutex);
   while (g_atomic_int_get (&mtsafe_call_counter) < (3 + 3 + 3 * 3) * NUM_COUNTER_INCREMENTS)
     {
       if (g_test_verbose())
@@ -155,9 +155,9 @@ prop_tester_class_init (PropTesterClass *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);
+  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();
@@ -184,14 +184,14 @@ static void
 test_threaded_object_init (void)
 {
   GThread *creator;
-  g_mutex_lock (sync_mutex);
+  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);
+  g_cond_wait (&sync_cond, &sync_mutex);
 
   object_create (NULL);
-  g_mutex_unlock (sync_mutex);
+  g_mutex_unlock (&sync_mutex);
 
   g_thread_join (creator);
 }
@@ -204,9 +204,6 @@ main (int   argc,
   g_test_init (&argc, &argv, NULL);
   g_type_init ();
 
-  sync_cond = g_cond_new();
-  sync_mutex = g_mutex_new();
-
   g_test_add_func ("/GObject/threaded-class-init", test_threaded_class_init);
   g_test_add_func ("/GObject/threaded-object-init", test_threaded_object_init);
 
diff --git a/tests/mainloop-test.c b/tests/mainloop-test.c
index 206f80e..4bcb05f 100644
--- a/tests/mainloop-test.c
+++ b/tests/mainloop-test.c
@@ -27,8 +27,8 @@
  * be locked while the context array mutex is locked
  */
 GPtrArray *context_array;
-GMutex *context_array_mutex;
-GCond *context_array_cond;
+GMutex context_array_mutex;
+GCond context_array_cond;
 
 GMainLoop *main_loop;
 
@@ -144,14 +144,14 @@ adder_thread (gpointer data)
 
   context = g_main_context_new ();
 
-  g_mutex_lock (context_array_mutex);
+  g_mutex_lock (&context_array_mutex);
   
   g_ptr_array_add (context_array, context);
 
   if (context_array->len == NTHREADS)
-    g_cond_broadcast (context_array_cond);
+    g_cond_broadcast (&context_array_cond);
   
-  g_mutex_unlock (context_array_mutex);
+  g_mutex_unlock (&context_array_mutex);
 
   addr_data.dest = channels[1];
   addr_data.loop = g_main_loop_new (context, FALSE);
@@ -183,11 +183,11 @@ adder_thread (gpointer data)
   g_print ("Timeout run %d times\n", addr_data.count);
 #endif
 
-  g_mutex_lock (context_array_mutex);
+  g_mutex_lock (&context_array_mutex);
   g_ptr_array_remove (context_array, context);
   if (context_array->len == 0)
     g_main_loop_quit (main_loop);
-  g_mutex_unlock (context_array_mutex);
+  g_mutex_unlock (&context_array_mutex);
 
   cleanup_crawlers (context);
 
@@ -343,10 +343,10 @@ create_crawler (void)
   G_LOCK (crawler_array_lock);
   g_ptr_array_add (crawler_array, source);
   
-  g_mutex_lock (context_array_mutex);
+  g_mutex_lock (&context_array_mutex);
   g_source_attach (source, context_array->pdata[g_random_int_range (0, context_array->len)]);
   g_source_unref (source);
-  g_mutex_unlock (context_array_mutex);
+  g_mutex_unlock (&context_array_mutex);
 
   G_UNLOCK (crawler_array_lock);
 }
@@ -386,14 +386,14 @@ recurser_start (gpointer data)
   GMainContext *context;
   GSource *source;
   
-  g_mutex_lock (context_array_mutex);
+  g_mutex_lock (&context_array_mutex);
   context = context_array->pdata[g_random_int_range (0, context_array->len)];
   source = g_idle_source_new ();
   g_source_set_name (source, "Recursing idle source");
   g_source_set_callback (source, recurser_idle, context, NULL);
   g_source_attach (source, context);
   g_source_unref (source);
-  g_mutex_unlock (context_array_mutex);
+  g_mutex_unlock (&context_array_mutex);
 
   return TRUE;
 }
@@ -407,8 +407,6 @@ main (int   argc,
   g_thread_init (NULL);
 
   context_array = g_ptr_array_new ();
-  context_array_mutex = g_mutex_new ();
-  context_array_cond = g_cond_new (); 
 
   crawler_array = g_ptr_array_new ();
 
@@ -419,12 +417,12 @@ main (int   argc,
 
   /* Wait for all threads to start
    */
-  g_mutex_lock (context_array_mutex);
+  g_mutex_lock (&context_array_mutex);
   
   if (context_array->len < NTHREADS)
-    g_cond_wait (context_array_cond, context_array_mutex);
+    g_cond_wait (&context_array_cond, &context_array_mutex);
   
-  g_mutex_unlock (context_array_mutex);
+  g_mutex_unlock (&context_array_mutex);
   
   for (i = 0; i < NCRAWLERS; i++)
     create_crawler ();
diff --git a/tests/memchunks.c b/tests/memchunks.c
index e4e2f0b..8ce1625 100644
--- a/tests/memchunks.c
+++ b/tests/memchunks.c
@@ -50,7 +50,6 @@ static guint mem_chunk_recursion = 0;
 #  define LEAVE_MEM_CHUNK_ROUTINE()	(mem_chunk_recursion = MEM_CHUNK_ROUTINE_COUNT () - 1)
 
 /* --- old memchunk prototypes --- */
-void            old_mem_chunks_init     (void);
 GMemChunk*      old_mem_chunk_new       (const gchar  *name,
                                          gint          atom_size,
                                          gulong        area_size,
@@ -127,15 +126,9 @@ static gint   old_mem_chunk_area_search  (GMemArea *a,
 /* here we can't use StaticMutexes, as they depend upon a working
  * g_malloc, the same holds true for StaticPrivate
  */
-static GMutex        *mem_chunks_lock = NULL;
+static GMutex         mem_chunks_lock;
 static GMemChunk     *mem_chunks = NULL;
 
-void
-old_mem_chunks_init (void)
-{
-  mem_chunks_lock = g_mutex_new ();
-}
-
 GMemChunk*
 old_mem_chunk_new (const gchar  *name,
                    gint          atom_size,
@@ -175,13 +168,13 @@ old_mem_chunk_new (const gchar  *name,
   rarea_size = old_mem_chunk_compute_size (rarea_size, atom_size + sizeof (GMemArea) - MEM_AREA_SIZE);
   mem_chunk->area_size = rarea_size - (sizeof (GMemArea) - MEM_AREA_SIZE);
   
-  g_mutex_lock (mem_chunks_lock);
+  g_mutex_lock (&mem_chunks_lock);
   mem_chunk->next = mem_chunks;
   mem_chunk->prev = NULL;
   if (mem_chunks)
     mem_chunks->prev = mem_chunk;
   mem_chunks = mem_chunk;
-  g_mutex_unlock (mem_chunks_lock);
+  g_mutex_unlock (&mem_chunks_lock);
   
   LEAVE_MEM_CHUNK_ROUTINE ();
   
@@ -206,7 +199,7 @@ old_mem_chunk_destroy (GMemChunk *mem_chunk)
       g_free (temp_area);
     }
   
-  g_mutex_lock (mem_chunks_lock);
+  g_mutex_lock (&mem_chunks_lock);
   if (mem_chunk->next)
     mem_chunk->next->prev = mem_chunk->prev;
   if (mem_chunk->prev)
@@ -214,7 +207,7 @@ old_mem_chunk_destroy (GMemChunk *mem_chunk)
   
   if (mem_chunk == mem_chunks)
     mem_chunks = mem_chunks->next;
-  g_mutex_unlock (mem_chunks_lock);
+  g_mutex_unlock (&mem_chunks_lock);
   
   if (mem_chunk->type == G_ALLOC_AND_FREE)
     g_tree_destroy (mem_chunk->mem_tree);  
@@ -545,20 +538,20 @@ old_mem_chunk_info (void)
   gint count;
   
   count = 0;
-  g_mutex_lock (mem_chunks_lock);
+  g_mutex_lock (&mem_chunks_lock);
   mem_chunk = mem_chunks;
   while (mem_chunk)
     {
       count += 1;
       mem_chunk = mem_chunk->next;
     }
-  g_mutex_unlock (mem_chunks_lock);
+  g_mutex_unlock (&mem_chunks_lock);
   
   g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "%d mem chunks", count);
   
-  g_mutex_lock (mem_chunks_lock);
+  g_mutex_lock (&mem_chunks_lock);
   mem_chunk = mem_chunks;
-  g_mutex_unlock (mem_chunks_lock);
+  g_mutex_unlock (&mem_chunks_lock);
   
   while (mem_chunk)
     {
diff --git a/tests/onceinit.c b/tests/onceinit.c
index a57c171..fa513d1 100644
--- a/tests/onceinit.c
+++ b/tests/onceinit.c
@@ -23,8 +23,8 @@
 
 #define N_THREADS               (13)
 
-static GMutex      *tmutex = NULL;
-static GCond       *tcond = NULL;
+static GMutex       tmutex;
+static GCond        tcond;
 static volatile int thread_call_count = 0;
 static char         dummy_value = 'x';
 
@@ -96,9 +96,9 @@ initializer3 (void)
 static gpointer
 tmain_call_initializer3 (gpointer user_data)
 {
-  g_mutex_lock (tmutex);
-  g_cond_wait (tcond, tmutex);
-  g_mutex_unlock (tmutex);
+  g_mutex_lock (&tmutex);
+  g_cond_wait (&tcond, &tmutex);
+  g_mutex_unlock (&tmutex);
   //g_printf ("[");
   initializer3();
   //g_printf ("]\n");
@@ -124,15 +124,13 @@ main (int   argc,
   g_assert (p == &dummy_value);
   /* setup threads */
   g_thread_init (NULL);
-  tmutex = g_mutex_new ();
-  tcond = g_cond_new ();
   /* start multiple threads for initializer3() */
-  g_mutex_lock (tmutex);
+  g_mutex_lock (&tmutex);
   for (i = 0; i < N_THREADS; i++)
     threads[i] = g_thread_create (tmain_call_initializer3, 0, FALSE, NULL);
-  g_mutex_unlock (tmutex);
+  g_mutex_unlock (&tmutex);
   /* concurrently call initializer3() */
-  g_cond_broadcast (tcond);
+  g_cond_broadcast (&tcond);
   /* loop until all threads passed the call to initializer3() */
   while (g_atomic_int_get (&thread_call_count) < i)
     {
@@ -140,14 +138,14 @@ main (int   argc,
         g_thread_yield();   /* concurrent shuffling for single core */
       else
         g_usleep (1000);    /* concurrent shuffling for multi core */
-      g_cond_broadcast (tcond);
+      g_cond_broadcast (&tcond);
     }
   /* call multiple (unoptimized) initializers from multiple threads */
-  g_mutex_lock (tmutex);
+  g_mutex_lock (&tmutex);
   g_atomic_int_set (&thread_call_count, 0);
   for (i = 0; i < N_THREADS; i++)
     g_thread_create (stress_concurrent_initializers, 0, FALSE, NULL);
-  g_mutex_unlock (tmutex);
+  g_mutex_unlock (&tmutex);
   while (g_atomic_int_get (&thread_call_count) < 256 * 4 * N_THREADS)
     g_usleep (50 * 1000);       /* wait for all 5 threads to complete */
   return 0;
@@ -157,7 +155,8 @@ main (int   argc,
  * to uncover possible races in the g_once_init_enter_impl()/
  * g_once_init_leave() implementations
  */
-#define g_once_init_enter       g_once_init_enter_impl
+#undef g_once_init_enter
+#undef g_once_init_leave
 
 /* define 16 * 16 simple initializers */
 #define DEFINE_TEST_INITIALIZER(N)                      \
@@ -262,8 +261,8 @@ stress_concurrent_initializers (void *user_data)
   };
   int i;
   /* sync to main thread */
-  g_mutex_lock (tmutex);
-  g_mutex_unlock (tmutex);
+  g_mutex_lock (&tmutex);
+  g_mutex_unlock (&tmutex);
   /* initialize concurrently */
   for (i = 0; i < G_N_ELEMENTS (initializers); i++)
     {
diff --git a/tests/slice-concurrent.c b/tests/slice-concurrent.c
index e059d30..f403144 100644
--- a/tests/slice-concurrent.c
+++ b/tests/slice-concurrent.c
@@ -30,7 +30,7 @@ struct ThreadData
   int	   thread_id;
   GThread* gthread;
 
-  GMutex*  to_free_mutex;
+  GMutex   to_free_mutex;
   void*    to_free [N_THREADS * N_ALLOCS];
   int      bytes_to_free [N_THREADS * N_ALLOCS];
   int      n_to_free;
@@ -57,11 +57,11 @@ thread_func (void *arg)
 
       /* associate block with random thread */
       int t = rand() % N_THREADS;
-      g_mutex_lock (tdata[t].to_free_mutex);
+      g_mutex_lock (&tdata[t].to_free_mutex);
       tdata[t].to_free[tdata[t].n_to_free] = mem;
       tdata[t].bytes_to_free[tdata[t].n_to_free] = bytes;
       tdata[t].n_to_free++;
-      g_mutex_unlock (tdata[t].to_free_mutex);
+      g_mutex_unlock (&tdata[t].to_free_mutex);
 
       /* shuffle thread execution order every once in a while */
       if (rand() % 97 == 0)
@@ -73,14 +73,14 @@ thread_func (void *arg)
         }
 
       /* free a block associated with this thread */
-      g_mutex_lock (td->to_free_mutex);
+      g_mutex_lock (&td->to_free_mutex);
       if (td->n_to_free > 0)
 	{
 	  td->n_to_free--;
 	  g_slice_free1 (td->bytes_to_free[td->n_to_free], td->to_free[td->n_to_free]);
 	  td->n_freed++;
 	}
-      g_mutex_unlock (td->to_free_mutex);
+      g_mutex_unlock (&td->to_free_mutex);
     }
 
   return NULL;
@@ -91,14 +91,11 @@ main()
 {
   int t;
 
-  g_thread_init (NULL);
-
   for (t = 0; t < N_THREADS; t++)
     {
       tdata[t].thread_id = t + 1;
       tdata[t].n_to_free = 0;
       tdata[t].n_freed = 0;
-      tdata[t].to_free_mutex = g_mutex_new();
     }
   g_print ("Starting %d threads for concurrent GSlice usage...\n", N_THREADS);
   for (t = 0; t < N_THREADS; t++)
diff --git a/tests/slice-test.c b/tests/slice-test.c
index 84eb872..beafce3 100644
--- a/tests/slice-test.c
+++ b/tests/slice-test.c
@@ -29,7 +29,6 @@ static guint    number_of_repetitions = 10000;     /* number of alloc+free repet
 static gboolean want_corruption = FALSE;
 
 /* --- old memchunk prototypes (memchunks.c) --- */
-void            old_mem_chunks_init     (void);
 GMemChunk*      old_mem_chunk_new       (const gchar  *name,
                                          gint          atom_size,
                                          gulong        area_size,
@@ -285,7 +284,6 @@ main (int   argc,
         threads[i] = g_thread_create (test_sliced_mem_thread, seedp, TRUE, NULL);
     else
       {
-        old_mem_chunks_init();
         for (i = 0; i < n_threads; i++)
           threads[i] = g_thread_create (test_memchunk_thread, seedp, TRUE, NULL);
       }
diff --git a/tests/thread-test.c b/tests/thread-test.c
index 0f41fc7..1684401 100644
--- a/tests/thread-test.c
+++ b/tests/thread-test.c
@@ -5,7 +5,7 @@
 
 /* GMutex */
 
-static GMutex* test_g_mutex_mutex = NULL;
+static GMutex test_g_mutex_mutex;
 static guint test_g_mutex_int = 0;
 static gboolean test_g_mutex_thread_ready;
 G_LOCK_DEFINE_STATIC (test_g_mutex);
@@ -14,12 +14,12 @@ static gpointer
 test_g_mutex_thread (gpointer data)
 {
   g_assert (GPOINTER_TO_INT (data) == 42);
-  g_assert (g_mutex_trylock (test_g_mutex_mutex) == FALSE);
+  g_assert (g_mutex_trylock (&test_g_mutex_mutex) == FALSE);
   g_assert (G_TRYLOCK (test_g_mutex) == FALSE);
   test_g_mutex_thread_ready = TRUE;
-  g_mutex_lock (test_g_mutex_mutex);
+  g_mutex_lock (&test_g_mutex_mutex);
   g_assert (test_g_mutex_int == 42);
-  g_mutex_unlock (test_g_mutex_mutex);
+  g_mutex_unlock (&test_g_mutex_mutex);
 
   return GINT_TO_POINTER (41);
 }
@@ -28,9 +28,8 @@ static void
 test_g_mutex (void)
 {
   GThread *thread;
-  test_g_mutex_mutex = g_mutex_new ();
 
-  g_assert (g_mutex_trylock (test_g_mutex_mutex));
+  g_assert (g_mutex_trylock (&test_g_mutex_mutex));
   g_assert (G_TRYLOCK (test_g_mutex));
   test_g_mutex_thread_ready = FALSE;
   thread = g_thread_create (test_g_mutex_thread, GINT_TO_POINTER (42),
@@ -41,9 +40,8 @@ test_g_mutex (void)
     g_usleep (G_USEC_PER_SEC / 5);
   test_g_mutex_int = 42;
   G_UNLOCK (test_g_mutex);
-  g_mutex_unlock (test_g_mutex_mutex);
+  g_mutex_unlock (&test_g_mutex_mutex);
   g_assert (GPOINTER_TO_INT (g_thread_join (thread)) == 41);
-  g_mutex_free (test_g_mutex_mutex);
 }
 
 /* GStaticRecMutex */