quack_concurrency 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1e1b4dcf29faab53b77b05eb8017b8b73c339829
-  data.tar.gz: 85e7852afdcad9dba9fab2b264104844ebd54ad9
+SHA256:
+  metadata.gz: 164e219c34134cf836d5a4169272a1f6185d832790ae69c29ad4dd4496a2af0f
+  data.tar.gz: e4f01597b27e39da0e1d916228abe30764b5b8b30a3d68d90fabea53635a5d10
 SHA512:
-  metadata.gz: b934eb948f2cb2a9a7565db507d83130e14363b3ab2e816f590f06ef8d9ccdeff8c3f6e655e4dcf9878f77f1311fcb0ff95ee092cdd881c26ea6e66840cb7c1c
-  data.tar.gz: 27891264874dd9a5083dcb7e9ac10a18665eeb7d538b10caa6471e69bda84c3c93996b3f9d49e4b602f70fe94593a41edb001c77e46b38deb6dad77ec75dee84
+  metadata.gz: 94ffaae9048528509d569619625ce1288ac16de3015f70fd92f08f52309ee3c15f91b07f1d1eb5bb5fb3b4ab6edd5022cd919c84f9a98672b04adb2e91d40686
+  data.tar.gz: 26da3552b5b6b17d4f60f0427f7fa9a1b081edeab9df71cd7760c236e5edb69bad1a491d3185aa91e79329a688279ac21062fc0882566f927f1cb9b35850dc6e

data/lib/quack_concurrency/concurrency_tool.rb

@@ -0,0 +1,26 @@
+module QuackConcurrency
+  class ConcurrencyTool
+    
+    def setup_duck_types(supplied_classes)
+      resultant_classes = {}
+      required_classes = [:condition_variable, :mutex]
+      required_classes = required_classes.map { |name| Name.new(name.to_s) }
+      if supplied_classes
+        raise ArgumentError, "'supplied_classes' must be Hash" unless supplied_classes.is_a?(Hash)
+        supplied_classes = supplied_classes.map { |k, v| [Name.new(k.to_s), v] }.to_h
+        required_classes.each do |class_name|
+          unless supplied_classes[class_name]
+            raise ArgumentError, "missing duck type: #{class_name.camel_case(:upper)}"
+          end
+          resultant_classes[class_name.snake_case.to_sym] = supplied_classes[class_name]
+        end
+      else
+        required_classes.each do |class_name|
+          resultant_classes[class_name.snake_case.to_sym] = Object.const_get(class_name.camel_case(:upper))
+        end
+      end
+      resultant_classes
+    end
+    
+  end
+end

data/lib/quack_concurrency/error.rb

@@ -0,0 +1,5 @@
+module QuackConcurrency
+  class Error < StandardError
+  end
+end
+    

data/lib/quack_concurrency/future/canceled.rb

@@ -0,0 +1,6 @@
+module QuackConcurrency
+  class Future
+    class Canceled < Error
+    end
+  end
+end

data/lib/quack_concurrency/future/complete.rb

@@ -0,0 +1,6 @@
+module QuackConcurrency
+  class Future
+    class Complete < Error
+    end
+  end
+end

data/lib/quack_concurrency/future.rb

@@ -1,14 +1,10 @@
 module QuackConcurrency
-  class Future
-  
-    class Canceled < StandardError
-    end
+  class Future < ConcurrencyTool
     
-    def initialize(duck_types: {})
-      condition_variable_class = duck_types[:condition_variable] || ConditionVariable
-      mutex_class = duck_types[:mutex] || Mutex
-      @condition_variable = condition_variable_class.new
-      @mutex = mutex_class.new
+    def initialize(duck_types: nil)
+      classes = setup_duck_types(duck_types)
+      @condition_variable = classes[:condition_variable].new
+      @mutex = classes[:mutex].new
       @value = nil
       @value_set = false
       @complete = false
@@ -16,18 +12,19 @@ module QuackConcurrency
     
     def set(new_value = nil)
       @mutex.synchronize do
-        raise if @complete
+        raise Complete if @complete
         @value_set = true
         @complete = true
         @value = new_value
         @condition_variable.broadcast
       end
+      nil
     end
     
     def get
       @mutex.synchronize do
         @condition_variable.wait(@mutex) unless complete?
-        raise 'should not get here' unless complete?
+        raise 'internal error, invalid state' unless complete?
         raise Canceled unless @value_set
         @value
       end
@@ -35,9 +32,11 @@ module QuackConcurrency
     
     def cancel
       @mutex.synchronize do
-        raise if @complete
+        raise Complete if @complete
         @complete = true
+        @condition_variable.broadcast
       end
+      nil
     end
     
     def complete?

data/lib/quack_concurrency/name.rb

@@ -0,0 +1,31 @@
+module QuackConcurrency
+  class Name < String
+    
+    def initialize(*args)
+      super
+      # set all names to a default case
+      # if we create two of the same name with different cases they will now be equal
+      replace(snake_case)
+    end
+    
+    def camel_case(first_letter = :upper)
+      case first_letter
+      when :upper
+        self.split('_').collect(&:capitalize).join
+      when :lower
+        self.camelcase(:upper)[0].downcase + self.camelcase(:upper)[1..-1]
+      else
+        raise ArgumentError, 'invalid option, use either :upper or :lower'
+      end
+    end
+    
+    def snake_case
+      self.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("- ", "_").
+      downcase
+    end
+    
+  end
+end

data/lib/quack_concurrency/queue.rb

@@ -1,11 +1,10 @@
 module QuackConcurrency
-  class Queue
+  class Queue < ConcurrencyTool
   
-    def initialize(duck_types: {})
-      condition_variable_class = duck_types[:condition_variable] || ConditionVariable
-      mutex_class = duck_types[:mutex] || Mutex
-      @condition_variable = condition_variable_class.new
-      @mutex = mutex_class.new
+    def initialize(duck_types: nil)
+      classes = setup_duck_types(duck_types)
+      @condition_variable = classes[:condition_variable].new
+      @mutex = classes[:mutex].new
       @queue = []
       @waiting_count = 0
       @closed = false

data/lib/quack_concurrency/reentrant_mutex/error.rb

@@ -0,0 +1,6 @@
+module QuackConcurrency
+  class ReentrantMutex
+    class Error < Error
+    end
+  end
+end

data/lib/quack_concurrency/reentrant_mutex.rb

@@ -1,14 +1,12 @@
 # based off https://en.wikipedia.org/wiki/Reentrant_mutex
 
 module QuackConcurrency
-  class ReentrantMutex
+  class ReentrantMutex < ConcurrencyTool
   
-    def initialize(duck_types: {})
-      condition_variable_class = duck_types[:condition_variable] || ConditionVariable
-      @kernel_module = duck_types[:kernel] || Kernel
-      mutex_class = duck_types[:mutex] || Mutex
-      @condition_variable = condition_variable_class.new
-      @mutex = mutex_class.new
+    def initialize(duck_types: nil)
+      classes = setup_duck_types(duck_types)
+      @condition_variable = classes[:condition_variable].new
+      @mutex = classes[:mutex].new
       @owner = nil
       @lock_depth = 0
     end
@@ -16,6 +14,7 @@ module QuackConcurrency
     def lock
       @mutex.synchronize do
         @condition_variable.wait(@mutex) if @owner && @owner != caller
+        raise 'internal error, invalid state' if @owner && @owner != caller 
         @owner = caller
         @lock_depth += 1
       end
@@ -34,14 +33,16 @@ module QuackConcurrency
       @owner == caller
     end
     
-    def sleep(timeout = nil)
+    def sleep(*args)
       unlock
-      if timeout
-        @kernel_module.sleep(timeout)
-      else
-        @kernel_module.sleep
+      # i would rather not need to get a ducktype for sleep so we will just take
+      #   advantage of Mutex's sleep method that must take it into account already
+      @mutex.synchronize do
+        @mutex.sleep(*args)
       end
-      lock
+      nil
+    ensure
+      lock unless owned?
     end
     
     def synchronize
@@ -52,27 +53,24 @@ module QuackConcurrency
       result
     ensure
       unless @lock_depth == start_depth && @owner == start_owner
-        raise 'could not unlock mutex as its state has been modified'
+        raise Error, 'could not unlock reentrant mutex as its state has been modified'
       end
       unlock
     end
     
     def try_lock
       @mutex.synchronize do
-        if @owner && @owner != caller
-          return false
-        else
-          @owner = caller
-          @lock_depth += 1
-        end
+        return false if @owner && @owner != caller
+        @owner = caller
+        @lock_depth += 1
+        true
       end
-      true
     end
     
     def unlock
       @mutex.synchronize do
-        raise "not locked" if @lock_depth == 0
-        raise "not the owner" unless @owner == caller
+        raise Error, 'can not unlock reentrant mutex, it is not locked' if @lock_depth == 0
+        raise Error, 'can not unlock reentrant mutex, caller is not the owner' unless @owner == caller
         @lock_depth -= 1
         if @lock_depth == 0
           @owner = nil

data/lib/quack_concurrency/semaphore/error.rb

@@ -0,0 +1,6 @@
+module QuackConcurrency
+  class Semaphore
+    class Error < Error
+    end
+  end
+end

data/lib/quack_concurrency/semaphore.rb

@@ -1,30 +1,52 @@
 module QuackConcurrency
-  class Semaphore
+  class Semaphore < ConcurrencyTool
   
     attr_reader :permit_count
     
-    def initialize(permit_count = 1, duck_types: {})
-      condition_variable_class = duck_types[:condition_variable] || ConditionVariable
-      raise 'permit_count invalid' if permit_count < 1
+    def initialize(permit_count = 1, duck_types: nil)
+      classes = setup_duck_types(duck_types)
+      @condition_variable = classes[:condition_variable].new
+      verify_permit_count(permit_count)
       @permit_count = permit_count
       @permits_used = 0
-      @condition_variable = condition_variable_class.new
       @mutex = ReentrantMutex.new(duck_types: duck_types)
     end
     
-    def acquire
+    def permit_available?
+      permits_available >= 1
+    end
+    
+    def permits_available
+      @mutex.synchronize do
+        raw_permits_available = @permit_count - @permits_used
+        raw_permits_available.positive? ? raw_permits_available : 0
+      end
+    end
+    
+    def reacquire
+      @mutex.synchronize do
+        raise Error, 'can not reacquire a permit, no permits released right now' if @permits_used == 0
+        @permits_used -= 1
+        @condition_variable.signal if permit_available?
+      end
+      nil
+    end
+    
+    def release
       @mutex.synchronize do
         @condition_variable.wait(@mutex) unless permit_available?
+        raise 'internal error, invalid state' unless permit_available?
         @permits_used += 1
       end
       nil
     end
     
     def set_permit_count(new_permit_count)
+      verify_permit_count(new_permit_count)
       @mutex.synchronize do
         remove_permits = @permit_count - new_permit_count
         if remove_permits.positive? && remove_permits > permits_available
-          raise 'can not remove enough permits right not'
+          raise Error, 'can not set new permit count, not enough permits available to remove right now'
         end
         set_permit_count!(new_permit_count)
       end
@@ -32,7 +54,7 @@ module QuackConcurrency
     end
     
     def set_permit_count!(new_permit_count)
-      raise "'permit_count' invalid" if new_permit_count < 1
+      verify_permit_count(new_permit_count)
       @mutex.synchronize do
         new_permits = new_permit_count - @permit_count
         if new_permits.positive?
@@ -45,42 +67,44 @@ module QuackConcurrency
       nil
     end
     
-    def release
-      @mutex.synchronize do
-        raise 'no pemit to release' if @permits_used == 0
-        @permits_used -= 1
-        @condition_variable.signal if permit_available?
+    def synchronize
+      release
+      begin
+        yield
+      ensure
+        reacquire
       end
-      nil
     end
     
-    # how to handle if yield raises an error but has temporarily released its permit?
-    #def synchronize
-    #  acquire
-    #  begin
-    #    yield
-    #  ensure
-    #    release
-    #  end
-    #end
-    
-    def permits_available
-      @mutex.synchronize { @permit_count - @permits_used }
-    end
-    
-    def permit_available?
-      @mutex.synchronize { permits_available >= 1 }
+    def try_release
+      @mutex.synchronize do
+        if permit_available?
+          release
+          true
+        else
+          false
+        end
+      end
     end
     
     private
     
     def add_permit
       @permit_count += 1
-      @condition_variable.signal
+      @condition_variable.signal if permit_available?
+      nil
     end
     
     def remove_permit!
       @permit_count -= 1
+      raise 'internal error, invalid state' if @permit_count < 0
+      nil
+    end
+    
+    def verify_permit_count(permit_count)
+      unless permit_count.is_a?(Integer) && permit_count >= 0
+        raise ArgumentError, "'permit_count' must be a non negative Integer"
+      end
     end
     
   end

data/lib/quack_concurrency/waiter.rb

@@ -1,7 +1,7 @@
 module QuackConcurrency
-  class Waiter
+  class Waiter < ConcurrencyTool
   
-    def initialize(duck_types: {})
+    def initialize(duck_types: nil)
       @queue = Queue.new(duck_types: duck_types)
     end
     

data/lib/quack_concurrency.rb

@@ -1,11 +1,27 @@
 require 'thread'
 
+require 'quack_concurrency/concurrency_tool'
+require 'quack_concurrency/error'
 require 'quack_concurrency/future'
+require 'quack_concurrency/name'
 require 'quack_concurrency/queue'
 require 'quack_concurrency/reentrant_mutex'
 require 'quack_concurrency/semaphore'
 require 'quack_concurrency/waiter'
+require 'quack_concurrency/future/canceled'
+require 'quack_concurrency/future/complete'
+require 'quack_concurrency/reentrant_mutex/error'
+require 'quack_concurrency/semaphore/error'
+
+
+# if you pass a duck type Hash to any of the concurrency tools it will force you to
+#  supply all the required ducktypes, all or nothing, as it were
+# this is to protect against forgetting to pass one of the duck types as this
+#   would be a hard bug to solve otherwise
 
 
 module QuackConcurrency
+  
+  ClosedQueueError = ::ClosedQueueError
+  
 end

data/spec/future_spec.rb

@@ -0,0 +1,145 @@
+require 'quack_concurrency'
+
+RSpec.describe QuackConcurrency::Future do
+  
+  describe "::new" do
+  
+    context "when called without a 'duck_types' argument" do
+      it "should create a new QuackConcurrency::Future" do
+        future = QuackConcurrency::Future.new
+        expect(future).to be_a(QuackConcurrency::Future)
+      end
+    end
+    
+    context "when called with 'condition_variable' and 'mutex' duck types" do
+      it "should create a new QuackConcurrency::Future" do
+        duck_types = {condition_variable: Class.new, mutex: Class.new}
+        future = QuackConcurrency::Future.new(duck_types: duck_types)
+        expect(future).to be_a(QuackConcurrency::Future)
+      end
+    end
+    
+    context "when called with only 'condition_variable' duck type" do
+      it "should raise ArgumentError" do
+        duck_types = {condition_variable: Class.new}
+        expect{ QuackConcurrency::Future.new(duck_types: duck_types) }.to raise_error(ArgumentError)
+      end
+    end
+    
+    context "when called with only 'mutex' duck type" do
+      it "should raise ArgumentError" do
+        duck_types = {mutex: Class.new}
+        expect{ QuackConcurrency::Future.new(duck_types: duck_types) }.to raise_error(ArgumentError)
+      end
+    end
+    
+  end
+  
+  describe "#set" do
+  
+    context "when called" do
+      it "should not raise error" do
+        future = QuackConcurrency::Future.new
+        expect{ future.set(1) }.not_to raise_error
+      end
+    end
+    
+    context "when called a second time" do
+      it "should raise QuackConcurrency::Future::Complete" do
+        future = QuackConcurrency::Future.new
+        future.set(1)
+        expect{ future.set(2) }.to raise_error(QuackConcurrency::Future::Complete)
+      end
+    end
+    
+  end
+  
+  describe "#cancel" do
+  
+    context "when called" do
+      it "should not raise error" do
+        future = QuackConcurrency::Future.new
+        expect{ future.cancel }.not_to raise_error
+      end
+    end
+    
+    context "when called a second time" do
+      it "should raise QuackConcurrency::Future::Complete" do
+        future = QuackConcurrency::Future.new
+        future.cancel
+        expect{ future.cancel }.to raise_error(QuackConcurrency::Future::Complete)
+      end
+    end
+    
+  end
+  
+  describe "#set, #get" do
+  
+    context "when #get called after #set" do
+      it "should return value from #set argument" do
+        future = QuackConcurrency::Future.new
+        future.set(1)
+        expect(future.get).to eql 1
+      end
+    end
+    
+    context "when #get called a second time" do
+      it "should return value from #set argument" do
+        future = QuackConcurrency::Future.new
+        future.set(1)
+        future.get
+        expect(future.get).to eql 1
+      end
+    end
+    
+    context "when #get called before #set" do
+      it "should wait and return value from #set argument after #set is called" do
+        future = QuackConcurrency::Future.new
+        thread = Thread.new do
+          sleep 1
+          future.set 1
+        end
+        start_time = Time.now
+        expect(future.get).to eql 1
+        end_time = Time.now
+        duration = end_time - start_time
+        thread.join
+        expect(duration).to be > 0.5
+      end
+    end
+    
+  end
+  
+  describe "#set, #cancel" do
+  
+    context "when #set called after #cancel" do
+      it "should raise QuackConcurrency::Future::Complete" do
+        future = QuackConcurrency::Future.new
+        future.cancel
+        expect{ future.set(1) }.to raise_error(QuackConcurrency::Future::Complete)
+      end
+    end
+    
+    context "when #cancel called after #set" do
+      it "should raise QuackConcurrency::Future::Complete" do
+        future = QuackConcurrency::Future.new
+        future.set(1)
+        expect{ future.cancel }.to raise_error(QuackConcurrency::Future::Complete)
+      end
+    end
+    
+  end
+  
+  describe "#get, #cancel" do
+  
+    context "when #get called after #cancel" do
+      it "should raise QuackConcurrency::Future::Canceled" do
+        future = QuackConcurrency::Future.new
+        future.cancel
+        expect{ future.get }.to raise_error(QuackConcurrency::Future::Canceled)
+      end
+    end
+    
+  end
+  
+end

data/spec/queue_spec.rb

@@ -2,50 +2,151 @@ require 'quack_concurrency'
 
 RSpec.describe QuackConcurrency::Queue do
   
-  describe "pop" do
+  describe "::new" do
   
-    context "when called when queue empty" do
-      it "should wait" do
-        $test = []
+    context "when called without a 'duck_types' argument" do
+      it "should create a new QuackConcurrency::Queue" do
+        queue = QuackConcurrency::Queue.new
+        expect(queue).to be_a(QuackConcurrency::Queue)
+      end
+    end
+    
+    context "when called with 'condition_variable' and 'mutex' duck types" do
+      it "should create a new QuackConcurrency::Queue" do
+        duck_types = {condition_variable: Class.new, mutex: Class.new}
+        queue = QuackConcurrency::Queue.new(duck_types: duck_types)
+        expect(queue).to be_a(QuackConcurrency::Queue)
+      end
+    end
+    
+    context "when called with only 'condition_variable' duck type" do
+      it "should raise ArgumentError" do
+        duck_types = {condition_variable: Class.new}
+        expect{ QuackConcurrency::Queue.new(duck_types: duck_types) }.to raise_error(ArgumentError)
+      end
+    end
+    
+    context "when called with only 'mutex' duck type" do
+      it "should raise ArgumentError" do
+        duck_types = {mutex: Class.new}
+        expect{ QuackConcurrency::Queue.new(duck_types: duck_types) }.to raise_error(ArgumentError)
+      end
+    end
+    
+  end
+  
+  describe "#push" do
+  
+    context "when called many times when queue is not closed" do
+      it "should not raise error" do
+        queue = QuackConcurrency::Queue.new
+        expect{ queue.push(1) }.not_to raise_error
+        expect{ queue.push(2) }.not_to raise_error
+      end
+    end
+    
+  end
+  
+  describe "#close, #push" do
+
+    context "when called when queue is closed" do
+      it "should raise ClosedQueueError" do
+        queue = QuackConcurrency::Queue.new
+        queue.close
+        expect{ queue.push(1) }.to raise_error(ClosedQueueError)
+      end
+    end
+    
+  end
+  
+  describe "#pop, #close" do
+  
+    context "when #pop is called after #close on empty queue" do
+      it "should reutrn nil" do
+        queue = QuackConcurrency::Queue.new
+        queue.close
+        expect(queue.pop).to eql nil
+      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
         queue = QuackConcurrency::Queue.new
         thread = Thread.new do
-          queue.pop
-          $test << 1
           sleep 1
-          queue.push
+          queue.close
         end
-        sleep 1
-        queue.push
-        queue.pop
-        $test << 2
+        start_time = Time.now
+        expect(queue.pop).to eql nil
+        end_time = Time.now
+        duration = end_time - start_time
         thread.join
-        expect($test).to eql [1, 2]
+        expect(duration).to be > 0.5
       end
     end
     
-    context "when called when queue not empty" do
-      it "should immediately return" do
+  end
+  
+  describe "#pop, #push, #close" do
+  
+    context "when #pop is called after #close on queue with one item" do
+      it "should reutrn item" 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
+      it "should wait until #push is called" do
         $test = []
         queue = QuackConcurrency::Queue.new
-        queue.push
         thread = Thread.new do
           queue.pop
           $test << 1
+          sleep 1
+          queue.push
         end
         sleep 1
+        queue.push
+        queue.pop
         $test << 2
         thread.join
         expect($test).to eql [1, 2]
       end
     end
-    
-    context "when called" do
-      it "should return value of the push" do
+  
+  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
         queue = QuackConcurrency::Queue.new
-        queue.push 1
-        expect(queue.pop).to eql 1
+        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
       end
     end
-    
+  
   end
+  
 end

data/spec/reentrant_mutex_spec.rb

@@ -2,7 +2,40 @@ require 'quack_concurrency'
 
 RSpec.describe QuackConcurrency::ReentrantMutex do
   
-  describe "lock" do
+  describe "::new" do
+  
+    context "when called without a 'duck_types' argument" do
+      it "should create a new QuackConcurrency::ReentrantMutex" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        expect(mutex).to be_a(QuackConcurrency::ReentrantMutex)
+      end
+    end
+    
+    context "when called with 'condition_variable' and 'mutex' duck types" do
+      it "should create a new QuackConcurrency::ReentrantMutex" do
+        duck_types = {condition_variable: Class.new, mutex: Class.new}
+        mutex = QuackConcurrency::ReentrantMutex.new(duck_types: duck_types)
+        expect(mutex).to be_a(QuackConcurrency::ReentrantMutex)
+      end
+    end
+    
+    context "when called with only 'condition_variable' duck type" do
+      it "should raise ArgumentError" do
+        duck_types = {condition_variable: Class.new}
+        expect{ QuackConcurrency::ReentrantMutex.new(duck_types: duck_types) }.to raise_error(ArgumentError)
+      end
+    end
+    
+    context "when called with only 'mutex' duck type" do
+      it "should raise ArgumentError" do
+        duck_types = {mutex: Class.new}
+        expect{ QuackConcurrency::ReentrantMutex.new(duck_types: duck_types) }.to raise_error(ArgumentError)
+      end
+    end
+    
+  end
+  
+  describe "#lock" do
   
     context "when called for first time" do
       it "should not raise error" do
@@ -11,7 +44,7 @@ RSpec.describe QuackConcurrency::ReentrantMutex do
       end
     end
     
-    context "when called the second time" do
+    context "when called a second time" do
       it "should not raise error" do
         mutex = QuackConcurrency::ReentrantMutex.new
         mutex.lock
@@ -19,29 +52,29 @@ RSpec.describe QuackConcurrency::ReentrantMutex do
       end
     end
     
-    context "when called on non owning thread" do
-      it "should wait" do
-        $test = []
+  end
+  
+  describe "#lock, #unlock" do
+    
+    context "when #lock called on non owning thread" do
+      it "should wait for #unlock" do
         mutex = QuackConcurrency::ReentrantMutex.new
         thread = Thread.new do
-          sleep 1
           mutex.lock
-          $test << 2
+          sleep 2
+          mutex.unlock
         end
+        sleep 1
+        start_time = Time.now
         mutex.lock
-        sleep 2
-        $test << 1
-        mutex.unlock
+        end_time = Time.now
+        duration = end_time - start_time
         thread.join
-        expect($test).to eql [1, 2]
+        expect(duration).to be > 0.5
       end
     end
     
-  end
-  
-  describe "unlock" do
-  
-    context "when called after one lock" do
+    context "when #unlock called after one #lock" do
       it "should not raise error" do
         mutex = QuackConcurrency::ReentrantMutex.new
         mutex.lock
@@ -49,7 +82,7 @@ RSpec.describe QuackConcurrency::ReentrantMutex do
       end
     end
     
-    context "when called after two locks" do
+    context "when #unlock called after two #locks" do
       it "should not raise error" do
         mutex = QuackConcurrency::ReentrantMutex.new
         mutex.lock
@@ -58,14 +91,108 @@ RSpec.describe QuackConcurrency::ReentrantMutex do
       end
     end
     
-    context "when called twice after only one lock" do
+    context "when #unlock called twice after only one #lock" do
       it "should raise error" do
         mutex = QuackConcurrency::ReentrantMutex.new
         mutex.lock
         mutex.unlock
-        expect { mutex.unlock }.to raise_error(RuntimeError)
+        expect { mutex.unlock }.to raise_error(QuackConcurrency::ReentrantMutex::Error)
       end
     end
     
   end
+  
+  describe "#lock, #try_lock" do
+    
+    context "when #try_lock called" 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
+      it "should reutrn false" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        thread = Thread.new { mutex.lock }
+        sleep 1
+        expect(mutex.try_lock).to eql false
+      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
+        mutex = QuackConcurrency::ReentrantMutex.new
+        thread = Thread.new do
+          mutex.try_lock
+          sleep 2
+          mutex.unlock
+        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
+    
+  end
+  
+  describe "#synchronize" do
+    
+    context "when #synchronize called" do
+      it "should return last value from block" do
+        mutex = QuackConcurrency::ReentrantMutex.new
+        value = mutex.synchronize do
+          1
+        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
+        mutex = QuackConcurrency::ReentrantMutex.new
+        start_time = Time.now
+        mutex.synchronize do
+          mutex.sleep(1)
+        end
+        end_time = Time.now
+        duration = end_time - start_time
+        expect(duration).to be > 0.5
+      end
+    end
+    
+    context "when #sleep called with no time argument" do
+      it "should wait until Thread is resumed" 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
+        end
+        sleep 1
+        thread.run
+        thread.join
+        duration = end_time - start_time
+        expect(duration).to be > 0.5
+      end
+    end
+    
+  end
+  
 end

data/spec/semaphore_spec.rb

@@ -2,26 +2,276 @@ require 'quack_concurrency'
 
 RSpec.describe QuackConcurrency::Semaphore do
   
-  describe "acquire" do
+  describe "::new" do
   
-    context "when no permits are available" do
-      it "should wait" do
-        $test = []
+    context "when called without a 'duck_types' argument" do
+      it "should create a new QuackConcurrency::Semaphore" do
+        semaphore = QuackConcurrency::Semaphore.new
+        expect(semaphore).to be_a(QuackConcurrency::Semaphore)
+      end
+    end
+    
+    context "when called with 'condition_variable' and 'mutex' duck types" do
+      it "should create a new QuackConcurrency::Semaphore" do
+        duck_types = {condition_variable: Class.new, mutex: Class.new}
+        semaphore = QuackConcurrency::Semaphore.new(duck_types: duck_types)
+        expect(semaphore).to be_a(QuackConcurrency::Semaphore)
+      end
+    end
+    
+    context "when called with only 'condition_variable' duck type" do
+      it "should raise ArgumentError" do
+        duck_types = {condition_variable: Class.new}
+        expect{ QuackConcurrency::Semaphore.new(duck_types: duck_types) }.to raise_error(ArgumentError)
+      end
+    end
+    
+    context "when called with only 'mutex' duck type" do
+      it "should raise ArgumentError" do
+        duck_types = {mutex: Class.new}
+        expect{ QuackConcurrency::Semaphore.new(duck_types: duck_types) }.to raise_error(ArgumentError)
+      end
+    end
+    
+  end
+  
+  describe "#release" do
+  
+    context "when called for the first time with many permits available" do
+      it "should not raise error" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        
+        expect{ semaphore.release }.not_to raise_error
+      end
+    end
+    
+    context "when called a second time with one permit available" do
+      it "should not raise error" do
         semaphore = QuackConcurrency::Semaphore.new(2)
+        semaphore.release
+        expect{ semaphore.release }.not_to raise_error
+      end
+    end
+  
+  end
+  
+  describe "#release, #reacquire" do
+    
+    context "when #release called with no permits available" do
+      it "should wait until #reacquire is called" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        semaphore.release
+        semaphore.release
         thread = Thread.new do
           sleep 1
-          semaphore.acquire
-          $test << 2
+          semaphore.reacquire
         end
-        semaphore.acquire
-        semaphore.acquire
-        sleep 2
-        $test << 1
+        start_time = Time.now
         semaphore.release
+        end_time = Time.now
+        duration = end_time - start_time
         thread.join
-        expect($test).to eql [1, 2]
+        expect(duration).to be > 0.5
+      end
+    end
+    
+    context "when #reacquire called when all permits are available" do
+      it "should raise QuackConcurrency::Semaphore::Error" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        expect{ semaphore.reacquire }.to raise_error(QuackConcurrency::Semaphore::Error)
+      end
+    end
+    
+  end
+  
+  describe "#release, #reacquire, #permit_available?, #permits_available" do
+  
+    context "#permit_available? and #permits_available" do
+      it "should work as expected" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        expect(semaphore.permit_available?).to eql true
+        expect(semaphore.permits_available).to eql 2
+        semaphore.release
+        expect(semaphore.permit_available?).to eql true
+        expect(semaphore.permits_available).to eql 1
+        semaphore.release
+        expect(semaphore.permit_available?).to eql false
+        expect(semaphore.permits_available).to eql 0
+        semaphore.reacquire
+        expect(semaphore.permit_available?).to eql true
+        expect(semaphore.permits_available).to eql 1
+        semaphore.reacquire
+        expect(semaphore.permit_available?).to eql true
+        expect(semaphore.permits_available).to eql 2
+      end
+    end
+    
+  end
+  
+  describe "#set_permit_count, #permits_available" do
+  
+    context "when #set_permit_count is called with more permits then currently exist" do
+      it "should add permits" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        expect(semaphore.permits_available).to eql 2
+        semaphore.set_permit_count(3)
+        expect(semaphore.permits_available).to eql 3
+      end
+    end
+    
+    context "when #set_permit_count is called with less permits then currently exist" do
+      it "should remove permits" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        expect(semaphore.permits_available).to eql 2
+        semaphore.set_permit_count(1)
+        expect(semaphore.permits_available).to eql 1
+      end
+    end
+  
+  end
+  
+  describe "#set_permit_count, #permits_available, #release" do
+    
+    context "when #set_permit_count is called with less permits then currently available" do
+      it "should raise QuackConcurrency::Semaphore::Error" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        expect(semaphore.permits_available).to eql 2
+        semaphore.release
+        semaphore.release
+        expect{ semaphore.set_permit_count(1) }.to raise_error(QuackConcurrency::Semaphore::Error)
       end
     end
     
   end
+  
+  describe "#set_permit_count, #release" do
+  
+    context "when #set_permit_count is called with more permits when one thread is waiting on #release" do
+      it "should resume the thread" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        semaphore.release
+        semaphore.release
+        thread = Thread.new do
+          sleep 1
+          semaphore.set_permit_count(3)
+        end
+        start_time = Time.now
+        semaphore.release
+        end_time = Time.now
+        duration = end_time - start_time
+        thread.join
+        expect(duration).to be > 0.5
+      end
+    end
+    
+  end
+  
+  describe "#set_permit_count!, #permits_available" do
+  
+    context "when #set_permit_count! is called with more permits then currently exist" do
+      it "should add permits" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        expect(semaphore.permits_available).to eql 2
+        semaphore.set_permit_count!(3)
+        expect(semaphore.permits_available).to eql 3
+      end
+    end
+    
+    context "when #set_permit_count! is called with less permits then currently exist" do
+      it "should remove permits" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        expect(semaphore.permits_available).to eql 2
+        semaphore.set_permit_count!(1)
+        expect(semaphore.permits_available).to eql 1
+      end
+    end
+  
+  end
+  
+  describe "#set_permit_count!, #permits_available, #release, #reacquire" do
+    
+    context "when #set_permit_count! is called with less permits then currently available" do
+      it "should force new permit count" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        expect(semaphore.permits_available).to eql 2
+        semaphore.release
+        semaphore.release
+        semaphore.set_permit_count!(1)
+        expect(semaphore.permit_available?).to eql false
+        semaphore.reacquire
+        expect(semaphore.permit_available?).to eql false
+        semaphore.reacquire
+        expect(semaphore.permit_available?).to eql true
+      end
+    end
+    
+  end
+  
+  describe "#set_permit_count!, #release" do
+  
+    context "when #set_permit_count! is called with more permits when one thread is waiting on #release" do
+      it "should resume the thread" do
+        semaphore = QuackConcurrency::Semaphore.new(2)
+        semaphore.release
+        semaphore.release
+        thread = Thread.new do
+          sleep 1
+          semaphore.set_permit_count(3)
+        end
+        start_time = Time.now
+        semaphore.release
+        end_time = Time.now
+        duration = end_time - start_time
+        thread.join
+        expect(duration).to be > 0.5
+      end
+    end
+    
+  end
+  
+  describe "#set_permit_count!, #release, #permit_available?" do
+  
+    context "when semaphore has no permits available, them #set_permit_count! is called to remove 2 permits, then called again to add 1 permit" do
+      it "should not have any permits available" do
+        semaphore = QuackConcurrency::Semaphore.new(3)
+        semaphore.release
+        semaphore.release
+        expect(semaphore.permit_available?).to eql true
+        semaphore.set_permit_count!(1)
+        expect(semaphore.permit_available?).to eql false
+        semaphore.set_permit_count!(2)
+        expect(semaphore.permit_available?).to eql false
+      end
+    end
+    
+  end
+  
+  describe "#set_permit_count!, #release, #reacquire" do
+  
+    context "when semaphore has no permits available, them #set_permit_count! is called to remove 2 permits, then a thread starts waiting for #release, then #set_permit_count! is called again to add 1 permit" do
+      it "thread should wait for #reacquire to be called" do
+        semaphore = QuackConcurrency::Semaphore.new(3)
+        semaphore.release
+        semaphore.release
+        semaphore.release
+        semaphore.set_permit_count!(1)
+        thread = Thread.new do
+          sleep 1
+          semaphore.set_permit_count!(2)
+          sleep 1
+          semaphore.reacquire
+          sleep 1
+          semaphore.reacquire
+        end
+        start_time = Time.now
+        semaphore.release
+        end_time = Time.now
+        duration = end_time - start_time
+        thread.join
+        expect(duration).to be_between(2.5, 3.5)
+      end
+    end
+    
+  end
+
 end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: quack_concurrency
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Rob Fors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-14 00:00:00.000000000 Z
+date: 2018-04-18 00:00:00.000000000 Z
 dependencies: []
-description: Offers concurrency tools that could also be found in the Concurrent Ruby
-  project. However, all these tools will also accept duck types to allow core classes
-  to behave as desired.
+description: Offers concurrency tools that could also be found in the 'Concurrent
+  Ruby'. However, all these tools will also accept core class ducktypes to build off
+  of.
 email: mail@robfors.com
 executables: []
 extensions: []
@@ -21,11 +21,19 @@ files:
 - LICENSE
 - README.md
 - lib/quack_concurrency.rb
+- lib/quack_concurrency/concurrency_tool.rb
+- lib/quack_concurrency/error.rb
 - lib/quack_concurrency/future.rb
+- lib/quack_concurrency/future/canceled.rb
+- lib/quack_concurrency/future/complete.rb
+- lib/quack_concurrency/name.rb
 - lib/quack_concurrency/queue.rb
 - lib/quack_concurrency/reentrant_mutex.rb
+- lib/quack_concurrency/reentrant_mutex/error.rb
 - lib/quack_concurrency/semaphore.rb
+- lib/quack_concurrency/semaphore/error.rb
 - lib/quack_concurrency/waiter.rb
+- spec/future_spec.rb
 - spec/queue_spec.rb
 - spec/reentrant_mutex_spec.rb
 - spec/semaphore_spec.rb
@@ -50,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Concurrency tools that accept duck types of core classes.