nudge 0.0.1

data/spec/search/individual_spec.rb

@@ -0,0 +1,356 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+require "fakeweb"
+include Nudge
+
+describe "Individual" do
+  describe "class methods" do
+    it "should have a class attribute Parser for validating code" do
+      Individual.helperParser.should be_a_kind_of(NudgeLanguageParser)
+    end
+  end
+  
+  describe "initialization" do
+    before(:each) do
+      @i1 = Individual.new("literal bool (false)")
+    end
+    
+    it "should have a genome string, with no default value" do
+      @i1.genome.should be_a_kind_of(String)
+      lambda{Individual.new()}.should raise_error
+    end
+    
+    it "should have a program attribute, which is the parsed genome" do
+      @par = NudgeLanguageParser.new
+      expected = @par.parse(@i1.genome).to_points
+      @i1.program.tidy.should == expected.tidy
+    end
+    
+    it "should raise an ArgumentError if the genome doesn't parse" do
+      lambda{Individual.new("bad stuff happens")}.should raise_error(ArgumentError)
+      lambda{Individual.new("block {")}.should raise_error(ArgumentError)
+      lambda{Individual.new("}")}.should raise_error(ArgumentError)
+      
+      lambda{Individual.new("")}.should raise_error(ArgumentError)
+      lambda{Individual.new("block {}")}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should have a scores hash, which is empty" do
+      @i1.scores.should == {}
+    end
+    it "should have a timestamp, which is when (wall clock time) it was made" do
+      @i1.timestamp.should be_a_kind_of(Fixnum)
+    end
+    it "should have an age, defaulting to zero" do
+      @i1.progress.should == 0
+    end
+    it "should have a locationID, defaulting to an empty string" do
+      @i1.station.should == ""
+    end
+    it "should have a list of ancestors, defaulting to none" do
+      @i1.ancestors.should == []
+    end
+  end
+  
+  
+  
+  describe "runnable?" do
+    it "should have a genome that an interpreter can understand" do
+      @i1 = Individual.new(fixture(:long_arithmetic))
+      @interp = Interpreter.new
+      @interp.reset(@i1.genome)
+      @interp.enable_all_instructions
+      @interp.run
+      @interp.stacks[:int].peek.value.should == -36
+    end
+  end
+  
+  
+  
+  describe "#known_scores and #score_vector" do
+    before(:each) do
+      @oneGuy = Individual.new("block {}")
+      @oneGuy.scores = {"beta" => -100, "alpha" => 100, "zeta" => 22}
+    end
+    
+    it "known_scores should return a sorted list of the keys of the scores hash" do
+      @oneGuy.known_scores.should == ["alpha", "beta", "zeta"]
+    end
+    
+    it "should return an Array of his #scores, in order based on a template w/default known_scores" do
+      @oneGuy.score_vector.should == [100,-100,22]
+      @oneGuy.score_vector(["alpha"]).should == [100]
+    end
+  end
+  
+  
+  
+  describe "#dominated_by?" do
+    before(:each) do
+      @oneGuy = Individual.new("block {}")
+      @betterGuy = Individual.new("block {}")
+      @mixedGuy = Individual.new("block {}")
+      @extraGuy = Individual.new("block {}")
+      
+      @oneGuy.scores =    {"beta" => -100, "alpha" => 100, "gamma" => 22 }
+      @betterGuy.scores = {"beta" => -120, "alpha" => 20,  "gamma" => 0  }
+      @mixedGuy.scores =  {"beta" => -10,  "alpha" => 20,  "gamma" => 100}
+      @extraGuy.scores =  {"beta" => -120, "alpha" => 20,  "gamma" => 21, "delta" => 10 }
+    end
+    
+    it "should test whether self dominates the other individual"  do
+      @oneGuy.dominated_by?(@betterGuy).should == true
+      @betterGuy.dominated_by?(@oneGuy).should == false
+      @oneGuy.dominated_by?(@mixedGuy).should == false
+      @mixedGuy.dominated_by?(@oneGuy).should == false
+    end
+    
+    it "should use a template of score keys to establish criteria for comparison, defaulting to self's" do
+      @oneGuy.dominated_by?(@mixedGuy).should == false
+      @oneGuy.dominated_by?(@mixedGuy, ["alpha"]).should == true
+      @mixedGuy.dominated_by?(@oneGuy, ["beta", "gamma"]).should == true
+    end
+    
+    it "should give the benefit of the doubt when comparing against a missing score" do
+      @oneGuy.dominated_by?(@extraGuy).should == true # because @extraGuy has all the same scores as self
+      @oneGuy.dominated_by?(@extraGuy,["delta"]).should == false # because self has no "delta" score
+      @extraGuy.dominated_by?(@oneGuy).should == false # because they're incomparible on "delta"
+    end
+  end
+  
+  
+  
+  describe "isolate_point" do
+    before(:each) do
+      @snipper = Individual.new("block {do some1 \n do some2 \n block {\n do some3}}")
+    end
+    
+    it "should raise an ArgumentError if the integer param referring to a particular point is OOB" do
+      lambda{@snipper.isolate_point()}.should raise_error(ArgumentError)
+      lambda{@snipper.isolate_point(-12)}.should raise_error(ArgumentError)
+      lambda{@snipper.isolate_point(912)}.should raise_error(ArgumentError)
+      
+      lambda{@snipper.isolate_point(2)}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should return a Hash containing up to three items" do
+      works = @snipper.isolate_point(2)
+      works.should be_a_kind_of(Hash)
+      works.length.should == 3
+      works.each_value {|chunk| chunk.should be_a_kind_of(String)}
+      
+      @snipper.isolate_point(1).length.should == 1
+      @snipper.isolate_point(5).length.should == 3
+    end
+    
+    it "should include the material in the genome before the point in the first string" do
+      works = @snipper.isolate_point(2)
+      works[:left].should include("block {")
+      works[:left].should_not include("}")
+      
+      whole = @snipper.isolate_point(1)
+      whole[:left].should == nil
+    end
+    
+    it "should include the material in the genome after the point in the third string" do
+      works = @snipper.isolate_point(2)
+      works[:right].should include("do some2")
+      works[:right].should_not include("do some1")
+      
+      whole = @snipper.isolate_point(1)
+      whole[:right].should == nil
+      
+      bracesLeft = @snipper.isolate_point(5)
+      bracesLeft[:right].should == "}}"
+    end
+    
+    it "should include the isolated point in the middle string" do
+      works = @snipper.isolate_point(2)
+      works[:middle].strip.should == "do some1"
+      
+      @snipper.isolate_point(3)[:middle].strip.should == "do some2"
+      @snipper.isolate_point(4)[:middle].gsub(/([\s]+)/," ").should == "block { do some3}"
+      @snipper.isolate_point(5)[:middle].strip.should == "do some3"
+    end
+  end
+  
+  
+  
+  describe "delete_point" do
+    before(:each) do
+      @clipper = Individual.new("block {do some1 \n do some2 \n block {\n do some3}}")
+      @parser = NudgeLanguageParser.new()
+    end
+    
+    it "should return Individual#genome if[f] the position param is out of bounds" do
+      @clipper.delete_point(-12).should == @clipper.program.listing
+      @clipper.delete_point(933).should == @clipper.program.listing
+      @clipper.delete_point(2).should_not == @clipper.program.listing
+    end
+    
+    it "should call self#isolate_point to slice the wildtype genome" do
+      @clipper.should_receive(:isolate_point).with(2).and_return(
+        {:left => "so",:middle=>"it",:right=>"works"})
+      @clipper.delete_point(2)
+    end
+    
+    it "should produce a parsable genome" do
+      (0..5).each do |where|
+        @parser.parse(@clipper.delete_point(2)).should_not == nil
+      end
+    end
+    
+    it "should return a genome with at least one fewer program points" do
+      startPoints = @clipper.points
+      (0..5).each do |where|
+        @parser.parse(@clipper.delete_point(2)).to_points.points.should < startPoints
+      end
+    end
+        
+    it "should delete the expected specific point (and any subpoints it has)" do
+      @parser.parse(@clipper.delete_point(2)).to_points.points.should == 4
+      @parser.parse(@clipper.delete_point(3)).to_points.points.should == 4
+      @parser.parse(@clipper.delete_point(4)).to_points.points.should == 3
+      @parser.parse(@clipper.delete_point(5)).to_points.points.should == 4
+    end
+    
+    it "should return 'block {}' when the entire program is deleted" do
+      @clipper.delete_point(1).should == "block {}"
+    end
+  end
+  
+  
+  describe "replace_point" do
+    before(:each) do
+      @receiver = Individual.new("block {do some1 \n do some2 \n block {\n do some3}}")
+      @parser = NudgeLanguageParser.new()
+      @mutant = "do NOTHING"
+    end
+    
+    it "should return Individual#genome if[f] the position param is out of bounds" do
+      @receiver.replace_point(-1,@mutant).should == @receiver.program.listing
+      @receiver.replace_point(132,@mutant).should == @receiver.program.listing
+      @receiver.replace_point(2,@mutant).should_not == @receiver.program.listing
+    end
+    
+    it "should raise an ArgumentError if passed an empty replacement" do
+      lambda{@receiver.replace_point(1,"")}.should raise_error(ArgumentError)
+    end
+    
+    
+    it "should call self#isolate_point to slice the wildtype genome" do
+      @receiver.should_receive(:isolate_point).with(2).and_return(
+        {:left => "so ",:middle=>"it",:right=>" works"})
+      @receiver.replace_point(2,"this")
+    end
+    
+    it "should produce a parsable genome" do
+      @parser.parse(@receiver.replace_point(2,@mutant)).should_not == nil
+      @parser.parse(@receiver.replace_point(1,@mutant)).should_not == nil
+    end
+    
+    it "should replace the expected specific point (and any subpoints it has)" do
+      @receiver.replace_point(2,@mutant).should_not include("some1")
+      @receiver.replace_point(3,@mutant).should_not include("some2")
+      @receiver.replace_point(4,@mutant).should_not include("some3")
+      @receiver.replace_point(5,@mutant).should_not include("some3")
+      @receiver.replace_point(1,@mutant).should_not include("block")
+    end
+
+    it "should replace the entire program if it replaces point 0" do
+      @receiver.replace_point(1,@mutant).should == " do NOTHING "
+    end
+    
+  end
+  
+  describe "Station knowledge" do
+    before(:each) do
+      @dude = Individual.new("block {}")
+      Station.cleanup
+      @where = Station.new("here")
+    end
+    
+    it "should know its Station" do
+      @where.add_individual @dude
+      @dude.station == @where
+    end
+  end
+  
+  describe "#write behavior" do
+    before(:each) do
+      Station.cleanup
+      @dude = Individual.new("block {}")
+      @dude.scores["error"] = 1
+      @dude.timestamp = Time.utc(2000,"jan",1,20,15,1)
+      @where = Station.new("here")
+      @where.stub!(:database => "http://127.0.0.1:5984/here")
+      @where.add_individual(@dude)
+      FakeWeb.allow_net_connect = false
+      
+      @response_body = <<-END
+      {
+        "id": "12345678",
+        "rev": "1-12345678"
+      }
+      END
+    end
+    
+    it "should write its data to the database for its Station" do
+      FakeWeb.register_uri(:post, "http://127.0.0.1:5984/here", body:@response_body)
+      @dude.write
+      @dude.id.should == "12345678"
+    end
+    
+    it "should write the genome" do
+      mockDatabase = mock("fakeDB")
+      CouchRest.should_receive(:database!).and_return(mockDatabase)
+      mockDatabase.should_receive(:save_doc).
+        with(hash_including({"genome" => "block {}"})).and_return(@response_body)
+      @dude.write
+    end
+    
+    it "should write the scores hash" do
+      mockDatabase = mock("fakeDB")
+      CouchRest.should_receive(:database!).and_return(mockDatabase)
+      mockDatabase.should_receive(:save_doc).
+        with(hash_including({"scores" => {"error" => 1}})).and_return(@response_body)
+      @dude.write
+    end
+    
+    it "should write the Time.now" do
+      mockDatabase = mock("fakeDB")
+      CouchRest.should_receive(:database!).and_return(mockDatabase)
+      mockDatabase.should_receive(:save_doc).
+        with(hash_including({"creation_time" => Time.utc(2000,"jan",1,20,15,1)})).and_return(@response_body)
+      @dude.write
+    end
+  end 
+
+  
+  describe "#get" do
+    before(:each) do
+      @url = "http://localhost:5984/here"
+      @individual_id = "88888"
+      @genome = "do int_add"
+      
+      @response_body = <<-END
+      {
+        "_id": "88888",
+        "_rev": "1-12345678",
+        "genome": "#{@genome}"
+      }
+      END
+      
+      FakeWeb.allow_net_connect = false
+      FakeWeb.register_uri(:get, "#{@url}/#{@individual_id}", body:@response_body)
+    end
+    
+    it "retrive an individual from the data store by id" do
+      @dude = Individual.get(@url, @individual_id)
+      @dude.id.should == @individual_id
+      @dude.genome.should == @genome
+    end
+    
+    it "should handle connection errors"
+  end
+  
+end

data/spec/search/operators/any_one_sampler_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), "./../../spec_helper")
+include Nudge
+
+describe AnyOneSampler do
+  before(:each) do
+    @ao = AnyOneSampler.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{@ao.generate()}.should raise_error(ArgumentError)
+      lambda{@ao.generate(@dudes)}.should_not raise_error(ArgumentError)
+    end
+
+    it "should return a Batch" do
+      @ao.generate(@dudes).should be_a_kind_of(Batch)
+    end
+    
+    it "should return a Batch containing references to individuals in the original Batch" do
+      one = @ao.generate(@dudes)
+      one.length.should == 1
+      one.each {|dude| @dudes.should include(dude)}
+    end
+    
+    it "should invoke Batch#sample" do
+      @dudes.should_receive(:sample).and_return(@dudes[0])
+      one = @ao.generate(@dudes)
+    end
+    
+  end
+  
+end

data/spec/search/operators/dominated_quantile_spec.rb

@@ -0,0 +1,111 @@
+require File.join(File.dirname(__FILE__), "./../../spec_helper")
+include Nudge
+
+describe DominatedQuantileSampler do
+  before(:each) do
+    @dq = DominatedQuantileSampler.new
+  end
+  
+  
+  describe "domination_classes" do
+    before(:each) do
+      @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
+  
+  
+  describe "#generate" do
+    before(:each) do
+      @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 a first parameter" do
+      lambda{@dq.generate()}.should raise_error(ArgumentError)
+      lambda{@dq.generate(@dudes)}.should_not raise_error(ArgumentError)
+    end
+
+    it "should return a Batch" do
+      @dq.generate(@dudes).should be_a_kind_of(Batch)
+    end
+    
+    it "should return a Batch containing references to individuals in the original Batch" do
+      half = @dq.generate(@dudes)
+      half.length.should be > 0
+      half.each {|dude| @dudes.should include(dude)}
+    end
+    
+    it "should have a parameter that specifies what fraction to return" do
+      some = @dq.generate(@dudes,1.0)
+      some.length.should == 2
+      
+      some = @dq.generate(@dudes,0.5)
+      some.length.should == 1
+    end
+    
+    it "should always return at least one for a non-zero fraction" do
+      some = @dq.generate(@dudes,0.01)
+      some.length.should be > 0
+      some.each {|dude| @dudes.should include(dude)}
+      
+      some = @dq.generate(@dudes,0)
+      some.length.should == 0
+    end
+    
+    
+    it "should take a template of objectives to use in sorting" do
+      @dq.generate(@dudes,0.5,["first"]).should include(@dudes[0])
+      @dq.generate(@dudes,0.5,["second"]).should include(@dudes[1])
+      @dq.generate(@dudes,0.5,["second", "third"]).should include(@dudes[1])
+    end
+    
+    it "should return the most-dominated Individuals first, nondominated last" do
+      some = @dq.generate(@dudes,1, ["first"])
+      some[0].should == @dudes[0]
+      
+      some = @dq.generate(@dudes,1, ["second"])
+      some[0].should == @dudes[1]
+    end
+  end
+  
+end

data/spec/search/operators/duplicate_genomes_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), "./../../spec_helper")
+include Nudge
+
+describe AllDuplicatedGenomesSampler do
+  before(:each) do
+    @dg = AllDuplicatedGenomesSampler.new
+  end
+  
+  
+  describe "#generate" do
+    before(:each) do
+      @dudes = Batch[Individual.new("block {}"), Individual.new("block {}"), Individual.new("do int_add")]
+    end
+    
+    it "should take a Batch as a first parameter" do
+      lambda{@dg.generate()}.should raise_error(ArgumentError)
+      lambda{@dg.generate(@dudes)}.should_not raise_error(ArgumentError)
+    end
+
+    it "should return a Batch" do
+      @dg.generate(@dudes).should be_a_kind_of(Batch)
+    end
+    
+    it "should return a Batch containing references to individuals in the original Batch" do
+      repeats = @dg.generate(@dudes)
+      repeats.length.should == 2
+      repeats.each {|dude| @dudes.should include(dude)}
+    end
+    
+    it "should return an empty Batch if there are no duplicates" do
+      @dudes.delete_at(0)
+      @dg.generate(@dudes).should be_empty
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), "./../../../spec_helper")
+include Nudge
+
+describe ProgramPointEvaluator do
+  
+  describe "initialization" do
+    it "should have an objective name set upon initialization" do
+      lambda{ProgramPointEvaluator.new}.should raise_error(ArgumentError)
+    end
+  end
+  
+  describe "#evaluate" do
+    before(:each) do
+      @ppe = ProgramPointEvaluator.new(name:"point_count")
+      @dudes = Batch[
+        Individual.new("block {}"),
+        Individual.new("block { block {}}"),
+        Individual.new("block { block { block {}}}")
+      ]
+    end
+    
+    it "should take a Batch of individuals as an argument" do
+      lambda{@ppe.evaluate(Individual.new("block {}"))}.should raise_error(ArgumentError)
+      lambda{@ppe.evaluate(Batch[Individual.new("block {}")])}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should raise an exception if it can't evaluate an Individual" do
+      lambda{@ppe.evaluate(Batch[Individual.new("blah_de_blah")])}.should raise_error(ArgumentError)
+    end
+    
+    it "should write the number of program points into each individual" do
+      @dudes.each {|dude| dude.scores["point_count"].should == nil}
+      @ppe.evaluate(@dudes)
+      @dudes.collect {|dude| dude.scores["point_count"]}.should == [1,2,3]
+    end
+    
+    it "should return the same Batch it got, with updated values" do
+      origIDs = @dudes.collect {|dude| dude.object_id}
+      @ppe.evaluate(@dudes)
+      @dudes.each {|dude| origIDs.should include(dude.object_id)}
+    end
+  end
+end