concurrent-ruby 0.6.1 → 0.7.0.rc0

data/spec/concurrent/obligation_shared.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-share_examples_for :obligation do
-
-  context '#state' do
-
-    it 'is :pending when first created' do
-      f = pending_subject
-      f.state.should == :pending
-      f.should be_pending
-    end
-
-    it 'is :fulfilled when the handler completes' do
-      f = fulfilled_subject
-      f.state.should == :fulfilled
-      f.should be_fulfilled
-    end
-
-    it 'is :rejected when the handler raises an exception' do
-      f = rejected_subject
-      f.state.should == :rejected
-      f.should be_rejected
-    end
-  end
-
-  context '#value' do
-
-    let!(:supports_timeout) { pending_subject.method(:value).arity != 0 }
-
-    it 'returns nil when reaching the optional timeout value' do
-      if supports_timeout
-        f = pending_subject
-        f.value(0).should be_nil
-        f.should be_pending
-      end
-    end
-
-    it 'returns immediately when timeout is zero' do
-      if supports_timeout
-        Concurrent.should_not_receive(:timeout).with(any_args())
-        f = pending_subject
-        f.value(0).should be_nil
-        f.should be_pending
-      end
-    end
-
-    it 'returns the value when fulfilled before timeout' do
-      if supports_timeout
-        f = pending_subject
-        f.value(10).should be_true
-        f.should be_fulfilled
-      end
-    end
-
-    it 'returns nil when timeout reached' do
-      if supports_timeout
-        f = pending_subject
-        f.value(0.1).should be_nil
-        f.should be_pending
-      end
-    end
-
-    it 'is nil when :pending' do
-      if supports_timeout
-        expected = pending_subject.value(0)
-        expected.should be_nil
-      end
-    end
-
-    it 'blocks the caller when :pending and timeout is nil' do
-      f = pending_subject
-      f.value.should be_true
-      f.should be_fulfilled
-    end
-
-    it 'is nil when :rejected' do
-      expected = rejected_subject.value
-      expected.should be_nil
-    end
-
-    it 'is set to the return value of the block when :fulfilled' do
-      expected = fulfilled_subject.value
-      expected.should eq fulfilled_value
-    end
-  end
-
-  context '#reason' do
-
-    it 'is nil when :pending' do
-      pending_subject.reason.should be_nil
-    end
-
-    it 'is nil when :fulfilled' do
-      fulfilled_subject.reason.should be_nil
-    end
-
-    it 'is set to error object of the exception when :rejected' do
-      rejected_subject.reason.should be_a(Exception)
-      rejected_subject.reason.to_s.should =~ /#{rejected_reason}/
-    end
-  end
-end

data/spec/concurrent/obligation_spec.rb

@@ -1,282 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe Obligation do
-
-    let (:obligation_class) do
-
-      Class.new do
-        include Obligation
-
-        def initialize
-          init_mutex
-        end
-
-        public :state=, :compare_and_set_state, :if_state, :mutex
-        attr_writer :value, :reason
-      end
-    end
-
-    let (:obligation) { obligation_class.new }
-    let (:event) { double 'event' }
-
-    share_examples_for :incomplete do
-      it 'should be not completed' do
-        obligation.should_not be_completed
-      end
-
-      it 'should be incomplete' do
-        obligation.should be_incomplete
-      end
-
-      methods = [:value, :value!, :no_error!]
-      methods.each do |method|
-        describe "##{method}" do
-
-          it 'should return immediately if timeout is zero' do
-            obligation.send(method, 0).should(method == :no_error! ? eq(obligation) : be_nil)
-          end
-
-          it 'should block on the event if timeout is not set' do
-            obligation.stub(:event).and_return(event)
-            event.should_receive(:wait).with(nil)
-
-            obligation.send method
-          end
-
-          it 'should block on the event if timeout is not zero' do
-            obligation.stub(:event).and_return(event)
-            event.should_receive(:wait).with(5)
-
-            obligation.send(method, 5)
-          end
-
-        end
-      end
-    end
-
-    context 'unscheduled' do
-      before(:each) { obligation.state = :unscheduled }
-      it_should_behave_like :incomplete
-    end
-
-    context 'pending' do
-      before(:each) { obligation.state = :pending }
-      it_should_behave_like :incomplete
-    end
-
-    context 'fulfilled' do
-
-      before(:each) do
-        obligation.state = :fulfilled
-        obligation.send(:value=, 42)
-        obligation.stub(:event).and_return(event)
-      end
-
-      it 'should be completed' do
-        obligation.should be_completed
-      end
-
-      it 'should be not incomplete' do
-        obligation.should_not be_incomplete
-      end
-
-      describe '#value' do
-
-        it 'should return immediately if timeout is zero' do
-          obligation.value(0).should eq 42
-        end
-
-        it 'should return immediately if timeout is not set' do
-          event.should_not_receive(:wait)
-
-          obligation.value.should eq 42
-        end
-
-        it 'should return immediately if timeout is not zero' do
-          event.should_not_receive(:wait)
-
-          obligation.value(5).should eq 42
-        end
-
-      end
-
-      describe '#value!' do
-
-        it 'should return immediately if timeout is zero' do
-          obligation.value!(0).should eq 42
-        end
-
-        it 'should return immediately if timeout is not set' do
-          event.should_not_receive(:wait)
-
-          obligation.value!.should eq 42
-        end
-
-        it 'should return immediately if timeout is not zero' do
-          event.should_not_receive(:wait)
-
-          obligation.value!(5).should eq 42
-        end
-
-      end
-
-      describe '#no_error!' do
-
-        it 'should return immediately if timeout is zero' do
-          obligation.no_error!(0).should eq obligation
-        end
-
-        it 'should return immediately if timeout is not set' do
-          event.should_not_receive(:wait)
-
-          obligation.no_error!.should eq obligation
-        end
-
-        it 'should return immediately if timeout is not zero' do
-          event.should_not_receive(:wait)
-
-          obligation.no_error!(5).should eq obligation
-        end
-
-      end
-
-    end
-
-    context 'rejected' do
-
-      before(:each) do
-        obligation.state = :rejected
-        obligation.stub(:event).and_return(event)
-      end
-
-      it 'should be completed' do
-        obligation.should be_completed
-      end
-
-      it 'should be not incomplete' do
-        obligation.should_not be_incomplete
-      end
-
-
-      describe '#value' do
-
-        it 'should return immediately if timeout is zero' do
-          event.should_not_receive(:wait)
-
-          obligation.value(0).should be_nil
-        end
-
-        it 'should return immediately if timeout is not set' do
-          event.should_not_receive(:wait)
-
-          obligation.value.should be_nil
-        end
-
-        it 'should return immediately if timeout is not zero' do
-          event.should_not_receive(:wait)
-
-          obligation.value(5).should be_nil
-        end
-
-      end
-
-      describe '#value!' do
-
-        it 'should return immediately if timeout is zero' do
-          event.should_not_receive(:wait)
-
-          -> { obligation.value!(0) }.should raise_error
-        end
-
-        it 'should return immediately if timeout is not set' do
-          event.should_not_receive(:wait)
-
-          -> { obligation.value! }.should raise_error
-        end
-
-        it 'should return immediately if timeout is not zero' do
-          event.should_not_receive(:wait)
-
-          -> { obligation.value!(5) }.should raise_error
-        end
-
-      end
-
-      describe '#no_error!' do
-
-        it 'should return immediately if timeout is zero' do
-          event.should_not_receive(:wait)
-
-          -> { obligation.no_error!(0) }.should raise_error
-        end
-
-        it 'should return immediately if timeout is not set' do
-          event.should_not_receive(:wait)
-
-          -> { obligation.no_error! }.should raise_error
-        end
-
-        it 'should return immediately if timeout is not zero' do
-          event.should_not_receive(:wait)
-
-          -> { obligation.no_error!(5) }.should raise_error
-        end
-
-      end
-
-    end
-
-    describe '#compare_and_set_state' do
-
-      before(:each) { obligation.state = :unscheduled }
-
-      context 'unexpected state' do
-        it 'should return false if state is not the expected one' do
-          obligation.compare_and_set_state(:pending, :rejected).should be_false
-        end
-
-        it 'should not change the state if current is not the expected one' do
-          obligation.compare_and_set_state(:pending, :rejected)
-          obligation.state.should eq :unscheduled
-        end
-      end
-
-      context 'expected state' do
-        it 'should return true if state is the expected one' do
-          obligation.compare_and_set_state(:pending, :unscheduled).should be_true
-        end
-
-        it 'should not change the state if current is not the expected one' do
-          obligation.compare_and_set_state(:pending, :unscheduled)
-          obligation.state.should eq :pending
-        end
-      end
-
-    end
-
-    describe '#if_state' do
-
-      before(:each) { obligation.state = :unscheduled }
-
-      it 'should raise without block' do
-        expect { obligation.if_state(:pending) }.to raise_error(ArgumentError)
-      end
-
-      it 'should return false if state is not expected' do
-        obligation.if_state(:pending, :rejected) { 42 }.should be_false
-      end
-
-      it 'should the block value if state is expected' do
-        obligation.if_state(:rejected, :unscheduled) { 42 }.should eq 42
-      end
-
-      it 'should execute the block within the mutex' do
-        obligation.if_state(:unscheduled) { obligation.mutex.should be_locked }
-      end
-
-    end
-
-  end
-end

data/spec/concurrent/observable_shared.rb

@@ -1,177 +0,0 @@
-require 'spec_helper'
-
-share_examples_for :observable do
-
-  let(:observer_set) do
-    subject.instance_variable_get(:@observers)
-  end
-
-  let(:observer_class) do
-    Class.new do
-      def initialize(&block)
-        @block = block
-      end
-      def update(*args)
-        @block.call(*args) if @block
-      end
-    end
-  end
-
-  let(:observer){ observer_class.new }
-
-  let!(:observer_func){ :notify }
-
-  let(:observer_with_func_class) do
-    Class.new do
-      def initialize(&block)
-        @block = block
-      end
-      def notify(*args)
-        @block.call(*args) if @block
-      end
-    end
-  end
-
-  let(:observer_with_func){ observer_with_func_class.new }
-
-  context '#add_observer' do
-
-    it 'adds an observer if called before first notification' do
-      observer_set.should_receive(:add_observer).with(any_args)
-      subject.add_observer(observer)
-    end
-
-    it 'adds an observer with :func if called before first notification' do
-      observer_set.should_receive(:add_observer).with(observer_with_func, :notify)
-      subject.add_observer(observer_with_func, observer_func)
-    end
-
-    it 'creates an observer from a block if called before first notification' do
-      block = proc{ nil }
-      observer_set.should_receive(:add_observer).with(any_args)
-      subject.add_observer(&block)
-    end
-
-    it 'raises an exception if not given an observer or a block' do
-      expect {
-        subject.add_observer
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raises an exception when given both an observer and a block' do
-      expect {
-        subject.add_observer(observer){ nil }
-      }.to raise_error(ArgumentError)
-    end
-  end
-  
-  context '#delete_observer' do
-  
-    it 'deletes the given observer if called before first notification' do
-      subject.count_observers.should eq 0
-      subject.add_observer(observer)
-      subject.count_observers.should eq 1
-      subject.delete_observer(observer)
-      subject.count_observers.should eq 0
-    end
-
-    it 'returns the removed observer if found in the observer set' do
-      subject.add_observer(observer)
-      subject.delete_observer(observer).should eq observer
-    end
-
-    it 'returns the given observer even when not found in the observer set' do
-      subject.delete_observer(observer).should eq observer
-    end
-  end
-  
-  context '#delete_observers' do
-
-    it 'deletes all observers when called before first notification' do
-      5.times{ subject.add_observer(observer_class.new) }
-      subject.count_observers.should eq 5
-      subject.delete_observers
-      subject.count_observers.should eq 0
-    end
-
-    it 'returns self' do
-      subject.delete_observers.should eq subject
-    end
-  end
-  
-  context '#count_observers' do
-  
-    it 'returns zero for a new observable object' do
-      subject.count_observers.should eq 0
-    end
-
-    it 'returns a count of registered observers if called before first notification' do
-      5.times{ subject.add_observer(observer_class.new) }
-      subject.count_observers.should eq 5
-    end
-
-    it 'returns zero after #delete_observers has been called' do
-      5.times{ subject.add_observer(observer_class.new) }
-      subject.delete_observers
-      subject.count_observers.should eq 0
-    end
-  end
-
-  context 'first notification' do
-
-    it 'calls the #update method on all observers without a specified :func' do
-      latch = Concurrent::CountDownLatch.new(5)
-      5.times do
-        subject.add_observer(observer_class.new{ latch.count_down })
-      end
-      trigger_observable(subject)
-      latch.count.should eq 0
-    end
-
-    it 'calls the appropriate function on all observers which specified a :func' do
-      latch = Concurrent::CountDownLatch.new(5)
-      5.times do
-        obs = observer_with_func_class.new{ latch.count_down }
-        subject.add_observer(obs, observer_func)
-      end
-      trigger_observable(subject)
-      latch.wait(1)
-      latch.count.should eq 0
-    end
-
-    it 'calls the proc for all observers added as a block' do
-      latch = Concurrent::CountDownLatch.new(5)
-      5.times do
-        subject.add_observer{ latch.count_down }
-      end
-      trigger_observable(subject)
-      latch.wait(1)
-      latch.count.should eq 0
-    end
-
-    it 'does not notify any observers removed with #delete_observer' do
-      latch = Concurrent::CountDownLatch.new(5)
-      
-      obs = observer_class.new{ latch.count_down }
-      subject.add_observer(obs)
-      subject.delete_observer(obs)
-
-      trigger_observable(subject)
-      latch.wait(1)
-      latch.count.should eq 5
-    end
-
-    it 'does not notify any observers after #delete_observers called' do
-      latch = Concurrent::CountDownLatch.new(5)
-      5.times do
-        subject.add_observer(observer_class.new{ latch.count_down })
-      end
-
-      subject.delete_observers
-
-      trigger_observable(subject)
-      latch.wait(1)
-      latch.count.should eq 5
-    end
-  end
-end