gisele-vm 0.6.0

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

@@ -0,0 +1,48 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_getr" do
+
+      before do
+        runner.stack = [ receiver ]
+      end
+
+      context 'with a hash' do
+        let(:receiver){ {:hello => "World"} }
+
+        it 'pushes the result on the stack and removes the receiver' do
+          runner.op_getr(:hello)
+          runner.stack.should eq(["World"])
+        end
+
+        it 'takes the attribute name from the stack if unspecified' do
+          runner.op_push :hello
+          runner.op_getr
+          runner.stack.should eq(["World"])
+        end
+      end
+
+      context 'with an object' do
+        let(:receiver){ Prog.new(:pc => 12) }
+
+        it 'pushes the result on the stack and removes the receiver' do
+          runner.op_getr(:pc)
+          runner.stack.should eq([12])
+        end
+
+        it 'takes the attribute name from the stack if unspecified' do
+          runner.op_push :pc
+          runner.op_getr
+          runner.stack.should eq([12])
+        end
+
+        it 'raises an Error if no such method' do
+          lambda{
+            runner.op_getr(:nosuchone)
+          }.should raise_error(VM::Error)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_ifenil" do
+
+      subject do
+        runner.opcodes = [ [:ifenil], [:push, 12], [:push, 24] ]
+        runner.run(nil, stack)
+        runner.stack
+      end
+
+      context 'when nil on the stack' do
+        let(:stack){ [ nil ] }
+
+        it 'skips the second op' do
+          subject.should eq([ nil, 12 ])
+        end
+
+      end
+
+      context 'when stack is empty' do
+        let(:stack){ [ ] }
+
+        it 'skips the second op' do
+          subject.should eq([ 12 ])
+        end
+
+      end
+
+      context 'when peek is not nil' do
+        let(:stack){ [ 56 ] }
+
+        it 'skips the first op' do
+          subject.should eq([ 56, 24 ])
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_ifezero" do
+
+      subject do
+        runner.opcodes = [ [:ifezero], [:push, 12], [:push, 24] ]
+        runner.run(nil, stack)
+        runner.stack
+      end
+
+      context 'when zero is on the stack' do
+        let(:stack){ [ 0 ] }
+
+        it 'skips the second op' do
+          subject.should eq([ 0, 12 ])
+        end
+
+      end
+
+      context 'when peek is not zero' do
+        let(:stack){ [ 56 ] }
+
+        it 'skips the first op' do
+          subject.should eq([ 56, 24 ])
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_invoke" do
+
+      def hello(*args)
+        @args = args
+      end
+
+      before do
+        runner.stack = [ self, [ "world", "!" ] ]
+      end
+
+      after do
+        @args.should eq(["world", "!"])
+      end
+
+      it 'invoke as expected' do
+        runner.op_invoke(:hello)
+      end
+
+      it 'does not push back on the stack' do
+        runner.op_invoke(:hello)
+        runner.stack.should eq([])
+      end
+
+      it 'takes the method name from the stack if unspecified' do
+        runner.op_push :hello
+        runner.op_invoke
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_nop" do
+
+      subject do
+        runner.op_nop
+        runner.stack
+      end
+
+      it 'does nothing' do
+        runner.stack = [ 12 ]
+        subject.should eq([ 12 ])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_parent" do
+
+      let(:runn){ runner(@child) }
+
+      context 'with a parent' do
+
+        before do
+          @parent = list.save Prog.new
+          @child  = list.save Prog.new(:parent => @parent)
+        end
+
+        it 'puts the parent of the current prog on the stack' do
+          runn.stack = [ ]
+          runn.op_parent
+          runn.stack.should eq([ list.fetch(@parent) ])
+        end
+
+      end
+
+      context 'without parent' do
+
+        before do
+          @child = list.save Prog.new
+        end
+
+        it 'puts the parent of the current prog on the stack' do
+          runn.stack = [ ]
+          runn.op_parent
+          runn.stack.should eq([ nil ])
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_pop" do
+
+      before do
+        runner.stack = [ 1, 2 ]
+      end
+
+      it 'fetches with the puid' do
+        runner.op_pop
+        runner.stack.should eq([ 1 ])
+      end
+
+      it 'allows specifying the number of pops to do' do
+        runner.op_pop(2)
+        runner.stack.should eq([ ])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_push" do
+
+      before do
+        runner.stack = [ 1 ]
+      end
+
+      it 'fetches with the puid' do
+        runner.op_push 'hello'
+        runner.stack.should eq([ 1, 'hello' ])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_save" do
+
+      before do
+        @puid0 = list.save Prog.new
+        @puid1 = list.save Prog.new
+        @at0 = list.fetch(@puid0)
+        @at1 = list.fetch(@puid1)
+        runner.stack = [ @at0, @at1 ]
+      end
+
+      it 'saves the prog on the top of the stack' do
+        runner.peek.pc = :s13
+        list.fetch(@puid1).pc.should eq(:main)
+        runner.op_save
+        list.fetch(@puid1).pc.should eq(:s13)
+        runner.stack.should eq([ @at0, @at1.puid ])
+      end
+
+      it 'allows specifying the number of progs to save' do
+        runner.stack.each_with_index{|prog,i| prog.pc = :"s#{i}"}
+        runner.op_save 2
+        list.fetch(@puid0).pc.should eq(:s0)
+        list.fetch(@puid1).pc.should eq(:s1)
+        runner.stack.should eq([ @at0.puid, @at1.puid ])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_save" do
+
+      before do
+        @puid0 = list.save Prog.new
+        @puid1 = list.save Prog.new
+        @at0 = list.fetch(@puid0)
+        @at1 = list.fetch(@puid1)
+        runner.stack = [ [ @at0, @at1 ] ]
+        runner.peek.each{|p| p.pc = :s18}
+      end
+
+      subject do
+        runner.op_savea
+      end
+
+      after do
+        top = runner.peek
+        top.each do |puid|
+          list.fetch(puid).pc.should eq(:s18)
+        end
+      end
+
+      it 'puts the saved puid back on the stack' do
+        subject
+        runner.stack.size.should eq(1)
+        runner.peek.should be_a(Array)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_self" do
+
+      let(:runn){ runner(@puid) }
+
+      before do
+        @puid = list.save Prog.new
+      end
+
+      it 'puts the current prog on the stack' do
+        runn.stack = [ ]
+        runn.op_self
+        runn.stack.should eq([ list.fetch(@puid) ])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_send" do
+
+      it 'pushes the result on the stack' do
+        runner.stack = [ 1, [ 2 ] ]
+        runner.op_send(:+)
+        runner.stack.should eq([ 3 ])
+      end
+
+      it 'takes the method name from the stack when unspecified' do
+        runner.stack = [ 1, [ 2 ], :+ ]
+        runner.op_send
+        runner.stack.should eq([ 3 ])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_set" do
+
+      after do
+        runner.stack.first.should eq(receiver)
+      end
+
+      context 'with a hash' do
+        let(:receiver){ {} }
+
+        before do
+          runner.stack = [ receiver, "World" ]
+        end
+
+        after do
+          runner.stack.last[:hello].should eq("World")
+        end
+
+        it 'sets the attribute under the specified key' do
+          runner.op_set(:hello)
+        end
+
+        it 'takes the attribute name from the stack if unspecified' do
+          runner.op_push :hello
+          runner.op_set
+        end
+      end
+
+      context 'with an object' do
+        let(:receiver){ Prog.new }
+
+        before do
+          runner.stack = [ receiver, 12 ]
+        end
+
+        after do
+          runner.stack.last.pc.should eq(12)
+        end
+
+        it 'sets the value under the attribute' do
+          runner.op_set(:pc)
+        end
+
+        it 'takes the attribute name from the stack if unspecified' do
+          runner.op_push :pc
+          runner.op_set
+        end
+
+        it 'raises an Error if no such method' do
+          lambda{
+            runner.op_set(:nosuchone)
+          }.should raise_error(VM::Error)
+          runner.stack.first.pc = 12                ## for after block
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_then" do
+
+      let(:bc){
+        Bytecode.coerce <<-BC.gsub(/^\s*/, '').strip
+          hello: push 12
+        BC
+      }
+      let(:runn){ runner(bc) }
+
+      before do
+        runn.opcodes  = [ [:nop] ]
+      end
+
+      after do
+        runn.opcodes.should eq([[:nop], [:push, 12]])
+        runn.stack.should eq([:prev])
+      end
+
+      context 'without argument' do
+
+        subject do
+          runn.op_then
+        end
+
+        it 'pushes opcodes on the code stack' do
+          runn.stack = [ :prev, :hello ]
+          subject
+        end
+
+      end # without argument
+
+      context 'without an argument' do
+
+        subject do
+          runn.op_then(:hello)
+        end
+
+        it 'pushes opcodes on the code stack' do
+          runn.stack = [ :prev ]
+          subject
+        end
+
+      end # with an argument
+
+    end
+  end
+end