gisele-vm 0.6.0

data/spec/unit/compiling/gts2bytecode/test_on_event.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gts2Bytecode, "on_event" do
+
+      let(:gts) do
+        Gts.new do
+          add_state :kind => :event
+          add_state :kind => :nop
+          connect(0, 1, :symbol => :hello, :event_args => [ "world" ])
+        end
+      end
+      let(:compiler){ Gts2Bytecode.new }
+      let(:bytecode){ compiler.builder.to_a }
+
+      before do
+        subject
+      end
+
+      subject do
+        compiler.on_event(gts.ith_state(0))
+      end
+
+      it 'should generate the expected bytecode' do
+        bytecode.should eq([:gvm,
+          [:block, :s0,
+            [:then, :s1],
+            [:then, :e0]],
+          [:block, :e0,
+            [:push, [ "world"] ],
+            [:event, :hello] ]
+        ])
+      end
+
+    end
+  end
+end

data/spec/unit/compiling/gts2bytecode/test_on_fork.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gts2Bytecode, "on_fork" do
+
+      let(:gts) do
+        Gts.new do
+          add_state :kind => :fork
+          add_state :kind => :join
+          add_state :kind => :event
+          add_state :kind => :event
+          connect(0, 1, :symbol => :"(wait)")
+          connect(0, 2, :symbol => :"(forked#1)")
+          connect(0, 3, :symbol => :"(forked#2)")
+          connect(2, 1, :symbol => :ping)
+          connect(3, 1, :symbol => :pong)
+        end
+      end
+      let(:compiler){ Gts2Bytecode.new      }
+      let(:bytecode){ compiler.builder.to_a }
+
+      before do
+        subject
+      end
+
+      subject do
+        compiler.on_fork(gts.ith_state(0))
+      end
+
+      it 'should generate the expected bytecode' do
+        bytecode.should eq([:gvm,
+          [:block, :s0,
+            [:push, :s1],
+            [:push, [:s2, :s3]],
+            [:then, :fork]]
+        ])
+      end
+
+    end
+  end
+end

data/spec/unit/compiling/gts2bytecode/test_on_join.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gts2Bytecode, "on_join" do
+
+      let(:gts) do
+        Gts.new do
+          add_state :kind => :fork
+          add_state :kind => :join
+          add_state :kind => :event
+          add_state :kind => :event
+          add_state :kind => :end
+          connect(0, 1, :symbol => :"(wait)")
+          connect(0, 2, :symbol => :"(forked#1)")
+          connect(0, 3, :symbol => :"(forked#2)")
+          connect(2, 1, :symbol => :ping)
+          connect(3, 1, :symbol => :pong)
+          connect(1, 4, :symbol => nil)
+        end
+      end
+      let(:compiler){ Gts2Bytecode.new      }
+      let(:bytecode){ compiler.builder.to_a }
+
+      before do
+        subject
+      end
+
+      subject do
+        compiler.on_join(gts.ith_state(1))
+      end
+
+      it 'should generate the expected bytecode' do
+        bytecode.should eq([:gvm,
+          [:block, :s1,
+            [:push, {:wake => :s4}],
+            [:then, :join]]
+        ])
+      end
+
+    end
+  end
+end

data/spec/unit/compiling/gts2bytecode/test_on_listen.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gts2Bytecode, "on_listen" do
+
+      let(:gts) do
+        Gts.new do
+          add_state :kind => :listen
+          add_state :kind => :nop
+          add_state :kind => :nop
+          connect(0, 1, :symbol => :ping)
+          connect(0, 2, :symbol => :pong)
+        end
+      end
+      let(:compiler){ Gts2Bytecode.new      }
+      let(:bytecode){ compiler.builder.to_a }
+
+      before do
+        subject
+      end
+
+      subject do
+        compiler.on_listen(gts.ith_state(0))
+      end
+
+      it 'should generate the expected bytecode' do
+        bytecode.should eq([:gvm,
+          [:block, :s0,
+            [:push, {:ping=>:s1, :pong=>:s2}],
+            [:then, :listen]]
+        ])
+      end
+
+    end
+  end
+end

data/spec/unit/compiling/gts2bytecode/test_on_nop.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gts2Bytecode, "on_nop" do
+
+      let(:gts) do
+        Gts.new do
+          add_state :kind => :nop
+          add_state :kind => :nop
+          connect(0, 1, :symbol => nil)
+        end
+      end
+      let(:compiler){ Gts2Bytecode.new      }
+      let(:bytecode){ compiler.builder.to_a }
+
+      before do
+        subject
+      end
+
+      subject do
+        compiler.on_nop(gts.ith_state(0))
+      end
+
+      it 'should generate the expected bytecode' do
+        bytecode.should eq([:gvm, [:block, :s0, [:then, :s1]]])
+      end
+
+    end
+  end
+end

data/spec/unit/component/test_component_name.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Component, "component_name" do
+
+      class FooComponent < VM::Component
+        public :component_name
+      end
+
+      it 'uses the class name by default' do
+        FooComponent.new.component_name.should eq("FooComponent")
+      end
+
+    end
+  end
+end

data/spec/unit/component/test_logging.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Component, "logging delegation" do
+
+      let(:component){ Component.new }
+
+      context 'without vm' do
+
+        it 'uses a NullObject to avoid failing' do
+          component.vm.should be_a(NullObject)
+        end
+
+        it 'delegates logger methods to it' do
+          lambda{
+            component.info("message")
+          }.should_not raise_error
+        end
+
+      end # without vm
+
+      context 'with a vm' do
+
+        before do
+          component.registered Struct.new(:info).new("blah")
+        end
+
+        it 'delegates logger methods to it' do
+          component.info.should eq("blah")
+        end
+
+      end # with a vm
+
+    end
+  end
+end

data/spec/unit/enacter/test_component.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Enacter do
+      subject{ Enacter.new }
+      pending{
+        it_should_behave_like "a component"
+      }
+    end
+  end
+end

data/spec/unit/event/test_to_s.rb

@@ -0,0 +1,12 @@
+module Gisele
+  class VM
+    describe Event, "to_s" do
+
+      it 'works as expected' do
+        expected = "start[17](Ping, 3)"
+        Event.new(Prog.new(:puid => 17), :start, ["Ping", "3"]).to_s.should eq(expected)
+      end
+
+    end
+  end
+end

data/spec/unit/event_manager/test_component.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe EventManager do
+      subject{ EventManager.new }
+      it_should_behave_like "a component"
+    end
+  end
+end

data/spec/unit/event_manager/test_subscribe.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe EventManager, 'subscribe' do
+
+      let(:publisher) { EventManager.new }
+      let(:subscriber){ lambda{|event| } }
+
+      after do
+        publisher.subscribed?(subscriber).should be_true
+      end
+
+      context 'when not connected' do
+        it 'subscribes a block correctly' do
+          publisher.subscribe(&subscriber)
+        end
+        it 'subscribes a Proc correctly' do
+          publisher.subscribe(subscriber)
+        end
+      end
+
+      context 'when connected' do
+        before do
+          publisher.registered(vm)
+          publisher.connect
+        end
+        after do
+          publisher.send(:name_of, subscriber).should_not be_nil
+        end
+        it 'subscribes a block to EM' do
+          publisher.subscribe(&subscriber)
+        end
+        it 'subscribes a Proc to EM' do
+          publisher.subscribe(subscriber)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/event_manager/test_unsubscribe.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe EventManager, 'unsubscribe' do
+
+      let(:publisher) { EventManager.new }
+      let(:subscriber){ lambda{|event| } }
+
+      after do
+        publisher.subscribed?(subscriber).should be_false
+      end
+
+      context 'when not connected' do
+        it 'does nothing when not previously subscribed' do
+          publisher.unsubscribe(subscriber).should be_nil
+        end
+        it 'unsubscribes a block previously subscribed' do
+          publisher.subscribe(subscriber)
+          publisher.unsubscribe(subscriber)
+        end
+      end
+
+      context 'when connected' do
+        before do
+          publisher.registered(vm)
+          publisher.connect
+        end
+        after do
+          publisher.send(:name_of, subscriber).should be_nil
+        end
+        it 'unsubscribes a Proc to EM' do
+          publisher.subscribe(subscriber)
+          publisher.unsubscribe(subscriber)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/kernel/macros/test_fork.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "fork macro" do
+
+      let(:runn)  { runner(@parent)     }
+      let(:parent){ list.fetch(@parent) }
+
+      before do
+        @parent = list.save Prog.new(:pc => :fork, :root => 16)
+        subject
+      end
+
+      subject do
+        runn.run(:fork, [ :joinat, [ :fat1, :fat2 ] ])
+      end
+
+      after do
+        runn.stack.should be_empty
+      end
+
+      it 'sets the events as waitlist' do
+        parent.waitlist.should eq({@parent+1 => true, @parent+2 => true})
+      end
+
+      it 'fork and schedules self and children correctly' do
+        expected = Relation([
+          {:puid => @parent,   :pc => :joinat, :parent => @parent, :root => 16, :waitfor => :children},
+          {:puid => @parent+1, :pc => :fat1,   :parent => @parent, :root => 16, :waitfor => :enacter },
+          {:puid => @parent+2, :pc => :fat2,   :parent => @parent, :root => 16, :waitfor => :enacter }
+        ])
+        list.to_relation.project([:puid, :pc, :parent, :root, :waitfor]).should eq(expected)
+      end
+
+    end
+  end
+end

data/spec/unit/kernel/macros/test_join.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "join macro" do
+
+      let(:runn)  { runner(@parent)     }
+      let(:parent){ list.fetch(@parent) }
+
+      before do
+        @parent = list.save Prog.new(:pc => :blah, :waitlist => wlist, :waitfor => :enacter)
+        subject
+      end
+
+      subject do
+        runn.run(:join, [ {:wake => :wakeat} ])
+      end
+
+      after do
+        runn.stack.should be_empty
+      end
+
+      context 'when the waitlist is not empty' do
+        let(:wlist){ {12 => true, 13 => true} }
+
+        it 'keeps the program sleeping' do
+          parent.pc.should eq(:blah)
+          parent.waitfor.should eq(:children)
+        end
+      end
+
+      context 'when the waitlist is empty' do
+        let(:wlist){ {} }
+
+        it 'schedules the program at :wakeat' do
+          parent.pc.should eq(:wakeat)
+          parent.waitlist.should eq({})
+          parent.waitfor.should eq(:enacter)
+        end
+      end
+
+    end
+  end
+end