concurrent-ruby 0.6.0 → 0.7.0.rc0

data/spec/concurrent/mvar_spec.rb

@@ -1,380 +0,0 @@
-require 'spec_helper'
-require_relative 'dereferenceable_shared'
-
-module Concurrent
-
-  describe MVar do
-
-    context 'behavior' do
-
-      # dereferenceable
-
-      def dereferenceable_subject(value, opts = {})
-        MVar.new(value, opts)
-      end
-
-      it_should_behave_like :dereferenceable
-    end
-
-    describe '#initialize' do
-
-      it 'accepts no initial value' do
-        m = MVar.new
-        m.should be_empty
-      end
-
-      it 'accepts an empty initial value' do
-        m = MVar.new(MVar::EMPTY)
-        m.should be_empty
-      end
-
-      it 'accepts an initial value' do
-        m = MVar.new(14)
-        m.should_not be_empty
-      end
-
-      it 'accepts a nil initial value' do
-        m = MVar.new(nil)
-        m.should_not be_empty
-      end
-
-    end
-
-    describe '#take' do
-
-      it 'sets the MVar to empty' do
-        m = MVar.new(14)
-        m.take
-        m.should be_empty
-      end
-
-      it 'returns the value on a full MVar' do
-        m = MVar.new(14)
-        m.take.should eq 14
-      end
-
-      it 'waits for another thread to #put' do
-        m = MVar.new
-
-        putter = Thread.new {
-          sleep(0.1)
-          m.put 14
-        }
-
-        m.take.should eq 14
-      end
-
-      it 'returns TIMEOUT on timeout on an empty MVar' do
-        m = MVar.new
-        m.take(0.1).should eq MVar::TIMEOUT
-      end
-
-    end
-
-    describe '#put' do
-
-      it 'sets the MVar to be empty' do
-        m = MVar.new(14)
-        m.take
-        m.should be_empty
-      end
-
-      it 'sets a new value on an empty MVar' do
-        m = MVar.new
-        m.put 14
-        m.take.should eq 14
-      end
-
-      it 'waits for another thread to #take' do
-        m = MVar.new(14)
-
-        putter = Thread.new {
-          sleep(0.1)
-          m.take
-        }
-
-        m.put(14).should eq 14
-      end
-
-      it 'returns TIMEOUT on timeout on a full MVar' do
-        m = MVar.new(14)
-        m.put(14, 0.1).should eq MVar::TIMEOUT
-      end
-
-      it 'returns the value' do
-        m = MVar.new
-        m.put(14).should eq 14
-      end
-
-    end
-
-    describe '#empty?' do
-
-      it 'returns true on an empty MVar' do
-        m = MVar.new
-        m.should be_empty
-      end
-
-      it 'returns false on a full MVar' do
-        m = MVar.new(14)
-        m.should_not be_empty
-      end
-
-    end
-
-    describe '#full?' do
-
-      it 'returns false on an empty MVar' do
-        m = MVar.new
-        m.should_not be_full
-      end
-
-      it 'returns true on a full MVar' do
-        m = MVar.new(14)
-        m.should be_full
-      end
-
-    end
-
-    describe '#modify' do
-
-      it 'raises an exception when no block given' do
-        m = MVar.new(14)
-        expect { m.modify }.to raise_error(ArgumentError)
-      end
-
-      it 'modifies a full MVar' do
-        m = MVar.new(14)
-        m.modify{ |v| v + 2 }
-        m.take.should eq 16
-      end
-
-      it 'returns the unmodified value' do
-        m = MVar.new(14)
-        m.modify{ |v| v + 2 }.should eq 14
-      end
-
-      it 'waits for another thread to #put' do
-        m = MVar.new
-
-        putter = Thread.new {
-          sleep(0.1)
-          m.put 14 
-        }
-
-        m.modify{ |v| v + 2 }.should eq 14
-      end
-
-      it 'is atomic' do
-        m = MVar.new(0)
-
-        # #modify conceptually does #take and #put - but it should be atomic.
-        # Check that another #put can't sneak it during the #modify.
-
-        modifier = Thread.new {
-          m.modify do |v|
-            sleep(0.5)
-            1
-          end
-        }
-
-        sleep(0.1)
-        m.put(2, 0.5).should eq MVar::TIMEOUT
-        m.take.should eq 1
-      end
-
-      it 'returns TIMEOUT on timeout on an empty MVar' do
-        m = MVar.new
-        m.modify(0.1){ |v| v + 2 }.should eq MVar::TIMEOUT
-      end
-
-    end
-
-    describe '#try_put!' do
-
-      it 'returns true an empty MVar' do
-        m = MVar.new
-        m.try_put!(14).should eq true
-      end
-
-      it 'returns false on a full MVar' do
-        m = MVar.new(14)
-        m.try_put!(14).should eq false
-      end
-
-      it 'sets an empty MVar to be full' do
-        m = MVar.new
-        m.try_put! 14
-        m.should be_full
-      end
-
-    end
-
-    describe '#try_take!' do
-
-      it 'returns EMPTY an empty MVar' do
-        m = MVar.new
-        m.try_take!.should eq MVar::EMPTY
-      end
-
-      it 'returns the value on a full MVar' do
-        m = MVar.new(14)
-        m.try_take!.should eq 14
-      end
-
-      it 'sets a full MVar to be empty' do
-        m = MVar.new(14)
-        m.try_take!
-        m.should be_empty
-      end
-
-    end
-
-    describe '#set!' do
-
-      it 'sets an empty MVar to be full' do
-        m = MVar.new
-        m.set! 14
-        m.should be_full
-      end
-
-      it 'sets a full MVar to be full' do
-        m = MVar.new(2)
-        m.set! 14
-        m.should be_full
-        m.take.should eq 14
-      end
-
-      it 'returns EMPTY on an empty MVar' do
-        m = MVar.new
-        m.set!(2).should eq MVar::EMPTY
-      end
-
-      it 'returns the original value on a full MVar' do
-        m = MVar.new(14)
-        m.set!(2).should eq 14
-      end
-
-    end
-
-    describe '#modify!' do
-
-      it 'raises an exception when no block given' do
-        m = MVar.new(14)
-        expect { m.modify! }.to raise_error(ArgumentError)
-      end
-
-      it 'modifies a full MVar' do
-        m = MVar.new(14)
-        m.modify!{ |v| v + 2 }
-        m.take.should eq 16
-      end
-
-      it 'modifies an empty MVar' do
-        m = MVar.new
-        m.modify!{ |v| 14 }
-        m.take.should eq 14
-      end
-
-      it 'can be used to set a full MVar to empty' do
-        m = MVar.new(14)
-        m.modify!{ |v| MVar::EMPTY }
-        m.should be_empty
-      end
-
-      it 'can be used to set an empty MVar to empty' do
-        m = MVar.new
-        m.modify!{ |v| MVar::EMPTY }
-        m.should be_empty
-      end
-
-      it 'returns the unmodified value' do
-        m = MVar.new(14)
-        m.modify!{ |v| v + 2 }.should eq 14
-      end
-
-    end
-
-    context 'spurious wake ups' do
-
-      let(:m) { MVar.new }
-
-      before(:each) do
-        def m.simulate_spurious_wake_up
-          @mutex.synchronize do
-            @full_condition.broadcast
-            @empty_condition.broadcast
-          end
-        end
-      end
-
-      describe '#take' do
-        it 'waits for another thread to #put' do
-          Thread.new { sleep(0.5); m.put 14 }
-          Thread.new { sleep(0.1); m.simulate_spurious_wake_up }
-
-          m.take.should eq 14
-        end
-
-        it 'returns TIMEOUT on timeout on an empty MVar' do
-          result = nil
-          Thread.new { result = m.take(0.3) }
-          sleep(0.1)
-          Thread.new { m.simulate_spurious_wake_up }
-          sleep(0.1)
-          result.should be_nil
-          sleep(0.2)
-          result.should eq MVar::TIMEOUT
-        end
-      end
-
-      describe '#modify' do
-
-        it 'waits for another thread to #put' do
-          Thread.new { sleep(0.5); m.put 14 }
-          Thread.new { sleep(0.1); m.simulate_spurious_wake_up }
-
-          m.modify{ |v| v + 2 }.should eq 14
-        end
-
-        it 'returns TIMEOUT on timeout on an empty MVar' do
-          result = nil
-          Thread.new { result = m.modify(0.3){ |v| v + 2 } }
-          sleep(0.1)
-          Thread.new { m.simulate_spurious_wake_up }
-          sleep(0.1)
-          result.should be_nil
-          sleep(0.2)
-          result.should eq MVar::TIMEOUT
-        end
-      end
-
-      describe '#put' do
-
-        before(:each) { m.put(42) }
-
-        it 'waits for another thread to #take' do
-          Thread.new { sleep(0.5); m.take }
-          Thread.new { sleep(0.1); m.simulate_spurious_wake_up }
-
-          m.put(14).should eq 14
-        end
-
-        it 'returns TIMEOUT on timeout on a full MVar' do
-          result = nil
-          Thread.new { result = m.put(14, 0.3) }
-          sleep(0.1)
-          Thread.new { m.simulate_spurious_wake_up }
-          sleep(0.1)
-          result.should be_nil
-          sleep(0.2)
-          result.should eq MVar::TIMEOUT
-        end
-      end
-
-
-    end
-
-  end
-
-end

data/spec/concurrent/obligation_shared.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-share_examples_for :obligation do
-
-  context '#state' do
-
-    it 'is :pending when first created' do
-      f = pending_subject
-      f.state.should == :pending
-      f.should be_pending
-    end
-
-    it 'is :fulfilled when the handler completes' do
-      f = fulfilled_subject
-      f.state.should == :fulfilled
-      f.should be_fulfilled
-    end
-
-    it 'is :rejected when the handler raises an exception' do
-      f = rejected_subject
-      f.state.should == :rejected
-      f.should be_rejected
-    end
-  end
-
-  context '#value' do
-
-    let!(:supports_timeout) { pending_subject.method(:value).arity != 0 }
-
-    it 'returns nil when reaching the optional timeout value' do
-      if supports_timeout
-        f = pending_subject
-        f.value(0).should be_nil
-        f.should be_pending
-      end
-    end
-
-    it 'returns immediately when timeout is zero' do
-      if supports_timeout
-        Concurrent.should_not_receive(:timeout).with(any_args())
-        f = pending_subject
-        f.value(0).should be_nil
-        f.should be_pending
-      end
-    end
-
-    it 'returns the value when fulfilled before timeout' do
-      if supports_timeout
-        f = pending_subject
-        f.value(10).should be_true
-        f.should be_fulfilled
-      end
-    end
-
-    it 'returns nil when timeout reached' do
-      if supports_timeout
-        f = pending_subject
-        f.value(0.1).should be_nil
-        f.should be_pending
-      end
-    end
-
-    it 'is nil when :pending' do
-      if supports_timeout
-        expected = pending_subject.value(0)
-        expected.should be_nil
-      end
-    end
-
-    it 'blocks the caller when :pending and timeout is nil' do
-      f = pending_subject
-      f.value.should be_true
-      f.should be_fulfilled
-    end
-
-    it 'is nil when :rejected' do
-      expected = rejected_subject.value
-      expected.should be_nil
-    end
-
-    it 'is set to the return value of the block when :fulfilled' do
-      expected = fulfilled_subject.value
-      expected.should eq fulfilled_value
-    end
-  end
-
-  context '#reason' do
-
-    it 'is nil when :pending' do
-      pending_subject.reason.should be_nil
-    end
-
-    it 'is nil when :fulfilled' do
-      fulfilled_subject.reason.should be_nil
-    end
-
-    it 'is set to error object of the exception when :rejected' do
-      rejected_subject.reason.should be_a(Exception)
-      rejected_subject.reason.to_s.should =~ /#{rejected_reason}/
-    end
-  end
-end