concurrent-ruby 0.6.1 → 0.7.0.rc0

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

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