concurrent-ruby 0.3.0.pre.1 → 0.3.0.pre.2

data/spec/concurrent/functions_spec.rb

@@ -1,197 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe 'functions' do
-
-    context '#post' do
-
-      it 'calls #post when supported by the object' do
-        object = Class.new{
-          def post() nil; end
-        }.new
-        object.should_receive(:post).with(no_args())
-        post(object){ nil }
-      end
-
-      it 'raises an exception when not supported by the object' do
-        object = Class.new{ }.new
-        lambda {
-          post(object){ nil }
-        }.should raise_error(ArgumentError)
-      end
-    end
-
-    context '#deref' do
-
-      it 'returns the value of the #deref function' do
-        object = Class.new{
-          def deref() nil; end
-        }.new
-        object.should_receive(:deref).with(nil)
-        deref(object, nil){ nil }
-      end
-
-      it 'returns the value of the #value function' do
-        object = Class.new{
-          def value() nil; end
-        }.new
-        object.should_receive(:value).with(nil)
-        deref(object, nil){ nil }
-      end
-
-      it 'raises an exception when not supported by the object' do
-        object = Class.new{ }.new
-        lambda {
-          deref(object, nil){ nil }
-        }.should raise_error(ArgumentError)
-      end
-    end
-
-    context '#pending?' do
-
-      it 'returns the value of the #pending? function' do
-        object = Class.new{
-          def pending?() nil; end
-        }.new
-        object.should_receive(:pending?).with(no_args())
-        pending?(object){ nil }
-      end
-
-      it 'raises an exception when not supported by the object' do
-        object = Class.new{ }.new
-        lambda {
-          pending?(object){ nil }
-        }.should raise_error(ArgumentError)
-      end
-    end
-
-    context '#fulfilled?' do
-
-      it 'returns the value of the #fulfilled? function' do
-        object = Class.new{
-          def fulfilled?() nil; end
-        }.new
-        object.should_receive(:fulfilled?).with(no_args())
-        fulfilled?(object){ nil }
-      end
-
-      it 'returns the value of the #realized? function' do
-        object = Class.new{
-          def realized?() nil; end
-        }.new
-        object.should_receive(:realized?).with(no_args())
-        fulfilled?(object){ nil }
-      end
-
-      it 'raises an exception when not supported by the object' do
-        object = Class.new{ }.new
-        lambda {
-          fulfilled?(object){ nil }
-        }.should raise_error(ArgumentError)
-      end
-    end
-
-    context '#realized?' do
-
-      it 'returns the value of the #realized? function' do
-        object = Class.new{
-          def realized?() nil; end
-        }.new
-        object.should_receive(:realized?).with(no_args())
-        realized?(object){ nil }
-      end
-
-      it 'returns the value of the #fulfilled? function' do
-        object = Class.new{
-          def fulfilled?() nil; end
-        }.new
-        object.should_receive(:fulfilled?).with(no_args())
-        realized?(object){ nil }
-      end
-
-      it 'raises an exception when not supported by the object' do
-        object = Class.new{ }.new
-        lambda {
-          realized?(object){ nil }
-        }.should raise_error(ArgumentError)
-      end
-    end
-
-    context '#rejected?' do
-
-      it 'returns the value of the #rejected? function' do
-        object = Class.new{
-          def rejected?() nil; end
-        }.new
-        object.should_receive(:rejected?).with(no_args())
-        rejected?(object){ nil }
-      end
-
-      it 'raises an exception when not supported by the object' do
-        object = Class.new{ }.new
-        lambda {
-          rejected?(object){ nil }
-        }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe Agent do
-
-    before(:each) do
-      Agent.thread_pool = FixedThreadPool.new(1)
-    end
-
-    it 'aliases #<< for Agent#post' do
-      subject = Agent.new(0)
-      subject << proc{ 100 }
-      sleep(0.1)
-      subject.value.should eq 100
-    end
-
-    it 'aliases Kernel#agent for Agent.new' do
-      agent(10).should be_a(Agent)
-    end
-
-    it 'aliases Kernel#deref for #deref' do
-      deref(Agent.new(10)).should eq 10
-      deref(Agent.new(10), 10).should eq 10
-    end
-
-    it 'aliases Kernel:post for Agent#post' do
-      subject = Agent.new(0)
-      post(subject){ 100 }
-      sleep(0.1)
-      subject.value.should eq 100
-    end
-  end
-
-  describe Future do
-
-    before(:each) do
-      Future.thread_pool = FixedThreadPool.new(1)
-    end
-
-    it 'aliases Kernel#future for Future.new' do
-      future().should be_a(Future)
-      future(){ nil }.should be_a(Future)
-      future(1, 2, 3).should be_a(Future)
-      future(1, 2, 3){ nil }.should be_a(Future)
-    end
-  end
-
-  describe Promise do
-
-    before(:each) do
-      Promise.thread_pool = FixedThreadPool.new(1)
-    end
-
-    it 'aliases Kernel#promise for Promise.new' do
-      promise().should be_a(Promise)
-      promise(){ nil }.should be_a(Promise)
-      promise(1, 2, 3).should be_a(Promise)
-      promise(1, 2, 3){ nil }.should be_a(Promise)
-    end
-  end
-end

data/spec/concurrent/null_thread_pool_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-require 'concurrent/goroutine'
-
-module Concurrent
-
-  describe NullThreadPool do
-
-    subject { NullThreadPool.new }
-
-    after(:all) do
-      $GLOBAL_THREAD_POOL = FixedThreadPool.new(1)
-    end
-
-    context '#post' do
-
-      it 'creates a new thread for a call without arguments' do
-        thread = Thread.new{ nil }
-        Thread.should_receive(:new).with(no_args()).and_return(thread)
-        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
-        subject.post{ nil }
-      end
-
-      it 'executes a call without arguments' do
-        @expected = false
-        subject.post{ @expected = true }
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'creates a new thread for a call with arguments' do
-        thread = Thread.new{ nil }
-        Thread.should_receive(:new).with(1,2,3).and_return(thread)
-        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
-        subject.post(1,2,3){ nil }
-      end
-
-      it 'executes a call with one argument' do
-        @expected = 0
-        subject.post(1){|one| @expected = one }
-        sleep(0.1)
-        @expected.should == 1
-      end
-
-      it 'executes a call with multiple arguments' do
-        @expected = nil
-        subject.post(1,2,3,4,5){|*args| @expected = args }
-        sleep(0.1)
-        @expected.should eq [1,2,3,4,5]
-      end
-
-      it 'aliases #<<' do
-        thread = Thread.new{ nil }
-        Thread.should_receive(:new).with(no_args()).and_return(thread)
-        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
-        subject << proc{ nil }
-      end
-    end
-
-    context 'operation' do
-
-      context 'goroutine' do
-
-        it 'gets a new thread' do
-          $GLOBAL_THREAD_POOL = subject
-
-          t = Thread.new{ nil }
-
-          Thread.should_receive(:new).with(no_args()).and_return(t)
-          go{ nil }
-
-          Thread.should_receive(:new).with(1,2,3).and_return(t)
-          go(1,2,3){ nil }
-        end
-      end
-    end
-  end
-end