concurrent-ruby 0.6.1 → 0.7.0.rc0

data/spec/concurrent/atomic/atomic_fixnum_spec.rb

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