concurrent-ruby 0.6.0.pre.2 → 0.6.0

data/spec/concurrent/async_spec.rb

@@ -10,6 +10,9 @@ module Concurrent
       Class.new do
         include Concurrent::Async
         attr_accessor :accessor
+        def initialize
+          init_mutex
+        end
         def echo(msg)
           msg
         end
@@ -103,7 +106,7 @@ module Concurrent
     context 'executor' do
 
       it 'returns the default executor when #executor= has never been called' do
-        Concurrent.configuration.should_receive(:global_task_pool).
+        Concurrent.configuration.should_receive(:global_operation_pool).
           and_return(ImmediateExecutor.new)
         subject = async_class.new
         subject.async.echo(:foo)
@@ -117,10 +120,10 @@ module Concurrent
         subject.async.echo(:foo)
       end
 
-      it 'raises an exception if #executor= is called multiple times' do
+      it 'raises an exception if #executor= is called after initialization complete' do
         executor = ImmediateExecutor.new
         subject = async_class.new
-        subject.executor = executor
+        subject.async.echo(:foo)
         expect {
           subject.executor = executor
         }.to raise_error(ArgumentError)
@@ -303,6 +306,7 @@ module Concurrent
         object = Class.new {
           include Concurrent::Async
           attr_reader :bucket
+          def initialize() init_mutex; end
           def gather(seconds, first, *rest)
             sleep(seconds)
             (@bucket ||= []).concat([first])
@@ -315,6 +319,34 @@ module Concurrent
         object.await.gather(0, :c, :d)
         object.bucket.should eq [:a, :b, :c, :d]
       end
+
+      context 'raises an InitializationError' do
+
+        let(:async_class) do
+          Class.new do
+            include Concurrent::Async
+            def echo(msg) msg; end
+          end
+        end
+
+        it 'when #async is called before #init_mutex' do
+          expect {
+            async_class.new.async.echo(:foo)
+          }.to raise_error(Concurrent::InitializationError)
+        end
+
+        it 'when #await is called before #init_mutex' do
+          expect {
+            async_class.new.async.echo(:foo)
+          }.to raise_error(Concurrent::InitializationError)
+        end
+
+        it 'when #executor= is called before #init_mutex' do
+          expect {
+            async_class.new.executor = Concurrent::ImmediateExecutor.new
+          }.to raise_error(Concurrent::InitializationError)
+        end
+      end
     end
   end
 end

data/spec/concurrent/atomic/atomic_boolean_spec.rb

@@ -151,7 +151,7 @@ module Concurrent
     end
   end
 
-  if jruby?
+  if TestHelpers.jruby?
 
     describe JavaAtomicBoolean do
       it_should_behave_like :atomic_boolean

data/spec/concurrent/atomic/atomic_fixnum_spec.rb

@@ -165,7 +165,7 @@ module Concurrent
     end
   end
 
-  if jruby?
+  if TestHelpers.jruby?
 
     describe JavaAtomicFixnum do
       it_should_behave_like :atomic_fixnum

data/spec/concurrent/atomic/atomic_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+share_examples_for :atomic do
+
+  context 'construction' do
+
+    it 'sets the initial value' do
+      described_class.new(:foo).value.should eq :foo
+    end
+
+    it 'defaults the initial value to nil' do
+      described_class.new.value.should eq nil
+    end
+  end
+
+  context '#value' do
+
+    it 'returns the current value' do
+      counter = described_class.new(:foo)
+      counter.value.should eq :foo
+    end
+  end
+
+  context '#value=' do
+
+    it 'sets the #value to the given object' do
+      atomic = described_class.new(:foo)
+      atomic.value = :bar
+      atomic.value.should eq :bar
+    end
+
+    it 'returns the new value' do
+      atomic = described_class.new(:foo)
+      (atomic.value = :bar).should eq :bar
+    end
+  end
+
+  context '#modify' do
+
+    it 'yields the current value' do
+      atomic = described_class.new(:foo)
+      current = []
+      atomic.modify { |value| current << value }
+      current.should eq [:foo]
+    end
+
+    it 'stores the value returned from the yield' do
+      atomic = described_class.new(:foo)
+      atomic.modify { |value| :bar }
+      atomic.value.should eq :bar
+    end
+
+    it 'returns the new value' do
+      atomic = described_class.new(:foo)
+      atomic.modify{ |value| :bar }.should eq :bar
+    end
+  end
+
+  context '#compare_and_set' do
+
+    it 'returns false if the value is not found' do
+      described_class.new(:foo).compare_and_set(:bar, :foo).should eq false
+    end
+
+    it 'returns true if the value is found' do
+      described_class.new(:foo).compare_and_set(:foo, :bar).should eq true
+    end
+
+    it 'sets if the value is found' do
+      f = described_class.new(:foo)
+      f.compare_and_set(:foo, :bar)
+      f.value.should eq :bar
+    end
+
+    it 'does not set if the value is not found' do
+      f = described_class.new(:foo)
+      f.compare_and_set(:bar, :baz)
+      f.value.should eq :foo
+    end
+  end
+end
+
+module Concurrent
+
+  describe MutexAtomic do
+
+    it_should_behave_like :atomic
+
+    specify 'construction is synchronized' do
+      mutex = double('mutex')
+      Mutex.should_receive(:new).once.with(no_args).and_return(mutex)
+      described_class.new
+    end
+
+    specify 'value is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:lock)
+      mutex.should_receive(:unlock)
+      described_class.new.value
+    end
+
+    specify 'value= is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:lock)
+      mutex.should_receive(:unlock)
+      described_class.new.value = 10
+    end
+
+    specify 'modify is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:lock)
+      mutex.should_receive(:unlock)
+      described_class.new(:foo).modify { |value| value }
+    end
+
+    specify 'compare_and_set is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:lock)
+      mutex.should_receive(:unlock)
+      described_class.new(14).compare_and_set(14, 2)
+    end
+  end
+
+  describe Atomic do
+    it 'inherits from MutexAtomic' do
+      Atomic.ancestors.should include(MutexAtomic)
+    end
+  end
+end

data/spec/concurrent/atomic/count_down_latch_spec.rb

@@ -129,7 +129,7 @@ module Concurrent
     end
   end
 
-  if jruby?
+  if TestHelpers.jruby?
 
     describe JavaCountDownLatch do
 

data/spec/concurrent/collection/priority_queue_spec.rb

@@ -295,7 +295,7 @@ module Concurrent
     it_should_behave_like :priority_queue
   end
 
-  if jruby?
+  if TestHelpers.jruby?
 
     describe JavaPriorityQueue do
 

data/spec/concurrent/configuration_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 module Concurrent
 
   describe Configuration do
+    with_full_reset
 
     it 'creates a global timer pool' do
       Concurrent.configuration.global_timer_set.should_not be_nil
@@ -24,11 +25,12 @@ module Concurrent
         Concurrent.configuration.global_task_pool.should eq executor
       end
 
-      specify 'writer raises an exception if called twice' do
+      specify 'writer raises an exception if called after initialization' do
         executor = ImmediateExecutor.new
         Concurrent.configure do |config|
           config.global_task_pool = executor
         end
+        Concurrent.configuration.global_task_pool
         expect {
           Concurrent.configure do |config|
             config.global_task_pool = executor
@@ -52,11 +54,12 @@ module Concurrent
         Concurrent.configuration.global_operation_pool.should eq executor
       end
 
-      specify 'writer raises an exception if called twice' do
+      specify 'writer raises an exception if called after initialization' do
         executor = ImmediateExecutor.new
         Concurrent.configure do |config|
           config.global_operation_pool = executor
         end
+        Concurrent.configuration.global_operation_pool
         expect {
           Concurrent.configure do |config|
             config.global_operation_pool = executor

data/spec/concurrent/delay_spec.rb

@@ -53,6 +53,20 @@ module Concurrent
       end
     end
 
+
+    context '#reconfigure' do
+      it 'returns value of block used in reconfiguration' do
+        Delay.new { nil }.tap { |d| d.reconfigure { true } }.value.should be_true
+      end
+
+      it 'returns false when process completed?' do
+        d = Delay.new { 1 }
+        d.reconfigure { 2 }.should be_true
+        d.value.should be 2
+        d.reconfigure { 3 }.should be_false
+      end
+    end
+
     context '#value' do
 
       let(:task){ proc{ nil } }

data/spec/concurrent/exchanger_spec.rb

@@ -50,20 +50,15 @@ module Concurrent
       context 'with timeout' do
         it 'should block until timeout' do
 
-          latch = Concurrent::CountDownLatch.new(1)
           value = 0
           start = Time.now.to_f
 
-          t = Thread.new do
-            value = exchanger.exchange(2, 0.2)
-            latch.count_down
+          future = Concurrent::Future.execute do
+            exchanger.exchange(2, 0.2)
           end
-
-          latch.wait(1)
-
+          
+          future.value.should be_nil
           (Time.now.to_f - start).should >= 0.2
-          t.status.should be_false
-          value.should be_nil
         end
       end
     end

data/spec/concurrent/executor/java_cached_thread_pool_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-if jruby?
+if Concurrent::TestHelpers.jruby?
 
   require_relative 'cached_thread_pool_shared'
 

data/spec/concurrent/executor/java_fixed_thread_pool_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-if jruby?
+if Concurrent::TestHelpers.jruby?
 
   require_relative 'fixed_thread_pool_shared'
 

data/spec/concurrent/executor/java_single_thread_executor_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-if jruby?
+if Concurrent::TestHelpers.jruby?
 
   require_relative 'thread_pool_shared'
 

data/spec/concurrent/executor/java_thread_pool_executor_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-if jruby?
+if Concurrent::TestHelpers.jruby?
 
   require_relative 'thread_pool_executor_shared'
 

data/spec/concurrent/executor/ruby_thread_pool_executor_spec.rb

@@ -119,20 +119,20 @@ module Concurrent
 
         specify 'a #post task is never executed when the queue is at capacity' do
           executed = Concurrent::AtomicFixnum.new(0)
-          100.times do
+          1000.times do
             subject.post{ executed.increment }
           end
           sleep(0.1)
-          executed.value.should < 100
+          executed.value.should < 1000
         end
 
         specify 'a #<< task is never executed when the queue is at capacity' do
           executed = Concurrent::AtomicFixnum.new(0)
-          100.times do
+          1000.times do
             subject << proc { executed.increment }
           end
           sleep(0.1)
-          executed.value.should < 100
+          executed.value.should < 1000
         end
       end
 

data/spec/concurrent/ivar_spec.rb

@@ -108,7 +108,7 @@ module Concurrent
       it 'raises an exception if set more than once' do
         i = IVar.new
         i.set(14)
-        expect {i.set(2)}.to raise_error(MultipleAssignmentError)
+        expect {i.set(2)}.to raise_error(Concurrent::MultipleAssignmentError)
         i.value.should eq 14
       end
 
@@ -135,7 +135,7 @@ module Concurrent
       it 'raises an exception if set more than once' do
         i = IVar.new
         i.fail
-        expect {i.fail}.to raise_error(MultipleAssignmentError)
+        expect {i.fail}.to raise_error(Concurrent::MultipleAssignmentError)
         i.value.should be_nil
       end
 

data/spec/concurrent/obligation_spec.rb

@@ -30,24 +30,28 @@ module Concurrent
         obligation.should be_incomplete
       end
 
-      describe '#value' do
+      methods = [:value, :value!, :no_error!]
+      methods.each do |method|
+        describe "##{method}" do
 
-        it 'should return immediately if timeout is zero' do
-          obligation.value(0).should be_nil
-        end
+          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)
+          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.value
-        end
+            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)
 
-        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
 
-          obligation.value(5)
         end
       end
     end
@@ -98,6 +102,45 @@ module Concurrent
 
       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
 
@@ -115,26 +158,72 @@ module Concurrent
       it 'should be not incomplete' do
         obligation.should_not be_incomplete
       end
-    end
 
-    describe '#value' do
 
-      it 'should return immediately if timeout is zero' do
-        event.should_not_receive(:wait)
+      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
 
-        obligation.value(0).should be_nil
       end
 
-      it 'should return immediately if timeout is not set' do
-        event.should_not_receive(:wait)
+      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
 
-        obligation.value.should be_nil
       end
 
-      it 'should return immediately if timeout is not zero' do
-        event.should_not_receive(:wait)
+      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
 
-        obligation.value(5).should be_nil
       end
 
     end