[core.sync.mutex] Add a @safe ddoc-ed test and a @nogc nothrow one

Author: PetarKirov

src/core/sync/mutex.d

@@ -294,7 +294,85 @@ package:
     }
 }
 
+///
+/* @safe nothrow -> see druntime PR 1726 */
+unittest
+{
+    import core.thread : Thread;
+
+    class Resource
+    {
+        Mutex mtx;
+        int cargo;
+
+        this() shared @safe nothrow
+        {
+            mtx = new shared Mutex();
+            cargo = 42;
+        }
+
+        void useResource() shared @safe nothrow @nogc
+        {
+            mtx.lock_nothrow();
+            cargo++;
+            mtx.unlock_nothrow();
+        }
+    }
+
+    shared Resource res = new shared Resource();
+
+    auto otherThread = new Thread(
+    {
+        foreach (i; 0 .. 10000)
+            res.useResource();
+    }).start();
+
+    foreach (i; 0 .. 10000)
+        res.useResource();
+
+    otherThread.join();
 
+    assert (res.cargo == 20042);
+}
+
+@system @nogc nothrow unittest
+{
+    import core.stdc.stdlib : malloc, free;
+
+    void* p = malloc(__traits(classInstanceSize, Mutex));
+
+    auto ti = typeid(Mutex);
+    p[0 .. ti.initializer.length] = ti.initializer[];
+
+    shared Mutex mtx = cast(shared(Mutex))p;
+    mtx.__ctor();
+
+    mtx.lock_nothrow();
+
+    { // test recursive locking
+        mtx.tryLock_nothrow();
+        mtx.unlock_nothrow();
+    }
+
+    mtx.unlock_nothrow();
+
+    // In general destorying classes like this is not
+    // safe, but since we know that the only base class
+    // of Mutex is Object and it doesn't have a dtor
+    // we can simply call the non-virtual __dtor() here.
+
+    // Ok to cast away shared because destruction
+    // should happen only from a single thread.
+    (cast(Mutex)mtx).__dtor();
+
+    // Verify that the underlying implementation has been destroyed
+    // by checking that locking is not possible. This assumes
+    // that the underlying implementation is well behaved
+    // and makes the object non-lockable upon destruction.
+    assert(!mtx.tryLock_nothrow());
+
+    free(cast(void*)mtx);
+}
 
 unittest
 {