Replaced sleep statements in many tests.

Author: jdantonio

spec/concurrent/atomic/event_spec.rb

@@ -27,8 +27,8 @@ module Concurrent
 
       it 'triggers the event' do
         latch = CountDownLatch.new(1)
-        Thread.new{ subject.wait.tap{ latch.count_down } }
-        sleep(0.1)
+        t = Thread.new{ subject.wait.tap{ latch.count_down } }
+        t.join(0.1)
         subject.set
         expect(latch.wait(1)).to be true
       end
@@ -156,21 +156,19 @@ def subject.simulate_spurious_wake_up
 
       it 'should resist to spurious wake ups without timeout' do
         latch = CountDownLatch.new(1)
-        Thread.new{ subject.wait.tap{ latch.count_down } }
+        t = Thread.new{ subject.wait.tap{ latch.count_down } }
+        t.join(0.1)
 
-        sleep(0.1)
         subject.simulate_spurious_wake_up
-
         expect(latch.wait(0.1)).to be false
       end
 
       it 'should resist to spurious wake ups with timeout' do
         latch = CountDownLatch.new(1)
-        Thread.new{ subject.wait(0.3); latch.count_down }
+        t = Thread.new{ subject.wait(0.3); latch.count_down }
+        t.join(0.1)
 
-        sleep(0.1)
         subject.simulate_spurious_wake_up
-
         expect(latch.wait(0.1)).to be false
         expect(latch.wait(1)).to be true
       end

spec/concurrent/dataflow_spec.rb

@@ -223,12 +223,11 @@ def fib_with_dot(n)
           else
             n1 = fib_with_dot(n - 1)
             n2 = fib_with_dot(n - 2)
-            Concurrent.dataflow_with(root_executor, n1, n2) { n1.value + n2.value }
+            Concurrent.dataflow_with(ImmediateExecutor.new, n1, n2) { n1.value + n2.value }
           end
         end
 
         expected = fib_with_dot(7)
-        sleep(0.1)
         expect(expected.value).to eq 13
       end
 

spec/concurrent/executor/cached_thread_pool_spec.rb

@@ -4,13 +4,15 @@ module Concurrent
 
   describe CachedThreadPool do
 
+    let(:latch) { Concurrent::CountDownLatch.new }
+
     subject do
       described_class.new(fallback_policy: :discard)
     end
 
     after(:each) do
       subject.kill
-      sleep(0.1)
+      subject.wait_for_termination(1)
     end
 
     it_should_behave_like :thread_pool
@@ -42,13 +44,15 @@ module Concurrent
 
       it 'returns zero while running' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         expect(subject.min_length).to eq 0
       end
 
       it 'returns zero once shutdown' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         subject.shutdown
         subject.wait_for_termination(1)
         expect(subject.min_length).to eq 0
@@ -63,13 +67,15 @@ module Concurrent
 
       it 'returns :max_length while running' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         expect(subject.max_length).to eq described_class::DEFAULT_MAX_POOL_SIZE
       end
 
       it 'returns :max_length once shutdown' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         subject.shutdown
         subject.wait_for_termination(1)
         expect(subject.max_length).to eq described_class::DEFAULT_MAX_POOL_SIZE
@@ -84,13 +90,15 @@ module Concurrent
 
       it 'returns a non-zero number once tasks have been received' do
         10.times{ subject.post{ sleep(0.1) } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         expect(subject.largest_length).to be > 0
       end
 
       it 'returns a non-zero number after shutdown if tasks have been received' do
         10.times{ subject.post{ sleep(0.1) } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         subject.shutdown
         subject.wait_for_termination(1)
         expect(subject.largest_length).to be > 0

spec/concurrent/executor/executor_service_shared.rb

@@ -4,7 +4,7 @@
 
   after(:each) do
     subject.kill
-    sleep(0.1)
+    subject.wait_for_termination(0.1)
   end
 
   it_should_behave_like :global_thread_pool

spec/concurrent/executor/fixed_thread_pool_spec.rb

@@ -4,12 +4,14 @@ module Concurrent
 
   describe FixedThreadPool do
 
+    let(:latch) { Concurrent::CountDownLatch.new }
+
     let!(:num_threads){ 5 }
     subject { described_class.new(num_threads) }
 
     after(:each) do
       subject.kill
-      sleep(0.1)
+      subject.wait_for_termination(0.1)
     end
 
     it_should_behave_like :thread_pool
@@ -82,13 +84,15 @@ module Concurrent
 
       it 'returns :num_threads while running' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         expect(subject.min_length).to eq num_threads
       end
 
       it 'returns :num_threads once shutdown' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         subject.shutdown
         subject.wait_for_termination(1)
         expect(subject.min_length).to eq num_threads
@@ -103,13 +107,15 @@ module Concurrent
 
       it 'returns :num_threads while running' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         expect(subject.max_length).to eq num_threads
       end
 
       it 'returns :num_threads once shutdown' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         subject.shutdown
         subject.wait_for_termination(1)
         expect(subject.max_length).to eq num_threads
@@ -120,7 +126,8 @@ module Concurrent
 
       it 'returns :num_threads while running' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         expect(subject.length).to eq num_threads
       end
     end
@@ -133,13 +140,15 @@ module Concurrent
 
       it 'returns :num_threads while running' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         expect(subject.largest_length).to eq num_threads
       end
 
       it 'returns :num_threads once shutdown' do
         10.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         subject.shutdown
         subject.wait_for_termination(1)
         expect(subject.largest_length).to eq num_threads

spec/concurrent/executor/java_single_thread_executor_spec.rb

@@ -8,7 +8,7 @@ module Concurrent
 
       after(:each) do
         subject.kill
-        sleep(0.1)
+        subject.wait_for_termination(0.1)
       end
 
       subject { JavaSingleThreadExecutor.new }

spec/concurrent/executor/java_thread_pool_executor_spec.rb

@@ -8,7 +8,7 @@ module Concurrent
 
       after(:each) do
         subject.kill
-        sleep(0.1)
+        subject.wait_for_termination(0.1)
       end
 
       subject do

spec/concurrent/executor/ruby_single_thread_executor_spec.rb

@@ -6,7 +6,7 @@ module Concurrent
 
     after(:each) do
       subject.kill
-      sleep(0.1)
+      subject.wait_for_termination(0.1)
     end
 
     subject { RubySingleThreadExecutor.new }

spec/concurrent/executor/ruby_thread_pool_executor_spec.rb

@@ -4,9 +4,11 @@ module Concurrent
 
   describe RubyThreadPoolExecutor, :type=>:mrirbx do
 
+    let(:latch) { Concurrent::CountDownLatch.new }
+
     after(:each) do
       subject.kill
-      sleep(0.1)
+      subject.wait_for_termination(0.1)
     end
 
     subject do
@@ -39,13 +41,15 @@ module Concurrent
 
       it 'returns :max_length when no tasks are enqueued' do
         5.times{ subject.post{ nil } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         expect(subject.remaining_capacity).to eq expected_max
       end
 
       it 'returns the remaining capacity when tasks are enqueued' do
         100.times{ subject.post{ sleep(0.5) } }
-        sleep(0.1)
+        subject.post { latch.count_down }
+        latch.wait(0.1)
         expect(subject.remaining_capacity).to be < expected_max
       end
     end

spec/concurrent/executor/thread_pool_shared.rb

@@ -2,9 +2,11 @@
 
 shared_examples :thread_pool do
 
+  let(:latch) { Concurrent::CountDownLatch.new }
+
   after(:each) do
     subject.kill
-    sleep(0.1)
+    subject.wait_for_termination(0.1)
   end
 
   it_should_behave_like :executor_service
@@ -42,7 +44,8 @@
 
     it 'returns zero once shut down' do
       5.times{ subject.post{ sleep(0.1) } }
-      sleep(0.1)
+      subject.post { latch.count_down }
+      latch.wait(0.1)
       subject.shutdown
       subject.wait_for_termination(1)
       expect(subject.length).to eq 0
@@ -57,13 +60,15 @@
 
     it 'returns the approximate number of tasks that have been post thus far' do
       10.times{ subject.post{ nil } }
-      sleep(0.1)
+      subject.post { latch.count_down }
+      latch.wait(0.1)
       expect(subject.scheduled_task_count).to be > 0
     end
 
     it 'returns the approximate number of tasks that were post' do
       10.times{ subject.post{ nil } }
-      sleep(0.1)
+      subject.post { latch.count_down }
+      latch.wait(0.1)
       subject.shutdown
       subject.wait_for_termination(1)
       expect(subject.scheduled_task_count).to be > 0
@@ -79,17 +84,17 @@
     it 'returns the approximate number of tasks that have been completed thus far' do
       5.times{ subject.post{ raise StandardError } }
       5.times{ subject.post{ nil } }
-      sleep(0.1)
-      expect(subject.completed_task_count).to be > 0
+      subject.post { latch.count_down }
+      latch.wait(1)
+      expect(subject.completed_task_count).to be > 1
     end
 
     it 'returns the approximate number of tasks that were completed' do
       5.times{ subject.post{ raise StandardError } }
       5.times{ subject.post{ nil } }
-      sleep(0.1)
       subject.shutdown
       subject.wait_for_termination(1)
-      expect(subject.completed_task_count).to be > 0
+      expect(subject.completed_task_count).to be > 1
     end
   end