dramatis 0.0.1

data/spec/dramatis/actor_spec.rb

@@ -0,0 +1,492 @@
+require File.join( File.dirname(__FILE__), "..", '/spec_helper.rb' )
+
+require 'dramatis/runtime'
+require 'dramatis/actor/name'
+
+# NB: don't use the module name here: rspec wants to include described
+# modules ... and making the result into an actor, well, needless to say,
+# it's not a good idea
+
+describe "Dramatis::Actor" do
+
+  include Dramatis
+
+  include DramatisSpecHelper
+
+  after(:each) { runtime_check }
+
+  Actor = Dramatis::Actor
+
+  it "should be creatable from an include-ed class
+      and return the right type" do
+
+    f = Class.new do
+      include Dramatis::Actor
+    end
+
+    name = f.new
+    name.should be_a_kind_of( Actor::Name )
+
+  end
+
+  it "should be possible to not get an actor name" do
+
+    f = Class.new do
+      include Dramatis::Actor
+      class << self
+        remove_method :new
+      end
+    end
+
+    name = f.new
+    name.should be_a_kind_of( f )
+
+  end
+
+  it "should create a new name when invoked with new" do
+    name = Actor.new Object.new
+    name.should be_a_kind_of( Actor::Name )
+  end
+
+  it "should deadlock if an rpc is made to an unbound name" do
+    lambda { Dramatis::Actor.new.foo }.should raise_error( Dramatis::Deadlock )
+  end
+
+  it "should return NoMethodError even when not a direct call" do
+    cls = Class.new do
+      include Dramatis::Actor
+      def rpc other
+        other.foo
+      end
+    end
+    a = cls.new
+    b = cls.new
+    lambda { a.rpc b }.should raise_error( NoMethodError )
+  end
+
+  it "should obey refuse" do
+    a = Class.new do
+      include Dramatis::Actor
+      def initialize
+        actor.refuse :fromB
+      end
+    end
+
+    b = Class.new do
+      include Dramatis::Actor
+      def initialize anA
+        @anA = anA
+      end
+      def startB
+        @anA.fromB
+      end
+    end
+
+    anA = a.new
+    aB = b.new anA
+
+    ( interface( aB ).continue nil ).startB
+
+    Dramatis::Runtime.current.warnings = false
+
+    lambda {
+      begin
+        Dramatis::Runtime.current.at_exit
+      rescue Dramatis::Error::Uncaught => uc
+        raise uc
+      end
+    }.should raise_error( Dramatis::Error::Uncaught )
+
+    Dramatis::Runtime.current.warnings = true
+
+    Dramatis::Runtime.reset
+
+  end
+
+  it "should obey refuse and then recover with default" do
+
+    a = Class.new do
+      include Dramatis::Actor
+      def initialize
+        actor.refuse :fromB
+      end
+      def allow
+        actor.default :fromB
+        class << self
+          def fromB; end
+        end
+      end
+    end
+
+    b = Class.new do
+      include Dramatis::Actor
+      include Dramatis::Actor
+      def initialize anA
+        @anA = anA
+        @count = 0
+        actor.always :count, true
+      end
+
+      def startB
+        @anA.fromB
+      end
+
+      def count
+        @count
+      end
+
+      def increment
+        @count += 1
+      end
+    end
+
+    anA = a.new
+    aB = b.new anA
+
+    aB_cast = interface( aB ).continue nil
+
+    aB.count.should equal( 0 )
+
+    aB.increment
+
+    aB.count.should equal( 1 )
+
+    aB_cast.increment
+
+    Dramatis::Runtime.current.quiesce
+
+    aB.count.should equal( 2 )
+    
+    aB_cast.startB
+    aB_cast.increment
+
+    Dramatis::Runtime.current.quiesce
+
+    aB.count.should equal( 2 )
+
+    anA.allow
+
+    Dramatis::Runtime.current.quiesce
+
+    aB.count.should equal( 3 )
+  end
+
+  it "should block calls when in an rpc is inflight and there is no call threading" do
+
+    a = Class.new do
+
+      include Dramatis::Actor
+
+      def initialize
+        actor.refuse :fromB
+      end
+
+      def allow
+        actor.default :fromB
+
+        # just for the hell of it,
+        # def fromB here; if called earlier
+        # should fail making timing errors
+        # more obvious
+
+        class << self
+          def fromB; end
+        end
+        
+      end
+
+    end
+
+    b = Class.new do
+
+      include Dramatis::Actor
+
+      def initialize anA
+        @anA = anA
+        @count = 0
+        actor.always :count, true
+      end
+
+      def startB
+        @anA.fromB
+      end
+
+      def count
+        @count
+      end
+
+      def increment
+        @count += 1
+      end
+
+      def shouldDeadlock; end
+
+    end
+
+    anA = a.new
+    aB = b.new anA
+
+    aB_cast = interface( aB ).continue nil
+
+    aB.count.should equal( 0 )
+
+    aB.increment
+
+    aB.count.should equal( 1 )
+
+    aB_cast.increment
+
+    Dramatis::Runtime.current.quiesce
+
+    aB.count.should equal( 2 )
+
+    aB_cast.startB
+    aB_cast.increment
+
+    Dramatis::Runtime.current.quiesce
+
+    aB.count.should equal( 2 )
+
+    Dramatis::Runtime.current.exceptions.length.should equal( 0 )
+
+    Dramatis::Runtime.current.warnings = false
+
+    lambda { aB.shouldDeadlock }.should raise_error( Dramatis::Deadlock )
+
+    lambda { Dramatis::Runtime.current.quiesce }.should raise_error( Dramatis::Error::Uncaught )
+
+    Dramatis::Runtime.current.warnings = true
+
+    Dramatis::Runtime.current.exceptions.length.should equal( 2 )
+
+    Dramatis::Runtime.current.clear_exceptions
+
+    Dramatis::Runtime.current.exceptions.length.should equal( 0 )
+
+    aB.count.should equal( 2 )
+    
+    anA.allow
+
+    aB_cast.startB
+    aB_cast.increment
+
+    Dramatis::Runtime.current.quiesce
+
+    aB.count.should equal( 3 )
+
+  end
+
+  it "should block on recursion in the non-call threaded case" do
+    a = Class.new do
+      include Dramatis::Actor
+      def a
+        actor.name.b
+      end
+      def b; end
+    end
+
+    lambda { a.new.a }.should raise_error( Dramatis::Deadlock )
+  end
+
+  it "should block block continuations during an rpc w/o call threading " do
+    a = Class.new do
+      include Dramatis::Actor
+      attr_reader :block_called
+      def initialize
+        @block_called = false
+        actor.refuse :c
+        actor.always :block_called, true
+      end
+      def a other
+        block = lambda { |c| @block_called = true }
+        ( interface( other ).continue( &block ) ).b
+        other.c
+      end
+      def enable
+        actor.default :c
+      end
+      def b; end
+      def c; end
+    end
+
+    a1 = a.new
+    a2 = a.new
+    ( interface( a1 ).continue nil ).a a2
+
+    Dramatis::Runtime.current.quiesce
+
+    a1.block_called.should be_false
+
+    a2.enable
+
+    Dramatis::Runtime.current.quiesce
+
+    a1.block_called.should be_true
+  end
+
+  it "should call exception blocks on exceptions" do
+    a = Class.new do
+      include Dramatis::Actor
+      attr_reader :block_called, :exception_raised
+      def initialize
+        actor.refuse :c
+        actor.always :block_called, true
+        actor.always :exception_raised, true
+        @block_called = @exception_raised = false
+      end
+      def a other
+        result = lambda { |r| @block_called = true }
+        except = lambda do |exception|
+
+          # FIX: lambda is overridden, I think, so get it back to
+          # the spec class and normal processing should work
+
+          # rspec seems to have problems with normal "should" stuff
+          # in this block ... this causes a failure, which is good
+          # (though it does cascacde, which isn't great, but not worth
+          # tracking down).
+          raise exception if exception.to_s != "hell"
+          @exception_raised = true
+        end
+        ( interface( other ).continue :exception => except, &result ).bb
+        ( interface( other ).continue :exception => except, &result ).b
+        other.c
+      end
+      def enable
+        actor.default :c
+      end
+      def bb; end
+      def b
+        raise "hell"
+      end
+      def c; end
+    end
+
+    a1 = a.new
+    a2 = a.new
+    ( interface( a1 ).continue nil ).a a2
+
+    Dramatis::Runtime.current.quiesce
+
+    a1.block_called.should be_false
+    a1.exception_raised.should be_true
+
+    a2.enable
+
+    Dramatis::Runtime.current.quiesce
+
+    a1.block_called.should be_true
+  end
+
+  it "should allow recursion and corecursion when call threading enabled" do
+    a = Class.new do
+      include Dramatis::Actor
+      def initialize
+        actor.enable_call_threading
+      end
+      def a
+        actor.name.b
+      end
+      def b; end
+      def c
+        other = self.class.new
+        other.d actor.name
+      end
+      def d first
+        first.a
+      end
+    end
+    a.new.a # recursion
+    a.new.c # co-recursion
+  end
+  
+  it "should map self returns into an actor name" do
+    a = Class.new do
+      include Dramatis::Actor
+      def me
+        self
+      end
+    end
+    anA = a.new
+    anA.should be_kind_of( Dramatis::Actor::Name )
+    anA.me.should be_kind_of( Dramatis::Actor::Name )
+  end
+
+  it "should map self in actor method calls to name" do
+    a = Class.new do
+      include Dramatis::Actor
+      def test
+        actor.always :f, true
+        actor.name.f self
+      end
+      def f ref
+        ref.object_id != self.object_id
+      end
+    end
+    anA = a.new
+    anA.test.should be_true
+  end
+
+  it "should raise deadlocks with pretty backtraces" do
+
+    a = Class.new do
+      include Dramatis::Actor
+      def deadlock
+        @@first_line = __LINE__.to_i + 1
+        actor.name.deadlock
+      end
+      def self.first_line
+        @@first_line
+      end
+    end
+
+    anA = a.new
+
+    second_line = nil
+
+    begin 
+      second_line = __LINE__.to_i + 1
+      anA.deadlock
+      raise "fail: should not get here"
+    rescue Dramatis::Deadlock => deadlock
+      bt = deadlock.backtrace
+
+      # pp bt
+
+      f, l = bt[0].split ':'
+      f.should == __FILE__
+      l.to_i.should == a.first_line
+
+      f, l = bt[1].split ':'
+      f.should == __FILE__
+      l.to_i.should == second_line
+
+    end
+    
+  end
+
+  it "should yield when asked to" do
+
+    c = Class.new do
+      include Dramatis::Actor
+      def f
+        @a = 1
+        @a.should == 1
+        release( actor.name ).g
+        sleep 1
+        @a.should == 1
+        actor.yield
+        @a.should == 2
+        return @a
+      end
+      def g
+        @a += 1
+      end
+    end
+
+    aC = c.new
+    aC.f.should == 2
+
+  end
+
+end

data/spec/dramatis/dramatis_spec.rb

@@ -0,0 +1,23 @@
+require File.join( File.dirname(__FILE__), "..", '/spec_helper.rb' )
+
+require 'dramatis'
+
+describe Dramatis do
+
+  it "should send exceptions to actors in the non-rpc case"
+
+  it "should give nice continuation-based backtraces on exceptions"
+
+  it "should not swallow exceptions when the continuation is null"
+
+  it "should limit actor() access"
+
+  it "should allow behavor access(?)"
+
+  it "should have a nice way to cast actor creation"
+
+  it "should allow threads to be locked to actors, e.g., for fox"
+
+  it "should gc actors"
+
+end

data/spec/dramatis/exc_spec.rb

@@ -0,0 +1,78 @@
+require File.join( File.dirname(__FILE__), "..", '/spec_helper.rb' )
+
+require 'dramatis/actor'
+require 'dramatis/runtime'
+
+# NB: don't use the module name here: rspec wants to include described
+# modules ... and making the result into an actor, well, needless to say,
+# it's not a good idea
+
+describe "Dramatis::Actor" do
+
+  include DramatisSpecHelper
+
+  after(:each) { runtime_check }
+
+  it "should provide pretty backtraces" do
+
+    foo = Class.new do
+      include Dramatis::Actor
+      
+      @@first_line = nil
+
+      def self.first_line
+        return @@first_line
+      end
+
+      def foo that
+        @@first_line = __LINE__.to_i + 1
+        return that.bar
+      end
+
+    end
+
+    bar = Class.new do
+      include Dramatis::Actor
+          
+      @@second_line = nil
+
+      def self.second_line
+        return @@second_line
+      end
+
+      def bar
+        @@second_line = __LINE__.to_i + 1
+        name_error
+        return "foobar"
+      end
+
+    end
+
+    aFoo = foo.new
+    aBar = bar.new
+    okay = false
+    r = "xyzzy"
+    begin
+      r = aFoo.foo aBar
+    rescue NameError => ne
+      tb = ne.backtrace
+
+      # puts tb.join("\n")
+
+      f,l = tb[0].split ":"
+      f.should == __FILE__
+      l.to_i.should == bar.second_line
+
+      f,l = tb[1].split ":"
+      f.should == __FILE__
+      l.to_i.should == foo.first_line
+
+      okay = true
+    end
+
+    r.should == "xyzzy"
+    okay.should be_true
+
+  end
+
+end

data/spec/dramatis/runtime/gate_spec.rb

@@ -0,0 +1,57 @@
+require File.join( File.dirname(__FILE__), "..", "..", '/spec_helper.rb' )
+
+require 'dramatis/runtime/gate'
+
+describe Dramatis::Runtime::Gate do
+
+  before do
+    @gate = Dramatis::Runtime::Gate.new
+  end
+
+  it "should accept simple defaults" do
+    @gate.accepts?( :actor ).should be_true
+    @gate.accepts?( :continuation ).should be_true
+    @gate.accepts?( :object ).should be_true
+    @gate.accepts?( :foo ).should be_true
+  end
+
+  it "should return the gate list" do
+    @gate.list.should == [ [[:object], true],
+                           [[:continuation], true],
+                           [[:actor], true],
+                           [[Object], true] ]
+  end
+
+  it "should obey simple changes" do
+    @gate.refuse :object
+    @gate.accepts?( :object ).should be_false
+    @gate.list.should == [ [[:object], false],
+                           [[:continuation], true],
+                           [[:actor], true],
+                           [[Object], true] ]
+  end
+
+  it "should reorder on change" do
+    @gate.refuse :actor
+    @gate.accepts?( :actor ).should be_false
+    @gate.list.should == [ [[:actor], false],
+                           [[:object], true],
+                           [[:continuation], true],
+                           [[Object], true] ]
+  end
+
+  it "should reorder on no change" do
+    @gate.accept :actor
+    @gate.accepts?( :actor ).should be_true
+    @gate.list.should == [ [[:actor], true],
+                           [[:object], true],
+                           [[:continuation], true],
+                           [[Object], true] ]
+  end
+
+  it "should obey simple changes" do
+    @gate.refuse :object
+    @gate.accepts?( :object ).should be_false
+  end
+
+end

data/spec/dramatis/runtime/thread_pool.rb

@@ -0,0 +1,30 @@
+require File.join( File.dirname(__FILE__), "..", "..", '/spec_helper.rb' )
+
+require 'dramatis/runtime/thread_pool'
+
+describe Dramatis::Runtime::ThreadPool do
+
+  it "should be resetable" do
+    thread_pool = Dramatis::Runtime::ThreadPool.new
+    thread_pool.reset
+  end
+
+  # this could be done with join, but is not currently
+  # needed for anything but the test, so ...
+  it "should allocate threads that do stuff" do
+    thread_pool = Dramatis::Runtime::ThreadPool.new
+    @x = 1
+    t = thread_pool.new do
+      sleep 0.1
+      @x = 2
+    end
+    @x.should == 1
+    thread_pool.length.should == 0
+    sleep 0.2
+    @x.should == 2
+    thread_pool.length.should == 1
+    thread_pool.reset
+    thread_pool.length.should == 0
+  end
+
+end

data/spec/dramatis/shoes_spec.rb

@@ -0,0 +1,11 @@
+require File.join( File.dirname(__FILE__), "..", '/spec_helper.rb' )
+
+require 'dramatis/shoes'
+
+describe Dramatis::Shoes do
+
+  it "should provide a handle to the runtime" do
+    runtime = Dramatis::Shoes.runtime
+  end
+
+end

data/spec/dramatis/simple_spec.rb

@@ -0,0 +1,32 @@
+require File.join( File.dirname(__FILE__), "..", '/spec_helper.rb' )
+
+require 'dramatis/actor'
+require 'dramatis/runtime'
+
+# NB: don't use the module name here: rspec wants to include described
+# modules ... and making the result into an actor, well, needless to say,
+# it's not a good idea
+
+describe "Dramatis::Actor" do
+
+  include DramatisSpecHelper
+
+  after(:each) { runtime_check }
+
+  it "should be creatable w/o requiring name" do
+
+    f = Class.new do
+      include Dramatis::Actor
+    end
+
+    name = f.new
+
+    # if we get here, we're fine
+    # is there an rspec "something" for this?
+    # note, this doesn't "test" in autotest,
+    # probably because it's eval'ing other tests that
+    # do bring in Actor::Name
+
+  end
+
+end