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

data/spec/concurrent/atomic/atomic_fixnum_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+share_examples_for :atomic_fixnum do
+
+  context 'construction' do
+
+    it 'sets the initial value' do
+      described_class.new(10).value.should eq 10
+    end
+
+    it 'defaults the initial value to zero' do
+      described_class.new.value.should eq 0
+    end
+
+    it 'raises en exception if the initial value is not a Fixnum' do
+      lambda {
+        described_class.new(10.01)
+      }.should raise_error
+    end
+  end
+
+  context '#value' do
+
+    it 'returns the current value' do
+      counter = described_class.new(10)
+      counter.value.should eq 10
+      counter.increment
+      counter.value.should eq 11
+      counter.decrement
+      counter.value.should eq 10
+    end
+  end
+
+  context '#value=' do
+
+    it 'sets the #value to the given `Fixnum`' do
+      atomic = described_class.new(0)
+      atomic.value = 10
+      atomic.value.should eq 10
+    end
+
+    it 'returns the new value' do
+      atomic = described_class.new(0)
+      (atomic.value = 10).should eq 10
+    end
+
+    it 'raises and exception if the value is not a `Fixnum`' do
+      atomic = described_class.new(0)
+      expect {
+        atomic.value = 'foo'
+      }.to raise_error
+    end
+  end
+
+  context '#increment' do
+
+    it 'increases the value by one' do
+      counter = described_class.new(10)
+      3.times{ counter.increment }
+      counter.value.should eq 13
+    end
+
+    it 'returns the new value' do
+      counter = described_class.new(10)
+      counter.increment.should eq 11
+    end
+
+    it 'is aliased as #up' do
+      described_class.new(10).up.should eq 11
+    end
+  end
+
+  context '#decrement' do
+
+    it 'decreases the value by one' do
+      counter = described_class.new(10)
+      3.times{ counter.decrement }
+      counter.value.should eq 7
+    end
+
+    it 'returns the new value' do
+      counter = described_class.new(10)
+      counter.decrement.should eq 9
+    end
+
+    it 'is aliased as #down' do
+      described_class.new(10).down.should eq 9
+    end
+  end
+
+  context '#compare_and_set' do
+
+    it 'returns false if the value is not found' do
+      described_class.new(14).compare_and_set(2, 14).should eq false
+    end
+
+    it 'returns true if the value is found' do
+      described_class.new(14).compare_and_set(14, 2).should eq true
+    end
+
+    it 'sets if the value is found' do
+      f = described_class.new(14)
+      f.compare_and_set(14, 2)
+      f.value.should eq 2
+    end
+
+    it 'does not set if the value is not found' do
+      f = described_class.new(14)
+      f.compare_and_set(2, 12)
+      f.value.should eq 14
+    end
+  end
+end
+
+module Concurrent
+
+  describe MutexAtomicFixnum do
+
+    it_should_behave_like :atomic_fixnum
+
+    specify 'construction is synchronized' do
+      mutex = double('mutex')
+      Mutex.should_receive(:new).once.with(no_args).and_return(mutex)
+      described_class.new
+    end
+
+    specify 'value is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:lock)
+      mutex.should_receive(:unlock)
+      described_class.new.value
+    end
+
+    specify 'value= is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:lock)
+      mutex.should_receive(:unlock)
+      described_class.new.value = 10
+    end
+
+    specify 'increment is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:lock)
+      mutex.should_receive(:unlock)
+      described_class.new.increment
+    end
+
+    specify 'decrement is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:lock)
+      mutex.should_receive(:unlock)
+      described_class.new.decrement
+    end
+
+    specify 'compare_and_set is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:lock)
+      mutex.should_receive(:unlock)
+      described_class.new(14).compare_and_set(14, 2)
+    end
+  end
+
+  if jruby?
+
+    describe JavaAtomicFixnum do
+      it_should_behave_like :atomic_fixnum
+    end
+  end
+
+  describe AtomicFixnum do
+    if jruby?
+      it 'inherits from JavaAtomicFixnum' do
+        AtomicFixnum.ancestors.should include(JavaAtomicFixnum)
+      end
+    else
+      it 'inherits from MutexAtomicFixnum' do
+        AtomicFixnum.ancestors.should include(MutexAtomicFixnum)
+      end
+    end
+  end
+end

data/spec/concurrent/{condition_spec.rb → atomic/condition_spec.rb}

@@ -86,7 +86,7 @@ module Concurrent
             sleep(0.1)
             result.should be_woken_up
             result.should_not be_timed_out
-            result.remaining_time.should be_within(0.05).of(0.87)
+            result.remaining_time.should be_within(0.1).of(0.85)
             t.status.should be_false
           end
 
@@ -98,7 +98,7 @@ module Concurrent
             sleep(0.1)
             result.should be_woken_up
             result.should_not be_timed_out
-            result.remaining_time.should be_within(0.05).of(0.87)
+            result.remaining_time.should be_within(0.1).of(0.85)
             t.status.should be_false
           end
 

data/spec/concurrent/atomic/count_down_latch_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+share_examples_for :count_down_latch do
+
+  let(:latch) { described_class.new(3) }
+  let(:zero_count_latch) { described_class.new(0) }
+
+  context '#initialize' do
+
+    it 'raises an exception if the initial count is less than zero' do
+      expect {
+        described_class.new(-1)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an exception if the initial count is not an integer' do
+      expect {
+        described_class.new('foo')
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#count' do
+
+    it 'should be the value passed to the constructor' do
+      latch.count.should eq 3
+    end
+
+    it 'should be decreased after every count down' do
+      latch.count_down
+      latch.count.should eq 2
+    end
+
+    it 'should not go below zero' do
+      5.times { latch.count_down }
+      latch.count.should eq 0
+    end
+  end
+
+  describe '#wait' do
+
+    context 'count set to zero' do
+      it 'should return true immediately' do
+        result = zero_count_latch.wait
+        result.should be_true
+      end
+
+      it 'should return true immediately with timeout' do
+        result = zero_count_latch.wait(5)
+        result.should be_true
+      end
+    end
+
+    context 'non zero count' do
+
+      it 'should block thread until counter is set to zero' do
+        3.times do
+          Thread.new { sleep(0.1); latch.count_down }
+        end
+
+        result = latch.wait
+        result.should be_true
+        latch.count.should eq 0
+      end
+
+      it 'should block until counter is set to zero with timeout' do
+        3.times do
+          Thread.new { sleep(0.1); latch.count_down }
+        end
+
+        result = latch.wait(1)
+        result.should be_true
+        latch.count.should eq 0
+
+      end
+
+      it 'should block until timeout and return false when counter is not set to zero' do
+        result = latch.wait(0.1)
+        result.should be_false
+        latch.count.should eq 3
+      end
+    end
+  end
+end
+
+module Concurrent
+
+  describe MutexCountDownLatch do
+
+    it_should_behave_like :count_down_latch
+
+    context 'spurious wake ups' do
+
+      subject { described_class.new(3) }
+
+      before(:each) do
+        def subject.simulate_spurious_wake_up
+          @mutex.synchronize do
+            @condition.signal
+            @condition.broadcast
+          end
+        end
+      end
+
+      it 'should resist to spurious wake ups without timeout' do
+        @expected = false
+        Thread.new { subject.wait; @expected = true }
+
+        sleep(0.1)
+        subject.simulate_spurious_wake_up
+
+        sleep(0.1)
+        @expected.should be_false
+      end
+
+      it 'should resist to spurious wake ups with timeout' do
+        @expected = false
+        Thread.new { subject.wait(0.5); @expected = true }
+
+        sleep(0.1)
+        subject.simulate_spurious_wake_up
+
+        sleep(0.1)
+        @expected.should be_false
+
+        sleep(0.4)
+        @expected.should be_true
+      end
+    end
+  end
+
+  if jruby?
+
+    describe JavaCountDownLatch do
+
+      it_should_behave_like :count_down_latch
+    end
+  end
+
+  describe CountDownLatch do
+    if jruby?
+      it 'inherits from JavaCountDownLatch' do
+        CountDownLatch.ancestors.should include(JavaCountDownLatch)
+      end
+    else
+      it 'inherits from MutexCountDownLatch' do
+        CountDownLatch.ancestors.should include(MutexCountDownLatch)
+      end
+    end
+  end
+end

data/spec/concurrent/atomic/cyclic_barrier_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe CyclicBarrier do
+
+    let(:parties) { 3 }
+    let!(:barrier) { described_class.new(3) }
+
+    context '#initialize' do
+
+      it 'raises an exception if the initial count is less than 1' do
+        expect {
+          described_class.new(0)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'raises an exception if the initial count is not an integer' do
+        expect {
+          described_class.new('foo')
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe '#parties' do
+
+      it 'should be the value passed to the constructor' do
+        barrier.parties.should eq 3
+      end
+
+    end
+
+    describe '#number_waiting' do
+      context 'without any waiting thread' do
+        it 'should be equal to zero' do
+          barrier.number_waiting.should eq 0
+        end
+      end
+
+      context 'with waiting threads' do
+        it 'should be equal to the waiting threads count' do
+          Thread.new { barrier.wait }
+          Thread.new { barrier.wait }
+
+          sleep(0.1)
+
+          barrier.number_waiting.should eq 2
+        end
+      end
+    end
+
+    describe '#broken?' do
+      it 'should not be broken when created' do
+        barrier.broken?.should eq false
+      end
+
+      it 'should not be broken when reset is called without waiting thread' do
+        barrier.reset
+        barrier.broken?.should eq false
+      end
+    end
+
+    describe 'reset' do
+      it 'should release all waiting threads' do
+        latch = CountDownLatch.new(1)
+
+        Thread.new { barrier.wait; latch.count_down }
+        sleep(0.1)
+        barrier.reset
+        latch.wait(0.1).should be_true
+
+        barrier.should_not be_broken
+        barrier.number_waiting.should eq 0
+      end
+    end
+
+    describe '#wait' do
+      context 'without timeout' do
+        it 'should block the thread' do
+          t = Thread.new { barrier.wait }
+          sleep(0.1)
+
+          t.status.should eq 'sleep'
+        end
+
+        it 'should release all threads when their number matches the desired one' do
+          latch = CountDownLatch.new(parties)
+
+          parties.times { Thread.new { barrier.wait; latch.count_down } }
+          latch.wait(0.1).should be_true
+          barrier.number_waiting.should eq 0
+          barrier.should_not be_broken
+        end
+
+        it 'returns true when released' do
+          latch = CountDownLatch.new(parties)
+
+          parties.times { Thread.new { latch.count_down if barrier.wait == true } }
+          latch.wait(0.1).should be_true
+        end
+
+        it 'executes the block once' do
+          counter = AtomicFixnum.new
+          barrier = described_class.new(parties) { counter.increment }
+
+          latch = CountDownLatch.new(parties)
+
+          parties.times { Thread.new { latch.count_down if barrier.wait == true } }
+          latch.wait(0.1).should be_true
+
+          counter.value.should eq 1
+        end
+
+        it 'can be reused' do
+          first_latch = CountDownLatch.new(parties)
+          parties.times { Thread.new { barrier.wait; first_latch.count_down } }
+          first_latch.wait(0.1).should be_true
+
+          latch = CountDownLatch.new(parties)
+          parties.times { Thread.new { barrier.wait; latch.count_down } }
+          latch.wait(0.1).should be_true
+        end
+
+        it 'return false if barrier has been reset' do
+          latch = CountDownLatch.new(1)
+
+          Thread.new { latch.count_down if barrier.wait == false }
+          sleep(0.1)
+          barrier.reset
+          latch.wait(0.1).should be_true
+        end
+      end
+
+      context 'with timeout' do
+        context 'timeout not expiring' do
+          it 'should block the thread' do
+            t = Thread.new { barrier.wait(1) }
+            sleep(0.1)
+
+            t.status.should eq 'sleep'
+          end
+
+          it 'should release all threads when their number matches the desired one' do
+            latch = CountDownLatch.new(parties)
+
+            parties.times { Thread.new { barrier.wait(1); latch.count_down } }
+            latch.wait(0.2).should be_true
+            barrier.number_waiting.should eq 0
+          end
+
+          it 'returns true when released' do
+            latch = CountDownLatch.new(parties)
+
+            parties.times { Thread.new { latch.count_down if barrier.wait(1) == true } }
+            latch.wait(0.1).should be_true
+          end
+        end
+
+        context 'timeout expiring' do
+
+          it 'returns false' do
+            latch = CountDownLatch.new(1)
+
+            Thread.new { latch.count_down if barrier.wait(0.1) == false }
+            latch.wait(0.2).should be_true
+          end
+
+          it 'breaks the barrier and release all other threads' do
+            latch = CountDownLatch.new(2)
+
+            Thread.new { barrier.wait(0.1); latch.count_down }
+            Thread.new { barrier.wait; latch.count_down }
+
+            latch.wait(0.2).should be_true
+            barrier.should be_broken
+          end
+
+          it 'does not execute the block on timeout' do
+            counter = AtomicFixnum.new
+            barrier = described_class.new(parties) { counter.increment }
+
+            barrier.wait(0.1)
+
+            counter.value.should eq 0
+          end
+        end
+      end
+
+      context '#broken barrier' do
+        it 'should not accept new threads' do
+          Thread.new { barrier.wait(0.1) }
+          sleep(0.2)
+
+          barrier.should be_broken
+
+          barrier.wait.should be_false
+        end
+
+        it 'can be reset' do
+          Thread.new { barrier.wait(0.1) }
+          sleep(0.2)
+
+          barrier.should be_broken
+
+          barrier.reset
+
+          barrier.should_not be_broken
+        end
+      end
+    end
+
+    context 'spurious wake ups' do
+
+      before(:each) do
+        def barrier.simulate_spurious_wake_up
+          @mutex.synchronize do
+            @condition.signal
+            @condition.broadcast
+          end
+        end
+      end
+
+      it 'should resist to spurious wake ups without timeout' do
+        @expected = false
+        Thread.new { barrier.wait; @expected = true }
+
+        sleep(0.1)
+        barrier.simulate_spurious_wake_up
+
+        sleep(0.1)
+        @expected.should be_false
+      end
+
+      it 'should resist to spurious wake ups with timeout' do
+        @expected = false
+        Thread.new { barrier.wait(0.5); @expected = true }
+
+        sleep(0.1)
+        barrier.simulate_spurious_wake_up
+
+        sleep(0.1)
+        @expected.should be_false
+
+      end
+    end
+  end
+
+end