Reliably testing concurrency abstractions will be the death of me.

Author: jdantonio

spec/concurrent/executor/thread_pool_executor_shared.rb

@@ -465,7 +465,7 @@
 
     context ':caller_runs' do
 
-      subject do
+      let(:executor) do
         described_class.new(
           min_threads: 1,
           max_threads: 1,
@@ -475,14 +475,20 @@
         )
       end
 
+      after(:each) do
+        # need to replicate this w/i scope otherwise rspec may complain
+        executor.kill
+        executor.wait_for_termination(0.1)
+      end
+
       specify '#post does not create any new threads when the queue is at capacity' do
         trigger = Concurrent::Event.new
         initial = Thread.list.length
 
         # Post several tasks to the executor. Has to be a new thread,
         # because it will start blocking once the queue fills up.
         Thread.new do
-          5.times{ subject.post{ trigger.wait } }
+          5.times{ executor.post{ trigger.wait } }
         end
 
         expect(Thread.list.length).to be < initial + 1 + 5
@@ -494,32 +500,32 @@
       specify '#<< executes the task on the current thread when the queue is at capacity' do
         trigger = Concurrent::Event.new
         latch = Concurrent::CountDownLatch.new(5)
-        subject.post{ trigger.wait }
-        5.times{|i| subject << proc { latch.count_down } }
+        executor.post{ trigger.wait }
+        5.times{|i| executor << proc { latch.count_down } }
         latch.wait(0.1)
         trigger.set
       end
 
       specify '#post executes the task on the current thread when the queue is at capacity' do
         trigger = Concurrent::Event.new
         latch = Concurrent::CountDownLatch.new(5)
-        subject.post{ trigger.wait }
-        5.times{|i| subject.post{ latch.count_down } }
+        executor.post{ trigger.wait }
+        5.times{|i| executor.post{ latch.count_down } }
         latch.wait(0.1)
         trigger.set
       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 }
+        executor.shutdown
+        executor.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 }
+        executor.shutdown
+        executor << proc { latch.count_down }
         latch.wait(0.1)
       end
     end