Testing failed CI test for MacOS

Author: sadko4u

src/main/ipc/SharedMutex.cpp

@@ -496,7 +496,10 @@ namespace lsp
             // Check that we don't lock the mutex again
             const thread_id_t tid = Thread::current_thread_id();
             if (atomic_load(&nOwner) == tid)
+            {
+                lsp_warn("Already locked mutex");
                 return STATUS_LOCKED;
+            }
 
         #ifdef PLATFORM_WINDOWS
             DWORD res = WaitForSingleObject(hLock, delay);
@@ -536,7 +539,9 @@ namespace lsp
             {
                 case 0: break;
                 case EDEADLK: return STATUS_BAD_STATE;
-                case EBUSY: return STATUS_LOCKED;
+                case EBUSY:
+                    lsp_warn("got EBUSY error");
+                    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,8 @@ UTEST_BEGIN("runtime.ipc", shmutex)
     {
         ipc::Mutex lock;
         LSPString data;
+        uatomic_t init_latch;
+        uatomic_t start_latch;
 
         void log(status_t code, const char *event, status_t expected)
         {
@@ -42,7 +45,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 +59,15 @@ UTEST_BEGIN("runtime.ipc", shmutex)
         ipc::SharedMutex mutex;
         context_t *ctx = static_cast<context_t *>(arg);
 
-        ipc::Thread::sleep(500);
         ctx->log(mutex.open("test-lsp.lock"), "open1", STATUS_OK);
-        ctx->log(mutex.lock(), "SYNC1", STATUS_OK);
+        wait_latch(ctx->init_latch, 0);
+        atomic_add(&ctx->init_latch, 1);
+        wait_latch(ctx->start_latch, 1);
+
+        ipc::Thread::sleep(500);
+        ctx->log(mutex.lock(), "SYNC1.lock", STATUS_OK);
         ipc::Thread::sleep(800);
-        ctx->log(mutex.unlock(), "SYNC2", STATUS_OK);
+        ctx->log(mutex.unlock(), "SYNC2.unlock", STATUS_OK);
 
         return STATUS_OK;
     }
@@ -68,23 +78,33 @@ UTEST_BEGIN("runtime.ipc", shmutex)
         context_t *ctx = static_cast<context_t *>(arg);
 
         ctx->log(mutex.open("test-lsp.lock"), "open2", STATUS_OK);
+        wait_latch(ctx->init_latch, 1);
+        atomic_add(&ctx->init_latch, 1);
+        wait_latch(ctx->start_latch, 1);
+
         ctx->log(mutex.lock(), "lock2", STATUS_OK);
 
         ipc::Thread::sleep(500);
 
-        ctx->log(mutex.unlock(), "SYNC1", STATUS_OK);
+        ctx->log(mutex.unlock(), "SYNC1.unlock", STATUS_OK);
 
         ipc::Thread::sleep(100);
 
         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);
         ipc::Thread::sleep(200);
-        ctx->log(mutex.unlock(), "SYNC3", STATUS_OK);
+        ctx->log(mutex.unlock(), "SYNC3.unlock", STATUS_OK);
 
         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 +142,8 @@ UTEST_BEGIN("runtime.ipc", shmutex)
     {
         ipc::SharedMutex mutex;
         context_t ctx;
+        atomic_store(&ctx.init_latch, uatomic_t(0));
+        atomic_store(&ctx.start_latch, uatomic_t(0));
 
         printf("Testing simple multi-threaded mutex locks\n");
 
@@ -134,6 +156,8 @@ UTEST_BEGIN("runtime.ipc", shmutex)
         ctx.log(STATUS_OK, "start", STATUS_OK);
         t1.start();
         t2.start();
+        wait_latch(ctx.init_latch, 2);
+        atomic_add(&ctx.start_latch, 1);
 
         ctx.log(STATUS_OK, "sleep", STATUS_OK);
         ipc::Thread::sleep(200);
@@ -142,16 +166,16 @@ UTEST_BEGIN("runtime.ipc", shmutex)
         UTEST_ASSERT(mutex.unlock() == STATUS_OK);
 
         ipc::Thread::sleep(2000);
-        ctx.log(mutex.lock(), "SYNC3", STATUS_OK);
+        ctx.log(mutex.lock(), "SYNC3.lock", STATUS_OK);
         ctx.log(mutex.unlock(), "unlock", STATUS_OK);
 
         ctx.log(mutex.close(), "close", STATUS_OK);
 
         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;";
 
         printf("Result content:   %s\n", ctx.data.get_ascii());
         printf("Expected content: %s\n", expected);