zombie-chaser 0.0.3 → 0.1.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: zombie-chaser
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Andrew Grimm
@@ -12,19 +12,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-13 00:00:00 +11:00
+date: 2010-04-11 00:00:00 +10:00
 default_executable: zombie-chaser
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: gosu
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
+dependencies: []
+
 description: A zombie-themed graphic(al) user interface for mutation testing
 email: andrew.j.grimm@gmail.com
 executables: 
@@ -34,46 +25,48 @@ extensions: []
 extra_rdoc_files: 
 - README.txt
 files: 
+- History.txt
 - README.txt
 - Rakefile
 - bin/zombie-chaser
-- lib/chaser.rb
-- lib/human.rb
-- lib/interface.rb
-- lib/test_unit_handler.rb
-- lib/world.rb
-- lib/zombie_test_chaser.rb
+- lib/zombie-chaser/chaser.rb
+- lib/zombie-chaser/human.rb
+- lib/zombie-chaser/icons/death.png
+- lib/zombie-chaser/icons/robot.png
+- lib/zombie-chaser/interface.rb
+- lib/zombie-chaser/sprites/robot-attacking.png
+- lib/zombie-chaser/sprites/robot-dead.png
+- lib/zombie-chaser/sprites/robot-dying.png
+- lib/zombie-chaser/sprites/robot-idle.png
+- lib/zombie-chaser/sprites/robot-moving.png
+- lib/zombie-chaser/sprites/robot-turning.png
+- lib/zombie-chaser/sprites/tank-attacking.png
+- lib/zombie-chaser/sprites/tank-dead.png
+- lib/zombie-chaser/sprites/tank-idle.png
+- lib/zombie-chaser/sprites/tank-moving.png
+- lib/zombie-chaser/sprites/tank-turning.png
+- lib/zombie-chaser/sprites/witch-attacking.png
+- lib/zombie-chaser/sprites/witch-dead.png
+- lib/zombie-chaser/sprites/witch-idle.png
+- lib/zombie-chaser/sprites/witch-moving.png
+- lib/zombie-chaser/sprites/witch-turning.png
+- lib/zombie-chaser/sprites/zombie-attacking.png
+- lib/zombie-chaser/sprites/zombie-dead.png
+- lib/zombie-chaser/sprites/zombie-dying.png
+- lib/zombie-chaser/sprites/zombie-idle.png
+- lib/zombie-chaser/sprites/zombie-moving.png
+- lib/zombie-chaser/sprites/zombie-turning.png
+- lib/zombie-chaser/test_unit_handler.rb
+- lib/zombie-chaser/tiles/grass.png
+- lib/zombie-chaser/tiles/shrubbery.png
+- lib/zombie-chaser/ui.rb
+- lib/zombie-chaser/world.rb
+- lib/zombie-chaser/zombie_test_chaser.rb
 - test/fixtures/chased.rb
+- test/integration.rb
 - test/test_chaser.rb
 - test/test_unit.rb
 - test/test_zombie.rb
-- ui/icons/death.png
-- ui/icons/robot.png
-- ui/sprites/robot-attacking.png
-- ui/sprites/robot-dead.png
-- ui/sprites/robot-dying.png
-- ui/sprites/robot-idle.png
-- ui/sprites/robot-moving.png
-- ui/sprites/robot-turning.png
-- ui/sprites/tank-attacking.png
-- ui/sprites/tank-dead.png
-- ui/sprites/tank-idle.png
-- ui/sprites/tank-moving.png
-- ui/sprites/tank-turning.png
-- ui/sprites/witch-attacking.png
-- ui/sprites/witch-dead.png
-- ui/sprites/witch-idle.png
-- ui/sprites/witch-moving.png
-- ui/sprites/witch-turning.png
-- ui/sprites/zombie-attacking.png
-- ui/sprites/zombie-dead.png
-- ui/sprites/zombie-dying.png
-- ui/sprites/zombie-idle.png
-- ui/sprites/zombie-moving.png
-- ui/sprites/zombie-turning.png
-- ui/tiles/grass.png
-- ui/tiles/shrubbery.png
-- ui/ui.rb
 - zombie-chaser.gemspec
 has_rdoc: true
 homepage: http://andrewjgrimm.wordpress.com/2009/11/08/declare-war-on-everything-with-chaser/
@@ -105,6 +98,7 @@ specification_version: 3
 summary: Lightweight mutation testing ... with ZOMBIES!!!
 test_files: 
 - test/fixtures/chased.rb
+- test/integration.rb
 - test/test_chaser.rb
 - test/test_unit.rb
 - test/test_zombie.rb

data/lib/human.rb

@@ -1,189 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. ui])
-
-require "test_unit_handler"
-require "ui" #For actor superclass
-
-class Human < Actor
-  private_class_method :new
-  attr_reader :successful_step_count
-
-  def self.new_using_test_unit_handler(test_pattern, world)
-    new(test_pattern, world)
-  end
-
-  def initialize(test_pattern, world)
-    @status = nil #Currently only used by zombie
-    @world = world
-    @successful_step_count = 0
-    @health = :alive
-    @test_handler = TestUnitHandler.new(test_pattern, self)
-  end
-
-  def run
-    notify_world
-    @test_handler.run
-  end
-
-  def current_symbol
-    case @health
-    when :alive
-      "@"
-    when :dying
-      "*"
-    when :dead
-      "+"
-    end
-  end
-
-  def actor_type
-    'robot'
-  end
-
-  def actor_state
-    return "attacking" if @status == :attacking
-    case @health
-    when :alive
-      "moving"
-    when :dying
-      "dying"
-    when :dead
-      "dead"
-    end
-  end
-
-  def actor_direction
-    270.0
-  end
-
-  def notify_passing_step
-    @successful_step_count += 1
-    notify_world
-  end
-
-  def notify_failing_step
-    @health = :dying
-    notify_world
-  end
-
-  def dying?
-    @health == :dying
-  end
-
-  def dead?
-    @health == :dead
-  end
-
-  def finish_dying
-    sleep 0.5
-    raise "I'm not dead yet!" unless dying?
-    @health = :dead
-    notify_world
-    sleep 0.5
-  end
-
-  def notify_world
-    @world.something_happened
-  end
-
-  def get_eaten
-    @health = :dying unless dead?
-  end
-
-  def test_suite_size
-    @test_handler.test_suite_size
-  end
-
-end
-
-class MockHuman < Human
-  private_class_method :new
-
-  def self.new_using_results(results, world)
-    new(results, world)
-  end
-
-  def initialize(results, world)
-    @world = world
-    @results = results
-    @successful_step_count = 0
-    @health = :alive
-  end
-
-  def run
-    until @successful_step_count == @results.size
-      if @results[@successful_step_count] == :failure
-        @health = :dying
-        notify_world
-        return
-      end
-      notify_world
-      @successful_step_count += 1
-    end
-    notify_world
-  end
-
-  def test_suite_size
-    @results.size
-  end
-end
-
-class MockZombieList
-
-  def self.new_using_results(zombies_results, world)
-    zombies = zombies_results.map do |zombie_results|
-      MockZombie.new_using_results(zombie_results, world)
-    end
-    new(zombies)
-  end
-
-  def initialize(zombies)
-    @zombies = zombies
-    @current_zombie_number = 0
-  end
-
-  def supply_next_zombie
-    zombie = @zombies[@current_zombie_number]
-    @current_zombie_number += 1
-    zombie
-  end
-
-  def all_slain?
-    @current_zombie_number == @zombies.length
-  end
-end
-
-module ZombieInterface
-  def current_symbol
-    case @health
-    when :alive
-      "Z"
-    when :dying
-      "*"
-    when :dead
-      "+"
-    end
-  end
-
-  def actor_type
-    'zombie'
-  end
-
-  def actor_direction
-    90.0
-  end
-
-end
-
-class Zombie < Human
-  include ZombieInterface
-
-  def eat(human)
-    @status = :attacking #Even if the human's dead, look for leftovers
-    human.get_eaten
-  end
-end
-
-class MockZombie < MockHuman #Fixme provide a proper hierarchy
-  include ZombieInterface
-
-end

data/lib/interface.rb

@@ -1,86 +0,0 @@
-class Interface
-  attr_writer :human, :current_zombie
-end
-
-class ConsoleInterface < Interface
-
-  def initialize
-    @representations = []
-    @current_zombie = nil
-  end
-
-  def current_representation
-    if @current_zombie.nil?
-      "." * human_position + @human.current_symbol
-    elsif human_position > zombie_position
-      "." * zombie_position + @current_zombie.current_symbol + "." * (human_position - zombie_position - 1) + @human.current_symbol
-    else
-      "." * zombie_position + @current_zombie.current_symbol
-    end
-  end
-
-  def something_happened
-    @representations << current_representation
-    display_representation(@representations.last)
-  end
-
-  def display_representation(representation)
-    print "\r", representation
-    STDOUT.flush
-    sleep 0.2
-  end
-
-  def finish
-    puts
-  end
-
-  def human_position
-    adjust_for_screen_width(@human.successful_step_count)
-  end
-
-  def zombie_position
-    adjust_for_screen_width(@current_zombie.successful_step_count)
-  end
-
-  def adjust_for_screen_width(step_count)
-    max_position = 78.0
-    (step_count * max_position / [@human.test_suite_size, max_position].max).round
-  end
-
-end
-
-class NoInterface < ConsoleInterface
-  attr_reader :representations
-
-  def display_representation(representation)
-    #Do nothing
-  end
-
-  def finish
-    #Do nothing
-  end
-end
-
-class GuiInterface < Interface
-
-  def initialize
-    @window = Window.new
-    #Actor.window = @window #Fixme why can't this do the trick?
-    Human.window = @window
-    Zombie.window = @window
-    @window_showing_thread = Thread.new {@window.show}
-  end
-
-  #Doesn't need to be used, as window updates 60 times a second anyway
-  def something_happened
-  end
-
-  def human=(human)
-    @window.human = human
-  end
-
-  def current_zombie=(current_zombie)
-    @window.current_zombie = current_zombie
-  end
-
-end

data/lib/test_unit_handler.rb

@@ -1,43 +0,0 @@
-require "test/unit/collector/objectspace"
-require "test/unit/ui/testrunnermediator"
-
-class TestUnitHandler
-  attr_reader :results, :test_suite_size
-
-  def initialize(test_pattern, actor)
-    @actor = actor
-    raise "Error: can't detect any files in test pattern \"#{test_pattern} (Don't forget to use forward slashes even in Windows)" if Dir.glob(test_pattern).empty?
-    Dir.glob(test_pattern).each {|test| require test} #In heckle, this is separated out
-    @finished = false
-    @results = []
-    @step_count = 0
-    obj_sp = Test::Unit::Collector::ObjectSpace.new
-    test_suite = Test::Unit::TestSuite.new("Mutation slayer test suite")
-    test_suite << obj_sp.collect
-    @test_suite_size = test_suite.size
-    @test_runner_mediator =  Test::Unit::UI::TestRunnerMediator.new(test_suite)
-    @test_runner_mediator.add_listener(Test::Unit::TestResult::FAULT) {test_failed}
-    @test_runner_mediator.add_listener(Test::Unit::TestCase::FINISHED) {test_finished}
-
-  end
-
-  def run
-    catch(:stop_test_runner) do
-      @test_runner_mediator.run_suite
-    end
-  end
-
-  def test_failed
-    @results << :failure
-    @actor.notify_failing_step
-    sleep 0.5
-    throw :stop_test_runner
-  end
-
-  def test_finished
-    sleep 0.1 #Hack to avoid it being too quick
-    @results << :pass
-    @actor.notify_passing_step
-  end
-
-end

data/lib/zombie_test_chaser.rb

@@ -1,133 +0,0 @@
-#!/usr/bin/env ruby
-
-require "test/unit/collector/objectspace"
-require "test/unit/ui/testrunnermediator"
-require 'chaser'
-
-$: << 'lib' << 'test'
-
-# Make sure test/unit doesn't swallow our timeout
-begin
-  Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS << Chaser::Timeout
-rescue NameError
-  # ignore
-end
-
-class ZombieTestChaser < Chaser
-
-  VERSION = '0.0.3'
-
-  @@test_pattern = 'test/test_*.rb'
-  @@tests_loaded = false
-  @@world = nil
-
-  def self.test_pattern=(value)
-    @@test_pattern = value
-  end
-
-  def self.create_world
-    @@tests_loaded = true
-    @@world = World.new_using_test_unit_handler(@@test_pattern)
-  end
-
-  def self.world
-    @@world
-  end
-
-  def self.current_class_names(exclude_list)
-    result = []
-    ObjectSpace.each_object(Class) do |klass|
-      next if klass.to_s.include?("Class:0x")
-      next unless klass.ancestors.all? {|ancestor| (ancestor.to_s.split(/::/) & exclude_list).empty?}
-      result << klass.to_s
-    end
-    result
-  end
-
-  def self.validate(klass_name = nil, method_name = nil, force = false)
-    pre_existing_class_names = self.current_class_names([]) unless klass_name
-    create_world
-
-    if klass_name
-      klass = klass_name.to_class
-      # Does the method exist?
-      klass_methods = klass.singleton_methods(false).collect {|meth| "self.#{meth}"}
-      if method_name
-        if method_name =~ /self\./
-          abort "Unknown method: #{klass_name}.#{method_name.gsub('self.', '')}" unless klass_methods.include? method_name
-        else
-          abort "Unknown method: #{klass_name}##{method_name}" unless klass.instance_methods(false).map{|sym| sym.to_s}.include? method_name
-        end
-      end
-    end
-
-    initial_time = Time.now
-
-    chaser = self.new(klass_name)
-
-    passed = chaser.human_survives?
-
-    unless force or passed then
-      abort "Initial run of tests failed... fix and run chaser again"
-    end
-
-    if self.guess_timeout? then
-      running_time = Time.now - initial_time
-      adjusted_timeout = (running_time * 2 < 5) ? 5 : (running_time * 2).ceil
-      self.timeout = adjusted_timeout
-    end
-
-    puts "Timeout set to #{adjusted_timeout} seconds."
-
-    if passed then
-      puts "Initial tests pass. Let's rumble."
-    else
-      puts "Initial tests failed but you forced things. Let's rumble."
-    end
-    puts
-
-    counts = Hash.new(0)
-
-    klass_names = klass_name ? Array(klass_name) : self.current_class_names(["Test"]) - pre_existing_class_names
-    klass_names.each do |block_klass_name|
-      block_klass = block_klass_name.to_class
-
-      methods = method_name ? Array(method_name) : block_klass.instance_methods(false) + block_klass.singleton_methods(false).collect {|meth| "self.#{meth}"}
-
-      methods.sort.each do |block_method_name|
-        result = self.new(block_klass_name, block_method_name).validate
-        counts[result] += 1
-      end
-    end
-    all_good = counts[false] == 0
-
-    puts "Chaser Results:"
-    puts
-    puts "Passed    : %3d" % counts[true]
-    puts "Failed    : %3d" % counts[false]
-    puts
-
-    if all_good then
-      puts "All chasing was thwarted! YAY!!!"
-    else
-      puts "Improve the tests and try again."
-    end
-
-    all_good
-  end
-
-  def human_survives?
-    self.class.world.run_human
-  end
-
-  def zombie_survives?
-    zombie = self.class.world.create_zombie_using_test_unit_handler
-    self.class.world.run_zombie(zombie)
-  end
-
-  def initialize(klass_name=nil, method_name=nil)
-    super
-    self.class.create_world unless @@tests_loaded
-  end
-
-end