heckle 1.3.0 → 1.4.0

data/History.txt

@@ -1,3 +1,13 @@
+== 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
+
 == 1.3.0 / 2007-02-12
 
 * 1 major enhancement:
@@ -10,7 +20,7 @@
 * 2 bug fixes:
   * Aborts when an unknown method is supplied.
   * Escapes slashes in random regexps.
-  
+
 == 1.2.0 / 2007-01-15
 
 * 2 major enhancements:
@@ -22,7 +32,7 @@
   * 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:
@@ -45,7 +55,7 @@
   * Can mutate regexes, ranges, symbols
   * Can run against entire classes
   * Command line options!
-  
+
 == 1.0.0 / 2006-10-22
 
 * 1 major enhancement

data/bin/heckle

@@ -4,6 +4,8 @@ $:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
 require 'test_unit_heckler'
 require 'optparse'
 
+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|
@@ -20,13 +22,31 @@ opts = OptionParser.new do |opts|
     TestUnitHeckler.test_pattern = pattern
   end
 
-  opts.on( "-b", "--branches-only", "Only mutate branches" ) do |opt|
+  opts.on(       "--assignments", "Only mutate assignments" ) do |opt|
+    puts "!"*70
+    puts "!!! Heckling assignments only"
+    puts "!"*70
+    puts
+
+    nodes = Heckle::ASGN_NODES
+  end
+
+  opts.on( "-b", "--branches", "Only mutate branches" ) do |opt|
     puts "!"*70
     puts "!!! Heckling branches only"
     puts "!"*70
     puts
 
-    Heckle::MUTATABLE_NODES.replace [:if, :while, :until]
+    nodes = Heckle::BRANCH_NODES
+  end
+
+  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
+    puts
+
+    TestUnitHeckler.focus = true
   end
 
   opts.on( "-T", "--timeout SECONDS", "The maximum time for a test run in seconds",
@@ -35,6 +55,18 @@ opts = OptionParser.new do |opts|
     puts "Setting timeout at #{timeout} seconds."
   end
 
+  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|
+    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|
     puts opts
     exit 0
@@ -54,4 +86,4 @@ unless impl then
   exit 1
 end
 
-exit TestUnitHeckler.validate(impl, meth) ? 0 : 1
+exit TestUnitHeckler.validate(impl, meth, nodes)

data/lib/heckle.rb

@@ -4,22 +4,76 @@ require 'ruby2ruby'
 require 'timeout'
 require 'tempfile'
 
-class String
+class String # :nodoc:
   def to_class
     split(/::/).inject(Object) { |klass, name| klass.const_get(name) }
   end
 end
 
+##
+# Test Unit Sadism
+
 class Heckle < SexpProcessor
-  VERSION = '1.3.0'
-  MUTATABLE_NODES = [:if, :lit, :str, :true, :false, :while, :until]
+
+  ##
+  # The version of Heckle you are using.
+
+  VERSION = '1.4.0'
+
+  ##
+  # Branch node types.
+
+  BRANCH_NODES = [:if, :until, :while]
+
+  ##
+  # Is this platform MS Windows-like?
+
   WINDOZE = RUBY_PLATFORM =~ /mswin/
+
+  ##
+  # Path to the bit bucket.
+
   NULL_PATH = WINDOZE ? 'NUL:' : '/dev/null'
+
+  ##
+  # diff(1) executable
+
   DIFF = WINDOZE ? 'diff.exe' : 'diff'
 
-  attr_accessor(:klass_name, :method_name, :klass, :method, :mutatees,
-                :original_tree, :mutation_count, :node_count,
-                :failures, :count)
+  ##
+  # Mutation count
+
+  attr_accessor :count
+
+  ##
+  # Mutations that caused failures
+
+  attr_accessor :failures
+
+  ##
+  # Class being heckled
+
+  attr_accessor :klass
+
+  ##
+  # Name of class being heckled
+
+  attr_accessor :klass_name
+
+  ##
+  # Method being heckled
+
+  attr_accessor :method
+
+  ##
+  # Name of method being heckled
+
+  attr_accessor :method_name
+
+  attr_accessor :mutatees # :nodoc:
+  attr_accessor :mutation_count # :nodoc:
+  attr_accessor :node_count # :nodoc:
+  attr_accessor :original_tree # :nodoc:
 
   @@debug = false
   @@guess_timeout = true
@@ -38,7 +92,12 @@ class Heckle < SexpProcessor
     @@guess_timeout
   end
 
-  def initialize(klass_name=nil, method_name=nil, reporter = Reporter.new)
+  ##
+  # Creates a new Heckle that will heckle +klass_name+ and +method_name+,
+  # sending results to +reporter+.
+
+  def initialize(klass_name = nil, method_name = nil,
+                 nodes = Heckle::MUTATABLE_NODES, reporter = Reporter.new)
     super()
 
     @klass_name = klass_name
@@ -58,7 +117,8 @@ class Heckle < SexpProcessor
     @node_count = Hash.new
     @count = 0
 
-    MUTATABLE_NODES.each {|type| @mutatees[type] = [] }
+    @mutatable_nodes = nodes
+    @mutatable_nodes.each {|type| @mutatees[type] = [] }
 
     @failures = []
 
@@ -70,8 +130,9 @@ class Heckle < SexpProcessor
     @original_mutatees = mutatees.deep_clone
   end
 
-  ############################################################
-  ### Overwrite test_pass? for your own Heckle runner.
+  ##
+  # Overwrite test_pass? for your own Heckle runner.
+
   def tests_pass?
     raise NotImplementedError
   end
@@ -154,6 +215,24 @@ class Heckle < SexpProcessor
   ############################################################
   ### Processing sexps
 
+  def process_call(exp)
+    recv = process(exp.shift)
+    meth = exp.shift
+    args = process(exp.shift)
+
+    out = [:call, recv, meth]
+    out << args if args
+
+    mutate_node out
+  end
+
+  ##
+  # Replaces the call node with nil.
+
+  def mutate_call(node)
+    [:nil]
+  end
+
   def process_defn(exp)
     self.method = exp.shift
     result = [:defn, method]
@@ -166,10 +245,96 @@ class Heckle < SexpProcessor
     reset_node_count
   end
 
+  def process_asgn(type, exp)
+    var = exp.shift
+    if exp.empty? then
+      mutate_node [type, var]
+    else
+      mutate_node [type, var, process(exp.shift)]
+    end
+  end
+
+  def mutate_asgn(node)
+    type = node.shift
+    var = node.shift
+    if node.empty? then
+      [:lasgn, :_heckle_dummy]
+    else
+      if node.last.first == :nil then
+        [type, var, [:lit, 42]]
+      else
+        [type, var, [:nil]]
+      end
+    end
+  end
+
+  def process_cvasgn(exp)
+    process_asgn :cvasgn, exp
+  end
+
+  ##
+  # Replaces the value of the cvasgn with nil if its some value, and 42 if its
+  # nil.
+
+  alias mutate_cvasgn mutate_asgn
+
+  def process_dasgn(exp)
+    process_asgn :dasgn, exp
+  end
+
+  ##
+  # Replaces the value of the dasgn with nil if its some value, and 42 if its
+  # nil.
+
+  alias mutate_dasgn mutate_asgn
+
+  def process_dasgn_curr(exp)
+    process_asgn :dasgn_curr, exp
+  end
+
+  ##
+  # Replaces the value of the dasgn_curr with nil if its some value, and 42 if
+  # its nil.
+
+  alias mutate_dasgn_curr mutate_asgn
+
+  def process_iasgn(exp)
+    process_asgn :iasgn, exp
+  end
+
+  ##
+  # Replaces the value of the iasgn with nil if its some value, and 42 if its
+  # nil.
+
+  alias mutate_iasgn mutate_asgn
+
+  def process_gasgn(exp)
+    process_asgn :gasgn, exp
+  end
+
+  ##
+  # Replaces the value of the gasgn with nil if its some value, and 42 if its
+  # nil.
+
+  alias mutate_gasgn mutate_asgn
+
+  def process_lasgn(exp)
+    process_asgn :lasgn, exp
+  end
+
+  ##
+  # Replaces the value of the lasgn with nil if its some value, and 42 if its
+  # nil.
+
+  alias mutate_lasgn mutate_asgn
+
   def process_lit(exp)
     mutate_node [:lit, exp.shift]
   end
 
+  ##
+  # Replaces the value of the :lit node with a random value.
+
   def mutate_lit(exp)
     case exp[1]
     when Fixnum, Float, Bignum
@@ -187,6 +352,9 @@ class Heckle < SexpProcessor
     mutate_node [:str, exp.shift]
   end
 
+  ##
+  # Replaces the value of the :str node with a random value.
+
   def mutate_str(node)
     [:str, rand_string]
   end
@@ -195,6 +363,9 @@ class Heckle < SexpProcessor
     mutate_node [: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]]
   end
@@ -203,6 +374,9 @@ class Heckle < SexpProcessor
     mutate_node [:true]
   end
 
+  ##
+  # Swaps for a :false node.
+
   def mutate_true(node)
     [:false]
   end
@@ -211,6 +385,9 @@ class Heckle < SexpProcessor
     mutate_node [:false]
   end
 
+  ##
+  # Swaps for a :true node.
+
   def mutate_false(node)
     [:true]
   end
@@ -220,6 +397,9 @@ class Heckle < SexpProcessor
     mutate_node [:while, cond, body, head_controlled]
   end
 
+  ##
+  # Swaps for a :until node.
+
   def mutate_while(node)
     [:until, node[1], node[2], node[3]]
   end
@@ -229,6 +409,9 @@ class Heckle < SexpProcessor
     mutate_node [:until, cond, body, head_controlled]
   end
 
+  ##
+  # Swaps for a :while node.
+
   def mutate_until(node)
     [:while, node[1], node[2], node[3]]
   end
@@ -237,7 +420,7 @@ class Heckle < SexpProcessor
     raise UnsupportedNodeError unless respond_to? "mutate_#{node.first}"
     increment_node_count node
 
-    if should_heckle? node
+    if should_heckle? node then
       increment_mutation_count node
       return send("mutate_#{node.first}", node)
     else
@@ -252,7 +435,7 @@ class Heckle < SexpProcessor
     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
+    if @mutatable_nodes.include? node.first
       @mutatees[node.first.to_sym].push(node)
       mutation_count[node] = 0
     end
@@ -350,10 +533,16 @@ class Heckle < SexpProcessor
     RubyToRuby.translate(klass_name.to_class, method_name)
   end
 
+  ##
+  # Returns a random Fixnum.
+
   def rand_number
     (rand(100) + 1)*((-1)**rand(2))
   end
 
+  ##
+  # Returns a random String
+
   def rand_string
     size = rand(50)
     str = ""
@@ -361,6 +550,9 @@ class Heckle < SexpProcessor
     str
   end
 
+  ##
+  # Returns a random Symbol
+
   def rand_symbol
     letters = ('a'..'z').to_a + ('A'..'Z').to_a
     str = ""
@@ -368,12 +560,18 @@ class Heckle < SexpProcessor
     :"#{str}"
   end
 
+  ##
+  # Returns a random Range
+
   def rand_range
     min = rand(50)
     max = min + rand(50)
     min..max
   end
 
+  ##
+  # Suppresses output on $stdout and $stderr.
+
   def silence_stream
     dead = File.open("/dev/null", "w")
 
@@ -467,4 +665,19 @@ class Heckle < SexpProcessor
       puts "Tests failed -- this is good"
     end
   end
+
+  ##
+  # All nodes that can be mutated by Heckle.
+
+  MUTATABLE_NODES = instance_methods.grep(/mutate_/).sort.map do |meth|
+    meth.sub(/mutate_/, '').intern
+  end - [:asgn, :node] # Ignore these methods
+
+  ##
+  # All assignment nodes that can be mutated by Heckle..
+
+  ASGN_NODES = MUTATABLE_NODES.map { |n| n.to_s }.grep(/asgn/).map do |n|
+    n.intern
+  end
+
 end

data/lib/test_unit_heckler.rb

@@ -2,22 +2,30 @@
 
 require 'test/unit/autorunner'
 require 'heckle'
+require 'zentest_mapping'
+
 $: << 'lib' << 'test'
 
 class TestUnitHeckler < Heckle
   @@test_pattern = 'test/test_*.rb'
-  @@tests_loaded = false;
+  @@tests_loaded = false
+  @@focus = false
 
   def self.test_pattern=(value)
     @@test_pattern = value
   end
 
+  def self.focus=(value)
+    @@focus = value
+  end
+
   def self.load_test_files
     @@tests_loaded = true
     Dir.glob(@@test_pattern).each {|test| require test}
   end
 
-  def self.validate(klass_name, method_name = nil)
+  def self.validate(klass_name, method_name = nil,
+                    nodes = Heckle::MUTATABLE_NODES)
     load_test_files
     klass = klass_name.to_class
 
@@ -54,7 +62,7 @@ class TestUnitHeckler < Heckle
 
     counts = Hash.new(0)
     methods.sort.each do |method_name|
-      result = self.new(klass_name, method_name).validate
+      result = self.new(klass_name, method_name, nodes).validate
       counts[result] += 1
     end
     all_good = counts[false] == 0
@@ -75,14 +83,22 @@ class TestUnitHeckler < Heckle
     all_good
   end
 
-  def initialize(klass_name=nil, method_name=nil)
-    super(klass_name, method_name)
+  def initialize(klass_name=nil, method_name=nil, nodes=Heckle::MUTATABLE_NODES)
+    super
     self.class.load_test_files unless @@tests_loaded
   end
 
+  include ZenTestMapping
+
   def tests_pass?
     silence_stream do
+      if @@focus and @method_name then
+        name = normal_to_test @method_name.to_s
+        ARGV.clear
+        ARGV << "--name=/#{name}/"
+      end
       Test::Unit::AutoRunner.run
+      ARGV.clear
     end
   end
 end

data/test/fixtures/heckled.rb

@@ -5,6 +5,50 @@ class Heckled
     @names = []
   end
 
+  def uses_call
+    some_func + some_other_func
+  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

data/test/test_heckle.rb

@@ -27,9 +27,10 @@ end
 class HeckleTestCase < Test::Unit::TestCase
   undef_method :default_test
   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}")
+    @heckler = TestHeckler.new("Heckled", "uses#{data}", @nodes)
   end
 
   def teardown
@@ -38,6 +39,11 @@ class HeckleTestCase < Test::Unit::TestCase
 end
 
 class LiteralHeckleTestCase < HeckleTestCase
+  def setup
+    @nodes = [:lit, :str]
+    super
+  end
+
   def toggle(value, toggle)
     toggle ? self.class::TOGGLE_VALUE : value
   end
@@ -93,6 +99,17 @@ 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
+      :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"]]],
@@ -121,7 +138,7 @@ class TestHeckle < HeckleTestCase
   end
 
   def test_should_count_mutatees_left
-    assert_equal 10, @heckler.mutations_left
+    assert_equal 15, @heckler.mutations_left
   end
 
   def test_reset
@@ -239,7 +256,6 @@ class TestHeckleRanges < LiteralHeckleTestCase
   end
 end
 
-
 class TestHeckleSameLiteral < LiteralHeckleTestCase
   TOGGLE_VALUE = 6
 
@@ -312,6 +328,12 @@ class TestHeckleIf < HeckleTestCase
 end
 
 class TestHeckleBoolean < HeckleTestCase
+
+  def setup
+    @nodes = [:true, :false]
+    super
+  end
+
   def toggle(value, toggle)
     (toggle ? ! value : value).to_s.intern
   end
@@ -386,6 +408,35 @@ class TestHeckleUntil < HeckleTestCase
   end
 end
 
+class TestHeckleCall < HeckleTestCase
+
+  def test_call_deleted
+    expected = [:defn, :uses_call,
+                [:scope,
+                 [:block,
+                  [:args],
+                  [:nil]]]]
+
+    @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]]]]]]]
+
+    assert_equal expected, @heckler.current_tree
+  end
+
+end
+
 class TestHeckleClassMethod < Test::Unit::TestCase
   def setup
     @heckler = TestHeckler.new("Heckled", "self.is_a_klass_method?")
@@ -414,8 +465,265 @@ class TestHeckleClassMethod < Test::Unit::TestCase
     assert_equal expected, @heckler.current_tree
   end
 end
- 
- 
- 
- 
- 
+
+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_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
+
+  def setup
+    @nodes = [:dasgn]
+    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)
+    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
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+
+end
+
+class TestHeckleDasgncurr < HeckleTestCase
+
+  def setup
+    @nodes = [:dasgn_curr]
+    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]]]]]]]
+
+    @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]]]]]]]
+
+    @heckler.process(@heckler.current_tree)
+    @heckler.reset_tree
+    @heckler.process(@heckler.current_tree)
+    @heckler.reset_tree
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+
+end
+
+class TestHeckleIasgn < HeckleTestCase
+
+  def setup
+    @nodes = [:iasgn]
+    super
+  end
+
+  def test_iasgn_val
+    expected = [:defn, :uses_iasgn,
+                [:scope,
+                 [:block,
+                  [:args],
+                  [:iasgn, :@ivar, [:nil]],
+                  [:iasgn, :@ivar, [: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]]]]]
+
+    @heckler.process(@heckler.current_tree)
+    @heckler.reset_tree
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+
+end
+
+class TestHeckleGasgn < HeckleTestCase
+
+  def setup
+    @nodes = [:gasgn]
+    super
+  end
+
+  def test_gasgn_val
+    expected = [:defn, :uses_gasgn,
+                [:scope,
+                 [:block,
+                  [:args],
+                  [:gasgn, :$gvar, [:nil]],
+                  [:gasgn, :$gvar, [: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]]]]]
+
+    @heckler.process(@heckler.current_tree)
+    @heckler.reset_tree
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+
+end
+
+class TestHeckleLasgn < HeckleTestCase
+
+  def setup
+    @nodes = [:lasgn]
+    super
+  end
+
+  def test_lasgn_val
+    expected = [:defn, :uses_lasgn,
+                [:scope,
+                 [:block,
+                  [:args],
+                  [:lasgn, :lvar, [:nil]],
+                  [:lasgn, :lvar, [: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]]]]]
+
+    @heckler.process(@heckler.current_tree)
+    @heckler.reset_tree
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+
+end
+
+class TestHeckleMasgn < HeckleTestCase
+
+  def setup
+    @nodes = [: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]]]]]]
+
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+
+end
+

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0.9
 specification_version: 1
 name: heckle
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
-date: 2007-02-13 00:00:00 -08:00
+  version: 1.4.0
+date: 2007-05-18 00:00:00 -07:00
 summary: Unit Test Sadism
 require_paths: 
 - lib