empathy 0.0.1.RC0

data/rubyspec/core/thread/join_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Thread#join" do
+  it "returns the thread when it is finished" do
+    t = Thread.new {}
+    t.join.should equal(t)
+  end
+
+  it "returns the thread when it is finished when given a timeout" do
+    t = Thread.new {}
+    t.join
+    t.join(0).should equal(t)
+  end
+
+  it "returns nil if it is not finished when given a timeout" do
+    c = Channel.new
+    t = Thread.new { c.receive }
+    begin
+      t.join(0).should == nil
+    ensure
+      c << true
+    end
+    t.join.should == t
+  end
+
+  it "accepts a floating point timeout length" do
+    c = Channel.new
+    t = Thread.new { c.receive }
+    begin
+      t.join(0.01).should == nil
+    ensure
+      c << true
+    end
+    t.join.should == t
+  end
+
+  it "raises any exceptions encountered in the thread body" do
+    t = Thread.new { raise NotImplementedError.new("Just kidding") }
+    lambda { t.join }.should raise_error(NotImplementedError)
+  end
+
+  it "returns the dead thread" do
+    t = Thread.new { Thread.current.kill }
+    t.join.should equal(t)
+  end
+
+  ruby_version_is "" ... "1.9" do
+    not_compliant_on :rubinius do
+      it "returns the dead thread even if an uncaught exception is thrown from ensure block" do
+        t = ThreadSpecs.dying_thread_ensures { raise "In dying thread" }
+        t.join.should equal(t)
+      end
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises any uncaught exception encountered in ensure block" do
+      t = ThreadSpecs.dying_thread_ensures { raise NotImplementedError.new("Just kidding") }
+      lambda { t.join }.should raise_error(NotImplementedError)
+    end
+  end
+end

data/rubyspec/core/thread/key_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Thread#key?" do
+  before :each do
+    @th = Thread.new do
+      Thread.current[:oliver] = "a"
+    end
+    @th.join
+  end
+
+  it "tests for existance of thread local variables using symbols or strings" do
+    @th.key?(:oliver).should == true
+    @th.key?("oliver").should == true
+    @th.key?(:stanley).should == false
+    @th.key?(:stanley.to_s).should == false
+  end
+
+  quarantine! do
+    ruby_version_is ""..."1.9" do
+      it "raises exceptions on the wrong type of keys" do
+        lambda { Thread.current.key? nil }.should raise_error(TypeError)
+        lambda { Thread.current.key? 5 }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises exceptions on the wrong type of keys" do
+      lambda { Thread.current.key? nil }.should raise_error(TypeError)
+      lambda { Thread.current.key? 5 }.should raise_error(TypeError)
+    end
+
+    it "is not shared across fibers" do
+      fib = Fiber.new do
+        Thread.current[:val1] = 1
+        Fiber.yield
+        Thread.current.key?(:val1).should be_true
+        Thread.current.key?(:val2).should be_false
+      end
+      Thread.current.key?(:val1).should_not be_true
+      fib.resume
+      Thread.current[:val2] = 2
+      fib.resume
+      Thread.current.key?(:val1).should be_false
+      Thread.current.key?(:val2).should be_true
+    end
+
+    it "stores a local in another thread when in a fiber" do
+      fib = Fiber.new do
+        t = Thread.new do
+          sleep
+          Thread.current.key?(:value).should be_true
+        end
+
+        Thread.pass while t.status and t.status != "sleep"
+        t[:value] = 1
+        t.wakeup
+        t.join
+      end
+      fib.resume
+    end
+  end
+end

data/rubyspec/core/thread/keys_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Thread#keys" do
+  it "returns an array of the names of the thread-local variables as symbols" do
+    th = Thread.new do
+      Thread.current["cat"] = 'woof'
+      Thread.current[:cat] = 'meow'
+      Thread.current[:dog] = 'woof'
+    end
+    th.join
+    th.keys.sort_by {|x| x.to_s}.should == [:cat,:dog]
+  end
+
+  ruby_version_is "1.9" do
+    it "is not shared across fibers" do
+      fib = Fiber.new do
+        Thread.current[:val1] = 1
+        Fiber.yield
+        Thread.current.keys.should include(:val1)
+        Thread.current.keys.should_not include(:val2)
+      end
+      Thread.current.keys.should_not include(:val1)
+      fib.resume
+      Thread.current[:val2] = 2
+      fib.resume
+      Thread.current.keys.should include(:val2)
+      Thread.current.keys.should_not include(:val1)
+    end
+
+    it "stores a local in another thread when in a fiber" do
+      fib = Fiber.new do
+        t = Thread.new do
+          sleep
+          Thread.current.keys.should include(:value)
+        end
+
+        Thread.pass while t.status and t.status != "sleep"
+        t[:value] = 1
+        t.wakeup
+        t.join
+      end
+      fib.resume
+    end
+  end
+
+end

data/rubyspec/core/thread/kill_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/exit', __FILE__)
+
+describe "Thread#kill" do
+  it_behaves_like :thread_exit, :kill
+end
+
+describe "Thread#kill!" do
+  it "needs to be reviewed for spec completeness"
+end
+
+describe "Thread.kill" do
+  it "causes the given thread to exit" do
+    thread = Thread.new { sleep }
+    Thread.pass while thread.status and thread.status != "sleep"
+    Thread.kill(thread)
+    thread.join
+    thread.status.should be_false
+  end
+end

data/rubyspec/core/thread/list_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Thread::list" do
+  it "includes the current and main thread" do
+    Thread.list.should include(Thread.current)
+    Thread.list.should include(Thread.main)
+  end
+
+  it "includes threads of non-default thread groups" do
+    t = Thread.new { sleep }
+    ThreadGroup.new.add(t)
+    Thread.list.should include(t)
+    t.kill
+  end
+
+  it "does not include deceased threads" do
+    t = Thread.new { 1; }
+    t.join
+    Thread.list.should_not include(t)
+  end
+
+  it "includes waiting threads" do
+    c = Channel.new
+    t = Thread.new { c.receive }
+    begin
+      Thread.pass while t.status and t.status != 'sleep'
+      Thread.list.should include(t)
+    ensure
+      c << nil
+      t.join
+    end
+  end
+end
+
+describe "Thread.list" do
+  it "needs to be reviewed for spec completeness"
+end

data/rubyspec/core/thread/main_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Thread.main" do
+  it "returns the main thread" do
+    Thread.new { @main = Thread.main ; @current = Thread.current}.join
+    @main.should_not == @current
+    @main.should == Thread.current
+  end
+end

data/rubyspec/core/thread/new_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Thread.new" do
+  it "creates a thread executing the given block" do
+    c = Channel.new
+    Thread.new { c << true }.join
+    c << false
+    c.receive.should == true
+  end
+
+  it "can pass arguments to the thread block" do
+    arr = []
+    a, b, c = 1, 2, 3
+    t = Thread.new(a,b,c) {|d,e,f| arr << d << e << f }
+    t.join
+    arr.should == [a,b,c]
+  end
+
+  it "raises an exception when not given a block" do
+    lambda { Thread.new }.should raise_error(ThreadError)
+  end
+
+  it "creates a subclass of thread calls super with a block in initialize" do
+    arr = []
+    t = ThreadSpecs::SubThread.new(arr)
+    t.join
+    arr.should == [1]
+  end
+
+  it "calls #initialize and raises an error if super not used" do
+    c = Class.new(Thread) do
+      def initialize
+      end
+    end
+
+    lambda {
+      c.new
+    }.should raise_error(ThreadError)
+  end
+
+  it "calls and respects #initialize for the block to use" do
+    c = Class.new(Thread) do
+      def initialize
+        ScratchPad.record [:good]
+        super { ScratchPad << :in_thread }
+      end
+    end
+
+    t = c.new
+    t.join
+
+    ScratchPad.recorded.should == [:good, :in_thread]
+  end
+
+end

data/rubyspec/core/thread/pass_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Thread.pass" do
+  it "returns nil" do
+    Thread.pass.should == nil
+  end
+end

data/rubyspec/core/thread/priority_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+describe "Thread#priority" do
+  it "needs to be reviewed for spec completeness"
+end
+
+describe "Thread#priority=" do
+  it "needs to be reviewed for spec completeness"
+end

data/rubyspec/core/thread/raise_spec.rb

@@ -0,0 +1,225 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../../../shared/kernel/raise', __FILE__)
+
+describe "Thread#raise" do
+  it "ignores dead threads" do
+    t = Thread.new { :dead }
+    Thread.pass while t.alive?
+    lambda {t.raise("Kill the thread")}.should_not raise_error
+    lambda {t.value}.should_not raise_error
+  end
+end
+
+describe "Thread#raise on a sleeping thread" do
+  before :each do
+    ScratchPad.clear
+    @thr = ThreadSpecs.sleeping_thread
+    Thread.pass while @thr.status and @thr.status != "sleep"
+  end
+
+  after :each do
+    @thr.kill
+  end
+
+  it "raises a RuntimeError if no exception class is given" do
+    @thr.raise
+    Thread.pass while @thr.status
+    ScratchPad.recorded.should be_kind_of(RuntimeError)
+  end
+
+  it "raises the given exception" do
+    @thr.raise Exception
+    Thread.pass while @thr.status
+    ScratchPad.recorded.should be_kind_of(Exception)
+  end
+
+  it "raises the given exception with the given message" do
+    @thr.raise Exception, "get to work"
+    Thread.pass while @thr.status
+    ScratchPad.recorded.should be_kind_of(Exception)
+    ScratchPad.recorded.message.should == "get to work"
+  end
+
+  it "is captured and raised by Thread#value" do
+    t = Thread.new do
+      sleep
+    end
+
+    ThreadSpecs.spin_until_sleeping(t)
+
+    t.raise
+    lambda { t.value }.should raise_error(RuntimeError)
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a ZeroDivisionError when called with no arguments inside rescue" do
+      t = Thread.new do
+        begin
+          1/0
+        rescue ZeroDivisionError
+          sleep
+        end
+      end
+      begin
+        raise RangeError
+      rescue
+        ThreadSpecs.spin_until_sleeping(t)
+        t.raise
+      end
+      lambda {t.value}.should raise_error(ZeroDivisionError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError when called with no arguments inside rescue" do
+      t = Thread.new do
+        begin
+          1/0
+        rescue ZeroDivisionError
+          sleep
+        end
+      end
+      begin
+        raise RangeError
+      rescue
+        ThreadSpecs.spin_until_sleeping(t)
+        t.raise
+      end
+      lambda {t.value}.should raise_error(RuntimeError)
+    end
+  end
+end
+
+describe "Thread#raise on a running thread" do
+  before :each do
+    ScratchPad.clear
+    ThreadSpecs.clear_state
+
+    @thr = ThreadSpecs.running_thread
+    Thread.pass until ThreadSpecs.state == :running
+  end
+
+  after :each do
+    @thr.kill
+  end
+
+  it "raises a RuntimeError if no exception class is given" do
+    @thr.raise
+    Thread.pass while @thr.status
+    ScratchPad.recorded.should be_kind_of(RuntimeError)
+  end
+
+  it "raises the given exception" do
+    @thr.raise Exception
+    Thread.pass while @thr.status
+    ScratchPad.recorded.should be_kind_of(Exception)
+  end
+
+  it "raises the given exception with the given message" do
+    @thr.raise Exception, "get to work"
+    Thread.pass while @thr.status
+    ScratchPad.recorded.should be_kind_of(Exception)
+    ScratchPad.recorded.message.should == "get to work"
+  end
+
+  it "can go unhandled" do
+    t = Thread.new do
+      loop {}
+    end
+
+    t.raise
+    lambda {t.value}.should raise_error(RuntimeError)
+  end
+
+  it "raise the given argument even when there is an active exception" do
+    raised = false
+    t = Thread.new do
+      begin
+        1/0
+      rescue ZeroDivisionError
+        raised = true
+        loop { }
+      end
+    end
+    begin
+      raise "Create an active exception for the current thread too"
+    rescue
+      Thread.pass until raised
+      t.raise RangeError
+      lambda {t.value}.should raise_error(RangeError)
+    end
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a ZeroDivisionError when called with no arguments inside rescue" do
+      raised = false
+      t = Thread.new do
+        begin
+          1/0
+        rescue ZeroDivisionError
+          raised = true
+          loop { }
+        end
+      end
+      begin
+        raise RangeError
+      rescue
+        Thread.pass until raised
+        t.raise
+      end
+      lambda {t.value}.should raise_error(ZeroDivisionError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError when called with no arguments inside rescue" do
+      raised = false
+      t = Thread.new do
+        begin
+          1/0
+        rescue ZeroDivisionError
+          raised = true
+          loop { }
+        end
+      end
+      begin
+        raise RangeError
+      rescue
+        Thread.pass until raised
+        t.raise
+      end
+      lambda {t.value}.should raise_error(RuntimeError)
+    end
+  end
+end
+
+describe "Thread#raise on same thread" do
+  it_behaves_like :kernel_raise, :raise, Thread.current
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a ZeroDivisionError when called with no arguments inside rescue" do
+      t = Thread.new do
+        begin
+          1/0
+        rescue ZeroDivisionError
+          Thread.current.raise
+        end
+      end
+      lambda {t.value}.should raise_error(ZeroDivisionError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError when called with no arguments inside rescue" do
+      t = Thread.new do
+        begin
+          1/0
+        rescue ZeroDivisionError
+          Thread.current.raise
+        end
+      end
+      lambda {t.value}.should raise_error(RuntimeError)
+    end
+  end
+end