nudge 0.0.2 → 0.1.0

data/spec/instructions/code/code_contains_q_spec.rb

@@ -0,0 +1,82 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeContainsQInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeContainsQInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeContainsQInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least two items on the :code stack" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should check to see if the second :code value is any point of the top item" do
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {do int_multiply}"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == true
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {do something_else}"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == false
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref x do int_multiply}"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == true
+        
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block { block{ref x} block {do int_multiply}}"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == true
+      end
+      
+      it "should compare the two :code values for equality if the top one isn't a list" do
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == true
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do nothing"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == false
+      end
+      
+      it "should return false if either item isn't parseable" do
+        @context.stacks[:code].push(ValuePoint.new("code", "some crap"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == false
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "some other crap"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == false
+        
+      end
+    end
+  end
+end

data/spec/instructions/code/code_define_spec.rb

@@ -0,0 +1,76 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeDefineInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeDefineInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeDefineInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least one item on the :name stack" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:name].push(ReferencePoint.new("a"))
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:code].push(ValuePoint.new("code", "block {}"))
+        lambda{@i1.preconditions?}.should_not raise_error
+        @context.stacks[:name].pop
+        lambda{@i1.preconditions?}.should raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should assign the top code item's parsed ProgramPoint in the name hash" do
+        @context.stacks[:name].push(ReferencePoint.new("a1"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {do it}"))
+        @context.names["a1"].should == nil
+        @i1.go
+        @context.stacks[:code].depth.should == 0
+        @context.stacks[:name].depth.should == 0
+        @context.names["a1"].should be_a_kind_of(CodeblockPoint)
+        @context.names["a1"].blueprint.should == "block {\n  do it}"
+      end
+      
+      it "should re-assign the binding if there already is one" do
+        @context.stacks[:name].push(ReferencePoint.new("b2"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do nothing"))
+        @context.names["b2"] = CodeblockPoint.new([])
+        @i1.go
+        @context.stacks[:code].depth.should == 0
+        @context.stacks[:name].depth.should == 0
+        @context.names["b2"].should be_a_kind_of(InstructionPoint)
+        @context.names["b2"].blueprint.should == "do nothing"
+      end
+      
+      it "should not work if the name is a variable (as opposed to a local)" do
+        @context.stacks[:name].push(ReferencePoint.new("c3"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {}"))
+        @context.variables["c3"] = CodeblockPoint.new([])
+        @i1.go
+        @context.stacks[:error].depth.should == 1
+      end
+      
+      it "should work for unparseable code values" do
+        @context.stacks[:name].push(ReferencePoint.new("c3"))
+        @context.stacks[:code].push(ValuePoint.new("code", "some random crap"))
+        @i1.go
+        @context.names["c3"].should == nil
+        @context.stacks[:error].depth.should == 1
+        @context.stacks[:error].peek.value.should include "code_define cannot parse"
+      end
+    end
+  end
+end

data/spec/instructions/code/code_discrepancy_spec.rb

@@ -0,0 +1,81 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeDiscrepancyInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeDiscrepancyInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = CodeDiscrepancyInstruction.new(@context)
+      @context.reset
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there is at least two :code items" do
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:code].push(ValuePoint.new("code", "foo"))
+        @context.stacks[:code].push(ValuePoint.new("code", "foo"))
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.reset
+      end
+      
+      it "should calculate the summed absolute difference in counts of all points in both programs" do
+        @context.stacks[:code].push(ValuePoint.new("code", "ref x"))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref y"))
+        @i1.go
+        @context.stacks[:int].peek.value.should == 2
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref y}"))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref y"))
+        @i1.go
+        @context.stacks[:int].peek.value.should == 1
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do x"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do x"))
+        @i1.go
+        @context.stacks[:int].peek.value.should == 0
+      end
+      
+      it "should sum occurrences of different items, not just unique parts" do
+        @context.stacks[:code].push(ValuePoint.new("code", "block {do x do x do x do x}"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {do y}"))
+        @i1.go
+        @context.stacks[:int].peek.value.should == 7
+      end
+      
+      it "should work as you would expect for NilPoint (unparseable) programs" do
+        @context.stacks[:code].push(ValuePoint.new("code", "some weird crap"))
+        @context.stacks[:code].push(ValuePoint.new("code", "nothing here either"))
+        @i1.go
+        @context.stacks[:int].peek.value.should == 0
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do real_program_stuff"))
+        @context.stacks[:code].push(ValuePoint.new("code", "refx")) # unparseable
+        @i1.go
+        @context.stacks[:int].peek.value.should == 1
+      end
+      
+      it "should not depend on typographic differences" do
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref y value «int» \n«int» 91}"))
+        @context.stacks[:code].push(ValuePoint.new("code",
+          "block   {\n  ref  y \tvalue    «int» \n\n«int»  \t91}"))
+        @i1.go
+        @context.stacks[:int].peek.value.should == 0
+      end
+    end
+  end
+end

data/spec/instructions/code/code_do_count_spec.rb

@@ -0,0 +1,83 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeDoCountInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeDoCountInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = CodeDoCountInstruction.new(@context)
+      @context.reset
+      @context.enable(CodeDoCountInstruction)
+      @context.enable(ExecDoRangeInstruction)
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there is one :int and 1 :code item" do
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:int].push(ValuePoint.new("int", 4))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref b1"))
+        @i1.preconditions?.should == true
+      end
+      
+      it "should check that the @context knows about exec_do_range" do
+        @context.disable(ExecDoRangeInstruction)
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref b1"))
+        lambda{@i1.preconditions?}.should raise_error
+        @context.enable(ExecDoRangeInstruction)
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.reset
+        @context.enable(CodeDoCountInstruction)
+        @context.enable(ExecDoRangeInstruction)
+      end
+      
+      it "should create an :error entry if the int is negative or zero" do
+        @context.stacks[:int].push(ValuePoint.new("int", -9182))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref b2"))
+        @i1.go
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 0
+        @context.stacks[:error].peek.value.should == "code_do_count needs a positive argument"
+        
+        @context.reset
+        @context.stacks[:int].push(ValuePoint.new("int", 0))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref b3"))
+        @i1.go
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 0
+        @context.stacks[:error].peek.value.should == "code_do_count needs a positive argument"
+      end
+      
+      it "should push a 0 onto :int, and an exec_do_range block onto :exec" do
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref b4"))
+        @i1.go
+        
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 1
+        @context.stacks[:exec].entries[0].blueprint.should ==
+          "block {\n  value «int»\n  value «int»\n  do exec_do_range\n  ref b4} \n«int» 0\n«int» 2"
+          
+        @context.run
+        @context.stacks[:int].depth.should == 3
+        @context.stacks[:exec].depth.should == 0
+        @context.stacks[:name].depth.should == 3
+      end
+    end
+  end
+end

data/spec/instructions/code/code_do_range_spec.rb

@@ -0,0 +1,113 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeDoRangeInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeDoRangeInstruction.new(@context)
+  end
+    
+  describe "\#go" do
+    before(:each) do
+      @i1 = CodeDoRangeInstruction.new(@context)
+      @context.reset("block {}")
+      @context.enable(CodeDoRangeInstruction)
+      @context.enable(ExecDoRangeInstruction)
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there are two :ints and at least one :code item" do
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref x1"))
+        @i1.preconditions?.should == true
+      end
+      
+      it "should check that the ExecDoRangeInstruction is enabled" do
+        @context.disable(ExecDoRangeInstruction)
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref x1"))
+        lambda{@i1.preconditions?}.should raise_error
+        @context.enable(ExecDoRangeInstruction)
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.reset
+      end
+      
+      it "should finish if the :ints are identical, pushing an :int and a copy of the codeblock" do
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref x1"))
+        @i1.go
+        @context.stacks[:int].depth.should == 1
+        @context.stacks[:int].peek.value.should == 3
+        @context.stacks[:exec].depth.should == 1
+        @context.stacks[:exec].peek.blueprint.should == "ref x1"
+      end
+      
+      it "should increment the counter if the counter < destination, and push a bunch of stuff" do
+        @context.stacks[:int].push(ValuePoint.new("int", 1))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref x2"))
+        @i1.go
+        
+        @context.stacks[:int].depth.should == 1
+        @context.stacks[:int].peek.value.should == 1
+        @context.stacks[:exec].depth.should == 2
+        @context.stacks[:exec].entries[1].blueprint.should == "ref x2"
+        @context.stacks[:exec].entries[0].blueprint.should == "block {\n  value «int»\n  value «int»\n  do exec_do_range\n  ref x2} \n«int» 2\n«int» 3"
+        
+        @context.run # get 'er done
+        
+        @context.stacks[:int].depth.should == 3
+        @context.stacks[:int].peek.value.should == 3
+        @context.stacks[:exec].depth.should == 0
+        @context.stacks[:name].depth.should == 3
+      end
+      
+      it "should decrement the counter if the counter > destination, and push a bunch of stuff" do
+        @context.stacks[:int].push(ValuePoint.new("int", 2))
+        @context.stacks[:int].push(ValuePoint.new("int", -12))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref x3"))
+        @i1.go
+        
+        @context.stacks[:int].depth.should == 1
+        @context.stacks[:int].peek.value.should == 2
+        @context.stacks[:exec].depth.should == 2
+        @context.stacks[:exec].entries[1].blueprint.should == "ref x3"
+        @context.stacks[:exec].entries[0].blueprint.should == "block {\n  value «int»\n  value «int»\n  do exec_do_range\n  ref x3} \n«int» 1\n«int» -12"
+        
+        @context.run # get 'er done
+        
+        @context.stacks[:int].depth.should == 15
+        @context.stacks[:int].peek.value.should == -12
+        
+        @context.stacks[:exec].depth.should == 0
+        @context.stacks[:name].depth.should == 15
+        (@context.stacks[:name].entries.collect {|e| e.value}).uniq.should == ["x3"]
+      end
+      
+      it "should 'continue' until counter and destination are the same value" do
+        @context.stacks[:int].push(ValuePoint.new("int", 1))
+        @context.stacks[:int].push(ValuePoint.new("int", 100))
+        @context.stacks[:code].push(ValuePoint.new("code", "value «float» \n«float» 1.1"))
+        
+        @i1.go
+        @context.run # finish it off
+        @context.stacks[:int].depth.should == 100
+        @context.stacks[:exec].depth.should == 0
+        @context.stacks[:float].depth.should == 100
+      end
+    end
+  end
+end

data/spec/instructions/code/code_do_times_spec.rb

@@ -0,0 +1,116 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeDoTimesInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeDoTimesInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = CodeDoTimesInstruction.new(@context)
+      @context.reset
+      @context.enable(CodeDoTimesInstruction)
+      @context.enable(ExecDoTimesInstruction)
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there are two :ints and at least one :code item" do
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:code].push(ValuePoint.new("code", "do nothing_now"))
+        @i1.preconditions?.should == true
+      end
+      
+      it "should check that ExecDoTimesInstruction is enabled" do
+        @context.disable(ExecDoTimesInstruction)
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:code].push(ValuePoint.new("code", "do nothing_now"))
+        lambda{@i1.preconditions?}.should raise_error
+        @context.enable(ExecDoTimesInstruction)
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.reset
+      end
+      
+      it "should finish if the :ints are identical, leaving only a copy of the codeblock" do
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:code].push(ValuePoint.new("code", "do nothing_now"))
+        
+        @i1.go
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 1
+        @context.stacks[:exec].peek.blueprint.should == "do nothing_now"
+      end
+      
+      it "should increment the counter if the counter < destination, and push a bunch of stuff" do
+        @context.stacks[:int].push(ValuePoint.new("int", 7))
+        @context.stacks[:int].push(ValuePoint.new("int", 9))
+        @context.stacks[:code].push(ValuePoint.new("code", "do nothing_now"))
+        @i1.go
+        
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 2
+        @context.stacks[:exec].entries[1].blueprint.should == "do nothing_now"
+        @context.stacks[:exec].entries[0].blueprint.should ==
+          "block {\n  value «int»\n  value «int»\n  do exec_do_times\n  do nothing_now} \n«int» 8\n«int» 9"
+      end
+      
+      it "should run the number of times specified" do
+        @context.stacks[:int].push(ValuePoint.new("int", 7))
+        @context.stacks[:int].push(ValuePoint.new("int", 9))
+        @context.stacks[:code].push(ValuePoint.new("code", "do nothing_now"))
+        @i1.go
+        @context.run
+        
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 0
+        @context.stacks[:error].depth.should == 3
+        @context.stacks[:error].peek.value.should include("NothingNowInstruction is not")
+      end
+      
+      it "should decrement the counter if the counter > destination, and push a bunch of stuff" do
+        @context.stacks[:code].push(ValuePoint.new("code","value «float»\n«float» 0.1"))
+        @context.stacks[:int].push(ValuePoint.new("int", -11))
+        @context.stacks[:int].push(ValuePoint.new("int", -19))
+        @i1.go
+        
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 2
+        @context.stacks[:exec].entries[0].blueprint.should include "\n«int» -12\n«int» -19\n«float» 0.1"
+        
+        @context.run
+
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 0
+        @context.stacks[:float].depth.should == 9
+        @context.stacks[:float].peek.value.should == 0.1
+      end
+      
+      it "should 'continue' until counter and destination are the same value" do
+        @context.stacks[:int].push(ValuePoint.new("int", 11001))
+        @context.stacks[:int].push(ValuePoint.new("int", 11100))
+        @context.stacks[:code].push(ValuePoint.new("code","value «float»\n«float» 0.9"))
+        @i1.go
+        @context.run # finish it off
+        @context.stacks[:float].depth.should == 100
+        @context.stacks[:exec].depth.should == 0
+      end
+    end
+  end
+end

data/spec/instructions/code/code_equal_q_spec.rb

@@ -0,0 +1,49 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+describe CodeEqualQInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeEqualQInstruction.new(@context)
+  end
+  
+  
+  it "should check that there are enough parameters" do
+    thing1 = ValuePoint.new("code", "block {ref x}")
+    @context.stacks[:code].push thing1
+    @context.stacks[:code].push thing1
+    @i1.preconditions?.should == true
+  end
+  
+  it "should raise an error if the preconditions aren't met" do
+    @context.clear_stacks # there are no params at all
+    lambda{@i1.preconditions?}.should raise_error(Instruction::NotEnoughStackItems)
+  end
+  
+  it "should push the correct result to the :bool stack" do
+    thing1 = ValuePoint.new("code", "ref x")
+    thing2 = ValuePoint.new("code", "block {ref x}")
+    @context.stacks[:code].push thing1
+    @context.stacks[:code].push thing1
+    @i1.go
+    @context.stacks[:bool].peek.value.should == true
+    
+    @context.stacks[:code].push thing1
+    @context.stacks[:code].push thing2
+    @i1.go
+    @context.stacks[:bool].peek.value.should == false
+  end
+  
+  it "should not depend on the values, but the tidied program blueprints of the :code items" do
+    thing1 = ValuePoint.new("code", "block { value «int» ref a}\n«int» 9182")
+    thing2 = ValuePoint.new("code", "block {\nvalue   «int» ref \na  }\n«int»\t9182\n")
+    @context.stacks[:code].push thing1
+    @context.stacks[:code].push thing2
+    @i1.go
+    @context.stacks[:bool].peek.value.should == true
+  end
+end

data/spec/instructions/code/code_execute_spec.rb

@@ -0,0 +1,52 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeExecuteInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeExecuteInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeExecuteInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least one item on the :code stack" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should push a ProgramPoint based on the code from the top of the :code stack" do
+        @context.stacks[:code].push(ValuePoint.new("code", "do foo_bar"))
+        @i1.go
+        @context.stacks[:exec].peek.blueprint.should == "do foo_bar"
+        @context.stacks[:exec].peek.should be_a_kind_of(InstructionPoint)
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref x}"))
+        @i1.go
+        @context.stacks[:exec].peek.blueprint.should == "block {\n  ref x}"
+        @context.stacks[:exec].peek.should be_a_kind_of(CodeblockPoint)
+        
+      end
+      
+      it "push an empty block {} if the code point can't be parsed" do
+        @context.stacks[:code].push(ValuePoint.new("code", "whatever you say boss"))
+        @i1.go
+        @context.stacks[:exec].peek.blueprint.should == "block {}"
+      end
+    end
+  end
+end