gisele-vm 0.6.0

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "listen macro" do
+
+      let(:runn)  { runner(@parent)     }
+      let(:parent){ list.fetch(@parent) }
+      let(:wlist) { {:ping => :sPing, :pong => :sPong}        }
+
+      before do
+        @parent = list.save Prog.new(:pc => :listen)
+        subject
+      end
+
+      subject do
+        runn.run(:listen, [ wlist ])
+      end
+
+      after do
+        runn.stack.should be_empty
+      end
+
+      it 'sets the events as waitlist' do
+        parent.waitlist.should eq(wlist)
+      end
+
+      it 'sets the program counter to :react' do
+        parent.pc.should eq(:react)
+      end
+
+      it 'unschedules the current Prog' do
+        parent.waitfor.should eq(:world)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "notify macro" do
+
+      let(:runn)  { runner(@child)      }
+      let(:parent){ list.fetch(@parent) }
+      let(:child) { list.fetch(@child)  }
+
+      subject do
+        runn.run(:notify, [ ])
+      end
+
+      after do
+        runn.stack.should be_empty
+      end
+
+      context 'when the child has a parent' do
+
+        before do
+          @parent = list.save Prog.new
+          @child  = list.save Prog.new(:parent => @parent)
+          @child2 = list.save Prog.new(:parent => @parent)
+          list.save(Prog.new :puid => @parent, :waitlist => {@child => true, @child2 => true})
+          subject
+        end
+
+        it 'ends the child' do
+          child.pc.should eq(-1)
+          child.waitfor.should eq(:none)
+        end
+
+        it 'resumes the parent on a reduced waitlist' do
+          parent.waitlist.should eq(@child2 => true)
+          parent.waitfor.should eq(:enacter)
+        end
+
+      end # with a parent
+
+      context 'when the child has no parent' do
+
+        before do
+          @child = list.save Prog.new
+          subject
+        end
+
+        it 'ends the child' do
+          child.pc.should eq(-1)
+          child.waitlist.should eq({})
+          child.waitfor.should eq(:none)
+        end
+
+      end # withoutb a parent
+
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "react macro" do
+
+      let(:runn)  { runner(@parent)     }
+      let(:parent){ list.fetch(@parent) }
+      let(:wlist) { {:ping => :sPing, :pong => :sPong} }
+
+      before do
+        @parent = list.save Prog.new(:pc => :react, :waitlist => wlist, :waitfor => waitfor)
+        subject
+      end
+
+      subject do
+        runn.run(:react, [ event ])
+      end
+
+      after do
+        runn.stack.should be_empty
+      end
+
+      context 'when a recognized event' do
+        let(:event)  { :ping  }
+        let(:waitfor){ :world }
+
+        it 'schedules the current Prog correctly' do
+          parent.pc.should eq(:sPing)
+          parent.waitfor.should eq(:enacter)
+          parent.waitlist.should eq({})
+        end
+      end
+
+      context 'when an unrecognized event' do
+        let(:event)  { :pang    }
+        let(:waitfor){ :enacter }
+
+        it 'sleeps the current Prog' do
+          parent.pc.should eq(:react)
+          parent.waitfor.should eq(:world)
+          parent.waitlist.should eq(wlist)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "schedule_at macro" do
+
+      let(:runn)  { runner(@parent)     }
+      let(:parent){ list.fetch(@parent) }
+
+      before do
+        @parent = list.save Prog.new(:waitfor => :none)
+        subject
+      end
+
+      subject do
+        runn.run(:schedule_at, [ :s16 ])
+      end
+
+      after do
+        runn.stack.should be_empty
+      end
+
+      it 'resumes the current Prog' do
+        parent.waitfor.should eq(:enacter)
+        parent.pc.should eq(:s16)
+        parent.waitlist.should eq({})
+      end
+
+    end
+  end
+end

data/spec/unit/kernel/opcodes/test_op_del.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_del" do
+
+      before do
+        runner.stack = [ receiver ]
+      end
+
+      context 'with a hash' do
+        let(:receiver){ {:hello => "World", :other => true} }
+
+        it 'removes the key from the hash' do
+          runner.op_del(:hello)
+          runner.stack.should eq([ {:other => true} ])
+        end
+
+        it 'takes the attribute name from the stack if unspecified' do
+          runner.op_push :hello
+          runner.op_del
+          runner.stack.should eq([ {:other => true} ])
+        end
+      end
+
+      context 'with an array' do
+        let(:receiver){ [:hello, :world] }
+
+        it 'pushes the result on the stack' do
+          runner.op_del(:hello)
+          runner.stack.should eq([[:world]])
+        end
+
+        it 'takes the attribute name from the stack if unspecified' do
+          runner.op_push :hello
+          runner.op_del
+          runner.stack.should eq([[:world]])
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/kernel/opcodes/test_op_event.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_event" do
+
+      let(:runn){ runner(Prog.new(:puid => 17)) }
+
+      before do
+        runn.stack = [ ["world"] ]
+      end
+
+      it 'calls the event interface' do
+        runn.op_event(:hello)
+        observed_events.include?(an_event).should be_true
+      end
+
+      it 'can take the event kind from the stack' do
+        runn.op_push :hello
+        runn.op_event
+        observed_events.include?(an_event).should be_true
+      end
+
+    end
+  end
+end

data/spec/unit/kernel/opcodes/test_op_fetch.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_fetch" do
+
+      before do
+        @parent = list.save Prog.new
+        @child  = list.save Prog.new
+        @at1    = list.fetch(@child)
+      end
+
+      after do
+        runner.stack.should eq([ @at1 ])
+      end
+
+      it 'fetches the correct Prog with an arg' do
+        runner.op_fetch(@child)
+      end
+
+      it 'supports taking the puid from the stack' do
+        runner.stack = [ @child ]
+        runner.op_fetch
+      end
+
+    end
+  end
+end

data/spec/unit/kernel/opcodes/test_op_flip.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_flip" do
+
+      before do
+        runner.stack = [ 1, 2, 3 ]
+      end
+
+      it 'flips the two top elements' do
+        runner.op_flip
+        runner.stack.should eq([ 1, 3, 2 ])
+      end
+
+    end
+  end
+end

data/spec/unit/kernel/opcodes/test_op_fold.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_fold" do
+
+      before do
+        runner.stack = [ :a, :b, :c ]
+      end
+
+      it 'pushes an array with the specified number of elements' do
+        runner.op_fold(2)
+        runner.stack.should eq([:a, [:b, :c]])
+      end
+
+      it 'supports traking n from the stack' do
+        runner.op_push 2
+        runner.op_fold
+        runner.stack.should eq([:a, [:b, :c]])
+      end
+
+      it 'supports 0' do
+        runner.op_push 0
+        runner.op_fold
+        runner.stack.should eq([:a, :b, :c, []])
+      end
+
+    end
+  end
+end

data/spec/unit/kernel/opcodes/test_op_fork.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_fork" do
+
+      let(:runn){ runner(Prog.new :puid => 17, :root => 16) }
+
+      context 'with a label' do
+
+        before do
+          runn.stack = [ ]
+          runn.op_fork(:somewhere)
+        end
+
+        subject{
+          runn.stack.size.should eq(1)
+          runn.stack.last
+        }
+
+        it 'sets the resulting prog on the stack' do
+          subject.should be_a(Prog)
+        end
+
+        it 'is a child Prog' do
+          subject.parent.should eq(17)
+          subject.root.should eq(16)
+        end
+
+        it 'is scheduled' do
+          subject.waitfor.should eq(:enacter)
+        end
+
+        it 'has the correct program counter' do
+          subject.pc.should eq(:somewhere)
+        end
+
+        it 'is not registered yet' do
+          subject.puid.should be_nil
+        end
+
+      end # with a label
+
+      context 'without label' do
+
+        before do
+          runn.stack = [ :somewhere_else ]
+          runn.op_fork
+        end
+
+        subject{
+          runn.stack.size.should eq(1)
+          runn.stack.last
+        }
+
+        it 'takes the label from the stack' do
+          subject.pc.should eq(:somewhere_else)
+        end
+
+      end # without label
+
+    end
+  end
+end

data/spec/unit/kernel/opcodes/test_op_forka.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_fork" do
+
+      let(:runn){ runner(Prog.new :puid => 17) }
+
+      after do
+        top = runn.stack.last
+        top.should be_a(Array)
+        top.size.should eq(2)
+        top.each{|p| p.should be_a(Prog)}
+        top.each{|p|
+          p.parent.should eq(17)
+          p.waitfor.should eq(:enacter)
+          p.puid.should be_nil
+        }
+        top.map{|p| p.pc}.should eq([:s0, :s1])
+      end
+
+      context 'with an array of labels' do
+
+        subject do
+          runn.stack = [ ]
+          runn.op_forka([ :s0, :s1 ])
+        end
+
+        it 'puts the resulting array on the stack' do
+          subject
+          runn.stack.size.should eq(1)
+        end
+
+      end # with a label
+
+      context 'without argument' do
+
+        subject do
+          runn.stack = [ [:s0, :s1] ]
+          runn.op_forka
+        end
+
+        it 'takes the labels from the stack' do
+          subject
+          runn.stack.size.should eq(1)
+        end
+
+      end # without label
+
+    end
+  end
+end

data/spec/unit/kernel/opcodes/test_op_get.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_get" do
+
+      before do
+        runner.stack = [ receiver ]
+      end
+
+      after do
+        runner.stack.first.should eq(receiver)
+      end
+
+      context 'with a hash' do
+        let(:receiver){ {:hello => "World"} }
+
+        it 'pushes the result on the stack' do
+          runner.op_get(:hello)
+          runner.stack.last.should eq("World")
+        end
+
+        it 'takes the attribute name from the stack if unspecified' do
+          runner.op_push :hello
+          runner.op_get
+          runner.stack.last.should eq("World")
+        end
+
+        it 'supports getting nil' do
+          runner.op_get(:nosuchone)
+          runner.stack.last.should be_nil
+        end
+
+        it 'does not try to call methods' do
+          runner.op_get(:fetch)
+          runner.stack.last.should be_nil
+        end
+      end
+
+      context 'with an object' do
+        let(:receiver){ Prog.new(:pc => 12) }
+
+        it 'pushes the result on the stack' do
+          runner.op_get(:pc)
+          runner.stack.last.should eq(12)
+        end
+
+        it 'takes the attribute name from the stack if unspecified' do
+          runner.op_push :pc
+          runner.op_get
+          runner.stack.last.should eq(12)
+        end
+
+        it 'raises an Error if no such method' do
+          lambda{
+            runner.op_get(:nosuchone)
+          }.should raise_error(VM::Error)
+        end
+      end
+
+    end
+  end
+end