nudge 0.0.1

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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,50 @@
+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