RubyGems - heckle - Versions diffs - 1.4.1 → 1.4.2 - Mend

heckle 1.4.1 → 1.4.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

data/lib/test_unit_heckler.rb CHANGED

@@ -1,12 +1,21 @@
 #!/usr/bin/env ruby
 require 'test/unit/autorunner'
+require 'test/unit/testcase'
 require 'heckle'
 require 'zentest_mapping'
 $: << 'lib' << 'test'
+# Make sure test/unit doesn't swallow our timeout
+begin
+  Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS << Heckle::Timeout
+rescue NameError
+  # ignore
+end
 class TestUnitHeckler < Heckle
   @@test_pattern = 'test/test_*.rb'
   @@tests_loaded = false
   @@focus = false
@@ -25,7 +34,7 @@ class TestUnitHeckler < Heckle
   end
   def self.validate(klass_name, method_name = nil,
-                    nodes = Heckle::MUTATABLE_NODES)
+                    nodes = Heckle::MUTATABLE_NODES, force = false)
     load_test_files
     klass = klass_name.to_class
@@ -41,21 +50,27 @@ class TestUnitHeckler < Heckle
     initial_time = Time.now
-    unless self.new(klass_name).tests_pass? then
+    heckle = self.new(klass_name)
+    passed = heckle.tests_pass?
+    unless force or passed then
       abort "Initial run of tests failed... fix and run heckle again"
     end
-    if self.guess_timeout?
-      running_time = (Time.now - initial_time)
-      adjusted_timeout = (running_time * 2 < 5) ? 5 : (running_time * 2)
+    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
-      puts "Setting timeout at #{adjusted_timeout} seconds." if @@debug
     end
-    self.timeout = adjusted_timeout
+    puts "Timeout set to #{adjusted_timeout} seconds."
-    puts "Initial tests pass. Let's rumble."
+    if passed then
+      puts "Initial tests pass. Let's rumble."
+    else
+      puts "Initial tests failed but you forced things. Let's rumble."
+    end
     puts
     methods = method_name ? Array(method_name) : klass.instance_methods(false) + klass_methods

data/test/fixtures/heckled.rb CHANGED

@@ -143,11 +143,15 @@ class Heckled
   def uses_nothing
   end
+  def uses_iter
+    x = [ 1, 2, 3 ]
+    x.each { |y| y }
+  end
   def self.is_a_klass_method?
     true
   end
   private
   def some_func; end

data/test/test_heckle.rb CHANGED

@@ -25,22 +25,31 @@ class TestHeckler < Heckle
 end
 class HeckleTestCase < Test::Unit::TestCase
-  undef_method :default_test
+  unless defined? Mini then
+    undef_method :default_test
+    alias :refute_equal :assert_not_equal
+  end
   def setup
     @nodes ||= Heckle::MUTATABLE_NODES
-    data = self.class.name["TestHeckle".size..-1].gsub(/([A-Z])/, '_\1').downcase
-    data = "_many_things" if data.empty?
-    @heckler = TestHeckler.new("Heckled", "uses#{data}", @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
+    @heckler = TestHeckler.new("Heckled", @hecklee, @nodes) rescue nil
   end
   def teardown
-    @heckler.reset
+    @heckler.reset if defined?(@heckler) && @heckler
   end
 end
 class LiteralHeckleTestCase < HeckleTestCase
   def setup
-    @nodes = [:lit, :str]
+    @nodes = s(:lit, :str)
     super
   end
@@ -72,26 +81,25 @@ end
 class TestHeckle < HeckleTestCase
   def test_should_set_original_tree
-    expected = [:defn, :uses_many_things,
-                [:fbody,
-                 [:scope,
-                  [:block,
-                   [:args],
-                   [:lasgn, :i, [:lit, 1]],
-                   [:while,
-                    [:call, [:lvar, :i], :<, [:array, [:lit, 10]]],
-                    [:block,
-                     [:lasgn, :i, [:call, [:lvar, :i], :+, [:array, [:lit, 1]]]],
-                     [:until, [:vcall, :some_func],
-                      [:vcall, :some_other_func], true],
-                     [:if,
-                      [:call, [:str, "hi there"], :==,
-                       [:array, [:str, "changeling"]]],
-                      [:return, [:true]],
-                      nil],
-                     [:return, [:false]]],
-                    true],
-                   [:lvar, :i]]]]]
+    expected = s(:defn, :uses_many_things,
+                 s(:args),
+                 s(:scope,
+                   s(:block,
+                     s(:lasgn, :i, s(:lit, 1)),
+                     s(:while,
+                       s(:call, s(:lvar, :i), :<, s(:arglist, s(:lit, 10))),
+                       s(:block,
+                         s(:lasgn, :i, s(:call, s(:lvar, :i), :+, s(:arglist, s(:lit, 1)))),
+                         s(:until, s(:call, nil, :some_func, s(:arglist)),
+                           s(:call, nil, :some_other_func, s(:arglist)), true),
+                         s(:if,
+                           s(:call, s(:str, "hi there"), :==,
+                             s(:arglist, s(:str, "changeling"))),
+                           s(:return, s(:true)),
+                           nil),
+                         s(:return, s(:false))),
+                       true),
+                     s(:lvar, :i))))
     assert_equal expected, @heckler.original_tree
   end
@@ -99,46 +107,52 @@ class TestHeckle < HeckleTestCase
   def test_should_grab_mutatees_from_method
     # expected is from tree of uses_while
     expected = {
-      :call => [[:call, [:lvar, :i], :<, [:array, [:lit, 10]]],
-                [:call, [:lvar, :i], :+, [:array, [:lit, 1]]],
-                [:call, [:str, "hi there"], :==,
-                        [:array, [:str, "changeling"]]]],
-      :cvasgn => [], # no cvasgns here
-      :dasgn => [], # no dasgns here
+      :call => [s(:call, s(:lvar, :i), :<, s(:arglist, s(:lit, 10))),
+                s(:call, s(:lvar, :i), :+, s(:arglist, s(:lit, 1))),
+                s(:call, nil, :some_func, s(:arglist)), # FIX: why added?
+                s(:call, nil, :some_other_func, s(:arglist)), # FIX: why added?
+                s(:call, s(:str, "hi there"), :==,
+                  s(:arglist, s(:str, "changeling")))],
+      :cvasgn => [],     # no cvasgns here
+      :dasgn => [],      # no dasgns here
       :dasgn_curr => [], # no dasgn_currs here
-      :iasgn => [], # no iasgns here
-      :gasgn => [], # no gasgns here
-      :lasgn => [[:lasgn, :i, [:lit, 1]],
-                 [:lasgn, :i, [:call, [:lvar, :i], :+, [:array, [:lit, 1]]]]],
-      :lit => [[:lit, 1], [:lit, 10], [:lit, 1]],
-      :if => [[:if,
-               [:call, [:str, "hi there"], :==, [:array, [:str, "changeling"]]],
-               [:return, [:true]],
-               nil]],
-      :str => [[:str, "hi there"], [:str, "changeling"]],
-      :true => [[:true]],
-      :false => [[:false]],
-      :while => [[:while,
-                  [:call, [:lvar, :i], :<, [:array, [:lit, 10]]],
-                  [:block,
-                   [:lasgn, :i, [:call, [:lvar, :i], :+, [:array, [:lit, 1]]]],
-                   [:until, [:vcall, :some_func],
-                    [:vcall, :some_other_func], true],
-                   [:if,
-                    [:call, [:str, "hi there"], :==,
-                     [:array, [:str, "changeling"]]],
-                    [:return, [:true]],
-                    nil],
-                   [:return, [:false]]],
-                  true]],
-      :until => [[:until, [:vcall, :some_func], [:vcall, :some_other_func], true]]
+      :iasgn => [],      # no iasgns here
+      :iter => [],
+      :gasgn => [],      # no gasgns here
+      :lasgn => [s(:lasgn, :i, s(:lit, 1)),
+                 s(:lasgn, :i, s(:call, s(:lvar, :i), :+, s(:arglist, s(:lit, 1))))],
+      :lit => [s(:lit, 1), s(:lit, 10), s(:lit, 1)],
+      :if => [s(:if,
+                s(:call, s(:str, "hi there"), :==, s(:arglist, s(:str, "changeling"))),
+                s(:return, s(:true)),
+                nil)],
+      :str => [s(:str, "hi there"), s(:str, "changeling")],
+      :true => [s(:true)],
+      :false => [s(:false)],
+      :while => [s(:while,
+                   s(:call, s(:lvar, :i), :<, s(:arglist, s(:lit, 10))),
+                   s(:block,
+                     s(:lasgn, :i, s(:call, s(:lvar, :i), :+, s(:arglist, s(:lit, 1)))),
+                     s(:until, s(:call, nil, :some_func, s(:arglist)),
+                       s(:call, nil, :some_other_func, s(:arglist)), true),
+                     s(:if,
+                       s(:call, s(:str, "hi there"), :==,
+                         s(:arglist, s(:str, "changeling"))),
+                       s(:return, s(:true)),
+                       nil),
+                     s(:return, s(:false))),
+                   true)],
+      :until => [s(:until,
+                   s(:call, nil, :some_func, s(:arglist)),
+                   s(:call, nil, :some_other_func, s(:arglist)),
+                   true)],
     }
     assert_equal expected, @heckler.mutatees
   end
   def test_should_count_mutatees_left
-    assert_equal 15, @heckler.mutations_left
+    assert_equal 17, @heckler.mutations_left # FIX WHY?!?
   end
   def test_reset
@@ -147,11 +161,11 @@ class TestHeckle < HeckleTestCase
     3.times { @heckler.process(@heckler.current_tree) }
-    assert_not_equal original_tree, @heckler.current_tree
-    assert_not_equal original_mutatees, @heckler.mutatees
+    refute_equal original_tree, @heckler.current_tree
+    refute_equal original_mutatees, @heckler.mutatees
     @heckler.reset
-    assert_equal original_tree[2], @heckler.current_tree[2][1]
+    assert_equal original_tree[2], @heckler.current_tree[2]
     assert_equal original_mutatees, @heckler.mutatees
   end
@@ -159,7 +173,7 @@ class TestHeckle < HeckleTestCase
     original_tree = @heckler.current_tree.deep_clone
     @heckler.process(@heckler.current_tree)
-    assert_not_equal original_tree, @heckler.current_tree
+    refute_equal original_tree, @heckler.current_tree
     @heckler.reset_tree
     assert_equal original_tree, @heckler.current_tree
@@ -170,16 +184,16 @@ class TestHeckle < HeckleTestCase
     original_mutatees = @heckler.mutatees.deep_clone
     @heckler.process(@heckler.current_tree)
-    assert_not_equal original_tree, @heckler.current_tree
-    assert_not_equal original_mutatees, @heckler.mutatees
+    refute_equal original_tree, @heckler.current_tree
+    refute_equal original_mutatees, @heckler.mutatees
     @heckler.reset
     assert_equal original_tree, @heckler.current_tree
     assert_equal original_mutatees, @heckler.mutatees
     3.times { @heckler.process(@heckler.current_tree) }
-    assert_not_equal original_tree, @heckler.current_tree
-    assert_not_equal original_mutatees, @heckler.mutatees
+    refute_equal original_tree, @heckler.current_tree
+    refute_equal original_mutatees, @heckler.mutatees
     @heckler.reset
     assert_equal original_tree, @heckler.current_tree
@@ -190,7 +204,7 @@ class TestHeckle < HeckleTestCase
     original_mutatees = @heckler.mutatees.deep_clone
     @heckler.process(@heckler.current_tree)
-    assert_not_equal original_mutatees, @heckler.mutatees
+    refute_equal original_mutatees, @heckler.mutatees
     @heckler.reset_mutatees
     assert_equal original_mutatees, @heckler.mutatees
@@ -203,14 +217,14 @@ class TestHeckleNumericLiterals < HeckleTestCase
   end
   def util_expected(n)
-    [:defn, :uses_numeric_literals,
-     [:scope,
-      [:block,
-       [:args],
-       [:lasgn, :i, [:lit, toggle(1, 1 == n)]],
-       [:lasgn, :i, [:call, [:lvar, :i], :+,
-                     [:array, [:lit, toggle(2147483648, 2 == n)]]]],
-       [:lasgn, :i, [:call, [:lvar, :i], :-, [:array, [:lit, toggle(3.5, 3 == n)]]]]]]]
+    s(:defn, :uses_numeric_literals,
+      s(:args),
+      s(:scope,
+        s(:block,
+          s(:lasgn, :i, s(:lit, toggle(1, 1 == n))),
+          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))))))))
   end
 end
@@ -218,13 +232,13 @@ class TestHeckleSymbols < LiteralHeckleTestCase
   TOGGLE_VALUE = :"l33t h4x0r"
   def util_expected(n = nil)
-    [:defn, :uses_symbols,
-     [:scope,
-      [:block,
-       [:args],
-       [:lasgn, :i, [:lit, toggle(:blah, n == 1)]],
-       [:lasgn, :i, [:lit, toggle(:blah, n == 2)]],
-       [:lasgn, :i, [:lit, toggle(:and_blah, n == 3)]]]]]
+    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))))))
   end
 end
@@ -232,13 +246,13 @@ class TestHeckleRegexes < LiteralHeckleTestCase
   TOGGLE_VALUE = /l33t\ h4x0r/
   def util_expected(n = nil)
-    [:defn, :uses_regexes,
-     [:scope,
-      [:block,
-       [:args],
-       [:lasgn, :i, [:lit, toggle(/a.*/, n == 1)]],
-       [:lasgn, :i, [:lit, toggle(/c{2,4}+/, n == 2)]],
-       [:lasgn, :i, [:lit, toggle(/123/, n == 3)]]]]]
+    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))))))
   end
 end
@@ -246,13 +260,13 @@ class TestHeckleRanges < LiteralHeckleTestCase
   TOGGLE_VALUE = 5..10
   def util_expected(n = nil)
-    [:defn, :uses_ranges,
-     [:scope,
-      [:block,
-       [:args],
-       [:lasgn, :i, [:lit, toggle(6..100, n == 1)]],
-       [:lasgn, :i, [:lit, toggle(-1..9, n == 2)]],
-       [:lasgn, :i, [:lit, toggle(1..4, n == 3)]]]]]
+    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))))))
   end
 end
@@ -260,13 +274,13 @@ class TestHeckleSameLiteral < LiteralHeckleTestCase
   TOGGLE_VALUE = 6
   def util_expected(n = nil)
-    [:defn, :uses_same_literal,
-     [:scope,
-      [:block,
-       [:args],
-       [:lasgn, :i, [:lit, toggle(1, n == 1)]],
-       [:lasgn, :i, [:lit, toggle(1, n == 2)]],
-       [:lasgn, :i, [:lit, toggle(1, n == 3)]]]]]
+    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))))))
   end
 end
@@ -274,53 +288,58 @@ class TestHeckleStrings < LiteralHeckleTestCase
   TOGGLE_VALUE = "l33t h4x0r"
   def util_expected(n = nil)
-    [:defn, :uses_strings,
-     [:scope,
-      [:block,
-       [:args],
-       [:call, [:ivar, :@names], :<<, [:array, [:str, toggle("Hello, Robert", n == 1)]]],
-       [:call, [:ivar, :@names], :<<, [:array, [:str, toggle("Hello, Jeff", n == 2)]]],
-       [:call, [:ivar, :@names], :<<, [:array, [:str, toggle("Hi, Frank", n == 3)]]]]]]
+    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)))))))
   end
 end
 class TestHeckleIf < HeckleTestCase
+  def setup
+    @nodes = s(:if)
+    super
+  end
   def test_default_structure
-    expected = [:defn, :uses_if,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:if,
-                   [:vcall, :some_func],
-                   [:if, [:vcall, :some_other_func], [:return], nil],
-                   nil]]]]
+    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)), s(:return), nil),
+                       nil))))
     assert_equal expected, @heckler.current_tree
   end
   def test_should_flip_if_to_unless
-    expected = [:defn, :uses_if,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:if,
-                   [:vcall, :some_func],
-                   [:if, [:vcall, :some_other_func], nil, [:return]],
-                   nil]]]]
+    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 = [:defn, :uses_if,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:if,
-                   [:vcall, :some_func],
-                   nil,
-                   [:if, [:vcall, :some_other_func], [:return], nil]]]]]
+    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
@@ -330,7 +349,7 @@ end
 class TestHeckleBoolean < HeckleTestCase
   def setup
-    @nodes = [:true, :false]
+    @nodes = s(:true, :false)
     super
   end
@@ -339,12 +358,12 @@ class TestHeckleBoolean < HeckleTestCase
   end
   def util_expected(n = nil)
-    [:defn, :uses_boolean,
-     [:scope,
-      [:block,
-       [:args],
-       [:lasgn, :a, [toggle(true, n == 1)]],
-       [:lasgn, :b, [toggle(false, n == 2)]]]]]
+    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_default_structure
@@ -363,46 +382,56 @@ class TestHeckleBoolean < HeckleTestCase
 end
 class TestHeckleWhile < HeckleTestCase
+  def setup
+    @nodes = s(:while)
+    super
+  end
   def test_default_structure
-    expected = [:defn, :uses_while,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:while, [:vcall, :some_func],
-                   [:vcall, :some_other_func], true]]]]
+    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 = [:defn, :uses_while,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:until, [:vcall, :some_func],
-                   [:vcall, :some_other_func], true]]]]
+    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
   end
 end
 class TestHeckleUntil < HeckleTestCase
+  def setup
+    @nodes = s(:until)
+    super
+  end
   def test_default_structure
-    expected = [:defn, :uses_until,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:until, [:vcall, :some_func],
-                   [:vcall, :some_other_func], true]]]]
+    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 = [:defn, :uses_until,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:while, [:vcall, :some_func],
-                   [:vcall, :some_other_func], true]]]]
+    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
   end
@@ -411,26 +440,29 @@ end
 class TestHeckleCall < HeckleTestCase
   def test_call_deleted
-    expected = [:defn, :uses_call,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:nil]]]]
+    expected = s(:defn, :uses_call,
+                 s(:args),
+                 s(:scope,
+                   s(:block,
+                     s(:nil))))
-    @heckler.process(@heckler.current_tree)
+    @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
   end
   def test_default_structure
-    expected = [:defn, :uses_call,
-                [:fbody,
-                 [:scope,
-                  [:block,
-                   [:args],
-                   [:call,
-                    [:vcall, :some_func],
-                    :+,
-                    [:array, [:vcall, :some_other_func]]]]]]]
+    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
@@ -440,175 +472,91 @@ end
 class TestHeckleCallblock < HeckleTestCase
   def setup
-    @nodes = [:call]
+    @nodes = s(:call)
     super
   end
-  def test_callblock_deleted
-    expected = [:defn, :uses_callblock,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:iter, [:call, [:vcall, :x], :y], nil, [:lit, 1]]]]]
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
-  end
-end
-class TestHeckleClassMethod < Test::Unit::TestCase
-  def setup
-    @heckler = TestHeckler.new("Heckled", "self.is_a_klass_method?")
-  end
-  def teardown
-    @heckler.reset
-  end
   def test_default_structure
-    expected = [:defn, :"self.is_a_klass_method?",
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:true]]]]
-    assert_equal expected, @heckler.current_tree
-  end
-  def test_heckle_class_methods
-    expected = [:defn, :"self.is_a_klass_method?",
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:false]]]]
-    @heckler.process(@heckler.current_tree)
-    assert_equal expected, @heckler.current_tree
-  end
-end
+    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)))))
-class TestHeckleCvasgn < HeckleTestCase
-  def setup
-    @nodes = [:cvasgn]
-    super
-  end
-  def test_cvasgn_val
-    expected = [:defn, :uses_cvasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:cvasgn, :@@cvar, [:nil]],
-                  [:cvasgn, :@@cvar, [:nil]]]]]
-    @heckler.process(@heckler.current_tree)
     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_cvasgn_nil
-    expected = [:defn, :uses_cvasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:cvasgn, :@@cvar, [:lit, 5]],
-                  [:cvasgn, :@@cvar, [:lit, 42]]]]]
-    @heckler.process(@heckler.current_tree)
-    @heckler.reset_tree
     @heckler.process(@heckler.current_tree)
     assert_equal expected, @heckler.current_tree
   end
 end
-class TestHeckleDasgn < HeckleTestCase
+class TestHeckleClassMethod < HeckleTestCase
   def setup
-    @nodes = [:dasgn]
+    @hecklee = "self.is_a_klass_method?"
+    @nodes = s(:true)
     super
   end
-  def test_dasgn_val
-    expected = [:defn, :uses_dasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:iter,
-                    [:fcall, :loop],
-                    [:dasgn_curr, :dvar],
-                    [:iter,
-                      [:fcall, :loop],
-                      nil,
-                      [:block,
-                        [:dasgn, :dvar, [:nil]],
-                        [:dasgn, :dvar, [:nil]]]]]]]]
-    @heckler.process(@heckler.current_tree)
+  def test_default_structure
+    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_dasgn_nil
-    expected = [:defn, :uses_dasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:iter,
-                    [:fcall, :loop],
-                    [:dasgn_curr, :dvar],
-                    [:iter,
-                      [:fcall, :loop],
-                      nil,
-                      [:block,
-                        [:dasgn, :dvar, [:lit, 5]],
-                        [:dasgn, :dvar, [:lit, 42]]]]]]]]
-    @heckler.process(@heckler.current_tree)
-    @heckler.reset_tree
+  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
   end
 end
-class TestHeckleDasgncurr < HeckleTestCase
+class TestHeckleCvasgn < HeckleTestCase
   def setup
-    @nodes = [:dasgn_curr]
+    @nodes = s(:cvasgn)
     super
   end
-  def test_dasgn_curr_val
-    expected = [:defn, :uses_dasgncurr,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:iter,
-                    [:fcall, :loop],
-                    [:dasgn_curr, :dvar],
-                    [:block,
-                      [:dasgn_curr, :dvar, [:nil]],
-                      [:dasgn_curr, :dvar, [:nil]]]]]]]
+  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)))))
-    @heckler.process(@heckler.current_tree)
-    @heckler.reset_tree
     @heckler.process(@heckler.current_tree)
     assert_equal expected, @heckler.current_tree
   end
-  def test_dasgn_curr_nil
-    expected = [:defn, :uses_dasgncurr,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:iter,
-                    [:fcall, :loop],
-                    [:dasgn_curr, :dvar],
-                    [:block,
-                      [:dasgn_curr, :dvar, [:lit, 5]],
-                      [:dasgn_curr, :dvar, [:lit, 42]]]]]]]
+  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)
     @heckler.reset_tree
     @heckler.process(@heckler.current_tree)
@@ -620,29 +568,29 @@ end
 class TestHeckleIasgn < HeckleTestCase
   def setup
-    @nodes = [:iasgn]
+    @nodes = s(:iasgn)
     super
   end
   def test_iasgn_val
-    expected = [:defn, :uses_iasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:iasgn, :@ivar, [:nil]],
-                  [:iasgn, :@ivar, [:nil]]]]]
+    expected = 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)
     assert_equal expected, @heckler.current_tree
   end
   def test_iasgn_nil
-    expected = [:defn, :uses_iasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:iasgn, :@ivar, [:lit, 5]],
-                  [:iasgn, :@ivar, [:lit, 42]]]]]
+    expected = s(:defn, :uses_iasgn,
+                 s(:args),
+                 s(:scope,
+                   s(:block,
+                     s(:iasgn, :@ivar, s(:lit, 5)),
+                     s(:iasgn, :@ivar, s(:lit, 42)))))
     @heckler.process(@heckler.current_tree)
     @heckler.reset_tree
@@ -655,29 +603,29 @@ end
 class TestHeckleGasgn < HeckleTestCase
   def setup
-    @nodes = [:gasgn]
+    @nodes = s(:gasgn)
     super
   end
   def test_gasgn_val
-    expected = [:defn, :uses_gasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:gasgn, :$gvar, [:nil]],
-                  [:gasgn, :$gvar, [:nil]]]]]
+    expected = 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)
     assert_equal expected, @heckler.current_tree
   end
   def test_gasgn_nil
-    expected = [:defn, :uses_gasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:gasgn, :$gvar, [:lit, 5]],
-                  [:gasgn, :$gvar, [:lit, 42]]]]]
+    expected = s(:defn, :uses_gasgn,
+                 s(:args),
+                 s(:scope,
+                   s(:block,
+                     s(:gasgn, :$gvar, s(:lit, 5)),
+                     s(:gasgn, :$gvar, s(:lit, 42)))))
     @heckler.process(@heckler.current_tree)
     @heckler.reset_tree
@@ -690,29 +638,29 @@ end
 class TestHeckleLasgn < HeckleTestCase
   def setup
-    @nodes = [:lasgn]
+    @nodes = s(:lasgn)
     super
   end
   def test_lasgn_val
-    expected = [:defn, :uses_lasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:lasgn, :lvar, [:nil]],
-                  [:lasgn, :lvar, [:nil]]]]]
+    expected = s(:defn, :uses_lasgn,
+                 s(:args),
+                 s(:scope,
+                   s(:block,
+                     s(:lasgn, :lvar, s(:nil)),
+                     s(:lasgn, :lvar, s(:nil)))))
     @heckler.process(@heckler.current_tree)
     assert_equal expected, @heckler.current_tree
   end
   def test_lasgn_nil
-    expected = [:defn, :uses_lasgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:lasgn, :lvar, [:lit, 5]],
-                  [:lasgn, :lvar, [:lit, 42]]]]]
+    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
@@ -725,21 +673,21 @@ end
 class TestHeckleMasgn < HeckleTestCase
   def setup
-    @nodes = [:dasgn, :dasgn_curr, :iasgn, :gasgn, :lasgn]
+    @nodes = s(:dasgn, :dasgn_curr, :iasgn, :gasgn, :lasgn)
     super
   end
   def test_masgn
-    expected = [:defn, :uses_masgn,
-                [:scope,
-                 [:block,
-                  [:args],
-                  [:masgn,
-                    [:array,
-                      [:lasgn, :_heckle_dummy],
-                      [:gasgn, :$b],
-                      [:lasgn, :c]],
-                    [:array, [:lit, 5], [:lit, 6], [:lit, 7]]]]]]
+    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))))))
     @heckler.process(@heckler.current_tree)
     assert_equal expected, @heckler.current_tree
@@ -747,3 +695,43 @@ class TestHeckleMasgn < HeckleTestCase
 end
+class TestHeckleIter < HeckleTestCase
+  def setup
+    @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)
+    @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))))))
+    @heckler.process(@heckler.current_tree)
+    assert_equal(expected, @heckler.current_tree)
+  end
+end