concurrent-ruby 0.6.0 → 0.7.0.rc0

data/spec/concurrent/timer_task_spec.rb

@@ -1,258 +0,0 @@
-require 'spec_helper'
-require_relative 'dereferenceable_shared'
-require_relative 'observable_shared'
-
-module Concurrent
-
-  describe TimerTask do
-    with_full_reset
-
-    before(:each) do
-      # suppress deprecation warnings.
-      Concurrent::TimerTask.any_instance.stub(:warn)
-      Concurrent::TimerTask.stub(:warn)
-    end
-
-    context :dereferenceable do
-
-      after(:each) do
-        begin
-          @subject.kill if @subject
-        rescue Exception => ex
-          # prevent exceptions with mocks in tests
-        end
-      end
-
-      def dereferenceable_subject(value, opts = {})
-        opts     = opts.merge(execution_interval: 0.1, run_now: true)
-        @subject = TimerTask.new(opts) { value }.execute.tap { sleep(0.1) }
-      end
-
-      def dereferenceable_observable(opts = {})
-        opts     = opts.merge(execution_interval: 0.1, run_now: true)
-        @subject = TimerTask.new(opts) { 'value' }
-      end
-
-      def execute_dereferenceable(subject)
-        subject.execute
-        sleep(0.1)
-      end
-
-      it_should_behave_like :dereferenceable
-    end
-
-    context :observable do
-
-      subject { TimerTask.new(execution_interval: 0.1) { nil } }
-
-      after(:each) { subject.kill }
-
-      def trigger_observable(observable)
-        observable.execute
-        sleep(0.2)
-      end
-
-      it_should_behave_like :observable
-    end
-
-    context 'created with #new' do
-
-      context '#initialize' do
-
-        it 'raises an exception if no block given' do
-          lambda {
-            Concurrent::TimerTask.new
-          }.should raise_error(ArgumentError)
-        end
-
-        it 'raises an exception if :execution_interval is not greater than zero' do
-          lambda {
-            Concurrent::TimerTask.new(execution_interval: 0) { nil }
-          }.should raise_error(ArgumentError)
-        end
-
-        it 'raises an exception if :execution_interval is not an integer' do
-          lambda {
-            Concurrent::TimerTask.new(execution_interval: 'one') { nil }
-          }.should raise_error(ArgumentError)
-        end
-
-        it 'raises an exception if :timeout_interval is not greater than zero' do
-          lambda {
-            Concurrent::TimerTask.new(timeout_interval: 0) { nil }
-          }.should raise_error(ArgumentError)
-        end
-
-        it 'raises an exception if :timeout_interval is not an integer' do
-          lambda {
-            Concurrent::TimerTask.new(timeout_interval: 'one') { nil }
-          }.should raise_error(ArgumentError)
-        end
-
-        it 'uses the default execution interval when no interval is given' do
-          subject = TimerTask.new { nil }
-          subject.execution_interval.should eq TimerTask::EXECUTION_INTERVAL
-        end
-
-        it 'uses the default timeout interval when no interval is given' do
-          subject = TimerTask.new { nil }
-          subject.timeout_interval.should eq TimerTask::TIMEOUT_INTERVAL
-        end
-
-        it 'uses the given execution interval' do
-          subject = TimerTask.new(execution_interval: 5) { nil }
-          subject.execution_interval.should eq 5
-        end
-
-        it 'uses the given timeout interval' do
-          subject = TimerTask.new(timeout_interval: 5) { nil }
-          subject.timeout_interval.should eq 5
-        end
-      end
-
-      context '#kill' do
-
-        it 'returns true on success' do
-          task = TimerTask.execute(run_now: false) { nil }
-          sleep(0.1)
-          task.kill.should be_true
-        end
-      end
-    end
-
-    context 'arguments' do
-
-      it 'raises an exception if no block given' do
-        lambda {
-          Concurrent::TimerTask.execute
-        }.should raise_error
-      end
-
-      specify '#execution_interval is writeable' do
-
-        latch   = CountDownLatch.new(1)
-        subject = TimerTask.new(execution_interval: 1) do |task|
-          task.execution_interval = 3
-          latch.count_down
-        end
-
-        subject.execution_interval.should == 1
-        subject.execution_interval = 0.1
-        subject.execution_interval.should == 0.1
-
-        subject.execute
-        latch.wait(0.2)
-
-        subject.execution_interval.should == 3
-        subject.kill
-      end
-
-      specify '#execution_interval is writeable' do
-
-        latch   = CountDownLatch.new(1)
-        subject = TimerTask.new(timeout_interval: 1, execution_interval: 0.1) do |task|
-          task.timeout_interval = 3
-          latch.count_down
-        end
-
-        subject.timeout_interval.should == 1
-        subject.timeout_interval = 2
-        subject.timeout_interval.should == 2
-
-        subject.execute
-        latch.wait(0.2)
-
-        subject.timeout_interval.should == 3
-        subject.kill
-      end
-    end
-
-    context 'execution' do
-
-      it 'runs the block immediately when the :run_now option is true' do
-        latch   = CountDownLatch.new(1)
-        subject = TimerTask.execute(execution: 500, now: true) { latch.count_down }
-        latch.wait(1).should be_true
-        subject.kill
-      end
-
-      it 'waits for :execution_interval seconds when the :run_now option is false' do
-        latch   = CountDownLatch.new(1)
-        subject = TimerTask.execute(execution: 0.1, now: false) { latch.count_down }
-        latch.count.should eq 1
-        latch.wait(1).should be_true
-        subject.kill
-      end
-
-      it 'waits for :execution_interval seconds when the :run_now option is not given' do
-        latch   = CountDownLatch.new(1)
-        subject = TimerTask.execute(execution: 0.1, now: false) { latch.count_down }
-        latch.count.should eq 1
-        latch.wait(1).should be_true
-        subject.kill
-      end
-
-      it 'passes a "self" reference to the block as the sole argument' do
-        expected = nil
-        latch    = CountDownLatch.new(1)
-        subject  = TimerTask.new(execution_interval: 1, run_now: true) do |task|
-          expected = task
-          latch.sount_down
-        end
-        subject.execute
-        latch.wait(1)
-        expected.should eq subject
-        subject.kill
-      end
-    end
-
-    context 'observation' do
-
-      let(:observer) do
-        Class.new do
-          attr_reader :time
-          attr_reader :value
-          attr_reader :ex
-          attr_reader :latch
-          define_method(:initialize) { @latch = CountDownLatch.new(1) }
-          define_method(:update) do |time, value, ex|
-            @time  = time
-            @value = value
-            @ex    = ex
-            @latch.count_down
-          end
-        end.new
-      end
-
-      it 'notifies all observers on success' do
-        subject = TimerTask.new(execution: 0.1) { 42 }
-        subject.add_observer(observer)
-        subject.execute
-        observer.latch.wait(1)
-        observer.value.should == 42
-        observer.ex.should be_nil
-        subject.kill
-      end
-
-      it 'notifies all observers on timeout' do
-        subject = TimerTask.new(execution: 0.1, timeout: 0.1) { sleep }
-        subject.add_observer(observer)
-        subject.execute
-        observer.latch.wait(1)
-        observer.value.should be_nil
-        observer.ex.should be_a(Concurrent::TimeoutError)
-        subject.kill
-      end
-
-      it 'notifies all observers on error' do
-        subject = TimerTask.new(execution: 0.1) { raise ArgumentError }
-        subject.add_observer(observer)
-        subject.execute
-        observer.latch.wait(1)
-        observer.value.should be_nil
-        observer.ex.should be_a(ArgumentError)
-        subject.kill
-      end
-    end
-  end
-end

data/spec/concurrent/tvar_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe TVar do
-
-    context '#initialize' do
-
-      it 'accepts an initial value' do
-        t = TVar.new(14)
-        t.value.should eq 14
-      end
-
-    end
-
-    context '#value' do
-
-      it 'gets the value' do
-        t = TVar.new(14)
-        t.value.should eq 14
-      end
-
-    end
-
-    context '#value=' do
-
-      it 'sets the value' do
-        t = TVar.new(14)
-        t.value = 2
-        t.value.should eq 2
-      end
-
-    end
-
-  end
-
-  describe '#atomically' do
-
-    it 'raises an exception when no block given' do
-      expect { Concurrent::atomically }.to raise_error(ArgumentError)
-    end
-
-    it 'retries on abort' do
-      count = 0
-
-      Concurrent::atomically do
-        if count == 0
-          count = 1
-          Concurrent::abort_transaction
-        else
-          count = 2
-        end
-      end
-
-      count.should eq 2
-    end
-
-    it 'commits writes if the transaction succeeds' do
-      t = TVar.new(0)
-
-      Concurrent::atomically do
-        t.value = 1
-      end
-
-      t.value.should eq 1
-    end
-
-    it 'undoes writes if the transaction is aborted' do
-      t = TVar.new(0)
-
-      count = 0
-
-      Concurrent::atomically do
-        if count == 0
-          t.value = 1
-          count = 1
-          Concurrent::abort_transaction
-        end
-      end
-
-      t.value.should eq 0
-    end
-
-    it 'provides atomicity' do
-      t1 = TVar.new(0)
-      t2 = TVar.new(0)
-
-      count = 0
-
-      Concurrent::atomically do
-        if count == 0
-          count = 1
-          t1.value = 1
-          Concurrent::abort_transaction
-          t2.value = 2
-        end
-      end
-
-      t1.value.should eq 0
-      t2.value.should eq 0
-    end
-
-    it 'provides isolation' do
-      t = TVar.new(0)
-
-      Thread.new do
-        Concurrent::atomically do
-          t1.value = 1
-          sleep(1)
-        end
-      end
-
-      sleep(0.5)
-
-      t.value.should eq 0
-    end
-
-    it 'nests' do
-      Concurrent::atomically do
-        Concurrent::atomically do
-          Concurrent::atomically do
-          end
-        end
-      end
-    end
-
-  end
-
-  describe '#abort_transaction' do
-
-    it 'raises an exception outside an #atomically block' do
-      expect { Concurrent::abort_transaction }.to raise_error(Concurrent::Transaction::AbortError)
-    end
-
-  end
-
-end

data/spec/concurrent/utility/processor_count_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe '#processor_count' do
-
-    it 'retuns a positive integer' do
-      Concurrent::processor_count.should be_a Integer
-      Concurrent::processor_count.should >= 1
-    end
-  end
-
-  describe '#physical_processor_count' do
-
-    it 'retuns a positive integer' do
-      Concurrent::physical_processor_count.should be_a Integer
-      Concurrent::physical_processor_count.should >= 1
-    end
-  end
-end

data/spec/concurrent/utility/timeout_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe '#timeout' do
-
-    it 'raises an exception if no block is given' do
-      expect {
-        Concurrent::timeout(1)
-      }.to raise_error
-    end
-
-    it 'returns the value of the block on success' do
-      result = Concurrent::timeout(1) { 42 }
-      result.should eq 42
-    end
-
-    it 'raises an exception if the timeout value is reached' do
-      expect {
-        Concurrent::timeout(1){ sleep }
-      }.to raise_error(Concurrent::TimeoutError)
-    end
-
-    it 'bubbles thread exceptions' do
-      expect {
-        Concurrent::timeout(1){ raise NotImplementedError }
-      }.to raise_error
-    end
-
-    it 'kills the thread on success' do
-      result = Concurrent::timeout(1) { 42 }
-      Thread.should_receive(:kill).with(any_args())
-      Concurrent::timeout(1){ 42 }
-    end
-
-    it 'kills the thread on timeout' do
-      Thread.should_receive(:kill).with(any_args())
-      expect {
-        Concurrent::timeout(1){ sleep }
-      }.to raise_error
-    end
-
-    it 'kills the thread on exception' do
-      Thread.should_receive(:kill).with(any_args())
-      expect {
-        Concurrent::timeout(1){ raise NotImplementedError }
-      }.to raise_error
-    end
-  end
-end

data/spec/concurrent/utility/timer_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe '#timer' do
-
-    it 'raises an exception when no block given' do
-      expect {
-        Concurrent::timer(0.1)
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raises an exception if the interval is less than 0 seconds' do
-      expect {
-        Concurrent::timer(-1){ :foo }
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'executes the block after the given number of seconds' do
-      start = Time.now.to_f
-      latch = CountDownLatch.new(1)
-      Concurrent::timer(0.5){ latch.count_down }
-      latch.count.should eq 1
-      latch.wait(0.1)
-      latch.count.should eq 1
-      latch.wait(1)
-      latch.count.should eq 0
-    end
-
-    it 'suppresses exceptions thrown by the block' do
-      expect {
-        Concurrent::timer(0.5){ raise Exception }
-      }.to_not raise_error
-    end
-
-    it 'passes all arguments to the block' do
-      expected = nil
-      latch = CountDownLatch.new(1)
-      Concurrent::timer(0, 1, 2, 3) do |*args|
-        expected = args
-        latch.count_down
-      end
-      latch.wait(0.2)
-      expected.should eq [1, 2, 3]
-    end
-
-    it 'runs the task on the global timer pool' do
-      Concurrent.configuration.global_timer_set.should_receive(:post).with(0.1)
-      Concurrent::timer(0.1){ :foo }
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-require 'simplecov'
-require 'coveralls'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-]
-
-SimpleCov.start do
-  project_name 'concurrent-ruby'
-  add_filter '/coverage/'
-  add_filter '/doc/'
-  add_filter '/pkg/'
-  add_filter '/spec/'
-  add_filter '/tasks/'
-end
-
-require 'concurrent'
-
-logger                          = Logger.new($stderr)
-logger.level                    = Logger::INFO
-Concurrent.configuration.logger = lambda do |level, progname, message = nil, &block|
-  logger.add level, message, progname, &block
-end
-
-# import all the support files
-Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) }
-
-RSpec.configure do |config|
-  config.order = 'random'
-end

data/spec/support/example_group_extensions.rb

@@ -1,48 +0,0 @@
-require 'rbconfig'
-
-module Concurrent
-  module TestHelpers
-    def delta(v1, v2)
-      if block_given?
-        v1 = yield(v1)
-        v2 = yield(v2)
-      end
-      return (v1 - v2).abs
-    end
-
-    def mri?
-      RbConfig::CONFIG['ruby_install_name']=~ /^ruby$/i
-    end
-
-    def jruby?
-      RbConfig::CONFIG['ruby_install_name']=~ /^jruby$/i
-    end
-
-    def rbx?
-      RbConfig::CONFIG['ruby_install_name']=~ /^rbx$/i
-    end
-
-    def reset_gem_configuration
-      Concurrent.instance_variable_set(:@configuration, Concurrent::Configuration.new)
-    end
-
-    extend self
-  end
-end
-
-class RSpec::Core::ExampleGroup
-  def self.with_full_reset
-    before(:each) do
-      reset_gem_configuration
-    end
-
-    after(:each) do
-      Thread.list.each do |thread|
-        thread.kill unless thread == Thread.current
-      end
-    end
-  end
-
-  include Concurrent::TestHelpers
-  extend Concurrent::TestHelpers
-end

data/spec/support/less_than_or_equal_to_matcher.rb

@@ -1,5 +0,0 @@
-RSpec::Matchers.define :be_less_than_or_equal_to do |expected|
-  match do |actual|
-    actual <= expected
-  end
-end