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

data/spec/concurrent/agent_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require_relative 'dereferenceable_shared'
+require_relative 'observable_shared'
 
 module Concurrent
 
@@ -18,6 +19,17 @@ module Concurrent
       end.new
     end
 
+    context '#send_off' do
+      subject { Agent.new 2 }
+
+      it 'executes post and post-off in order' do
+        subject.post { |v| v + 2 }
+        subject.post_off { |v| v * 3 }
+        subject.await
+        subject.value.should eq 12
+      end
+    end
+
     context 'behavior' do
 
       # dereferenceable
@@ -33,11 +45,22 @@ module Concurrent
       end
 
       def execute_dereferenceable(subject)
-        subject.post{|value| 10 }
+        subject.post { |value| 10 }
         sleep(0.1)
       end
 
       it_should_behave_like :dereferenceable
+
+      # observable
+
+      subject { Agent.new(0) }
+
+      def trigger_observable(observable)
+        observable.post { nil }
+        sleep(0.1)
+      end
+
+      it_should_behave_like :observable
     end
 
     context '#initialize' do
@@ -59,25 +82,25 @@ module Concurrent
       it 'uses the executor given with the :executor option' do
         executor.should_receive(:post).with(any_args).and_return(0)
         agent = Agent.new(0, executor: executor)
-        agent.post{|value| 0 }
+        agent.post { |value| 0 }
       end
 
       it 'uses the global operation pool when :operation is true' do
         Concurrent.configuration.should_receive(:global_operation_pool).and_return(executor)
         agent = Agent.new(0, operation: true)
-        agent.post{|value| 0 }
+        agent.post { |value| 0 }
       end
 
       it 'uses the global task pool when :task is true' do
         Concurrent.configuration.should_receive(:global_task_pool).and_return(executor)
         agent = Agent.new(0, task: true)
-        agent.post{|value| 0 }
+        agent.post { |value| 0 }
       end
 
       it 'uses the global task pool by default' do
         Concurrent.configuration.should_receive(:global_task_pool).and_return(executor)
         agent = Agent.new(0)
-        agent.post{|value| 0 }
+        agent.post { |value| 0 }
       end
     end
 
@@ -135,20 +158,54 @@ module Concurrent
     context '#post' do
 
       it 'adds the given block to the queue' do
-        executor.should_receive(:post).with(no_args).exactly(3).times
-        subject.post { sleep(100) }
+        executor.should_receive(:post).with(no_args).exactly(1).times
+        subject.post { sleep(1) }
         subject.post { nil }
         subject.post { nil }
         sleep(0.1)
+        subject.
+            instance_variable_get(:@one_by_one).
+            instance_variable_get(:@stash).
+            size.should eq 2
       end
 
       it 'does not add to the queue when no block is given' do
-        executor.should_receive(:post).with(no_args).exactly(2).times
-        subject.post { sleep(100) }
+        executor.should_receive(:post).with(no_args).exactly(0).times
         subject.post
-        subject.post { nil }
         sleep(0.1)
       end
+
+      it 'works with ImmediateExecutor' do
+        agent = Agent.new(0, executor: ImmediateExecutor.new)
+        agent.post { |old| old + 1 }
+        agent.post { |old| old + 1 }
+        agent.value.should eq 2
+      end
+
+    end
+
+    context '#await' do
+
+      it 'waits until already sent updates are done' do
+        fn = false
+        subject.post { fn = true; sleep 0.1 }
+        subject.await
+        fn.should be_true
+      end
+
+      it 'does not waits until updates sent after are done' do
+        fn = false
+        subject.await
+        subject.post { fn = true; sleep 0.1 }
+        fn.should be_false
+      end
+
+      it 'does not alter the value' do
+        subject.post { |v| v + 1 }
+        subject.await
+        subject.value.should eq 1
+      end
+
     end
 
     context 'fulfillment' do
@@ -227,85 +284,85 @@ module Concurrent
       it 'calls the first exception block with a matching class' do
         @expected = nil
         subject.
-      rescue(StandardError) { |ex| @expected = 1 }.
-        rescue(StandardError) { |ex| @expected = 2 }.
-        rescue(StandardError) { |ex| @expected = 3 }
-          subject.post { raise StandardError }
-          sleep(0.1)
-          @expected.should eq 1
-        end
+            rescue(StandardError) { |ex| @expected = 1 }.
+            rescue(StandardError) { |ex| @expected = 2 }.
+            rescue(StandardError) { |ex| @expected = 3 }
+        subject.post { raise StandardError }
+        sleep(0.1)
+        @expected.should eq 1
+      end
 
       it 'matches all with a rescue with no class given' do
         @expected = nil
         subject.
-      rescue(LoadError) { |ex| @expected = 1 }.
-        rescue { |ex| @expected = 2 }.
-        rescue(StandardError) { |ex| @expected = 3 }
-          subject.post { raise NoMethodError }
-          sleep(0.1)
-          @expected.should eq 2
-        end
+            rescue(LoadError) { |ex| @expected = 1 }.
+            rescue { |ex| @expected = 2 }.
+            rescue(StandardError) { |ex| @expected = 3 }
+        subject.post { raise NoMethodError }
+        sleep(0.1)
+        @expected.should eq 2
+      end
 
       it 'searches associated rescue handlers in order' do
         @expected = nil
         subject.
-      rescue(ArgumentError) { |ex| @expected = 1 }.
-        rescue(LoadError) { |ex| @expected = 2 }.
-        rescue(StandardError) { |ex| @expected = 3 }
-          subject.post { raise ArgumentError }
-          sleep(0.1)
-          @expected.should eq 1
+            rescue(ArgumentError) { |ex| @expected = 1 }.
+            rescue(LoadError) { |ex| @expected = 2 }.
+            rescue(StandardError) { |ex| @expected = 3 }
+        subject.post { raise ArgumentError }
+        sleep(0.1)
+        @expected.should eq 1
 
-          @expected = nil
-          subject.
-        rescue(ArgumentError) { |ex| @expected = 1 }.
-          rescue(LoadError) { |ex| @expected = 2 }.
-          rescue(StandardError) { |ex| @expected = 3 }
-            subject.post { raise LoadError }
-            sleep(0.1)
-            @expected.should eq 2
-
-            @expected = nil
-            subject.
-          rescue(ArgumentError) { |ex| @expected = 1 }.
+        @expected = nil
+        subject.
+            rescue(ArgumentError) { |ex| @expected = 1 }.
+            rescue(LoadError) { |ex| @expected = 2 }.
+            rescue(StandardError) { |ex| @expected = 3 }
+        subject.post { raise LoadError }
+        sleep(0.1)
+        @expected.should eq 2
+
+        @expected = nil
+        subject.
+            rescue(ArgumentError) { |ex| @expected = 1 }.
             rescue(LoadError) { |ex| @expected = 2 }.
             rescue(StandardError) { |ex| @expected = 3 }
-              subject.post { raise StandardError }
-              sleep(0.1)
-              @expected.should eq 3
-            end
+        subject.post { raise StandardError }
+        sleep(0.1)
+        @expected.should eq 3
+      end
 
       it 'passes the exception object to the matched block' do
         @expected = nil
         subject.
-      rescue(ArgumentError) { |ex| @expected = ex }.
-        rescue(LoadError) { |ex| @expected = ex }.
-        rescue(StandardError) { |ex| @expected = ex }
-          subject.post { raise StandardError }
-          sleep(0.1)
-          @expected.should be_a(StandardError)
-        end
+            rescue(ArgumentError) { |ex| @expected = ex }.
+            rescue(LoadError) { |ex| @expected = ex }.
+            rescue(StandardError) { |ex| @expected = ex }
+        subject.post { raise StandardError }
+        sleep(0.1)
+        @expected.should be_a(StandardError)
+      end
 
       it 'ignores rescuers without a block' do
         @expected = nil
         subject.
-      rescue(StandardError).
-        rescue(StandardError) { |ex| @expected = ex }
-          subject.post { raise StandardError }
-          sleep(0.1)
-          @expected.should be_a(StandardError)
-        end
+            rescue(StandardError).
+            rescue(StandardError) { |ex| @expected = ex }
+        subject.post { raise StandardError }
+        sleep(0.1)
+        @expected.should be_a(StandardError)
+      end
 
       it 'supresses the exception if no rescue matches' do
         lambda {
           subject.
-      rescue(ArgumentError) { |ex| @expected = ex }.
-        rescue(NotImplementedError) { |ex| @expected = ex }.
-        rescue(NoMethodError) { |ex| @expected = ex }
+              rescue(ArgumentError) { |ex| @expected = ex }.
+              rescue(NotImplementedError) { |ex| @expected = ex }.
+              rescue(NoMethodError) { |ex| @expected = ex }
           subject.post { raise StandardError }
           sleep(0.1)
         }.should_not raise_error
-        end
+      end
 
       it 'suppresses exceptions thrown from rescue handlers' do
         lambda {
@@ -353,6 +410,46 @@ module Concurrent
       end
     end
 
+    context 'clojure-like behaviour' do
+      it 'does not block dereferencing when updating the value' do
+        continue = IVar.new
+        agent    = Agent.new(0, executor: executor)
+        agent.post { |old| old + continue.value }
+        sleep 0.1
+        Concurrent.timeout(0.2) { agent.value.should eq 0 }
+        continue.set 1
+        sleep 0.1
+      end
+
+      it 'does not allow to execute two updates at the same time' do
+        agent     = Agent.new(0, executor: executor)
+        continue1 = IVar.new
+        continue2 = IVar.new
+        f1        = f2 = false
+        agent.post { |old| f1 = true; old + continue1.value }
+        agent.post { |old| f2 = true; old + continue2.value }
+
+        sleep 0.1
+        f1.should eq true
+        f2.should eq false
+        agent.value.should eq 0
+
+        continue1.set 1
+        sleep 0.1
+        f1.should eq true
+        f2.should eq true
+        agent.value.should eq 1
+
+        continue2.set 1
+        sleep 0.1
+        f1.should eq true
+        f2.should eq true
+        agent.value.should eq 2
+      end
+
+      it 'waits with sending functions to other agents until update is done'
+    end
+
     context 'aliases' do
 
       it 'aliases #deref for #value' do
@@ -398,14 +495,6 @@ module Concurrent
         sleep(0.1)
         @expected.should be_true
       end
-
-      it 'aliases #add_watch for #add_observer' do
-        agent = Agent.new(0, executor: executor)
-        agent.add_watch(observer)
-        agent.post { 10 }
-        sleep(0.1)
-        observer.value.should eq 10
-      end
     end
   end
 end

data/spec/concurrent/atomic/atomic_boolean_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+share_examples_for :atomic_boolean do
+
+  describe 'construction' do
+
+    it 'sets the initial value' do
+      described_class.new(true).value.should be_true
+    end
+
+    it 'defaults the initial value to false' do
+      described_class.new.value.should be_false
+    end
+
+    it 'evaluates the truthiness of a true value' do
+      described_class.new(10).value.should be_true
+    end
+
+    it 'evaluates the truthiness of a false value' do
+      described_class.new(nil).value.should be_false
+    end
+  end
+
+  describe '#value' do
+
+    it 'returns the current value' do
+      counter = described_class.new(true)
+      counter.value.should be_true
+      counter.make_false
+      counter.value.should be_false
+      counter.make_true
+      counter.value.should be_true
+    end
+  end
+
+  describe '#value=' do
+
+    it 'sets the #value to the given `Boolean`' do
+      atomic = described_class.new(true)
+      atomic.value = false
+      atomic.value.should be_false
+    end
+
+    it 'returns the new value' do
+      atomic = described_class.new(false)
+      (atomic.value = true).should be_true
+    end
+
+    it 'evaluates the truthiness of a true value' do
+      atomic = described_class.new(false)
+      atomic.value = 10
+      atomic.value.should be_true
+    end
+
+    it 'evaluates the truthiness of a false value' do
+      atomic = described_class.new(true)
+      atomic.value = nil
+      atomic.value.should be_false
+    end
+  end
+
+  describe '#true?' do
+
+    specify { described_class.new(true).true?.should be_true }
+
+    specify { described_class.new(false).true?.should be_false }
+  end
+
+  describe '#false?' do
+
+    specify { described_class.new(true).false?.should be_false }
+
+    specify { described_class.new(false).false?.should be_true }
+  end
+
+  describe '#make_true' do
+
+    it 'makes a false value true and returns true' do
+      subject = described_class.new(false)
+      subject.make_true.should be_true
+      subject.value.should be_true
+    end
+
+    it 'keeps a true value true and returns false' do
+      subject = described_class.new(true)
+      subject.make_true.should be_false
+      subject.value.should be_true
+    end
+  end
+
+  describe '#make_false' do
+
+    it 'makes a true value false and returns true' do
+      subject = described_class.new(true)
+      subject.make_false.should be_true
+      subject.value.should be_false
+    end
+
+    it 'keeps a false value false and returns false' do
+      subject = described_class.new(false)
+      subject.make_false.should be_false
+      subject.value.should be_false
+    end
+  end
+end
+
+module Concurrent
+
+  describe MutexAtomicBoolean do
+
+    it_should_behave_like :atomic_boolean
+
+    specify 'construction is synchronized' do
+      mutex = double('mutex')
+      Mutex.should_receive(:new).once.with(no_args).and_return(mutex)
+      described_class.new
+    end
+
+    context 'instance methods' do
+
+      before(:each) do
+        mutex = double('mutex')
+        Mutex.stub(:new).with(no_args).and_return(mutex)
+        mutex.should_receive(:lock)
+        mutex.should_receive(:unlock)
+      end
+
+      specify 'value is synchronized' do
+        described_class.new.value
+      end
+
+      specify 'value= is synchronized' do
+        described_class.new.value = 10
+      end
+
+      specify 'true? is synchronized' do
+        described_class.new.true?
+      end
+
+      specify 'false? is synchronized' do
+        described_class.new.false?
+      end
+
+      specify 'make_true is synchronized' do
+        described_class.new.make_true
+      end
+
+      specify 'make_false is synchronized' do
+        described_class.new.make_false
+      end
+    end
+  end
+
+  if jruby?
+
+    describe JavaAtomicBoolean do
+      it_should_behave_like :atomic_boolean
+    end
+  end
+
+  describe AtomicBoolean do
+    if jruby?
+      it 'inherits from JavaAtomicBoolean' do
+        AtomicBoolean.ancestors.should include(JavaAtomicBoolean)
+      end
+    else
+      it 'inherits from MutexAtomicBoolean' do
+        AtomicBoolean.ancestors.should include(MutexAtomicBoolean)
+      end
+    end
+  end
+end