empathy 0.0.1.RC0

data/rubyspec/library/queue/shift_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'thread'
+require File.expand_path('../shared/deque', __FILE__)
+
+describe "Queue#shift" do
+  it_behaves_like :queue_deq, :shift
+end

data/rubyspec/library/queue/size_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'thread'
+require File.expand_path('../shared/length', __FILE__)
+
+describe "Queue#size" do
+  it_behaves_like :queue_length, :size
+end

data/rubyspec/shared/kernel/raise.rb

@@ -0,0 +1,68 @@
+describe :kernel_raise, :shared => true do
+  before :each do
+    ScratchPad.clear
+  end
+
+  it "aborts execution" do
+    lambda do
+      @object.raise Exception, "abort"
+      ScratchPad.record :no_abort
+    end.should raise_error(Exception, "abort")
+
+    ScratchPad.recorded.should be_nil
+  end
+
+  it "raises RuntimeError if no exception class is given" do
+    lambda { @object.raise }.should raise_error(RuntimeError)
+  end
+
+  it "raises a given Exception instance" do
+    error = RuntimeError.new
+    lambda { @object.raise(error) }.should raise_error(error)
+  end
+
+  it "raises a RuntimeError if string given" do
+    lambda { @object.raise("a bad thing") }.should raise_error(RuntimeError)
+  end
+
+  it "raises a TypeError when passed a non-Exception object" do
+    lambda { @object.raise(Object.new) }.should raise_error(TypeError)
+  end
+
+  it "raises a TypeError when passed true" do
+    lambda { @object.raise(true) }.should raise_error(TypeError)
+  end
+
+  it "raises a TypeError when passed false" do
+    lambda { @object.raise(false) }.should raise_error(TypeError)
+  end
+
+  it "raises a TypeError when passed nil" do
+    lambda { @object.raise(nil) }.should raise_error(TypeError)
+  end
+
+  it "re-raises the rescued exception" do
+    lambda do
+      begin
+        raise Exception, "outer"
+        ScratchPad.record :no_abort
+      rescue
+        begin
+          raise StandardError, "inner"
+        rescue
+        end
+
+        @object.raise
+        ScratchPad.record :no_reraise
+      end
+    end.should raise_error(Exception, "outer")
+
+    ScratchPad.recorded.should be_nil
+  end
+
+  it "allows Exception, message, and backtrace parameters" do
+    lambda do
+      @object.raise(ArgumentError, "message", caller)
+    end.should raise_error(ArgumentError, "message")
+  end
+end

data/rubyspec/shared/mutex/lock.rb

@@ -0,0 +1,52 @@
+describe :mutex_lock, :shared => true do
+  before :each do
+    ScratchPad.clear
+  end
+
+  it "returns self" do
+    m = Mutex.new
+    m.lock.should == m
+    m.unlock
+  end
+
+  it "waits if the lock is not available" do
+    m = Mutex.new
+
+    m.lock
+
+    th = Thread.new do
+      m.lock
+      ScratchPad.record :after_lock
+    end
+
+    Thread.pass while th.status and th.status != "sleep"
+
+    ScratchPad.recorded.should be_nil
+    m.unlock
+    th.join
+    ScratchPad.recorded.should == :after_lock
+  end
+
+  # Unable to find a specific ticket but behavior change may be
+  # related to this ML thread.
+  ruby_bug "[ruby-core:23457]", "1.8.7.174" do
+    it "raises a ThreadError when used recursively" do
+      m = Mutex.new
+
+      th = Thread.new do
+        m.lock
+        m.lock
+        v = 1
+      end
+
+      Thread.pass while th.status and th.status != "sleep"
+
+      ScratchPad.recorded.should be_nil
+
+      lambda do
+        th.kill
+        th.join
+      end.should raise_error(ThreadError)
+    end
+  end
+end

data/rubyspec/shared/mutex/locked.rb

@@ -0,0 +1,31 @@
+describe :mutex_locked, :shared => true do
+  it "returns true if locked" do
+    m = Mutex.new
+    m.lock
+    m.locked?.should be_true
+  end
+
+  it "returns false if unlocked" do
+    m = Mutex.new
+    m.locked?.should be_false
+  end
+
+  it "returns the status of the lock" do
+    m1 = Mutex.new
+    m2 = Mutex.new
+
+    m2.lock # hold th with only m1 locked
+
+    th = Thread.new do
+      m1.lock
+      m2.lock
+    end
+
+    Thread.pass while th.status and th.status != "sleep"
+
+    m1.locked?.should be_true
+    m2.unlock # release th
+    th.join
+    m1.locked?.should be_false
+  end
+end

data/rubyspec/shared/mutex/synchronize.rb

@@ -0,0 +1,23 @@
+describe :mutex_synchronize, :shared => true do
+  it "wraps the lock/unlock pair in an ensure" do
+    m1 = Mutex.new
+    m2 = Mutex.new
+    m2.lock
+
+    th = Thread.new do
+      lambda do
+        m1.synchronize do
+          m2.lock
+          raise Exception
+        end
+      end.should raise_error(Exception)
+    end
+
+    Thread.pass while th.status and th.status != "sleep"
+
+    m1.locked?.should be_true
+    m2.unlock
+    th.join
+    m1.locked?.should be_false
+  end
+end

data/rubyspec/shared/mutex/try_lock.rb

@@ -0,0 +1,30 @@
+describe :mutex_try_lock, :shared => true do
+  describe "when unlocked" do
+    it "returns true" do
+      m = Mutex.new
+      m.try_lock.should be_true
+    end
+
+    it "locks the mutex" do
+      m = Mutex.new
+      m.try_lock
+      m.locked?.should be_true
+    end
+  end
+
+  describe "when locked by the current thread" do
+    it "returns false" do
+      m = Mutex.new
+      m.lock
+      m.try_lock.should be_false
+    end
+  end
+
+  describe "when locked by another thread" do
+    it "returns false" do
+      m = Mutex.new
+      m.lock
+      Thread.new { m.try_lock }.value.should be_false
+    end
+  end
+end

data/rubyspec/shared/mutex/unlock.rb

@@ -0,0 +1,35 @@
+describe :mutex_unlock, :shared => true do
+  it "raises ThreadError unless Mutex is locked" do
+    mutex = Mutex.new
+    lambda { mutex.unlock }.should raise_error(ThreadError)
+  end
+
+  it "raises ThreadError unless thread owns Mutex" do
+    mutex = Mutex.new
+    wait = Mutex.new
+    wait.lock
+    th = Thread.new do
+      mutex.lock
+      wait.lock
+    end
+
+    # avoid race on mutex.lock
+    Thread.pass while th.status and th.status != "sleep"
+
+    lambda { mutex.unlock }.should raise_error(ThreadError)
+
+    wait.unlock
+    th.join
+  end
+
+  it "raises ThreadError if previously locking thread is gone" do
+    mutex = Mutex.new
+    th = Thread.new do
+      mutex.lock
+    end
+
+    th.join
+
+    lambda { mutex.unlock }.should raise_error(ThreadError)
+  end
+end

data/rubyspec/spec_helper.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+unless ENV['MSPEC_RUNNER']
+  begin
+    require "pp"
+    require 'mspec/version'
+    require 'mspec/helpers'
+    require 'mspec/guards'
+    require 'mspec/runner/shared'
+    require 'mspec/matchers/be_ancestor_of'
+    require 'mspec/matchers/output'
+    require 'mspec/matchers/output_to_fd'
+    require 'mspec/matchers/complain'
+    require 'mspec/matchers/equal_element'
+    require 'mspec/matchers/equal_utf16'
+    require 'mspec/matchers/match_yaml'
+
+    # Code to setup HOME directory correctly on Windows
+    # This duplicates Ruby 1.9 semantics for defining HOME
+    platform_is :windows do
+      if ENV['HOME']
+        ENV['HOME'] = ENV['HOME'].tr '\\', '/'
+      elsif ENV['HOMEDIR'] && ENV['HOMEDRIVE']
+        ENV['HOME'] = File.join(ENV['HOMEDRIVE'], ENV['HOMEDIR'])
+      elsif ENV['HOMEDIR']
+        ENV['HOME'] = ENV['HOMEDIR']
+      elsif ENV['HOMEDRIVE']
+        ENV['HOME'] = ENV['HOMEDRIVE']
+      elsif ENV['USERPROFILE']
+        ENV['HOME'] = ENV['USERPROFILE']
+      else
+        puts "No suitable HOME environment found. This means that all of"
+        puts "HOME, HOMEDIR, HOMEDRIVE, and USERPROFILE are not set"
+        exit 1
+      end
+    end
+  rescue LoadError
+    puts "Please install the MSpec gem to run the specs."
+    exit 1
+  end
+end
+
+minimum_version = "1.5.18"
+unless MSpec::VERSION >= minimum_version
+  puts "Please install MSpec version >= #{minimum_version} to run the specs"
+  exit 1
+end
+
+$VERBOSE = nil unless ENV['OUTPUT_WARNINGS']

data/spec/empathy_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+# Test class delegation
+class EmTest
+  def self.test_class_method(an_arg=:test_class_method,&block)
+    return block.call if block_given?
+    an_arg
+  end
+
+  def whoami
+    :test
+  end
+end
+
+module Empathy
+  module EM
+    class EmTest
+      def self.test_class_method(an_arg=:em_test_class_method,&block)
+        return block.call if block_given?
+        an_arg
+      end
+
+      def whoami
+        :em_test
+      end
+    end
+  end
+
+  create_delegate_module('EmTest',:new, :test_class_method)
+end
+
+describe Empathy do
+
+  describe "#run" do
+    it "raise errors when block raises error" do
+      lambda do
+        Empathy.run { raise RuntimeError }
+      end.should raise_error(RuntimeError)
+      EventMachine.reactor_running?.should be_false
+    end
+  end
+
+  shared_examples_for "empathy_delegation" do
+    it "delegates Thread" do
+      t =  Empathy::Thread.new() { }
+      t.should be_kind_of(thread_class)
+      Empathy::Thread.list.should == thread_class.list
+      Empathy::Thread.current.should == thread_class.current
+      Empathy::Thread.main.should == thread_class.main
+      Empathy::Thread.singleton_methods.should include(:stop,:pass)
+    end
+
+    it "delegates Queue" do
+      q = Empathy::Queue.new()
+      q.should be_kind_of(queue_class)
+    end
+
+    it "delegates ConditionVariable" do
+      q = Empathy::ConditionVariable.new()
+      q.should be_kind_of(condition_variable_class)
+    end
+
+    it "delegates Mutex" do
+      q = Empathy::Mutex.new()
+      q.should be_kind_of(mutex_class)
+    end
+
+    it "delegates Kernel.sleep" do
+      Empathy::Kernel.singleton_methods.should include(:sleep)
+    end
+
+    it "rescues errors" do
+      lambda do
+        begin
+          raise error_class
+        rescue Empathy::ThreadError
+          # do nothing
+        end
+      end.should_not raise_error
+    end
+  end
+
+  context "in eventmachine" do
+    around(:each) do |example|
+      Empathy.run { example.run }
+    end
+
+    let (:thread_class) { Empathy::EM::Thread }
+    let (:queue_class) { Empathy::EM::Queue }
+    let (:condition_variable_class) { Empathy::EM::ConditionVariable }
+    let (:mutex_class) { Empathy::EM::Mutex }
+    let (:error_class) { ::FiberError }
+
+    it "delegates to Empathy::EM classes" do
+      Empathy.run do
+        Empathy.event_machine?.should be_true
+        t = Empathy::EmTest.new
+        t.should be_kind_of(Empathy::EM::EmTest)
+        t.whoami.should == :em_test
+        Empathy::EmTest.test_class_method.should == :em_test_class_method
+        Empathy::EmTest.test_class_method(:em_hello).should == :em_hello
+        Empathy::EmTest.test_class_method() { :em_with_block }.should == :em_with_block
+      end
+    end
+
+    include_examples "empathy_delegation"
+  end
+
+  context "outside eventmachine" do
+    let (:thread_class) { ::Thread }
+    let (:queue_class) { ::Queue }
+    let (:condition_variable_class) { ::ConditionVariable }
+    let (:mutex_class) { ::Mutex }
+    let (:error_class) { ::ThreadError }
+
+    it "delegate to ruby top level classes" do
+      EventMachine.reactor_running?.should be_false
+      Empathy.event_machine?.should be_false
+      t = Empathy::EmTest.new
+      t.should be_kind_of(EmTest)
+      t.whoami.should == :test
+      Empathy::EmTest.test_class_method.should == :test_class_method
+      Empathy::EmTest.test_class_method(:hello).should == :hello
+      Empathy::EmTest.test_class_method() { :with_block }.should == :with_block
+    end
+
+    include_examples "empathy_delegation"
+  end
+end

data/spec/library_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+module TestReactorLibrary
+  def self.test_thread_error
+    raise ::FiberError, "oops"
+  rescue ThreadError
+    :rescued
+  end
+end
+
+Empathy::EM.empathise(TestReactorLibrary)
+
+module TestLibrary
+  def self.test_thread_error
+    begin
+      raise ::FiberError, "fiber error"
+    rescue ThreadError
+    end
+
+    begin
+      raise ::ThreadError, "thread error"
+    rescue ThreadError
+    end
+    :ok
+  end
+end
+
+Empathy.empathise(TestLibrary)
+
+shared_examples_for "Empathy.empathise" do
+  it "rescues thread and fiber exceptions" do
+    TestLibrary.test_thread_error.should == :ok
+  end
+end
+
+describe "Empathy.empathise" do
+
+  it "defines constants in Library namespace" do
+    TestLibrary::Thread.should == Empathy::Thread
+    TestLibrary::Queue.should == Empathy::Queue
+    TestLibrary::ConditionVariable.should == Empathy::ConditionVariable
+    TestLibrary::Mutex.should == Empathy::Mutex
+    TestLibrary::ThreadError.should == Empathy::ThreadError
+  end
+
+  context "in reactor" do
+    around :each do |example|
+      Empathy.run { example.run }
+    end
+
+    include_examples "Empathy.empathise"
+  end
+
+  context "outside reactor" do
+    include_examples "Empathy.empathise"
+  end
+
+end
+
+describe "Empathy::EM.empathise" do
+
+  it "defines constants in Library namespace" do
+    TestReactorLibrary::Thread.should == Empathy::EM::Thread
+    TestReactorLibrary::Queue.should == Empathy::EM::Queue
+    TestReactorLibrary::ConditionVariable.should == Empathy::EM::ConditionVariable
+    TestReactorLibrary::Mutex.should == Empathy::EM::Mutex
+    TestReactorLibrary::ThreadError.should == FiberError
+  end
+
+  context "in reactor" do
+    around :each do |example|
+      Empathy.run { example.run }
+    end
+
+    it "rescues fiber errors" do
+      TestReactorLibrary.test_thread_error.should == :rescued
+    end
+  end
+end