Revert "audio: fix pc speaker init"

[mirror_qemu.git] / tests / test-coroutine.c

diff --git a/tests/test-coroutine.c b/tests/test-coroutine.c
index 76c646107e7c1102eea070c52f2b53cf1b222cd9..e946d93a657fd19da5f2405ab2d801d50e1bcb8b 100644 (file)
--- a/tests/test-coroutine.c
+++ b/tests/test-coroutine.c
@@ -14,6 +14,7 @@
 #include "qemu/osdep.h"
 #include "qemu/coroutine.h"
 #include "qemu/coroutine_int.h"
+#include "qemu/lockable.h"
 
 /*
  * Check that qemu_in_coroutine() works
@@ -175,7 +176,7 @@ static void coroutine_fn c1_fn(void *opaque)
     qemu_coroutine_enter(c2);
 }
 
-static void test_co_queue(void)
+static void test_no_dangling_access(void)
 {
     Coroutine *c1;
     Coroutine *c2;
@@ -195,6 +196,74 @@ static void test_co_queue(void)
     *c1 = tmp;
 }
 
+static bool locked;
+static int done;
+
+static void coroutine_fn mutex_fn(void *opaque)
+{
+    CoMutex *m = opaque;
+    qemu_co_mutex_lock(m);
+    assert(!locked);
+    locked = true;
+    qemu_coroutine_yield();
+    locked = false;
+    qemu_co_mutex_unlock(m);
+    done++;
+}
+
+static void coroutine_fn lockable_fn(void *opaque)
+{
+    QemuLockable *x = opaque;
+    qemu_lockable_lock(x);
+    assert(!locked);
+    locked = true;
+    qemu_coroutine_yield();
+    locked = false;
+    qemu_lockable_unlock(x);
+    done++;
+}
+
+static void do_test_co_mutex(CoroutineEntry *entry, void *opaque)
+{
+    Coroutine *c1 = qemu_coroutine_create(entry, opaque);
+    Coroutine *c2 = qemu_coroutine_create(entry, opaque);
+
+    done = 0;
+    qemu_coroutine_enter(c1);
+    g_assert(locked);
+    qemu_coroutine_enter(c2);
+
+    /* Unlock queues c2.  It is then started automatically when c1 yields or
+     * terminates.
+     */
+    qemu_coroutine_enter(c1);
+    g_assert_cmpint(done, ==, 1);
+    g_assert(locked);
+
+    qemu_coroutine_enter(c2);
+    g_assert_cmpint(done, ==, 2);
+    g_assert(!locked);
+}
+
+static void test_co_mutex(void)
+{
+    CoMutex m;
+
+    qemu_co_mutex_init(&m);
+    do_test_co_mutex(mutex_fn, &m);
+}
+
+static void test_co_mutex_lockable(void)
+{
+    CoMutex m;
+    CoMutex *null_pointer = NULL;
+
+    qemu_co_mutex_init(&m);
+    do_test_co_mutex(lockable_fn, QEMU_MAKE_LOCKABLE(&m));
+
+    g_assert(QEMU_MAKE_LOCKABLE(null_pointer) == NULL);
+}
+
 /*
  * Check that creation, enter, and return work
  */
@@ -300,7 +369,7 @@ static void perf_lifecycle(void)
     }
     duration = g_test_timer_elapsed();
 
-    g_test_message("Lifecycle %u iterations: %f s\n", max, duration);
+    g_test_message("Lifecycle %u iterations: %f s", max, duration);
 }
 
 static void perf_nesting(void)
@@ -324,7 +393,7 @@ static void perf_nesting(void)
     }
     duration = g_test_timer_elapsed();
 
-    g_test_message("Nesting %u iterations of %u depth each: %f s\n",
+    g_test_message("Nesting %u iterations of %u depth each: %f s",
         maxcycles, maxnesting, duration);
 }
 
@@ -357,8 +426,7 @@ static void perf_yield(void)
     }
     duration = g_test_timer_elapsed();
 
-    g_test_message("Yield %u iterations: %f s\n",
-        maxcycles, duration);
+    g_test_message("Yield %u iterations: %f s", maxcycles, duration);
 }
 
 static __attribute__((noinline)) void dummy(unsigned *i)
@@ -380,8 +448,7 @@ static void perf_baseline(void)
     }
     duration = g_test_timer_elapsed();
 
-    g_test_message("Function call %u iterations: %f s\n",
-        maxcycles, duration);
+    g_test_message("Function call %u iterations: %f s", maxcycles, duration);
 }
 
 static __attribute__((noinline)) void perf_cost_func(void *opaque)
@@ -422,7 +489,7 @@ int main(int argc, char **argv)
      * crash, so skip it.
      */
     if (CONFIG_COROUTINE_POOL) {
-        g_test_add_func("/basic/co_queue", test_co_queue);
+        g_test_add_func("/basic/no-dangling-access", test_no_dangling_access);
     }
 
     g_test_add_func("/basic/lifecycle", test_lifecycle);
@@ -432,6 +499,8 @@ int main(int argc, char **argv)
     g_test_add_func("/basic/entered", test_entered);
     g_test_add_func("/basic/in_coroutine", test_in_coroutine);
     g_test_add_func("/basic/order", test_order);
+    g_test_add_func("/locking/co-mutex", test_co_mutex);
+    g_test_add_func("/locking/co-mutex/lockable", test_co_mutex_lockable);
     if (g_test_perf()) {
         g_test_add_func("/perf/lifecycle", perf_lifecycle);
         g_test_add_func("/perf/nesting", perf_nesting);