concurrent-ruby 0.6.0 → 0.7.0.rc0

data/spec/concurrent/atomic/thread_local_var_spec.rb

@@ -1,113 +0,0 @@
-require 'spec_helper'
-require 'rbconfig'
-
-module Concurrent
-
-  describe ThreadLocalVar do
-
-    subject{ ThreadLocalVar.new }
-
-    context '#initialize' do
-
-      it 'can set an initial value' do
-        v = ThreadLocalVar.new(14)
-        v.value.should eq 14
-      end
-
-      it 'sets nil as a default initial value' do
-        v = ThreadLocalVar.new
-        v.value.should be_nil
-      end
-
-      it 'sets the same initial value for all threads' do
-        v = ThreadLocalVar.new(14)
-        t1 = Thread.new { v.value }
-        t2 = Thread.new { v.value }
-        t1.value.should eq 14
-        t2.value.should eq 14
-      end
-
-      if jruby?
-        it 'uses ThreadLocalJavaStorage' do
-          subject.class.ancestors.should include(Concurrent::ThreadLocalJavaStorage)
-        end
-      elsif rbx? || RbConfig::CONFIG['ruby_version'] =~ /^1\.9/
-        it 'uses ThreadLocalOldStorage' do
-          subject.class.ancestors.should include(Concurrent::ThreadLocalOldStorage)
-        end
-      else
-        it 'uses ThreadLocalNewStorage' do
-          subject.class.ancestors.should include(Concurrent::ThreadLocalNewStorage)
-        end
-      end
-    end
-
-    context '#value' do
-
-      it 'returns the current value' do
-        v = ThreadLocalVar.new(14)
-        v.value.should eq 14
-      end
-
-      it 'returns the value after modification' do
-        v = ThreadLocalVar.new(14)
-        v.value = 2
-        v.value.should eq 2
-      end
-
-    end
-
-    context '#value=' do
-
-      it 'sets a new value' do
-        v = ThreadLocalVar.new(14)
-        v.value = 2
-        v.value.should eq 2
-      end
-
-      it 'returns the new value' do
-        v = ThreadLocalVar.new(14)
-        (v.value = 2).should eq 2
-      end
-
-      it 'does not modify the initial value for other threads' do
-        v = ThreadLocalVar.new(14)
-        v.value = 2
-        t = Thread.new { v.value }
-        t.value.should eq 14
-      end
-
-      it 'does not modify the value for other threads' do
-        v = ThreadLocalVar.new(14)
-        v.value = 2
-
-        b1 = CountDownLatch.new(2)
-        b2 = CountDownLatch.new(2)
-
-        t1 = Thread.new do
-          b1.count_down
-          b1.wait
-          v.value = 1
-          b2.count_down
-          b2.wait
-          v.value
-        end
-
-        t2 = Thread.new do
-          b1.count_down
-          b1.wait
-          v.value = 2
-          b2.count_down
-          b2.wait
-          v.value
-        end
-
-        t1.value.should eq 1
-        t2.value.should eq 2
-      end
-
-    end
-
-  end
-
-end

data/spec/concurrent/channel/buffered_channel_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe BufferedChannel do
-
-    let(:size) { 2 }
-    let!(:channel) { BufferedChannel.new(size) }
-    let(:probe) { Channel::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

@@ -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