nudge 0.0.2 → 0.1.0

data/push_language_coverage.md

@@ -1,177 +0,0 @@
-INTEGER instructions
-
-INTEGER.%:           IntModuloInstruction
-INTEGER.*:           IntMultiplyInstruction
-INTEGER.+:           IntAddInstruction
-INTEGER.-:           IntSubtractInstruction
-INTEGER./:           IntDivideInstruction
-INTEGER.<:           IntLessThanQInstruction
-INTEGER.=:           IntEqualQInstruction
-INTEGER.>:           IntGreaterThanQInstruction
-INTEGER.DEFINE:      IntDefineInstruction
-INTEGER.DUP:         IntDuplicateInstruction
-INTEGER.FLUSH:       IntFlushInstruction
-INTEGER.FROMBOOLEAN: IntFromBoolInstruction
-INTEGER.FROMFLOAT:   IntFromFloatInstruction
-INTEGER.MAX:         IntMaxInstruction
-INTEGER.MIN:         IntMinInstruction
-INTEGER.POP:         IntPopInstruction
-INTEGER.RAND:        IntRandomInstruction
-INTEGER.ROT:         IntRotateInstruction
-INTEGER.SHOVE:       IntShoveInstruction
-INTEGER.STACKDEPTH:  IntDepthInstruction
-INTEGER.SWAP:        IntSwapInstruction
-INTEGER.YANK:        IntYankInstruction
-INTEGER.YANKDUP:     IntYankdupInstruction
-
-                     IntAbsInstruction
-                     IntIfInstruction
-                     IntNegativeInstruction
-
-FLOAT instructions
-
-FLOAT.%:             FloatModuloInstruction
-FLOAT.*:             FloatMultiplyInstruction
-FLOAT.+:             FloatAddInstruction
-FLOAT.-:             FloatSubtractInstruction
-FLOAT./:             FloatDivideInstruction
-FLOAT.<:             FloatLessThanQInstruction
-FLOAT.=:             FloatEqualQInstruction
-FLOAT.>:             FloatGreaterThanQInstruction
-FLOAT.COS:           FloatCosineInstruction
-FLOAT.DEFINE:        FloatDefineInstruction
-FLOAT.DUP:           FloatDuplicateInstruction
-FLOAT.FLUSH:         FloatFlushInstruction
-FLOAT.FROMBOOLEAN:   FloatFromBoolInstruction
-FLOAT.FROMINTEGER:   FloatFromIntInstruction
-FLOAT.MAX:           FloatMaxInstruction
-FLOAT.MIN:           FloatMinInstruction
-FLOAT.POP:           FloatPopInstruction
-FLOAT.RAND:          FloatRandomInstruction
-FLOAT.ROT:           FloatRotateInstruction
-FLOAT.SHOVE:         FloatShoveInstruction
-FLOAT.SIN:           FloatSineInstruction
-FLOAT.STACKDEPTH:    FloatDepthInstruction
-FLOAT.SWAP:          FloatSwapInstruction
-FLOAT.TAN:           FloatTangentInstruction
-FLOAT.YANK:          FloatYankInstruction
-FLOAT.YANKDUP:       FloatYankdupInstruction
-                     
-                     FloatAbsInstruction
-                     FloatIfInstruction
-                     FloatNegativeInstruction
-                     FloatPowerInstruction
-                     FloatSqrtInstruction
-
-BOOLEAN instructions
-
-BOOLEAN.=:           BoolEqualQInstruction
-BOOLEAN.AND:         BoolAndInstruction
-BOOLEAN.DEFINE:      BoolDefineInstruction
-BOOLEAN.DUP:         BoolDuplicateInstruction
-BOOLEAN.FLUSH:       BoolFlushInstruction
-BOOLEAN.FROMFLOAT:   BoolFromFloatInstruction
-BOOLEAN.FROMINTEGER: BoolFromIntInstruction
-BOOLEAN.NOT:         BoolNotInstruction
-BOOLEAN.OR:          BoolOrInstruction
-BOOLEAN.POP:         BoolPopInstruction
-BOOLEAN.RAND:        BoolRandomInstruction
-BOOLEAN.ROT:         BoolRotateInstruction
-BOOLEAN.SHOVE:       BoolShoveInstruction
-BOOLEAN.STACKDEPTH:  BoolDepthInstruction
-BOOLEAN.SWAP:        BoolSwapInstruction
-BOOLEAN.YANK:        BoolYankInstruction
-BOOLEAN.YANKDUP:     BoolYankdupInstruction
-
-                     BoolXorInstruction
-
-
-
-NAME instructions
-
-NAME.=:              NameEqualQInstruction
-NAME.DUP:            NameDupInstruction
-NAME.FLUSH:          NameFlushInstruction
-NAME.POP:            NamePopInstruction
-NAME.QUOTE:          NameDisableLookupInstruction
-NAME.RAND:           NameNextInstruction
-NAME.RANDBOUNDNAME:  NameRandomBoundInstruction
-NAME.ROT:            NameRotInstruction
-NAME.SHOVE:          NameShoveInstruction
-NAME.STACKDEPTH:     NameDepthInstruction
-NAME.SWAP:           NameSwapInstruction
-NAME.YANK:           NameYankInstruction
-NAME.YANKDUP:        NameYankdupInstruction
-
-
-
-EXEC instructions
-
-EXEC.=:              ExecEqualQInstruction
-EXEC.DEFINE:         ExecDefineInstruction
-EXEC.DO*COUNT:       ExecDoCountInstruction
-EXEC.DO*RANGE:       ExecDoRangeInstruction
-EXEC.DO*TIMES:       ExecDoTimesInstruction
-EXEC.DUP:            ExecDuplicateInstruction
-EXEC.FLUSH:          ExecFlushInstruction
-EXEC.IF:             ExecIfInstruction
-EXEC.K:              ExecKInstruction
-EXEC.POP:            ExecPopInstruction
-EXEC.ROT:            ExecRotateInstruction
-EXEC.S:              ExecSInstruction
-EXEC.SHOVE:          ExecShoveInstruction
-EXEC.STACKDEPTH:     ExecDepthInstruction
-EXEC.SWAP:           ExecSwapInstruction
-EXEC.Y:              ExecYInstruction
-EXEC.YANK:           ExecYankInstruction
-EXEC.YANKDUP:        ExecYankdupInstruction
-
-
-
-CODE instructions
-
-CODE.=: 
-CODE.APPEND: 
-CODE.ATOM: 
-CODE.CAR: 
-CODE.CDR: 
-CODE.CONS: 
-CODE.CONTAINER: 
-CODE.CONTAINS: 
-CODE.DEFINE: 
-CODE.DEFINITION: 
-CODE.DISCREPANCY: 
-CODE.DO: 
-CODE.DO*: 
-CODE.DO*COUNT:
-CODE.DO*RANGE: 
-CODE.DO*TIMES: 
-CODE.DUP:            CodeDuplicateInstruction
-CODE.EXTRACT: 
-CODE.FLUSH:          CodeFlushInstruction
-CODE.FROMBOOLEAN: 
-CODE.FROMFLOAT: 
-CODE.FROMINTEGER: 
-CODE.FROMNAME: 
-CODE.IF: 
-CODE.INSERT: 
-CODE.INSTRUCTIONS: 
-CODE.LENGTH: 
-CODE.LIST: 
-CODE.MEMBER: 
-CODE.NOOP:           CodeNoopInstruction
-CODE.NTH: 
-CODE.NTHCDR: 
-CODE.NULL: 
-CODE.POP:            CodePopInstruction
-CODE.POSITION: 
-CODE.QUOTE: 
-CODE.RAND: 
-CODE.ROT:            CodeRotateInstruction
-CODE.SHOVE:          CodeShoveInstruction
-CODE.SIZE: 
-CODE.STACKDEPTH:     CodeDepthInstruction
-CODE.SUBST: 
-CODE.SWAP:           CodeSwapInstruction
-CODE.YANK:           CodeYankInstruction
-CODE.YANKDUP:        CodeYankdupInstruction

data/script/console

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-# File: script/console
-irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-
-libs =  " -r irb/completion"
-# Perhaps use a console_lib to store any extra methods I may want available in the cosole
-# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
-libs <<  " -r #{File.dirname(__FILE__) + '/../lib/foobar.rb'}"
-puts "Loading foobar gem"
-exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-begin
-  require 'rubigen'
-rescue LoadError
-  require 'rubygems'
-  require 'rubigen'
-end
-require 'rubigen/scripts/destroy'
-
-ARGV.shift if ['--help', '-h'].include?(ARGV[0])
-RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
-RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-begin
-  require 'rubigen'
-rescue LoadError
-  require 'rubygems'
-  require 'rubigen'
-end
-require 'rubigen/scripts/generate'
-
-ARGV.shift if ['--help', '-h'].include?(ARGV[0])
-RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
-RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/data/couchdb_spec.rb

@@ -1,2 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-include Nudge

data/spec/instructions/bool_basics_spec.rb

@@ -1,97 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-include Nudge
-
-theseInstructions = [
-  BoolAndInstruction,
-  BoolNotInstruction,
-  BoolOrInstruction,
-  BoolXorInstruction,
-  BoolEqualQInstruction
-  ]
-  
-boolsTheyNeed = {
-  BoolAndInstruction => 2,
-  BoolNotInstruction => 1,
-  BoolOrInstruction => 2,
-  BoolEqualQInstruction => 2,
-  BoolXorInstruction => 2
-  }
-  
-resultTuples = {
-  BoolAndInstruction => {[true, true] => true, [true, false] => false, [false, false] => false},
-  BoolNotInstruction => {[true] => false, [false] => true},
-  BoolOrInstruction => {[true,true] => true, [true, false] => true, [false, false]=> false},
-  BoolEqualQInstruction => {[true,true] => true, [true, false] => false, [false, false]=> true},
-  BoolXorInstruction => {[true,true] => false, [true, false] => true, [false, true] => true, [false, false]=> false}
-  }
-  
-  
-  
-theseInstructions.each do |instName|
-  describe instName do
-    before(:each) do
-      @context = Interpreter.new
-      @i1 = instName.new(@context)
-    end
-    
-    it "should have its #context set to that Interpreter instance it's in" do
-      @i1.context.should == @context
-    end
-    
-    [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
-      it "should respond to \##{methodName}" do
-        @i1 = instName.new(@context)
-        @i1.should respond_to(methodName)
-      end   
-    end
-    
-    describe "\#go" do
-      before(:each) do
-        @i1 = instName.new(@context)
-        @bool1 = LiteralPoint.new("bool", false)
-      end
-
-      describe "\#preconditions?" do
-        it "should check that there are enough parameters" do
-          10.times {@context.stacks[:bool].push(@bool1)}
-          @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 successfully run #go only if all preconditions are met" do
-          5.times {@context.stacks[:bool].push(@bool1)}
-          @i1.should_receive(:cleanup)
-          @i1.go
-        end
-      end
-      
-      describe "\#derive" do
-        it "should pop all the arguments" do
-          reduction = boolsTheyNeed[instName]
-          reduction.times {@context.stacks[:bool].push(@bool1)}
-          @i1.stub!(:cleanup) # and do nothing
-          @i1.go
-          @context.stacks[:bool].depth.should == 0
-        end
-      end
-
-      describe "\#cleanup" do
-        describe "should push the result" do
-          examples = resultTuples[instName]
-          examples.each do |inputs, expected|
-            params = inputs.inspect
-            it "should produce #{expected} given #{params}" do
-              inputs.each {|i| @context.stacks[:bool].push(LiteralPoint.new("bool", i))}
-              @i1.go
-              @context.stacks[:bool].peek.value.should == expected
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/instructions/bool_stack_spec.rb

@@ -1,391 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-include Nudge
-
-theseInstructions = [
-  BoolPopInstruction,
-  BoolSwapInstruction,
-  BoolDuplicateInstruction,
-  BoolRotateInstruction
-  ]
-  
-boolsTheyNeed = {
-  BoolPopInstruction => 1,
-  BoolSwapInstruction => 2,
-  BoolDuplicateInstruction => 1,
-  BoolRotateInstruction => 3
-  }
-  
-resultTuples = {
-  BoolPopInstruction => {[false, true]=>[false]},
-  BoolSwapInstruction => {[false, true]=>[true, false]},
-  BoolDuplicateInstruction => {[true] => [true, true]},
-  BoolRotateInstruction => {[true, false, false] => [false, false, true]}
-  }
-    
-theseInstructions.each do |instName|
-  describe instName do
-    before(:each) do
-      @context = Interpreter.new
-      @i1 = instName.new(@context)
-    end
-    
-    it "should have its context right" do
-      @i1.context.should == @context
-    end
-    
-    [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
-      it "should respond to \##{methodName}" do
-        @i1 = instName.new(@context)
-        @i1.should respond_to(methodName)
-      end   
-    end
-    
-    describe "\#go" do
-      before(:each) do
-        @i1 = instName.new(@context)
-        @context.clear_stacks
-        @bool1 = LiteralPoint.new("bool", true)
-      end
-    
-      describe "\#preconditions?" do
-        it "should check that there are enough parameters" do
-          10.times {@context.stacks[:bool].push(@bool1)}
-          @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 successfully run #go only if all preconditions are met" do
-          5.times {@context.stacks[:bool].push(@bool1)}
-          @i1.should_receive(:cleanup)
-          @i1.go
-        end
-      end
-      
-      describe "\#cleanup" do
-        describe "should restructure the stack" do
-          examples = resultTuples[instName]
-          examples.each do |inputs, finalStackState|
-            params = inputs.inspect
-            expected = finalStackState.inspect
-            it "should end up with #{expected} on the \:bool stack, starting with #{params}" do
-              inputs.each {|i| @context.stacks[:bool].push(LiteralPoint.new("bool", i))}
-              @i1.go
-              finalStackState.reverse.each {|i| @context.stacks[:bool].pop.value.should == i}
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-
-describe BoolDepthInstruction do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = BoolDepthInstruction.new(@context)
-  end
-  
-  it "should have its context set" do
-    @i1.context.should == @context
-  end
-  
-  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
-    it "should respond to \##{methodName}" do
-      @i1.should respond_to(methodName)
-    end   
-  end
-  
-  describe "\#go" do
-    before(:each) do
-      @i1 = BoolDepthInstruction.new(@context)
-      @context.clear_stacks
-      @bool1 = LiteralPoint.new("bool", false)
-    end
-    
-    describe "\#preconditions?" do
-      it "should check that the :bool stack responds to #depth" do
-        @i1.preconditions?.should == true
-      end
-    end
-    
-    describe "\#cleanup" do
-      it "should count the items on the stack and push it onto the :int stack" do
-        @context.stacks[:int].depth.should == 0
-        @i1.go # there are no bools
-        @context.stacks[:int].peek.value.should == 0
-        7.times {@context.stacks[:bool].push @bool1}
-        @i1.go
-        @context.stacks[:int].peek.value.should == 7
-      end
-    end
-  end
-end
-
-
-describe BoolFlushInstruction do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = BoolFlushInstruction.new(@context)
-  end
-  
-  it "should have a context upon creation" do
-    @i1.context.should == @context
-  end
-  
-  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
-    it "should respond to \##{methodName}" do
-      @i1.should respond_to(methodName)
-    end   
-  end
-  
-  describe "\#go" do
-    before(:each) do
-      @i1 = BoolFlushInstruction.new(@context)
-      @context.clear_stacks
-      @bool1 = LiteralPoint.new("bool", true)
-    end
-    
-    describe "\#preconditions?" do
-      it "should check that the :bool stack responds to #depth" do
-        @i1.preconditions?.should == true
-      end
-    end
-    
-    describe "\#cleanup" do
-      it "should remove all items on the stack" do
-        11.times {@context.stacks[:bool].push(@bool1)}
-        @context.stacks[:bool].depth.should == 11
-        @i1.go
-        @context.stacks[:bool].depth.should == 0
-      end
-    end
-  end
-end
-
-
-
-describe BoolShoveInstruction do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = BoolShoveInstruction.new(@context)
-  end
-  
-  it "should check its context is set" do
-    @i1.context.should == @context
-  end
-  
-  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
-    it "should respond to \##{methodName}" do
-      @i1.should respond_to(methodName)
-    end   
-  end
-  
-  describe "\#go" do
-    before(:each) do
-      @i1 = BoolShoveInstruction.new(@context)
-      @context.clear_stacks
-      @bool1 = LiteralPoint.new("bool", true)
-    end
-    
-    describe "\#preconditions?" do
-      it "should check that there is one :int and at least one :bool" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 4))
-        @context.stacks[:bool].push(@bool1)
-        @i1.preconditions?.should == true
-      end
-    end
-    
-    describe "\#cleanup" do
-      before(:each) do
-        @context.clear_stacks
-        11.times {@context.stacks[:bool].push(@bool1)}
-        @context.stacks[:bool].push(LiteralPoint.new("bool", false)) # making it 12 deep
-      end
-      
-      it "should not move the top item if the integer is negative" do
-        @context.stacks[:int].push(LiteralPoint.new("int", -99))
-        @i1.go
-        @context.stacks[:bool].depth.should == 12
-        @context.stacks[:bool].peek.value.should == false
-      end
-      
-      it "should not move the top item if the integer is zero" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 0))
-        @i1.go
-        @context.stacks[:bool].depth.should == 12
-        @context.stacks[:bool].peek.value.should == false  
-      end
-      
-      it "should move the top item farther down if the value is less than the depth" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 1000))
-        @i1.go
-        @context.stacks[:bool].depth.should == 12
-        @context.stacks[:bool].entries[0].value.should == false
-      end
-      
-      it "should move the top item to the bottom if the value is more than the depth" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 4))
-        @i1.go
-        @context.stacks[:bool].depth.should == 12
-        @context.stacks[:bool].entries[11].value.should == true
-        @context.stacks[:bool].entries[7].value.should == false
-      end
-      
-    end
-  end
-end
-
-
-describe BoolYankInstruction do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = BoolYankInstruction.new(@context)
-  end
-  
-  it "should check its context is set" do
-    @i1.context.should == @context
-  end
-  
-  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
-    it "should respond to \##{methodName}" do
-      @i1.should respond_to(methodName)
-    end   
-  end
-  
-  describe "\#go" do
-    before(:each) do
-      @i1 = BoolYankInstruction.new(@context)
-      @context.clear_stacks
-      @int1 = LiteralPoint.new("int", 3)
-    end
-    
-    describe "\#preconditions?" do
-      it "should check that there is one :int and at least one more :int" do
-        @context.stacks[:bool].push(LiteralPoint.new("bool", false))
-        @context.stacks[:int].push(@int1)
-        @i1.preconditions?.should == true
-      end
-    end
-    
-    describe "\#cleanup" do
-      before(:each) do
-        @context.clear_stacks
-        (1..4).each {|i| @context.stacks[:bool].push(LiteralPoint.new("bool",i.even?))}
-      end
-      
-      it "should not change anything if the position integer is negative" do
-        @context.stacks[:int].push(LiteralPoint.new("int", -99))
-        @i1.go
-        @context.stacks[:bool].depth.should == 4
-        @context.stacks[:bool].peek.value.should == true
-      end
-      
-      it "should not change anything if the position integer is zero" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 0))
-        @i1.go
-        @context.stacks[:bool].depth.should == 4
-        @context.stacks[:bool].peek.value.should == true  
-      end
-      
-      it "should pull the last item on the stack to the top if the position is more than the stackdepth" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 1000))
-        @i1.go
-        @context.stacks[:bool].depth.should == 4
-        and_now = @context.stacks[:bool].entries.collect {|i| i.value}
-        and_now.should == [true,false,true,false]
-      end
-      
-      it "should yank the indicated item to the top of the stack, counting from the 'top' 'down'" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 2))
-        @i1.go
-        and_now = @context.stacks[:bool].entries.collect {|i| i.value}
-        and_now.should == [false,false,true,true]
-        
-        @context.stacks[:int].push(LiteralPoint.new("int", 2))
-        @i1.go
-        and_now = @context.stacks[:bool].entries.collect {|i| i.value}
-        and_now.should == [false,true,true, false]
-        
-      end
-    end
-  end
-end
-
-
-describe BoolYankdupInstruction do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = BoolYankdupInstruction.new(@context)
-  end
-  
-  it "should check its context is set" do
-    @i1.context.should == @context
-  end
-  
-  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
-    it "should respond to \##{methodName}" do
-      @i1.should respond_to(methodName)
-    end   
-  end
-  
-  describe "\#go" do
-    before(:each) do
-      @i1 = BoolYankdupInstruction.new(@context)
-      @context.clear_stacks
-      @int1 = LiteralPoint.new("int", 3)
-    end
-    
-    describe "\#preconditions?" do
-      it "should check that there is one :int and at least one :bool" do
-        @context.stacks[:bool].push(LiteralPoint.new("bool", false))
-        @context.stacks[:int].push(@int1)
-        @i1.preconditions?.should == true
-      end
-    end
-    
-    describe "\#cleanup" do
-      before(:each) do
-        @context.clear_stacks
-        (1..4).each {|i| @context.stacks[:bool].push(LiteralPoint.new("bool",i.even?))}
-      end
-      
-      it "should duplicate the top item if the position integer is negative" do
-        @context.stacks[:int].push(LiteralPoint.new("int", -99))
-        @i1.go
-        and_now = @context.stacks[:bool].entries.collect {|i| i.value}
-        and_now.should == [false, true, false, true, true]
-      end
-      
-      it "should duplicate the top item if the position integer is zero" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 0))
-        @i1.go
-        and_now = @context.stacks[:bool].entries.collect {|i| i.value}
-        and_now.should == [false, true, false, true, true]
-      end
-      
-      it "should clone the bottom item and push it if the position is more than the stackdepth" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 1000))
-        @i1.go
-        and_now = @context.stacks[:bool].entries.collect {|i| i.value}
-        and_now.should == [false, true, false, true, false]
-      end
-      
-      it "should push a copy of the indicated item to the top of the stack, counting from the 'top down'" do
-        @context.stacks[:int].push(LiteralPoint.new("int", 2))
-        @i1.go
-        and_now = @context.stacks[:bool].entries.collect {|i| i.value}
-        and_now.should == [false, true, false, true, true]
-        
-        @context.stacks[:int].push(LiteralPoint.new("int", 2))
-        @i1.go
-        and_now = @context.stacks[:bool].entries.collect {|i| i.value}
-        and_now.should == [false, true, false, true, true, false]
-      end
-    end
-  end
-end