concurrent-ruby 0.6.0 → 0.7.0.rc0

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

data/spec/concurrent/observable_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe Observable do
-
-    let (:described_class) do
-      Class.new do
-        include Concurrent::Observable
-        public :observers, :observers=
-      end
-    end
-
-    let(:observer_set) { double(:observer_set) }
-    subject { described_class.new }
-
-    before(:each) do
-      subject.observers = observer_set
-    end
-
-    it 'does not initialize set by by default' do
-      described_class.new.observers.should be_nil
-    end
-
-    it 'uses the given observer set' do
-      expected          = CopyOnWriteObserverSet.new
-      subject.observers = expected
-      subject.observers.should eql expected
-    end
-
-    it 'delegates #add_observer' do
-      observer_set.should_receive(:add_observer).with(:observer).and_return { |v| v }
-      subject.add_observer(:observer).should eq :observer
-    end
-
-    it 'delegates #with_observer' do
-      observer_set.should_receive(:add_observer).with(:observer).and_return { |v| v }
-      subject.with_observer(:observer).should eq subject
-    end
-
-    it 'delegates #delete_observer' do
-      observer_set.should_receive(:delete_observer).with(:observer)
-      subject.delete_observer(:observer)
-    end
-
-    it 'delegates #delete_observers' do
-      observer_set.should_receive(:delete_observers).with(no_args)
-      subject.delete_observers
-    end
-
-    it 'delegates #count_observers' do
-      observer_set.should_receive(:count_observers).with(no_args)
-      subject.count_observers
-    end
-  end
-end

data/spec/concurrent/options_parser_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe OptionsParser do
-
-    let(:executor){ ImmediateExecutor.new }
-
-    let(:task_pool){ ImmediateExecutor.new }
-    let(:operation_pool){ ImmediateExecutor.new }
-
-    context '#get_executor_from' do
-
-      it 'returns the given :executor' do
-        OptionsParser::get_executor_from(executor: executor).should eq executor
-      end
-
-      it 'returns the global operation pool when :operation is true' do
-        Concurrent.configuration.should_receive(:global_operation_pool).
-          and_return(:operation_pool)
-        OptionsParser::get_executor_from(operation: true)
-      end
-
-      it 'returns the global task pool when :operation is false' do
-        Concurrent.configuration.should_receive(:global_task_pool).
-          and_return(:task_pool)
-        OptionsParser::get_executor_from(operation: false)
-      end
-
-      it 'returns the global operation pool when :task is false' do
-        Concurrent.configuration.should_receive(:global_operation_pool).
-          and_return(:operation_pool)
-        OptionsParser::get_executor_from(task: false)
-      end
-
-      it 'returns the global task pool when :task is true' do
-        Concurrent.configuration.should_receive(:global_task_pool).
-          and_return(:task_pool)
-        OptionsParser::get_executor_from(task: true)
-      end
-
-      it 'returns the global task pool when :executor is nil' do
-        Concurrent.configuration.should_receive(:global_task_pool).
-          and_return(:task_pool)
-        OptionsParser::get_executor_from(executor: nil)
-      end
-
-      it 'returns the global task pool when no option is given' do
-        Concurrent.configuration.should_receive(:global_task_pool).
-          and_return(:task_pool)
-        OptionsParser::get_executor_from
-      end
-
-      specify ':executor overrides :operation' do
-        OptionsParser::get_executor_from(executor: executor, operation: true).
-          should eq executor
-      end
-
-      specify ':executor overrides :task' do
-        OptionsParser::get_executor_from(executor: executor, task: true).
-          should eq executor
-      end
-
-      specify ':operation overrides :task' do
-        Concurrent.configuration.should_receive(:global_operation_pool).
-          and_return(:operation_pool)
-        OptionsParser::get_executor_from(operation: true, task: true)
-      end
-    end
-  end
-end