gisele-vm 0.6.0

data/spec/fixtures/ts.gts

@@ -0,0 +1,20 @@
+Stamina::Automaton.new do
+  add_state :kind => :listen, :initial => true
+  add_state :kind => :fork
+  add_state :kind => :event
+  add_state :kind => :end
+  add_state :kind => :event
+  add_state :kind => :end
+  add_state :kind => :join
+  add_state :kind => :end
+  connect 0, 1, :symbol => :ping
+  connect 1, 2, nil
+  connect 2, 3, :symbol => :pong
+  connect 1, 4, nil
+  connect 4, 5, :symbol => :pang
+  connect 3, 6, nil
+  connect 5, 6, nil
+  connect 6, 0, nil
+  connect 0, 7, :symbol => :exit
+  connect 1, 6, :symbol => :"(wait)"
+end

data/spec/fixtures/ts.gvm

@@ -0,0 +1,19 @@
+main: then :s0
+s0:   push {:ping=>:s1, :exit=>:s7}
+      then :listen
+s1:   push :s6
+      push [:s2, :s4]
+      then :fork
+s2:   then :s3
+      then :e2
+e2:   push []
+      event :pong
+s3:   then :notify
+s4:   then :s5
+      then :e4
+e4:   push []
+      event :pang
+s5:   then :notify
+s6:   push {:wake => :s0}
+      then :join
+s7:   then :notify

data/spec/spec_helper.rb

@@ -0,0 +1,86 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'gisele-vm'
+require_relative 'fixtures/kernel'
+require_relative 'fixtures/fake_component'
+
+def fixtures
+  Path.dir/:fixtures
+end
+
+(Path.dir/'unit/shared').glob("**/*.rb").each{|f| require(f.without_extension)}
+
+module SpecHelpers
+
+  class FakeEventManager < Gisele::VM::Component
+    attr_reader :events
+    def event(event)
+      @events ||= []
+      @events << event
+    end
+  end
+
+  def observed_events
+    vm.event_manager.events
+  end
+
+  def an_event
+    Gisele::VM::Event.new(Gisele::VM::Prog.new(:puid => 17), :hello, [ "world" ])
+  end
+
+  def vm(bc = nil)
+    @vm ||= begin
+      vm = Gisele::VM.new(bc || [:gvm]) do |vm|
+        vm.proglist      = Gisele::VM::ProgList.memory
+        vm.event_manager = FakeEventManager.new
+      end
+      vm.connect
+      vm.proglist.clear
+      vm
+    end
+  end
+
+  def list
+    @list ||= vm.proglist
+  end
+
+  def kernel(bc = nil)
+    @k ||= vm(bc).kernel
+  end
+
+  def runner(*args)
+    bc   = args.find{|x| Gisele::VM::Bytecode===x}
+    prog = args.find{|x| Integer===x or Gisele::VM::Prog===x}
+    prog = list.fetch(prog) if Integer===prog
+    @kernel ||= kernel(bc).runner(prog)
+  end
+
+  def capture_io
+    stdout, stderr = $stdout, $stderr
+    $stdout, $stderr = StringIO.new, StringIO.new
+    yield
+    [$stdout.string, $stderr.string]
+  ensure
+    $stdout, $stderr = stdout, stderr
+  end
+
+  def measure
+    t1 = Time.now
+    yield
+    t2 = Time.now
+    puts "It took #{(t2-t1)} ms."
+  end
+
+  def sqlite_protocol
+    Gisele::VM::ProgList::Sqldb.sqlite_protocol
+  end
+
+  def sqlite_memory
+    {:uri => "#{sqlite_protocol}:memory"}
+  end
+
+end
+
+RSpec.configure do |c|
+  c.extend  SpecHelpers
+  c.include SpecHelpers
+end

data/spec/test_examples.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Gisele
+  class VM
+
+    shared_examples_for "A valid example file" do
+
+      it 'respect the .gvm grammar' do
+        Bytecode.coerce(subject).verify!
+      end
+
+    end # A valid example file
+
+    examples = Path.backfind('.[examples]')/:examples
+    examples.glob("**/*.gvm").each do |file|
+      describe "the example #{file.basename}" do
+        subject{file}
+        it_behaves_like "A valid example file"
+      end
+    end
+
+    fixtures.glob("**/*.gvm").each do |file|
+      describe "the fixture #{file.basename}" do
+        subject{file}
+        it_behaves_like "A valid example file"
+      end
+    end
+
+  end
+end

data/spec/test_gisele-vm.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../spec_helper', __FILE__)
+describe Gisele::VM do
+
+  it "should have a version number" do
+    Gisele::VM.const_defined?(:VERSION).should be_true
+  end
+
+end

data/spec/unit/bytecode/builder/test_at.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    class Bytecode
+      describe Builder, "at" do
+
+        let(:builder){ Builder.new }
+
+        it 'yields itself then returns the block' do
+          r = builder.at(:s0) do |b|
+            b.push 12
+          end
+          r.should eq([:block, :s0, [:push, 12]])
+        end
+
+        it 'allows a stack based usage' do
+          builder.at(:s0)
+          builder.instruction(:push, [12])
+          builder.end_block.should eq([:block, :s0, [:push, 12]])
+        end
+
+        it 'allows no arg for main' do
+          builder.at
+          builder.end_block.should eq([:block, :main])
+        end
+
+        it 'raises a BadUsageError if the previous block has not been dumped' do
+          builder.at(:s0)
+          lambda{
+            builder.at(:s1)
+          }.should raise_error(BadUsageError)
+        end
+
+        context 'when namespaced' do
+          let(:builder){ Builder.new('Somewhere') }
+
+          it 'use namespaced labels' do
+            builder.at(:s0)
+            builder.end_block.should eq([:block, :Somewhere_s0])
+          end
+
+          it 'allows disabling auto labeling' do
+            builder.at(:s0, false)
+            builder.end_block.should eq([:block, :s0])
+          end
+
+          it 'uses the namespace for main' do
+            builder.at
+            builder.end_block.should eq([:block, :Somewhere])
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/bytecode/builder/test_helpers.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    class Bytecode
+      describe Builder, "the pseudo method-missing helpers" do
+
+        let(:builder){ Builder.new("Somewhere") }
+
+        before do
+          builder.at(:s0)
+        end
+
+        after do
+          builder.end_block
+        end
+
+        it 'returns the instruction built' do
+          builder.push(12).should eq([:push, 12])
+        end
+
+        it 'provides auto-labeling on :then' do
+          builder.then(:s1).should eq([:then, :Somewhere_s1])
+        end
+
+        it 'allows disabling auto-labeling on :then' do
+          builder.then(:s1, false).should eq([:then, :s1])
+        end
+
+        it 'allows a O-adic :then' do
+          builder.then.should eq([:then])
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/bytecode/builder/test_instruction.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    class Bytecode
+      describe Builder, "instruction" do
+
+        let(:builder){ Builder.new }
+
+        it 'adds an instruction to the current block' do
+          builder.at(:s0) do |b|
+            b.instruction(:push, [12])
+          end
+          expected = [:gvm, [:block, :s0, [:push, 12]] ]
+          builder.to_a.should eq(expected)
+        end
+
+        it 'raises BadUsageError if no current block' do
+          lambda{
+            builder.instruction(:push, [ 12 ])
+          }.should raise_error(BadUsageError)
+        end
+
+        it "raises InvalidBytecodeError if arguments don't match" do
+          lambda{
+            builder.instruction(:pop, ['blih'])
+          }.should raise_error(InvalidBytecodeError)
+          lambda{
+            builder.instruction(:push, [])
+          }.should raise_error(InvalidBytecodeError)
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/bytecode/builder/test_to_a.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    class Bytecode
+      describe Builder, "to_a" do
+
+        let(:builder){ Builder.new(namespace) }
+
+        before do
+          builder.at(:s0) do |b|
+            b.then :s1
+          end
+          builder.at(:s1) do |b|
+            b.push 12
+          end
+        end
+
+        context 'without namespace' do
+          let(:namespace){ nil }
+
+          it 'returns blocks' do
+            expected = [ :gvm,
+              [:block, :s0, [:then, :s1]],
+              [:block, :s1, [:push, 12 ]],
+            ]
+            builder.to_a.should eq(expected)
+          end
+
+          it 'returns valid bytecode' do
+            (Grammar === builder.to_a).should be_true
+          end
+        end
+
+        context 'without namespace' do
+          let(:namespace){ 'Somewhere' }
+
+          it 'uses namespaced labels' do
+            expected = [ :gvm,
+              [:block, :Somewhere_s0, [:then, :Somewhere_s1]],
+              [:block, :Somewhere_s1, [:push, 12 ]],
+            ]
+            builder.to_a.should eq(expected)
+          end
+
+          it 'returns valid bytecode' do
+            (Grammar === builder.to_a).should be_true
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/bytecode/bytecode.gvm

@@ -0,0 +1 @@
+s0: push 12

data/spec/unit/bytecode/grammar/fixtures/comments.gvm

@@ -0,0 +1,16 @@
+# This file demonstrates the use of comments
+# in .gvm files
+
+# Below is the first block of instructions
+0: puid
+   fetch    # comments are allowed here
+   save     # as well as here
+
+# A second block here
+1: puid
+   save     # and here also
+
+# trailing comments are allowed as well
+
+
+# as well as trailign spaces

data/spec/unit/bytecode/grammar/fixtures/every.gvm

@@ -0,0 +1,46 @@
+0: fetch
+   fetch 1
+   fetch 'blah'
+   fork
+   fork 15
+   fork :a_label
+   forka
+   invoke
+   parent
+   pop
+   pop 2
+   push 12
+   push 'hello'
+   push Symbol
+   push []
+   push [12]
+   push [12, 'hello']
+   push {}
+   push { }
+   push {name: 'blah'}
+   push {name: 'blah', at: :A_start}
+   then
+   then 0
+   then :a_label
+   save
+   save 2
+   puid
+   send
+   fold
+   fold 3
+   unfold
+   event
+   event :hello
+   get
+   get :attrname
+   getr
+   getr :attrname
+   set
+   set :attrname
+   del
+   del :attrname
+   self
+   flip
+   nop
+   ifenil
+   ifezero

data/spec/unit/bytecode/grammar/fixtures/singleblock.gvm

@@ -0,0 +1,2 @@
+0: puid
+   then

data/spec/unit/bytecode/grammar/fixtures/twoblocks.gvm

@@ -0,0 +1,4 @@
+0: puid
+   then
+1: then
+   pop

data/spec/unit/bytecode/grammar/fixtures/with_end.gvm

@@ -0,0 +1,5 @@
+# We show here the __END__ trick
+0: puid
+
+__END__
+{:puid => 0, :parent => nil}

data/spec/unit/bytecode/grammar/test_array.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "array" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :array)
+      end
+
+      it 'parses empty arrays correctly' do
+        parse("[ ]").value.should eq([])
+      end
+
+      it 'parses singletons correcttly' do
+        parse("[0]").value.should eq([0])
+      end
+
+      it 'parses arrays correcttly' do
+        parse("[0, 'blah', :symb]").value.should eq([0, 'blah', :symb])
+      end
+
+    end
+  end
+end