heckle 1.4.3 → 2.0.0.b1

data/lib/minitest_heckler.rb

@@ -0,0 +1,33 @@
+class MiniTestHeckler < Heckle
+  def initialize(class_or_module, method, options)
+    Dir.glob(options[:test_pattern]).each {|t| load File.expand_path(t) }
+
+    super(class_or_module, method, options[:nodes])
+  end
+
+  def tests_pass?
+    silence do
+      MiniTest::Unit.runner = nil
+
+      MiniTest::Unit.new.run
+
+      runner = MiniTest::Unit.runner
+
+      runner.failures == 0 && runner.errors == 0
+    end
+  end
+
+  # TODO: Windows.
+  def silence
+    return yield if Heckle.debug
+
+    begin
+      original = MiniTest::Unit.output
+      MiniTest::Unit.output = File.open("/dev/null", "w")
+
+      yield
+    ensure
+      MiniTest::Unit.output = original
+    end
+  end
+end

data/lib/test_unit_heckler.rb

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'test/unit/autorunner'
 require 'test/unit/testcase'
 require 'heckle'
 require 'zentest_mapping'

data/test/fixtures/heckle_dummy.rb

@@ -0,0 +1,200 @@
+class HeckleDummy
+  attr_accessor :names
+
+  def initialize
+    @names = []
+  end
+
+  def uses_call
+    some_func + some_other_func
+  end
+
+  def uses_callblock
+    x.y { 1 }
+  end
+
+  def uses_cvasgn
+    @@cvar = 5
+    @@cvar = nil
+  end
+
+  def uses_dasgn
+    loop do |dvar|
+      loop do
+        dvar = 5
+        dvar = nil
+      end
+    end
+  end
+
+  def uses_dasgncurr
+    loop do |dvar|
+      dvar = 5
+      dvar = nil
+    end
+  end
+
+  def uses_iasgn
+    @ivar = 5
+    @ivar = nil
+  end
+
+  def uses_gasgn
+    $gvar = 5
+    $gvar = nil
+  end
+
+  def uses_lasgn
+    lvar = 5
+    lvar = nil
+  end
+
+  def uses_masgn
+    @a, $b, c = 5, 6, 7
+  end
+
+  def uses_many_things
+    i = 1
+    while i < 10
+      i += 1
+      until some_func
+        some_other_func
+      end
+      return true if "hi there" == "changeling"
+      return false
+    end
+    i
+  end
+
+  def uses_while
+    while some_func
+      some_other_func
+    end
+  end
+
+  def uses_until
+    until some_func
+      some_other_func
+    end
+  end
+
+  def uses_numeric_literals
+    i = 1
+    i += 2147483648
+    i -= 3.5
+  end
+
+  def uses_strings
+    @names << "Hello, Robert"
+    @names << "Hello, Jeff"
+    @names << "Hi, Frank"
+  end
+
+  def uses_different_types
+    i = 1
+    b = "Hello, Joe"
+    c = 3.3
+  end
+
+  def uses_literal
+    i = 1
+  end
+
+  def uses_same_literal
+    i = 1
+    i = 1
+    i = 1
+  end
+
+  def uses_if
+    if some_func
+      if some_other_func
+        return
+      end
+    end
+  end
+
+  def uses_boolean
+    a = true
+    b = false
+  end
+
+  def uses_unless
+    unless true
+      if false
+        return
+      end
+    end
+  end
+
+  def uses_symbols
+    i = :blah
+    i = :blah
+    i = :and_blah
+  end
+
+  def uses_regexes
+    i = /a.*/
+    i = /c{2,4}+/
+    i = /123/
+  end
+
+  def uses_ranges
+    i = 6..100
+    i = -1..9
+    i = 1..4
+  end
+
+  def uses_nothing
+  end
+  
+  def uses_iter
+    x = [ 1, 2, 3 ]
+    x.each { |y| y }
+  end
+  
+  def self.is_a_klass_method?
+    true
+  end
+
+  module OuterNesting
+    def foo
+      -1
+    end
+
+    module InnerNesting
+      def foo
+        -2
+      end
+
+      class InnerClass
+        def bar
+          -1
+        end
+      end
+    end
+
+    module InnerNesting
+      def foo
+        -3
+      end
+
+      class InnerClass
+        module DecoyNesting
+          def foo
+            -4
+          end
+        end
+
+        def foo
+          1337
+        end
+      end
+    end
+  end
+
+  private
+
+  def some_func; end
+  def some_other_func; end
+end

data/test/fixtures/heckled.rb

@@ -96,6 +96,10 @@ class Heckled
     c = 3.3
   end
 
+  def uses_literal
+    i = 1
+  end
+
   def uses_same_literal
     i = 1
     i = 1

data/test/fixtures/minitest_project/README.txt

@@ -0,0 +1,57 @@
+= minitest_project
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/test/fixtures/minitest_project/Rakefile

@@ -0,0 +1,17 @@
+require 'rake/testtask'
+
+Rake::TestTask.new
+
+namespace :heckle do
+  desc "Run heckle with all tests."
+  task :pass do
+    puts `../../../bin/heckle Doubler double`
+  end
+
+  desc "Run heckle with some test."
+  task :fail do
+    puts `../../../bin/heckle Doubler double --tests test/test_doubler_with_a_number.rb`
+  end
+end
+
+task :default => :test

data/test/fixtures/minitest_project/lib/doubler.rb

@@ -0,0 +1,9 @@
+class Doubler
+  def double x
+    if Numeric === x
+      x * 2
+    else
+      "NaN"
+    end
+  end
+end

data/test/fixtures/minitest_project/test/test_doubler_with_a_number.rb

@@ -0,0 +1,12 @@
+require "minitest/autorun"
+require "doubler"
+
+class TestDoublerWithANumber < MiniTest::Unit::TestCase
+  def setup
+    @doubler = Doubler.new
+  end
+
+  def test_double_with_a_number
+    assert_equal 4, @doubler.double(2)
+  end
+end

data/test/fixtures/minitest_project/test/test_doubler_with_bad_input.rb

@@ -0,0 +1,16 @@
+require "minitest/autorun"
+require "doubler"
+
+class TestDoublerWithBadInput < MiniTest::Unit::TestCase
+  def setup
+    @doubler = Doubler.new
+  end
+
+  def test_doubler_with_a_string
+    assert_equal "NaN", @doubler.double("2")
+  end
+
+  def test_doubler_with_nil
+    assert_equal "NaN", @doubler.double(nil)
+  end
+end

data/test/test_heckle.rb

@@ -1,10 +1,5 @@
-$:.unshift(File.dirname(__FILE__) + '/fixtures')
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-
-require 'test/unit/testcase'
-require 'test/unit' if $0 == __FILE__
-require 'test_unit_heckler'
-require 'heckled'
+require 'fixtures/heckle_dummy'
+require 'heckle'
 
 class TestHeckler < Heckle
   def rand(*args)
@@ -22,60 +17,44 @@ class TestHeckler < Heckle
   def rand_symbol
     :"l33t h4x0r"
   end
-end
 
-class HeckleTestCase < Test::Unit::TestCase
-  unless defined? Mini then
-    undef_method :default_test
-    alias :refute_equal :assert_not_equal
+  # HAX
+  def expand_dirs_to_files(*)
+    super('test/fixtures/heckle_dummy.rb')
   end
+end
 
+class HeckleTestCase < MiniTest::Unit::TestCase
   def setup
+    @klass ||= "HeckleDummy"
     @nodes ||= Heckle::MUTATABLE_NODES
-    unless defined? @hecklee then
-      data = self.class.name.sub(/HeckleTestCase/, '').sub(/TestHeckle/, '')
-      data = data.gsub(/([A-Z])/, '_\1').downcase
-      data = "_many_things" if data.empty?
-      @hecklee = "uses#{data}"
-    end
+    @method_heckled ||= 'uses_many_things'
 
-    @heckler = TestHeckler.new("Heckled", @hecklee, @nodes) rescue nil
+    @heckler = TestHeckler.new(@klass, @method_heckled, @nodes)
   end
 
   def teardown
     @heckler.reset if defined?(@heckler) && @heckler
   end
-end
-
-class LiteralHeckleTestCase < HeckleTestCase
-  def setup
-    @nodes = s(:lit, :str)
-    super
-  end
-
-  def toggle(value, toggle)
-    toggle ? self.class::TOGGLE_VALUE : value
-  end
-
-  def test_default_structure
-    return if self.class == LiteralHeckleTestCase
-    assert_equal util_expected, @heckler.current_tree
-  end
 
-  def test_should_iterate_mutations
-    return if self.class == LiteralHeckleTestCase
-    @heckler.process(@heckler.current_tree)
-    assert_equal util_expected(1), @heckler.current_tree
+  def assert_mutations expected, heckle
+    initial = heckle.current_tree.deep_clone
+    mutations = []
 
-    @heckler.reset_tree
+    begin
+      heckle.process(heckle.current_tree)
+      mutant = heckle.current_tree
+      mutations << mutant
+      heckle.reset_tree
+    end until initial == mutant
 
-    @heckler.process(@heckler.current_tree)
-    assert_equal util_expected(2), @heckler.current_tree
+    mutations.delete(initial)
 
-    @heckler.reset_tree
-
-    @heckler.process(@heckler.current_tree)
-    assert_equal util_expected(3), @heckler.current_tree
+    # HAX: Sorting an array of Sexps blows up in some cases.
+    assert_equal expected.map {|sexp| sexp.to_s }.sort,
+      mutations.map {|sexp| sexp.to_s }.sort,
+      [ "expected(#{expected.size}):", (expected - mutations).map {|m| m.pretty_inspect},
+        "mutations(#{mutations.size}):", (mutations - expected).map {|m| m.pretty_inspect} ].join("\n")
   end
 end
 
@@ -212,99 +191,306 @@ class TestHeckle < HeckleTestCase
 end
 
 class TestHeckleNumericLiterals < HeckleTestCase
-  def toggle(value, toggle)
-    value + (toggle ? 5 : 0)
+  def setup
+    @method_heckled = "uses_numeric_literals"
+    @nodes = s(:lit, :str)
+    super
   end
 
-  def util_expected(n)
-    s(:defn, :uses_numeric_literals,
+  def test_numeric_literals_original_tree
+    expected = s(:defn, :uses_numeric_literals,
       s(:args),
       s(:scope,
         s(:block,
-          s(:lasgn, :i, s(:lit, toggle(1, 1 == n))),
+          s(:lasgn, :i, s(:lit, 1)),
           s(:lasgn, :i, s(:call, s(:lvar, :i), :+,
-                          s(:arglist, s(:lit, toggle(2147483648, 2 == n))))),
-          s(:lasgn, :i, s(:call, s(:lvar, :i), :-, s(:arglist, s(:lit, toggle(3.5, 3 == n))))))))
+                          s(:arglist, s(:lit, 2147483648)))),
+          s(:lasgn, :i, s(:call, s(:lvar, :i), :-, s(:arglist, s(:lit, 3.5)))))))
+
+    assert_equal expected, @heckler.current_tree
+  end
+
+  def test_numeric_literals_mutations
+    expected = [
+      s(:defn, :uses_numeric_literals,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, 6)),
+            s(:lasgn, :i, s(:call, s(:lvar, :i), :+,
+                            s(:arglist, s(:lit, 2147483648)))),
+            s(:lasgn, :i, s(:call, s(:lvar, :i), :-, s(:arglist, s(:lit, 3.5))))))),
+      s(:defn, :uses_numeric_literals,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, 1)),
+            s(:lasgn, :i, s(:call, s(:lvar, :i), :+,
+                            s(:arglist, s(:lit, 2147483653)))),
+            s(:lasgn, :i, s(:call, s(:lvar, :i), :-, s(:arglist, s(:lit, 3.5))))))),
+      s(:defn, :uses_numeric_literals,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, 1)),
+            s(:lasgn, :i, s(:call, s(:lvar, :i), :+,
+                            s(:arglist, s(:lit, 2147483648)))),
+            s(:lasgn, :i, s(:call, s(:lvar, :i), :-, s(:arglist, s(:lit, 8.5))))))),
+    ]
+
+    assert_mutations expected, @heckler
   end
 end
 
-class TestHeckleSymbols < LiteralHeckleTestCase
-  TOGGLE_VALUE = :"l33t h4x0r"
+class TestHeckleSymbols < HeckleTestCase
+  def setup
+    @method_heckled = "uses_symbols"
+    @nodes = s(:lit, :str)
+    super
+  end
 
-  def util_expected(n = nil)
-    s(:defn, :uses_symbols,
+  def test_symbols_original_tree
+    expected = s(:defn, :uses_symbols,
       s(:args),
       s(:scope,
         s(:block,
-          s(:lasgn, :i, s(:lit, toggle(:blah, n == 1))),
-          s(:lasgn, :i, s(:lit, toggle(:blah, n == 2))),
-          s(:lasgn, :i, s(:lit, toggle(:and_blah, n == 3))))))
+          s(:lasgn, :i, s(:lit, :blah)),
+          s(:lasgn, :i, s(:lit, :blah)),
+          s(:lasgn, :i, s(:lit, :and_blah)))))
+
+    assert_equal expected, @heckler.current_tree
+  end
+
+  def test_symbols_mutations
+    expected = [
+      s(:defn, :uses_symbols,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, :"l33t h4x0r")),
+            s(:lasgn, :i, s(:lit, :blah)),
+            s(:lasgn, :i, s(:lit, :and_blah))))),
+      s(:defn, :uses_symbols,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, :blah)),
+            s(:lasgn, :i, s(:lit, :"l33t h4x0r")),
+            s(:lasgn, :i, s(:lit, :and_blah))))),
+      s(:defn, :uses_symbols,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, :blah)),
+            s(:lasgn, :i, s(:lit, :blah)),
+            s(:lasgn, :i, s(:lit, :"l33t h4x0r"))))),
+    ]
+
+    assert_mutations expected, @heckler
   end
 end
 
-class TestHeckleRegexes < LiteralHeckleTestCase
-  TOGGLE_VALUE = /l33t\ h4x0r/
+class TestHeckleRegexes < HeckleTestCase
+  def setup
+    @method_heckled = "uses_regexes"
+    @nodes = s(:lit, :str)
+    super
+  end
 
-  def util_expected(n = nil)
-    s(:defn, :uses_regexes,
+  def test_regexes_original_tree
+    expected = s(:defn, :uses_regexes,
       s(:args),
       s(:scope,
         s(:block,
-          s(:lasgn, :i, s(:lit, toggle(/a.*/, n == 1))),
-          s(:lasgn, :i, s(:lit, toggle(/c{2,4}+/, n == 2))),
-          s(:lasgn, :i, s(:lit, toggle(/123/, n == 3))))))
+          s(:lasgn, :i, s(:lit, /a.*/)),
+          s(:lasgn, :i, s(:lit, /c{2,4}+/)),
+          s(:lasgn, :i, s(:lit, /123/)))))
+
+    assert_equal expected, @heckler.original_tree
+  end
+
+  def test_regexes_mutuations
+    expected = [
+      s(:defn, :uses_regexes,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, /l33t\ h4x0r/)),
+            s(:lasgn, :i, s(:lit, /c{2,4}+/)),
+            s(:lasgn, :i, s(:lit, /123/))))),
+      s(:defn, :uses_regexes,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, /a.*/)),
+            s(:lasgn, :i, s(:lit, /l33t\ h4x0r/)),
+            s(:lasgn, :i, s(:lit, /123/))))),
+      s(:defn, :uses_regexes,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, /a.*/)),
+            s(:lasgn, :i, s(:lit, /c{2,4}+/)),
+            s(:lasgn, :i, s(:lit, /l33t\ h4x0r/))))),
+    ]
+
+    assert_mutations expected, @heckler
   end
 end
 
-class TestHeckleRanges < LiteralHeckleTestCase
-  TOGGLE_VALUE = 5..10
+class TestHeckleRanges < HeckleTestCase
+  def setup
+    @method_heckled = "uses_ranges"
+    @nodes = s(:lit, :str)
+    super
+  end
 
-  def util_expected(n = nil)
-    s(:defn, :uses_ranges,
+  def test_ranges_original_tree
+    expected = s(:defn, :uses_ranges,
       s(:args),
       s(:scope,
         s(:block,
-          s(:lasgn, :i, s(:lit, toggle(6..100, n == 1))),
-          s(:lasgn, :i, s(:lit, toggle(-1..9, n == 2))),
-          s(:lasgn, :i, s(:lit, toggle(1..4, n == 3))))))
+          s(:lasgn, :i, s(:lit, 6..100)),
+          s(:lasgn, :i, s(:lit, -1..9)),
+          s(:lasgn, :i, s(:lit, 1..4)))))
+
+    assert_equal expected, @heckler.current_tree
+  end
+
+  def test_ranges_mutations
+    expected = [
+      s(:defn, :uses_ranges,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, 5..10)),
+            s(:lasgn, :i, s(:lit, -1..9)),
+            s(:lasgn, :i, s(:lit, 1..4))))),
+      s(:defn, :uses_ranges,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, 6..100)),
+            s(:lasgn, :i, s(:lit, 5..10)),
+            s(:lasgn, :i, s(:lit, 1..4))))),
+      s(:defn, :uses_ranges,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, 6..100)),
+            s(:lasgn, :i, s(:lit, -1..9)),
+            s(:lasgn, :i, s(:lit, 5..10))))),
+    ]
+
+    assert_mutations expected, @heckler
+
   end
 end
 
-class TestHeckleSameLiteral < LiteralHeckleTestCase
-  TOGGLE_VALUE = 6
+class TestHeckleSameLiteral < HeckleTestCase
+  def setup
+    @method_heckled = "uses_same_literal"
+    @nodes = s(:lit, :str)
+    super
+  end
 
-  def util_expected(n = nil)
-    s(:defn, :uses_same_literal,
+  def test_same_literal_original_tree
+    expected = s(:defn, :uses_same_literal,
       s(:args),
       s(:scope,
         s(:block,
-          s(:lasgn, :i, s(:lit, toggle(1, n == 1))),
-          s(:lasgn, :i, s(:lit, toggle(1, n == 2))),
-          s(:lasgn, :i, s(:lit, toggle(1, n == 3))))))
+          s(:lasgn, :i, s(:lit, 1)),
+          s(:lasgn, :i, s(:lit, 1)),
+          s(:lasgn, :i, s(:lit, 1)))))
+
+    assert_equal expected, @heckler.current_tree
+  end
+
+  def test_same_literal_mutations
+    expected = [
+      s(:defn, :uses_same_literal,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, 6)),
+            s(:lasgn, :i, s(:lit, 1)),
+            s(:lasgn, :i, s(:lit, 1))))),
+      s(:defn, :uses_same_literal,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, 1)),
+            s(:lasgn, :i, s(:lit, 6)),
+            s(:lasgn, :i, s(:lit, 1))))),
+      s(:defn, :uses_same_literal,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :i, s(:lit, 1)),
+            s(:lasgn, :i, s(:lit, 1)),
+            s(:lasgn, :i, s(:lit, 6))))),
+      ]
+
+    assert_mutations expected, @heckler
   end
 end
 
-class TestHeckleStrings < LiteralHeckleTestCase
-  TOGGLE_VALUE = "l33t h4x0r"
+class TestHeckleStrings < HeckleTestCase
+  def setup
+    @method_heckled = "uses_strings"
+    @nodes = s(:lit, :str)
+    super
+  end
 
-  def util_expected(n = nil)
-    s(:defn, :uses_strings,
+  def test_strings_original_tree
+    expected = s(:defn, :uses_strings,
       s(:args),
       s(:scope,
         s(:block,
-          s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, toggle("Hello, Robert", n == 1)))),
-          s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, toggle("Hello, Jeff", n == 2)))),
-          s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, toggle("Hi, Frank", n == 3)))))))
+          s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "Hello, Robert"))),
+          s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "Hello, Jeff"))),
+          s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "Hi, Frank"))))))
+
+    assert_equal expected, @heckler.current_tree
+  end
+
+  def test_strings_mutations
+    expected = [
+      s(:defn, :uses_strings,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "l33t h4x0r"))),
+            s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "Hello, Jeff"))),
+            s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "Hi, Frank")))))),
+      s(:defn, :uses_strings,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "Hello, Robert"))),
+            s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "l33t h4x0r"))),
+            s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "Hi, Frank")))))),
+      s(:defn, :uses_strings,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "Hello, Robert"))),
+            s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "Hello, Jeff"))),
+            s(:call, s(:ivar, :@names), :<<, s(:arglist, s(:str, "l33t h4x0r")))))),
+    ]
+
+    assert_mutations expected, @heckler
   end
 end
 
 class TestHeckleIf < HeckleTestCase
   def setup
+    @method_heckled = "uses_if"
     @nodes = s(:if)
     super
   end
 
-  def test_default_structure
+  def test_if_original_tree
     expected = s(:defn, :uses_if,
                  s(:args),
                  s(:scope,
@@ -317,421 +503,513 @@ class TestHeckleIf < HeckleTestCase
     assert_equal expected, @heckler.current_tree
   end
 
-  def test_should_flip_if_to_unless
-    expected = s(:defn, :uses_if,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:if,
-                       s(:call, nil, :some_func, s(:arglist)),
-                       s(:if, s(:call, nil, :some_other_func, s(:arglist)), nil, s(:return)),
-                       nil))))
-
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
-
-    @heckler.reset_tree
-
-    expected = s(:defn, :uses_if,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:if,
-                       s(:call, nil, :some_func, s(:arglist)),
-                       nil,
-                       s(:if, s(:call, nil, :some_other_func, s(:arglist)), s(:return), nil)))))
-
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
+  def test_if_mutations
+    expected = [
+      s(:defn,
+        :uses_if,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:if,
+              s(:call, nil, :some_func, s(:arglist)),
+              nil,
+              s(:if, s(:call, nil, :some_other_func, s(:arglist)), s(:return), nil))))),
+      s(:defn,
+        :uses_if,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:if,
+              s(:call, nil, :some_func, s(:arglist)),
+              s(:if, s(:call, nil, :some_other_func, s(:arglist)), nil, s(:return)),
+              nil))))
+    ]
+
+    assert_mutations expected, @heckler
   end
 end
 
 class TestHeckleBoolean < HeckleTestCase
-
   def setup
+    @method_heckled = "uses_boolean"
     @nodes = s(:true, :false)
     super
   end
 
-  def toggle(value, toggle)
-    (toggle ? ! value : value).to_s.intern
-  end
-
-  def util_expected(n = nil)
-    s(:defn, :uses_boolean,
-      s(:args),
-      s(:scope,
-        s(:block,
-          s(:lasgn, :a, s(toggle(true, n == 1))),
-          s(:lasgn, :b, s(toggle(false, n == 2))))))
-  end
+  def test_boolean_original_tree
+    expected = s(:defn, :uses_boolean,
+                 s(:args),
+                 s(:scope,
+                   s(:block,
+                     s(:lasgn, :a, s(:true)),
+                     s(:lasgn, :b, s(:false)))))
 
-  def test_default_structure
-    assert_equal util_expected, @heckler.current_tree
+    assert_equal expected, @heckler.current_tree
   end
 
-  def test_should_flip_true_to_false_and_false_to_true
-    @heckler.process(@heckler.current_tree)
-    assert_equal util_expected(1), @heckler.current_tree
-
-    @heckler.reset_tree
-
-    @heckler.process(@heckler.current_tree)
-    assert_equal util_expected(2), @heckler.current_tree
+  def test_boolean_mutations
+    expected = [
+      s(:defn, :uses_boolean,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :a, s(:false)),
+            s(:lasgn, :b, s(:false))))),
+      s(:defn, :uses_boolean,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :a, s(:true)),
+            s(:lasgn, :b, s(:true))))),
+    ]
+
+    assert_mutations expected, @heckler
   end
 end
 
 class TestHeckleWhile < HeckleTestCase
   def setup
+    @method_heckled = "uses_while"
     @nodes = s(:while)
     super
   end
 
-  def test_default_structure
-    expected = s(:defn, :uses_while,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:while, s(:call, nil, :some_func, s(:arglist)),
-                       s(:call, nil, :some_other_func, s(:arglist)), true))))
+  def test_while_original_tree
+    expected =  s(:defn, :uses_while,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:while, s(:call, nil, :some_func, s(:arglist)),
+                        s(:call, nil, :some_other_func, s(:arglist)), true))))
+
     assert_equal expected, @heckler.current_tree
   end
 
-  def test_flips_while_to_until
-    expected = s(:defn, :uses_while,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:until, s(:call, nil, :some_func, s(:arglist)),
-                       s(:call, nil, :some_other_func, s(:arglist)), true))))
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
+  def test_while_mutations
+    expected = [
+      s(:defn, :uses_while,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:until, s(:call, nil, :some_func, s(:arglist)),
+              s(:call, nil, :some_other_func, s(:arglist)), true))))]
+
+    assert_mutations expected, @heckler
   end
 end
 
 class TestHeckleUntil < HeckleTestCase
   def setup
+    @method_heckled = "uses_until"
     @nodes = s(:until)
     super
   end
 
-  def test_default_structure
-    expected = s(:defn, :uses_until,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:until, s(:call, nil, :some_func, s(:arglist)),
-                       s(:call, nil, :some_other_func, s(:arglist)), true))))
+  def test_until_original_tree
+    expected =  s(:defn, :uses_until,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:until, s(:call, nil, :some_func, s(:arglist)),
+                        s(:call, nil, :some_other_func, s(:arglist)), true))))
+
     assert_equal expected, @heckler.current_tree
   end
 
-  def test_flips_until_to_while
-    expected = s(:defn, :uses_until,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:while, s(:call, nil, :some_func, s(:arglist)),
-                       s(:call, nil, :some_other_func, s(:arglist)), true))))
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
+  def test_until_mutations
+    expected = [
+      s(:defn, :uses_until,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:while, s(:call, nil, :some_func, s(:arglist)),
+              s(:call, nil, :some_other_func, s(:arglist)), true))))]
+
+    assert_mutations expected, @heckler
   end
 end
 
 class TestHeckleCall < HeckleTestCase
-
-  def test_call_deleted
-    expected = s(:defn, :uses_call,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:nil))))
-
-    @heckler.process(@heckler.current_tree) # some_func
-    @heckler.reset_tree
-    @heckler.process(@heckler.current_tree) # some_other_func
-    @heckler.reset_tree
-    @heckler.process(@heckler.current_tree) # +
-    assert_equal expected, @heckler.current_tree
+  def setup
+    @method_heckled = "uses_call"
+    super
   end
 
-  def test_default_structure
-    expected = s(:defn, :uses_call,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:call,
-                       s(:call, nil, :some_func, s(:arglist)),
-                       :+,
-                       s(:arglist, s(:call, nil, :some_other_func, s(:arglist)))))))
+  def test_call_original_tree
+    expected =  s(:defn, :uses_call,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:call,
+                        s(:call, nil, :some_func, s(:arglist)),
+                        :+,
+                        s(:arglist, s(:call, nil, :some_other_func, s(:arglist)))))))
 
     assert_equal expected, @heckler.current_tree
   end
 
+  def test_call_mutations
+    expected = [
+      s(:defn, :uses_call,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:call,
+              s(:call, nil, :some_func, s(:arglist)),
+              :+,
+              s(:arglist, s(:nil)))))),
+      s(:defn, :uses_call,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:call,
+              s(:nil),
+              :+,
+              s(:arglist, s(:call, nil, :some_other_func, s(:arglist))))))),
+      s(:defn, :uses_call,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:nil)))),
+    ]
+
+    assert_mutations expected, @heckler
+  end
 end
 
 class TestHeckleCallblock < HeckleTestCase
-
   def setup
+    @method_heckled = "uses_callblock"
     @nodes = s(:call)
     super
   end
 
-  def test_default_structure
-    expected = s(:defn, :uses_callblock,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:iter,
-                       s(:call, s(:call, nil, :x, s(:arglist)), :y, s(:arglist)),
-                       nil,
-                       s(:lit, 1)))))
+  def test_callblock_original_tree
+    expected =  s(:defn, :uses_callblock,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:iter,
+                        s(:call, s(:call, nil, :x, s(:arglist)), :y, s(:arglist)),
+                        nil,
+                        s(:lit, 1)))))
 
     assert_equal expected, @heckler.current_tree
   end
-  def test_callblock_deleted
-    expected = s(:defn, :uses_callblock,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:iter,
-                       s(:call, s(:nil), :y, s(:arglist)),
-                       nil,
-                       s(:lit, 1)))))
+  def test_callblock_mutations
+    expected = [
+      s(:defn, :uses_callblock,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:iter,
+              s(:call, s(:nil), :y, s(:arglist)),
+              nil,
+              s(:lit, 1)))))
+    ]
 
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
+    assert_mutations expected, @heckler
   end
 end
 
 class TestHeckleClassMethod < HeckleTestCase
   def setup
-    @hecklee = "self.is_a_klass_method?"
+    @method_heckled = "self.is_a_klass_method?"
     @nodes = s(:true)
     super
   end
 
-  def test_default_structure
-    expected = s(:defs, s(:self), :is_a_klass_method?,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:true))))
+  def test_class_method_original_tree
+    expected =  s(:defs, s(:self), :is_a_klass_method?,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:true))))
+
     assert_equal expected, @heckler.current_tree
   end
 
-  def test_heckle_class_methods
-    expected = s(:defs, s(:self), :is_a_klass_method?,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:false))))
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
+  def test_class_methods_mutations
+    expected = [
+      s(:defs, s(:self), :is_a_klass_method?,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:false))))
+    ]
+
+    assert_mutations expected, @heckler
   end
 end
 
 class TestHeckleCvasgn < HeckleTestCase
-
   def setup
+    @method_heckled = "uses_cvasgn"
     @nodes = s(:cvasgn)
     super
   end
 
-  def test_cvasgn_val
-    expected = s(:defn, :uses_cvasgn,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:cvasgn, :@@cvar, s(:nil)),
-                     s(:cvasgn, :@@cvar, s(:nil)))))
+  def test_cvasgn_original_tree
+    expected =  s(:defn, :uses_cvasgn,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:cvasgn, :@@cvar, s(:lit, 5)),
+                      s(:cvasgn, :@@cvar, s(:nil)))))
 
-    @heckler.process(@heckler.current_tree)
     assert_equal expected, @heckler.current_tree
   end
 
-  def test_cvasgn_nil
-    expected = s(:defn, :uses_cvasgn,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:cvasgn, :@@cvar, s(:lit, 5)),
-                     s(:cvasgn, :@@cvar, s(:lit, 42)))))
-
-    @heckler.process(@heckler.current_tree)
-    @heckler.reset_tree
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
+  def test_cvasgn_mutations
+    expected = [
+      s(:defn, :uses_cvasgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:cvasgn, :@@cvar, s(:lit, 5)),
+            s(:cvasgn, :@@cvar, s(:lit, 42))))),
+      s(:defn, :uses_cvasgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:cvasgn, :@@cvar, s(:nil)),
+            s(:cvasgn, :@@cvar, s(:nil))))),
+    ]
+
+    assert_mutations expected, @heckler
   end
-
 end
 
 class TestHeckleIasgn < HeckleTestCase
-
   def setup
+    @method_heckled = "uses_iasgn"
     @nodes = s(:iasgn)
     super
   end
 
-  def test_iasgn_val
-    expected = s(:defn, :uses_iasgn,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:iasgn, :@ivar, s(:nil)),
-                     s(:iasgn, :@ivar, s(:nil)))))
+  def test_iasgn_original_tree
+    expected =  s(:defn, :uses_iasgn,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:iasgn, :@ivar, s(:lit, 5)),
+                      s(:iasgn, :@ivar, s(:nil)))))
 
-    @heckler.process(@heckler.current_tree)
     assert_equal expected, @heckler.current_tree
   end
 
-  def test_iasgn_nil
-    expected = s(:defn, :uses_iasgn,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:iasgn, :@ivar, s(:lit, 5)),
-                     s(:iasgn, :@ivar, s(:lit, 42)))))
+  def test_iasgn_mutations
+    expected = [
+      s(:defn, :uses_iasgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:iasgn, :@ivar, s(:lit, 5)),
+            s(:iasgn, :@ivar, s(:lit, 42))))),
+      s(:defn, :uses_iasgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:iasgn, :@ivar, s(:nil)),
+            s(:iasgn, :@ivar, s(:nil))))),
+    ]
 
-    @heckler.process(@heckler.current_tree)
-    @heckler.reset_tree
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
+    assert_mutations expected, @heckler
   end
 
 end
 
 class TestHeckleGasgn < HeckleTestCase
-
   def setup
+    @method_heckled = "uses_gasgn"
+      s(:defn, :uses_cvasgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:cvasgn, :@@cvar, s(:lit, 5)),
+            s(:cvasgn, :@@cvar, s(:lit, 42)))))
     @nodes = s(:gasgn)
     super
   end
 
-  def test_gasgn_val
-    expected = s(:defn, :uses_gasgn,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:gasgn, :$gvar, s(:nil)),
-                     s(:gasgn, :$gvar, s(:nil)))))
+  def test_gasgn_original_tree
+    expected =  s(:defn, :uses_gasgn,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:gasgn, :$gvar, s(:lit, 5)),
+                      s(:gasgn, :$gvar, s(:nil)))))
 
-    @heckler.process(@heckler.current_tree)
     assert_equal expected, @heckler.current_tree
   end
 
-  def test_gasgn_nil
-    expected = s(:defn, :uses_gasgn,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:gasgn, :$gvar, s(:lit, 5)),
-                     s(:gasgn, :$gvar, s(:lit, 42)))))
+  def test_gasgn_mutations
+    expected = [
+      s(:defn, :uses_gasgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:gasgn, :$gvar, s(:lit, 5)),
+            s(:gasgn, :$gvar, s(:lit, 42))))),
+      s(:defn, :uses_gasgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:gasgn, :$gvar, s(:nil)),
+            s(:gasgn, :$gvar, s(:nil))))),
+    ]
 
-    @heckler.process(@heckler.current_tree)
-    @heckler.reset_tree
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
+    assert_mutations expected, @heckler
   end
 
 end
 
 class TestHeckleLasgn < HeckleTestCase
-
   def setup
+    @method_heckled = "uses_lasgn"
     @nodes = s(:lasgn)
     super
   end
 
-  def test_lasgn_val
-    expected = s(:defn, :uses_lasgn,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:lasgn, :lvar, s(:nil)),
-                     s(:lasgn, :lvar, s(:nil)))))
+  def test_lasgn_original_tree
+    expected =  s(:defn, :uses_lasgn,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:lasgn, :lvar, s(:lit, 5)),
+                      s(:lasgn, :lvar, s(:nil)))))
 
-    @heckler.process(@heckler.current_tree)
     assert_equal expected, @heckler.current_tree
   end
 
-  def test_lasgn_nil
-    expected = s(:defn, :uses_lasgn,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:lasgn, :lvar, s(:lit, 5)),
-                     s(:lasgn, :lvar, s(:lit, 42)))))
-
-    @heckler.process(@heckler.current_tree)
-    @heckler.reset_tree
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
+  def test_lasgn_mutations
+    expected = [
+      s(:defn, :uses_lasgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :lvar, s(:nil)),
+            s(:lasgn, :lvar, s(:nil))))),
+      s(:defn, :uses_lasgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :lvar, s(:lit, 5)),
+            s(:lasgn, :lvar, s(:lit, 42))))),
+    ]
+
+    assert_mutations expected, @heckler
   end
-
 end
 
 class TestHeckleMasgn < HeckleTestCase
-
   def setup
+    @method_heckled = "uses_masgn"
     @nodes = s(:dasgn, :dasgn_curr, :iasgn, :gasgn, :lasgn)
     super
   end
 
-  def test_masgn
-    expected = s(:defn, :uses_masgn,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:masgn,
-                       s(:array,
-                         s(:lasgn, :_heckle_dummy),
-                         s(:gasgn, :$b),
-                         s(:lasgn, :c)),
-                       s(:array, s(:lit, 5), s(:lit, 6), s(:lit, 7))))))
+  def test_masgn_original_tree
+    expected =  s(:defn, :uses_masgn,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:masgn,
+                        s(:array, s(:iasgn, :@a), s(:gasgn, :$b), s(:lasgn, :c)),
+                        s(:array, s(:lit, 5), s(:lit, 6), s(:lit, 7))))))
 
-    @heckler.process(@heckler.current_tree)
     assert_equal expected, @heckler.current_tree
   end
 
+  def test_masgn_mutations
+    expected = [
+      s(:defn, :uses_masgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:masgn,
+              s(:array, s(:iasgn, :_heckle_dummy), s(:gasgn, :$b), s(:lasgn, :c)),
+              s(:array, s(:lit, 5), s(:lit, 6), s(:lit, 7)))))),
+      s(:defn, :uses_masgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:masgn,
+              s(:array, s(:iasgn, :@a), s(:gasgn, :_heckle_dummy), s(:lasgn, :c)),
+              s(:array, s(:lit, 5), s(:lit, 6), s(:lit, 7)))))),
+      s(:defn, :uses_masgn,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:masgn,
+              s(:array,s(:iasgn, :@a), s(:gasgn, :$b), s(:lasgn, :_heckle_dummy)),
+              s(:array, s(:lit, 5), s(:lit, 6), s(:lit, 7)))))),
+    ]
+
+    assert_mutations expected, @heckler
+  end
+
 end
 
 class TestHeckleIter < HeckleTestCase
   def setup
+    @method_heckled = "uses_iter"
     @nodes = [ :call, :lasgn ]
     super
   end
-  
-  def test_iter
-    expected = s(:defn, :uses_iter,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:lasgn, :x, s(:nil)),
-                     s(:iter,
-                       s(:call, s(:lvar, :x), :each, s(:arglist)),
-                       s(:lasgn, :y),
-                       s(:lvar, :y)))))
-    
-    # This call causes the replacement of [:lasgn, :x...] above to
-    # become [:lasgn, :nil].  We then reset the tree to ensure that
-    # the original method is maintained.  We are really trying to test
-    # the reset_tree method here, not the actual changes.
 
-    @heckler.process(@heckler.current_tree)
-    assert_equal(expected, @heckler.current_tree)
+  def test_iter_original_tree
+    expected =  s(:defn, :uses_iter,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:lasgn, :x, s(:array, s(:lit, 1), s(:lit, 2), s(:lit, 3))),
+                      s(:iter,
+                        s(:call, s(:lvar, :x), :each, s(:arglist)),
+                        s(:lasgn, :y), s(:lvar, :y)))))
 
-    @heckler.reset_tree
-    expected = s(:defn, :uses_iter,
-                 s(:args),
-                 s(:scope,
-                   s(:block,
-                     s(:lasgn, :x, s(:array, s(:lit, 1), s(:lit, 2), s(:lit, 3))),
-                     s(:iter,
-                       s(:call, s(:lvar, :x), :each, s(:arglist)),
-                       s(:lasgn, :_heckle_dummy),
-                       s(:call, nil, :y, s(:arglist))))))
+    assert_equal expected, @heckler.current_tree
+  end
 
-    @heckler.process(@heckler.current_tree)
-    assert_equal(expected, @heckler.current_tree)
+  def test_iter_mutations
+    expected = [
+      s(:defn, :uses_iter,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :x, s(:nil)),
+            s(:iter,
+              s(:call, s(:lvar, :x), :each, s(:arglist)),
+              s(:lasgn, :y), s(:lvar, :y))))),
+      s(:defn, :uses_iter,
+        s(:args),
+        s(:scope,
+          s(:block,
+            s(:lasgn, :x, s(:array, s(:lit, 1), s(:lit, 2), s(:lit, 3))),
+            s(:iter,
+              s(:call, s(:lvar, :x), :each, s(:arglist)),
+              s(:lasgn, :_heckle_dummy), s(:lvar, :y))))),
+    ]
+
+
+    assert_mutations expected, @heckler
+  end
+end
+
+
+class TestHeckleFindsNestedClassAndModule < HeckleTestCase
+  def setup
+    @klass = "HeckleDummy::OuterNesting::InnerNesting::InnerClass"
+    @method_heckled = "foo"
+    @nodes = []
+    super
+  end
+
+  def test_nested_class_and_module_original_tree
+    expected =  s(:defn, :foo, s(:args), s(:scope,
+                  s(:block,
+                    s(:lit, 1337))))
+
+    assert_equal expected, @heckler.current_tree
   end
 end