Fixes from testing under JRuby

Author: rkday

lib/concurrent/executor/executor.rb

@@ -252,7 +252,7 @@ module JavaExecutor
       }.freeze
 
       # @!macro executor_method_post
-      def post(*args)
+      def post(*args, &task)
         raise ArgumentError.new('no block given') unless block_given?
         return handle_fallback(*args, &task) unless running?
         executor_submit = @executor.java_method(:submit, [Runnable.java_class])

spec/concurrent/executor/ruby_thread_pool_executor_spec.rb

@@ -48,195 +48,5 @@ module Concurrent
         expect(subject.remaining_capacity).to be < expected_max
       end
     end
-
-    context '#fallback_policy' do
-
-      let!(:min_threads){ 1 }
-      let!(:max_threads){ 1 }
-      let!(:idletime){ 60 }
-      let!(:max_queue){ 1 }
-
-      context ':abort' do
-
-        subject do
-          described_class.new(
-            min_threads: min_threads,
-            max_threads: max_threads,
-            idletime: idletime,
-            max_queue: max_queue,
-            fallback_policy: :abort
-          )
-        end
-
-        specify '#post raises an error when the queue is at capacity' do
-          expect {
-            100.times{ subject.post{ sleep(1) } }
-          }.to raise_error(Concurrent::RejectedExecutionError)
-        end
-
-        specify '#<< raises an error when the queue is at capacity' do
-          expect {
-            100.times{ subject << proc { sleep(1) } }
-          }.to raise_error(Concurrent::RejectedExecutionError)
-        end
-
-        specify '#post raises an error when the executor is shutting down' do
-          expect {
-            subject.shutdown; subject.post{ sleep(1) }
-          }.to raise_error(Concurrent::RejectedExecutionError)
-        end
-
-        specify '#<< raises an error when the executor is shutting down' do
-          expect {
-            subject.shutdown; subject << proc { sleep(1) }
-          }.to raise_error(Concurrent::RejectedExecutionError)
-        end
-
-        specify 'a #post task is never executed when the queue is at capacity' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          10.times do
-            begin
-              subject.post{ executed.increment; sleep(0.1) }
-            rescue
-            end
-          end
-          sleep(0.2)
-          expect(executed.value).to be < 10
-        end
-
-        specify 'a #<< task is never executed when the queue is at capacity' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          10.times do
-            begin
-              subject << proc { executed.increment; sleep(0.1) }
-            rescue
-            end
-          end
-          sleep(0.2)
-          expect(executed.value).to be < 10
-        end
-      end
-
-      context ':discard' do
-
-        subject do
-          described_class.new(
-            min_threads: min_threads,
-            max_threads: max_threads,
-            idletime: idletime,
-            max_queue: max_queue,
-            fallback_policy: :discard
-          )
-        end
-
-        specify 'a #post task is never executed when the queue is at capacity' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          1000.times do
-            subject.post{ executed.increment }
-          end
-          sleep(0.1)
-          expect(executed.value).to be < 1000
-        end
-
-        specify 'a #<< task is never executed when the queue is at capacity' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          1000.times do
-            subject << proc { executed.increment }
-          end
-          sleep(0.1)
-          expect(executed.value).to be < 1000
-        end
-
-        specify 'a #post task is never executed when the executor is shutting down' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          subject.shutdown
-          subject.post{ executed.increment }
-          sleep(0.1)
-          expect(executed.value).to be 0
-        end
-
-        specify 'a #<< task is never executed when the executor is shutting down' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          subject.shutdown
-          subject << proc { executed.increment }
-          sleep(0.1)
-          expect(executed.value).to be 0
-        end
-
-        specify '#post returns false when the executor is shutting down' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          subject.shutdown
-          ret = subject.post{ executed.increment }
-          expect(ret).to be false
-        end
-      end
-
-      context ':caller_runs' do
-
-        subject do
-          described_class.new(
-            min_threads: 1,
-            max_threads: 1,
-            idletime: idletime,
-            max_queue: 1,
-            fallback_policy: :caller_runs
-          )
-        end
-
-        specify '#post does not create any new threads when the queue is at capacity' do
-          initial = Thread.list.length
-          5.times{ subject.post{ sleep(0.1) } }
-          expect(Thread.list.length).to be < initial + 5
-        end
-
-        specify '#<< executes the task on the current thread when the queue is at capacity' do
-          expect(subject).to receive(:handle_fallback).with(any_args).at_least(:once)
-          5.times{ subject << proc { sleep(0.1) } }
-        end
-
-        specify '#post executes the task on the current thread when the queue is at capacity' do
-          latch = Concurrent::CountDownLatch.new(5)
-          subject.post{ sleep(1) }
-          5.times{|i| subject.post{ latch.count_down } }
-          latch.wait(0.1)
-        end
-
-        specify '#post executes the task on the current thread when the executor is shutting down' do
-          latch = Concurrent::CountDownLatch.new(1)
-          subject.shutdown
-          subject.post{ latch.count_down }
-          latch.wait(0.1)
-        end
-
-        specify '#<< executes the task on the current thread when the executor is shutting down' do
-          latch = Concurrent::CountDownLatch.new(1)
-          subject.shutdown
-          subject << proc { latch.count_down }
-          latch.wait(0.1)
-        end
-      end
-    end
-
-    context '#fallback_policy' do
-      context ':caller_runs is honoured even if the old fallback_policy arg is used' do
-
-        subject do
-          described_class.new(
-            min_threads: 1,
-            max_threads: 1,
-            idletime: 60,
-            max_queue: 1,
-            fallback_policy: :caller_runs
-          )
-        end
-
-        specify '#<< executes the task on the current thread when the executor is shutting down' do
-          latch = Concurrent::CountDownLatch.new(1)
-          subject.shutdown
-          subject << proc { latch.count_down }
-          latch.wait(0.1)
-        end
-      end
-    end
   end
 end