nudge 0.0.2 → 0.1.0

data/spec/instructions/comparisons_spec.rb

@@ -1,486 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-include Nudge
-
-describe "IntEqualQInstruction" do
-  before(:each) do
-    @context = Interpreter.new    
-    @i1 = IntEqualQInstruction.new(@context)
-    @int1 = LiteralPoint.new("int", 1)
-    @int2 = LiteralPoint.new("int", 2)
-  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.should respond_to(methodName)
-    end   
-  end 
-  
-  it "should check that there are enough parameters" do
-    6.times {@context.stacks[:int].push(@int1)}
-    @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[:int].push(@int1)}
-    @i1.should_receive(:cleanup)
-    @i1.go
-  end
-  
-  it "should pop all the arguments" do
-    @context.clear_stacks
-    5.times {@context.stacks[:int].push(@int1)}
-    @i1.stub!(:cleanup) # and do nothing
-    @i1.go
-    @context.stacks[:int].depth.should == 3
-  end
-  
-  it "should push the result" do
-    @context.clear_stacks
-    @context.stacks[:int].push(@int1)
-    @context.stacks[:int].push(@int1)
-    @context.stacks[:int].push(@int1)
-    @context.stacks[:int].push(@int2)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-    @i1.go
-    @context.stacks[:bool].peek.value.should == true
-  end
-end
-
-
-describe "IntLessThanQInstruction" do
-  before(:each) do
-    @context = Interpreter.new    
-    @i1 = IntLessThanQInstruction.new(@context)
-    @int1 = LiteralPoint.new("int", 1)
-    @int2 = LiteralPoint.new("int", 2)
-  end
-  
-  it "should have a #context" 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 
-  
-  it "should check that there are enough parameters" do
-    6.times {@context.stacks[:int].push(@int1)}
-    @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[:int].push(@int1)}
-    @i1.should_receive(:cleanup)
-    @i1.go
-  end
-  
-  it "should pop all the arguments" do
-    @context.clear_stacks
-    5.times {@context.stacks[:int].push(@int1)}
-    @i1.stub!(:cleanup) # and do nothing
-    @i1.go
-    @context.stacks[:int].depth.should == 3
-  end
-  
-  it "should push the result" do
-    @context.clear_stacks
-    @context.stacks[:int].push(@int1)
-    @context.stacks[:int].push(@int1)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-    
-    @context.stacks[:int].push(@int1)
-    @context.stacks[:int].push(@int2)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == true
-    
-    @context.stacks[:int].push(@int2)
-    @context.stacks[:int].push(@int1)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-  end
-end
-
-
-describe "IntGreaterThanQInstruction" do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = IntGreaterThanQInstruction.new(@context)
-    @int1 = LiteralPoint.new("int", 1)
-    @int2 = LiteralPoint.new("int", 2)
-  end
-  
-  it "should have its #context set correctly" 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 
-  
-  it "should check that there are enough parameters" do
-    6.times {@context.stacks[:int].push(@int1)}
-    @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[:int].push(@int1)}
-    @i1.should_receive(:cleanup)
-    @i1.go
-  end
-  
-  it "should pop all the arguments" do
-    @context.clear_stacks
-    5.times {@context.stacks[:int].push(@int1)}
-    @i1.stub!(:cleanup) # and do nothing
-    @i1.go
-    @context.stacks[:int].depth.should == 3
-  end
-  
-  it "should push the result" do
-    @context.clear_stacks
-    @context.stacks[:int].push(@int1)
-    @context.stacks[:int].push(@int1)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-    
-    @context.stacks[:int].push(@int1)
-    @context.stacks[:int].push(@int2)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-    
-    @context.stacks[:int].push(@int2)
-    @context.stacks[:int].push(@int1)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == true
-  end
-end
-
-
-describe "FloatGreaterThanQInstruction" do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = FloatGreaterThanQInstruction.new(@context)
-    @float1 = LiteralPoint.new("float", 1.0)
-    @float2 = LiteralPoint.new("float", 2.0)
-  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 
-  
-  it "should check that there are enough parameters" do
-    6.times {@context.stacks[:float].push(@float1)}
-    @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[:float].push(@float1)}
-    @i1.should_receive(:cleanup)
-    @i1.go
-  end
-  
-  it "should pop all the arguments" do
-    @context.clear_stacks
-    5.times {@context.stacks[:float].push(@float1)}
-    @i1.stub!(:cleanup) # and do nothing
-    @i1.go
-    @context.stacks[:float].depth.should == 3
-  end
-  
-  it "should push the result" do
-    @context.clear_stacks
-    @context.stacks[:float].push(@float1)
-    @context.stacks[:float].push(@float1)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-    
-    @context.stacks[:float].push(@float1)
-    @context.stacks[:float].push(@float2)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-    
-    @context.stacks[:float].push(@float2)
-    @context.stacks[:float].push(@float1)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == true
-  end
-end
-
-
-describe "FloatLessThanQInstruction" do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = FloatLessThanQInstruction.new(@context)
-    @float1 = LiteralPoint.new("float", 1.0)
-    @float2 = LiteralPoint.new("float", 2.0)
-  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 
-  
-  it "should check that there are enough parameters" do
-    6.times {@context.stacks[:float].push(@float1)}
-    @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[:float].push(@float1)}
-    @i1.should_receive(:cleanup)
-    @i1.go
-  end
-  
-  it "should pop all the arguments" do
-    @context.clear_stacks
-    5.times {@context.stacks[:float].push(@float1)}
-    @i1.stub!(:cleanup) # and do nothing
-    @i1.go
-    @context.stacks[:float].depth.should == 3
-  end
-  
-  it "should push the result" do
-    @context.clear_stacks
-    @context.stacks[:float].push(@float1)
-    @context.stacks[:float].push(@float1)
-    @i1.go
-    @context.stacks[:bool].pop.value.should == false
-    
-    @context.stacks[:float].push(@float1)
-    @context.stacks[:float].push(@float2)
-    @i1.go
-    @context.stacks[:bool].pop.value.should == true
-    
-    @context.stacks[:float].push(@float2)
-    @context.stacks[:float].push(@float1)
-    @i1.go
-    @context.stacks[:bool].pop.value.should == false
-  end
-end
-
-
-describe "FloatEqualQInstruction" do
-  before(:each) do
-    @context = Interpreter.new    
-    @i1 = FloatEqualQInstruction.new(@context)
-    @float1 = LiteralPoint.new("float", 1.0)
-    @float2 = LiteralPoint.new("float", 2.0)
-  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.should respond_to(methodName)
-    end   
-  end 
-  
-  it "should check that there are enough parameters" do
-    6.times {@context.stacks[:float].push(@float1)}
-    @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[:float].push(@float1)}
-    @i1.should_receive(:cleanup)
-    @i1.go
-  end
-  
-  it "should pop all the arguments" do
-    @context.clear_stacks
-    5.times {@context.stacks[:float].push(@float1)}
-    @i1.stub!(:cleanup) # and do nothing
-    @i1.go
-    @context.stacks[:float].depth.should == 3
-  end
-  
-  it "should push the result" do
-    @context.clear_stacks
-    @context.stacks[:float].push(@float1)
-    @context.stacks[:float].push(@float1)
-    @context.stacks[:float].push(@float1)
-    @context.stacks[:float].push(@float2)
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-    @i1.go
-    @context.stacks[:bool].peek.value.should == true
-  end
-end
-
-
-describe "ExecEqualQInstruction" do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = ExecEqualQInstruction.new(@context)
-    @thing1 = "block { do int_add  sample float(0.5) block { } }"
-    @thing2 = "block {do int_add sample float(0.5) block {}}"
-    @thing3 = "block {do int_add sample float(0.25) block {}}"
-    @context.reset("block {#{@thing1} #{@thing2} #{@thing3} #{@thing2}}")
-    @context.step
-  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.should respond_to(methodName)
-    end   
-  end 
-  
-  it "should check that there are enough parameters" do
-    @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
-    @i1.go
-    @context.stacks[:bool].peek.value.should == true
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-  end
-end
-
-
-describe "NameEqualQInstruction" do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = NameEqualQInstruction.new(@context)
-    @thing1 = ChannelPoint.new("x")
-    @thing2 = ChannelPoint.new("x")
-    @thing3 = ChannelPoint.new("not_x")
-    @thing1.go(@context)
-    @thing2.go(@context)
-    @thing3.go(@context)
-    @thing1.go(@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.should respond_to(methodName)
-    end   
-  end 
-  
-  it "should check that there are enough parameters" do
-    @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
-    @i1.go
-    @context.stacks[:bool].peek.value.should == false
-    @i1.go
-    @context.stacks[:bool].peek.value.should == true
-  end
-end
-
-
-describe CodeEqualQInstruction do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = CodeEqualQInstruction.new(@context)
-    @thing1 = ChannelPoint.new("x")
-    @thing2 = LiteralPoint.new("int", 991)
-  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.should respond_to(methodName)
-    end   
-  end 
-  
-  it "should check that there are enough parameters" do
-    @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
-    @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 depend on the tidy listing, not the type of the item on the :code stack"
-end

data/spec/instructions/conditionals_spec.rb

@@ -1,162 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-include Nudge
-
-describe IntIfInstruction do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = IntIfInstruction.new(@context)
-  end
-  
-  it "should have the right context" 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
-      @context = Interpreter.new
-      @i1 = IntIfInstruction.new(@context)
-      @v1 = LiteralPoint.new("int",  1)
-      @v2 = LiteralPoint.new("int", -100)
-    end
-
-    describe "\#preconditions?" do
-      it "should check that there are two items on the target stack and at least one :bool" do
-        @context.stacks[:int].push(@v1)
-        @context.stacks[:int].push(@v2)
-        @context.stacks[:bool].push(LiteralPoint.new("bool", true))
-        @i1.preconditions?.should == true
-      end
-    end
-
-    describe "\#cleanup" do
-      it "should keep the top :int if the :bool is true, otherwise the second" do
-        @context.stacks[:int].push(@v1)
-        @context.stacks[:int].push(@v2)
-        @context.stacks[:bool].push(LiteralPoint.new("bool", true))
-        @i1.go
-        @context.stacks[:int].depth.should == 1
-        @context.stacks[:int].peek.value.should == 1
-        
-        @context.stacks[:int].push(@v1)
-        @context.stacks[:int].push(@v2)
-        @context.stacks[:bool].push(LiteralPoint.new("bool", false))
-        @i1.go
-        @context.stacks[:int].peek.value.should == -100
-      end
-    end
-  end
-end
-
-
-describe FloatIfInstruction do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = FloatIfInstruction.new(@context)
-  end
-  
-  it "should have the right context" 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
-      @context = Interpreter.new
-      @i1 = FloatIfInstruction.new(@context)
-      @v1 = LiteralPoint.new("float",  1.0)
-      @v2 = LiteralPoint.new("float", -9.5)
-    end
-
-    describe "\#preconditions?" do
-      it "should check that there are two items on the target stack and at least one :bool" do
-        @context.stacks[:float].push(@v1)
-        @context.stacks[:float].push(@v2)
-        @context.stacks[:bool].push(LiteralPoint.new("bool", true))
-        @i1.preconditions?.should == true
-      end
-    end
-
-    describe "\#cleanup" do
-      it "should keep the top :int if the :bool is true, otherwise the second" do
-        @context.stacks[:float].push(@v1)
-        @context.stacks[:float].push(@v2)
-        @context.stacks[:bool].push(LiteralPoint.new("bool", true))
-        @i1.go
-        @context.stacks[:float].depth.should == 1
-        @context.stacks[:float].peek.value.should == 1.0
-        
-        @context.stacks[:float].push(@v1)
-        @context.stacks[:float].push(@v2)
-        @context.stacks[:bool].push(LiteralPoint.new("bool", false))
-        @i1.go
-        @context.stacks[:float].peek.value.should == -9.5
-      end
-    end
-  end
-end
-
-
-describe ExecIfInstruction do
-  before(:each) do
-    @context = Interpreter.new
-    @i1 = ExecIfInstruction.new(@context)
-  end
-  
-  it "should have the right context" 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
-      @context = Interpreter.new
-      @context.enable(ExecIfInstruction)
-      @i1 = ExecIfInstruction.new(@context)
-      @v1 = LiteralPoint.new("float",  1.0)
-      @v2 = LiteralPoint.new("float", -9.5)
-    end
-
-    describe "\#preconditions?" do
-      it "should check that there are two items on the target stack and at least one :bool" do
-        @context.stacks[:exec].push(@v1)
-        @context.stacks[:exec].push(@v2)
-        @context.stacks[:bool].push(LiteralPoint.new("bool", true))
-        @i1.preconditions?.should == true
-      end
-    end
-
-    describe "\#cleanup" do
-      it "should keep the top :exec item if the :bool is true, otherwise the second" do
-        @context.stacks[:exec].push(@v1)
-        @context.stacks[:exec].push(@v2)
-        @context.stacks[:bool].push(LiteralPoint.new("bool", true))
-        @i1.go
-        @context.stacks[:exec].entries.each {|i| p i.listing}
-        @context.stacks[:exec].depth.should == 1
-        @context.stacks[:exec].peek.value.should == 1.0
-        
-        @context.stacks[:exec].push(@v1)
-        @context.stacks[:exec].push(@v2)
-        @context.stacks[:bool].push(LiteralPoint.new("bool", false))
-        @i1.go
-        @context.stacks[:exec].peek.value.should == -9.5
-      end
-    end
-  end
-end