concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/spec/concurrent/atomic_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe AtomicFixnum do
+
+    context 'construction' do
+
+      it 'sets the initial value' do
+        AtomicFixnum.new(10).value.should eq 10
+      end
+
+      it 'defaults the initial value to zero' do
+        AtomicFixnum.new.value.should eq 0
+      end
+
+      it 'raises en exception if the initial value is not a Fixnum' do
+        lambda {
+          AtomicFixnum.new(10.01)
+        }.should raise_error(ArgumentError)
+      end
+
+      if jruby?
+
+        it 'uses Java AtomicLong' do
+          mutex = double('mutex')
+          Mutex.stub(:new).with(no_args).and_return(mutex)
+          mutex.should_not_receive(:synchronize)
+          AtomicFixnum.new.value
+        end
+
+      else
+
+        it 'is synchronized' do
+          mutex = double('mutex')
+          Mutex.stub(:new).with(no_args).and_return(mutex)
+          mutex.should_receive(:synchronize)
+          AtomicFixnum.new.value
+        end
+
+      end
+
+    end
+
+    context '#value' do
+
+      it 'returns the current value' do
+        counter = AtomicFixnum.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 = AtomicFixnum.new(0)
+        atomic.value = 10
+        atomic.value.should eq 10
+      end
+
+      it 'returns the new value' do
+        atomic = AtomicFixnum.new(0)
+        (atomic.value = 10).should eq 10
+      end
+
+      it 'raises and exception if the value is not a `Fixnum`' do
+        atomic = AtomicFixnum.new(0)
+        expect {
+          atomic.value = 'foo'
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context '#increment' do
+
+      it 'increases the value by one' do
+        counter = AtomicFixnum.new(10)
+        3.times{ counter.increment }
+        counter.value.should eq 13
+      end
+
+      it 'returns the new value' do
+        counter = AtomicFixnum.new(10)
+        counter.increment.should eq 11
+      end
+
+      it 'is aliased as #up' do
+        AtomicFixnum.new(10).up.should eq 11
+      end
+
+      if jruby?
+
+        it 'does not use Mutex class' do
+          mutex = double('mutex')
+          Mutex.stub(:new).with(no_args).and_return(mutex)
+          mutex.should_not_receive(:synchronize)
+          AtomicFixnum.new.increment
+        end
+
+      else
+
+        it 'is synchronized' do
+          mutex = double('mutex')
+          Mutex.stub(:new).with(no_args).and_return(mutex)
+          mutex.should_receive(:synchronize)
+          AtomicFixnum.new.increment
+        end
+
+      end
+
+    end
+
+    context '#decrement' do
+
+      it 'decreases the value by one' do
+        counter = AtomicFixnum.new(10)
+        3.times{ counter.decrement }
+        counter.value.should eq 7
+      end
+
+      it 'returns the new value' do
+        counter = AtomicFixnum.new(10)
+        counter.decrement.should eq 9
+      end
+
+      it 'is aliased as #down' do
+        AtomicFixnum.new(10).down.should eq 9
+      end
+
+      if jruby?
+
+        it 'does not use Mutex class' do
+          mutex = double('mutex')
+          Mutex.stub(:new).with(no_args).and_return(mutex)
+          mutex.should_not_receive(:synchronize)
+          AtomicFixnum.new.decrement
+        end
+
+      else
+
+        it 'is synchronized' do
+          mutex = double('mutex')
+          Mutex.stub(:new).with(no_args).and_return(mutex)
+          mutex.should_receive(:synchronize)
+          AtomicFixnum.new.decrement
+        end
+
+      end
+
+    end
+
+    context '#compare_and_set' do
+
+      it 'returns false if the value is not found' do
+        AtomicFixnum.new(14).compare_and_set(2, 14).should eq false
+      end
+
+      it 'returns true if the value is found' do
+        AtomicFixnum.new(14).compare_and_set(14, 2).should eq true
+      end
+
+      it 'sets if the value is found' do
+        f = AtomicFixnum.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 = AtomicFixnum.new(14)
+        f.compare_and_set(2, 12)
+        f.value.should eq 14
+      end
+
+      if jruby?
+
+        it 'does not use Mutex class' do
+          mutex = double('mutex')
+          Mutex.stub(:new).with(no_args).and_return(mutex)
+          mutex.should_not_receive(:synchronize)
+          AtomicFixnum.new(14).compare_and_set(14, 2)
+        end
+
+      else
+
+        it 'is synchronized' do
+          mutex = double('mutex')
+          Mutex.stub(:new).with(no_args).and_return(mutex)
+          mutex.should_receive(:synchronize)
+          AtomicFixnum.new(14).compare_and_set(14, 2)
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/concurrent/condition_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe Condition do
+
+    let(:mutex) { Mutex.new }
+    subject{ Condition.new }
+
+    before(:each) do
+      # rspec is not thread safe, without mutex initialization
+      # we can experience race conditions
+      mutex
+    end
+
+    context 'with no waiting threads' do
+      describe '#signal' do
+        it 'should return immediately' do
+          subject.signal.should be_true
+        end
+      end
+
+      describe '#broadcast' do
+        it 'should return immediately' do
+          subject.broadcast.should be_true
+        end
+      end
+    end
+
+    context 'with one waiting thread' do
+
+      context 'signalled wake up' do
+
+        describe '#wait without timeout' do
+
+          it 'should block the thread' do
+            t = Thread.new { mutex.synchronize { subject.wait(mutex) } }
+            sleep(0.1)
+            t.status.should eq 'sleep'
+            t.kill
+          end
+
+          it 'should return a woken up result when is woken up by #signal' do
+            result = nil
+            t = Thread.new { mutex.synchronize { result = subject.wait(mutex) } }
+            sleep(0.1)
+            mutex.synchronize { subject.signal }
+            sleep(0.1)
+            result.should be_woken_up
+            result.should_not be_timed_out
+            result.remaining_time.should be_nil
+            t.status.should be_false
+          end
+
+          it 'should return a woken up result when is woken up by #broadcast' do
+            result = nil
+            t = Thread.new { mutex.synchronize { result = subject.wait(mutex) } }
+            sleep(0.1)
+            mutex.synchronize { subject.broadcast }
+            sleep(0.1)
+            result.should be_woken_up
+            result.should_not be_timed_out
+            result.remaining_time.should be_nil
+            t.status.should be_false
+          end
+        end
+
+      end
+
+      context 'timeout' do
+
+        describe '#wait' do
+
+          it 'should block the thread' do
+            t = Thread.new { mutex.synchronize { subject.wait(mutex, 1) } }
+            sleep(0.1)
+            t.status.should eq 'sleep'
+            t.kill
+          end
+
+          it 'should return remaining time when is woken up by #signal' do
+            result = nil
+            t = Thread.new { mutex.synchronize { result = subject.wait(mutex, 1) } }
+            sleep(0.1)
+            mutex.synchronize { subject.signal }
+            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)
+            t.status.should be_false
+          end
+
+          it 'should return remaining time when is woken up by #broadcast' do
+            result = nil
+            t = Thread.new { mutex.synchronize { result = subject.wait(mutex, 1) } }
+            sleep(0.1)
+            mutex.synchronize { subject.broadcast }
+            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)
+            t.status.should be_false
+          end
+
+          it 'should return 0 or negative number if timed out' do
+            result = nil
+            t = Thread.new { mutex.synchronize { result = subject.wait(mutex, 0.1) } }
+            sleep(0.2)
+            result.should_not be_woken_up
+            result.should be_timed_out
+            result.remaining_time.should be_less_than_or_equal_to(0)
+            t.status.should be_false
+          end
+        end
+
+      end
+    end
+
+    context 'with many waiting threads' do
+
+      context 'signalled wake up' do
+
+        describe '#wait' do
+
+          it 'should block threads' do
+            t1 = Thread.new { mutex.synchronize { subject.wait(mutex) } }
+            t2 = Thread.new { mutex.synchronize { subject.wait(mutex) } }
+            sleep(0.1)
+            [t1, t2].each { |t| t.status.should eq 'sleep' }
+            [t1, t2].each { |t| t.kill }
+          end
+
+        end
+
+        describe '#signal' do
+          it 'wakes up only one thread' do
+            latch = CountDownLatch.new(2)
+
+            t1 = Thread.new { mutex.synchronize { subject.wait(mutex); latch.count_down } }
+            t2 = Thread.new { mutex.synchronize { subject.wait(mutex); latch.count_down } }
+
+            sleep(0.1)
+            mutex.synchronize { subject.signal }
+            sleep(0.2)
+
+            latch.count.should eq 1
+            [t1, t2].each { |t| t.kill }
+          end
+        end
+
+        describe '#broadcast' do
+          it 'wakes up all threads' do
+            latch = CountDownLatch.new(2)
+
+            t1 = Thread.new { mutex.synchronize { subject.wait(mutex); latch.count_down } }
+            t2 = Thread.new { mutex.synchronize { subject.wait(mutex); latch.count_down } }
+
+            sleep(0.1)
+            mutex.synchronize { subject.broadcast }
+            sleep(0.2)
+
+            latch.count.should eq 0
+            [t1, t2].each { |t| t.kill }
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/spec/concurrent/copy_on_notify_observer_set_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require_relative 'observer_set_shared'
+
+module Concurrent
+
+  describe CopyOnNotifyObserverSet do
+    it_behaves_like 'an observer set'
+  end
+
+end

data/spec/concurrent/copy_on_write_observer_set_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require_relative 'observer_set_shared'
+
+module Concurrent
+
+  describe CopyOnWriteObserverSet do
+    it_behaves_like 'an observer set'
+  end
+
+end

data/spec/concurrent/count_down_latch_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe CountDownLatch do
+
+    let(:latch) { CountDownLatch.new(3) }
+    let(:zero_count_latch) { CountDownLatch.new(0) }
+
+    context '#initialize' do
+
+      it 'raises an exception if the initial count is less than zero' do
+        expect {
+          CountDownLatch.new(-1)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'raises an exception if the initial count is not an integer' do
+        expect {
+          CountDownLatch.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
+
+    context 'spurious wake ups' do
+
+      before(:each) do
+        def latch.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 { latch.wait; @expected = true }
+
+        sleep(0.1)
+        latch.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 { latch.wait(0.5); @expected = true }
+
+        sleep(0.1)
+        latch.simulate_spurious_wake_up
+
+        sleep(0.1)
+        @expected.should be_false
+
+        sleep(0.4)
+        @expected.should be_true
+      end
+    end
+
+  end
+end