nudge 0.0.2 → 0.1.0

data/spec/search/operators/resample_values_spec.rb

@@ -1,126 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe "ResampleValuesOperator search operator" do
-  
-  it "should not need any initial parameters" do
-    lambda{ResampleValuesOperator.new()}.should_not raise_error
-  end
-  
-  it "should be possible to pass in stored parameters" do
-    lambda{ResampleValuesOperator.new(:randomIntegerLowerBound => 12)}.should_not raise_error
-    rs = ResampleValuesOperator.new({:boolTrueProbability => 0.2})
-    rs.params.should include(:boolTrueProbability)
-  end
-  
-  describe "generate" do
-    before(:each) do
-      @rs = ResampleValuesOperator.new({:boolTrueProbability => 0.2})
-      @intDude = Individual.new("block {sample int(3)}")
-      @boolDude = Individual.new("block {sample bool(false)}")
-      @floatDude = Individual.new("block {sample float(-991.2213)}")
-      @complicatedDude = Individual.new("block {sample int(3) sample bool(false) block {sample float(0.0)}}")
-    end
-    
-    it "should require a Batch as a first parameter" do
-      lambda{@rs.generate()}.should raise_error(ArgumentError)
-      lambda{@rs.generate(Batch.new)}.should_not raise_error(ArgumentError)
-    end
-    
-    it "should raise an ArgumentError if the array parameter isn't all Individuals" do
-      lambda{@rs.generate([88])}.should raise_error(ArgumentError)
-      lambda{@rs.generate([@intDude])}.should_not raise_error(ArgumentError)
-    end
-    
-    it "should by default produce one (1) resampled mutant for each input" do
-      @rs.generate([@intDude]).length.should == 1
-      @rs.generate([@intDude, @intDude]).length.should == 2
-    end
-    
-    it "should call #random_value for each line in each individual that is a 'sample'" do
-      IntType.should_receive(:random_value).and_return(777)
-      newGuys = @rs.generate([@intDude])
-      BoolType.should_receive(:random_value).and_return(false)
-      newGuys = @rs.generate([@boolDude])
-      FloatType.should_receive(:random_value).and_return(9.999)
-      newGuys = @rs.generate([@floatDude])
-      IntType.should_receive(:random_value).and_return(777)
-      BoolType.should_receive(:random_value).and_return(false)
-      FloatType.should_receive(:random_value).and_return(9.999)
-      newGuys = @rs.generate([@complicatedDude])
-      
-      IntType.should_receive(:random_value).and_return(1,2)
-      BoolType.should_receive(:random_value).and_return(false,true)
-      FloatType.should_receive(:random_value).and_return(1.0,2.0)
-      newGuys = @rs.generate([@intDude,@boolDude,@floatDude,@complicatedDude],1)
-      newGuys[0].genome.should include "1"
-      newGuys[1].genome.should include "false"
-      newGuys[2].genome.should include "1.0"
-      newGuys[3].genome.should include "2.0"
-    end
-    
-    it "should be possible to pass in a higher integer, and get that many variants for each input" do
-      IntType.should_receive(:random_value).and_return(11,22,33)
-      newGuys = @rs.generate([@intDude],3)
-      newGuys[0].genome.should include("11")
-      newGuys[1].genome.should include("22")
-      newGuys[2].genome.should include("33")
-      
-      IntType.should_receive(:random_value).and_return(4,5,6,7)
-      newGuys = @rs.generate([@intDude, @intDude],2)
-    end
-    
-    it "should be using the Operator's saved parameters as a default behavior" do
-      wholeLottaParams = {
-        :randomIntegerLowerBound => 1000,
-        :randomIntegerUpperBound => 1005,
-        :randomBooleanTruthProb => 0.2,
-        :randomFloatLowerBound => 112.0,
-        :randomFloatUpperBound => 112.5}
-      
-      resampleLimited = ResampleValuesOperator.new(wholeLottaParams)
-      
-      IntType.should_receive(:random_value).with(wholeLottaParams)
-      newGuys = resampleLimited.generate([@intDude])
-      
-      BoolType.should_receive(:random_value).with(wholeLottaParams)
-      newGuys = resampleLimited.generate([@boolDude])
-      
-      FloatType.should_receive(:random_value).with(wholeLottaParams)
-      newGuys = resampleLimited.generate([@floatDude])
-    end
-    
-    it "should return Individuals who (probably) differ from the originals passed in" do
-      outOfRangeParams = {
-        :randomIntegerLowerBound => 1000,
-        :randomIntegerUpperBound => 1005,
-        :randomBooleanTruthProb => 1.0,
-        :randomFloatLowerBound => 112.0,
-        :randomFloatUpperBound => 112.5}
-      resampleFarAway = ResampleValuesOperator.new(outOfRangeParams)
-      newGuys = resampleFarAway.generate([@intDude])
-      newGuys[0].genome.should =~ /100[0-5]/
-      newGuys = resampleFarAway.generate([@boolDude])
-      newGuys[0].genome.should =~ /true/
-      newGuys = resampleFarAway.generate([@floatDude])
-      newGuys[0].genome.should =~ /112\.[0-5]/
-    end
-    
-    it "should be possible to temporarily override some or all of the preset @params" do
-      bigInt = {:randomIntegerLowerBound => 90000,:randomIntegerUpperBound => 91000}
-      toBeOverridden = ResampleValuesOperator.new(bigInt)
-      defaults = toBeOverridden.generate([@intDude],5)
-      defaults.each {|dude| dude.genome.should =~ /9\d\d\d\d/}
-      
-      littler = toBeOverridden.generate([@intDude],5,
-        :randomIntegerLowerBound => -19, :randomIntegerUpperBound => -10)
-      littler.each {|dude| dude.genome.should =~ /-1\d/}
-    end
-    
-    it "should increment the #progress of every clone" do
-      @complicatedDude.progress = 192
-      @rs.generate([@complicatedDude],5).each {|clone| clone.progress.should == 193}
-    end
-  end
-  
-end

data/spec/search/operators/sizePreservingMutation_spec.rb

@@ -1,2 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge

data/spec/search/operators/uniformBackboneCrossover_spec.rb

@@ -1,63 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe "UniformBackboneCrossoverOperator" do
-  before(:each) do
-    @newDudes = []
-    @params = {:points => 3, :instructions => [IntAddInstruction], :types => [IntType]}
-    @myXover = UniformBackboneCrossoverOperator.new
-    @myGuesser = RandomGuessOperator.new(@params)
-  end
-  
-  it "should be a kind of SearchOperator" do
-    @myXover.should be_a_kind_of(SearchOperator)
-  end
-  
-  it "should produce a Batch of Individuals when it receives #generate" do
-    @newDudes = @myXover.generate(@myGuesser.generate(2))
-    @newDudes.should be_a_kind_of(Batch)
-    @newDudes.each {|dude| dude.should be_a_kind_of(Individual)}
-  end
-  
-  it "should produce the same number of Individuals it gets as a default" do
-    @newDudes = @myXover.generate(@myGuesser.generate(6))
-    @newDudes.length.should == 6
-  end
-  
-  it "should have an optional parameter that specifies the number of offspring to produce" do
-    @newDudes = @myXover.generate(@myGuesser.generate(2),5)
-    @newDudes.length.should == 5
-  end
-  
-  it "should only include backbone points from one of the parents in the offsprings' genomes" do
-    rents = @myGuesser.generate(2)
-    @newDudes = @myXover.generate(rents,1)
-    @newDudes.length.should == 1
-    allParentalPoints = rents[0].program.contents + rents[1].program.contents
-    allTidied = allParentalPoints.collect {|pt| pt.tidy}
-    @newDudes[0].program.contents.each {|pt| allTidied.should include(pt.tidy)}
-  end
-  
-  it "should return an identical individual if given only one parent" do
-    rent = @myGuesser.generate(1)
-    @newDudes = @myXover.generate(rent,3)
-    @newDudes.each {|kid| kid.program.tidy.should == rent[0].program.tidy}
-  end
-  
-  
-  it "should not affect the original parents set in any way" do
-    rents = @myGuesser.generate(2)
-    originalMom = rents[0].object_id
-    @newDudes = @myXover.generate(rents,1)
-    rents[0].object_id.should == originalMom
-  end
-  
-  it "should return offspring with #progress values incremented from the largest parent value" do
-    rents = @myGuesser.generate(2)
-    rents[0].progress = 12
-    rents[1].progress = 33
-    @newDudes = @myXover.generate(rents,20)
-    @newDudes.each {|baby| [13, 34].should include(baby.progress)}
-  end
-  
-end

data/spec/search/stations/station_spec.rb

@@ -1,496 +0,0 @@
-require File.join(File.dirname(__FILE__), "./../../spec_helper")
-include Nudge
-
-describe "Station" do
-  before(:each) do
-    Station.cleanup
-  end
-  
-  
-  describe "class methods" do
-    describe "#stations" do
-      it "should be a Hash" do
-        Station.stations.should be_a_kind_of(Hash)
-      end
-      
-      it "should always include :DEAD" do
-        Station.stations.should include(:DEAD)
-      end
-    end
-  end
-  
-  
-  describe "names" do
-    it "should have a name" do
-      loc1 = Station.new("candy_mountain")
-      loc1.name.should == "candy_mountain"
-    end
-    it "needs to have a name" do
-      lambda{loc1 = Station.new}.should raise_error
-    end
-    it "needs to be a unique name" do
-      loc1 = Station.new("california")
-      lambda{loc2 = Station.new("california")}.should raise_error
-    end
-    it "should register its name in Station#stations upon creation" do
-      loc1 = Station.new("neverland")
-      Station.stations["neverland"].should == loc1
-    end
-    
-    it "should collect all created stations" do
-      Station.stations.length.should == 1
-      alpha = Station.new("alpha")
-      Station.stations.length.should == 2
-      beta = Station.new("beta")
-      Station.stations.length.should == 3
-      Station.stations.keys.should == [:DEAD,"alpha", "beta"]
-    end
-  end
-  
-  
-  describe "capacity" do
-    it "should have a #capacity parameter that defaults to 100 individuals" do
-      loc1 = Station.new("candy_mountain")
-      loc1.capacity.should == 100
-    end
-    it "should be settable as a second parameter" do
-      loc1 = Station.new("germany", capacity:912)
-      loc1.capacity.should == 912
-    end
-  end
-  
-  
-  describe "settings" do
-    it "should have a #settings attribute, where active instructions, variable names and types are listed" do
-      loc1 = Station.new("place")
-      loc1.settings.should_not == nil
-      loc1.settings.should be_a_kind_of(InterpreterSettings)
-    end
-    
-    it "should default to all defined Instructions" do
-      Station.new("place").settings.instructions.should == Instruction.all_instructions
-    end
-    
-    it "should default to no variables defined" do
-      Station.new("place").settings.references.should == []
-    end
-    
-    it "should default to the Push types (not all types)" do
-      Station.new("place").settings.types.should == NudgeType.push_types
-    end
-    
-    it "should be possible to pass in initial Array of active Instructions" do
-      loc = Station.new("p1", instructions: [IntAddInstruction])
-      loc.settings.instructions.should == [IntAddInstruction]
-      Station.new("p2", capacity: 4, :types => [IntType]).settings.types.should == [IntType]
-      Station.new("p3", capacity: 4, :references => ["x1"]).settings.references.should == ["x1"]
-      lambda{Station.new("p4", capacity: 4, :random_crap => ["whatever"])}.should_not raise_error
-    end
-  end
-  
-  
-  describe "network" do
-    it "should have a #flows_into method that adds a #downstream link" do
-      loc1 = Station.new("bree")
-      loc2 = Station.new("rivendell")
-      loc1.flows_into(loc2)
-      loc1.downstream.should be_a_kind_of(Set)
-      loc1.downstream.should include("rivendell")
-    end
-  end
-  
-  
-  describe "population" do
-    it "should be an Array that's empty initially" do
-      loc1 = Station.new("spain")
-      loc1.population.should == []
-    end
-  end
-  
-  describe "persistent store (database)" do
-    it "should have a URL for a couchDB (with name)" do
-      loc1 = Station.new("spain", database:"http://localhost:5984")
-      loc1.database.should == "http://localhost:5984/spain"
-    end
-  end
-  
-  describe "breeding pool" do
-    it "should include every Individual in the Station and all downstream stations" do
-      loc1 = Station.new("bree")
-      loc2 = Station.new("rivendell")
-      dude1 = Individual.new("block {}")
-      dude2 = Individual.new("ref x")
-      loc1.population << dude1
-      loc2.population << dude2
-      loc1.breeding_pool.should include(dude1)
-      loc1.breeding_pool.should_not include(dude2)
-      loc1.flows_into(loc2)
-      loc1.breeding_pool.should include(dude1)
-      loc1.breeding_pool.should include(dude2)
-      loc2.breeding_pool.should_not include(dude1)
-      loc2.breeding_pool.should include(dude2)
-    end
-  end
-  
-  
-  describe "add_individual" do
-    it "should set the station of the Individual being added to the population to the Station name" do
-      loc1 = Station.new("mordor")
-      dude1 = Individual.new("ref f")
-      loc1.add_individual dude1
-      dude1.station.should == loc1
-    end
-    
-    it "should be a private method"
-  end
-  
-  
-  describe "transfer" do
-    before(:each) do
-      @loc1 = Station.new("bree")
-      @loc2 = Station.new("rivendell")
-      @dude1 = Individual.new("block {}")
-      @loc1.add_individual @dude1
-    end
-    
-    it "should send an Individual from self.population to a different Station" do
-      @loc1.transfer(0,"rivendell")
-      @loc1.population.length.should == 0
-      @loc2.population.should include(@dude1)
-    end
-    
-    it "should change the #station attribute of the moved Individual" do
-      @dude1.station.should == @loc1
-      @loc1.transfer(0,"rivendell")
-      @dude1.station.should == @loc2
-    end
-    
-    it "should bounds check the popIndex parameter and raise an error if impossible" do
-      lambda{@loc1.transfer(-20,"rivendell")}.should raise_error(ArgumentError,
-        "self#transfer called with index -20")
-      lambda{@loc1.transfer(8,"rivendell")}.should raise_error(ArgumentError)
-      lambda{@loc1.transfer(1,"rivendell")}.should_not raise_error(ArgumentError)
-    end
-    
-    it "should name-check the station parameter" do
-      lambda{@loc1.transfer(1,"nowhere")}.should raise_error(ArgumentError,
-        'self#transfer called with nonexistent station "nowhere"')
-      lambda{@loc1.transfer(1,"rivendell")}.should_not raise_error(ArgumentError)
-    end
-  end
-  
-  
-  describe "promote" do    
-    describe "to a specific station" do
-      before(:each) do
-        @loc1 = Station.new("bree")
-        @loc2 = Station.new("rivendell")
-        @loc3 = Station.new("numenor")
-        @loc4 = Station.new("washington")
-        @loc1.flows_into(@loc2)
-        @loc2.flows_into(@loc3)
-        @loc2.flows_into(@loc4)
-        @dude1 = Individual.new("block {}")
-        @loc1.add_individual @dude1
-      end
-      
-      it "should raise an exception if the new station isn't immediately downstream" do
-        lambda{@loc1.promote(0,"numenor")}.should raise_error(ArgumentError,
-          '"bree" is not connected to "numenor"')
-        lambda{@loc1.promote(0,"rivendell")}.should_not raise_error(ArgumentError)          
-      end
-      
-      it "should select a random downstream destination if none is specified" do
-        @loc1.promote(0)
-        @loc2.population.should include(@dude1)
-        @loc2.promote(0)
-        (@loc3.population + @loc4.population).should include(@dude1)
-      end
-      
-      it "should fail silently if there are no downstream stations" do
-        dude2 = Individual.new("do int_add")
-        @loc4.add_individual(dude2)
-        lambda{@loc4.promote(0)}.should_not raise_error
-        @loc4.promote(0)
-        @loc4.population.length.should == 1
-      end
-    end
-  end
-  
-  describe "promotion_rule" do
-    it "should default to false"
-    it "should be settable via a parameter with that name"
-  end
-  
-  
-  describe "promote?" do
-    before(:each) do
-      @loc1 = Station.new("bree")
-      @loc2 = Station.new("rivendell")
-      @loc3 = Station.new("numenor")
-      @loc4 = Station.new("washington")
-      @loc1.flows_into(@loc2)
-      @loc2.flows_into(@loc3)
-      @loc2.flows_into(@loc4)
-      @dude1 = Individual.new("block {}")
-      @loc1.add_individual @dude1
-    end
-    
-    it "should default to 'false'" do
-      @loc1.promote?(@loc1.population[0]).should == false
-    end
-    
-    it "should refer to self.promotion_rule to make the decision" do
-      @loc1.promotion_rule.stub(:call).and_return(999)
-      @loc1.promote?(@loc1.population[0]).should == 999
-    end
-  end
-  
-  
-  describe "review_and_promote" do
-    before(:each) do
-      @loc1 = Station.new("bree")
-      @loc2 = Station.new("rivendell")
-      @loc1.flows_into(@loc2)
-      @dude1 = Individual.new("block {}")
-      @loc1.add_individual @dude1
-    end
-    
-    it "should apply self.promote? to all members of the population" do
-      @loc1.should_receive(:promote?).once
-      @loc1.review_and_promote
-      
-      @loc1.add_individual @dude1 # again! Don't actually ever do this...
-      @loc1.should_receive(:promote?).twice
-      @loc1.review_and_promote
-    end
-    
-    it "should only send the ones for whom #promote? is true" do
-      @loc1.should_not_receive(:promote)
-      @loc1.review_and_promote
-    end
-    
-    it "should however actually lose the ones for whom #promote? is true" do
-      @loc2.population.length.should == 0
-      theGuy = @loc1.population[0]
-      @loc1.promotion_rule = Proc.new {|dude| true}
-      @loc1.review_and_promote
-      @loc2.population.length.should == 1
-      @loc2.population.should include(theGuy)
-    end
-    
-    it "should only move the ones for whom #promote? is true" do
-      dude2 = Individual.new("do something")
-      @loc1.add_individual dude2
-      @loc1.promotion_rule = Proc.new {|dude| dude.genome.include?("something")}
-      @loc1.review_and_promote
-      
-      @loc1.population.length.should == 1
-      @loc2.population.length.should == 1
-      @loc2.population.should_not include(@dude1)
-      @loc1.population.should include(@dude1)
-      @loc2.population.should include(dude2)
-      @loc1.population.should_not include(dude2)
-    end
-  end
-  
-  
-  describe "cull_check" do
-    it "should default to 'is population.length > capacity'?" do
-      loc1 = Station.new("here", capacity: 1)
-      dude1 = Individual.new("block {}")
-      loc1.add_individual dude1
-      loc1.population.length.should == 1
-      loc1.cull_check.call.should == false
-      loc1.add_individual dude1
-      loc1.population.length.should == 2
-      loc1.cull_check.call.should == true
-    end
-    
-    it "should be settable to some other Proc" do
-      loc1 = Station.new("here", cull_check: Proc.new {77})
-      loc1.cull_check.call.should == 77
-    end
-  end
-  
-  
-  describe "cull?" do
-    it "should be a method that returns a boolean" do
-      loc1 = Station.new("bree")
-      [true,false].should include(loc1.cull?)
-    end
-    
-    it "should invoke self#cull_check" do
-      loc1 = Station.new("amondul", capacity:1)
-      loc1.cull_check.should_receive(:call)
-      loc1.cull?
-    end
-  end
-  
-  
-  describe "cull" do
-    it "should invoke the cull_rule if cull? is true"
-    
-    it "should not invoke cull_rule if cull? is false"
-    
-    it "should invoke cull_rule repeatedly until cull? is false"
-    
-    it "should return an Array with the Individuals from self#population in it" do
-      pending
-      loc1 = Station.new("amondul", capacity:1)
-      loc1.add_individual Individual.new("block {}")
-      loc1.add_individual Individual.new("ref x")
-      loc1.cull_order.should be_a_kind_of(Array)
-      loc1.cull_order[0].should be_a_kind_of(Individual)
-      loc1.cull_order.length.should == loc1.population.length
-    end
-    
-    it "should default to random shuffle order" do
-      pending
-      loc1 = Station.new("amondul", capacity:1) # default rule
-      loc1.add_individual Individual.new("block {}")
-      loc1.add_individual Individual.new("ref x")
-      loc1.population.should_receive(:shuffle)
-      loc1.cull_order
-    end
-  end
-  
-  
-  describe "actual culling" do
-    it "should eventually satisfy the cull? condition" do
-      loc1 = Station.new("amondul",capacity:1) # will have a default cull_order
-      lDead = Station.stations[:DEAD]
-      loc1.add_individual Individual.new("block {}")
-      loc1.cull?.should == false
-      loc1.add_individual Individual.new("ref x")
-      loc1.cull?.should == true
-      
-      pending "This needs rewriting"
-      loc1.review_and_cull
-      loc1.cull?.should == false
-      lDead.population.length.should == 1
-    end
-    
-    it "should not fire unless self#cull? is true" do
-      loc1 = Station.new("amondul",capacity:1) # will have a default cull_order
-      lDead = Station.stations[:DEAD]
-      loc1.add_individual Individual.new("block {}")
-      loc1.cull?.should == false
-      loc1.review_and_cull
-      loc1.population.length.should == 1
-    end
-  end
-  
-  
-  describe "Station#generate" do
-    before(:each) do
-      @loc1 = Station.new("here",capacity:1)
-    end
-    
-    it "should access the breeding_pool when called" do
-      @loc1.should_receive(:breeding_pool).and_return(["mock filler"])
-      @loc1.generate()
-    end
-    
-    it "should invoke #generate_rule" do
-      @loc1.generate_rule.should_receive(:call).and_return(["some dude"])
-      @loc1.generate
-    end
-    
-    it "should end up with the results of generate_rule merged into its population" do
-      @loc1.generate_rule.should_receive(:call).and_return(["some dude"])
-      @loc1.generate
-      @loc1.population.should include("some dude")
-      
-      @loc1.generate_rule.should_receive(:call).and_return(["other dude"])
-      @loc1.generate
-      @loc1.population.length.should == 2
-    end
-  end
-  
-  
-  describe "generate_rule" do
-    before(:each) do
-      @loc1 = Station.new("here",capacity:1)
-      @loc1.settings.types = [IntType]
-    end
-    
-    it "should be possible to override the default by passing a param"
-    
-    it "should take one parameter" do
-      @loc1.generate_rule.arity.should == 1
-    end
-    
-    # detailed validation of inputs and output is a postponed story
-    
-    it "should return an array of individuals" do
-      newDudes = @loc1.generate_rule.call
-      newDudes.should be_a_kind_of(Array)
-      newDudes.each {|i| i.should be_a_kind_of(Individual)}
-    end
-  end
-  
-  
-  describe "core_cycle" do
-    before(:each) do
-      @loc1 = Station.new("here",capacity:1)
-      @loc2 = Station.new("there",capacity:1)
-      @loc1.flows_into(@loc2)
-      @loc1.settings.types = [IntType]
-      @loc2.settings.types = [IntType]
-    end
-    
-    it "should invoke #generate once" do
-      @loc1.should_receive(:generate)
-      @loc1.core_cycle
-    end
-    
-    it "should invoke #review_and_promote" do
-      @loc1.should_receive(:review_and_promote)
-      @loc1.core_cycle
-    end
-    
-    it "should invoke #cull once" do
-      @loc1.should_receive(:review_and_cull).once
-      @loc1.core_cycle
-      # there is one random guy here with the default generate rule
-    end
-    
-    it "should cull only enough to make the cull_trigger false" do
-      @loc1.add_individual(Individual.new("do die"))
-      @loc1.population.length.should == 1
-      
-      pending "This needs rewriting"
-      @loc1.core_cycle #this adds a new random dude AND CULLS HIM (capacity = 1)
-      @loc1.population.length.should == 1
-      Station.stations[:DEAD].population.length.should == 1
-      
-      @loc1.capacity = 2
-      @loc1.core_cycle #this adds a new random dude AND HE'S FINE (capacity = 2)
-      @loc1.population.length.should == 2
-      Station.stations[:DEAD].population.length.should == 1
-      
-      @loc1.cull_check.should_receive(:call).and_return(true, true, false)
-      @loc1.should_receive(:cull_order).and_return(@loc1.population)
-      @loc1.core_cycle  #now we have three dudes, two of which will die
-      @loc1.population.length.should == 1
-      Station.stations[:DEAD].population.length.should == 3
-    end
-  end
-end
-
-
-
-
-describe "DeadStation" do
-  it "should always exist" do
-    Station.cleanup
-    Station.stations.should include(:DEAD)
-    Station.stations[:DEAD].should be_a_kind_of(Station)
-    Station.stations[:DEAD].should be_a_kind_of(DeadStation)
-  end
-  
-  it "should have no capacity" do
-    Station.stations[:DEAD].capacity.should == nil
-  end
-end