concurrent-ruby 0.1.1.pre.5 → 0.1.1

data/spec/concurrent/global_thread_pool_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe UsesGlobalThreadPool do
-
-    before(:each) do
-      $GLOBAL_THREAD_POOL = FixedThreadPool.new(1)
-    end
-
-    it 'defaults to the global thread pool' do
-      clazz = Class.new{ include UsesGlobalThreadPool }
-      clazz.thread_pool.should eq $GLOBAL_THREAD_POOL
-    end
-
-    it 'sets and gets the thread pool for the class' do
-      pool = NullThreadPool.new
-      clazz = Class.new{ include UsesGlobalThreadPool }
-
-      clazz.thread_pool = pool
-      clazz.thread_pool.should eq pool
-    end
-
-    it 'gives each class its own thread pool' do
-      clazz1 = Class.new{ include UsesGlobalThreadPool }
-      clazz2 = Class.new{ include UsesGlobalThreadPool }
-      clazz3 = Class.new{ include UsesGlobalThreadPool }
-
-      clazz1.thread_pool = FixedThreadPool.new(1)
-      clazz2.thread_pool = CachedThreadPool.new
-      clazz3.thread_pool = NullThreadPool.new
-
-      clazz1.thread_pool.should_not eq clazz2.thread_pool
-      clazz2.thread_pool.should_not eq clazz3.thread_pool
-      clazz3.thread_pool.should_not eq clazz1.thread_pool
-    end
-  end
-end

data/spec/concurrent/null_thread_pool_spec.rb

@@ -1,54 +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 'proxies a call without arguments' do
-        Thread.should_receive(:new).with(no_args())
-        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
-        subject.post{ nil }
-      end
-
-      it 'proxies a call with arguments' do
-        Thread.should_receive(:new).with(1,2,3)
-        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
-        subject.post(1,2,3){ nil }
-      end
-
-      it 'aliases #<<' do
-        Thread.should_receive(:new).with(no_args())
-        $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

data/spec/concurrent/reactor/drb_async_demux_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-  class Reactor
-
-    describe DRbAsyncDemux do
-
-      pending
-
-    end
-  end
-end

data/spec/concurrent/reactor/tcp_sync_demux_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-  class Reactor
-
-    describe TcpSyncDemux do
-
-      pending
-
-    end
-  end
-end

data/spec/concurrent/reactor_spec.rb

@@ -1,351 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe Reactor do
-
-    let(:sync_demux) do
-      Class.new {
-        def initialize
-          @running = false
-          @queue = Queue.new
-        end
-        def start() @running = true; end
-        def stop
-          @queue.push(:stop)
-          @running = false
-        end
-        def stopped?() return ! @running; end
-        def accept()
-          event = @queue.pop
-          if event == :stop
-            return nil
-          else
-            return Reactor::EventContext.new(event)
-          end
-        end
-        def respond(result, message) return [result, message]; end
-        def close() nil; end
-        def send(event) @queue.push(event) end
-      }.new
-    end
-
-    let(:async_demux) do
-      Class.new {
-        def initialize() @running = false; end
-        def start() @running = true; end
-        def stop() @running = false; end
-        def stopped?() return ! @running; end
-        def set_reactor(reactor) @reactor = reactor; end
-        def send(event) @reactor.handle(event); end
-      }.new
-    end
-
-    context '#initialize' do
-
-      it 'raises an exception when the demux is not valid' do
-        lambda {
-          Reactor.new('bogus demux')
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'sets the initial state to not running' do
-        Reactor.new.should_not be_running
-      end
-    end
-
-    context '#running?' do
-
-      it 'returns true when the reactor is running' do
-        reactor = Reactor.new
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        reactor.should be_running
-        reactor.stop
-      end
-
-      it 'returns true when the reactor is stopped' do
-        reactor = Reactor.new
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        reactor.stop
-        sleep(0.1)
-        reactor.should_not be_running
-      end
-    end
-
-    context '#add_handler' do
-
-      it 'raises an exception is the event name is reserved' do
-        reactor = Reactor.new
-        lambda {
-          reactor.add_handler(Reactor::RESERVED_EVENTS.first){ nil }
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'raises an exception if no block is given' do
-        reactor = Reactor.new
-        lambda {
-          reactor.add_handler('no block given')
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'returns true if the handler is added' do
-        reactor = Reactor.new
-        reactor.add_handler('good'){ nil }.should be_true
-      end
-    end
-
-    context '#remove_handler' do
-
-      it 'returns true if the handler is found and removed' do
-        reactor = Reactor.new
-        reactor.add_handler('good'){ nil }
-        reactor.remove_handler('good').should be_true
-      end
-
-      it 'returns false if the handler is not found' do
-        reactor = Reactor.new
-        reactor.remove_handler('not found').should be_false
-      end
-    end
-
-    context '#stop_on_signal' do
-
-      it 'traps each valid signal' do
-        Signal.should_receive(:trap).with('USR1')
-        Signal.should_receive(:trap).with('USR2')
-        reactor = Reactor.new
-        reactor.stop_on_signal('USR1', 'USR2')
-      end
-
-      it 'raises an exception if given an invalid signal' do
-        if mri?
-          reactor = Reactor.new
-          lambda {
-            reactor.stop_on_signal('BOGUS')
-          }.should raise_error(ArgumentError)
-        end
-      end
-
-      it 'stops the reactor when it receives a trapped signal' do
-        reactor = Reactor.new
-        reactor.stop_on_signal('USR1')
-        reactor.should_receive(:stop).with(no_args())
-        Process.kill('USR1', Process.pid)
-        sleep(0.1)
-      end
-    end
-
-    context '#handle' do
-
-      it 'raises an exception if the demux is synchronous' do
-        reactor = Reactor.new(sync_demux)
-        lambda {
-          reactor.handle('event')
-        }.should raise_error(NotImplementedError)
-      end
-
-      it 'returns :stopped if the reactor is not running' do
-        reactor = Reactor.new
-        reactor.handle('event').first.should eq :stopped
-      end
-
-      it 'returns :ok and the block result on success' do
-        reactor = Reactor.new
-        reactor.add_handler(:event){ 10 }
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        result = reactor.handle(:event)
-        result.first.should eq :ok
-        result.last.should eq 10
-        reactor.stop
-      end
-
-      it 'returns :ex and the exception on failure' do
-        reactor = Reactor.new
-        reactor.add_handler(:event){ raise StandardError }
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        result = reactor.handle(:event)
-        result.first.should eq :ex
-        result.last.should be_a(StandardError)
-        reactor.stop
-      end
-
-      it 'returns :noop when there is no handler' do
-        reactor = Reactor.new
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        result = reactor.handle(:event)
-        result.first.should eq :noop
-        reactor.stop
-      end
-
-      it 'triggers handlers added after the reactor is started' do
-        @expected = false
-        reactor = Reactor.new
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        reactor.add_handler(:event){ @expected = true }
-        reactor.handle(:event)
-        @expected.should be_true
-        reactor.stop
-      end
-
-      it 'does not trigger an event that was removed' do
-        @expected = false
-        reactor = Reactor.new
-        reactor.add_handler(:event){ @expected = true }
-        reactor.remove_handler(:event)
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        reactor.handle(:event)
-        @expected.should be_false
-        reactor.stop
-      end
-    end
-
-    context '#start' do
-
-      it 'raises an exception if the reactor is already running' do
-        reactor = Reactor.new
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        lambda {
-          reactor.start
-        }.should raise_error(StandardError)
-        reactor.stop
-      end
-
-      it 'starts the reactor if it is not running' do
-        reactor = Reactor.new(async_demux)
-        reactor.should_receive(:run_async).with(no_args())
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        reactor.should be_running
-        reactor.stop
-
-        reactor = Reactor.new(sync_demux)
-        reactor.should_receive(:run_sync).with(no_args())
-        Thread.new{ reactor.start }
-        sleep(0.1)
-        reactor.should be_running
-        reactor.stop
-      end
-    end
-
-    context '#stop' do
-
-      it 'returns if the reactor is not running' do
-        reactor = Reactor.new
-        reactor.stop.should be_true
-      end
-
-      it 'stops the reactor when running and synchronous' do
-        reactor = Reactor.new(sync_demux)
-        Thread.new{ sleep(0.1); reactor.stop }
-        Thread.pass
-        reactor.start
-      end
-
-      it 'stops the reactor when running and asynchronous' do
-        reactor = Reactor.new(async_demux)
-        Thread.new{ sleep(0.1); reactor.stop }
-        Thread.pass
-        reactor.start
-      end
-
-      it 'stops the reactor when running without a demux' do
-        reactor = Reactor.new
-        Thread.new{ sleep(0.1); reactor.stop }
-        Thread.pass
-        reactor.start
-      end
-    end
-
-    specify 'synchronous demultiplexing' do
-
-      demux = sync_demux
-      reactor = Concurrent::Reactor.new(demux)
-
-      reactor.should_not be_running
-
-      reactor.add_handler(:foo){ 'Foo' }
-      reactor.add_handler(:bar){ 'Bar' }
-      reactor.add_handler(:baz){ 'Baz' }
-      reactor.add_handler(:fubar){ raise StandardError.new('Boom!') }
-
-      reactor.stop_on_signal('USR1')
-
-      demux.should_receive(:respond).with(:ok, 'Foo')
-      demux.send(:foo)
-
-      t = Thread.new do
-        reactor.start
-      end
-      t.abort_on_exception = true
-      sleep(0.1)
-
-      reactor.should be_running
-
-      demux.should_receive(:respond).with(:ok, 'Bar')
-      demux.should_receive(:respond).with(:ok, 'Baz')
-      demux.should_receive(:respond).with(:noop, anything())
-      demux.should_receive(:respond).with(:ex, anything())
-
-      demux.send(:bar)
-      demux.send(:baz)
-      demux.send(:bogus)
-      demux.send(:fubar)
-
-      reactor.should be_running
-
-      Process.kill('USR1', Process.pid)
-      sleep(0.1)
-
-      demux.should_not_receive(:respond).with(:foo, anything())
-      demux.send(:foo)
-      reactor.should_not be_running
-    end
-
-    specify 'asynchronous demultiplexing' do
-
-      demux = async_demux
-      reactor = Concurrent::Reactor.new(demux)
-
-      reactor.should_not be_running
-
-      reactor.add_handler(:foo){ 'Foo' }
-      reactor.add_handler(:bar){ 'Bar' }
-      reactor.add_handler(:baz){ 'Baz' }
-      reactor.add_handler(:fubar){ raise StandardError.new('Boom!') }
-
-      reactor.stop_on_signal('USR2')
-
-      demux.send(:foo).first.should eq :stopped
-
-      t = Thread.new do
-        reactor.start
-      end
-      t.abort_on_exception = true
-      sleep(0.1)
-
-      reactor.should be_running
-
-      demux.send(:foo).should eq [:ok, 'Foo']
-      demux.send(:bar).should eq [:ok, 'Bar']
-      demux.send(:baz).should eq [:ok, 'Baz']
-      demux.send(:bogus).first.should eq :noop
-      demux.send(:fubar).first.should eq :ex
-
-      reactor.should be_running
-
-      Process.kill('USR2', Process.pid)
-      sleep(0.1)
-
-      demux.send(:foo).first.should eq :stopped
-      reactor.should_not be_running
-    end
-  end
-end