concurrent-ruby 0.6.1 → 0.7.0.rc0

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

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