nudge 0.0.2 → 0.1.0

data/spec/search/operators/evaluators/test_case_evaluator_spec.rb

@@ -1,133 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../../spec_helper")
-include Nudge
-
-
-describe TestCase do
-  describe "bindings" do
-    it "should have a Hash of independent variable names and assigned values" do
-      TestCase.new.should respond_to(:bindings)
-    end
-  end
-  
-  describe "expectations" do
-    it "should have a Hash of dependent variable names and expected values" do
-      TestCase.new.should respond_to(:expectations)
-    end
-  end
-  
-  describe "gauges" do
-    it "should have a Hash of Proc objects that measure the observed values" do
-      TestCase.new.should respond_to(:gauges)
-    end
-    
-    it "should have one gauge for every expectation" do
-      lambda{TestCase.new(
-        :expectations => {"y1"=>31},
-        :gauges => {"h"=>Proc.new {} } )}.should raise_error
-      lambda{TestCase.new(
-        :expectations => {"y1"=>31},
-        :gauges => {"y1"=>Proc.new {} } )}.should_not raise_error
-    end
-  end
-end
-
-
-
-
-
-describe TestCaseEvaluator do
-  describe "initialize" do
-    it "should have a name" do
-      lambda{TestCaseEvaluator.new()}.should raise_error(ArgumentError)
-      lambda{TestCaseEvaluator.new(name:"boolean_multiplexer_SSE")}.should_not raise_error
-    end
-    
-    it "should have all the info it needs to set up an Interpreter"
-  end
-  
-  describe "evaluate" do
-    before(:each) do
-      @tce = TestCaseEvaluator.new(name:"error")
-      @dudes = Batch[
-        Individual.new("sample int(12)"),
-        Individual.new("sample int(-9912)"),
-        Individual.new("sample bool(false)"),
-        Individual.new("block { sample int(99) sample int(12)}")
-      ]
-      @cases = [
-        TestCase.new(:bindings => {"x" => LiteralPoint.new("int",77)},
-          :expectations => {"y" => 12},
-          :gauges => {"y" => Proc.new {|interp| interp.stacks[:int].peek}}
-        ),
-        TestCase.new(:bindings => {"x" => LiteralPoint.new("int",78)},
-          :expectations => {"y" => 13},
-          :gauges => {"y" => Proc.new {|interp| interp.stacks[:int].peek}}
-        )
-      ]
-    end
-    
-    it "should raise an exception if the batch argument isn't a Batch" do
-      lambda{@tce.evaluate()}.should raise_error(ArgumentError)
-      lambda{@tce.evaluate(@dudes)}.should_not raise_error(ArgumentError)
-    end
-    
-    it "should raise an exception if it can't evaluate an Individual" do
-      lambda{@tce.evaluate(Batch[Individual.new("blah_de_blah")])}.should raise_error(ArgumentError)
-    end
-    
-    it "should assign a numeric score to all the Individuals in the Batch" do
-      @dudes.each {|dude| dude.scores["error"].should == nil}
-      @tce.evaluate(@dudes, @cases)
-      @dudes.each {|dude| dude.scores["error"].kind_of?(Numeric).should == true}
-    end
-    
-    it "should create an Interpreter for each run" do
-      myI = Interpreter.new
-      Interpreter.should_receive(:new).exactly(8).times.and_return(myI)
-      @tce.evaluate(@dudes, @cases)
-    end
-    
-    it "should be reset each time before running them" do
-      myI = Interpreter.new
-      Interpreter.stub!(:new).and_return(myI)
-      myI.should_receive(:reset).exactly(8).times
-      @tce.evaluate(@dudes, @cases)
-    end
-    
-    it "should set up bindings before running them" do
-      myI = Interpreter.new
-      Interpreter.stub!(:new).and_return(myI)
-      myI.should_receive(:bind_variable).exactly(8).times
-      @tce.evaluate(@dudes, @cases)
-    end
-    
-    it "should run each TestCase for each individual in the Batch" do
-      myI = Interpreter.new
-      Interpreter.stub!(:new).and_return(myI)
-      myI.should_receive(:run).exactly(8).times
-      @tce.evaluate(@dudes, @cases)
-    end
-    
-    it "after running a TestCase using an Individual, all the gauges should be called" do
-      myI = Interpreter.new
-      Interpreter.stub!(:new).and_return(myI)
-      myI.should_receive(:run).exactly(8).times
-      @tce.evaluate(@dudes, @cases)
-      
-      myI.should_receive(:run).exactly(4).times
-      @tce.evaluate(@dudes, [TestCase.new(:gauges => {"a" => Proc.new {|interp|}})])
-    end
-    
-    it "should synthesize the gauge readings into a single numerical score"
-    
-    it "should loop over the test cases to collect the error" do
-      @dudes.each {|dude| dude.scores["error"].should == nil}
-      
-      @tce.evaluate(@dudes, @cases)
-      equal12or13error = @dudes.collect {|dude| dude.scores["error"]}
-      expectedScores = [1, 19849, 200000, 1]
-      (0..3).each {|i| equal12or13error[i].should be_close(expectedScores[i].to_f / 2, 0.0001)}
-    end
-    
-  end
-end

data/spec/search/operators/infrastructure_spec.rb

@@ -1,47 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-
-
-describe "domination_classes" do
-  before(:each) do
-    @dq = Sampler.new
-    
-    @dudes = Batch[Individual.new("block {}"), Individual.new("do int_add")]
-    @dudes[0].scores["first"] = 120
-    @dudes[1].scores["first"] = 2
-    @dudes[0].scores["second"] = 2
-    @dudes[1].scores["second"] = 120
-    @dudes[0].scores["third"] = 20
-    @dudes[1].scores["third"] = 1200
-  end
-  
-  it "should take a Batch as an argument" do
-    lambda{@dq.domination_classes()}.should raise_error(ArgumentError)
-    lambda{@dq.domination_classes(@dudes)}.should_not raise_error(ArgumentError)
-    
-  end
-  
-  it "can take a template of objective names to use" do
-    lambda{@dq.domination_classes(@dudes, ["first"])}.should_not raise_error(ArgumentError)
-  end
-  
-  it "should return a Hash" do
-    @dq.domination_classes(@dudes, ["first"]).should be_a_kind_of(Hash)
-  end
-  
-  it "should use the count of dominating Individuals as the key" do
-    @dq.domination_classes(@dudes, ["second"]).keys.should == [0,1]
-    @dq.domination_classes(@dudes).keys.should == [0]
-    
-  end
-  
-  it "should have an Array of the Individuals in that class as the value" do
-    @dq.domination_classes(@dudes, ["first"])[0].length.should == 1
-    @dq.domination_classes(@dudes, ["first"])[0][0].should == @dudes[1]
-    @dq.domination_classes(@dudes, ["second"])[0].length.should == 1
-    @dq.domination_classes(@dudes, ["second"])[0][0].should == @dudes[0]
-    @dq.domination_classes(@dudes, ["second", "third"])[0].length.should == 1
-    @dq.domination_classes(@dudes, ["second", "third"])[0][0].should == @dudes[0]
-  end
-end

data/spec/search/operators/most_dominated_subset_spec.rb

@@ -1,47 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe MostDominatedSubsetSampler do
-  before(:each) do
-    @md = MostDominatedSubsetSampler.new
-  end
-    
-  
-  describe "#generate" do
-    before(:each) do
-      @dudes = Batch[Individual.new("block {}"), Individual.new("block {}"), Individual.new("block {}")]
-      @dudes[0].scores = Hash["first", 2,   "second", 20,  "third", 200]
-      @dudes[1].scores = Hash["first", 20,  "second", 200, "third", 2]
-      @dudes[2].scores = Hash["first", 200, "second", 2,   "third", 20]
-    end
-    
-    it "should take a Batch as a first parameter" do
-      lambda{@md.generate()}.should raise_error(ArgumentError)
-      lambda{@md.generate(@dudes)}.should_not raise_error(ArgumentError)
-    end
-
-    it "should return a Batch" do
-      @md.generate(@dudes).should be_a_kind_of(Batch)
-    end
-    
-    it "should return a Batch containing references to individuals in the original Batch" do
-      half = @md.generate(@dudes)
-      half.length.should be > 0
-      half.each {|dude| @dudes.should include(dude)}
-    end
-    
-    it "should always return at least one, even when everybody is nondominated" do
-      some = @md.generate(@dudes)
-      some.length.should == 3
-      some.each {|dude| @dudes.should include(dude)}
-    end
-    
-    
-    it "should take a template of objectives to use in sorting" do
-      @md.generate(@dudes,["first"]).should include(@dudes[2])
-      @md.generate(@dudes,["second"]).should include(@dudes[1])
-      @md.generate(@dudes,["second", "third"]).should include(@dudes[0])
-    end
-  end
-  
-end

data/spec/search/operators/nondominated_subset_spec.rb

@@ -1,97 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe "nondominated_subset operator" do
-  before(:each) do
-    @myNondominatedScreener = NondominatedSubsetSelector.new
-    @params = {:points => 3, :instructions => [IntAddInstruction], :types => [IntType]}
-    @myGuesser = RandomGuessOperator.new(@params)
-    @twoGuys = @myGuesser.generate(2)
-  end
-  
-  it "should be a kind of SearchOperator" do
-    @myNondominatedScreener.should be_a_kind_of(SearchOperator)
-  end
-  
-  it "the #all_known_scores method should return an Array with the union of all scores keys in the crowd" do
-    @twoGuys[0].scores = {"x2" => 612, "y2" => 77, "x3" => 712}
-    @twoGuys[1].scores = {"y1" => 2, "x1" => 3, "x2" => 4}
-    @myNondominatedScreener.all_known_scores(@twoGuys).sort.should == ["x1","x2", "x3", "y1", "y2"].sort
-  end
-  
-  it "the #all_shared_scores method should return an Array of the keys of the #scores hashes in the crowd" do
-    twoGuys = @myGuesser.generate(2)
-    twoGuys[0].scores = {"x2" => 612, "x1" => 77, "x3" => 712}
-    twoGuys[1].scores = {"x2" => 2, "x1" => 3, "x3" => 4}
-    @myNondominatedScreener.all_shared_scores(twoGuys).sort.should == ["x1","x2", "x3"].sort
-    
-    twoGuys[0].scores = {"x3" => 712, "something_else" => 88}
-    twoGuys[1].scores = {"x2" => 2, "x1" => 3, "x3" => 4}
-    @myNondominatedScreener.all_shared_scores(twoGuys).sort.should == ["x3"].sort
-  end
-  
-  it "should produce a Batch of Individual objects when it receives #generate; at least one" do
-    twoGuys = @myGuesser.generate(2)
-    twoGuys[0].scores = {"x2" => 612, "x1" => 77, "x3" => 712}
-    twoGuys[1].scores = {"x2" => 2, "x1" => 3, "x3" => 4}
-    @myNondominatedScreener.generate(twoGuys).should be_a_kind_of(Batch)
-    @myNondominatedScreener.generate(twoGuys)[0].should be_a_kind_of(Individual)
-  end
-  
-  it "should work, passing along references not clones to the original guys" do
-    twoGuys = @myGuesser.generate(2)
-    twoGuys[0].scores = {"x2" => 612, "x1" => 77, "x3" => 712}
-    twoGuys[1].scores = {"x2" => 2, "x1" => 3, "x3" => 4}
-    @myNondominatedScreener.generate(twoGuys).should include(twoGuys[1])
-    
-    twoGuys[0].scores = {"x2" => 1, "x1" => 2, "x3" => 3}
-    twoGuys[1].scores = {"x2" => 2, "x1" => 1, "x3" => 3}
-    @myNondominatedScreener.generate(twoGuys).length.should == 2
-    @myNondominatedScreener.generate(twoGuys).should include(twoGuys[0])
-    @myNondominatedScreener.generate(twoGuys).should include(twoGuys[1])
-  end
-  
-  it "should work the same no matter what the scores hash order" do
-    twoGuys = @myGuesser.generate(2)
-    twoGuys[0].scores = {"x1" => 77, "x3" => 712,"x2" => 612}
-    twoGuys[1].scores = {"x2" => 2, "x1" => 3, "x3" => 4}
-    @myNondominatedScreener.generate(twoGuys).should include(twoGuys[1])
-    
-  end
-  
-  it "can use the 'template' parameter to compare individuals by a specified vector of scores" do
-    threeGuys = @myGuesser.generate(3)
-    threeGuys[0].scores = {"x1" => 1, "x2" => 2, "x3" => 3}
-    threeGuys[1].scores = {"x1" => 2, "x2" => 1, "x3" => 1}
-    threeGuys[2].scores = {"x1" => 4, "x2" => 0, "x3" => 2}
-    @myNondominatedScreener.generate(threeGuys).length.should == 3
-    @myNondominatedScreener.generate(threeGuys,["x1"]).length.should == 1
-    @myNondominatedScreener.generate(threeGuys,["x1"]).should include(threeGuys[0])
-    @myNondominatedScreener.generate(threeGuys,["x2"]).length.should == 1
-    @myNondominatedScreener.generate(threeGuys,["x2"]).should include(threeGuys[2])
-    @myNondominatedScreener.generate(threeGuys,["x3"]).length.should == 1
-    @myNondominatedScreener.generate(threeGuys,["x3"]).should include(threeGuys[1])
-    @myNondominatedScreener.generate(threeGuys,["x1","x3"]).length.should == 2
-    @myNondominatedScreener.generate(threeGuys,["x1","x2"]).length.should == 3
-    @myNondominatedScreener.generate(threeGuys,["x2","x3"]).length.should == 2
-  end
-  
-  
-  it "should use a default 'template' parameter that's the intersection of scores keys in the crowd" do
-    twoGuys = @myGuesser.generate(2)
-    twoGuys[0].scores = {"x1" => 1, "x2" => 2, "x3" => 3}
-    twoGuys[1].scores = {           "x2" => 1,           "x4" => 3}
-    @myNondominatedScreener.generate(twoGuys).length.should == 1
-    @myNondominatedScreener.generate(twoGuys).should include twoGuys[1]
-    @myNondominatedScreener.generate(twoGuys,["x1"]).length.should == 2 # neither dominates on an objectve not shared
-  end
-  
-  it "should return Individuals that belonged to crowd passed in" do
-    twoGuys = @myGuesser.generate(2)
-    orig_IDs = twoGuys.collect {|dude| dude.object_id}
-    twoGuys[0].scores = {"x1" => 1, "x2" => 2, "x3" => 3}
-    twoGuys[1].scores = {           "x2" => 1,           "x4" => 3}
-    @myNondominatedScreener.generate(twoGuys).length.should == 1
-    @myNondominatedScreener.generate(twoGuys).each {|newDude| orig_IDs.should include(newDude.object_id)}
-  end
-end

data/spec/search/operators/pointCrossover_spec.rb

@@ -1,55 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe "PointCrossoverOperator" do
-  before(:each) do
-    @myXover = PointCrossoverOperator.new
-    @dude1 = Individual.new("block{do a \n do b\n do c}")
-    @dude2 = Individual.new("block{ref x \n ref y\n ref z}")
-  end
-  
-  it "should be a kind of SearchOperator" do
-    @myXover.should be_a_kind_of(SearchOperator)
-  end
-  
-  
-  describe "generate" do
-    
-    it "should take as a param a set of one or more Individuals" do
-      lambda{@myXover.generate()}.should raise_error(ArgumentError)
-      lambda{@myXover.generate(331)}.should raise_error(ArgumentError)
-      lambda{@myXover.generate([])}.should raise_error(ArgumentError)
-      lambda{@myXover.generate([11])}.should raise_error(ArgumentError)
-      
-      lambda{@myXover.generate([@dude1])}.should_not raise_error(ArgumentError)
-    end
-    
-    it "should produce the same number of Individuals it gets as a default" do
-      babies = @myXover.generate([@dude1])
-      babies.length.should == 1
-    end
-          
-    it "should have an optional parameter that specifies the number of offspring to produce per parent" do
-      babies = @myXover.generate(Batch.[](@dude1, @dude2))
-      babies.length.should == 2
-      babies = @myXover.generate([@dude1, @dude2],4)
-      babies.length.should == 8
-    end
-    it "should only include points from one of the parents in the offspring genomes" do
-      babies = @myXover.generate([@dude1, @dude2])
-      bothGenomes = @dude1.program.listing + @dude2.program.listing
-      babies.each do |baby|
-        baby.program.listing.each_line do |line|
-          bothGenomes.match(line.strip.delete("}")).should_not == nil
-        end
-      end
-    end
-    
-    it "should increment the offspring's progress from the max parents' progress" do
-      @dude1.progress = 7
-      @dude2.progress = 11
-      babies = @myXover.generate([@dude1, @dude2],10)
-      babies.each {|baby| [8,12].should include(baby.progress)}
-    end
-  end
-end

data/spec/search/operators/pointDeletion_spec.rb

@@ -1,57 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe "PointDeleteOperator search operator" do
-  describe "generate" do
-    before(:each) do
-      @zapper = PointDeleteOperator.new()
-      @dude1 = Individual.new("block { do thing1 \n do thing2 \n do thing3}")
-    end
-    
-    it "should accept a Batch as a param" do
-      lambda{@zapper.generate()}.should raise_error(ArgumentError)
-      lambda{@zapper.generate(812)}.should raise_error(ArgumentError)
-      lambda{@zapper.generate(Batch.new)}.should_not raise_error(ArgumentError)
-      lambda{@zapper.generate(Batch[@dude1])}.should_not raise_error(ArgumentError)
-    end
-    
-    it "should raise an Argument error if all contents of the crowd aren't Individuals" do
-      lambda{@zapper.generate([])}.should_not raise_error(ArgumentError)
-      lambda{@zapper.generate([ 77 ])}.should raise_error(ArgumentError)
-      lambda{@zapper.generate([ @dude1, 77 ])}.should raise_error(ArgumentError)
-    end
-    
-    it "should return a Batch as a result" do
-      @zapper.generate([@dude1]).should be_a_kind_of(Batch)
-    end
-    
-    it "should use Individual#delete_point to produce the variants" do
-      @dude1.should_receive(:delete_point).and_return("do parseable")
-      @zapper.generate([@dude1])
-    end
-    
-    it "should produce one result per individual in the wildtype crowd as a default" do
-      @zapper.generate([@dude1]).length.should == 1
-      @zapper.generate([@dude1, @dude1]).length.should == 2
-    end
-    
-    it "should produce more if passed the optional howManyCopies parameter > 1" do
-      @zapper.generate([@dude1],2).length.should == 2
-      @zapper.generate([@dude1, @dude1],3).length.should == 6
-    end
-    
-    it "should produce individuals from which a random point (and its subpoints) is deleted" do
-      @zapper.generate([@dude1],5).each {|baby| baby.points.should < @dude1.points}
-    end
-    
-    it "should produce 'block {}' whenever a root is deleted" do
-      @zapper.should_receive(:rand).with(4).and_return(0)
-      @zapper.generate([@dude1])[0].genome.should == "block {}"
-    end
-    
-    it "should increment the progress of the offspring" do
-      @dude1.progress = 195
-      @zapper.generate([@dude1])[0].progress.should == 196
-    end
-  end
-end

data/spec/search/operators/pointMutation_spec.rb

@@ -1,71 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe "PointMutationOperator" do
-  describe "initialization" do
-    it "should have a params attribute when created that sets basic values for code generation" do
-      PointMutationOperator.new.params.should == {}
-      mutator = PointMutationOperator.new(:points => 3, :blocks => 1)
-      mutator.params.should_not == {}
-      mutator.params[:points].should == 3
-    end
-  end
-  
-  describe "generate" do
-    before(:each) do
-      @gammaray = PointMutationOperator.new(:points => 3, :types => [IntType])
-      @dude1 = Individual.new("block { do x1 \n do x2 \n do x3}")
-    end
-    
-    it "should accept an Array of one or more Individuals as a param" do
-      lambda{@gammaray.generate()}.should raise_error(ArgumentError)
-      lambda{@gammaray.generate(99)}.should raise_error(ArgumentError)
-      lambda{@gammaray.generate([])}.should raise_error(ArgumentError)
-      lambda{@gammaray.generate([99])}.should raise_error(ArgumentError)
-      
-      lambda{@gammaray.generate([@dude1])}.should_not raise_error(ArgumentError)
-    end
-    
-    it "should return a Batch as a result" do
-      @gammaray.generate([@dude1]).should be_a_kind_of(Batch)
-    end
-    
-    it "should use Individual#replace_point to produce the variants" do
-      @dude1.should_receive(:replace_point).and_return("do anything")
-      @gammaray.generate([@dude1])
-    end
-    
-    it "should produce one result per individual in the wildtype crowd as a default" do
-      @gammaray.generate([@dude1]).length.should == 1
-      @gammaray.generate([@dude1,@dude1]).length.should == 2
-    end
-    
-    it "should produce more if passed the optional howManyCopies parameter > 1" do
-      @gammaray.generate([@dude1],3).length.should == 3
-      @gammaray.generate([@dude1,@dude1],2).length.should == 4
-    end
-    
-    it "should produce individuals from which a random point (and all subpoints) is replaced" do
-      @gammaray.should_receive(:rand).and_return(0)
-      @gammaray.generate([@dude1])[0].points.should == 3 # totally replaced with 3-pt code
-      @gammaray.should_receive(:rand).and_return(1)
-      @gammaray.generate([@dude1])[0].points.should == 6 #replace point 2 with 3-pt code
-      @gammaray.should_receive(:rand).and_return(2)
-      @gammaray.generate([@dude1])[0].points.should == 6 #replace point 3 with 3-pt code
-      @gammaray.should_receive(:rand).and_return(3)
-      @gammaray.generate([@dude1])[0].points.should == 6 #replace point 4 with 3-pt code
-    end
-    
-    it "should accept temporarily overriding params to pass into CodeType.random_value" do
-      @gammaray.should_receive(:rand).and_return(0)
-      @gammaray.generate([@dude1])[0].points.should == 3 # totally replaced with 3-pt code
-      @gammaray.should_receive(:rand).and_return(0)
-      @gammaray.generate([@dude1],1,:points => 10)[0].points.should == 10
-    end
-    
-    it "should increment the #progress of the offspring" do
-      @dude1.progress = 888
-      @gammaray.generate([@dude1],13).each {|baby| baby.progress.should == 889}
-    end
-  end
-end

data/spec/search/operators/random_guess_spec.rb

@@ -1,51 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe "random_guess operator" do
-  before(:each) do
-    @myGuesser = RandomGuessOperator.new
-  end
-  
-  it "should be a kind of SearchOperator" do
-    @myGuesser.should be_a_kind_of(SearchOperator)
-  end
-  
-  it "should have a params attribute when created that sets basic values for code generation" do
-    RandomGuessOperator.new.params.should == {}
-    thisGuesser = RandomGuessOperator.new(:points => 3, :blocks => 1, :types => [IntType])
-    thisGuesser.params.should_not == {}
-    thisGuesser.params[:points].should == 3
-  end
-  
-  it "should produce a Batch of Individuals when it receives #generate" do
-    newDudes = @myGuesser.generate
-    newDudes.should be_a_kind_of(Batch)
-    newDudes[0].should be_a_kind_of(Individual)
-    newDudes[0].genome.should_not == nil
-    newDudes[0].program.should_not == nil
-  end
-  
-  it "should produce one as a default, more if a higher number is passed in" do
-    @myGuesser.generate.length.should == 1
-    @myGuesser.generate(4).length.should == 4
-  end
-  
-  it "should have a parsed genome as its #program attribute" do
-    newDudes = @myGuesser.generate
-    newDudes[0].program.should be_a_kind_of(CodeBlock)
-  end
-  
-  it "should accept temporarily overriding params to pass into CodeType.random_value" do
-    @myNewGuesser = RandomGuessOperator.new(
-      :points => 7, :instructions => [IntAddInstruction, IntSubtractInstruction],
-      :references => ["x1", "x2", "x3"])
-    lambda{@myNewGuesser.generate(3,:points => 12, :references => ["y1"])}.should_not raise_error
-    @myNewGuesser.generate(3,:points => 12)[0].program.points.should_not == 7
-    @myNewGuesser.generate(3,:points => 12)[0].program.points.should == 12
-    @myNewGuesser.generate(1,:points => 6, :blocks => 0, :types => [], :instructions => [], :references => ["y1"])[0].genome.should include("y1")
-  end
-  
-  it "should produce a Batch that contains Individuals with progress=0 only" do
-    @myGuesser.generate(12).each {|dude| dude.progress.should == 0}
-  end
-end

data/spec/search/operators/resample_and_clone_spec.rb

@@ -1,50 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe "resample_and_clone operator" do
-  before(:each) do
-    @myGuesser = RandomGuessOperator.new(:types => [IntType], :instructions => [IntAddInstruction])
-    @mySampler = ResampleAndCloneOperator.new
-  end
-  
-  it "should be a kind of SearchOperator" do
-    @mySampler.should be_a_kind_of(SearchOperator)
-  end
-
-  it "should produce a list of Individuals when it receives #generate" do
-    newDudes = @mySampler.generate(@myGuesser.generate(3))
-    newDudes.should be_a_kind_of(Batch)
-    newDudes[0].should be_a_kind_of(Individual)
-    newDudes[0].genome.should_not == nil
-    newDudes[0].program.should_not == nil
-  end
-  
-  it "should produce one Individual with a genome identical to one of the passed in crowd's" do
-    pop = @myGuesser.generate(1)
-    newDudes = @mySampler.generate(pop)
-    newDudes[0].genome.should == pop[0].genome
-  end
-  
-  it "should return more than one individual when asked to, resampling as needed" do
-    newDudes = @mySampler.generate(@myGuesser.generate(10))
-    newDudes.length.should == 1
-    newDudes = @mySampler.generate(@myGuesser.generate(3),2)
-    newDudes.length.should == 2
-    newDudes = @mySampler.generate(@myGuesser.generate(1),2)
-    newDudes.length.should == 2
-    newDudes[0].genome.should == newDudes[1].genome
-  end
-  
-  it "should have a parsed genome as its #program attribute" do
-    pop = @myGuesser.generate(3)
-    newDudes = @mySampler.generate(pop)
-    newDudes[0].program.should be_a_kind_of(CodeBlock)
-  end
-  
-  it "should increment the #progress of each clone" do
-    pop = @myGuesser.generate(3)
-    pop.each {|donor| donor.progress = 12}
-    newDudes = @mySampler.generate(pop)
-    newDudes.each {|kid| kid.progress.should == 13}
-  end
-end