concurrent-ruby 0.6.0 → 0.7.0.rc0

data/spec/concurrent/async_spec.rb

@@ -1,352 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe Async do
-
-    let(:executor) { PerThreadExecutor.new }
-
-    let(:async_class) do
-      Class.new do
-        include Concurrent::Async
-        attr_accessor :accessor
-        def initialize
-          init_mutex
-        end
-        def echo(msg)
-          msg
-        end
-        def gather(first, second = nil)
-          return first, second
-        end
-        def boom(ex = StandardError.new)
-          raise ex
-        end
-        def wait(seconds)
-          sleep(seconds)
-        end
-        def with_block
-          yield
-        end
-      end
-    end
-
-    subject do
-      obj = async_class.new
-      obj.executor = executor
-      obj
-    end
-
-    context '#validate_argc' do
-
-      subject do
-        Class.new {
-          def zero() nil; end
-          def three(a, b, c, &block) nil; end
-          def two_plus_two(a, b, c=nil, d=nil, &block) nil; end
-          def many(*args, &block) nil; end
-        }.new
-      end
-
-      it 'raises an exception when the method is not defined' do
-        expect {
-          Async::validate_argc(subject, :bogus)
-        }.to raise_error(StandardError)
-      end
-
-      it 'raises an exception for too many args on a zero arity method' do
-        expect {
-          Async::validate_argc(subject, :zero, 1, 2, 3)
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'does not raise an exception for correct zero arity' do
-        expect {
-          Async::validate_argc(subject, :zero)
-        }.not_to raise_error
-      end
-
-      it 'raises an exception for too many args on a method with positive arity' do
-        expect {
-          Async::validate_argc(subject, :three, 1, 2, 3, 4)
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'raises an exception for too few args on a method with positive arity' do
-        expect {
-          Async::validate_argc(subject, :three, 1, 2)
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'does not raise an exception for correct positive arity' do
-        expect {
-          Async::validate_argc(subject, :three, 1, 2, 3)
-        }.not_to raise_error
-      end
-
-      it 'raises an exception for too few args on a method with negative arity' do
-        expect {
-          Async::validate_argc(subject, :two_plus_two, 1)
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'does not raise an exception for correct negative arity' do
-        expect {
-          Async::validate_argc(subject, :two_plus_two, 1, 2)
-          Async::validate_argc(subject, :two_plus_two, 1, 2, 3, 4)
-          Async::validate_argc(subject, :two_plus_two, 1, 2, 3, 4, 5, 6)
-
-          Async::validate_argc(subject, :many)
-          Async::validate_argc(subject, :many, 1, 2)
-          Async::validate_argc(subject, :many, 1, 2, 3, 4)
-        }.not_to raise_error
-      end
-    end
-
-    context 'executor' do
-
-      it 'returns the default executor when #executor= has never been called' do
-        Concurrent.configuration.should_receive(:global_operation_pool).
-          and_return(ImmediateExecutor.new)
-        subject = async_class.new
-        subject.async.echo(:foo)
-      end
-
-      it 'returns the memo after #executor= has been called' do
-        executor = ImmediateExecutor.new
-        executor.should_receive(:post)
-        subject = async_class.new
-        subject.executor = executor
-        subject.async.echo(:foo)
-      end
-
-      it 'raises an exception if #executor= is called after initialization complete' do
-        executor = ImmediateExecutor.new
-        subject = async_class.new
-        subject.async.echo(:foo)
-        expect {
-          subject.executor = executor
-        }.to raise_error(ArgumentError)
-      end
-    end
-
-    context '#async' do
-
-      it 'raises an error when calling a method that does not exist' do
-        expect {
-          subject.async.bogus
-        }.to raise_error(StandardError)
-      end
-
-      it 'raises an error when passing too few arguments' do
-        expect {
-          subject.async.gather
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'raises an error when pasing too many arguments (arity >= 0)' do
-        expect {
-          subject.async.echo(1, 2, 3, 4, 5)
-        }.to raise_error(StandardError)
-      end
-
-      it 'returns a :pending Future' do
-        val = subject.async.wait(5)
-        val.should be_a Concurrent::Future
-        val.should be_pending
-      end
-
-      it 'runs the Future on the memoized executor' do
-        executor = ImmediateExecutor.new
-        executor.should_receive(:post).with(any_args)
-        subject = async_class.new
-        subject.executor = executor
-        subject.async.echo(:foo)
-      end
-
-      it 'sets the value on success' do
-        val = subject.async.echo(:foo)
-        val.value.should eq :foo
-        val.should be_fulfilled
-      end
-
-      it 'sets the reason on failure' do
-        ex = ArgumentError.new
-        val = subject.async.boom(ex)
-        sleep(0.1)
-        val.reason.should eq ex
-        val.should be_rejected
-      end
-
-      it 'sets the reason when giving too many optional arguments' do
-        val = subject.async.gather(1, 2, 3, 4, 5)
-        sleep(0.1)
-        val.reason.should be_a StandardError
-        val.should be_rejected
-      end
-
-      it 'supports attribute accessors' do
-        subject.async.accessor = :foo
-        sleep(0.1)
-        val = subject.async.accessor
-        sleep(0.1)
-        val.value.should eq :foo
-        subject.accessor.should eq :foo
-      end
-
-      it 'supports methods with blocks' do
-        val = subject.async.with_block{ :foo }
-        sleep(0.1)
-        val.value.should eq :foo
-      end
-
-      it 'is aliased as #future' do
-        val = subject.future.wait(5)
-        val.should be_a Concurrent::Future
-      end
-
-      context '#method_missing' do
-
-        it 'defines the method after the first call' do
-          expect { subject.async.method(:echo) }.to raise_error(NameError)
-          subject.async.echo(:foo)
-          sleep(0.1)
-          expect { subject.async.method(:echo) }.not_to raise_error
-        end
-
-        it 'does not define the method on name/arity exception' do
-          expect { subject.async.method(:bogus) }.to raise_error(NameError)
-          expect { subject.async.bogus }.to raise_error(NameError)
-          expect { subject.async.method(:bogus) }.to raise_error(NameError)
-        end
-      end
-    end
-
-    context '#await' do
-
-      it 'raises an error when calling a method that does not exist' do
-        expect {
-          subject.await.bogus
-        }.to raise_error(StandardError)
-      end
-
-      it 'raises an error when passing too few arguments' do
-        expect {
-          subject.await.gather
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'raises an error when pasing too many arguments (arity >= 0)' do
-        expect {
-          subject.await.echo(1, 2, 3, 4, 5)
-        }.to raise_error(StandardError)
-      end
-
-      it 'returns a :fulfilled IVar' do
-        val = subject.await.echo(5)
-        val.should be_a Concurrent::IVar
-        val.should be_fulfilled
-      end
-
-      it 'sets the value on success' do
-        val = subject.await.echo(:foo)
-        val.value.should eq :foo
-        val.should be_fulfilled
-      end
-
-      it 'sets the reason on failure' do
-        ex = ArgumentError.new
-        val = subject.await.boom(ex)
-        val.reason.should eq ex
-        val.should be_rejected
-      end
-
-      it 'sets the reason when giving too many optional arguments' do
-        val = subject.await.gather(1, 2, 3, 4, 5)
-        val.reason.should be_a StandardError
-        val.should be_rejected
-      end
-
-      it 'supports attribute accessors' do
-        subject.await.accessor = :foo
-        val = subject.await.accessor
-        val.value.should eq :foo
-        subject.accessor.should eq :foo
-      end
-
-      it 'supports methods with blocks' do
-        val = subject.await.with_block{ :foo }
-        val.value.should eq :foo
-      end
-
-      it 'is aliased as #delay' do
-        val = subject.delay.echo(5)
-        val.should be_a Concurrent::IVar
-      end
-
-      context '#method_missing' do
-
-        it 'defines the method after the first call' do
-          expect { subject.await.method(:echo) }.to raise_error(NameError)
-          subject.await.echo(:foo)
-          expect { subject.await.method(:echo) }.not_to raise_error
-        end
-
-        it 'does not define the method on name/arity exception' do
-          expect { subject.await.method(:bogus) }.to raise_error(NameError)
-          expect { subject.await.bogus }.to raise_error(NameError)
-          expect { subject.await.method(:bogus) }.to raise_error(NameError)
-        end
-      end
-    end
-
-    context 'locking' do
-
-      it 'uses the same mutex for both #async and #await' do
-        object = Class.new {
-          include Concurrent::Async
-          attr_reader :bucket
-          def initialize() init_mutex; end
-          def gather(seconds, first, *rest)
-            sleep(seconds)
-            (@bucket ||= []).concat([first])
-            @bucket.concat(rest)
-          end
-        }.new
-
-        object.async.gather(0.5, :a, :b)
-        sleep(0.1)
-        object.await.gather(0, :c, :d)
-        object.bucket.should eq [:a, :b, :c, :d]
-      end
-
-      context 'raises an InitializationError' do
-
-        let(:async_class) do
-          Class.new do
-            include Concurrent::Async
-            def echo(msg) msg; end
-          end
-        end
-
-        it 'when #async is called before #init_mutex' do
-          expect {
-            async_class.new.async.echo(:foo)
-          }.to raise_error(Concurrent::InitializationError)
-        end
-
-        it 'when #await is called before #init_mutex' do
-          expect {
-            async_class.new.async.echo(:foo)
-          }.to raise_error(Concurrent::InitializationError)
-        end
-
-        it 'when #executor= is called before #init_mutex' do
-          expect {
-            async_class.new.executor = Concurrent::ImmediateExecutor.new
-          }.to raise_error(Concurrent::InitializationError)
-        end
-      end
-    end
-  end
-end

data/spec/concurrent/atomic/atomic_boolean_spec.rb

@@ -1,172 +0,0 @@
-require 'spec_helper'
-
-share_examples_for :atomic_boolean do
-
-  describe 'construction' do
-
-    it 'sets the initial value' do
-      described_class.new(true).value.should be_true
-    end
-
-    it 'defaults the initial value to false' do
-      described_class.new.value.should be_false
-    end
-
-    it 'evaluates the truthiness of a true value' do
-      described_class.new(10).value.should be_true
-    end
-
-    it 'evaluates the truthiness of a false value' do
-      described_class.new(nil).value.should be_false
-    end
-  end
-
-  describe '#value' do
-
-    it 'returns the current value' do
-      counter = described_class.new(true)
-      counter.value.should be_true
-      counter.make_false
-      counter.value.should be_false
-      counter.make_true
-      counter.value.should be_true
-    end
-  end
-
-  describe '#value=' do
-
-    it 'sets the #value to the given `Boolean`' do
-      atomic = described_class.new(true)
-      atomic.value = false
-      atomic.value.should be_false
-    end
-
-    it 'returns the new value' do
-      atomic = described_class.new(false)
-      (atomic.value = true).should be_true
-    end
-
-    it 'evaluates the truthiness of a true value' do
-      atomic = described_class.new(false)
-      atomic.value = 10
-      atomic.value.should be_true
-    end
-
-    it 'evaluates the truthiness of a false value' do
-      atomic = described_class.new(true)
-      atomic.value = nil
-      atomic.value.should be_false
-    end
-  end
-
-  describe '#true?' do
-
-    specify { described_class.new(true).true?.should be_true }
-
-    specify { described_class.new(false).true?.should be_false }
-  end
-
-  describe '#false?' do
-
-    specify { described_class.new(true).false?.should be_false }
-
-    specify { described_class.new(false).false?.should be_true }
-  end
-
-  describe '#make_true' do
-
-    it 'makes a false value true and returns true' do
-      subject = described_class.new(false)
-      subject.make_true.should be_true
-      subject.value.should be_true
-    end
-
-    it 'keeps a true value true and returns false' do
-      subject = described_class.new(true)
-      subject.make_true.should be_false
-      subject.value.should be_true
-    end
-  end
-
-  describe '#make_false' do
-
-    it 'makes a true value false and returns true' do
-      subject = described_class.new(true)
-      subject.make_false.should be_true
-      subject.value.should be_false
-    end
-
-    it 'keeps a false value false and returns false' do
-      subject = described_class.new(false)
-      subject.make_false.should be_false
-      subject.value.should be_false
-    end
-  end
-end
-
-module Concurrent
-
-  describe MutexAtomicBoolean do
-
-    it_should_behave_like :atomic_boolean
-
-    specify 'construction is synchronized' do
-      mutex = double('mutex')
-      Mutex.should_receive(:new).once.with(no_args).and_return(mutex)
-      described_class.new
-    end
-
-    context 'instance methods' do
-
-      before(:each) do
-        mutex = double('mutex')
-        Mutex.stub(:new).with(no_args).and_return(mutex)
-        mutex.should_receive(:lock)
-        mutex.should_receive(:unlock)
-      end
-
-      specify 'value is synchronized' do
-        described_class.new.value
-      end
-
-      specify 'value= is synchronized' do
-        described_class.new.value = 10
-      end
-
-      specify 'true? is synchronized' do
-        described_class.new.true?
-      end
-
-      specify 'false? is synchronized' do
-        described_class.new.false?
-      end
-
-      specify 'make_true is synchronized' do
-        described_class.new.make_true
-      end
-
-      specify 'make_false is synchronized' do
-        described_class.new.make_false
-      end
-    end
-  end
-
-  if TestHelpers.jruby?
-
-    describe JavaAtomicBoolean do
-      it_should_behave_like :atomic_boolean
-    end
-  end
-
-  describe AtomicBoolean do
-    if jruby?
-      it 'inherits from JavaAtomicBoolean' do
-        AtomicBoolean.ancestors.should include(JavaAtomicBoolean)
-      end
-    else
-      it 'inherits from MutexAtomicBoolean' do
-        AtomicBoolean.ancestors.should include(MutexAtomicBoolean)
-      end
-    end
-  end
-end

data/spec/concurrent/atomic/atomic_fixnum_spec.rb

@@ -1,186 +0,0 @@
-require 'spec_helper'
-
-share_examples_for :atomic_fixnum do
-
-  context 'construction' do
-
-    it 'sets the initial value' do
-      described_class.new(10).value.should eq 10
-    end
-
-    it 'defaults the initial value to zero' do
-      described_class.new.value.should eq 0
-    end
-
-    it 'raises en exception if the initial value is not a Fixnum' do
-      lambda {
-        described_class.new(10.01)
-      }.should raise_error
-    end
-  end
-
-  context '#value' do
-
-    it 'returns the current value' do
-      counter = described_class.new(10)
-      counter.value.should eq 10
-      counter.increment
-      counter.value.should eq 11
-      counter.decrement
-      counter.value.should eq 10
-    end
-  end
-
-  context '#value=' do
-
-    it 'sets the #value to the given `Fixnum`' do
-      atomic = described_class.new(0)
-      atomic.value = 10
-      atomic.value.should eq 10
-    end
-
-    it 'returns the new value' do
-      atomic = described_class.new(0)
-      (atomic.value = 10).should eq 10
-    end
-
-    it 'raises and exception if the value is not a `Fixnum`' do
-      atomic = described_class.new(0)
-      expect {
-        atomic.value = 'foo'
-      }.to raise_error
-    end
-  end
-
-  context '#increment' do
-
-    it 'increases the value by one' do
-      counter = described_class.new(10)
-      3.times{ counter.increment }
-      counter.value.should eq 13
-    end
-
-    it 'returns the new value' do
-      counter = described_class.new(10)
-      counter.increment.should eq 11
-    end
-
-    it 'is aliased as #up' do
-      described_class.new(10).up.should eq 11
-    end
-  end
-
-  context '#decrement' do
-
-    it 'decreases the value by one' do
-      counter = described_class.new(10)
-      3.times{ counter.decrement }
-      counter.value.should eq 7
-    end
-
-    it 'returns the new value' do
-      counter = described_class.new(10)
-      counter.decrement.should eq 9
-    end
-
-    it 'is aliased as #down' do
-      described_class.new(10).down.should eq 9
-    end
-  end
-
-  context '#compare_and_set' do
-
-    it 'returns false if the value is not found' do
-      described_class.new(14).compare_and_set(2, 14).should eq false
-    end
-
-    it 'returns true if the value is found' do
-      described_class.new(14).compare_and_set(14, 2).should eq true
-    end
-
-    it 'sets if the value is found' do
-      f = described_class.new(14)
-      f.compare_and_set(14, 2)
-      f.value.should eq 2
-    end
-
-    it 'does not set if the value is not found' do
-      f = described_class.new(14)
-      f.compare_and_set(2, 12)
-      f.value.should eq 14
-    end
-  end
-end
-
-module Concurrent
-
-  describe MutexAtomicFixnum do
-
-    it_should_behave_like :atomic_fixnum
-
-    specify 'construction is synchronized' do
-      mutex = double('mutex')
-      Mutex.should_receive(:new).once.with(no_args).and_return(mutex)
-      described_class.new
-    end
-
-    specify 'value is synchronized' do
-      mutex = double('mutex')
-      Mutex.stub(:new).with(no_args).and_return(mutex)
-      mutex.should_receive(:lock)
-      mutex.should_receive(:unlock)
-      described_class.new.value
-    end
-
-    specify 'value= is synchronized' do
-      mutex = double('mutex')
-      Mutex.stub(:new).with(no_args).and_return(mutex)
-      mutex.should_receive(:lock)
-      mutex.should_receive(:unlock)
-      described_class.new.value = 10
-    end
-
-    specify 'increment is synchronized' do
-      mutex = double('mutex')
-      Mutex.stub(:new).with(no_args).and_return(mutex)
-      mutex.should_receive(:lock)
-      mutex.should_receive(:unlock)
-      described_class.new.increment
-    end
-
-    specify 'decrement is synchronized' do
-      mutex = double('mutex')
-      Mutex.stub(:new).with(no_args).and_return(mutex)
-      mutex.should_receive(:lock)
-      mutex.should_receive(:unlock)
-      described_class.new.decrement
-    end
-
-    specify 'compare_and_set is synchronized' do
-      mutex = double('mutex')
-      Mutex.stub(:new).with(no_args).and_return(mutex)
-      mutex.should_receive(:lock)
-      mutex.should_receive(:unlock)
-      described_class.new(14).compare_and_set(14, 2)
-    end
-  end
-
-  if TestHelpers.jruby?
-
-    describe JavaAtomicFixnum do
-      it_should_behave_like :atomic_fixnum
-    end
-  end
-
-  describe AtomicFixnum do
-    if jruby?
-      it 'inherits from JavaAtomicFixnum' do
-        AtomicFixnum.ancestors.should include(JavaAtomicFixnum)
-      end
-    else
-      it 'inherits from MutexAtomicFixnum' do
-        AtomicFixnum.ancestors.should include(MutexAtomicFixnum)
-      end
-    end
-  end
-end