wrong 0.1.0

data/README.markdown

@@ -0,0 +1,56 @@
+## Abstract ##
+
+Wrong provides a general assert method that takes a predicate block.  Assertion failure messages are rich in detail.
+
+Wrong is alpha-quality - I'd very much appreciate feedback and bug reports.
+
+It's an offshoot of predicated.
+[http://github.com/sconover/predicated](http://github.com/sconover/predicated)
+
+Inspired by assert { 2.0 }
+[http://assert2.rubyforge.org/](http://assert2.rubyforge.org/)
+
+## Usage ##
+
+Wrong provides a simple assert method:
+
+	require "wrong"
+	
+	include Wrong::Assert
+	
+	assert{1==1} 
+	 ==> nil
+	
+	assert{2==1}
+	 ==> Wrong::Assert::AssertionFailedError: 2 is not equal to 1
+
+And a companion, 'deny':
+
+	deny{'abc'.include?('bc')}
+	 ==> Wrong::Assert::AssertionFailedError: 'abc' includes 'bc'
+
+There's a convenience method for catching errors:
+
+	assert{ catch_raise{raise "boom!"}.message == "boom!" }
+	 ==> nil
+
+## Adapters ##
+
+Adapters for various test frameworks sit under wrong/adapters.
+TODO
+
+## Message ##
+
+Enhancements for error messages sit under wrong/message.
+TODO
+
+## Etc ##
+
+Tracker project:
+[http://www.pivotaltracker.com/projects/95014](http://www.pivotaltracker.com/projects/95014)
+
+“I think it's wrong that only one company makes the game Monopoly.” -Steven Wright
+
+"And it really doesn't matter if I'm wrong 
+ I'm right where I belong"
+-Fixing a Hole

data/lib/wrong.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "wrong/assert"

data/lib/wrong/adapters/minitest.rb

@@ -0,0 +1,11 @@
+require "wrong/assert"
+
+class MiniTest::Unit::TestCase
+  include Wrong::Assert
+  
+  Wrong::Assert.disable_existing_assert_methods(self)
+  
+  def failure_class
+    MiniTest::Assertion
+  end
+end

data/lib/wrong/adapters/test_unit.rb

@@ -0,0 +1,13 @@
+require "wrong/assert"
+
+class Test::Unit::TestCase
+  
+  
+  include Wrong::Assert
+  
+  Wrong::Assert.disable_existing_assert_methods(self)
+  
+  def failure_class
+    Test::Unit::AssertionFailedError
+  end
+end

data/lib/wrong/assert.rb

@@ -0,0 +1,67 @@
+require "predicated/predicate"
+require "predicated/from/callable_object"
+require "predicated/to/sentence"
+
+#see http://yehudakatz.com/2009/01/18/other-ways-to-wrap-a-method/
+class Module
+  def overridable(&blk)
+    mod = Module.new(&blk)
+    include mod
+  end
+end
+
+module Wrong
+  module Assert
+    
+    class AssertionFailedError < RuntimeError; end
+    
+    def failure_class
+      AssertionFailedError
+    end
+    
+    def assert(&block)
+      unless block.call
+        raise failure_class.new(
+          failure_message(:assert, block, Predicated::Predicate.from_callable_object(block))
+        )
+      end
+    end
+
+
+    def deny(&block)
+      if block.call
+        raise failure_class.new(
+          failure_message(:deny, block, Predicated::Predicate.from_callable_object(block))
+        )
+      end
+    end
+
+    def catch_raise
+      error = nil
+      begin
+        yield
+      rescue Exception, RuntimeError => e
+        error = e
+      end
+      e
+    end
+    
+    overridable do
+      def failure_message(method_sym, block, predicate)
+        method_sym == :deny ? predicate.to_sentence : predicate.to_negative_sentence
+      end
+    end
+    
+    def self.disable_existing_assert_methods(the_class)
+      (the_class.public_instance_methods.
+        select{|m|m =~ /^assert/} - ["assert"]).each do |old_assert_method|
+        the_class.class_eval(%{
+          def #{old_assert_method}(*args)
+            raise "#{old_assert_method} has been disabled.  When you use Wrong, it overrides 'assert', which most test frameworks have defined, and use internally."
+          end
+        })
+      end
+    end  
+    
+  end
+end

data/lib/wrong/message/array_diff.rb

@@ -0,0 +1,87 @@
+require "diff/lcs"
+
+module Wrong
+  module Assert
+    
+    def failure_message(method_sym, block, predicate)
+      message = super
+      
+      if predicate.is_a?(Predicated::Equal) && 
+         predicate.left.is_a?(Enumerable) &&
+         predicate.right.is_a?(Enumerable)
+        
+        
+        
+        diffs = Diff::LCS.sdiff(predicate.left, predicate.right)
+        # left_offset = 0
+        left_arr = []
+        right_arr = []
+        diff_arr = []
+        
+        diffs.each do |diff|
+          left_elem = diff.old_element.nil? ? "nil" : diff.old_element.inspect
+          right_elem = diff.new_element.nil? ? "nil" : diff.new_element.inspect
+          
+          max_length = [left_elem.length, right_elem.length].max
+          left_arr << left_elem.ljust(max_length) unless diff.action == "+"
+          right_arr << right_elem.ljust(max_length) unless diff.action == "-"
+          diff_arr <<  (diff.action == "=" ? " ".ljust(max_length) : "^".ljust(max_length))
+        end
+        
+        
+        left_str, right_str, diff_str = ArrayDiff.compute_and_format(predicate.left, predicate.right)
+
+        message << "\n\narray diff:\n"
+        message << left_str + "\n"
+        message << right_str + "\n"
+        message << diff_str + "\n"
+      end
+      
+      message
+    end
+    
+    module ArrayDiff
+      def self.compute_and_format(left, right)
+        diffs = Diff::LCS.sdiff(left, right)
+        
+        left_arr = []
+        right_arr = []
+        diff_arr = []
+        
+        diffs.each do |diff|
+          left_elem = diff.old_element.nil? ? "nil" : diff.old_element.inspect
+          right_elem = diff.new_element.nil? ? "nil" : diff.new_element.inspect
+          
+          max_length = [left_elem.length, right_elem.length].max
+          left_arr << left_elem.ljust(max_length) unless diff.action == "+"
+          right_arr << right_elem.ljust(max_length) unless diff.action == "-"
+          diff_arr <<  (diff.action == "=" ? " ".ljust(max_length) : "^".ljust(max_length))
+        end
+        
+
+        [format(left_arr), 
+         format(right_arr),
+          " " + diff_arr.join("  ") + " "]
+      end
+      
+      def self.format(thing)
+        str = ""
+        if thing.is_a?(Array)
+          str << "["
+          thing.each_with_index do |item, i|
+            str << format(item)
+            str << ", " unless i == thing.length-1
+          end
+          str << "]"
+        else
+          str << thing
+        end
+        str
+      end
+      
+    end
+      
+    
+    
+  end
+end

data/lib/wrong/message/string_diff.rb

@@ -0,0 +1,44 @@
+require "diff"
+
+module Wrong
+  module Assert
+    
+    def failure_message(method_sym, block, predicate)
+      message = super
+      
+      if predicate.is_a?(Predicated::Equal) && 
+         predicate.left.is_a?(String) &&
+         predicate.right.is_a?(String)
+        
+        problems = predicate.left.diff(predicate.right)
+        max_length = [predicate.left.length, predicate.right.length].max
+        
+        message << "\n\nstring diff:\n"
+        message << StringDiff.string_with_diff(predicate.left, problems, max_length, "-")
+        message << StringDiff.string_with_diff(predicate.right, problems, max_length, "+")
+      end
+      
+      message
+    end
+    
+    module StringDiff
+      def self.string_with_diff(original_str, problems, max_length, sign)
+        str = ""
+        str << original_str.gsub("\n", "\\n").gsub("\t", "\\t").gsub("\r", "\\r") + "\n"
+        str << StringDiff.problems_to_carrot_string(problems, max_length, sign) + "\n"
+        str
+      end
+      
+      def self.problems_to_carrot_string(problems, length, sign)
+        carrot_string = " " * length
+        problems.diffs.first.each do |add_subtract, position, character_code|
+          carrot_string[position] = "^" if sign == add_subtract
+        end
+        carrot_string
+      end
+    end
+      
+    
+    
+  end
+end

data/lib/wrong/message/test_context.rb

@@ -0,0 +1,26 @@
+module Wrong
+  module Assert
+    
+    def failure_message(method_sym, block, predicate)
+      upper_portion = super
+      
+      first_test_line = caller.find{|line|line =~ /(_test.rb|_spec.rb)/}
+      file, failure_line_number = first_test_line.split(":",2)
+    
+      lines = File.readlines(file)
+      line_number = failure_line_number.to_i - 1
+      to_show = []
+      begin
+        line = lines[line_number]
+        to_show.unshift(line)
+        line_number -= 1
+      end while !(line =~ /^\s+(test|it)[ ]+/ || line =~ /^\s+def test_\w+/)
+    
+      to_show[to_show.length-1] = to_show[to_show.length-1].chomp + 
+        "      ASSERTION FAILURE #{file}:#{failure_line_number.to_i}\n"
+      
+      upper_portion + "\n\n" + to_show.join
+    end
+    
+  end
+end

data/lib/wrong/version.rb

@@ -0,0 +1,3 @@
+module Wrong
+  VERSION = "0.1.0" unless defined?(Wrong::VERSION)
+end

data/test/adapters/minitest_test.rb

@@ -0,0 +1,53 @@
+require "test/test_helper"
+
+require "minitest/spec"
+require "minitest/unit"
+
+require "wrong/assert"
+require "wrong/adapters/minitest"
+
+apropos "basic assert features" do
+  
+  apropos "pass/fail basics" do
+    test "disables other assert methods" do
+      test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
+      assert{ catch_raise{test_case_instance.assert_equal(1,1)}.
+               message.include?("has been disabled") }
+    end
+    
+    test "raises minitest assertion failures" do
+      test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
+      assert{ catch_raise{test_case_instance.assert{1==2}}.is_a?(MiniTest::Assertion)}
+    end
+    
+    test "assert and deny are available to minitest tests" do
+      class MyFailingAssertTest <  MiniTest::Unit::TestCase
+        def initialize
+          super("assert test")
+        end
+        
+        def test_fail
+          assert{1==2}
+        end
+      end
+      
+      class MyFailingDenyTest <  MiniTest::Unit::TestCase
+        def initialize
+          super("deny test")
+        end
+        
+        def test_fail
+          deny{1==1}
+        end
+      end
+      
+      msg = catch_raise{MyFailingAssertTest.new.test_fail}.message
+      assert{ "1 is not equal to 2" ==  msg }
+
+      msg = catch_raise{MyFailingDenyTest.new.test_fail}.message
+      assert{ "1 is equal to 1" ==  msg }
+    end
+  
+  end
+  
+end

data/test/adapters/test_unit_test.rb

@@ -0,0 +1,50 @@
+require "test/test_helper"
+
+require "test/unit"
+
+require "wrong/assert"
+require "wrong/adapters/test_unit"
+
+class MyFailingAssertTest <  Test::Unit::TestCase
+  
+  def test_strip_out_other_assert_methods
+    #because they call into assert and we're redfining that method so it's potentially confusing
+    
+    begin
+      Class.new(Test::Unit::TestCase).assert_equal(1, 1)
+    rescue StandardError => e
+      e.message.include?("has been disabled")
+    end
+  end
+  
+  
+  def test_assert_and_deny_are_available_to_test_unit_tests
+    my_failing_assert_test = Class.new(Test::Unit::TestCase)
+    my_failing_assert_test.class_eval do
+      def test_fail
+        assert{1==2}
+      end
+    end
+    
+    my_failing_deny_test = Class.new(Test::Unit::TestCase)
+    my_failing_deny_test.class_eval do
+      def test_fail
+        deny{1==1}
+      end
+    end
+    
+    result = Test::Unit::TestResult.new
+    my_failing_assert_test.new("test_fail").run(result) {|started, name| }
+    #I can do without all the TU Listener business, thank you
+    failures = result.instance_variable_get("@failures".to_sym)
+    assert{ failures.length==1 }
+    assert{ failures.first.long_display.include?("1 is not equal to 2") }
+    
+    result = Test::Unit::TestResult.new
+    failures = result.instance_variable_get("@failures".to_sym)
+    my_failing_deny_test.new("test_fail").run(result) {|started, name| }
+    assert{ failures.length==1 }
+    assert{ failures.first.long_display.include?("1 is equal to 1") }
+  end
+  
+end

data/test/basic_assert_test.rb

@@ -0,0 +1,38 @@
+require "test/test_helper"
+
+require "wrong/assert"
+
+apropos "basic assert features" do
+  
+  before do
+    @m = Module.new do
+      extend Wrong::Assert
+    end
+  end
+  
+  apropos "pass/fail basics" do
+    test "passes when the result is true.  deny does the reverse" do
+      @m.assert{true}
+      @m.assert{1==1}
+
+      @m.deny{false}
+      @m.deny{1==2}
+    end
+  
+    test "fails when result is false.  deny does the reverse" do
+      get_error{@m.assert{false}} || fail
+      get_error{@m.assert{1==2}} || fail
+      
+      get_error{@m.deny{true}} || fail
+      get_error{@m.deny{1==1}} || fail
+    end
+  
+    class MyError < StandardError; end
+  
+    test "both deny and assert fail when an error is thrown.  bubbles up the error." do
+      assert_raises(MyError) { @m.assert{ raise MyError.new } }
+      assert_raises(MyError) { @m.deny{ raise MyError.new } }
+    end
+  end
+  
+end

data/test/catch_raise_test.rb

@@ -0,0 +1,16 @@
+require "test/test_helper"
+
+require "wrong/assert"
+require "wrong/adapters/minitest"
+
+apropos "a tool for rescuing errors" do
+  
+  class RedError < StandardError; end
+  class BlueError < StandardError; end
+  
+  test "catch the error and assert on it" do
+    assert{ catch_raise{raise RedError.new}.is_a?(RedError) }
+    assert{ catch_raise{"x"}.nil? }
+  end
+  
+end

data/test/failures_test.rb

@@ -0,0 +1,113 @@
+require "test/test_helper"
+
+require "wrong/assert"
+
+apropos "failures" do
+  
+  before do
+    @m = Module.new do
+      extend Wrong::Assert
+    end
+  end
+  
+  apropos "simple" do
+    test "raw boolean failure" do
+      assert_match "false", get_error{@m.assert{false}}.message
+      assert_match "true", get_error{@m.deny{true}}.message
+    end
+  
+    test "equality failure" do
+      assert_match "1 is not equal to 2", get_error{@m.assert{1==2}}.message
+      assert_match "1 is equal to 1", get_error{@m.deny{1==1}}.message
+    end
+  
+    test "failure of basic operations" do
+      assert_match "1 is not greater than 2", get_error{@m.assert{1>2}}.message
+      assert_match "2 is not less than 1", get_error{@m.assert{2<1}}.message
+      assert_match "1 is not greater than or equal to 2", get_error{@m.assert{1>=2}}.message
+      assert_match "2 is not less than or equal to 1", get_error{@m.assert{2<=1}}.message
+
+      assert_match "2 is greater than 1", get_error{@m.deny{2>1}}.message
+      assert_match "1 is less than 2", get_error{@m.deny{1<2}}.message
+      assert_match "2 is greater than or equal to 1", get_error{@m.deny{2>=1}}.message
+      assert_match "1 is less than or equal to 2", get_error{@m.deny{1<=2}}.message
+    end
+    
+    class Color
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+    
+      def ==(other)
+        other.is_a?(Color) && @name == other.name
+      end
+      
+      def inspect
+        "Color:#{@name}"
+      end
+    end
+    
+    test "object failure" do
+      assert_match "'Color:red' is not equal to 2", get_error{@m.assert{Color.new("red")==2}}.message
+    end
+    
+    test %{multiline assert block shouldn't look any different 
+           than when there everything is on one line} do
+      assert_match("1 is not equal to 2", get_error{@m.assert{
+        1==
+        2
+      }}.message)
+    end
+
+  end
+  
+  apropos "accessing and printing values set outside of the assert" do
+    test "use a value in the assert defined outside of it" do
+      a = 1
+      assert_match "1 is not equal to 2", get_error{@m.assert{a==2}}.message
+      assert_match "1 is equal to 1", get_error{@m.deny{a==1}}.message
+    end
+  end
+  
+  apropos "the assert block has many statements" do
+    test "only pay attention to the final statement" do
+      assert_match("1 is not equal to 2", get_error{@m.assert{
+        a = "aaa"
+        b = 1 + 2
+        c = ["foo", "bar"].length / 3
+        if a=="aaa"
+          b = 4
+        end; 1==2
+      }}.message)
+    end
+
+    test "works even if the assertion is based on stuff set previously in the block" do
+      assert_match("'aaa' is not equal to 'bbb'", get_error{@m.assert{
+        a = "aaa"
+        a=="bbb"
+      }}.message)
+    end
+  end
+  
+  apropos "array comparisons" do
+    test "basic" do
+      assert_match %{'[1, 2]' is not equal to '["a", "b"]'}, get_error{@m.assert{[1,2]==%w{a b}}}.message
+    end
+  end
+  
+  apropos "hash comparisons" do
+    test "basic" do
+      assert_match %{'{1=>2}' is not equal to '{"a"=>"b"}'},
+       get_error{@m.assert{{1=>2}=={"a"=>"b"}}}.message
+    end
+  end
+  
+  apropos "methods that result in a boolean.  this might be hard." do
+    test "string include" do
+      assert_match "'abc' does not include 'cd'", get_error{@m.assert{"abc".include?("cd")}}.message
+      assert_match "'abc' includes 'bc'", get_error{@m.deny{"abc".include?("bc")}}.message
+    end
+  end
+
+end

data/test/message/array_diff_test.rb

@@ -0,0 +1,59 @@
+require "test/test_helper"
+require "wrong/assert"
+require "wrong/message/array_diff"
+require "wrong/adapters/minitest"
+
+apropos "when you're comparing strings and they don't match, show me the diff message" do
+  
+  def assert_string_diff_message(block, str)
+    assert{catch_raise{assert(&block)}.message.include?(str)}
+  end
+  
+  test "don't attempt to do this if the assertion is not of the form a_array==b_array" do
+    deny{catch_raise{assert{[1]==2}}.message.include?("diff")}
+    deny{catch_raise{assert{nil==[1]}}.message.include?("diff")}
+  end
+
+  test "simple" do
+    assert{catch_raise{assert{["a"]==["b"]}}.message.include?("diff")}
+    
+    assert_string_diff_message(proc{["a", "b"]==["a", "c", "c"]}, %{
+["a", "b"]
+["a", "c", "c"]
+      ^    ^   
+})
+  end
+  
+  test "elements align properly" do
+    assert_string_diff_message(proc{["a", "b", "c"]==["a", "cccc", "c"]}, %{
+["a", "b"   , "c"]
+["a", "cccc", "c"]
+      ^           
+})
+
+    assert_string_diff_message(proc{["a", "b", "c", "d"]==["a", "cccc", "xxx", "d"]}, %{
+["a", "b"   , "c"  , "d"]
+["a", "cccc", "xxx", "d"]
+      ^       ^          
+})
+  end
+
+  test "different primitive types" do
+    assert_string_diff_message(proc{[1, true]==[2, true, nil]}, %{
+[1, true]
+[2, true, nil]
+ ^        ^   
+})
+  end
+
+  test "2d array - just inspects the inner array like it would any other element" do
+    assert{[1, [2, 3]]==[1, [2, 3]]}
+    assert_string_diff_message(proc{[1, [2]]==[1, [2, 3]]}, %{
+[1, [2]   ]
+[1, [2, 3]]
+    ^      
+})
+
+  end
+  
+end

data/test/message/string_diff_test.rb

@@ -0,0 +1,65 @@
+require "test/test_helper"
+require "wrong/assert"
+require "wrong/message/string_diff"
+require "wrong/adapters/minitest"
+
+apropos "when you're comparing strings and they don't match, show me the diff message" do
+  
+  def assert_string_diff_message(block, str)
+    assert{catch_raise{assert(&block)}.message.include?(str)}
+  end
+  
+  test "don't attempt to do this if the assertion is not of the form a_string==b_string" do
+    deny{catch_raise{assert{1==2}}.message.include?("diff")}
+    deny{catch_raise{assert{"a"==2}}.message.include?("diff")}
+    deny{catch_raise{assert{1=="a"}}.message.include?("diff")}
+    deny{catch_raise{assert{nil=="a"}}.message.include?("diff")}
+  end
+
+  test "simple" do
+    assert{catch_raise{assert{"a"=="b"}}.message.include?("diff")}
+    
+    assert_string_diff_message(proc{"ab"=="acc"}, %{
+ab
+ ^ 
+acc
+ ^^
+})
+  end
+
+  test "whitespace" do
+    assert_string_diff_message(proc{"a\nb"=="a\ncc"}, %{
+a\\nb
+  ^ 
+a\\ncc
+  ^^
+})
+
+    assert_string_diff_message(proc{"a\tb"=="a\tcc"}, %{
+a\\tb
+  ^ 
+a\\tcc
+  ^^
+})
+    assert_string_diff_message(proc{"a\rb"=="a\rcc"}, %{
+a\\rb
+  ^ 
+a\\rcc
+  ^^
+})
+
+  end
+
+  xtest "elides really long matching sections" do
+    left = "x"*100 + "ab" + "y"*100 + "AB" + "z"*100 
+    right = "x"*100 + "acc" + "y"*100 + "ACC" + "z"*100 
+    
+    assert_string_diff_message(proc{"ab"=="acc"}, %{
+...xxabyyy....yyABzzz....
+      ^          ^       
+...xxaccyyy...yyACCzzz...
+      ^^         ^^     
+})
+  end
+  
+end

data/test/message/test_context_text.rb

@@ -0,0 +1,68 @@
+require "test/test_helper"
+require "wrong/assert"
+require "wrong/message/test_context"
+
+apropos "test failures" do
+
+  include Wrong::Assert
+  
+  test "you can see test method all the way back to the start of the test, plus an indication of where the failure was" do
+    a = 1
+    b = 2
+    c = 1
+    assert{ a == c }
+    begin
+      assert{ a == b }
+    rescue Wrong::Assert::AssertionFailedError => e
+      assert do
+        e.message.include?(
+%{  test "you can see test method all the way back to the start of the test, plus an indication of where the failure was" do
+    a = 1
+    b = 2
+    c = 1
+    assert{ a == c }
+    begin
+      assert{ a == b }      ASSERTION FAILURE test/include_test_context_test.rb:15}
+        )
+      end
+      
+      deny {e.message.include?("works with it too")}
+      deny {e.message.include?("test_works_with_test_undercore")}
+    end
+  end
+  
+  it "works with it too" do
+    begin
+      assert{ 1 == 2 }
+    rescue Wrong::Assert::AssertionFailedError => e
+      assert do
+        e.message.include?(
+%{  it "works with it too" do
+    begin
+      assert{ 1 == 2 }      ASSERTION FAILURE test/include_test_context_test.rb:36}
+        )
+      end
+      
+      deny {e.message.include?("you can see test method")}
+      deny {e.message.include?("test_works_with_test_undercore")}
+    end
+  end
+  
+  def test_works_with_test_undercore_too
+    begin
+      assert{ 1 == 2 }
+    rescue Wrong::Assert::AssertionFailedError => e
+      assert do
+        e.message.include?(
+%{  def test_works_with_test_undercore_too
+    begin
+      assert{ 1 == 2 }      ASSERTION FAILURE test/include_test_context_test.rb:53}
+        )
+      end
+      
+      deny {e.message.include?("you can see test method")}
+      deny {e.message.include?("works with it too")}
+    end
+  end
+  
+end

data/test/suite.rb

@@ -0,0 +1,4 @@
+#simple way to make sure requires are isolated
+result = Dir["test/**/*_test.rb"].collect{|test_file| system("ruby #{test_file}") }.uniq == [true]
+puts "suite " + (result ? "passed" : "FAILED")
+exit(result ? 0 : 1)

data/test/test_helper.rb

@@ -0,0 +1,44 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{dir}/../lib"
+$LOAD_PATH.unshift "../predicated/lib"
+require "rubygems"
+require "minitest/spec"
+require "minitest/unit"
+require "pp"
+
+def get_error
+  error = nil
+  begin
+    yield
+  rescue Exception, RuntimeError => e
+    error = e
+  end
+  e
+end
+
+class MiniTest::Unit::TestCase
+  
+end
+
+module Kernel
+  alias_method :apropos, :describe
+  
+  def xapropos(str)
+    puts "x'd out 'apropos \"#{str}\"'"
+  end
+end
+
+class MiniTest::Spec
+  include MiniTest::Assertions
+  
+  class << self
+    alias_method :test, :it
+    
+    def xtest(str)
+      puts "x'd out 'test \"#{str}\"'"
+    end
+
+  end
+end
+
+MiniTest::Unit.autorun

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification 
+name: wrong
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Steve Conover
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-06 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: predicated
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 3
+        - 0
+        - 5
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby_parser
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 2
+        - 4
+        version: 1.2.4
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: diff
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 3
+        - 6
+        version: 0.3.6
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: diff-lcs
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 1
+        - 2
+        version: 1.1.2
+  type: :runtime
+  version_requirements: *id006
+description: Wrong provides a general assert method that takes a predicate block.  Assertion failure messages are rich in detail.
+email: sconover@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- lib/wrong/adapters/minitest.rb
+- lib/wrong/adapters/test_unit.rb
+- lib/wrong/assert.rb
+- lib/wrong/message/array_diff.rb
+- lib/wrong/message/string_diff.rb
+- lib/wrong/message/test_context.rb
+- lib/wrong/version.rb
+- lib/wrong.rb
+- README.markdown
+- test/adapters/minitest_test.rb
+- test/adapters/test_unit_test.rb
+- test/basic_assert_test.rb
+- test/catch_raise_test.rb
+- test/failures_test.rb
+- test/message/array_diff_test.rb
+- test/message/string_diff_test.rb
+- test/message/test_context_text.rb
+- test/suite.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/sconover/wrong
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: wrong
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Wrong provides a general assert method that takes a predicate block.  Assertion failure messages are rich in detail.
+test_files: 
+- test/adapters/minitest_test.rb
+- test/adapters/test_unit_test.rb
+- test/basic_assert_test.rb
+- test/catch_raise_test.rb
+- test/failures_test.rb
+- test/message/array_diff_test.rb
+- test/message/string_diff_test.rb
+- test/message/test_context_text.rb
+- test/suite.rb
+- test/test_helper.rb