zombie-chaser 0.0.3 → 0.1.0

data/test/test_unit.rb

@@ -1,2 +1,2 @@
-require "test/test_chaser.rb"
-require "test/test_zombie.rb"
+require "test_chaser.rb"
+require "test_zombie.rb"

data/test/test_zombie.rb

@@ -1,108 +1,302 @@
-$: << "lib"
-
-require "test/unit"
-require "world"
-
-module TestHumanHelper
-  def assert_that_representations_include(expected_representation, human_results, failure_message)
-    world = create_world(human_results)
-    actual_representations = world.interface.representations
-    assert actual_representations.include?(expected_representation), failure_message + "Expected #{expected_representation}, got #{actual_representations.inspect}"
-  end
-
-  def assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
-    world = create_world(human_results, zombies_results)
-    actual_representations = world.interface.representations
-    expected_representations.each do |expected_representation|
-      assert actual_representations.include?(expected_representation), failure_message + ": Expected #{expected_representation}, got #{actual_representations.inspect}"
-    end
-  end
-
-  def create_world(human_results, zombies_results = [])
-    world = World.new_using_results(human_results, zombies_results)
-    world.run
-    world
-  end
-end
-
-class TestHuman < Test::Unit::TestCase
-  include TestHumanHelper
-
-  def test_human_single_success
-    human_results = [:pass]
-    failure_message = "Can't handle single success"
-    assert_that_representations_include(".@", human_results, failure_message)
-  end
-
-  def test_human_single_failure
-    human_results = [:failure]
-    failure_message = "Can't handle single failure"
-    assert_that_representations_include("+", human_results, failure_message)
-  end
-
-  def test_human_two_successes
-    human_results = [:pass, :pass]
-    expected_representations = ["@", ".@", "..@"]
-    failure_message = "Needs to be able to do multiple steps"
-    #This'll run the simulation three times. Optimize if neccessary (it isn't yet)
-    expected_representations.each do |expected_representation|
-      assert_that_representations_include(expected_representation, human_results, failure_message)
-    end
-  end
-
-  def test_human_success_failure
-    human_results = [:pass, :failure]
-    expected_representation = ".+"
-    failure_message = "Can't handle success and failure"
-    assert_that_representations_include(expected_representation, human_results, failure_message)
-  end
-
-  def test_human_success_failure_success
-    human_results = [:pass, :failure, :pass]
-    expected_representation = ".+"
-    failure_message = "Can't handle success and failure"
-    assert_that_representations_include(expected_representation, human_results, failure_message)
-  end
-
-  def test_human_exploding
-    human_results = [:pass, :failure]
-    expected_representation = ".*"
-    failure_message = "Doesn't represent the human exploding"
-    assert_that_representations_include(expected_representation, human_results, failure_message)
-  end
-
-end
-
-class TestZombie < Test::Unit::TestCase
-  include TestHumanHelper
-
-  def test_human_surviving_zombie_slaying
-    human_results = [:pass, :pass]
-    zombies_results = [[:failure]]
-    expected_representations = ["..@", "*.@"]
-    failure_message = "Can't represent a zombie slaying."
-    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
-  end
-
-  def test_human_surviving_zombie_slaying2
-    human_results = [:pass, :pass, :pass]
-    zombies_results = [[:pass, :failure]]
-    expected_representations = ["...@", "Z..@", ".*.@"]
-    failure_message = "Can't represent a zombie slaying."
-    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
-  end
-
-end
-
-class TestConsoleInterface < Test::Unit::TestCase
-  include TestHumanHelper
-
-  def test_excessive_tests_dont_make_it_run_off_the_page
-    human_results = [:pass] * 500
-    zombies_results = [[:pass, :failure]]
-    expected_representations = ["Z" + "." * 77 + "@"] #Having 80 characters in a line doesn't work
-    failure_message = "Doesn't handle large number of tests properly"
-    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
-  end
-
-end
+require "test/unit"
+require "zombie-chaser/world"
+require "timeout"
+
+module TestHumanHelper
+  def assert_that_representations_include(expected_representation, human_results, failure_message)
+    world = create_world(human_results)
+    actual_representations = world.interface.representations
+    assert actual_representations.include?(expected_representation), failure_message + "Expected #{expected_representation}, got #{actual_representations.inspect}"
+  end
+
+  def assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
+    world = create_world(human_results, zombies_results)
+    actual_representations = world.interface.representations
+    expected_representations.each do |expected_representation|
+      assert actual_representations.include?(expected_representation), failure_message + ": Expected #{expected_representation}, got #{actual_representations.inspect}"
+    end
+  end
+
+  def assert_adjusted_width_representations_include_representations(expected_representations, human_results, zombies_results, console_width, failure_message)
+    world = create_world_with_set_console_width(human_results, zombies_results, console_width)
+    actual_representations = world.interface.representations
+    expected_representations.each do |expected_representation|
+      assert actual_representations.include?(expected_representation), failure_message + ": Expected #{expected_representation}, got #{actual_representations.inspect}"
+    end
+  end
+
+  def assert_that_representations_do_not_include(unexpected_representation, human_results, zombies_results, failure_message)
+    world = create_world(human_results, zombies_results)
+    actual_representations = world.interface.representations
+    assert_equal false, actual_representations.include?(unexpected_representation), failure_message + ": Didn't expect #{unexpected_representation}, got #{actual_representations.inspect}"
+  end
+
+  def assert_that_representations_include_regexp_match(expected_regexp, human_results, zombies_results, failure_message)
+    world = create_world(human_results, zombies_results)
+    actual_representations = world.interface.representations
+    assert actual_representations.any?{|actual_representation| actual_representation =~ expected_regexp}, failure_message + ": Expected #{expected_regexp.inspect} would match something in #{actual_representations.inspect}"
+  end
+
+  def assert_that_representations_do_not_include_regexp_match(unexpected_regexp, human_results, zombies_results, failure_message)
+    world = create_world(human_results, zombies_results)
+    actual_representations = world.interface.representations
+    assert_equal false, actual_representations.any?{|actual_representation| puts actual_representation if actual_representation =~ unexpected_regexp; actual_representation =~ unexpected_regexp}, failure_message + ": Didn't expect #{unexpected_regexp.inspect} would match something in #{actual_representations.inspect}"
+  end
+
+  def assert_that_human_deadness_is(human_expected_to_die, human_results, zombies_results, failure_message)
+    world = create_world(human_results, zombies_results)
+    assert_equal human_expected_to_die, world.human_dead?, failure_message
+  end
+
+  def assert_that_counts_are(expected_counts, human_results, zombies_results, failure_message)
+    world = World.new_using_results(human_results, zombies_results)
+    actual_counts = Hash.new(0)
+    world.while_world_running do
+      assert world.run_human, "Human unexpectedly died"
+      zombies_results.size.times do
+        begin
+          # Chaser#validate returns true if chaser-proof, and false if mutations to it still pass its unit tests
+          # Hence the "not" in the next line
+          result = (not world.run_next_zombie)
+        rescue Timeout::Error
+          result = true
+        end
+        actual_counts[result] += 1
+      end
+    end
+    assert_equal expected_counts, actual_counts, failure_message
+  end
+
+  def assert_does_not_deadlock(human_results, zombies_results, failure_message)
+    assert_nothing_raised(failure_message) do
+      timeout(1) do
+        world = create_world(human_results, zombies_results)
+      end
+    end
+  end
+
+  def create_world(human_results, zombies_results = [])
+    world = World.new_using_results(human_results, zombies_results)
+    world.while_world_running do
+      human_survives = world.run_human
+      if human_survives
+        zombies_results.size.times do
+          begin
+            world.run_next_zombie
+          rescue Timeout::Error
+            #Don't worry about it
+          end
+        end
+      end
+    end
+    world
+  end
+end
+
+class TestHuman < Test::Unit::TestCase
+  include TestHumanHelper
+
+  def test_human_single_success
+    human_results = [:pass]
+    failure_message = "Can't handle single success"
+    assert_that_representations_include(".@", human_results, failure_message)
+  end
+
+  def test_human_single_failure
+    human_results = [:failure]
+    failure_message = "Can't handle single failure"
+    assert_that_representations_include("+", human_results, failure_message)
+  end
+
+  def test_human_two_successes
+    human_results = [:pass, :pass]
+    expected_representations = ["@", ".@", "..@"]
+    failure_message = "Needs to be able to do multiple steps"
+    #This'll run the simulation three times. Optimize if neccessary (it isn't yet)
+    expected_representations.each do |expected_representation|
+      assert_that_representations_include(expected_representation, human_results, failure_message)
+    end
+  end
+
+  def test_human_success_failure
+    human_results = [:pass, :failure]
+    expected_representation = ".+"
+    failure_message = "Can't handle success and failure"
+    assert_that_representations_include(expected_representation, human_results, failure_message)
+  end
+
+  def test_human_success_failure_success
+    human_results = [:pass, :failure, :pass]
+    expected_representation = ".+"
+    failure_message = "Can't handle success and failure"
+    assert_that_representations_include(expected_representation, human_results, failure_message)
+  end
+
+  def test_human_exploding
+    human_results = [:pass, :failure]
+    expected_representation = ".*"
+    failure_message = "Doesn't represent the human exploding"
+    assert_that_representations_include(expected_representation, human_results, failure_message)
+  end
+
+end
+
+class TestZombie < Test::Unit::TestCase
+  include TestHumanHelper
+
+  def test_human_surviving_zombie_slaying
+    human_results = [:pass, :pass]
+    zombies_results = [[:failure]]
+    expected_representations = ["..@", "*.@"]
+    failure_message = "Can't represent a zombie slaying."
+    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
+  end
+
+  def test_human_surviving_zombie_slaying2
+    human_results = [:pass, :pass, :pass]
+    zombies_results = [[:pass, :failure]]
+    expected_representations = ["...@", "Z..@", ".*.@"]
+    failure_message = "Can't represent a zombie slaying."
+    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
+  end
+
+  #Describes existing behaviour, but added to ensure a future commit works properly
+  def test_zombies_dont_appear_if_human_doesnt_survive_unit_tests
+    human_results = [:pass, :failure]
+    zombies_results = [[:pass, :failure]]
+    unexpected_representation = "Z+"
+    failure_message = "Doesn't stop after failed unmutated unit tests"
+    assert_that_representations_do_not_include(unexpected_representation, human_results, zombies_results, failure_message)
+  end
+
+  def test_corpse_littered_landscape
+    human_results = [:pass, :pass, :pass]
+    zombies_results = [[:pass, :failure],[:failure]]
+    expected_representations = ["++.@"]
+    failure_message = "Can't display a corpse littered landscape"
+    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
+  end
+
+  def test_multiple_living_zombies_visible
+    human_results = [:pass] * 10
+    zombies_results = [[:pass]* 8 + [:failure]] * 5
+    expected_regexp = /ZZ/
+    failure_message = "Can't display multiple zombies at once"
+    assert_that_representations_include_regexp_match(expected_regexp, human_results, zombies_results, failure_message)
+  end
+
+  def test_timeouts_in_test_dont_cause_frozen_zombies
+    human_results = [:pass]
+    zombies_results = [[:timeout]]
+    failure_message = "Doesn't handle timeouts"
+    assert_does_not_deadlock(human_results, zombies_results, failure_message)
+  end
+end
+
+class TestConsoleInterface < Test::Unit::TestCase
+  include TestHumanHelper
+
+  #Put inside of this test case so that only things with this test case's teardown can use it
+  def create_world_with_set_console_width(human_results, zombies_results, width)
+    ConsoleInterface.width = width
+    world = create_world(human_results, zombies_results)
+    world
+  end
+
+  def test_excessive_tests_dont_make_it_run_off_the_page
+    human_results = [:pass] * 500
+    zombies_results = [[:pass, :failure]]
+    expected_representations = ["Z" + "." * 77 + "@"] #Having 80 characters in a line doesn't work
+    failure_message = "Doesn't handle large number of tests properly"
+    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
+  end
+
+  def test_console_width_configurable
+    human_results = [:pass] * 500
+    zombies_results = [[:pass, :failure]]
+    console_width = 11
+    expected_representations = ["Z" + "." * 9 + "@"]
+    failure_message = "Doesn't allow console width to be configurable"
+    assert_adjusted_width_representations_include_representations(expected_representations, human_results, zombies_results, console_width, failure_message)
+  end
+
+  def test_zombies_do_not_trample_non_dead_zombies
+    human_results = [:pass, :pass]
+    zombies_results = [[:pass, :failure], [:pass, :pass]]
+    expected_representations = ["Z*@", "Z+@"]
+    failure_message = "Zombies are trampling on non-dead zombies"
+    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
+  end
+
+  def dont_test_zombies_do_not_collide
+    human_results = [:pass] * 10
+    zombies_results = [[:pass] * 10, [:pass] * 10]
+    unexpected_regexp = /\A\.\.+Z\.+\@/ #Only one square with zombies, the second zombie should have appeared by now, and the human hasn't been eaten
+    failure_message = "Zombies are sharing the same square"
+    100.times do |i|
+      assert_that_representations_do_not_include_regexp_match(unexpected_regexp, human_results, zombies_results, failure_message + "(attempt #{i})")
+    end
+  end
+
+  def test_multiple_successful_zombies_do_not_deadlock
+    human_results = [:pass] * 2
+    zombies_results = [[:pass] * 2] * 2
+    failure_message = "Multiple successful zombies deadlock (pardon the pun)"
+    assert_does_not_deadlock(human_results, zombies_results, failure_message)
+  end
+
+  #Confirming existing behaviour
+  def test_zombie_does_not_deadlock_when_console_position_adjusted
+    ConsoleInterface.width = 10
+    human_results = [:pass] * 25
+    zombies_results = [[:pass]*25]
+    failure_message = "A zombie that isn't changing squares because of width limitations deadlocks (pardon the pun)"
+    assert_does_not_deadlock(human_results, zombies_results, failure_message)
+  end
+
+  def teardown
+    ConsoleInterface.width = 79
+  end
+
+end
+
+class TestZombieHumanInteraction < Test::Unit::TestCase
+  include TestHumanHelper
+
+  def test_zombies_eat_human
+    human_results = [:pass, :pass]
+    zombies_results = [[:pass, :pass]]
+    human_expected_to_die = true
+    failure_message = "Human not eaten"
+    assert_that_human_deadness_is human_expected_to_die, human_results, zombies_results, failure_message
+  end
+end
+
+class TestResultsReporting < Test::Unit::TestCase
+  include TestHumanHelper
+
+  def test_killed_zombies_reported_as_success
+    human_results = [:pass]
+    zombies_results = [[:failure]]
+    expected_counts = {true=>1}
+    failure_message = "All zombies killed not regarded as all good"
+    assert_that_counts_are expected_counts, human_results, zombies_results, failure_message
+  end
+
+  def test_unkilled_zombies_reported_as_failure
+    human_results = [:pass]
+    zombies_results = [[:pass]]
+    expected_counts = {false => 1}
+    failure_message = "Unkilled zombie not regarded as a problem"
+    assert_that_counts_are expected_counts, human_results, zombies_results, failure_message
+  end
+
+  def test_timeouts_reported_as_success
+    human_results = [:pass]
+    zombies_results = [[:timeout]]
+    expected_counts = {true => 1}
+    failure_message = "Zombie causing timeout not regarded as all good"
+    assert_that_counts_are expected_counts, human_results, zombies_results, failure_message
+  end
+
+end

data/zombie-chaser.gemspec

@@ -1,88 +1,88 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{zombie-chaser}
-  s.version = "0.0.3"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Andrew Grimm", "Ryan Davis", "Eric Hodel", "Kevin Clark"]
-  s.date = %q{2009-12-13}
-  s.default_executable = %q{zombie-chaser}
-  s.description = %q{A zombie-themed graphic(al) user interface for mutation testing}
-  s.email = %q{andrew.j.grimm@gmail.com}
-  s.executables = ["zombie-chaser"]
-  s.extra_rdoc_files = [
-    "README.txt"
-  ]
-  s.files = [
-    "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",
-     "test/fixtures/chased.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"
-  ]
-  s.homepage = %q{http://andrewjgrimm.wordpress.com/2009/11/08/declare-war-on-everything-with-chaser/}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Lightweight mutation testing ... with ZOMBIES!!!}
-  s.test_files = [
-    "test/fixtures/chased.rb",
-     "test/test_chaser.rb",
-     "test/test_unit.rb",
-     "test/test_zombie.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<gosu>, [">= 0"])
-    else
-      s.add_dependency(%q<gosu>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<gosu>, [">= 0"])
-  end
-end
-
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{zombie-chaser}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andrew Grimm", "Ryan Davis", "Eric Hodel", "Kevin Clark"]
+  s.date = %q{2010-04-11}
+  s.default_executable = %q{zombie-chaser}
+  s.description = %q{A zombie-themed graphic(al) user interface for mutation testing}
+  s.email = %q{andrew.j.grimm@gmail.com}
+  s.executables = ["zombie-chaser"]
+  s.extra_rdoc_files = [
+    "README.txt"
+  ]
+  s.files = [
+    "History.txt",
+     "README.txt",
+     "Rakefile",
+     "bin/zombie-chaser",
+     "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",
+     "zombie-chaser.gemspec"
+  ]
+  s.homepage = %q{http://andrewjgrimm.wordpress.com/2009/11/08/declare-war-on-everything-with-chaser/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Lightweight mutation testing ... with ZOMBIES!!!}
+  s.test_files = [
+    "test/fixtures/chased.rb",
+     "test/integration.rb",
+     "test/test_chaser.rb",
+     "test/test_unit.rb",
+     "test/test_zombie.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+