gisele-vm 0.6.0

data/spec/unit/bytecode/test_fetch.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode, 'fetch' do
+
+      let(:bytecode){
+        Bytecode.new([:gvm, [:block, :s0, [:push, 12]]])
+      }
+
+      it 'returns the set of instructions at that label' do
+        bytecode[:s0].should eq([ [:push, 12] ])
+      end
+
+      it 'returns nil if no such label' do
+        bytecode[:s10].should be_nil
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/test_grammar.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar do
+
+      it 'recognizes bad instructions' do
+        (Bytecode::Grammar[:instruction] === [:push, 12]).should be_true
+        (Bytecode::Grammar[:instruction] === [:push]).should be_false
+      end
+
+      it 'recognizes bad blocks' do
+        (Bytecode::Grammar[:block] === [:block]).should be_false
+        (Bytecode::Grammar[:block] === [:block, 0]).should be_false
+        (Bytecode::Grammar[:block] === [:block, 0, [:push]]).should be_false
+        (Bytecode::Grammar[:block] === [:block, 0, [:push, 12]]).should be_true
+      end
+
+      it 'recognize bad files' do
+        (Bytecode::Grammar === [:gvm, [:block, 0, [:push]]]).should be_false
+        (Bytecode::Grammar === [:gvm, [:block, 0, [:push, 12]]]).should be_true
+      end
+
+      it 'provides the list of instruction names' do
+        Bytecode::Grammar.instructions.should be_a(Array)
+        Bytecode::Grammar.instructions.include?(:push).should be_true
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/test_parse.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode, '.parse' do
+
+      let(:file){ Path.dir/'bytecode.gvm' }
+
+      subject{
+        Bytecode.parse(file)
+      }
+
+      it 'returns a Bytecode instance' do
+        subject.should be_a(Bytecode)
+      end
+
+      it 'has the expected bytecode' do
+        subject[:s0].should eq([ [:push, 12] ])
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/test_plus.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode, '+' do
+
+      subject{
+        left + right
+      }
+
+      let(:left) { Bytecode.coerce('s0: push 12') }
+      let(:right){ 's1: push 14'                  }
+
+      it 'returns a Bytecode' do
+        subject.should be_a(Bytecode)
+      end
+
+      it 'denotes the concatenation of bytecodes' do
+        expected = [:gvm,
+          [:block, :s0, [ :push, 12 ]],
+          [:block, :s1, [ :push, 14 ]]
+        ]
+        subject.to_a.should eq(expected)
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/test_to_a.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode, 'to_a' do
+
+      let(:gvm){
+        [:gvm, [:block, :s0, [:push, 12]]]
+      }
+      let(:bytecode){
+        Bytecode.new(gvm)
+      }
+
+      it 'returns the gvm array' do
+        bytecode.to_a.should eq(gvm)
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/test_to_s.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode, 'to_a' do
+
+      let(:bytecode){
+        Bytecode.coerce <<-BC.gsub(/^\s+/, '')
+          s0: push 12
+              pop
+          a_long_label: push [12, "hello"]
+                        push {:hello => :s1}
+        BC
+      }
+
+      subject{ bytecode.to_s.strip }
+
+      it 'should indent friendly' do
+        subject.should eq(<<-STR.gsub(/^\s+\| /, '').strip)
+          | s0:           push 12
+          |               pop
+          | a_long_label: push [12, "hello"]
+          |               push {:hello=>:s1}
+        STR
+      end
+
+      it 'should print equivalent bytecode' do
+        Bytecode.parse(bytecode.to_s).to_a.should eq(bytecode.to_a)
+      end
+
+    end
+  end
+end

data/spec/unit/command/code.gis

@@ -0,0 +1,3 @@
+task Hello
+  World
+end

data/spec/unit/command/test_vm.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Command, "vm" do
+
+      subject do
+        c = Command.new
+        c.parse_options argv
+        c.vm(Path.dir/'code.gis')
+      end
+      let(:components){ subject.components }
+
+      after do
+        components.any?{|c| c.is_a?(ProgList)}.should be_true
+        components.any?{|c| c.is_a?(EventManager)}.should be_true
+      end
+
+      context 'without options' do
+        let(:argv){ [] }
+        it 'should have an Enacter' do
+          components.any?{|c| c.is_a?(Enacter)}.should be_true
+        end
+      end
+
+      context 'with --simulate' do
+        let(:argv){ ["--simulate"] }
+        it 'should have Simulator agents' do
+          pending{
+            components.any?{|c| c.is_a?(Simulator::Resumer)}.should be_true
+            components.any?{|c| c.is_a?(Simulator::Starter)}.should be_true
+          }
+        end
+      end
+
+      context 'with --interactive' do
+        let(:argv){ ["--interactive"] }
+        it 'should have a Console agent' do
+          components.any?{|c| c.is_a?(Console)}.should be_true
+        end
+      end
+
+      context 'with --storage' do
+        let(:argv){ ["--storage=postgres://localhost/gvm"] }
+        it 'sets the options on ProgList correctly' do
+          subject.proglist.options[:uri].should eq("postgres://localhost/gvm")
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/compiling/gisele2gts/test_on_par_st.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gisele2Gts, "on_par_st" do
+
+      before do
+        subject.ith_state(0).initial!
+      end
+
+      subject do
+        code = <<-GIS.strip
+          par
+            Ping
+            Pong
+          end
+        GIS
+        Gisele2Gts.compile code.strip, :root => :par_st
+      end
+
+      let :expected do
+        ping = Gisele2Gts.compile("Ping", :root => :task_call_st)
+        pong = Gisele2Gts.compile("Pong", :root => :task_call_st)
+        Gts.new do
+          s0 = add_state :kind => :fork, :initial => true
+          s1 = add_state :kind => :end, :accepting => true
+          s2 = add_state :kind => :end, :accepting => true
+          s3 = add_state :kind => :join, :accepting => true
+          connect(s0, s3, :symbol => :"(wait)")
+
+          ping.dup(self) do |source,target|
+            connect(s0, target, :symbol => :"(forked#0)") if source.in_edges.empty?
+            connect(target, s1, :symbol => :"(joined)")   if source.out_edges.empty?
+          end
+          pong.dup(self) do |source,target|
+            connect(s0, target, :symbol => :"(forked#1)") if source.in_edges.empty?
+            connect(target, s2, :symbol => :"(joined)")   if source.out_edges.empty?
+          end
+          connect(s1, s3, :symbol => :"(notify)")
+          connect(s2, s3, :symbol => :"(notify)")
+        end
+      end
+
+      it 'generates an equivalent transition system' do
+        # (Path.pwd/'examples/gts.dot').write subject.to_dot
+        # (Path.pwd/'examples/expected.dot').write expected.to_dot
+        subject.bytecode_equivalent!(expected).should be_true
+      end
+
+    end
+  end
+end

data/spec/unit/compiling/gisele2gts/test_on_seq_st.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gisele2Gts, "on_seq_def" do
+
+      before do
+        subject.ith_state(0).initial!
+      end
+
+      subject do
+        code = <<-GIS.strip
+          seq
+            Ping
+            Pong
+          end
+        GIS
+        Gisele2Gts.compile code.strip, :root => :seq_st
+      end
+
+      let :expected do
+        ping = Gisele2Gts.compile("Ping", :root => :task_call_st)
+        pong = Gisele2Gts.compile("Pong", :root => :task_call_st)
+        Gts.new do
+          s0 = add_state :kind => :nop, :initial => true
+          s1 = add_state :kind => :nop
+          ping_end = nil
+          ping.dup(self) do |source,target|
+            connect(s0, target, :symbol => nil) if source.in_edges.empty?
+            ping_end = target if source.out_edges.empty?
+          end
+          pong.dup(self) do |source,target|
+            connect(ping_end, target, :symbol => nil) if source.in_edges.empty?
+            connect(target, s1, :symbol => nil)       if source.out_edges.empty?
+          end
+        end
+      end
+
+      it 'generates an equivalent transition system' do
+        # (Path.pwd/'examples/gts.dot').write subject.to_dot
+        # (Path.pwd/'examples/expected.dot').write expected.to_dot
+        subject.bytecode_equivalent!(expected).should be_true
+      end
+
+    end
+  end
+end

data/spec/unit/compiling/gisele2gts/test_on_task_call_st.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gisele2Gts, "on_task_call_st" do
+
+      before do
+        subject.ith_state(0).initial!
+      end
+
+      subject do
+        Gisele2Gts.compile "Hello", :root => :task_call_st
+      end
+
+      let :expected do
+        Gts.new do
+          add_state :kind => :fork,   :initial => true
+          add_state :kind => :event
+          add_state :kind => :listen, :accepting => true
+          add_state :kind => :event
+          add_state :kind => :end,    :accepting => true
+          add_state :kind => :join,   :accepting => true
+          connect 0, 1, :symbol => :"(forked)"
+          connect 1, 2, :symbol => :start, :event_args => [ "Hello" ]
+          connect 2, 3, :symbol => :ended
+          connect 3, 4, :symbol => :end,   :event_args => [ "Hello" ]
+          connect 4, 5, :symbol => :"(notify)"
+          connect 0, 5, :symbol => :"(wait)"
+        end
+      end
+
+      it 'generates an equivalent transition system' do
+        subject.bytecode_equivalent!(expected).should be_true
+      end
+
+    end
+  end
+end

data/spec/unit/compiling/gisele2gts/test_on_task_def.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gisele2Gts, "on_task_def" do
+
+      before do
+        subject
+        subject.ith_state(0).initial!
+      end
+
+      subject do
+        code = <<-GIS.strip
+          task Main
+            Hello
+          end
+        GIS
+        Gisele2Gts.compile(code, :root => :task_def)
+      end
+
+      let :expected do
+        Gts.new do
+          add_state :kind =>:event, :initial => true
+          add_state :kind => :fork
+          add_state :kind => :event
+          add_state :kind => :listen, :accepting => true
+          add_state :kind => :event
+          add_state :kind => :end, :accepting => true
+          add_state :kind => :join, :accepting => true
+          add_state :kind => :event
+          add_state :kind => :end, :accepting => true
+          connect 0, 1, :symbol => :start, :event_args => [ "Main" ]
+          connect 1, 2, :symbol => :"(forked)"
+          connect 2, 3, :symbol => :start, :event_args => [ "Hello" ]
+          connect 3, 4, :symbol => :ended
+          connect 4, 5, :symbol => :end,   :event_args => [ "Hello" ]
+          connect 5, 6, :symbol => :"(notify)"
+          connect 1, 6, :symbol => :"(wait)"
+          connect 6, 7, :symbol => nil
+          connect 7, 8, :symbol => :end, :event_args => [ "Main" ]
+        end
+      end
+
+      it 'generates an equivalent transition system' do
+        subject.bytecode_equivalent!(expected).should be_true
+      end
+
+    end
+  end
+end

data/spec/unit/compiling/gisele2gts/test_on_unit_def.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Gisele
+  module Compiling
+    describe Gisele2Gts, "on_unit_def" do
+
+      subject do
+        code = <<-GIS.strip
+          task Ping
+            Helli
+          end
+        GIS
+        Gisele2Gts.compile code.strip
+      end
+
+      let :expected do
+        ping = Gisele2Gts.compile("task Ping Helli end", :root => :task_def)
+        Gts.new do
+          s0 = add_state :kind => :launch, :initial => true
+          s1 = add_state :kind => :end, :accepting => true
+          ping.dup(self) do |source,target|
+            connect(s0, target, :symbol => :Ping) if source.in_edges.empty?
+            connect(target, s1, :symbol => nil)   if source.out_edges.empty?
+          end
+        end
+      end
+
+      it 'generates an equivalent transition system' do
+        # (Path.pwd/'examples/gts.dot').write gts.to_dot
+        # (Path.pwd/'examples/expected.dot').write expected.to_dot
+        subject.bytecode_equivalent!(expected).should be_true
+      end
+
+    end
+  end
+end

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

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