strand 0.1.0 → 0.2.0.rc0

data/spec/strand/strand.rb

@@ -0,0 +1,32 @@
+require 'strand/join'
+require 'strand/exit'
+require 'strand/wakeup'
+require 'strand/status'
+require 'strand/stop'
+require 'strand/raise'
+require 'strand/current'
+require 'strand/alive'
+require 'strand/pass'
+require 'strand/value'
+require 'strand/sleep'
+
+shared_examples "a strand" do
+
+    it "is the expected type of strand" do
+        Strand.delegate_class(::Thread).should == strand_type
+    end
+
+    include_examples "Strand#current"
+    include_examples "Strand#status"
+    include_examples "Strand#exit"
+    include_examples "Strand#join"
+    include_examples "Strand#wakeup"
+    include_examples "Strand#stop"
+    include_examples "Strand#raise"
+    include_examples "Strand#alive?"
+    include_examples "Strand#pass"
+    include_examples "Strand#value"
+    include_examples "Strand#sleep"
+
+    it "should have specs for Strand#list"
+end

data/spec/strand/value.rb

@@ -0,0 +1,39 @@
+
+shared_examples_for "Strand#value" do
+    describe "value" do
+        it "returns the result of the block" do
+            Thread.new { 3 }.value.should == 3
+        end
+
+        it "re-raises error for an uncaught exception" do
+            t = Thread.new { raise "Hello" }
+            lambda { t.value }.should raise_error(RuntimeError, "Hello")
+        end
+
+        quarantine!() do
+            # varying results for killed threads and exceptions
+            ruby_version_is "" ... "1.9" do
+                it "is false for a killed thread" do
+                    t = Thread.new { Thread.current.exit }
+                    t.value.should == false
+                end
+            end
+
+            ruby_version_is "1.9" do
+                it "is nil for a killed thread" do
+                    t = Thread.new { Thread.current.exit }
+                    t.value.should == nil
+                end
+            end
+
+            ruby_version_is "" ... "1.9" do
+                not_compliant_on :rubinius do
+                    it "is false for an uncaught exception thrown from a dying thread" do
+                        t = ThreadSpecs.dying_thread_ensures { 1/0 }
+                        t.value.should == false
+                    end
+                end
+            end
+        end
+    end
+end

data/spec/strand/wakeup.rb

@@ -0,0 +1,60 @@
+shared_examples_for "Strand#wakeup" do
+
+    context :wakeup do
+        it "can interrupt Strand#sleep" do
+            exit_loop = false
+            after_sleep1 = false
+            after_sleep2 = false
+
+            t = Strand.new do
+
+                # For Threads, this is an infinite running loop
+                # but for EM::Thread this part of the test cannot
+                # be simulated
+                #while true
+                #    break if exit_loop == true
+                #end unless 
+
+                Strand.sleep
+                after_sleep1 = true
+
+                Strand.sleep
+                after_sleep2 = true
+            end
+          
+            10.times { Strand.sleep(0.1) if t.status and t.status != "sleep" } 
+            after_sleep1.should == false # t should be blocked on the first sleep
+            t.send(:wakeup)
+
+            10.times { Strand.sleep(0.1) if t.status and t.status != "sleep" } 
+            after_sleep2.should == false # t should be blocked on the second sleep
+            t.send(:wakeup)
+
+            t.join
+        end
+
+        it "does not result in a deadlock" do
+            t = Strand.new do
+                10.times { Strand.stop }
+            end
+
+            while(t.status != false) do
+                begin
+                    t.send(:wakeup)
+                rescue FiberError,ThreadError
+                    # The strand might die right after.
+                    t.status.should == false
+                end
+            end
+
+            1.should == 1 # test succeeds if we reach here
+        end
+
+        it "raises a StrandError when trying to wake up a dead strand" do
+            expected_error = Strand.event_machine? ? FiberError : ThreadError
+            t = Strand.new { 1 }
+            t.join
+            lambda { t.wakeup }.should raise_error(expected_error)
+        end
+    end
+end

data/spec/strand_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'strand/shared'
+
+include EM::SpecHelper
+
+describe Strand::EM::Thread do
+
+    let(:strand_type) { Strand::EM::Thread }
+    let(:strand_exception) { FiberError }
+    around(:each) do |example|
+       ScratchPad.clear
+       em do
+           example.run
+           done
+       end
+    end
+
+    it "should run examples within EventMachine" do
+        EM.reactor_running?.should be_true
+        Strand.event_machine?.should be_true
+    end
+
+    include_examples Strand
+
+    it "should pass resume and yield arguments like fiber" do
+        em do
+          s = Strand.new() do 
+              # These yield args get swalled by the resume that
+              # automatically starts the Strand
+              Strand.yield(:y1).should == [ :r2,"r2" ]
+
+              #These yeild args should be visible by our resume call below
+              Strand.yield(:y2,"y2").should == [ "r3",:r3]
+              :the_end
+          end
+        
+          s.resume(:r2,"r2").should == [ :y2, "y2" ]
+
+          # This is the end of the strand because there are no more yields
+          # should be the value of the block.
+          # Most apps should be calling value() here, rather than resume
+          s.resume("r3",:r3).should == :the_end
+
+          # the Strand is dead now, but should still have captured the value
+          s.value.should == :the_end
+          done 
+        end
+    end
+    
+    it "needs some tests to describe how raw fibers can be treated as strands"
+end

data/spec/support/fixtures.rb

@@ -0,0 +1,305 @@
+
+# Channel is just a queue with receive aliased to shift.
+# if thread specs refer to these just replace with Queue
+#
+module StrandSpecs
+
+    module SubStrand
+        def self.new(*args)
+            subclass = Strand.event_machine? ? EMSubStrand : SubThread
+            subclass.new(*args)
+        end
+    end
+
+    class EMSubStrand < Strand::EM::Thread
+        def initialize(*args)
+            super { args.first << 1 }
+        end
+    end
+
+    class SubThread < ::Thread
+        def initialize(*args)
+            super { args.first << 1 }
+        end
+    end
+
+    class Status
+        attr_reader :strand, :inspect, :status
+        def initialize(strand)
+            @strand = strand
+            @alive = strand.alive?
+            @inspect = strand.inspect
+            @status = strand.status
+            @stop = strand.stop?
+        end
+
+        def alive?
+            @alive
+        end
+
+        def stop?
+            @stop
+        end
+    end
+
+    # TODO: In the great Thread spec rewrite, abstract this
+    class << self
+        attr_accessor :state
+    end
+
+    def self.clear_state
+        @state = nil
+    end
+
+    # GG Not really necessary, if a strand is executing by
+    # definition all other strands are dead or sleeping
+    def self.spin_until_sleeping(t)
+        Strand.pass while t.status and t.status != "sleep"
+    end
+
+    def self.sleeping_strand
+        Strand.new do
+            begin
+                Strand.sleep
+            rescue Object => e
+                ScratchPad.record e
+            end
+        end
+    end
+
+    #GG: Only the current strand can be running, so you can never
+    # find a running strand from outside the strand
+    def self.running_strand
+        Strand.new do
+            begin
+                StrandSpecs.state = :running
+                loop { Strand.pass }
+                ScratchPad.record :woken
+            rescue Object => e
+                ScratchPad.record e
+            end
+        end
+    end
+
+    def self.completed_strand
+        Strand.new {}
+    end
+
+    def self.status_of_current_strand
+        Strand.new { Status.new(Strand.current) }.value
+    end
+
+    #GG: can't check a running strand from outside the strand
+    def self.status_of_running_strand
+        t = running_strand
+        Strand.pass while t.status and t.status != "run"
+        status = Status.new t
+        t.kill
+        t.join
+        status
+    end
+
+    def self.status_of_completed_strand
+        t = completed_strand
+        t.join
+        Status.new t
+    end
+
+    def self.status_of_sleeping_strand
+        t = sleeping_strand
+        Strand.pass while t.status and t.status != 'sleep'
+        status = Status.new t
+        t.run
+        t.join
+        status
+    end
+
+    def self.status_of_blocked_strand
+        m = Strand::Mutex.new
+        m.lock
+        t = Strand.new { m.lock }
+        Strand.pass while t.status and t.status != 'sleep'
+        status = Status.new t
+        m.unlock
+        t.join
+        status
+    end
+
+    def self.status_of_aborting_strand
+    end
+
+    def self.status_of_killed_strand
+        t = Strand.new { Strand.sleep }
+        t.kill
+        t.join
+        Status.new t
+    end
+
+    def self.status_of_strand_with_uncaught_exception
+        t = Strand.new { raise "error" }
+        begin
+            t.join
+        rescue RuntimeError
+        end
+        Status.new t
+    end
+
+    def self.status_of_dying_running_strand
+        status = nil
+        t = dying_strand_ensures { status = Status.new Strand.current }
+        t.join
+        status
+    end
+
+    def self.status_of_dying_sleeping_strand
+        t = dying_strand_ensures { Strand.stop; }
+        Strand.pass while t.status and t.status != 'sleep'
+        status = Status.new t
+        t.wakeup
+        t.join
+        status
+    end
+
+    def self.dying_strand_ensures(kill_method_name=:kill)
+        t = Strand.new do
+            begin
+                Strand.current.send(kill_method_name)
+            ensure
+                yield
+            end
+        end
+    end
+
+    def self.dying_strand_with_outer_ensure(kill_method_name=:kill)
+        t = Strand.new do
+            begin
+                begin
+                    Strand.current.send(kill_method_name)
+                ensure
+                    raise "In dying strand"
+                end
+            ensure
+                yield
+            end
+        end
+    end
+
+    def self.join_dying_strand_with_outer_ensure(kill_method_name=:kill)
+        t = dying_strand_with_outer_ensure(kill_method_name) { yield }
+        lambda { t.join }.should raise_error(RuntimeError, "In dying strand")
+        return t
+    end
+
+    def self.wakeup_dying_sleeping_strand(kill_method_name=:kill)
+        t = StrandSpecs.dying_strand_ensures(kill_method_name) { yield }
+        Strand.pass while t.status and t.status != 'sleep'
+        t.wakeup
+        t.join
+    end
+
+    def self.critical_is_reset
+        # Create another strand to verify that it can call Strand.critical=
+        t = Strand.new do
+            initial_critical = Strand.critical
+            Strand.critical = true
+            Strand.critical = false
+            initial_critical == false && Strand.critical == false
+        end
+        v = t.value
+        t.join
+        v
+    end
+
+    def self.counter
+        @@counter
+    end
+
+    def self.counter= c
+        @@counter = c
+    end
+
+    def self.increment_counter(incr)
+        incr.times do
+            begin
+                Strand.critical = true
+                @@counter += 1
+            ensure
+                Strand.critical = false
+            end
+        end
+    end
+
+    def self.critical_strand1()
+        Strand.critical = true
+        Strand.current.key?(:strand_specs).should == false
+    end
+
+    def self.critical_strand2(isStrandStop)
+        Strand.current[:strand_specs].should == 101
+        Strand.critical.should == !isStrandStop
+        if not isStrandStop
+            Strand.critical = false
+        end
+    end
+
+    def self.main_strand1(critical_strand, isStrandSleep, isStrandStop)
+        # Strand.stop resets Strand.critical. Also, with native strands, the Strand.Stop may not have executed yet
+        # since the main strand will race with the critical strand
+        if not isStrandStop
+            Strand.critical.should == true
+        end
+        critical_strand[:strand_specs] = 101
+        if isStrandSleep or isStrandStop
+            # Strand#wakeup calls are not queued up. So we need to ensure that the strand is sleeping before calling wakeup
+            Strand.pass while critical_strand.status and critical_strand.status != "sleep"
+            critical_strand.wakeup
+        end
+    end
+
+    def self.main_strand2(critical_strand)
+        Strand.pass # The join below seems to cause a deadlock with CRuby unless Strand.pass is called first
+        critical_strand.join
+        Strand.critical.should == false
+    end
+
+    def self.critical_strand_yields_to_main_strand(isStrandSleep=false, isStrandStop=false)
+        @@after_first_sleep = false
+
+        critical_strand = Strand.new do
+            Strand.pass while Strand.main.status and Strand.main.status != "sleep"
+            critical_strand1()
+            Strand.main.wakeup
+            yield
+            Strand.pass while @@after_first_sleep != true # Need to ensure that the next statement does not see the first sleep itself
+            Strand.pass while Strand.main.status and Strand.main.status != "sleep"
+            critical_strand2(isStrandStop)
+            Strand.main.wakeup
+        end
+
+        sleep 5
+        @@after_first_sleep = true
+        main_strand1(critical_strand, isStrandSleep, isStrandStop)
+        sleep 5
+        main_strand2(critical_strand)
+    end
+
+    def self.create_critical_strand()
+        critical_strand = Strand.new do
+            Strand.critical = true
+            yield
+            Strand.critical = false
+        end
+        return critical_strand
+    end
+
+    def self.create_and_kill_critical_strand(passAfterKill=false)
+        critical_strand = StrandSpecs.create_critical_strand do
+            Strand.current.kill
+            if passAfterKill
+                Strand.pass
+            end
+            ScratchPad.record("status=" + Strand.current.status)
+        end
+    end
+
+end