concurrent-ruby 0.6.0 → 0.7.0.rc0

data/spec/concurrent/atomic/cyclic_barrier_spec.rb

@@ -1,248 +0,0 @@
-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

data/spec/concurrent/atomic/event_spec.rb

@@ -1,200 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe Event do
-
-    subject{ Event.new }
-
-    context '#initialize' do
-
-      it 'sets the state to unset' do
-        subject.should_not be_set
-      end
-    end
-
-    context '#set?' do
-
-      it 'returns true when the event has been set' do
-        subject.set
-        subject.should be_set
-      end
-
-      it 'returns false if the event is unset' do
-        subject.should_not be_set
-      end
-    end
-
-    context '#set' do
-
-      it 'triggers the event' do
-        @expected = false
-        Thread.new{ subject.wait; @expected = true }
-        sleep(0.1)
-        subject.set
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'sets the state to set' do
-        subject.set
-        subject.should be_set
-      end
-    end
-
-    context '#try?' do
-
-      it 'triggers the event if not already set' do
-        subject.try?
-        subject.should be_set
-      end
-
-      it 'returns true if not previously set' do
-        subject.try?.should be_true
-      end
-
-      it 'returns false if previously set' do
-        subject.set
-        subject.try?.should be_false
-      end
-    end
-
-    context '#reset' do
-
-      it 'does not change the state of an unset event' do
-        subject.reset
-        subject.should_not be_set
-      end
-
-      it 'does not trigger an unset event' do
-        @expected = false
-        Thread.new{ subject.wait; @expected = true }
-        sleep(0.1)
-        subject.reset
-        sleep(0.1)
-        @expected.should be_false
-      end
-
-      it 'does not interrupt waiting threads when event is unset' do
-        @expected = false
-        Thread.new{ subject.wait; @expected = true }
-        sleep(0.1)
-        subject.reset
-        sleep(0.1)
-        subject.set
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'returns true when called on an unset event' do
-        subject.reset.should be_true
-      end
-
-      it 'sets the state of a set event to unset' do
-        subject.set
-        subject.should be_set
-        subject.reset
-        subject.should_not be_set
-      end
-
-      it 'returns true when called on a set event' do
-        subject.set
-        subject.should be_set
-        subject.reset.should be_true
-      end
-    end
-
-    context '#wait' do
-
-      it 'returns immediately when the event has been set' do
-        subject.reset
-        @expected = false
-        subject.set
-        Thread.new{ subject.wait(1000); @expected = true}
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'returns true once the event is set' do
-        subject.set
-        subject.wait.should be_true
-      end
-
-      it 'blocks indefinitely when the timer is nil' do
-        subject.reset
-        @expected = false
-        Thread.new{ subject.wait; @expected = true}
-        subject.set
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'stops waiting when the timer expires' do
-        subject.reset
-        @expected = false
-        Thread.new{ subject.wait(0.5); @expected = true}
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'returns false when the timer expires' do
-        subject.reset
-        subject.wait(1).should be_false
-      end
-
-      it 'triggers multiple waiting threads' do
-        latch = CountDownLatch.new(5)
-        subject.reset
-        5.times{ Thread.new{ subject.wait; latch.count_down } }
-        subject.set
-        latch.wait(0.2).should be_true
-      end
-
-      it 'behaves appropriately if wait begins while #set is processing' do
-        subject.reset
-        latch = CountDownLatch.new(5)
-        5.times{ Thread.new{ subject.wait(5) } }
-        subject.set
-        5.times{ Thread.new{ subject.wait; latch.count_down } }
-        latch.wait(0.2).should be_true
-      end
-    end
-
-    context 'spurious wake ups' do
-
-      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
-end

data/spec/concurrent/atomic/observer_set_shared.rb

@@ -1,242 +0,0 @@
-require 'spec_helper'
-
-shared_examples "an observer set" do
-
-  let (:observer_set) { described_class.new }
-  let (:observer) { double('observer') }
-  let (:another_observer) { double('another observer') }
-
-  describe '#add_observer' do
-
-    context 'with arguments' do
-      it 'should return the observer' do
-        observer_set.add_observer(observer, :a_method).should == observer
-      end
-    end
-
-    context 'with a block' do
-      it 'should return the observer based on a block' do
-        observer = observer_set.add_observer { :block }
-        observer.call.should == :block
-      end
-    end
-  end
-
-  describe '#notify_observers' do
-    it 'should return the observer set' do
-      observer_set.notify_observers.should be(observer_set)
-    end
-
-    context 'with a single observer' do
-      it 'should update a registered observer without arguments' do
-        expect(observer).to receive(:update).with(no_args)
-
-        observer_set.add_observer(observer)
-
-        observer_set.notify_observers
-      end
-
-      it 'should update a registered observer with arguments' do
-        expect(observer).to receive(:update).with(1, 2, 3)
-
-        observer_set.add_observer(observer)
-
-        observer_set.notify_observers(1, 2, 3)
-      end
-
-      it 'should notify an observer using the chosen method' do
-        expect(observer).to receive(:another_method).with('a string arg')
-
-        observer_set.add_observer(observer, :another_method)
-
-        observer_set.notify_observers('a string arg')
-      end
-
-      it 'should notify an observer once using the last added method' do
-        expect(observer).to receive(:another_method).with(any_args).never
-        expect(observer).to receive(:yet_another_method).with('a string arg')
-
-        observer_set.add_observer(observer, :another_method)
-        observer_set.add_observer(observer, :yet_another_method)
-
-        observer_set.notify_observers('a string arg')
-      end
-
-      it 'should notify an observer from a block' do
-        notification = double
-        expect(notification).to receive(:catch)
-
-        observer_set.add_observer {|arg| arg.catch }
-        observer_set.notify_observers notification
-      end
-
-      it 'can be called many times' do
-        expect(observer).to receive(:update).with(:an_arg).twice
-        expect(observer).to receive(:update).with(no_args).once
-
-        observer_set.add_observer(observer)
-
-        observer_set.notify_observers(:an_arg)
-        observer_set.notify_observers
-        observer_set.notify_observers(:an_arg)
-      end
-    end
-
-    context 'with many observers' do
-      it 'should notify all observer using the chosen method' do
-        expect(observer).to receive(:a_method).with(4, 'a')
-        expect(another_observer).to receive(:update).with(4, 'a')
-
-        observer_set.add_observer(observer, :a_method)
-        observer_set.add_observer(another_observer)
-
-        observer_set.notify_observers(4, 'a')
-      end
-    end
-
-    context 'with a block' do
-
-      before(:each) do
-        observer.stub(:update).with(any_args)
-        another_observer.stub(:update).with(any_args)
-      end
-
-      it 'calls the block once for every observer' do
-
-        counter = double('block call counter')
-        expect(counter).to receive(:called).with(no_args).exactly(2).times
-
-        observer_set.add_observer(observer)
-        observer_set.add_observer(another_observer)
-
-        observer_set.notify_observers{ counter.called }
-      end
-
-      it 'passes the block return value to the update method' do
-
-        expect(observer).to receive(:update).with(1, 2, 3, 4)
-        observer_set.add_observer(observer)
-        observer_set.notify_observers{ [1, 2, 3, 4] }
-      end
-
-      it 'accepts blocks returning a single value' do
-
-        expect(observer).to receive(:update).with(:foo)
-        observer_set.add_observer(observer)
-        observer_set.notify_observers{ :foo }
-      end
-
-      it 'accepts block return values that include arrays' do
-
-        expect(observer).to receive(:update).with(1, [2, 3], 4)
-        observer_set.add_observer(observer)
-        observer_set.notify_observers{ [1, [2, 3], 4] }
-      end
-
-      it 'raises an exception if given both arguments and a block' do
-
-        observer_set.add_observer(observer)
-
-        expect {
-          observer_set.notify_observers(1, 2, 3, 4){ nil }
-        }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  context '#count_observers' do
-    it 'should be zero after initialization' do
-      observer_set.count_observers.should eq 0
-    end
-
-    it 'should be 1 after the first observer is added' do
-      observer_set.add_observer(observer)
-      observer_set.count_observers.should eq 1
-    end
-
-    it 'should be 1 if the same observer is added many times' do
-      observer_set.add_observer(observer)
-      observer_set.add_observer(observer, :another_method)
-      observer_set.add_observer(observer, :yet_another_method)
-
-      observer_set.count_observers.should eq 1
-    end
-
-    it 'should be equal to the number of unique observers' do
-      observer_set.add_observer(observer)
-      observer_set.add_observer(another_observer)
-      observer_set.add_observer(double('observer 3'))
-      observer_set.add_observer(double('observer 4'))
-
-      observer_set.count_observers.should eq 4
-    end
-  end
-
-  describe '#delete_observer' do
-    it 'should not notify a deleted observer' do
-      expect(observer).to receive(:update).never
-
-      observer_set.add_observer(observer)
-      observer_set.delete_observer(observer)
-
-      observer_set.notify_observers
-    end
-
-    it 'can delete a non added observer' do
-      observer_set.delete_observer(observer)
-    end
-
-    it 'should return the observer' do
-      observer_set.delete_observer(observer).should be(observer)
-    end
-  end
-
-  describe '#delete_observers' do
-    it 'should remove all observers' do
-      expect(observer).to receive(:update).never
-      expect(another_observer).to receive(:update).never
-
-      observer_set.add_observer(observer)
-      observer_set.add_observer(another_observer)
-
-      observer_set.delete_observers
-
-      observer_set.notify_observers
-    end
-
-    it 'should return the observer set' do
-      observer_set.delete_observers.should be(observer_set)
-    end
-  end
-
-  describe '#notify_and_delete_observers' do
-    before(:each) do
-      observer_set.add_observer(observer, :a_method)
-      observer_set.add_observer(another_observer)
-
-      expect(observer).to receive(:a_method).with('args').once
-      expect(another_observer).to receive(:update).with('args').once
-    end
-
-    it 'should notify all observers' do
-      observer_set.notify_and_delete_observers('args')
-    end
-
-    it 'should clear observers' do
-      observer_set.notify_and_delete_observers('args')
-
-      observer_set.count_observers.should eq(0)
-    end
-
-    it 'can be called many times without any other notification' do
-      observer_set.notify_and_delete_observers('args')
-      observer_set.notify_and_delete_observers('args')
-      observer_set.notify_and_delete_observers('args')
-    end
-
-    it 'should return the observer set' do
-      observer_set.notify_and_delete_observers('args').should be(observer_set)
-    end
-  end
-
-end