heckle 1.0.0 → 1.1.0

data/lib/heckle/reporter.rb

@@ -0,0 +1,43 @@
+module Heckle
+  class Reporter
+    def no_mutations(method_name)
+      puts
+      puts "!"*70
+      puts "!!! #{method_name} has a thick skin. There's nothing to heckle."
+      puts "!"*70
+      puts
+    end
+
+    def method_loaded(klass_name, method_name, mutations_left)
+      puts
+      puts "*"*70
+      puts "***  #{klass_name}\##{method_name} loaded with #{mutations_left} possible mutations"
+      puts "*"*70
+      puts
+    end
+
+    def remaining_mutations(mutations_left)
+      puts "#{mutations_left} mutations remaining..."
+    end
+
+    def no_failures
+      puts "\nThe following mutations didn't cause test failures:\n"
+    end
+
+    def failure(failure)
+      puts "\n#{failure}\n"
+    end
+
+    def no_surviving_mutants
+      puts "No mutants survived. Cool!\n\n"
+    end
+
+    def replacing(klass_name, method_name, src)
+      puts "Replacing #{klass_name}##{method_name} with:\n\n#{src}\n"
+    end
+
+    def report_test_failures
+      puts "Tests failed -- this is good"
+    end
+  end
+end

data/lib/test_unit_heckler.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'test/unit/autorunner'
+require 'heckle'
+
+class TestUnitHeckler < Heckle::Base
+  @@test_pattern = 'test/test_*.rb'
+  @@tests_loaded = false;
+
+  def self.test_pattern=(value)
+    @@test_pattern = value
+  end
+  
+  def self.load_test_files
+    @@tests_loaded = true
+    Dir.glob(@@test_pattern).each {|test| require test}
+  end
+
+  def self.validate(klass_name)
+    load_test_files
+    klass = klass_name.to_class
+    klass.instance_methods(false).each do |method_name|
+      heckler = self.new(klass_name, method_name)
+      heckler.test_and_validate
+    end
+  end
+
+  def initialize(klass_name=nil, method_name=nil)
+    super(klass_name, method_name)
+    self.class.load_test_files unless @@tests_loaded
+  end
+  
+  def test_and_validate
+    if silence_stream(STDOUT) { tests_pass? } then
+      puts "Initial tests pass. Let's rumble."
+      validate
+    else
+      puts "Tests failed... fix and run heckle again"
+    end
+  end
+  
+  def tests_pass?
+    Test::Unit::AutoRunner.run
+  end
+end

data/sample/Rakefile

@@ -0,0 +1,16 @@
+# -*- ruby -*-
+require 'rubygems'
+require 'rake/testtask'
+
+task :default => :test
+
+desc "Run basic tests"
+Rake::TestTask.new { |t|
+  t.pattern = 'test/test_*.rb'
+  t.verbose = true
+  t.warning = true
+}
+
+
+
+# vim: syntax=Ruby

data/sample/changes.log

@@ -0,0 +1,91 @@
+# Logfile created on Fri Nov 10 22:52:10 PST 2006 by logger.rb/1.5.2.7
+I, [2006-11-10T22:52:10.310486 #498]  INFO -- : Validating 
+I, [2006-11-10T22:52:10.326577 #498]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T22:52:10.328115 #498]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "I\rmeo&+eIZ{bD2dj1Z_e\001{Y!](CbI'!`@\020Wlg4,w\t\02181/4J\t\v@][ L!Xy[\r\\MJ[0.+gh}\001ks\026_-BK")
+  (@names << "Hello, Jeff")
+  (@names << "Hi, Frank")
+end
+I, [2006-11-10T22:52:10.344547 #498]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T22:52:10.346021 #498]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "Hello, Robert")
+  (@names << "\030ym+3\f:\031\023`\r:O\a")
+  (@names << "Hi, Frank")
+end
+I, [2006-11-10T22:52:10.356743 #498]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T22:52:10.358234 #498]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "Hello, Robert")
+  (@names << "Hello, Jeff")
+  (@names << "o,NY\020\027V0v\032dEw\010<*4\026uh$\026\010vhl(A\"ybX$sd\"M\006qbH\032TAV/")
+end
+I, [2006-11-10T22:52:10.369174 #498]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T22:52:10.370636 #498]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "Hello, Robert")
+  (@names << "Hello, Jeff")
+  (@names << "Hi, Frank")
+end
+I, [2006-11-10T23:17:54.953429 #569]  INFO -- : Validating 
+I, [2006-11-10T23:19:05.369315 #570]  INFO -- : Validating 
+I, [2006-11-10T23:20:01.512545 #571]  INFO -- : Validating 
+I, [2006-11-10T23:20:08.080030 #572]  INFO -- : Validating 
+I, [2006-11-10T23:20:08.100363 #572]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T23:20:08.101943 #572]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "\034\000\021[\r\aM!L=qfU'#")
+  (@names << "Hello, Jeff")
+  (@names << "Hi, Frank")
+end
+I, [2006-11-10T23:20:08.120455 #572]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T23:20:08.122176 #572]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "Hello, Robert")
+  (@names << "\r\025 $\n<z\037Z5<VSsja\026/\t>(&6P^X<\000\t..[<QGM\036\ei$\010RL\030J.vEsJ,")
+  (@names << "Hi, Frank")
+end
+I, [2006-11-10T23:20:08.141360 #572]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T23:20:08.143164 #572]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "Hello, Robert")
+  (@names << "Hello, Jeff")
+  (@names << ":\032lTh\031\037sw8\004!d\021\017n8\"\f8ucDs:.H\026n\010Bb|Is?p\027XR<4+%qfQ|^(\022\aN\024<e)\023P_a.j\000(\037bRe\"&xIO\001\f5\021o?\005\a\034)V@WmAb|\001(Z\020\032")
+end
+I, [2006-11-10T23:20:08.162167 #572]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T23:20:08.163769 #572]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "Hello, Robert")
+  (@names << "Hello, Jeff")
+  (@names << "Hi, Frank")
+end
+I, [2006-11-10T23:20:30.047573 #574]  INFO -- : Validating 
+I, [2006-11-10T23:20:30.064031 #574]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T23:20:30.065826 #574]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "B]ms\026*\025\034\035%\026d_!\023\017c8\f\v\003G\fSAdh\025kC8&!,1sc\032htACl6\023rgq[j\016J>\003$I\025\037\001\027E$/P\025<Uu+#MCN%.mGFw\005qje 1D\037{wQL")
+  (@names << "Hello, Jeff")
+  (@names << "Hi, Frank")
+end
+I, [2006-11-10T23:20:30.076369 #574]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T23:20:30.078079 #574]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "Hello, Robert")
+  (@names << "A\002\tu<:r\021L\n`yArP\010\032]n\n\036+@?sh\e\020\023{\027I<t+QbD\000\006:3{w\f\\XCH\032\026xSogO\036)*B_E\034;\016\\Mj")
+  (@names << "Hi, Frank")
+end
+I, [2006-11-10T23:20:30.089013 #574]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T23:20:30.090484 #574]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "Hello, Robert")
+  (@names << "Hello, Jeff")
+  (@names << "Z\023C#\025qg{Cb++W\r\\dtEbq4P2c")
+end
+I, [2006-11-10T23:20:30.101238 #574]  INFO -- : Heckling Heckled#uses_strings
+I, [2006-11-10T23:20:30.102788 #574]  INFO -- : Replacing #uses_strings with:
+def uses_strings
+  (@names << "Hello, Robert")
+  (@names << "Hello, Jeff")
+  (@names << "Hi, Frank")
+end

data/sample/lib/heckled.rb

@@ -0,0 +1,63 @@
+class Heckled
+  attr_accessor :names
+  
+  def initialize
+    @names = []
+  end
+  
+  def uses_while
+    i = 1
+    while i < 10
+      i += 1
+    end 
+    i
+  end
+
+  def uses_until
+    i = 1
+    until i >= 10
+      i += 1
+    end
+    i
+  end
+  
+  def uses_numeric_literals
+    i = 1
+    i += 10
+    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_the_same_literal
+    i = 1
+    i = 1
+    i = 1
+  end
+  
+  def uses_if
+    if true
+      if false
+        return
+      end
+    end
+  end
+  
+  def uses_unless
+    unless true
+      if false
+        return
+      end
+    end
+  end
+end

data/sample/test/test_heckled.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#
+#  Created by Kevin Clark on 2006-11-10.
+#  Copyright (c) 2006. All rights reserved.
+
+require "test/unit"
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require "heckled"
+
+class TestHeckled < Test::Unit::TestCase
+  def setup
+    @heckled = Heckled.new
+  end
+  def test_uses_strings
+    @heckled.uses_strings
+    assert_equal ["Hello, Robert", "Hello, Jeff", "Hi, Frank"], @heckled.names
+  end
+end

data/test/fixtures/heckled.rb

@@ -0,0 +1,103 @@
+class Heckled
+  attr_accessor :names
+  
+  def initialize
+    @names = []
+  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_the_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
+    true
+    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
+  
+  private
+  
+  def some_func; end
+  def some_other_func; end
+end

data/test/test_heckle.rb

@@ -1,33 +1,658 @@
+$:.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'
 
 class TestHeckle < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_many_things")
+  end
+  
+  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]]]]]
+    
+    assert_equal expected, @heckler.original_tree
+  end
+  
+  def test_should_grab_mutatees_from_method
+    # expected is from tree of uses_while
+    expected = {
+     :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]]
+    }
+     
+    assert_equal expected, @heckler.mutatees
+  end
+  
+  def test_should_count_mutatees_left
+    assert_equal 10, @heckler.mutations_left
+  end
 
-  ############################################################
-  # Our method under test - in here just for demo...
+  def test_reset
+    original_tree = @heckler.current_tree.deep_clone
+    original_mutatees = @heckler.mutatees.deep_clone
+    
+    3.times { @heckler.process(@heckler.current_tree) }
+    
+    assert_not_equal original_tree, @heckler.current_tree
+    assert_not_equal original_mutatees, @heckler.mutatees
+    
+    @heckler.reset
+    assert_equal original_tree[2], @heckler.current_tree[2][1]
+    assert_equal original_mutatees, @heckler.mutatees
+  end
+  
+  def test_reset_tree
+    original_tree = @heckler.current_tree.deep_clone
+    
+    @heckler.process(@heckler.current_tree)
+    assert_not_equal original_tree, @heckler.current_tree    
+    
+    @heckler.reset_tree
+    assert_equal original_tree, @heckler.current_tree
+  end
+  
+  def test_reset_should_work_over_several_process_calls
+    original_tree = @heckler.current_tree.deep_clone
+    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
+    
+    @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
+    
+    @heckler.reset
+    assert_equal original_tree, @heckler.current_tree
+    assert_equal original_mutatees, @heckler.mutatees
+  end
+  
+  def test_reset_mutatees
+    original_mutatees = @heckler.mutatees.deep_clone
+    
+    @heckler.process(@heckler.current_tree)
+    assert_not_equal original_mutatees, @heckler.mutatees
+    
+    @heckler.reset_mutatees
+    assert_equal original_mutatees, @heckler.mutatees
+  end
+  
+  def teardown
+    @heckler.reset
+  end
+end
 
-  def many? n
-    if n >= 3 then
-      true
-    else
-      false
+module Heckle
+  class Base
+    def rand(*args)
+      5
+    end
+  
+    def rand_number(*args)
+      5
     end
   end
+end
 
-  ############################################################
+class TestHeckleNumbers < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_numeric_literals")
+  end
+      
+  def test_literals_should_flip_one_at_a_time
+    assert_equal 3, @heckler.mutations_left
+    expected = [:defn,
+     :uses_numeric_literals,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 6]],
+       [:lasgn, :i, [:call, [:lvar, :i], :+, [:array, [:lit, 2147483648]]]],
+       [:lasgn, :i, [:call, [:lvar, :i], :-, [:array, [:lit, 3.5]]]]]]]
+    
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+    
+    @heckler.reset_tree
+    
+    expected = [:defn,
+     :uses_numeric_literals,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 1]],
+       [:lasgn, :i, [:call, [:lvar, :i], :+, [:array, [:lit, 2147483653]]]],
+       [:lasgn, :i, [:call, [:lvar, :i], :-, [:array, [:lit, 3.5]]]]]]]
+    
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+    
+    @heckler.reset_tree
+    
+    expected = [:defn,
+     :uses_numeric_literals,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 1]],
+       [:lasgn, :i, [:call, [:lvar, :i], :+, [:array, [:lit, 2147483648]]]],
+       [:lasgn, :i, [:call, [:lvar, :i], :-, [:array, [:lit, 8.5]]]]]]]
+    
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
   
-  if false then
-    def test_many_eh_good
-      assert ! many?(0)
-      assert ! many?(1)
-      assert   many?(3)
+  def teardown
+    @heckler.reset
+  end
+end
+
+module Heckle
+  class Base
+    def rand_symbol
+      :"l33t h4x0r"
     end
-  else
-    def test_many_eh_bad
-      # obviously bad - need a better example for my demo
+  end
+end
+
+class TestHeckleSymbols < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_symbols")
+  end
+  
+  def test_default_structure
+    expected = [:defn,
+     :uses_symbols,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, :blah]],
+       [:lasgn, :i, [:lit, :blah]],
+       [:lasgn, :i, [:lit, :and_blah]]]]]
+    assert_equal expected, @heckler.current_tree
+  end
+  
+  
+  def test_should_randomize_symbol
+    expected = [:defn,
+     :uses_symbols,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, :"l33t h4x0r"]],
+       [:lasgn, :i, [:lit, :blah]],
+       [:lasgn, :i, [:lit, :and_blah]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  
+    @heckler.reset_tree
+  
+    expected = [:defn,
+     :uses_symbols,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, :blah]],
+       [:lasgn, :i, [:lit, :"l33t h4x0r"]],
+       [:lasgn, :i, [:lit, :and_blah]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+    
+    @heckler.reset_tree
+    
+    expected = [:defn,
+     :uses_symbols,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, :blah]],
+       [:lasgn, :i, [:lit, :blah]],
+       [:lasgn, :i, [:lit, :"l33t h4x0r"]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+end
+
+class TestHeckleRegexes < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_regexes")
+  end
+  
+  def test_default_structure
+    expected = [:defn,
+     :uses_regexes,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, /a.*/]],
+       [:lasgn, :i, [:lit, /c{2,4}+/]],
+       [:lasgn, :i, [:lit, /123/]]]]]
+    assert_equal expected, @heckler.current_tree
+  end
+  
+  
+  def test_should_randomize_symbol
+    expected = [:defn,
+     :uses_regexes,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, /l33t\ h4x0r/]],
+       [:lasgn, :i, [:lit, /c{2,4}+/]],
+       [:lasgn, :i, [:lit, /123/]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  
+    @heckler.reset_tree
+    
+    expected = [:defn,
+     :uses_regexes,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, /a.*/]],
+       [:lasgn, :i, [:lit, /l33t\ h4x0r/]],
+       [:lasgn, :i, [:lit, /123/]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  
+    @heckler.reset_tree
+  
+    expected = [:defn,
+     :uses_regexes,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, /a.*/]],
+       [:lasgn, :i, [:lit, /c{2,4}+/]],
+       [:lasgn, :i, [:lit, /l33t\ h4x0r/]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+end
+
+class TestHeckleRanges < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_ranges")
+  end
+  
+  def test_default_structure
+    expected = [:defn,
+     :uses_ranges,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 6..100]],
+       [:lasgn, :i, [:lit, -1..9]],
+       [:lasgn, :i, [:lit, 1..4]]]]]
+    assert_equal expected, @heckler.current_tree
+  end
+  
+  def test_should_randomize_symbol
+    expected = [:defn,
+     :uses_ranges,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 5..10]],
+       [:lasgn, :i, [:lit, -1..9]],
+       [:lasgn, :i, [:lit, 1..4]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  
+    @heckler.reset_tree
+    
+    expected = [:defn,
+     :uses_ranges,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 6..100]],
+       [:lasgn, :i, [:lit, 5..10]],
+       [:lasgn, :i, [:lit, 1..4]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  
+    @heckler.reset_tree
+  
+    expected = [:defn,
+     :uses_ranges,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 6..100]],
+       [:lasgn, :i, [:lit, -1..9]],
+       [:lasgn, :i, [:lit, 5..10]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+end
+
+
+class TestHeckleSameLiteral < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_the_same_literal")
+  end
+
+  def teardown
+    @heckler.reset
+  end
+  
+  def test_original_tree
+    expected = [:defn,
+     :uses_the_same_literal,
+     [:fbody, [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 1]],
+       [:lasgn, :i, [:lit, 1]],
+       [:lasgn, :i, [:lit, 1]]]]]]
+    
+    assert_equal expected, @heckler.current_tree
+  end
+  
+  def test_literals_should_flip_one_at_a_time
+    # structure of uses_numeric_literals with first literal +5 (from stubbed rand)
+    expected = [:defn,
+     :uses_the_same_literal,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 6]],
+       [:lasgn, :i, [:lit, 1]],
+       [:lasgn, :i, [:lit, 1]]]]]
+    
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+    
+    @heckler.reset_tree
+        
+    expected = [:defn,
+     :uses_the_same_literal,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 1]],
+       [:lasgn, :i, [:lit, 6]],
+       [:lasgn, :i, [:lit, 1]]]]]
+       
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+    
+    @heckler.reset_tree
+    
+    expected = [:defn,
+     :uses_the_same_literal,
+     [:scope,
+      [:block,
+       [:args],
+       [:lasgn, :i, [:lit, 1]],
+       [:lasgn, :i, [:lit, 1]],
+       [:lasgn, :i, [:lit, 6]]]]]
+       
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+end
+
+module Heckle
+  class Base
+    def rand_string
+      "l33t h4x0r"
     end
   end
 end
 
-puts 'loaded'
+class TestHeckleStrings < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_strings")
+  end
+  
+  def teardown
+    @heckler.reset
+  end
+  
+  def test_default_structure
+    expected = [:defn,
+     :uses_strings,
+     [:scope,
+      [:block,
+       [:args],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "Hello, Robert"]]],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "Hello, Jeff"]]],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "Hi, Frank"]]]]]]
+    assert_equal expected, @heckler.current_tree
+  end
+  
+  def test_should_heckle_string_literals
+    expected = [:defn,
+     :uses_strings,
+     [:scope,
+      [:block,
+       [:args],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "l33t h4x0r"]]],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "Hello, Jeff"]]],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "Hi, Frank"]]]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+    
+    @heckler.reset_tree
+    
+    expected = [:defn,
+     :uses_strings,
+     [:scope,
+      [:block,
+       [:args],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "Hello, Robert"]]],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "l33t h4x0r"]]],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "Hi, Frank"]]]]]]
+    
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+    
+    @heckler.reset_tree
+    
+    expected = [:defn,
+     :uses_strings,
+     [:scope,
+      [:block,
+       [:args],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "Hello, Robert"]]],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "Hello, Jeff"]]],
+       [:call, [:ivar, :@names], :<<, [:array, [:str, "l33t h4x0r"]]]]]]
+    
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+end
+
+class TestHeckleIfs < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_if")
+  end
+  
+  def teardown
+    @heckler.reset
+  end
+  
+  def test_default_structure
+    expected = [:defn,
+     :uses_if,
+     [:scope,
+      [:block,
+       [:args],
+       [:if,
+        [:vcall, :some_func],
+        [:if, [:vcall, :some_other_func], [: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]]]]    
+    
+    @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]]]]]    
+    
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+end
+
+class TestHeckleBooleans < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_boolean")
+  end
+  
+  def teardown
+    @heckler.reset
+  end
+  
+  def test_default_structure
+    expected = [:defn, :uses_boolean, [:scope, [:block, [:args], [:true], [:false]]]]
+    assert_equal expected, @heckler.current_tree
+  end
+  
+  
+  def test_should_flip_true_to_false_and_false_to_true
+    expected = [:defn, :uses_boolean, [:scope, [:block, [:args], [:false], [:false]]]]
+    
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+    
+    @heckler.reset_tree
+    
+    expected = [:defn, :uses_boolean, [:scope, [:block, [:args], [:true], [:true]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+end
+
+class TestHeckleWhile < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_while")
+  end
+  
+  def teardown
+    @heckler.reset
+  end
+  
+  def test_default_structure
+    expected = [:defn,
+     :uses_while,
+     [:scope,
+      [:block,
+       [:args],
+       [:while, [:vcall, :some_func], [:vcall, :some_other_func], 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]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+end
+
+class TestHeckleUntil < Test::Unit::TestCase
+  def setup
+    @heckler = Heckle::Base.new("Heckled", "uses_until")
+  end
+  
+  def teardown
+    @heckler.reset
+  end
+  
+  def test_default_structure
+    expected = [:defn,
+     :uses_until,
+     [:scope,
+      [:block,
+       [:args],
+       [:until, [:vcall, :some_func], [:vcall, :some_other_func], 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]]]]
+    @heckler.process(@heckler.current_tree)
+    assert_equal expected, @heckler.current_tree
+  end
+end