nudge 0.0.2 → 0.1.0

data/spec/search/individual_spec.rb

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

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

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

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

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