concurrent-ruby 0.6.1 → 0.7.0.rc0

data/spec/concurrent/actress_spec.rb

@@ -1,211 +0,0 @@
-require 'spec_helper'
-require 'concurrent/actress'
-
-module Concurrent
-  module Actress
-    i_know_it_is_experimental!
-
-    class Reference
-      def backdoor(&block)
-        core.send :schedule_execution do
-          core.instance_eval &block
-        end
-      end
-    end
-
-    describe 'Concurrent::Actress' do
-      prepend_before do
-        do_no_reset!
-      end
-
-      def terminate_actors(*actors)
-        actors.each do |actor|
-          actor.backdoor { terminate! }
-          actor.terminated.wait
-        end
-      end
-
-      class Ping
-        include Context
-
-        def initialize(queue)
-          @queue = queue
-        end
-
-        def on_message(message)
-          case message
-          when :terminate
-            terminate!
-          when :child
-            AdHoc.spawn(:pong, @queue) { |queue| -> m { queue << m } }
-          else
-            @queue << message
-            message
-          end
-        end
-      end
-
-      # def trace!
-      #   set_trace_func proc { |event, file, line, id, binding, classname|
-      #     # thread = eval('Thread.current', binding).object_id.to_s(16)
-      #     printf "%8s %20s %20s %s %s:%-2d\n", event, id, classname, nil, file, line
-      #   }
-      #   yield
-      # ensure
-      #   set_trace_func nil
-      # end
-
-      describe 'stress test' do
-        1.times do |i|
-          it format('run %3d', i) do
-            # puts format('run %3d', i)
-            Array.new(10).map do
-              Thread.new do
-                10.times do
-                  # trace! do
-                  queue = Queue.new
-                  actor = Ping.spawn :ping, queue
-
-                  # when spawn returns children are set
-                  Concurrent::Actress::ROOT.send(:core).instance_variable_get(:@children).should include(actor)
-
-                  actor << 'a' << 1
-                  queue.pop.should eq 'a'
-                  actor.ask(2).value.should eq 2
-
-                  actor.parent.should eq Concurrent::Actress::ROOT
-                  Concurrent::Actress::ROOT.path.should eq '/'
-                  actor.path.should eq '/ping'
-                  child = actor.ask(:child).value
-                  child.path.should eq '/ping/pong'
-                  queue.clear
-                  child.ask(3)
-                  queue.pop.should eq 3
-
-                  actor << :terminate
-                  actor.ask(:blow_up).wait.should be_rejected
-                  terminate_actors actor, child
-                end
-              end
-            end.each(&:join)
-          end
-        end
-      end
-
-      describe 'spawning' do
-        describe 'Actress#spawn' do
-          behaviour = -> v { -> _ { v } }
-          subjects  = { spawn:                 -> { Actress.spawn(AdHoc, :ping, 'arg', &behaviour) },
-                        context_spawn:         -> { AdHoc.spawn(:ping, 'arg', &behaviour) },
-                        spawn_by_hash:         -> { Actress.spawn(class: AdHoc, name: :ping, args: ['arg'], &behaviour) },
-                        context_spawn_by_hash: -> { AdHoc.spawn(name: :ping, args: ['arg'], &behaviour) } }
-
-          subjects.each do |desc, subject_definition|
-            describe desc do
-              subject &subject_definition
-              after { terminate_actors subject }
-              its(:path) { should eq '/ping' }
-              its(:parent) { should eq ROOT }
-              its(:name) { should eq 'ping' }
-              it('executor should be global') { subject.executor.should eq Concurrent.configuration.global_task_pool }
-              its(:reference) { should eq subject }
-              it 'returns ars' do
-                subject.ask!(:anything).should eq 'arg'
-              end
-            end
-          end
-        end
-
-        it 'terminates on failed initialization' do
-          a = AdHoc.spawn(name: :fail, logger: Concurrent.configuration.no_logger) { raise }
-          a.ask(nil).wait.rejected?.should be_true
-          a.terminated?.should be_true
-        end
-
-        it 'terminates on failed initialization and raises with spawn!' do
-          expect do
-            AdHoc.spawn!(name: :fail, logger: Concurrent.configuration.no_logger) { raise 'm' }
-          end.to raise_error(StandardError, 'm')
-        end
-
-        it 'terminates on failed message processing' do
-          a = AdHoc.spawn(name: :fail, logger: Concurrent.configuration.no_logger) { -> _ { raise } }
-          a.ask(nil).wait.rejected?.should be_true
-          a.terminated?.should be_true
-        end
-      end
-
-      describe 'messaging' do
-        subject { AdHoc.spawn(:add) { c = 0; -> v { c = c + v } } }
-        specify do
-          subject.tell(1).tell(1)
-          subject << 1 << 1
-          subject.ask(0).value!.should eq 4
-        end
-        after { terminate_actors subject }
-      end
-
-      describe 'children' do
-        let(:parent) do
-          AdHoc.spawn(:parent) do
-            -> message do
-              if message == :child
-                AdHoc.spawn(:child) { -> _ { parent } }
-              else
-                children
-              end
-            end
-          end
-        end
-
-        it 'has children set after a child is created' do
-          child = parent.ask!(:child)
-          parent.ask!(nil).should include(child)
-          child.ask!(nil).should eq parent
-
-          terminate_actors parent, child
-        end
-      end
-
-      describe 'envelope' do
-        subject { AdHoc.spawn(:subject) { -> _ { envelope } } }
-        specify do
-          envelope = subject.ask!('a')
-          envelope.should be_a_kind_of Envelope
-          envelope.message.should eq 'a'
-          envelope.ivar.should be_completed
-          envelope.ivar.value.should eq envelope
-          envelope.sender.should eq Thread.current
-          terminate_actors subject
-        end
-      end
-
-      describe 'termination' do
-        subject do
-          AdHoc.spawn(:parent) do
-            child = AdHoc.spawn(:child) { -> v { v } }
-            -> v do
-              if v == :terminate
-                terminate!
-              else
-                child
-              end
-            end
-          end
-        end
-
-        it 'terminates with all its children' do
-          child = subject.ask! :child
-          subject.terminated?.should be_false
-          subject.ask(:terminate).wait
-          subject.terminated?.should be_true
-          child.terminated.wait
-          child.terminated?.should be_true
-
-          terminate_actors subject, child
-        end
-      end
-
-    end
-  end
-end

data/spec/concurrent/agent_spec.rb

@@ -1,500 +0,0 @@
-require 'spec_helper'
-require_relative 'dereferenceable_shared'
-require_relative 'observable_shared'
-
-module Concurrent
-
-  describe Agent do
-
-    let(:executor) { PerThreadExecutor.new }
-
-    subject { Agent.new(0, executor: executor) }
-
-    let(:observer) do
-      Class.new do
-        attr_reader :value
-        define_method(:update) do |time, value|
-          @value = value
-        end
-      end.new
-    end
-
-    context '#send_off' do
-      subject { Agent.new 2, executor: executor }
-
-      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
-
-      def dereferenceable_subject(value, opts = {})
-        opts = opts.merge(executor: executor)
-        Agent.new(value, opts)
-      end
-
-      def dereferenceable_observable(opts = {})
-        opts = opts.merge(executor: executor)
-        Agent.new(0, opts)
-      end
-
-      def execute_dereferenceable(subject)
-        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
-
-      let(:executor) { ImmediateExecutor.new }
-
-      it 'sets the value to the given initial state' do
-        Agent.new(10).value.should eq 10
-      end
-
-      it 'sets the timeout to the given value' do
-        Agent.new(0, timeout: 5).timeout.should eq 5
-      end
-
-      it 'sets the timeout to the default when nil' do
-        Agent.new(0).timeout.should eq Agent::TIMEOUT
-      end
-
-      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 }
-      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 }
-      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 }
-      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 }
-      end
-    end
-
-    context '#rescue' do
-
-      it 'returns self when a block is given' do
-        a1 = subject
-        a2 = a1.rescue {}
-
-        a2.should be a1
-      end
-
-      it 'returns self when no block is given' do
-        a1 = subject
-        a2 = a1.rescue
-
-        a2.should be a1
-      end
-
-      it 'accepts an exception class as the first parameter' do
-        lambda {
-          subject.rescue(StandardError) {}
-        }.should_not raise_error
-      end
-
-      it 'ignores rescuers without a block' do
-        subject.rescue
-        subject.instance_variable_get(:@rescuers).should be_empty
-      end
-    end
-
-    context '#validate' do
-
-      it 'returns self when a block is given' do
-        a1 = subject
-        a2 = a1.validate {}
-
-        a2.should be a1
-      end
-
-      it 'returns self when no block is given' do
-        a1 = subject
-        a2 = a1.validate
-
-        a2.should be a1
-      end
-
-      it 'ignores validators without a block' do
-        default_validator = subject.instance_variable_get(:@validator)
-        subject.validate
-        subject.instance_variable_get(:@validator).should be default_validator
-      end
-    end
-
-    context '#post' do
-
-      it 'adds the given block to the queue' do
-        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(:@serialized_execution).
-            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(0).times
-        subject.post
-        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
-
-      it 'process each block in the queue' do
-        @expected = []
-        subject.post { @expected << 1 }
-        subject.post { @expected << 2 }
-        subject.post { @expected << 3 }
-        sleep(0.1)
-        @expected.sort.should eq [1, 2, 3]
-      end
-
-      it 'passes the current value to the handler' do
-        @expected = nil
-        Agent.new(10, executor: executor).post { |i| @expected = i }
-        sleep(0.1)
-        @expected.should eq 10
-      end
-
-      it 'sets the value to the handler return value on success' do
-        subject.post { 100 }
-        sleep(0.1)
-        subject.value.should eq 100
-      end
-
-      it 'rejects the handler after timeout reached' do
-        agent = Agent.new(0, timeout: 0.1, executor: executor)
-        agent.post { sleep(1); 10 }
-        agent.value.should eq 0
-      end
-    end
-
-    context 'validation' do
-
-      it 'processes the validator when present' do
-        @expected = nil
-        subject.validate { @expected = 10; true }
-        subject.post { nil }
-        sleep(0.1)
-        @expected.should eq 10
-      end
-
-      it 'passes the new value to the validator' do
-        @expected = nil
-        subject.validate { |v| @expected = v; true }
-        subject.post { 10 }
-        sleep(0.1)
-        @expected.should eq 10
-      end
-
-      it 'sets the new value when the validator returns true' do
-        agent = Agent.new(0, executor: executor).validate { true }
-        agent.post { 10 }
-        sleep(0.1)
-        agent.value.should eq 10
-      end
-
-      it 'does not change the value when the validator returns false' do
-        agent = Agent.new(0, executor: executor).validate { false }
-        agent.post { 10 }
-        sleep(0.1)
-        agent.value.should eq 0
-      end
-
-      it 'does not change the value when the validator raises an exception' do
-        agent = Agent.new(0, executor: executor).validate { raise StandardError }
-        agent.post { 10 }
-        sleep(0.1)
-        agent.value.should eq 0
-      end
-    end
-
-    context 'rejection' do
-
-      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
-
-      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
-
-      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
-
-        @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
-
-      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
-
-      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
-
-      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 }
-          subject.post { raise StandardError }
-          sleep(0.1)
-        }.should_not raise_error
-      end
-
-      it 'suppresses exceptions thrown from rescue handlers' do
-        lambda {
-          subject.rescue(StandardError) { raise StandardError }
-          subject.post { raise ArgumentError }
-          sleep(0.1)
-        }.should_not raise_error
-      end
-    end
-
-    context 'observation' do
-
-      it 'notifies all observers when the value changes' do
-        agent = Agent.new(0, executor: executor)
-        agent.add_observer(observer)
-        agent.post { 10 }
-        sleep(0.1)
-        observer.value.should eq 10
-      end
-
-      it 'does not notify removed observers when the value changes' do
-        agent = Agent.new(0, executor: executor)
-        agent.add_observer(observer)
-        agent.delete_observer(observer)
-        agent.post { 10 }
-        sleep(0.1)
-        observer.value.should be_nil
-      end
-
-      it 'does not notify observers when validation fails' do
-        agent = Agent.new(0, executor: executor)
-        agent.validate { false }
-        agent.add_observer(observer)
-        agent.post { 10 }
-        sleep(0.1)
-        observer.value.should be_nil
-      end
-
-      it 'does not notify observers when the handler raises an exception' do
-        agent = Agent.new(0, executor: executor)
-        agent.add_observer(observer)
-        agent.post { raise StandardError }
-        sleep(0.1)
-        observer.value.should be_nil
-      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
-        Agent.new(10, executor: executor).deref.should eq 10
-      end
-
-      it 'aliases #validates for :validate' do
-        @expected = nil
-        subject.validates { |v| @expected = v }
-        subject.post { 10 }
-        sleep(0.1)
-        @expected.should eq 10
-      end
-
-      it 'aliases #validate_with for :validate' do
-        @expected = nil
-        subject.validate_with { |v| @expected = v }
-        subject.post { 10 }
-        sleep(0.1)
-        @expected.should eq 10
-      end
-
-      it 'aliases #validates_with for :validate' do
-        @expected = nil
-        subject.validates_with { |v| @expected = v }
-        subject.post { 10 }
-        sleep(0.1)
-        @expected.should eq 10
-      end
-
-      it 'aliases #catch for #rescue' do
-        @expected = nil
-        subject.catch { @expected = true }
-        subject.post { raise StandardError }
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'aliases #on_error for #rescue' do
-        @expected = nil
-        subject.on_error { @expected = true }
-        subject.post { raise StandardError }
-        sleep(0.1)
-        @expected.should be_true
-      end
-    end
-  end
-end