Testing failed CI test for MacOS

Author: sadko4u

src/main/ipc/SharedMutex.cpp

@@ -536,7 +536,8 @@ namespace lsp
             {
                 case 0: break;
                 case EDEADLK: return STATUS_BAD_STATE;
-                case EBUSY: return STATUS_LOCKED;
+                case EBUSY:
+                    return STATUS_LOCKED;
                 case ETIMEDOUT: return STATUS_TIMED_OUT;
                 case EOWNERDEAD:
                 {

src/test/utest/ipc/shmutex.cpp

@@ -20,6 +20,7 @@
  */
 
 #include <lsp-plug.in/test-fw/utest.h>
+#include <lsp-plug.in/common/atomic.h>
 #include <lsp-plug.in/ipc/Thread.h>
 #include <lsp-plug.in/ipc/Mutex.h>
 #include <lsp-plug.in/ipc/SharedMutex.h>
@@ -34,6 +35,7 @@ UTEST_BEGIN("runtime.ipc", shmutex)
     {
         ipc::Mutex lock;
         LSPString data;
+        uatomic_t sequence_latch;
 
         void log(status_t code, const char *event, status_t expected)
         {
@@ -42,7 +44,10 @@ UTEST_BEGIN("runtime.ipc", shmutex)
 
             data.append_ascii(event);
             data.append('=');
-            data.append_ascii((code == expected) ? "true" : "false");
+            if (code == expected)
+                data.append_ascii("true");
+            else
+                data.fmt_append_ascii("false(code=%d)", int(code));
             data.append(';');
         }
     } context_t;
@@ -53,11 +58,26 @@ UTEST_BEGIN("runtime.ipc", shmutex)
         ipc::SharedMutex mutex;
         context_t *ctx = static_cast<context_t *>(arg);
 
-        ipc::Thread::sleep(500);
+        wait_latch(ctx->sequence_latch, 0);
         ctx->log(mutex.open("test-lsp.lock"), "open1", STATUS_OK);
-        ctx->log(mutex.lock(), "SYNC1", STATUS_OK);
+        atomic_add(&ctx->sequence_latch, 1); // 0 -> 1
+
+        // Sleep 500 ms and lock the mutex
+        wait_latch(ctx->sequence_latch, 3);
+        ipc::Thread::sleep(500);
+        ctx->log(mutex.lock(), "SYNC1.lock", STATUS_OK);
+        atomic_add(&ctx->sequence_latch, 1); // 3 -> 6
+
+        // Now sleep 800 msec and unlock the mutex
+        wait_latch(ctx->sequence_latch, 6);
         ipc::Thread::sleep(800);
-        ctx->log(mutex.unlock(), "SYNC2", STATUS_OK);
+        ctx->log(mutex.unlock(), "SYNC2.unlock", STATUS_OK);
+        atomic_add(&ctx->sequence_latch, 1); // 6 -> 8
+
+        // Close the mutex
+        wait_latch(ctx->sequence_latch, 9);
+        ctx->log(mutex.close(), "close1", STATUS_OK);
+        atomic_add(&ctx->sequence_latch, 1); // 9 -> 10
 
         return STATUS_OK;
     }
@@ -67,24 +87,43 @@ UTEST_BEGIN("runtime.ipc", shmutex)
         ipc::SharedMutex mutex;
         context_t *ctx = static_cast<context_t *>(arg);
 
+        wait_latch(ctx->sequence_latch, 1);
         ctx->log(mutex.open("test-lsp.lock"), "open2", STATUS_OK);
-        ctx->log(mutex.lock(), "lock2", STATUS_OK);
+        atomic_add(&ctx->sequence_latch, 1); // 1 -> 2
 
+        // Lock mutex immediately, sleep 500 ms and unlock it
+        wait_latch(ctx->sequence_latch, 3);
+        ctx->log(mutex.lock(), "lock2", STATUS_OK);
         ipc::Thread::sleep(500);
+        ctx->log(mutex.unlock(), "SYNC1.unlock", STATUS_OK);
+        atomic_add(&ctx->sequence_latch, 1); // 3 -> 6
 
-        ctx->log(mutex.unlock(), "SYNC1", STATUS_OK);
-
-        ipc::Thread::sleep(100);
-
+        // Call mutltiple times lock, succeed on last call
+        wait_latch(ctx->sequence_latch, 6);
         ctx->log(mutex.try_lock(), "trylock2", STATUS_RETRY);
         ctx->log(mutex.lock(500), "timedlock2", STATUS_TIMED_OUT);
-        ctx->log(mutex.lock(500), "SYNC2", STATUS_OK);
+        ctx->log(mutex.lock(500), "SYNC2.lock", STATUS_OK);
+        atomic_add(&ctx->sequence_latch, 1); // 6 -> 8
+
+        // Sleep 200 milliseconds and unlock the mutex
+        wait_latch(ctx->sequence_latch, 8);
         ipc::Thread::sleep(200);
-        ctx->log(mutex.unlock(), "SYNC3", STATUS_OK);
+        ctx->log(mutex.unlock(), "SYNC3.unlock", STATUS_OK);
+
+        // Close the mutex
+        wait_latch(ctx->sequence_latch, 10);
+        ctx->log(mutex.close(), "close2", STATUS_OK);
+        atomic_add(&ctx->sequence_latch, 1); // 10 -> 11
 
         return STATUS_OK;
     }
 
+    static void wait_latch(uatomic_t & latch, uatomic_t value)
+    {
+        while (atomic_load(&latch) != value)
+            ipc::Thread::yield();
+    }
+
     void test_simple()
     {
         ipc::SharedMutex mutex;
@@ -122,6 +161,7 @@ UTEST_BEGIN("runtime.ipc", shmutex)
     {
         ipc::SharedMutex mutex;
         context_t ctx;
+        atomic_store(&ctx.sequence_latch, uatomic_t(0));
 
         printf("Testing simple multi-threaded mutex locks\n");
 
@@ -134,24 +174,31 @@ UTEST_BEGIN("runtime.ipc", shmutex)
         ctx.log(STATUS_OK, "start", STATUS_OK);
         t1.start();
         t2.start();
+        wait_latch(ctx.sequence_latch, 2);
+        atomic_add(&ctx.sequence_latch, 1); // 2 -> 3
 
+        // Sleep 200 ms and unlock the mutex
         ctx.log(STATUS_OK, "sleep", STATUS_OK);
         ipc::Thread::sleep(200);
-
         ctx.log(STATUS_OK, "unlock", STATUS_OK);
         UTEST_ASSERT(mutex.unlock() == STATUS_OK);
+        atomic_add(&ctx.sequence_latch, 1); // 3 -> 6
 
-        ipc::Thread::sleep(2000);
-        ctx.log(mutex.lock(), "SYNC3", STATUS_OK);
+        // Lock the mutex, unlock it and return result
+        wait_latch(ctx.sequence_latch, 8);
+        ctx.log(mutex.lock(), "SYNC3.lock", STATUS_OK);
         ctx.log(mutex.unlock(), "unlock", STATUS_OK);
 
         ctx.log(mutex.close(), "close", STATUS_OK);
+        atomic_add(&ctx.sequence_latch, 1); // 8 -> 9
 
+        // Do final comparison
+        wait_latch(ctx.sequence_latch, 11);
         static const char *expected =
-            "open=true;lock=true;start=true;sleep=true;open2=true;unlock=true;lock2=true;open1=true;"
-            "SYNC1=true;SYNC1=true;trylock2=true;timedlock2=true;"
-            "SYNC2=true;SYNC2=true;"
-            "SYNC3=true;SYNC3=true;unlock=true;close=true;";
+            "open=true;lock=true;start=true;open1=true;open2=true;sleep=true;unlock=true;lock2=true;"
+            "SYNC1.unlock=true;SYNC1.lock=true;trylock2=true;timedlock2=true;"
+            "SYNC2.unlock=true;SYNC2.lock=true;"
+            "SYNC3.unlock=true;SYNC3.lock=true;unlock=true;close=true;close1=true;close2=true;";
 
         printf("Result content:   %s\n", ctx.data.get_ascii());
         printf("Expected content: %s\n", expected);