heckle 1.4.1 → 1.4.2

data/.autotest

@@ -0,0 +1,16 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+Autotest.add_hook :initialize do |at|
+  at.libs << ":../../RubyInline/dev/lib"
+  at.libs << ":../../ParseTree/dev/lib:../../ParseTree/dev/test"
+  at.libs << ":../../sexp_processor/dev/lib"
+  at.libs << ":../../ruby2ruby/dev/lib"
+
+  %w(Dasgn Iter Dasgncurr Cvasgn Boolean Call Callblock
+     ClassMethod Gasgn Iasgn If Lasgn Masgn Ranges Regexes
+     SameLiteral Strings Symbols Until While).each do |klass|
+    at.extra_class_map["TestHeckle#{klass}"] = "test/test_heckle.rb"
+  end
+end

data/History.txt

@@ -1,6 +1,16 @@
+=== 1.4.2 / 2009-02-08
+
+* 2 bug fixes:
+
+  * Fixed Ruby2Ruby dependency and Ruby2Ruby references (name changed).
+    Reported by David Chelimsky
+  * Fix bug #11435 where [:iter, [:call], ...] would cause an endless
+    loop.  Reported by Thomas Preymesser.
+
 === 1.4.1 / 2007-06-05
 
 * 3 bug fixes:
+
   * Add zentest as a heckle dependency. Closes #10996
   * Fixed heckling of call with blocks.
   * Fix test_unit_heckler's test_pass? so it returns the result of the
@@ -9,9 +19,12 @@
 === 1.4.0 / 2007-05-18
 
 * 2 major enhancements:
+
   * Method calls are now heckled (by removal).
   * Assignments are now heckled (by value changing).
+
 * 3 minor enhancements:
+
   * Added --focus to feel the Eye of Sauron (specify unit tests to run).
   * Specify nodes to be included/excluded in heckle with -n/-x.
   * Test only assignments with --assignments
@@ -19,31 +32,42 @@
 === 1.3.0 / 2007-02-12
 
 * 1 major enhancement:
+
   * Unified diffs for mutatated methods
+
 * 4 minor enhancements:
+
   * Now returns exit status 1 if failed.
   * Added a simple report at the end.
   * Runs are now sorted by method.
   * Autodetects rails and changes test_pattern accordingly.
+
 * 2 bug fixes:
+
   * Aborts when an unknown method is supplied.
   * Escapes slashes in random regexps.
 
 === 1.2.0 / 2007-01-15
 
 * 2 major enhancements:
+
   * Timeout for tests set dynamically and overridable with -T
   * Class method support with "self.method_name"
+
 * 3 minor enhancements:
+
   * -b allows heckling of branches only
   * Restructured class heirarchy and got rid of Base and others.
   * Revamped the tests and reduced size by 60%.
+
 * 1 bug fix:
+
   * Fixed the infinite loop caused by syntax errors
 
 === 1.1.1 / 2006-12-20
 
 * 3 bug fixes:
+
   * Load tests properly when supplying method name.
   * Make sure random symbols have at least one character.
   * Removed all extra warnings from the unit tests. Consolidated and cleaned.
@@ -51,6 +75,7 @@
 === 1.1.0 / 2006-12-19
 
 * 12 major enhancements:
+
   * Able to roll back original method after processing.
   * Can mutate numeric literals.
   * Can mutate strings.
@@ -67,4 +92,5 @@
 === 1.0.0 / 2006-10-22
 
 * 1 major enhancement
+
   * Birthday!

data/Manifest.txt

@@ -1,3 +1,4 @@
+.autotest
 History.txt
 Manifest.txt
 README.txt

data/README.txt

@@ -1,10 +1,11 @@
-heckle
-    http://www.rubyforge.org/projects/seattlerb
-    by Ryan Davis and Kevin Clark
+= heckle
+
+* http://www.rubyforge.org/projects/seattlerb
+* http://seattlerb.rubyforge.org/heckle
 
 == DESCRIPTION:
 
-Heckle is a mutation tester. It modifies your code and runs your tests to make sure they fail. The idea is that if code can be changed and your tests don't notice, either that code isn't being covered or it doesn't do anything.
+Heckle is unit test sadism(tm) at it's core. Heckle is a mutation tester. It modifies your code and runs your tests to make sure they fail. The idea is that if code can be changed and your tests don't notice, either that code isn't being covered or it doesn't do anything.
 
 It's like hiring a white-hat hacker to try to break into your server and making sure you detect it. You learn the most by trying to break things and watching the outcome in an act of unit test sadism.
 
@@ -20,18 +21,18 @@ It's like hiring a white-hat hacker to try to break into your server and making
 
 == REQUIREMENTS:
 
-+ ruby2ruby 1.1.2 or greater
-+ ParseTree 1.6.1 or greater
+* ruby2ruby 1.1.2 or greater
+* ParseTree 1.6.1 or greater
 
 == INSTALL:
 
-+ sudo gem install heckle
+* sudo gem install heckle
 
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2006 Ryan Davis and Kevin Clark
+Copyright (c) 2006-2008 Ryan Davis and Kevin Clark
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,21 +1,30 @@
 # -*- ruby -*-
 
-$: << 'lib'
-
 require 'rubygems'
 require 'hoe'
+
+Hoe.add_include_dirs("../../ParseTree/dev/lib",
+                     "../../ParseTree/dev/test",
+                     "../../RubyInline/dev/lib",
+                     "../../ruby2ruby/dev/lib",
+                     "../../ZenTest/dev/lib",
+                     "../../sexp_processor/dev/lib",
+                     "lib")
+
 require './lib/heckle.rb'
 
-Hoe.new('heckle', Heckle::VERSION) do |p|
-  p.rubyforge_name = 'seattlerb'
-  p.summary = 'Unit Test Sadism'
-  p.description = p.paragraphs_of('README.txt', 2).join("\n\n")
-  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
-  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+Hoe.new('heckle', Heckle::VERSION) do |heckle|
+  heckle.rubyforge_name = 'seattlerb'
+
+  heckle.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+  heckle.developer('Eric Hodel', 'drbrain@segment7.net')
+  heckle.developer('Kevin Clark', 'kevin.clark@gmail.com')
+
+  heckle.clean_globs << File.expand_path("~/.ruby_inline")
 
-  p.extra_deps << ['ruby2ruby', '>= 1.1.0']
-  p.extra_deps << ['ZenTest', '>= 3.5.2']
-  
+  heckle.extra_deps << ['ParseTree', '>= 2.0.0']
+  heckle.extra_deps << ['ruby2ruby', '>= 1.1.6']
+  heckle.extra_deps << ['ZenTest', '>= 3.5.2']
 end
 
 # vim: syntax=Ruby

data/bin/heckle

@@ -4,25 +4,31 @@ $:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
 require 'test_unit_heckler'
 require 'optparse'
 
+force = false
 nodes = Heckle::MUTATABLE_NODES
 
 opts = OptionParser.new do |opts|
   opts.banner = "Usage: #{File.basename($0)} class_name [method_name]"
-  opts.on( "-v", "--verbose", "Loudly explain heckle run" ) do |opt|
+  opts.on("-v", "--verbose", "Loudly explain heckle run") do |opt|
     TestUnitHeckler.debug = true
   end
 
-  opts.on( "-V", "--version", "Prints Heckle's version number") do |opt|
+  opts.on("-V", "--version", "Prints Heckle's version number") do |opt|
     puts "Heckle #{Heckle::VERSION}"
     exit 0
   end
 
-  opts.on( "-t", "--tests TEST_PATTERN",
-           "Location of tests (glob)" ) do |pattern|
+  opts.on("-t", "--tests TEST_PATTERN",
+          "Location of tests (glob)") do |pattern|
     TestUnitHeckler.test_pattern = pattern
   end
 
-  opts.on(       "--assignments", "Only mutate assignments" ) do |opt|
+  opts.on("-F", "--force", "Ignore initial test failures",
+          "Best used with --focus") do |opt|
+    force = true
+  end
+
+  opts.on(      "--assignments", "Only mutate assignments") do |opt|
     puts "!"*70
     puts "!!! Heckling assignments only"
     puts "!"*70
@@ -31,7 +37,7 @@ opts = OptionParser.new do |opts|
     nodes = Heckle::ASGN_NODES
   end
 
-  opts.on( "-b", "--branches", "Only mutate branches" ) do |opt|
+  opts.on("-b", "--branches", "Only mutate branches") do |opt|
     puts "!"*70
     puts "!!! Heckling branches only"
     puts "!"*70
@@ -40,7 +46,7 @@ opts = OptionParser.new do |opts|
     nodes = Heckle::BRANCH_NODES
   end
 
-  opts.on( "-f", "--focus", "Apply the eye of sauron" ) do |opt|
+  opts.on("-f", "--focus", "Apply the eye of sauron") do |opt|
     puts "!"*70
     puts "!!! Running in focused mode. FEEL THE EYE OF SAURON!!!"
     puts "!"*70
@@ -49,25 +55,25 @@ opts = OptionParser.new do |opts|
     TestUnitHeckler.focus = true
   end
 
-  opts.on( "-T", "--timeout SECONDS", "The maximum time for a test run in seconds",
+  opts.on("-T", "--timeout SECONDS", "The maximum time for a test run in seconds",
                                      "Used to catch infinite loops") do |timeout|
     Heckle.timeout = timeout.to_i
     puts "Setting timeout at #{timeout} seconds."
   end
 
-  opts.on( "-n", "--nodes NODES", "Nodes to mutate",
-                                  "Possible values: #{Heckle::MUTATABLE_NODES.join(',')}" ) do |opt|
+  opts.on("-n", "--nodes NODES", "Nodes to mutate",
+          "Possible values: #{Heckle::MUTATABLE_NODES.join(',')}") do |opt|
     nodes = opt.split(',').collect {|n| n.to_sym }
     puts "Mutating nodes: #{nodes.inspect}"
   end
 
-  opts.on( "-x", "--exclude-nodes NODES", "Nodes to exclude") do |opt|
+  opts.on("-x", "--exclude-nodes NODES", "Nodes to exclude") do |opt|
     exclusions = opt.split(',').collect {|n| n.to_sym }
     nodes = nodes - exclusions
     puts "Mutating without nodes: #{exclusions.inspect}"
   end
 
-  opts.on( "-h", "--help", "Show this message") do |opt|
+  opts.on("-h", "--help", "Show this message") do |opt|
     puts opts
     exit 0
   end
@@ -86,4 +92,5 @@ unless impl then
   exit 1
 end
 
-exit TestUnitHeckler.validate(impl, meth, nodes)
+exit TestUnitHeckler.validate(impl, meth, nodes, force)
+

data/lib/heckle.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'parse_tree'
+require 'sexp_processor'
 require 'ruby2ruby'
 require 'timeout'
 require 'tempfile'
@@ -15,10 +16,12 @@ end
 
 class Heckle < SexpProcessor
 
+  class Timeout < Timeout::Error; end
+
   ##
   # The version of Heckle you are using.
 
-  VERSION = '1.4.1'
+  VERSION = '1.4.2'
 
   ##
   # Branch node types.
@@ -79,6 +82,10 @@ class Heckle < SexpProcessor
   @@guess_timeout = true
   @@timeout = 60 # default to something longer (can be overridden by runners)
 
+  def self.debug
+    @@debug
+  end
+
   def self.debug=(value)
     @@debug = value
   end
@@ -110,11 +117,11 @@ class Heckle < SexpProcessor
 
     self.strict = false
     self.auto_shift_type = true
-    self.expected = Array
+    self.expected = Sexp
 
     @mutatees = Hash.new
-    @mutation_count = Hash.new
-    @node_count = Hash.new
+    @mutation_count = Hash.new 0
+    @node_count = Hash.new 0
     @count = 0
 
     @mutatable_nodes = nodes
@@ -149,24 +156,31 @@ class Heckle < SexpProcessor
   ### Running the script
 
   def validate
-    if mutations_left == 0
+    left = mutations_left
+
+    if left == 0 then
       @reporter.no_mutations(method_name)
       return
     end
 
-    @reporter.method_loaded(klass_name, method_name, mutations_left)
+    @reporter.method_loaded(klass_name, method_name, left)
 
-    until mutations_left == 0
-      @reporter.remaining_mutations(mutations_left)
+    until left == 0 do
+      @reporter.remaining_mutations left
       reset_tree
       begin
         process current_tree
-        silence_stream { timeout(@@timeout) { run_tests } }
+        timeout(@@timeout, Heckle::Timeout) { run_tests }
       rescue SyntaxError => e
         @reporter.warning "Mutation caused a syntax error:\n\n#{e.message}}"
-      rescue Timeout::Error
+      rescue Heckle::Timeout
         @reporter.warning "Your tests timed out. Heckle may have caused an infinite loop."
+      rescue Interrupt
+        @reporter.warning 'Mutation canceled, hit ^C again to exit'
+        sleep 2
       end
+
+      left = mutations_left
     end
 
     reset # in case we're validating again. we should clean up.
@@ -174,7 +188,7 @@ class Heckle < SexpProcessor
     unless @failures.empty?
       @reporter.no_failures
       @failures.each do |failure|
-        original = RubyToRuby.new.process(@original_tree.deep_clone)
+        original = Ruby2Ruby.new.process(@original_tree.deep_clone)
         @reporter.failure(original, failure)
       end
       false
@@ -191,13 +205,13 @@ class Heckle < SexpProcessor
   def heckle(exp)
     exp_copy = exp.deep_clone
     src = begin
-            RubyToRuby.new.process(exp)
+            Ruby2Ruby.new.process(exp)
           rescue => e
             puts "Error: #{e.message} with: #{klass_name}##{method_name}: #{exp_copy.inspect}"
             raise e
           end
 
-    original = RubyToRuby.new.process(@original_tree.deep_clone)
+    original = Ruby2Ruby.new.process(@original_tree.deep_clone)
     @reporter.replacing(klass_name, method_name, original, src) if @@debug
 
     clean_name = method_name.to_s.gsub(/self\./, '')
@@ -220,50 +234,66 @@ class Heckle < SexpProcessor
     meth = exp.shift
     args = process(exp.shift)
 
-    out = [:call, recv, meth]
-    out << args if args
-
-    stack = caller.map { |s| s[/process_\w+/] }.compact
-
-    if stack.first != "process_iter" then
-      mutate_node out
-    else
-      out
-    end
+    mutate_node s(:call, recv, meth, args)
   end
 
   ##
   # Replaces the call node with nil.
 
   def mutate_call(node)
-    [:nil]
+    s(:nil)
   end
 
   def process_defn(exp)
     self.method = exp.shift
-    result = [:defn, method]
+    result = s(:defn, method)
     result << process(exp.shift) until exp.empty?
     heckle(result) if method == method_name
 
     return result
   ensure
     @mutated = false
-    reset_node_count
+    node_count.clear
+  end
+
+  def process_defs(exp)
+    recv = process exp.shift
+    meth = exp.shift
+
+    self.method = "#{Ruby2Ruby.new.process(recv.deep_clone)}.#{meth}".intern
+
+    result = s(:defs, recv, meth)
+    result << process(exp.shift) until exp.empty?
+
+    heckle(result) if method == method_name
+
+    return result
+  ensure
+    @mutated = false
+    node_count.clear
   end
 
   ##
   # So process_call works correctly
 
   def process_iter(exp)
-    [:iter, process(exp.shift), process(exp.shift), process(exp.shift)]
+    call = process exp.shift
+    args = process exp.shift
+    body = process exp.shift
+
+    mutate_node s(:iter, call, args, body)
+  end
+
+  def mutate_iter(exp)
+    s(:nil)
   end
 
   def process_asgn(type, exp)
     var = exp.shift
     if exp.empty? then
-      mutate_node [type, var]
+      mutate_node s(type, var)
     else
-      mutate_node [type, var, process(exp.shift)]
+      mutate_node s(type, var, process(exp.shift))
     end
   end
 
@@ -271,12 +301,12 @@ class Heckle < SexpProcessor
     type = node.shift
     var = node.shift
     if node.empty? then
-      [:lasgn, :_heckle_dummy]
+      s(type, :_heckle_dummy)
     else
       if node.last.first == :nil then
-        [type, var, [:lit, 42]]
+        s(type, var, s(:lit, 42))
       else
-        [type, var, [:nil]]
+        s(type, var, s(:nil))
       end
     end
   end
@@ -342,7 +372,7 @@ class Heckle < SexpProcessor
   alias mutate_lasgn mutate_asgn
 
   def process_lit(exp)
-    mutate_node [:lit, exp.shift]
+    mutate_node s(:lit, exp.shift)
   end
 
   ##
@@ -351,82 +381,82 @@ class Heckle < SexpProcessor
   def mutate_lit(exp)
     case exp[1]
     when Fixnum, Float, Bignum
-      [:lit, exp[1] + rand_number]
+      s(:lit, exp[1] + rand_number)
     when Symbol
-      [:lit, rand_symbol]
+      s(:lit, rand_symbol)
     when Regexp
-      [:lit, Regexp.new(Regexp.escape(rand_string.gsub(/\//, '\\/')))]
+      s(:lit, Regexp.new(Regexp.escape(rand_string.gsub(/\//, '\\/'))))
     when Range
-      [:lit, rand_range]
+      s(:lit, rand_range)
     end
   end
 
   def process_str(exp)
-    mutate_node [:str, exp.shift]
+    mutate_node s(:str, exp.shift)
   end
 
   ##
   # Replaces the value of the :str node with a random value.
 
   def mutate_str(node)
-    [:str, rand_string]
+    s(:str, rand_string)
   end
 
   def process_if(exp)
-    mutate_node [:if, process(exp.shift), process(exp.shift), process(exp.shift)]
+    mutate_node s(:if, process(exp.shift), process(exp.shift), process(exp.shift))
   end
 
   ##
   # Swaps the then and else parts of the :if node.
 
   def mutate_if(node)
-    [:if, node[1], node[3], node[2]]
+    s(:if, node[1], node[3], node[2])
   end
 
   def process_true(exp)
-    mutate_node [:true]
+    mutate_node s(:true)
   end
 
   ##
   # Swaps for a :false node.
 
   def mutate_true(node)
-    [:false]
+    s(:false)
   end
 
   def process_false(exp)
-    mutate_node [:false]
+    mutate_node s(:false)
   end
 
   ##
   # Swaps for a :true node.
 
   def mutate_false(node)
-    [:true]
+    s(:true)
   end
 
   def process_while(exp)
     cond, body, head_controlled = grab_conditional_loop_parts(exp)
-    mutate_node [:while, cond, body, head_controlled]
+    mutate_node s(:while, cond, body, head_controlled)
   end
 
   ##
   # Swaps for a :until node.
 
   def mutate_while(node)
-    [:until, node[1], node[2], node[3]]
+    s(:until, node[1], node[2], node[3])
   end
 
   def process_until(exp)
     cond, body, head_controlled = grab_conditional_loop_parts(exp)
-    mutate_node [:until, cond, body, head_controlled]
+    mutate_node s(:until, cond, body, head_controlled)
   end
 
   ##
   # Swaps for a :while node.
 
   def mutate_until(node)
-    [:while, node[1], node[2], node[3]]
+    s(:while, node[1], node[2], node[3])
   end
 
   def mutate_node(node)
@@ -444,28 +474,44 @@ class Heckle < SexpProcessor
   ############################################################
   ### Tree operations
 
-  def walk_and_push(node)
+  def walk_and_push(node, index = 0)
     return unless node.respond_to? :each
     return if node.is_a? String
-    node.each { |child| walk_and_push(child) }
-    if @mutatable_nodes.include? node.first
-      @mutatees[node.first.to_sym].push(node)
-      mutation_count[node] = 0
+
+    @walk_stack.push node.first
+    node.each_with_index { |child_node, i| walk_and_push child_node, i }
+    @walk_stack.pop
+
+    if @mutatable_nodes.include? node.first and
+       # HACK skip over call nodes that are the first child of an iter or
+       # they'll get added twice
+       #
+       # I think heckle really needs two processors, one for finding and one
+       # for heckling.
+       !(node.first == :call and index == 1 and @walk_stack.last == :iter) then
+      @mutatees[node.first].push(node)
     end
   end
 
   def grab_mutatees
-    walk_and_push(current_tree)
+    @walk_stack = []
+    walk_and_push current_tree
   end
 
   def current_tree
-    ParseTree.translate(klass_name.to_class, method_name)
+    ur = Unifier.new
+
+    sexp = ParseTree.translate(klass_name.to_class, method_name)
+    raise "sexp invalid for #{klass_name}##{method_name}" if sexp == [nil]
+    sexp = ur.process(sexp)
+
+    rewrite sexp
   end
 
   def reset
     reset_tree
     reset_mutatees
-    reset_mutation_count
+    mutation_count.clear
   end
 
   def reset_tree
@@ -488,26 +534,15 @@ class Heckle < SexpProcessor
     @mutatees = @original_mutatees.deep_clone
   end
 
-  def reset_mutation_count
-    mutation_count.each {|k,v| mutation_count[k] = 0}
-  end
-
-  def reset_node_count
-    node_count.each {|k,v| node_count[k] = 0}
-  end
-
   def increment_node_count(node)
-    if node_count[node].nil?
-      node_count[node] = 1
-    else
-      node_count[node] += 1
-    end
+    node_count[node] += 1
   end
 
   def increment_mutation_count(node)
     # So we don't re-mutate this later if the tree is reset
     mutation_count[node] += 1
-    @mutatees[node.first].delete_at(@mutatees[node.first].index(node))
+    mutatee_type = @mutatees[node.first]
+    mutatee_type.delete_at mutatee_type.index(node)
     @mutated = true
   end
 
@@ -520,9 +555,10 @@ class Heckle < SexpProcessor
 
   def should_heckle?(exp)
     return false unless method == method_name
-    mutation_count[exp] = 0 if mutation_count[exp].nil?
     return false if node_count[exp] <= mutation_count[exp]
-    ( mutatees[exp.first.to_sym] || [] ).include?(exp) && !already_mutated?
+    key = exp.first.to_sym
+
+    mutatees.include?(key) && mutatees[key].include?(exp) && !already_mutated?
   end
 
   def grab_conditional_loop_parts(exp)
@@ -537,13 +573,34 @@ class Heckle < SexpProcessor
   end
 
   def mutations_left
+    @last_mutations_left ||= -1
+
     sum = 0
-    @mutatees.each {|mut| sum += mut.last.size }
+    @mutatees.each { |mut| sum += mut.last.size }
+
+    if sum == @last_mutations_left then
+      puts 'bug!'
+      puts
+      require 'pp'
+      puts 'mutatees:'
+      pp @mutatees
+      puts
+      puts 'original tree:'
+      pp @original_tree
+      puts
+      puts "Infinite loop detected!"
+      puts "Please save this output to an attachment and submit a ticket here:"
+      puts "http://rubyforge.org/tracker/?func=add&group_id=1513&atid=5921"
+      exit 1
+    else
+      @last_mutations_left = sum
+    end
+
     sum
   end
 
   def current_code
-    RubyToRuby.translate(klass_name.to_class, method_name)
+    Ruby2Ruby.translate(klass_name.to_class, method_name)
   end
 
   ##
@@ -586,26 +643,30 @@ class Heckle < SexpProcessor
   # Suppresses output on $stdout and $stderr.
 
   def silence_stream
-    dead = File.open("/dev/null", "w")
+    return yield if @@debug
 
-    $stdout.flush
-    $stderr.flush
+    begin
+      dead = File.open("/dev/null", "w")
 
-    oldstdout = $stdout.dup
-    oldstderr = $stderr.dup
+      $stdout.flush
+      $stderr.flush
 
-    $stdout.reopen(dead)
-    $stderr.reopen(dead)
+      oldstdout = $stdout.dup
+      oldstderr = $stderr.dup
 
-    result = yield
+      $stdout.reopen(dead)
+      $stderr.reopen(dead)
 
-  ensure
-    $stdout.flush
-    $stderr.flush
+      result = yield
+
+    ensure
+      $stdout.flush
+      $stderr.flush
 
-    $stdout.reopen(oldstdout)
-    $stderr.reopen(oldstderr)
-    result
+      $stdout.reopen(oldstdout)
+      $stderr.reopen(oldstderr)
+      result
+    end
   end
 
   class Reporter
@@ -675,7 +736,7 @@ class Heckle < SexpProcessor
     end
 
     def report_test_failures
-      puts "Tests failed -- this is good"
+      puts "Tests failed -- this is good" if Heckle.debug
     end
   end
 
@@ -694,3 +755,4 @@ class Heckle < SexpProcessor
   end
 
 end
+