concurrent-ruby 0.6.0 → 0.7.0.rc0

data/spec/concurrent/atomic/atomic_spec.rb

@@ -1,133 +0,0 @@
-require 'spec_helper'
-
-share_examples_for :atomic do
-
-  context 'construction' do
-
-    it 'sets the initial value' do
-      described_class.new(:foo).value.should eq :foo
-    end
-
-    it 'defaults the initial value to nil' do
-      described_class.new.value.should eq nil
-    end
-  end
-
-  context '#value' do
-
-    it 'returns the current value' do
-      counter = described_class.new(:foo)
-      counter.value.should eq :foo
-    end
-  end
-
-  context '#value=' do
-
-    it 'sets the #value to the given object' do
-      atomic = described_class.new(:foo)
-      atomic.value = :bar
-      atomic.value.should eq :bar
-    end
-
-    it 'returns the new value' do
-      atomic = described_class.new(:foo)
-      (atomic.value = :bar).should eq :bar
-    end
-  end
-
-  context '#modify' do
-
-    it 'yields the current value' do
-      atomic = described_class.new(:foo)
-      current = []
-      atomic.modify { |value| current << value }
-      current.should eq [:foo]
-    end
-
-    it 'stores the value returned from the yield' do
-      atomic = described_class.new(:foo)
-      atomic.modify { |value| :bar }
-      atomic.value.should eq :bar
-    end
-
-    it 'returns the new value' do
-      atomic = described_class.new(:foo)
-      atomic.modify{ |value| :bar }.should eq :bar
-    end
-  end
-
-  context '#compare_and_set' do
-
-    it 'returns false if the value is not found' do
-      described_class.new(:foo).compare_and_set(:bar, :foo).should eq false
-    end
-
-    it 'returns true if the value is found' do
-      described_class.new(:foo).compare_and_set(:foo, :bar).should eq true
-    end
-
-    it 'sets if the value is found' do
-      f = described_class.new(:foo)
-      f.compare_and_set(:foo, :bar)
-      f.value.should eq :bar
-    end
-
-    it 'does not set if the value is not found' do
-      f = described_class.new(:foo)
-      f.compare_and_set(:bar, :baz)
-      f.value.should eq :foo
-    end
-  end
-end
-
-module Concurrent
-
-  describe MutexAtomic do
-
-    it_should_behave_like :atomic
-
-    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 'modify 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(:foo).modify { |value| value }
-    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
-
-  describe Atomic do
-    it 'inherits from MutexAtomic' do
-      Atomic.ancestors.should include(MutexAtomic)
-    end
-  end
-end

data/spec/concurrent/atomic/condition_spec.rb

@@ -1,171 +0,0 @@
-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.1).of(0.85)
-            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.1).of(0.85)
-            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/atomic/copy_on_notify_observer_set_spec.rb

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

data/spec/concurrent/atomic/copy_on_write_observer_set_spec.rb

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

data/spec/concurrent/atomic/count_down_latch_spec.rb

@@ -1,151 +0,0 @@
-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 TestHelpers.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