concurrent-ruby 0.6.1 → 0.7.0.rc0

data/spec/concurrent/channel/channel_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe Channel do
-
-    describe '.select' do
-
-      context 'without timeout' do
-        it 'returns the first value available on a channel' do
-          channels = [ UnbufferedChannel.new, UnbufferedChannel.new]
-
-          Thread.new { channels[1].push 77 }
-
-          value, channel = Channel.select(*channels)
-
-          value.should eq 77
-          channel.should be channels[1]
-        end
-
-        it 'cleans up' do
-          channels = [ UnbufferedChannel.new, UnbufferedChannel.new]
-          channels.each { |ch| ch.stub(:remove_probe).with( an_instance_of(Channel::Probe) )}
-
-          Thread.new { channels[1].push 77 }
-
-          value, channel = Channel.select(*channels)
-
-          value.should eq 77
-          channel.should be channels[1]
-
-          channels.each { |ch| expect(ch).to have_received(:remove_probe).with( an_instance_of(Channel::Probe) ) }
-        end
-      end
-
-    end
-
-  end
-end

data/spec/concurrent/channel/probe_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require_relative '../observable_shared'
-
-module Concurrent
-
-  describe Channel::Probe do
-
-    let(:channel) { Object.new }
-    let(:probe) { Channel::Probe.new }
-
-    describe 'behavior' do
-
-      # observable
-      
-      subject{ Channel::Probe.new }
-      
-      def trigger_observable(observable)
-        observable.set('value')
-      end
-
-      it_should_behave_like :observable
-    end
-
-    describe '#set_unless_assigned' do
-      context 'empty probe' do
-        it 'assigns the value' do
-          probe.set_unless_assigned(32, channel)
-          probe.value.should eq 32
-        end
-
-        it 'assign the channel' do
-          probe.set_unless_assigned(32, channel)
-          probe.channel.should be channel
-        end
-
-        it 'returns true' do
-          probe.set_unless_assigned('hi', channel).should eq true
-        end
-      end
-
-      context 'fulfilled probe' do
-        before(:each) { probe.set([27, nil]) }
-
-        it 'does not assign the value' do
-          probe.set_unless_assigned(88, channel)
-          probe.value.should eq 27
-        end
-
-        it 'returns false' do
-          probe.set_unless_assigned('hello', channel).should eq false
-        end
-      end
-
-      context 'rejected probe' do
-        before(:each) { probe.fail }
-
-        it 'does not assign the value' do
-          probe.set_unless_assigned(88, channel)
-          probe.should be_rejected
-        end
-
-        it 'has a nil value' do
-          probe.value.should be_nil
-        end
-
-        it 'has a nil channel' do
-          probe.channel.should be_nil
-        end
-
-        it 'returns false' do
-          probe.set_unless_assigned('hello', channel).should eq false
-        end
-      end
-    end
-
-  end
-end

data/spec/concurrent/channel/unbuffered_channel_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe UnbufferedChannel do
-
-    let!(:channel) { subject }
-    let(:probe) { Channel::Probe.new }
-
-    context 'with one thread' do
-
-      context 'without timeout' do
-
-        describe '#push' do
-          it 'should block' do
-            t = Thread.new { channel.push 5 }
-            sleep(0.05)
-            t.status.should eq 'sleep'
-          end
-        end
-
-        describe '#pop' do
-          it 'should block' do
-            t = Thread.new { channel.pop }
-            sleep(0.05)
-            t.status.should eq 'sleep'
-          end
-        end
-
-      end
-
-    end
-
-    context 'cooperating threads' do
-
-      it 'passes the pushed value to thread waiting on pop' do
-        result = nil
-
-        Thread.new { channel.push 42 }
-        Thread.new { result = channel.pop; }
-
-        sleep(0.1)
-
-        result.should eq 42
-      end
-
-      it 'passes the pushed value to only one thread' do
-        result = []
-
-        Thread.new { channel.push 37 }
-        Thread.new { result << channel.pop }
-        Thread.new { result << channel.pop }
-
-        sleep(0.1)
-
-        result.should have(1).items
-      end
-
-      it 'gets the pushed value when ready' do
-        result = nil
-
-        Thread.new { result = channel.pop; }
-        Thread.new { channel.push 57 }
-
-        sleep(0.1)
-
-        result.should eq 57
-      end
-    end
-
-    describe 'select' do
-
-      it 'does not block' do
-        t = Thread.new { channel.select(probe) }
-
-        sleep(0.05)
-
-        t.status.should eq false
-      end
-
-      it 'gets notified by writer thread' do
-        channel.select(probe)
-
-        Thread.new { channel.push 82 }
-
-        probe.value.should eq 82
-      end
-
-      it 'ignores already set probes and waits for a new one' do
-        probe.set(27)
-
-        channel.select(probe)
-
-        t = Thread.new { channel.push 72 }
-
-        sleep(0.05)
-
-        t.status.should eq 'sleep'
-
-        new_probe = Channel::Probe.new
-
-        channel.select(new_probe)
-
-        sleep(0.05)
-
-        new_probe.value.should eq 72
-      end
-
-    end
-
-    describe 'probe set' do
-
-      it 'has size zero after creation' do
-        channel.probe_set_size.should eq 0
-      end
-
-      it 'increases size after a select' do
-        channel.select(probe)
-        channel.probe_set_size.should eq 1
-      end
-
-      it 'decreases size after a removal' do
-        channel.select(probe)
-        channel.remove_probe(probe)
-        channel.probe_set_size.should eq 0
-      end
-
-    end
-
-
-  end
-end

data/spec/concurrent/collection/blocking_ring_buffer_spec.rb

@@ -1,149 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe BlockingRingBuffer do
-
-    let(:capacity) { 3 }
-    let(:buffer) { BlockingRingBuffer.new(capacity) }
-
-    def fill_buffer
-      capacity.times { buffer.put 3 }
-    end
-
-    describe '#capacity' do
-      it 'returns the value passed in constructor' do
-        buffer.capacity.should eq capacity
-      end
-    end
-
-    describe '#count' do
-      it 'is zero when created' do
-        buffer.count.should eq 0
-      end
-
-      it 'increases when an element is added' do
-        buffer.put 5
-        buffer.count.should eq 1
-
-        buffer.put 1
-        buffer.count.should eq 2
-      end
-
-      it 'decreases when an element is removed' do
-        buffer.put 10
-
-        buffer.take
-
-        buffer.count.should eq 0
-      end
-    end
-
-    describe '#empty?' do
-      it 'is true when count is zero' do
-        buffer.empty?.should be_true
-      end
-
-      it 'is false when count is not zero' do
-        buffer.put 82
-        buffer.empty?.should be_false
-      end
-    end
-
-    describe '#full?' do
-      it 'is true when count is capacity' do
-        fill_buffer
-        buffer.full?.should be_true
-      end
-
-      it 'is false when count is not capacity' do
-        buffer.full?.should be_false
-      end
-    end
-
-    describe '#put' do
-      it 'block when buffer is full' do
-        fill_buffer
-
-        t = Thread.new { buffer.put 32 }
-
-        sleep(0.1)
-
-        t.status.should eq 'sleep'
-      end
-
-      it 'continues when an element is removed' do
-        latch = CountDownLatch.new(1)
-
-        Thread.new { (capacity + 1).times { buffer.put 'hi' }; latch.count_down }
-        Thread.new { sleep(0.1); buffer.take }
-
-        latch.wait(0.2).should be_true
-      end
-    end
-
-    describe '#take' do
-      it 'blocks when buffer is empty' do
-        t = Thread.new { buffer.take }
-
-        sleep(0.1)
-
-        t.status.should eq 'sleep'
-      end
-
-      it 'continues when an element is added' do
-        latch = CountDownLatch.new(1)
-
-        Thread.new { buffer.take; latch.count_down }
-        Thread.new { sleep(0.1); buffer.put 3 }
-
-        latch.wait(0.2).should be_true
-      end
-
-      it 'returns the first added value' do
-        buffer.put 'hi'
-        buffer.put 'foo'
-        buffer.put 'bar'
-
-        buffer.take.should eq 'hi'
-        buffer.take.should eq 'foo'
-        buffer.take.should eq 'bar'
-      end
-    end
-
-    describe '#peek' do
-      context 'buffer empty' do
-        it 'returns nil when buffer is empty' do
-          buffer.peek.should be_nil
-        end
-      end
-
-      context 'not empty' do
-
-        before(:each) { buffer.put 'element' }
-
-        it 'returns the first value' do
-          buffer.peek.should eq 'element'
-        end
-
-        it 'does not change buffer' do
-          buffer.peek
-          buffer.count.should eq 1
-        end
-      end
-    end
-
-    context 'circular condition' do
-      it 'can filled many times' do
-        fill_buffer
-        capacity.times { buffer.take }
-
-        buffer.put 'hi'
-
-        buffer.take.should eq 'hi'
-        buffer.capacity.should eq capacity
-      end
-    end
-
-  end
-end

data/spec/concurrent/collection/priority_queue_spec.rb

@@ -1,317 +0,0 @@
-require 'spec_helper'
-
-share_examples_for :priority_queue do
-
-  subject{ described_class.new }
-
-  context '#initialize' do
-
-    it 'sorts from high to low when :order is :max' do
-      subject = described_class.from_list([2, 1, 4, 5, 3, 0], order: :max)
-      subject.pop.should eq 5
-      subject.pop.should eq 4
-      subject.pop.should eq 3
-    end
-
-    it 'sorts from high to low when :order is :high' do
-      subject = described_class.new(order: :high)
-      [2, 1, 4, 5, 3, 0].each{|item| subject << item }
-      subject.pop.should eq 5
-      subject.pop.should eq 4
-      subject.pop.should eq 3
-    end
-
-    it 'sorts from low to high when :order is :min' do
-      subject = described_class.from_list([2, 1, 4, 5, 3, 0], order: :min)
-      subject.pop.should eq 0
-      subject.pop.should eq 1
-      subject.pop.should eq 2
-    end
-
-    it 'sorts from low to high when :order is :low' do
-      subject = described_class.new(order: :low)
-      [2, 1, 4, 5, 3, 0].each{|item| subject << item }
-      subject.pop.should eq 0
-      subject.pop.should eq 1
-      subject.pop.should eq 2
-    end
-
-    it 'sorts from high to low by default' do
-      subject = described_class.new
-      subject = described_class.from_list([2, 1, 4, 5, 3, 0])
-      subject.pop.should eq 5
-      subject.pop.should eq 4
-      subject.pop.should eq 3
-    end
-  end
-
-  context '#clear' do
-
-    it 'removes all items from a populated queue' do
-      10.times{|i| subject << i}
-      subject.clear
-      subject.should be_empty
-    end
-
-    it 'has no effect on an empty queue' do
-      subject.clear
-      subject.should be_empty
-    end
-
-    specify { subject.clear.should be_true }
-  end
-
-  context '#delete' do
-
-    it 'deletes the requested item when found' do
-      10.times{|item| subject << item }
-      subject.delete(5)
-      subject.pop.should eq 9
-      subject.pop.should eq 8
-      subject.pop.should eq 7
-      subject.pop.should eq 6
-      subject.pop.should eq 4
-      subject.pop.should eq 3
-      subject.pop.should eq 2
-      subject.pop.should eq 1
-      subject.pop.should eq 0
-    end
-
-    it 'deletes the requested item when it is the first element' do
-      10.times{|item| subject << item }
-      subject.delete(9)
-      subject.length.should eq 9
-      subject.pop.should eq 8
-      subject.pop.should eq 7
-      subject.pop.should eq 6
-      subject.pop.should eq 5
-      subject.pop.should eq 4
-      subject.pop.should eq 3
-      subject.pop.should eq 2
-      subject.pop.should eq 1
-      subject.pop.should eq 0
-    end
-
-    it 'deletes the requested item when it is the last element' do
-      10.times{|item| subject << item }
-      subject.delete(2)
-      subject.length.should eq 9
-      subject.pop.should eq 9
-      subject.pop.should eq 8
-      subject.pop.should eq 7
-      subject.pop.should eq 6
-      subject.pop.should eq 5
-      subject.pop.should eq 4
-      subject.pop.should eq 3
-      subject.pop.should eq 1
-      subject.pop.should eq 0
-    end
-
-    it 'deletes multiple matching items when present' do
-      [2, 1, 2, 2, 2, 3, 2].each{|item| subject << item }
-      subject.delete(2)
-      subject.pop.should eq 3
-      subject.pop.should eq 1
-    end
-
-    it 'returns true when found' do
-      10.times{|i| subject << i}
-      subject.delete(2).should be_true
-    end
-
-    it 'returns false when not found' do
-      10.times{|i| subject << i}
-      subject.delete(100).should be_false
-    end
-
-    it 'returns false when called on an empty queue' do
-      subject.delete(:foo).should be_false
-    end
-  end
-
-  context '#empty?' do
-
-    it 'returns true for an empty queue' do
-      subject.should be_empty
-    end
-
-    it 'returns false for a populated queue' do
-      10.times{|i| subject << i}
-      subject.should_not be_empty
-    end
-  end
-
-  context '#include?' do
-
-    it 'returns true if the item is found' do
-      10.times{|i| subject << i}
-      subject.should include(5)
-    end
-
-    it 'returns false if the item is not found' do
-      10.times{|i| subject << i}
-      subject.should_not include(50)
-    end
-
-    it 'returns false when the queue is empty' do
-      subject.should_not include(1)
-    end
-
-    it 'is aliased as #has_priority?' do
-      10.times{|i| subject << i}
-      subject.should have_priority(5)
-    end
-  end
-
-  context '#length' do
-
-    it 'returns the length of a populated queue' do
-      10.times{|i| subject << i}
-      subject.length.should eq 10
-    end
-
-    it 'returns zero when the queue is empty' do
-      subject.length.should eq 0
-    end
-
-    it 'is aliased as #size' do
-      10.times{|i| subject << i}
-      subject.size.should eq 10
-    end
-  end
-
-  context '#peek' do
-
-    it 'returns the item at the head of the queue' do
-      10.times{|i| subject << i}
-      subject.peek.should eq 9
-    end
-
-    it 'does not remove the item from the queue' do
-      10.times{|i| subject << i}
-      subject.peek
-      subject.length.should eq 10
-      subject.should include(9)
-    end
-
-    it 'returns nil when the queue is empty' do
-      subject.peek.should be_nil
-    end
-  end
-
-  context '#pop' do
-
-    it 'returns the item at the head of the queue' do
-      10.times{|i| subject << i}
-      subject.pop.should eq 9
-    end
-
-    it 'removes the item from the queue' do
-      10.times{|i| subject << i}
-      subject.pop
-      subject.length.should eq 9
-      subject.should_not include(9)
-    end
-
-    it 'returns nil when the queue is empty' do
-      subject.pop.should be_nil
-    end
-
-    it 'is aliased as #deq' do
-      10.times{|i| subject << i}
-      subject.deq.should eq 9
-    end
-
-    it 'is aliased as #shift' do
-      10.times{|i| subject << i}
-      subject.shift.should eq 9
-    end
-  end
-
-  context '#push' do
-
-    it 'adds the item to the queue' do
-      subject.push(1)
-      subject.should include(1)
-    end
-
-    it 'sorts the new item in priority order' do
-      3.times{|i| subject << i}
-      subject.pop.should eq 2
-      subject.pop.should eq 1
-      subject.pop.should eq 0
-    end
-
-    it 'arbitrarily orders equal items with respect to each other' do
-      3.times{|i| subject << i}
-      subject.push(1)
-      subject.pop.should eq 2
-      subject.pop.should eq 1
-      subject.pop.should eq 1
-      subject.pop.should eq 0
-    end
-
-    specify { subject.push(10).should be_true }
-
-    it 'is aliased as <<' do
-      subject << 1
-      subject.should include(1)
-    end
-
-    it 'is aliased as enq' do
-      subject.enq(1)
-      subject.should include(1)
-    end
-  end
-
-  context '.from_list' do
-
-    it 'creates an empty queue from an empty list' do
-      subject = described_class.from_list([])
-      subject.should be_empty
-    end
-
-    it 'creates a sorted, populated queue from an Array' do
-      subject = described_class.from_list([2, 1, 4, 5, 3, 0])
-      subject.pop.should eq 5
-      subject.pop.should eq 4
-      subject.pop.should eq 3
-      subject.pop.should eq 2
-      subject.pop.should eq 1
-      subject.pop.should eq 0
-    end
-
-    it 'creates a sorted, populated queue from a Hash' do
-      subject = described_class.from_list(two: 2, one: 1, three: 3, zero: 0)
-      subject.length.should eq 4
-    end
-  end
-end
-
-module Concurrent
-
-  describe MutexPriorityQueue do
-
-    it_should_behave_like :priority_queue
-  end
-
-  if TestHelpers.jruby?
-
-    describe JavaPriorityQueue do
-
-      it_should_behave_like :priority_queue
-    end
-  end
-
-  describe PriorityQueue do
-    if jruby?
-      it 'inherits from JavaPriorityQueue' do
-        PriorityQueue.ancestors.should include(JavaPriorityQueue)
-      end
-    else
-      it 'inherits from MutexPriorityQueue' do
-        PriorityQueue.ancestors.should include(MutexPriorityQueue)
-      end
-    end
-  end
-end