concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/spec/concurrent/channel/blocking_ring_buffer_spec.rb

@@ -0,0 +1,149 @@
+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/channel/buffered_channel_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe BufferedChannel do
+
+    let(:size) { 2 }
+    let!(:channel) { BufferedChannel.new(size) }
+    let(:probe) { Probe.new }
+
+    context 'without timeout' do
+
+      describe '#push' do
+        it 'adds elements to buffer' do
+          channel.buffer_queue_size.should be 0
+
+          channel.push('a')
+          channel.push('a')
+
+          channel.buffer_queue_size.should be 2
+        end
+
+        it 'should block when buffer is full' do
+          channel.push 1
+          channel.push 2
+
+          t = Thread.new { channel.push 3 }
+          sleep(0.05)
+          t.status.should eq 'sleep'
+        end
+
+        it 'restarts thread when buffer is no more full' do
+          channel.push 'hi'
+          channel.push 'foo'
+
+          result = nil
+
+          Thread.new { channel.push 'bar'; result = 42 }
+
+          sleep(0.1)
+
+          channel.pop
+
+          sleep(0.1)
+
+          result.should eq 42
+        end
+
+        it 'should assign value to a probe if probe set is not empty' do
+          channel.select(probe)
+          Thread.new { sleep(0.1); channel.push 3 }
+          probe.value.should eq 3
+        end
+      end
+
+      describe '#pop' do
+        it 'should block if buffer is empty' do
+          t = Thread.new { channel.pop }
+          sleep(0.05)
+          t.status.should eq 'sleep'
+        end
+
+        it 'returns value if buffer is not empty' do
+          channel.push 1
+          result = channel.pop
+
+          result.should eq 1
+        end
+
+        it 'removes the first value from the buffer' do
+          channel.push 'a'
+          channel.push 'b'
+
+          channel.pop.should eq 'a'
+          channel.buffer_queue_size.should eq 1
+        end
+      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
+
+    end
+
+    context 'already set probes' do
+      context 'empty buffer' do
+        it 'discards already set probes' do
+          probe.set('set value')
+
+          channel.select(probe)
+
+          channel.push 27
+
+          channel.buffer_queue_size.should eq 1
+          channel.probe_set_size.should eq 0
+        end
+      end
+
+      context 'empty probe set' do
+        it 'discards set probe' do
+          probe.set('set value')
+
+          channel.push 82
+
+          channel.select(probe)
+
+          channel.buffer_queue_size.should eq 1
+
+          channel.pop.should eq 82
+
+        end
+      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/channel/channel_spec.rb

@@ -0,0 +1,37 @@
+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.select(*channels)
+
+          value.should eq 77
+        end
+
+        it 'cleans up' do
+          channels = [ UnbufferedChannel.new, UnbufferedChannel.new]
+          channels.each { |ch| ch.stub(:remove_probe).with( an_instance_of(Probe) )}
+
+          Thread.new { channels[1].push 77 }
+
+          value = Channel.select(*channels)
+
+          value.should eq 77
+
+          channels.each { |ch| expect(ch).to have_received(:remove_probe).with( an_instance_of(Probe) ) }
+        end
+      end
+
+    end
+
+  end
+end

data/spec/concurrent/channel/probe_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe Probe do
+
+    let(:probe) { Probe.new }
+
+    describe '#set_unless_assigned' do
+      context 'empty probe' do
+        it 'assigns the value' do
+          probe.set_unless_assigned(32)
+          probe.value.should eq 32
+        end
+
+        it 'returns true' do
+          probe.set_unless_assigned('hi').should eq true
+        end
+      end
+
+      context 'fulfilled probe' do
+        before(:each) { probe.set(27) }
+
+        it 'does not assign the value' do
+          probe.set_unless_assigned(88)
+          probe.value.should eq 27
+        end
+
+        it 'returns false' do
+          probe.set_unless_assigned('hello').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)
+          probe.should be_rejected
+        end
+
+        it 'returns false' do
+          probe.set_unless_assigned('hello').should eq false
+        end
+      end
+    end
+
+  end
+end

data/spec/concurrent/channel/ring_buffer_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe RingBuffer do
+
+    let(:capacity) { 3 }
+    let(:buffer) { RingBuffer.new(capacity) }
+
+    def fill_buffer
+      capacity.times { buffer.offer 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.offer 5
+        buffer.count.should eq 1
+
+        buffer.offer 1
+        buffer.count.should eq 2
+      end
+
+      it 'decreases when an element is removed' do
+        buffer.offer 10
+        buffer.poll
+
+        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.offer 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 '#offer' do
+      it 'returns false when buffer is full' do
+        fill_buffer
+        buffer.offer(3).should be_false
+      end
+
+      it 'returns true when the buffer is not full' do
+        buffer.offer(5).should be_true
+      end
+
+    end
+
+    describe '#poll' do
+      it 'returns the first added value' do
+        buffer.offer 'hi'
+        buffer.offer 'foo'
+        buffer.offer 'bar'
+
+        buffer.poll.should eq 'hi'
+        buffer.poll.should eq 'foo'
+        buffer.poll.should eq 'bar'
+      end
+
+      it 'returns nil when buffer is empty' do
+        buffer.poll.should be_nil
+      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.offer '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.poll }
+
+        buffer.offer 'hi'
+
+        buffer.poll.should eq 'hi'
+        buffer.capacity.should eq capacity
+      end
+    end
+
+  end
+end