gisele-vm 0.6.0

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_unfold" do
+
+      it 'unfolds the op array' do
+        runner.stack = [ :a, [:b, :c] ]
+        runner.op_unfold
+        runner.stack.should eq([:a, :b, :c])
+      end
+
+      it 'is the reverse of fold' do
+        runner.stack = [:a, [:b, :c] ]
+        runner.op_unfold
+        runner.stack.should eq([:a, :b, :c])
+        runner.op_fold(2)
+        runner.stack.should eq([:a, [:b, :c]])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Kernel, "op_puid" do
+
+      let(:runn){ runner(Prog.new :puid => 17) }
+
+      it 'pushes the puid on top of the stack' do
+        runn.stack = [:hello]
+        runn.op_puid
+        runn.stack.should eq([:hello, 17])
+      end
+
+    end
+  end
+end

data/spec/unit/kernel/runner/test_pop.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    class Kernel
+      describe Runner, 'pop' do
+
+        before do
+          runner.stack = [:a, :b, :c, :d]
+        end
+
+        it 'returns the poped object when n is not specified' do
+          runner.pop.should eq(:d)
+          runner.pop.should eq(:c)
+          runner.stack.should eq([:a, :b])
+        end
+
+        it 'returns the poped objects when n is specified' do
+          runner.pop(0).should eq([])
+          runner.pop(2).should eq([:d, :c])
+          runner.pop(1).should eq([:b])
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/kernel/runner/test_stack.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    class Kernel
+      describe Runner, "stack" do
+
+        it 'pushes at the end' do
+          runner.stack = [:hello]
+          runner.push :world
+          runner.stack.should eq([:hello, :world])
+        end
+
+        it 'pops from the end' do
+          runner.stack = [:hello, :world]
+          runner.pop.should eq(:world)
+          runner.stack.should eq([:hello])
+        end
+
+        it 'peeks at the the end' do
+          runner.stack = [:hello, :world]
+          runner.peek.should eq(:world)
+          runner.stack.should eq([:hello, :world])
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/kernel/test_progress.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+module Gisele
+  describe VM, "progress" do
+
+    subject do
+      kernel.progress(arg)
+    end
+
+    before do
+      @puid = kernel.start(:ping, [ "world" ])
+    end
+
+    context 'with a puid' do
+      let(:arg){ @puid }
+      it 'executes the Prog with its input' do
+        subject
+        prog           = list.fetch(@puid)
+        expected_event = VM::Event.new(prog, :pong, [ "world" ])
+        observed_events.should eq([ expected_event ])
+        list.fetch(@puid).input.should eq([])
+      end
+    end
+
+    context 'with a prog' do
+      let(:arg){ list.fetch(@puid) }
+      it 'executes the Prog with its input' do
+        subject
+        observed_events.should eq([ VM::Event.new(arg, :pong, [ "world" ]) ])
+        list.fetch(@puid).input.should eq([])
+      end
+    end
+
+    it 'detects invalid puids' do
+      lambda{
+        kernel.progress(17)
+      }.should raise_error(VM::InvalidPUIDError, "Invalid puid: `17`")
+    end
+
+    it 'detects progs that do not wait for the enacter' do
+      list.save(VM::Prog.new :puid => @puid, :waitfor => :world)
+      lambda{
+        kernel.progress(@puid)
+      }.should raise_error(VM::InvalidStateError, "Prog `#{@puid}` does not wait for the enacter")
+    end
+
+  end
+end

data/spec/unit/kernel/test_resume.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Gisele
+  describe VM, "resume" do
+
+    subject do
+      kernel.resume(arg, [ :an_event ])
+    end
+
+    before do
+      @puid = list.save VM::Prog.new(:pc => :hello, :waitfor => :world)
+    end
+
+    let(:expected){
+      Relation(:puid => @puid, :waitfor => :enacter, :input => [ :an_event ])
+    }
+
+    context 'with a puid' do
+      let(:arg){ @puid }
+      it 'creates a fresh new Prog instance and schedules it' do
+        subject
+        list.to_relation.project([:puid, :waitfor, :input]).should eq(expected)
+      end
+    end
+
+    context 'with a Prog' do
+      let(:arg){ list.fetch(@puid) }
+      it 'creates a fresh new Prog instance and schedules it' do
+        subject
+        list.to_relation.project([:puid, :waitfor, :input]).should eq(expected)
+      end
+    end
+
+    it 'detects invalid puids' do
+      lambda{
+        kernel.resume(17, [])
+      }.should raise_error(VM::InvalidPUIDError, "Invalid puid: `17`")
+    end
+
+    it 'detects invalid inputs' do
+      lambda{
+        kernel.resume(@puid, 12)
+      }.should raise_error(VM::InvalidInputError, "Invalid VM input: `12`")
+    end
+
+    it 'detects progs that do not wait for the world' do
+      list.save(VM::Prog.new :puid => @puid, :waitfor => :enacter)
+      lambda{
+        kernel.resume(@puid, [])
+      }.should raise_error(VM::InvalidStateError, "Prog `#{@puid}` does not wait for the world")
+    end
+
+  end
+end

data/spec/unit/kernel/test_start.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Gisele
+  describe VM, "start" do
+
+    subject do
+      kernel.start(:ping, [ 12 ])
+    end
+
+    before do
+      subject
+    end
+
+    it 'returns a puid' do
+      list.fetch(subject).should be_a(VM::Prog)
+      list.fetch(subject).pc.should eq(:ping)
+    end
+
+    it 'creates a fresh new Prog instance and schedules it' do
+      expected = Relation(:pc => :ping, :waitfor => :enacter, :input => [ 12 ])
+      list.to_relation.project([:pc, :waitfor, :input]).should eq(expected)
+    end
+
+    it 'detects invalid labels' do
+      lambda{
+        kernel.start(:nosuchone, [])
+      }.should raise_error(VM::InvalidLabelError, "Unknown label: `:nosuchone`")
+    end
+
+    it 'detects invalid inputs' do
+      lambda{
+        kernel.start(:ping, 12)
+      }.should raise_error(VM::InvalidInputError, "Invalid VM input: `12`")
+    end
+
+  end
+end

data/spec/unit/prog/test_to_hash.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Prog, 'to_hash' do
+
+      let(:h){ {:puid => 17, :parent => 16, :root => 8} }
+      let(:prog){ Prog.new(h) }
+
+      context 'without argument' do
+        subject do
+          prog.to_hash
+        end
+        it 'returns the whole hash' do
+          subject.size.should eq(7)
+        end
+      end
+
+      context 'with some keys only' do
+        subject do
+          prog.to_hash([:puid, :parent, :root])
+        end
+        it 'returns a projection' do
+          subject.should eq(h)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/prog/test_waitlist_eq.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Prog, 'waitlist=' do
+
+      let(:prog){ Prog.new }
+
+      it 'sets the waitlist when a Hash' do
+        prog.waitlist = {:event => :label}
+        prog.waitlist.should eq({:event => :label})
+      end
+
+      it 'coerces the waitlist when an Array' do
+        prog.waitlist = [12, 13]
+        prog.waitlist.should eq({12 => true, 13 => true})
+      end
+
+    end
+  end
+end

data/spec/unit/prog_list/memory/test_component.rb

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

data/spec/unit/prog_list/memory/test_fetch.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+class Gisele::VM
+  describe ProgList::Memory, 'fetch' do
+    let(:list){ ProgList::Memory.new }
+
+    before do
+      @puid = list.save(Prog.new)
+    end
+
+    it 'returns Progs' do
+      list.fetch(@puid).should be_a(Prog)
+    end
+
+    it 'returns the correct Prog' do
+      list.fetch(@puid).puid.should eq(@puid)
+    end
+
+    it 'distributes copies, not original Progs' do
+      list.fetch(@puid).pc = :newpc
+      list.fetch(@puid).pc.should eq(:main)
+    end
+
+    it 'allows passing strings' do
+      list.fetch(@puid.to_s).should be_a(Prog)
+    end
+
+    it 'raises an ArgumentError if arg is not an PUID' do
+      lambda{
+        list.fetch(:blih)
+      }.should raise_error(InvalidPUIDError, "Invalid puid: `:blih`")
+    end
+
+    it 'raises an InvalidPUIDError if arg is invalid' do
+      lambda{
+        list.fetch(12)
+      }.should raise_error(InvalidPUIDError, "Invalid puid: `12`")
+    end
+
+  end
+end

data/spec/unit/prog_list/memory/test_pick.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+class Gisele::VM
+  describe ProgList::Memory, 'pick' do
+    let(:list){ ProgList::Memory.new }
+
+    context 'when a matching Prog exists' do
+
+      before do
+        @puid0 = list.save(Prog.new(:waitfor => :world))
+        @puid1 = list.save(Prog.new(:waitfor => :enacter))
+      end
+
+      it 'returns a Prog' do
+        list.pick(:waitfor => :enacter).should be_a(Prog)
+      end
+
+      it 'returns a scheduled Prog' do
+        list.pick(:waitfor => :enacter).waitfor.should eq(:enacter)
+      end
+
+    end
+
+    context 'when no matching Prog exists' do
+
+      before do
+        @puid0 = list.save(Prog.new(:waitfor => :world))
+        @puid1 = list.save(Prog.new(:waitfor => :world))
+      end
+
+      it 'calls the block and returns nil' do
+        called = false
+        list.pick(:waitfor => :enacter){ called = true }.should be_nil
+        called.should be_true
+      end
+
+    end
+
+  end
+end

data/spec/unit/prog_list/memory/test_save.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+class Gisele::VM
+  describe ProgList::Memory, 'save' do
+
+    context 'when arg is an existing Prog' do
+      let(:puid){ @puid }
+      let(:list){ ProgList::Memory.new }
+
+      before do
+        @puid = list.save(Prog.new :pc => :main)
+      end
+
+      it 'returns the puid' do
+        list.save(list.fetch(puid)).should eq(puid)
+      end
+
+      it 'saves the prog for real' do
+        list.fetch(puid).pc.should eq(:main)
+
+        # update it
+        prog = list.fetch(puid)
+        prog.pc = 12
+
+        # the original have not changed
+        list.fetch(puid).pc.should eq(:main)
+
+        # save and check
+        list.save(prog)
+        list.fetch(puid).pc.should eq(12)
+      end
+
+      it 'makes a dup when saving' do
+        prog = list.fetch(puid)
+        prog.pc = 12
+        list.save(prog)
+        prog.pc = 23
+        list.fetch(puid).pc.should eq(12)
+      end
+
+    end # PUID
+
+    context 'when arg is a fresh new Prog' do
+      let(:puid){ nil }
+      let(:list){ ProgList::Memory.new }
+
+      it 'sets a fresh new puid' do
+        puid = list.save(Prog.new)
+        puid.should_not be_nil
+        list.fetch(puid).puid.should eq(puid)
+        list.fetch(puid).parent.should eq(puid)
+        list.fetch(puid).root.should eq(puid)
+      end
+
+      it 'accepts a valid parent' do
+        parent = list.save(Prog.new)
+        child  = list.save(Prog.new(:parent => parent))
+        list.fetch(child).parent.should eq(parent)
+      end
+    end
+
+    context 'when arg is an array of Progs' do
+      let(:list){ ProgList::Memory.new }
+
+      subject do
+        list.save([ Prog.new, Prog.new ])
+      end
+
+      it 'returns a list of puids' do
+        subject.should be_a(Array)
+      end
+
+      it 'returns valid puids' do
+        subject.each{|p| list.fetch(p).should be_a(Prog)}
+      end
+
+    end
+
+    it 'raises an ArgumentError if arg is not recognized' do
+      lambda{
+        ProgList::Memory.new.save(self)
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'raises an InvalidPUIDError if arg is invalid' do
+      lambda{
+        ProgList::Memory.new.save(Prog.new(:puid => 12))
+      }.should raise_error(InvalidPUIDError)
+    end
+
+  end
+end