quack_concurrency 0.5.4 → 0.6.0

data/spec/queue_spec.rb

@@ -1,130 +1,270 @@
 require 'quack_concurrency'
 
-RSpec.describe QuackConcurrency::Queue do
-  
-  describe "#push" do
-  
-    context "when called many times when queue is not closed" do
-      it "should not raise error" do
+describe QuackConcurrency::Queue do
+
+  describe "::new" do
+
+    context "called with no arguments" do
+      it "should return a Queue" do
         queue = QuackConcurrency::Queue.new
-        expect{ queue.push(1) }.not_to raise_error
-        expect{ queue.push(2) }.not_to raise_error
+        expect(queue).to be_a(QuackConcurrency::Queue)
       end
     end
-    
+
   end
-  
-  describe "#pop" do
-  
-    context "when #pop is called with non_block set to true" do
-      it "should raise Error" do
+
+  describe "#clear" do
+
+    context "when called with some items in the Queue" do
+      it "should remove all the items" do
         queue = QuackConcurrency::Queue.new
-        expect{ queue.pop(true) }.to raise_error(ThreadError)
+        queue.push(1)
+        queue.push(2)
+        queue.clear
+        expect(queue.empty?).to be true
       end
     end
-    
+
   end
-  
-  describe "#close, #push" do
 
-    context "when called when queue is closed" do
-      it "should raise ClosedQueueError" do
+  describe "#close" do
+
+    context "when called" do
+      it "should close the Queue" do
         queue = QuackConcurrency::Queue.new
         queue.close
-        expect{ queue.push(1) }.to raise_error(ClosedQueueError)
+        expect(queue.closed?).to be true
+      end
+      it "should resume all threads waiting on the Queue" do
+        queue = QuackConcurrency::Queue.new
+        thread1 = Thread.new { queue.pop }
+        thread2 = Thread.new { queue.pop }
+        sleep 1
+        queue.close
+        sleep 1
+        expect(thread1.alive?).to be false
+        expect(thread2.alive?).to be false
       end
     end
-    
+
   end
-  
-  describe "#pop, #close" do
-  
-    context "when #pop is called after #close on empty queue" do
-      it "should reutrn nil" do
+
+  describe "#closed?" do
+
+    context "when called on non closed Queue" do
+      it "should return false" do
+        queue = QuackConcurrency::Queue.new
+        expect(queue.closed?).to be false
+      end
+    end
+
+    context "when called on a closed Queue" do
+      it "should return true" do
         queue = QuackConcurrency::Queue.new
         queue.close
-        expect(queue.pop).to eql nil
+        expect(queue.closed?).to be true
       end
     end
-    
+
   end
-  
-  describe "#pop, #close" do
-  
-    context "when #pop is called before #close on empty queue" do
-      it "should wait for #close then reutrn nil" do
+
+  describe "#empty?" do
+
+    context "when called on a empty Queue" do
+      it "should return false" do
         queue = QuackConcurrency::Queue.new
-        thread = Thread.new do
-          sleep 1
-          queue.close
-        end
-        start_time = Time.now
-        expect(queue.pop).to eql nil
-        end_time = Time.now
-        duration = end_time - start_time
+        expect(queue.empty?).to be true
+      end
+    end
+
+    context "when called on a non empty Queue" do
+      it "should return false" do
+        queue = QuackConcurrency::Queue.new
+        queue.push(1)
+        expect(queue.empty?).to be false
+      end
+    end
+
+  end
+
+  describe "#length" do
+
+    context "when called on a empty Queue" do
+      it "should return 1" do
+        queue = QuackConcurrency::Queue.new
+        expect(queue.length).to be 0
+      end
+    end
+
+    context "when called on a Queue with one item" do
+      it "should return 1" do
+        queue = QuackConcurrency::Queue.new
+        queue.push(1)
+        expect(queue.length).to be 1
+      end
+    end
+
+    context "when called on a Queue with two items" do
+      it "should return 2" do
+        queue = QuackConcurrency::Queue.new
+        queue.push(1)
+        queue.push(3)
+        expect(queue.length).to be 2
+      end
+    end
+
+  end
+
+  describe "#num_waiting" do
+
+    context "when called on a Queue with no thread waiting on it" do
+      it "should return 0" do
+        queue = QuackConcurrency::Queue.new
+        expect(queue.num_waiting).to be 0
+      end
+    end
+
+    context "when called on a Queue with a thread waiting on it" do
+      it "should return 1" do
+        queue = QuackConcurrency::Queue.new
+        thread = Thread.new { queue.pop }
+        sleep 1
+        expect(queue.num_waiting).to be 1
+        queue.close
         thread.join
-        expect(duration).to be > 0.5
       end
     end
-    
+
+    context "when called on a Queue with two threads waiting on it" do
+      it "should return 2" do
+        queue = QuackConcurrency::Queue.new
+        thread1 = Thread.new { queue.pop }
+        thread2 = Thread.new { queue.pop }
+        sleep 1
+        expect(queue.num_waiting).to be 2
+        queue.close
+        thread1.join
+        thread2.join
+      end
+    end
+
   end
-  
-  describe "#pop, #push, #close" do
-  
-    context "when #pop is called after #close on queue with one item" do
+
+  describe "#pop" do
+
+    context "when called on queue with one item" do
       it "should reutrn item" do
+        queue = QuackConcurrency::Queue.new
+        queue.push(1)
+        expect(queue.pop).to eql 1
+      end
+    end
+
+    context "when called before #close on empty queue" do
+      it "should wait for #close then reutrn nil" do
+        queue = QuackConcurrency::Queue.new
+        value = :not_set
+        thread = Thread.new { value = queue.pop }
+        sleep 1
+        expect(thread.alive?).to be true
+        queue.close
+        sleep 1
+        expect(value).to be nil
+      end
+    end
+
+    context "when called after #close on queue with one item" do
+      it "should reutrn item immediately" do
         queue = QuackConcurrency::Queue.new
         queue.push(1)
         queue.close
         expect(queue.pop).to eql 1
       end
     end
-    
-  end
-  
-  describe "#pop, #push" do
-  
-    context "when #pop is called before #push" do
+
+    context "when called on empty Queue with non_block set to true" do
+      it "should raise Error" do
+        queue = QuackConcurrency::Queue.new
+        expect{ queue.pop(true) }.to raise_error(ThreadError)
+      end
+    end
+
+    context "when called after #close on empty queue" do
+      it "should reutrn nil immediately" do
+        queue = QuackConcurrency::Queue.new
+        queue.close
+        expect(queue.pop).to eql nil
+      end
+    end
+
+    context "when called Queue with some items" do
+      it "should reutrn oldest item in the Queue" do
+        queue = QuackConcurrency::Queue.new
+        queue.push(1)
+        queue.push(3)
+        queue.push(2)
+        expect(queue.pop).to be 1
+        expect(queue.pop).to be 3
+        expect(queue.pop).to be 2
+      end
+    end
+
+    context "when called with other threads waiting on Queue" do
+      it "should reutrn items in the chronological order of calls to #pop" do
+        queue = QuackConcurrency::Queue.new
+        values = []
+        Thread.new { sleep 1; values << queue.pop }
+        Thread.new { sleep 2; values << queue.pop }
+        Thread.new { sleep 3; values << queue.pop }
+        sleep 4
+        queue.push(1)
+        queue.push(2)
+        queue.push(3)
+        sleep 1
+        expect(values).to eql [1, 2, 3]
+      end
+    end
+
+    context "when called before #push" do
       it "should wait until #push is called" do
-        $test = []
+        values = []
         queue = QuackConcurrency::Queue.new
         thread = Thread.new do
           queue.pop
-          $test << 1
+          values << 1
           sleep 1
           queue.push
         end
         sleep 1
         queue.push
         queue.pop
-        $test << 2
+        values << 2
         thread.join
-        expect($test).to eql [1, 2]
+        expect(values).to eql [1, 2]
       end
     end
-  
+
   end
-  
-  describe "#pop, #push, #clear" do
-  
-    context "when #pop is called after #push but before #clear" do
-      it "should wait until #push is called again" do
+
+  describe "#push" do
+
+    context "when called on non closed Queue" do
+      it "should add items to Queue" do
         queue = QuackConcurrency::Queue.new
         queue.push(1)
-        queue.clear
-        thread = Thread.new do
-          sleep 1
-          queue.push(2)
-        end
-        start_time = Time.now
-        expect(queue.pop).to eql 2
-        end_time = Time.now
-        duration = end_time - start_time
-        thread.join
-        expect(duration).to be > 0.5
+        queue.push(3)
+        expect(queue.length).to be 2
       end
     end
-  
+
+    context "when called on closed Queue" do
+      it "should raise ClosedQueueError" do
+        queue = QuackConcurrency::Queue.new
+        queue.close
+        expect{ queue.push(1) }.to raise_error(ClosedQueueError)
+      end
+    end
+
   end
-  
+
 end

data/spec/reentrant_mutex_spec.rb

@@ -1,167 +1,462 @@
 require 'quack_concurrency'
 
-RSpec.describe QuackConcurrency::ReentrantMutex do
-  
+describe QuackConcurrency::ReentrantMutex do
+
+  it "should inherit Mutex" do
+    expect(described_class).to be < QuackConcurrency::Mutex
+  end
+
+  describe "::new" do
+
+    context "when called with no arguments" do
+      it "should return a ReentrantMutex" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        expect(mutex).to be_a(QuackConcurrency::ReentrantMutex)
+      end
+    end
+
+  end
+
   describe "#lock" do
-  
-    context "when called for first time" do
+
+    context "when called when mutex is not locked" do
       it "should not raise error" do
         mutex = QuackConcurrency::ReentrantMutex.new
         expect { mutex.lock }.not_to raise_error
       end
     end
-    
-    context "when called a second time" do
+
+    context "when called when mutex is locked by this thread" do
       it "should not raise error" do
         mutex = QuackConcurrency::ReentrantMutex.new
         mutex.lock
         expect { mutex.lock }.not_to raise_error
       end
     end
-    
-  end
-  
-  describe "#lock, #unlock" do
-    
-    context "when #lock called on non owning thread" do
-      it "should wait for #unlock" do
+
+    context "when called when mutex is locked by another thread" do
+      it "should block until lock is available" do
         mutex = QuackConcurrency::ReentrantMutex.new
-        thread = Thread.new do
+        thread = Thread.new { sleep 1; mutex.lock }
+        mutex.lock
+        sleep 2
+        expect(thread.alive?).to be true
+        mutex.unlock
+        sleep 1
+        expect(thread.alive?).to be false
+      end
+      context "and another thread waiting on the mutex" do
+        it "should wake the threads in order of calling #lock" do
+          mutex = QuackConcurrency::ReentrantMutex.new
           mutex.lock
-          sleep 2
+          values = []
+          thread1 = Thread.new { mutex.lock { values << 1 } }
+          thread2 = Thread.new { sleep 1; mutex.lock { values << 2 } }
+          thread3 = Thread.new { sleep 2; mutex.lock { values << 3 } }
+          sleep 3
           mutex.unlock
+          sleep 1
+          expect(values).to eq [1, 2, 3]
         end
-        sleep 1
-        start_time = Time.now
-        mutex.lock
-        end_time = Time.now
-        duration = end_time - start_time
-        thread.join
-        expect(duration).to be > 0.5
       end
     end
-    
-    context "when #unlock called after one #lock" do
-      it "should not raise error" do
+
+    context "when called with a block" do
+      it "should run block and return it's value" do
         mutex = QuackConcurrency::ReentrantMutex.new
-        mutex.lock
-        expect { mutex.unlock }.not_to raise_error
+        expect(mutex.lock { :a }).to be :a
+      end
+      it "should pass up any error raised in the block" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        e = Class.new(StandardError)
+        expect{ mutex.lock { raise e } }.to raise_error(e)
+      end
+      it "should hold lock while block is executed" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        hold_thread = Thread.new { mutex.lock { sleep 3 } }
+        lock_thread = Thread.new { sleep 1; mutex.lock }
+        sleep 2
+        expect(lock_thread.alive?).to be true
+        hold_thread.join
+        lock_thread.join
+      end
+      it "should release the lock after the block has returned" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        Thread.new { mutex.lock { sleep 2 } }
+        lock_thread = Thread.new { sleep 1; mutex.lock }
+        sleep 3
+        expect(lock_thread.alive?).to be false
+      end
+      context "that raises an error" do
+        it "should release the lock after the block has returned" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          Thread.new do
+            mutex.lock { sleep 2; raise } rescue nil
+          end
+          lock_thread = Thread.new { sleep 1; mutex.lock }
+          sleep 3
+          expect(lock_thread.alive?).to be false
+        end
+      end
+      context "that locks the mutex" do
+        it "should raise ThreadError" do
+          mutex = QuackConcurrency::Mutex.new
+          expect{ mutex.lock { mutex.lock } }.to raise_error(ThreadError)
+        end
+      end
+      context "that unlocks the mutex" do
+        it "should raise ThreadError" do
+          mutex = QuackConcurrency::Mutex.new
+          expect{ mutex.lock { mutex.unlock } }.to raise_error(ThreadError)
+        end
+      end
+      context "that fully unlocks the mutex" do
+        it "should raise ThreadError" do
+          mutex = QuackConcurrency::Mutex.new
+          mutex.lock
+          expect{ mutex.lock { mutex.unlock; mutex.unlock } }.to raise_error(ThreadError)
+        end
       end
     end
-    
-    context "when #unlock called after two #locks" do
-      it "should not raise error" do
+
+    context "when called twice when mutex is not locked" do
+      it "should need to unlock twice before mutex is released" do
         mutex = QuackConcurrency::ReentrantMutex.new
+        thread = Thread.new { sleep 1; mutex.lock }
         mutex.lock
         mutex.lock
-        expect { mutex.unlock }.not_to raise_error
+        sleep 2
+        expect(thread.alive?).to be true
+        mutex.unlock
+        sleep 1
+        expect(thread.alive?).to be true
+        mutex.unlock
+        sleep 1
+        expect(thread.alive?).to be false
+      end
+    end
+
+  end
+
+  describe "#sleep" do
+
+    context "when called while not locking the mutex" do
+      it "should raise ThreadError" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        expect{ mutex.sleep }.to raise_error(ThreadError)
       end
     end
-    
-    context "when #unlock called twice after only one #lock" do
-      it "should raise error" do
+
+    context "when called" do
+      it "should relock the mutex after thread is woken" do
         mutex = QuackConcurrency::ReentrantMutex.new
-        mutex.lock
-        mutex.unlock
-        expect { mutex.unlock }.to raise_error(QuackConcurrency::ReentrantMutex::Error)
+        thread = Thread.new { mutex.lock { mutex.sleep; sleep 2 } }
+        sleep 1
+        thread.run
+        sleep 1
+        expect(mutex.locked?).to be true
+        thread.join
+      end
+    end
+
+    context "when called with no timeout" do
+      it "should return only after Thread#run is called" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        thread = Thread.new { mutex.lock { mutex.sleep } }
+        sleep 1
+        expect(thread.alive?).to be true
+        thread.run
+        sleep 1
+        expect(thread.alive?).to be false
       end
     end
-    
+
+    context "when called with a timeout" do
+      it "should return timeout reached" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        thread = Thread.new { mutex.lock { mutex.sleep(1) } }
+        sleep 2
+        expect(thread.alive?).to be false
+      end
+    end
+
+    context "when called while holding two locks" do
+      it "should acquire two locks after thread is woken" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        thread = Thread.new do
+          mutex.lock
+          mutex.lock
+          mutex.sleep(2)
+          sleep 2
+          mutex.unlock
+          sleep 2
+          mutex.unlock
+          sleep 2
+        end
+        sleep 1
+        expect(mutex.locked?).to be false
+        sleep 2
+        expect(mutex.locked?).to be true
+        sleep 2
+        expect(mutex.locked?).to be true
+        sleep 2
+        expect(mutex.locked?).to be false
+        thread.join
+      end
+    end
+
   end
-  
-  describe "#lock, #try_lock" do
-    
-    context "when #try_lock called" do
+
+  describe "#try_lock" do
+
+    context "when called when mutex is not locked by any thread" do
       it "should reutrn true" do
         mutex = QuackConcurrency::ReentrantMutex.new
         expect(mutex.try_lock).to eql true
       end
     end
-    
-    context "when #try_lock called after #lock called from other Thread" do
+
+    context "when called when mutex is locked by another thread" do
       it "should reutrn false" do
         mutex = QuackConcurrency::ReentrantMutex.new
-        thread = Thread.new { mutex.lock }
+        thread = Thread.new { mutex.lock; sleep 2 }
         sleep 1
         expect(mutex.try_lock).to eql false
       end
     end
-    
+
+    context "when called when mutex is locked by this thread" do
+      it "should reutrn true" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        mutex.lock
+        expect(mutex.try_lock).to eql true
+      end
+    end
+
   end
-  
-  describe "#lock, #try_lock, #unlock" do
-    
-    context "when #lock called after #try_lock called from other Thread" do
-      it "should wait for #unlock" do
+
+  describe "#unlock" do
+
+    context "when called when this thread does not hold a lock" do
+      it "should raise ThreadError" do
         mutex = QuackConcurrency::ReentrantMutex.new
-        thread = Thread.new do
-          mutex.try_lock
+        expect { mutex.unlock }.to raise_error(ThreadError)
+      end
+      context "after locking and unlocking" do
+        it "should raise ThreadError" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          mutex.lock
+          mutex.lock
+          mutex.unlock
+          mutex.unlock
+          expect { mutex.unlock }.to raise_error(ThreadError)
+        end
+      end
+    end
+
+    context "when called when this thread holds one lock" do
+      context "and with a thread waiting on the mutex" do
+        it "should wake the thread" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          mutex.lock
+          thread = Thread.new { mutex.lock }
+          sleep 1
+          mutex.unlock
+          sleep 1
+          expect(thread.alive?).to eql false
+          thread.join
+        end
+      end
+      context "and with no thread waiting on the mutex" do
+        it "should let another thread lock the mutex in the future" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          mutex.lock
+          thread = Thread.new { sleep 1; mutex.lock }
+          mutex.unlock
           sleep 2
+          expect(thread.alive?).to eql false
+        end
+      end
+    end
+
+    context "when called when this thread holds two locks" do
+      context "and with a thread waiting on the mutex" do
+        it "should not wake the thread until a second unlock" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          mutex.lock
+          mutex.lock
+          thread = Thread.new { mutex.lock }
+          sleep 1
+          mutex.unlock
+          sleep 1
+          expect(thread.alive?).to eql true
           mutex.unlock
+          sleep 1
+          expect(thread.alive?).to eql false
+          thread.join
         end
-        sleep 1
-        start_time = Time.now
+        context "and with no thread waiting on the mutex" do
+          it "should not let another thread lock the mutex in the future" do
+            mutex = QuackConcurrency::ReentrantMutex.new
+            mutex.lock
+            mutex.lock
+            thread = Thread.new { sleep 1; mutex.lock }
+            mutex.unlock
+            sleep 2
+            expect(thread.alive?).to eql true
+            mutex.unlock
+            thread.join
+          end
+        end
+      end
+    end
+
+    context "when called with a block" do
+      it "should run block and return it's value" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        mutex.lock
+        expect(mutex.unlock { :a }).to be :a
+      end
+      it "should pass up any error raised in the block" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        e = Class.new(StandardError)
         mutex.lock
-        end_time = Time.now
-        duration = end_time - start_time
+        expect{ mutex.unlock { raise e } }.to raise_error(e)
+      end
+      it "should release a lock while block is executed" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        thread = Thread.new do
+          mutex.lock { mutex.unlock { sleep 2 } }
+        end
+        sleep 1
+        expect(mutex.locked?).to be false
         thread.join
-        expect(duration).to be > 0.5
       end
-    end
-    
-  end
-  
-  describe "#synchronize" do
-    
-    context "when #synchronize called" do
-      it "should return last value from block" do
+      it "should reacquire the lock after the block has returned" do
         mutex = QuackConcurrency::ReentrantMutex.new
-        value = mutex.synchronize do
-          1
+        thread = Thread.new do
+          mutex.lock { mutex.unlock {}; sleep 2 }
+        end
+        sleep 1
+        expect(mutex.locked?).to be true
+        thread.join
+      end
+      context "that raises an error when no other thread is locking the mutex" do
+        it "should reacquire the lock after the block has returned" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          thread = Thread.new do
+            mutex.lock do
+              mutex.unlock { raise } rescue nil
+              sleep 2
+            end
+          end
+          sleep 1
+          expect(mutex.locked?).to be true
+          thread.join
+        end
+      end
+      context "that raises an error when another thread is locking the mutex" do
+        it "should raise ThreadError after the block has returned" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          thread = Thread.new { sleep 1; mutex.lock; sleep 2 }
+          mutex.lock
+          expect{ mutex.unlock { sleep 2; raise } }.to raise_error(ThreadError)
+          thread.join
         end
-        expect(value).to eql 1
       end
     end
-    
+
   end
-  
-  describe "#sleep" do
-    
-    context "when #sleep called with time argument" do
-      it "should wait for that time" do
+
+  describe "#unlock!" do
+
+    context "when called without a block" do
+      it "should raise ArgumentError" do
         mutex = QuackConcurrency::ReentrantMutex.new
-        start_time = Time.now
-        #require 'pry'
-        #binding.pry
-        mutex.synchronize do
-          mutex.sleep(1)
-        end
-        end_time = Time.now
-        duration = end_time - start_time
-        expect(duration).to be > 0.5
+        mutex.lock
+        expect{ mutex.unlock! }.to raise_error(ArgumentError)
       end
     end
-    
-    context "when #sleep called with no time argument" do
-      it "should wait until Thread is resumed" do
+
+    context "when called with a block" do
+      it "should run block and return it's value" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        mutex.lock
+        expect(mutex.unlock! { :a }).to be :a
+      end
+      it "should pass up any error raised in the block" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        e = Class.new(StandardError)
+        mutex.lock
+        expect{ mutex.unlock! { raise e } }.to raise_error(e)
+      end
+      it "should release a lock while block is executed" do
         mutex = QuackConcurrency::ReentrantMutex.new
-        start_time = nil
-        end_time = nil
         thread = Thread.new do
-          start_time = Time.now
-          mutex.synchronize do
-            mutex.sleep
-          end
-          end_time = Time.now
+          mutex.lock { mutex.unlock! { sleep 2 } }
         end
         sleep 1
-        thread.run
+        expect(mutex.locked?).to be false
+        thread.join
+      end
+      it "should reacquire the lock after the block has returned" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        thread = Thread.new do
+          mutex.lock { mutex.unlock! {}; sleep 2 }
+        end
+        sleep 1
+        expect(mutex.locked?).to be true
         thread.join
-        duration = end_time - start_time
-        expect(duration).to be > 0.5
+      end
+      context "while holding two locks" do
+        it "should acquire two locks after block reutrn" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          thread = Thread.new do
+            mutex.lock
+            mutex.lock
+            mutex.unlock! { sleep 2 }
+            sleep 2
+            mutex.unlock
+            sleep 2
+            mutex.unlock
+            sleep 2
+          end
+          sleep 1
+          expect(mutex.locked?).to be false
+          sleep 2
+          expect(mutex.locked?).to be true
+          sleep 2
+          expect(mutex.locked?).to be true
+          sleep 2
+          expect(mutex.locked?).to be false
+          thread.join
+        end
+      end
+      context "that raises an error when no other thread is locking the mutex" do
+        it "should reacquire the lock after the block has returned" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          thread = Thread.new do
+            mutex.lock do
+              mutex.unlock! { raise } rescue nil
+              sleep 2
+            end
+          end
+          sleep 1
+          expect(mutex.locked?).to be true
+          thread.join
+        end
+      end
+      context "that raises an error when another thread is locking the mutex" do
+        it "should raise ThreadError after the block has returned" do
+          mutex = QuackConcurrency::ReentrantMutex.new
+          thread = Thread.new { sleep 1; mutex.lock; sleep 2 }
+          mutex.lock
+          expect{ mutex.unlock! { sleep 2; raise } }.to raise_error(ThreadError)
+          thread.join
+        end
       end
     end
-    
+
   end
-  
+
 end