concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/spec/concurrent/ivar_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+require_relative 'dereferenceable_shared'
+require_relative 'obligation_shared'
+require_relative 'uses_global_thread_pool_shared'
+
+module Concurrent
+
+  describe IVar do
+
+    let!(:value) { 10 }
+    
+    subject do
+      i = IVar.new
+      i.set(14)
+      i
+    end
+
+    context 'behavior' do
+
+    # obligation
+
+    let!(:fulfilled_value) { 10 }
+    let(:rejected_reason) { StandardError.new('Boom!') }
+
+    let(:pending_subject) do
+      @i = IVar.new
+      Thread.new do
+        sleep(3)
+        @i.set(fulfilled_value)
+      end
+      @i
+    end
+
+    let(:fulfilled_subject) do
+      i = IVar.new
+      i.set(fulfilled_value)
+      i
+    end
+
+    let(:rejected_subject) do
+      i = IVar.new
+      i.fail(rejected_reason)
+      i
+    end
+
+    it_should_behave_like :obligation
+
+      # dereferenceable
+
+      def dereferenceable_subject(value, opts = {})
+        IVar.new(value, opts)
+      end
+
+      def dereferenceable_observable(opts = {})
+        IVar.new(IVar::NO_VALUE, opts)
+      end
+
+      def execute_dereferenceable(subject)
+        subject.set('value')
+        sleep(0.1)
+      end
+
+      it_should_behave_like :dereferenceable
+    end
+
+    context '#initialize' do
+
+      it 'does not have to set an initial value' do
+        i = IVar.new
+        i.should be_incomplete
+      end
+
+      it 'does not set an initial value if you pass NO_VALUE' do
+        i = IVar.new(IVar::NO_VALUE)
+        i.should be_incomplete
+      end
+
+      it 'can set an initial value' do
+        i = IVar.new(14)
+        i.should be_completed
+      end
+
+    end
+
+    context '#set' do
+
+      it 'sets the state to be fulfilled' do
+        i = IVar.new
+        i.set(14)
+        i.should be_fulfilled
+      end
+
+      it 'sets the value' do
+        i = IVar.new
+        i.set(14)
+        i.value.should eq 14
+      end
+
+      it 'raises an exception if set more than once' do
+        i = IVar.new
+        i.set(14)
+        expect {i.set(2)}.to raise_error(MultipleAssignmentError)
+        i.value.should eq 14
+      end
+
+    end
+
+    context '#fail' do
+
+      it 'sets the state to be rejected' do
+        i = IVar.new
+        i.fail
+        i.should be_rejected
+      end
+
+      it 'sets the value to be nil' do
+        i = IVar.new
+        i.fail
+        i.value.should be_nil
+      end
+
+      it 'raises an exception if set more than once' do
+        i = IVar.new
+        i.fail
+        expect {i.fail}.to raise_error(MultipleAssignmentError)
+        i.value.should be_nil
+      end
+
+    end
+
+    context 'observation' do
+
+      let(:clazz) do
+        Class.new do
+          attr_reader :value
+          attr_reader :reason
+          attr_reader :count
+          define_method(:update) do |time, value, reason|
+            @count = @count.to_i + 1
+            @value = value
+            @reason = reason
+          end
+        end
+      end
+
+      let(:observer) { clazz.new }
+
+      it 'notifies all observers on #set' do
+        i = IVar.new
+        i.add_observer(observer)
+
+        i.set(42)
+
+        observer.value.should == 42
+        observer.reason.should be_nil
+      end
+
+      context 'deadlock avoidance' do
+
+        def reentrant_observer(i)
+          obs = Object.new
+          obs.define_singleton_method(:update) do |time, value, reason|
+            @value = i.value
+          end
+          obs.define_singleton_method(:value) { @value }
+          obs
+        end
+
+        it 'should notify observers outside mutex lock' do
+          i = IVar.new
+          obs = reentrant_observer(i)
+
+          i.add_observer(obs)
+          i.set(42)
+
+          obs.value.should eq 42
+        end
+
+        it 'should notify a new observer added after fulfillment outside lock' do
+          i = IVar.new
+          i.set(42)
+          obs = reentrant_observer(i)
+
+          i.add_observer(obs)
+
+          obs.value.should eq 42
+        end
+      end
+
+    end
+  end
+end

data/spec/concurrent/mvar_spec.rb

@@ -0,0 +1,380 @@
+require 'spec_helper'
+require_relative 'dereferenceable_shared'
+
+module Concurrent
+
+  describe MVar do
+
+    context 'behavior' do
+
+      # dereferenceable
+
+      def dereferenceable_subject(value, opts = {})
+        MVar.new(value, opts)
+      end
+
+      it_should_behave_like :dereferenceable
+    end
+
+    describe '#initialize' do
+
+      it 'accepts no initial value' do
+        m = MVar.new
+        m.should be_empty
+      end
+
+      it 'accepts an empty initial value' do
+        m = MVar.new(MVar::EMPTY)
+        m.should be_empty
+      end
+
+      it 'accepts an initial value' do
+        m = MVar.new(14)
+        m.should_not be_empty
+      end
+
+      it 'accepts a nil initial value' do
+        m = MVar.new(nil)
+        m.should_not be_empty
+      end
+
+    end
+
+    describe '#take' do
+
+      it 'sets the MVar to empty' do
+        m = MVar.new(14)
+        m.take
+        m.should be_empty
+      end
+
+      it 'returns the value on a full MVar' do
+        m = MVar.new(14)
+        m.take.should eq 14
+      end
+
+      it 'waits for another thread to #put' do
+        m = MVar.new
+
+        putter = Thread.new {
+          sleep(0.1)
+          m.put 14
+        }
+
+        m.take.should eq 14
+      end
+
+      it 'returns TIMEOUT on timeout on an empty MVar' do
+        m = MVar.new
+        m.take(0.1).should eq MVar::TIMEOUT
+      end
+
+    end
+
+    describe '#put' do
+
+      it 'sets the MVar to be empty' do
+        m = MVar.new(14)
+        m.take
+        m.should be_empty
+      end
+
+      it 'sets a new value on an empty MVar' do
+        m = MVar.new
+        m.put 14
+        m.take.should eq 14
+      end
+
+      it 'waits for another thread to #take' do
+        m = MVar.new(14)
+
+        putter = Thread.new {
+          sleep(0.1)
+          m.take
+        }
+
+        m.put(14).should eq 14
+      end
+
+      it 'returns TIMEOUT on timeout on a full MVar' do
+        m = MVar.new(14)
+        m.put(14, 0.1).should eq MVar::TIMEOUT
+      end
+
+      it 'returns the value' do
+        m = MVar.new
+        m.put(14).should eq 14
+      end
+
+    end
+
+    describe '#empty?' do
+
+      it 'returns true on an empty MVar' do
+        m = MVar.new
+        m.should be_empty
+      end
+
+      it 'returns false on a full MVar' do
+        m = MVar.new(14)
+        m.should_not be_empty
+      end
+
+    end
+
+    describe '#full?' do
+
+      it 'returns false on an empty MVar' do
+        m = MVar.new
+        m.should_not be_full
+      end
+
+      it 'returns true on a full MVar' do
+        m = MVar.new(14)
+        m.should be_full
+      end
+
+    end
+
+    describe '#modify' do
+
+      it 'raises an exception when no block given' do
+        m = MVar.new(14)
+        expect { m.modify }.to raise_error(ArgumentError)
+      end
+
+      it 'modifies a full MVar' do
+        m = MVar.new(14)
+        m.modify{ |v| v + 2 }
+        m.take.should eq 16
+      end
+
+      it 'returns the unmodified value' do
+        m = MVar.new(14)
+        m.modify{ |v| v + 2 }.should eq 14
+      end
+
+      it 'waits for another thread to #put' do
+        m = MVar.new
+
+        putter = Thread.new {
+          sleep(0.1)
+          m.put 14 
+        }
+
+        m.modify{ |v| v + 2 }.should eq 14
+      end
+
+      it 'is atomic' do
+        m = MVar.new(0)
+
+        # #modify conceptually does #take and #put - but it should be atomic.
+        # Check that another #put can't sneak it during the #modify.
+
+        modifier = Thread.new {
+          m.modify do |v|
+            sleep(0.5)
+            1
+          end
+        }
+
+        sleep(0.1)
+        m.put(2, 0.5).should eq MVar::TIMEOUT
+        m.take.should eq 1
+      end
+
+      it 'returns TIMEOUT on timeout on an empty MVar' do
+        m = MVar.new
+        m.modify(0.1){ |v| v + 2 }.should eq MVar::TIMEOUT
+      end
+
+    end
+
+    describe '#try_put!' do
+
+      it 'returns true an empty MVar' do
+        m = MVar.new
+        m.try_put!(14).should eq true
+      end
+
+      it 'returns false on a full MVar' do
+        m = MVar.new(14)
+        m.try_put!(14).should eq false
+      end
+
+      it 'sets an empty MVar to be full' do
+        m = MVar.new
+        m.try_put! 14
+        m.should be_full
+      end
+
+    end
+
+    describe '#try_take!' do
+
+      it 'returns EMPTY an empty MVar' do
+        m = MVar.new
+        m.try_take!.should eq MVar::EMPTY
+      end
+
+      it 'returns the value on a full MVar' do
+        m = MVar.new(14)
+        m.try_take!.should eq 14
+      end
+
+      it 'sets a full MVar to be empty' do
+        m = MVar.new(14)
+        m.try_take!
+        m.should be_empty
+      end
+
+    end
+
+    describe '#set!' do
+
+      it 'sets an empty MVar to be full' do
+        m = MVar.new
+        m.set! 14
+        m.should be_full
+      end
+
+      it 'sets a full MVar to be full' do
+        m = MVar.new(2)
+        m.set! 14
+        m.should be_full
+        m.take.should eq 14
+      end
+
+      it 'returns EMPTY on an empty MVar' do
+        m = MVar.new
+        m.set!(2).should eq MVar::EMPTY
+      end
+
+      it 'returns the original value on a full MVar' do
+        m = MVar.new(14)
+        m.set!(2).should eq 14
+      end
+
+    end
+
+    describe '#modify!' do
+
+      it 'raises an exception when no block given' do
+        m = MVar.new(14)
+        expect { m.modify! }.to raise_error(ArgumentError)
+      end
+
+      it 'modifies a full MVar' do
+        m = MVar.new(14)
+        m.modify!{ |v| v + 2 }
+        m.take.should eq 16
+      end
+
+      it 'modifies an empty MVar' do
+        m = MVar.new
+        m.modify!{ |v| 14 }
+        m.take.should eq 14
+      end
+
+      it 'can be used to set a full MVar to empty' do
+        m = MVar.new(14)
+        m.modify!{ |v| MVar::EMPTY }
+        m.should be_empty
+      end
+
+      it 'can be used to set an empty MVar to empty' do
+        m = MVar.new
+        m.modify!{ |v| MVar::EMPTY }
+        m.should be_empty
+      end
+
+      it 'returns the unmodified value' do
+        m = MVar.new(14)
+        m.modify!{ |v| v + 2 }.should eq 14
+      end
+
+    end
+
+    context 'spurious wake ups' do
+
+      let(:m) { MVar.new }
+
+      before(:each) do
+        def m.simulate_spurious_wake_up
+          @mutex.synchronize do
+            @full_condition.broadcast
+            @empty_condition.broadcast
+          end
+        end
+      end
+
+      describe '#take' do
+        it 'waits for another thread to #put' do
+          Thread.new { sleep(0.5); m.put 14 }
+          Thread.new { sleep(0.1); m.simulate_spurious_wake_up }
+
+          m.take.should eq 14
+        end
+
+        it 'returns TIMEOUT on timeout on an empty MVar' do
+          result = nil
+          Thread.new { result = m.take(0.3) }
+          sleep(0.1)
+          Thread.new { m.simulate_spurious_wake_up }
+          sleep(0.1)
+          result.should be_nil
+          sleep(0.2)
+          result.should eq MVar::TIMEOUT
+        end
+      end
+
+      describe '#modify' do
+
+        it 'waits for another thread to #put' do
+          Thread.new { sleep(0.5); m.put 14 }
+          Thread.new { sleep(0.1); m.simulate_spurious_wake_up }
+
+          m.modify{ |v| v + 2 }.should eq 14
+        end
+
+        it 'returns TIMEOUT on timeout on an empty MVar' do
+          result = nil
+          Thread.new { result = m.modify(0.3){ |v| v + 2 } }
+          sleep(0.1)
+          Thread.new { m.simulate_spurious_wake_up }
+          sleep(0.1)
+          result.should be_nil
+          sleep(0.2)
+          result.should eq MVar::TIMEOUT
+        end
+      end
+
+      describe '#put' do
+
+        before(:each) { m.put(42) }
+
+        it 'waits for another thread to #take' do
+          Thread.new { sleep(0.5); m.take }
+          Thread.new { sleep(0.1); m.simulate_spurious_wake_up }
+
+          m.put(14).should eq 14
+        end
+
+        it 'returns TIMEOUT on timeout on a full MVar' do
+          result = nil
+          Thread.new { result = m.put(14, 0.3) }
+          sleep(0.1)
+          Thread.new { m.simulate_spurious_wake_up }
+          sleep(0.1)
+          result.should be_nil
+          sleep(0.2)
+          result.should eq MVar::TIMEOUT
+        end
+      end
+
+
+    end
+
+  end
+
+end