concurrent-ruby 0.6.1 → 0.7.0.rc0

data/spec/concurrent/ivar_spec.rb

@@ -1,215 +0,0 @@
-require 'spec_helper'
-require_relative 'dereferenceable_shared'
-require_relative 'obligation_shared'
-require_relative 'observable_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')
-      end
-
-      it_should_behave_like :dereferenceable
-
-      # observable
-      
-      subject{ IVar.new }
-      
-      def trigger_observable(observable)
-        observable.set('value')
-      end
-
-      it_should_behave_like :observable
-    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(Concurrent::MultipleAssignmentError)
-        i.value.should eq 14
-      end
-
-      it 'returns self' do
-        i = IVar.new
-        i.set(42).should eq i
-      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(Concurrent::MultipleAssignmentError)
-        i.value.should be_nil
-      end
-
-      it 'defaults the reason to a StandardError' do
-        i = IVar.new
-        i.fail
-        i.reason.should be_a StandardError
-      end
-
-      it 'returns self' do
-        i = IVar.new
-        i.fail.should eq i
-      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

@@ -1,380 +0,0 @@
-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