concurrent-ruby 0.6.1 → 0.7.0.rc0

data/spec/concurrent/executor/timer_set_spec.rb

@@ -1,183 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe TimerSet do
-
-    subject{ TimerSet.new(executor: ImmediateExecutor.new) }
-
-    after(:each){ subject.kill }
-
-    it 'uses the executor given at construction' do
-      executor = double(:executor)
-      executor.should_receive(:post).with(no_args)
-      subject = TimerSet.new(executor: executor)
-      subject.post(0){ nil }
-      sleep(0.1)
-    end
-
-    it 'uses the global task pool be default' do
-      Concurrent.configuration.global_task_pool.should_receive(:post).with(no_args)
-      subject = TimerSet.new
-      subject.post(0){ nil }
-      sleep(0.1)
-    end
-
-    it 'executes a given task when given a Time' do
-      latch = CountDownLatch.new(1)
-      subject.post(Time.now + 0.1){ latch.count_down }
-      latch.wait(0.2).should be_true
-    end
-
-    it 'executes a given task when given an interval in seconds' do
-      latch = CountDownLatch.new(1)
-      subject.post(0.1){ latch.count_down }
-      latch.wait(0.2).should be_true
-    end
-
-    it 'passes all arguments to the task on execution' do
-      expected = nil
-      latch = CountDownLatch.new(1)
-      subject.post(0.1, 1, 2, 3) do |*args|
-        expected = args
-        latch.count_down
-      end
-      latch.wait(0.2).should be_true
-      expected.should eq [1, 2, 3]
-    end
-
-    it 'immediately posts a task when the delay is zero' do
-      Thread.should_not_receive(:new).with(any_args)
-      subject.post(0){ true }
-    end
-
-    it 'does not execute tasks early' do
-      expected = AtomicFixnum.new(0)
-      subject.post(0.2){ expected.increment }
-      sleep(0.15)
-      expected.value.should eq 0
-      sleep(0.10)
-      expected.value.should eq 1
-    end
-
-    it 'raises an exception when given a task with a past Time value' do
-      expect {
-        subject.post(Time.now - 10){ nil }
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raises an exception when given a task with a delay less than zero' do
-      expect {
-        subject.post(-10){ nil }
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raises an exception when no block given' do
-      expect {
-        subject.post(10)
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'executes all tasks scheduled for the same time' do
-      latch = CountDownLatch.new(5)
-      5.times{ subject.post(0.1){ latch.count_down } }
-      latch.wait(0.2).should be_true
-    end
-
-    it 'executes tasks with different times in schedule order' do
-      expected = []
-      3.times{|i| subject.post(i/10){ expected << i } }
-      sleep(0.3)
-      expected.should eq [0, 1, 2]
-    end
-
-    it 'cancels all pending tasks on #shutdown' do
-      expected = AtomicFixnum.new(0)
-      10.times{ subject.post(0.2){ expected.increment } }
-      sleep(0.1)
-      subject.shutdown
-      sleep(0.2)
-      expected.value.should eq 0
-    end
-
-    it 'cancels all pending tasks on #kill' do
-      expected = AtomicFixnum.new(0)
-      10.times{ subject.post(0.2){ expected.increment } }
-      sleep(0.1)
-      subject.kill
-      sleep(0.2)
-      expected.value.should eq 0
-    end
-
-    it 'stops the monitor thread on #shutdown' do
-      timer_executor = subject.instance_variable_get(:@timer_executor)
-      subject.shutdown
-      sleep(0.1)
-      timer_executor.should_not be_running
-    end
-
-    it 'kills the monitor thread on #kill' do
-      timer_executor = subject.instance_variable_get(:@timer_executor)
-      subject.kill
-      sleep(0.1)
-      timer_executor.should_not be_running
-    end
-
-    it 'rejects tasks once shutdown' do
-      expected = AtomicFixnum.new(0)
-      subject.shutdown
-      sleep(0.1)
-      subject.post(0){ expected.increment }.should be_false
-      sleep(0.1)
-      expected.value.should eq 0
-    end
-
-    it 'rejects tasks once killed' do
-      expected = AtomicFixnum.new(0)
-      subject.kill
-      sleep(0.1)
-      subject.post(0){ expected.increment }.should be_false
-      sleep(0.1)
-      expected.value.should eq 0
-    end
-
-    it 'is running? when first created' do
-      subject.should be_running
-      subject.should_not be_shutdown
-    end
-
-    it 'is running? after tasks have been post' do
-      subject.post(0.1){ nil }
-      subject.should be_running
-      subject.should_not be_shutdown
-    end
-
-    it 'is shutdown? after shutdown completes' do
-      subject.shutdown
-      sleep(0.1)
-      subject.should_not be_running
-      subject.should be_shutdown
-    end
-
-    it 'is shutdown? after being killed' do
-      subject.kill
-      sleep(0.1)
-      subject.should_not be_running
-      subject.should be_shutdown
-    end
-
-    specify '#wait_for_termination returns true if shutdown completes before timeout' do
-      subject.post(0.1){ nil }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(0.1).should be_true
-    end
-
-    specify '#wait_for_termination returns false on timeout' do
-      subject.post(0.1){ nil }
-      sleep(0.1)
-      # do not call shutdown -- force timeout
-      subject.wait_for_termination(0.1).should be_false
-    end
-  end
-end

data/spec/concurrent/future_spec.rb

@@ -1,329 +0,0 @@
-require 'spec_helper'
-require_relative 'dereferenceable_shared'
-require_relative 'obligation_shared'
-require_relative 'observable_shared'
-
-module Concurrent
-
-  describe Future do
-
-    let!(:value) { 10 }
-    let(:executor) { PerThreadExecutor.new }
-
-    subject do
-      Future.new(executor: executor){
-        value
-      }.execute.tap{ sleep(0.1) }
-    end
-
-    context 'behavior' do
-
-      # obligation
-
-      let!(:fulfilled_value) { 10 }
-      let!(:rejected_reason) { StandardError.new('mojo jojo') }
-
-      let(:pending_subject) do
-        Future.new(executor: executor){ sleep(3); fulfilled_value }.execute
-      end
-
-      let(:fulfilled_subject) do
-        Future.new(executor: executor){ fulfilled_value }.execute.tap{ sleep(0.1) }
-      end
-
-      let(:rejected_subject) do
-        Future.new(executor: executor){ raise rejected_reason }.execute.tap{ sleep(0.1) }
-      end
-
-      it_should_behave_like :obligation
-
-      # dereferenceable
-
-      def dereferenceable_subject(value, opts = {})
-        opts = opts.merge(executor: executor)
-        Future.new(opts){ value }.execute.tap{ sleep(0.1) }
-      end
-
-      def dereferenceable_observable(opts = {})
-        opts = opts.merge(executor: executor)
-        Future.new(opts){ 'value' }
-      end
-
-      def execute_dereferenceable(subject)
-        subject.execute
-        sleep(0.1)
-      end
-
-      it_should_behave_like :dereferenceable
-
-      # observable
-      
-      subject{ Future.new{ nil } }
-      
-      def trigger_observable(observable)
-        observable.execute
-        sleep(0.1)
-      end
-
-      it_should_behave_like :observable
-    end
-
-    context 'subclassing' do
-
-      subject{ Future.execute(executor: executor){ 42 } }
-
-      it 'protects #set' do
-        expect{ subject.set(100) }.to raise_error
-      end
-
-      it 'protects #fail' do
-        expect{ subject.fail }.to raise_error
-      end
-
-      it 'protects #complete' do
-        expect{ subject.complete(true, 100, nil) }.to raise_error
-      end
-    end
-
-    context '#initialize' do
-
-      let(:executor) { ImmediateExecutor.new }
-
-      it 'sets the state to :unscheduled' do
-        Future.new(executor: executor){ nil }.should be_unscheduled
-      end
-
-      it 'raises an exception when no block given' do
-        expect {
-          Future.new.execute
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'uses the executor given with the :executor option' do
-        executor.should_receive(:post)
-        Future.execute(executor: executor){ nil }
-      end
-
-      it 'uses the global operation pool when :operation is true' do
-        Concurrent.configuration.should_receive(:global_operation_pool).and_return(executor)
-        Future.execute(operation: true){ nil }
-      end
-
-      it 'uses the global task pool when :task is true' do
-        Concurrent.configuration.should_receive(:global_task_pool).and_return(executor)
-        Future.execute(task: true){ nil }
-      end
-
-      it 'uses the global task pool by default' do
-        Concurrent.configuration.should_receive(:global_task_pool).and_return(executor)
-        Future.execute{ nil }
-      end
-    end
-
-    context 'instance #execute' do
-
-      it 'does nothing unless the state is :unscheduled' do
-        executor = ImmediateExecutor.new
-        executor.should_not_receive(:post).with(any_args)
-        future = Future.new(executor: executor){ nil }
-        future.instance_variable_set(:@state, :pending)
-        future.execute
-        future.instance_variable_set(:@state, :rejected)
-        future.execute
-        future.instance_variable_set(:@state, :fulfilled)
-        future.execute
-      end
-
-      it 'posts the block given on construction' do
-        executor.should_receive(:post).with(any_args)
-        future = Future.new(executor: executor){ nil }
-        future.execute
-      end
-
-      it 'sets the state to :pending' do
-        future = Future.new(executor: executor){ sleep(0.1) }
-        future.execute
-        future.should be_pending
-      end
-
-      it 'returns self' do
-        future = Future.new(executor: executor){ nil }
-        future.execute.should be future
-      end
-    end
-
-    context 'class #execute' do
-
-      let(:executor) { ImmediateExecutor.new }
-
-      it 'creates a new Future' do
-        future = Future.execute(executor: executor){ nil }
-        future.should be_a(Future)
-      end
-
-      it 'passes the block to the new Future' do
-        @expected = false
-        Future.execute(executor: executor){ @expected = true }
-        @expected.should be_true
-      end
-
-      it 'calls #execute on the new Future' do
-        future = double('future')
-        Future.stub(:new).with(any_args).and_return(future)
-        future.should_receive(:execute).with(no_args)
-        Future.execute{ nil }
-      end
-    end
-
-    context 'fulfillment' do
-
-      let(:executor) { ImmediateExecutor.new }
-
-      it 'passes all arguments to handler' do
-        @expected = false
-        Future.new(executor: executor){ @expected = true }.execute
-        @expected.should be_true
-      end
-
-      it 'sets the value to the result of the handler' do
-        future = Future.new(executor: executor){ 42 }.execute
-        future.value.should eq 42
-      end
-
-      it 'sets the state to :fulfilled when the block completes' do
-        future = Future.new(executor: executor){ 42 }.execute
-        future.should be_fulfilled
-      end
-
-      it 'sets the value to nil when the handler raises an exception' do
-        future = Future.new(executor: executor){ raise StandardError }.execute
-        future.value.should be_nil
-      end
-
-      it 'sets the state to :rejected when the handler raises an exception' do
-        future = Future.new(executor: executor){ raise StandardError }.execute
-        future.should be_rejected
-      end
-
-      context 'aliases' do
-
-        it 'aliases #realized? for #fulfilled?' do
-          subject.should be_realized
-        end
-
-        it 'aliases #deref for #value' do
-          subject.deref.should eq value
-        end
-      end
-    end
-
-    context 'observation' do
-
-      let(:executor) { ImmediateExecutor.new }
-
-      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 fulfillment' do
-        future = Future.new(executor: executor){ 42 }
-        future.add_observer(observer)
-
-        future.execute
-
-        observer.value.should == 42
-        observer.reason.should be_nil
-      end
-
-      it 'notifies all observers on rejection' do
-        future = Future.new(executor: executor){ raise StandardError }
-        future.add_observer(observer)
-
-        future.execute
-
-        observer.value.should be_nil
-        observer.reason.should be_a(StandardError)
-      end
-
-      it 'notifies an observer added after fulfillment' do
-        future = Future.new(executor: executor){ 42 }.execute
-        future.add_observer(observer)
-        observer.value.should == 42
-      end
-
-      it 'notifies an observer added after rejection' do
-        future = Future.new(executor: executor){ raise StandardError }.execute
-        future.add_observer(observer)
-        observer.reason.should be_a(StandardError)
-      end
-
-      it 'does not notify existing observers when a new observer added after fulfillment' do
-        future = Future.new(executor: executor){ 42 }.execute
-        future.add_observer(observer)
-
-        observer.count.should == 1
-
-        o2 = clazz.new
-        future.add_observer(o2)
-
-        observer.count.should == 1
-        o2.value.should == 42
-      end
-
-      it 'does not notify existing observers when a new observer added after rejection' do
-        future = Future.new(executor: executor){ raise StandardError }.execute
-        future.add_observer(observer)
-
-        observer.count.should == 1
-
-        o2 = clazz.new
-        future.add_observer(o2)
-
-        observer.count.should == 1
-        o2.reason.should be_a(StandardError)
-      end
-
-      context 'deadlock avoidance' do
-
-        def reentrant_observer(future)
-          obs = Object.new
-          obs.define_singleton_method(:update) do |time, value, reason|
-            @value = future.value
-          end
-          obs.define_singleton_method(:value) { @value }
-          obs
-        end
-
-        it 'should notify observers outside mutex lock' do
-          future = Future.new(executor: executor){ 42 }
-          obs = reentrant_observer(future)
-
-          future.add_observer(obs)
-          future.execute
-
-          obs.value.should eq 42
-        end
-
-        it 'should notify a new observer added after fulfillment outside lock' do
-          future = Future.new(executor: executor){ 42 }.execute
-          obs = reentrant_observer(future)
-
-          future.add_observer(obs)
-
-          obs.value.should eq 42
-        end
-      end
-    end
-  end
-end