concurrent-ruby 0.3.0.pre.1 → 0.3.0.pre.2

data/spec/concurrent/agent_spec.rb

@@ -240,9 +240,10 @@ module Concurrent
 
       it 'ignores rescuers without a block' do
         @expected = nil
-        Promise.new{ raise StandardError }.
+        subject.
           rescue(StandardError).
           rescue(StandardError){|ex| @expected = ex }
+        subject.post{ raise StandardError }
         sleep(0.1)
         @expected.should be_a(StandardError)
       end

data/spec/concurrent/cached_thread_pool_spec.rb

@@ -29,39 +29,39 @@ module Concurrent
       end
     end
 
-    context '#size' do
+    context '#length' do
 
       it 'returns zero for a new thread pool' do
-        subject.size.should eq 0
+        subject.length.should eq 0
       end
 
-      it 'returns the size of the subject when running' do
+      it 'returns the length of the subject when running' do
         5.times{ sleep(0.1); subject << proc{ sleep(1) } }
-        subject.size.should eq 5
+        subject.length.should eq 5
       end
 
       it 'returns zero once shut down' do
         subject.shutdown
-        subject.size.should eq 0
+        subject.length.should eq 0
       end
     end
 
     context 'worker creation and caching' do
 
       it 'creates new workers when there are none available' do
-        subject.size.should eq 0
+        subject.length.should eq 0
         5.times{ sleep(0.1); subject << proc{ sleep } }
         sleep(1)
-        subject.size.should eq 5
+        subject.length.should eq 5
       end
 
       it 'uses existing idle threads' do
         5.times{ subject << proc{ sleep(0.1) } }
         sleep(1)
-        subject.size.should eq 5
+        subject.length.should >= 5
         3.times{ subject << proc{ sleep } }
         sleep(0.1)
-        subject.size.should eq 5
+        subject.length.should >= 5
       end
 
       it 'never creates more than :max_threads threads' do
@@ -79,32 +79,22 @@ module Concurrent
 
     context 'garbage collection' do
 
-      subject{ CachedThreadPool.new(gc_interval: 1, idletime: 0.1) }
+      subject{ CachedThreadPool.new(gc_interval: 1, idletime: 1) }
 
       it 'removes from pool any thread that has been idle too long' do
+        3.times { subject << proc{ sleep(0.1) } }
+        subject.length.should eq 3
+        sleep(2)
         subject << proc{ nil }
-        subject.size.should eq 1
-        sleep(1.5)
-        subject.size.should eq 0
+        subject.length.should < 3
       end
 
       it 'removed from pool any dead thread' do
-        subject << proc{ raise StandardError }
-        subject.size.should eq 1
-        sleep(1.5)
-        subject.size.should eq 0
-      end
-    end
-
-    context '#status' do
-
-      it 'returns an empty collection when the pool is empty' do
-        subject.status.should be_empty
-      end
-
-      it 'returns one status object for each thread in the pool' do
-        3.times{ sleep(0.1); subject << proc{ sleep(0.5) } }
-        subject.status.length.should eq 3
+        3.times { subject << proc{ sleep(0.1); raise Exception } }
+        subject.length.should == 3
+        sleep(2)
+        subject << proc{ nil }
+        subject.length.should < 3
       end
     end
   end

data/spec/concurrent/event_machine_defer_proxy_spec.rb

@@ -5,7 +5,7 @@ require 'concurrent/future'
 require 'concurrent/goroutine'
 require 'concurrent/promise'
 
-if Functional::PLATFORM.mri?
+if mri?
 
   module Concurrent
 

data/spec/concurrent/event_spec.rb

@@ -83,7 +83,7 @@ module Concurrent
         subject.reset
         @expected = false
         Thread.new{ subject.wait(0.5); @expected = true}
-        sleep(1)
+        sleep(2)
         @expected.should be_true
       end
 

data/spec/concurrent/executor_spec.rb

@@ -171,14 +171,6 @@ module Concurrent
           @expected.should eq args
         end
 
-        it 'supresses exceptions thrown by the execution block' do
-          lambda {
-            @subject = Executor.new('Foo', execution_interval: 0.5) { raise StandardError }
-          @thread = Thread.new { @subject.run }
-            sleep(1)
-          }.should_not raise_error
-        end
-
         it 'kills the worker thread if the timeout is reached' do
           # the after(:each) block will trigger this expectation
           Thread.should_receive(:kill).at_least(1).with(any_args())

data/spec/concurrent/fixed_thread_pool_spec.rb

@@ -16,46 +16,46 @@ module Concurrent
 
     context '#initialize' do
 
-      it 'raises an exception when the pool size is less than one' do
+      it 'raises an exception when the pool length is less than one' do
         lambda {
           FixedThreadPool.new(0)
         }.should raise_error(ArgumentError)
       end
 
-      it 'raises an exception when the pool size is greater than MAX_POOL_SIZE' do
+      it 'raises an exception when the pool length is greater than MAX_POOL_SIZE' do
         lambda {
           FixedThreadPool.new(FixedThreadPool::MAX_POOL_SIZE + 1)
         }.should raise_error(ArgumentError)
       end
     end
 
-    context '#size' do
+    context '#length' do
 
-      let(:pool_size) { 3 }
-      subject { FixedThreadPool.new(pool_size) }
+      let(:pool_length) { 3 }
+      subject { FixedThreadPool.new(pool_length) }
 
       it 'returns zero on start' do
         subject.shutdown
-        subject.size.should eq 0
+        subject.length.should eq 0
       end
 
-      it 'returns the size of the pool when running' do
-        pool_size.times do |i|
+      it 'returns the length of the pool when running' do
+        pool_length.times do |i|
           subject.post{ sleep }
           sleep(0.1)
-          subject.size.should eq i+1
+          subject.length.should eq pool_length
         end
       end
 
       it 'returns zero while shutting down' do
         subject.post{ sleep(1) }
         subject.shutdown
-        subject.size.should eq 0
+        subject.length.should eq 0
       end
 
       it 'returns zero once shut down' do
         subject.shutdown
-        subject.size.should eq 0
+        subject.length.should eq 0
       end
     end
 
@@ -63,10 +63,10 @@ module Concurrent
 
       it 'creates new workers when there are none available' do
         pool = FixedThreadPool.new(5)
-        pool.size.should eq 0
+        pool.length.should eq 0
         5.times{ sleep(0.1); pool << proc{ sleep } }
         sleep(0.1)
-        pool.size.should eq 5
+        pool.length.should eq 5
         pool.kill
       end
 
@@ -77,16 +77,27 @@ module Concurrent
         pool.length.should eq 5
         pool.kill
       end
+
+      it 'creates new threads when garbage collecting' do
+        pool = FixedThreadPool.new(5)
+        pool.length.should == 0
+        pool << proc { sleep }
+        sleep(0.1)
+        pool.length.should == 5
+        pool.instance_variable_set(:@max_threads, 25)
+        pool << proc { sleep }
+        pool.length.should == 25
+      end
     end
 
     context 'exception handling' do
 
       it 'restarts threads that experience exception' do
+        pending
         pool = FixedThreadPool.new(5)
         5.times{ pool << proc{ raise StandardError } }
-        sleep(5)
-        pool.size.should eq 5
-        pool.status.should_not include(nil)
+        sleep(1)
+        pool.length.should eq 5
       end
     end
   end

data/spec/concurrent/future_spec.rb

@@ -30,17 +30,6 @@ module Concurrent
 
     it_should_behave_like Concurrent::Obligation
 
-    context 'behavior' do
-
-      it 'implements :future behavior' do
-        lambda {
-          Future.new{ nil }
-        }.should_not raise_error
-
-        Future.new{ nil }.behaves_as?(:future).should be_true
-      end
-    end
-
     context '#initialize' do
 
       it 'spawns a new thread when a block is given' do
@@ -151,7 +140,6 @@ module Concurrent
         sleep(0.1)
         future.value.should == 42
         future.add_observer(observer)
-        observer.value.should be_nil
         sleep(0.1)
         observer.value.should == 42
       end
@@ -161,7 +149,6 @@ module Concurrent
         sleep(0.1)
         future.reason.should be_a(StandardError)
         future.add_observer(observer)
-        observer.value.should be_nil
         sleep(0.1)
         observer.reason.should be_a(StandardError)
       end

data/spec/concurrent/global_thread_pool_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'concurrent/goroutine'
 require_relative 'uses_global_thread_pool_shared'
 
 module Concurrent
@@ -8,4 +9,76 @@ module Concurrent
     let!(:thread_pool_user){ Class.new{ include UsesGlobalThreadPool } }
     it_should_behave_like Concurrent::UsesGlobalThreadPool
   end
+
+  describe NullThreadPool do
+
+    subject { NullThreadPool.new }
+
+    after(:all) do
+      $GLOBAL_THREAD_POOL = FixedThreadPool.new(1)
+    end
+
+    context '#post' do
+
+      it 'creates a new thread for a call without arguments' do
+        thread = Thread.new{ nil }
+        Thread.should_receive(:new).with(no_args()).and_return(thread)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
+        subject.post{ nil }
+      end
+
+      it 'executes a call without arguments' do
+        @expected = false
+        subject.post{ @expected = true }
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'creates a new thread for a call with arguments' do
+        thread = Thread.new{ nil }
+        Thread.should_receive(:new).with(1,2,3).and_return(thread)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
+        subject.post(1,2,3){ nil }
+      end
+
+      it 'executes a call with one argument' do
+        @expected = 0
+        subject.post(1){|one| @expected = one }
+        sleep(0.1)
+        @expected.should == 1
+      end
+
+      it 'executes a call with multiple arguments' do
+        @expected = nil
+        subject.post(1,2,3,4,5){|*args| @expected = args }
+        sleep(0.1)
+        @expected.should eq [1,2,3,4,5]
+      end
+
+      it 'aliases #<<' do
+        thread = Thread.new{ nil }
+        Thread.should_receive(:new).with(no_args()).and_return(thread)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
+        subject << proc{ nil }
+      end
+    end
+
+    context 'operation' do
+
+      context 'goroutine' do
+
+        it 'gets a new thread' do
+          $GLOBAL_THREAD_POOL = subject
+
+          t = Thread.new{ nil }
+
+          Thread.should_receive(:new).with(no_args()).and_return(t)
+          go{ nil }
+
+          Thread.should_receive(:new).with(1,2,3).and_return(t)
+          go(1,2,3){ nil }
+        end
+      end
+    end
+  end
 end

data/spec/concurrent/goroutine_spec.rb

@@ -48,20 +48,5 @@ module Concurrent
       sleep(0.1)
       @expected.should eq [1,2,3]
     end
-
-    it 'accepts an alternate thread pool as the first argument' do
-      pool = Concurrent::FixedThreadPool.new(2)
-      pool.should_receive(:post).with(no_args())
-      go(pool){ sleep(0.1) }
-      sleep(0.2)
-    end
-
-    it 'passes all other arguments to the block when a thread pool is given' do
-      @expected = nil
-      pool = Concurrent::FixedThreadPool.new(2)
-      go(pool, 1, 2, 3){|a, b, c| @expected = [c, b, a] }
-      sleep(0.1)
-      @expected.should eq [3, 2, 1]
-    end
   end
 end

data/spec/concurrent/obligation_shared.rb

@@ -38,7 +38,7 @@ share_examples_for Concurrent::Obligation do
     end
 
     it 'returns immediately when timeout is zero' do
-      Timeout.should_not_receive(:timeout).with(any_args())
+      Concurrent.should_not_receive(:timeout).with(any_args())
       f = pending_subject
       f.value(0).should be_nil
       f.should be_pending
@@ -87,41 +87,4 @@ share_examples_for Concurrent::Obligation do
       rejected_subject.reason.to_s.should =~ /#{rejected_reason}/
     end
   end
-
-  context 'Kernel aliases' do
-
-    it 'aliases Kernel#deref for #deref' do
-      deref(fulfilled_subject).should eq fulfilled_value
-      deref(fulfilled_subject, 0).should eq fulfilled_value
-    end
-
-    it 'aliases Kernel#pending? for #pending?' do
-      #NOTE: was structured like others but was incorrectly failing
-      # on fulfilled_subject
-      fulfilled_subject.should_receive(:pending?).once
-      pending?(fulfilled_subject)
-      pending_subject.should_receive(:pending?).once
-      pending?(pending_subject)
-      rejected_subject.should_receive(:pending?).once
-      pending?(rejected_subject)
-    end
-
-    it 'aliases Kernel#fulfilled? for #fulfilled?' do
-      fulfilled?(fulfilled_subject).should be_true
-      fulfilled?(pending_subject).should be_false
-      fulfilled?(rejected_subject).should be_false
-    end
-
-    it 'aliases Kernel#realized? for #realized?' do
-      realized?(fulfilled_subject).should be_true
-      realized?(pending_subject).should be_false
-      realized?(rejected_subject).should be_false
-    end
-
-    it 'aliases Kernel#rejected? for #rejected?' do
-      rejected?(rejected_subject).should be_true
-      rejected?(fulfilled_subject).should be_false
-      rejected?(pending_subject).should be_false
-    end
-  end
 end

data/spec/concurrent/promise_spec.rb

@@ -31,25 +31,6 @@ module Concurrent
 
     it_should_behave_like Concurrent::Obligation
 
-    context 'behavior' do
-
-      it 'implements :promise behavior' do
-        lambda {
-          Promise.new{ nil }
-        }.should_not raise_error
-
-        Promise.new{ nil }.behaves_as?(:promise).should be_true
-      end
-
-      it 'implements :future behavior' do
-        lambda {
-          Promise.new{ nil }
-        }.should_not raise_error
-
-        Promise.new{ nil }.behaves_as?(:future).should be_true
-      end
-    end
-
     context '#then' do
 
       it 'returns a new Promise when :pending' do
@@ -154,8 +135,8 @@ module Concurrent
     context 'rejection' do
 
       it 'sets the promise reason the error object on exception' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
-        sleep(0.1)
+        p = Promise.new{ sleep(0.1); raise StandardError.new('Boom!') }
+        sleep(0.2)
         p.reason.should be_a(StandardError)
         p.reason.should.to_s =~ /Boom!/
       end
@@ -167,36 +148,36 @@ module Concurrent
       end
 
       it 'recursively rejects all children' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
+        p = Promise.new{ sleep(0.1); raise StandardError.new('Boom!') }
         promises = 10.times.collect{ p.then{ true } }
-        sleep(0.1)
+        sleep(0.5)
         10.times.each{|i| promises[i].should be_rejected }
       end
 
       it 'skips processing rejected promises' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
+        p = Promise.new{ sleep(0.1); raise StandardError.new('Boom!') }
         promises = 3.times.collect{ p.then{ true } }
-        sleep(0.1)
+        sleep(0.5)
         promises.each{|p| p.value.should_not be_true }
       end
 
       it 'calls the first exception block with a matching class' do
         @expected = nil
-        Promise.new{ raise StandardError }.
+        Promise.new{ sleep(0.1); raise StandardError }.
           rescue(StandardError){|ex| @expected = 1 }.
           rescue(StandardError){|ex| @expected = 2 }.
           rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.1)
+        sleep(0.2)
         @expected.should eq 1
       end
 
       it 'matches all with a rescue with no class given' do
         @expected = nil
-        Promise.new{ raise NoMethodError }.
+        Promise.new{ sleep(0.1); raise NoMethodError }.
           rescue(LoadError){|ex| @expected = 1 }.
           rescue{|ex| @expected = 2 }.
           rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.1)
+        sleep(0.2)
         @expected.should eq 2
       end
 
@@ -204,84 +185,84 @@ module Concurrent
         Promise.thread_pool = CachedThreadPool.new
 
         @expected = nil
-        Promise.new{ raise ArgumentError }.
+        Promise.new{ sleep(0.1); raise ArgumentError }.
           rescue(ArgumentError){|ex| @expected = 1 }.
           rescue(LoadError){|ex| @expected = 2 }.
           rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.1)
+        sleep(0.2)
         @expected.should eq 1
 
         @expected = nil
-        Promise.new{ raise LoadError }.
+        Promise.new{ sleep(0.1); raise LoadError }.
           rescue(ArgumentError){|ex| @expected = 1 }.
           rescue(LoadError){|ex| @expected = 2 }.
           rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.1)
+        sleep(0.2)
         @expected.should eq 2
 
         @expected = nil
-        Promise.new{ raise StandardError }.
+        Promise.new{ sleep(0.1); raise StandardError }.
           rescue(ArgumentError){|ex| @expected = 1 }.
           rescue(LoadError){|ex| @expected = 2 }.
           rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.1)
+        sleep(0.2)
         @expected.should eq 3
       end
 
       it 'passes the exception object to the matched block' do
         @expected = nil
-        Promise.new{ raise StandardError }.
+        Promise.new{ sleep(0.1); raise StandardError }.
           rescue(ArgumentError){|ex| @expected = ex }.
           rescue(LoadError){|ex| @expected = ex }.
           rescue(StandardError){|ex| @expected = ex }
-        sleep(0.1)
+        sleep(0.2)
         @expected.should be_a(StandardError)
       end
 
       it 'ignores rescuers without a block' do
         @expected = nil
-        Promise.new{ raise StandardError }.
+        Promise.new{ sleep(0.1); raise StandardError }.
           rescue(StandardError).
           rescue(StandardError){|ex| @expected = ex }
-        sleep(0.1)
+        sleep(0.2)
         @expected.should be_a(StandardError)
       end
 
       it 'supresses the exception if no rescue matches' do
         lambda {
-          Promise.new{ raise StandardError }.
+          Promise.new{ sleep(0.1); raise StandardError }.
             rescue(ArgumentError){|ex| @expected = ex }.
             rescue(NotImplementedError){|ex| @expected = ex }.
             rescue(NoMethodError){|ex| @expected = ex }
-          sleep(0.1)
+          sleep(0.2)
         }.should_not raise_error
       end
 
       it 'supresses exceptions thrown from rescue handlers' do
         lambda {
-          Promise.new{ raise ArgumentError }.
+          Promise.new{ sleep(0.1); raise ArgumentError }.
           rescue(StandardError){ raise StandardError }
-          sleep(0.1)
+          sleep(0.2)
         }.should_not raise_error
       end
 
       it 'calls matching rescue handlers on all children' do
         @expected = []
-        Promise.new{ raise StandardError }.
+        Promise.new{ sleep(0.1); raise StandardError }.
           then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
           then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
           then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
           then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
           then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }
-        sleep(0.1)
+        sleep(1)
 
         @expected.length.should eq 5
       end
 
       it 'matches a rescue handler added after rejection' do
         @expected = false
-        p = Promise.new{ raise StandardError }
-        sleep(0.1)
+        p = Promise.new{ sleep(0.1); raise StandardError }
+        sleep(0.2)
         p.rescue(StandardError){ @expected = true }
         @expected.should be_true
       end