quality_extensions 0.1.1

data/lib/qualitysmith_extensions/template.rb

@@ -0,0 +1,33 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# Changes::
+#++
+
+
+
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+  end
+
+end
+=end
+

data/lib/qualitysmith_extensions/test/all.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + "/../kernel/require_all"
+require_all File.dirname(__FILE__), :exclude_files => 'all.rb'

data/lib/qualitysmith_extensions/test/assert_anything.rb

@@ -0,0 +1,93 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+
+class Test::Unit::TestCase
+  # Lets you make an assertion out of any method, without having to write a new assert_ method for it!
+  #
+  # So as long as the +whatever+ method's return value can be interpreted as a boolean value, you can simply call
+  # <tt>assert_whatever a, b</tt>, which will be equivalent to calling <tt>assert a.whatever(b)</tt>
+  #
+  # Follow this basic pattern:
+  #   assert_{method} {receiver}, {args}
+  #   assert_not_{method} {receiver}, {args}
+  #   assert_{method}_is      {receiver}, {args}, {expected_return_value}
+  #   assert_{method}_returns {receiver}, {args}, {expected_return_value}
+  #
+  # Examples:
+  #   assert_include? [1, 2, 3], 2
+  #   assert_not_include? [1, 2, 3], 4
+  #   assert_class_is 'foo', String
+  #
+  def method_missing(name, *args)
+    # to do: 
+    #   options = args.pop if args.last.is_a?(Hash)
+    #   message = options[:message]
+    if name.to_s =~ /^assert_(.*)/
+      receiver = args.shift
+      negated = false
+      message_to_pass = $1
+
+      if name.to_s =~ /^assert_(.*)_is/
+        message_to_pass = $1
+        expected = args.pop
+        if name.to_s =~ /^assert_(.*)_is_not/
+          message_to_pass = $1
+          negated = true
+        end
+
+        result = receiver.send(message_to_pass, *args)
+        if negated
+          assert_not_equal expected, result
+        else
+          assert_equal expected, result
+        end
+      else
+        if name.to_s =~ /^assert_not_(.*)|assert_(.*)_is_not/
+          message_to_pass = $1
+          negated = true
+        end
+
+        result = receiver.send(message_to_pass, *args)
+        result = !result if negated
+        assert result
+      end
+
+    else
+      super
+    end
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    assert_include? [1, 2, 3], 2
+    assert_not_include? [1, 2, 3], 4
+  end
+  def test_is
+    assert_class_is 'foo', String
+    assert_class_is_not ['foo'], String
+  end
+
+end
+=end
+
+

data/lib/qualitysmith_extensions/test/assert_changed.rb

@@ -0,0 +1,66 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+#++
+
+require 'test/unit'
+class Test::Unit::TestCase
+
+  # Asserts that the block that is passed in causes the value of the specified variable (+variable+) to change.
+  # +variable+ should be a Proc that, when evaluated, returns the current value of the variable. 
+  #
+  # Options:
+  # * If the optional +:from+ option is supplied, it also asserts that it had that initial value.
+  # * If the optional +:to+ option is supplied, it also asserts that it changed _to_ that value.
+  #
+  # So instead of doing this:
+  #   assert_equal 1, Model.count
+  #   do_something_that_should_cause_count_to_increase
+  #   assert_equal 2, Model.count
+  # we can do this:
+  #   assert_changed(lambda {ErrorType.count}, :from => 1, :to => 2) do
+  #     do_something_that_should_cause_count_to_increase
+  #   end
+  # Or, if we don't care what it's changing _from_ as long as it increases in value _by_ 1, we can write this:
+  #   assert_changed(c = lambda {ErrorType.count}, :to => c.call+1) do
+  #     do_something_that_should_cause_count_to_increase
+  #   end
+  # instead of this:
+  #   before = Model.count
+  #   do_something_that_should_cause_count_to_increase
+  #   assert_equal before + 1, Model.count
+  #
+  def assert_changed(variable, options = {}, &block)
+    expected_from = options.delete(:from) || variable.call
+
+    assert_equal expected_from, variable.call
+
+    failure_message = build_message(failure_message, "The variable was expected to change from <?> to <?> but it didn't", variable.call, options.delete(:to) || "something else")
+    assert_block(failure_message) do
+      before = variable.call
+      yield
+      expected_to = options.delete(:to) || variable.call
+      before != variable.call and variable.call == expected_to
+    end
+  end
+
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+  end
+end
+=end
+
+

data/lib/qualitysmith_extensions/test/assert_exception.rb

@@ -0,0 +1,66 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+#++
+
+require 'test/unit'
+class Test::Unit::TestCase
+
+  # Used when you want to make assertions *about* an assertion that you expect to be raised. (With the built-in assert_raise()
+  # you can only assert *that* a particular class of exception is raised, not any specifics about it.
+  #
+  # Before:
+  #
+  #    exception = nil
+  #    assert_raises(ArgumentError) { SomeCommand.execute("foo '''") }
+  #    begin
+  #      SomeCommand.execute("foo -m '''")
+  #    rescue Exception => _exception
+  #      exception = _exception
+  #    end
+  #    assert_equal "Unmatched single quote: '", exception.message
+  #
+  # After:
+  #
+  #    assert_exception(ArgumentError, lambda { |exception|
+  #      assert_match /Unmatched single quote/, exception.message
+  #    }) do
+  #      SomeCommand.execute("foo -m 'stuff''")
+  #    end
+  #
+  def assert_exception(expected_class, additional_expectations = nil, &block)
+    exception = nil
+    assert_raise(expected_class) do
+      begin
+        yield
+      rescue Exception => _exception
+        exception = _exception
+        raise
+      end
+    end
+    additional_expectations.call(exception) if additional_expectations
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    assert_exception(RuntimeError, lambda { |exception|
+      assert_match /est/, exception.message
+    }) do
+      raise "Test"
+    end
+  end
+end
+=end
+

data/lib/qualitysmith_extensions/test/assert_includes.rb

@@ -0,0 +1,36 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+#++
+
+require 'test/unit'
+class Test::Unit::TestCase
+  def assert_includes(container, expected_contents, failure_message = nil)
+    failure_message = build_message(failure_message, "Container <?> was expected to contain <?> but it didn't", container, expected_contents)
+    assert_block(failure_message) do
+      container.include?(expected_contents)
+    end
+  end
+  alias_method :assert_contains, :assert_includes
+
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+  end
+end
+=end
+
+
+

data/lib/qualitysmith_extensions/test/assert_user_error.rb

@@ -0,0 +1,37 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: No
+# Context::   Rails
+#++
+
+require 'test/unit'
+class Test::Unit::TestCase
+  def assert_user_error(error_message)
+    assert_tag({
+      :attributes => { :id => "errorExplanation" },
+      :descendant => { 
+        :content => error_message
+      }
+    })
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+  end
+end
+=end
+
+
+

data/lib/qualitysmith_extensions/test/difference_highlighting.rb

@@ -0,0 +1,323 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+#++
+# This file adds a bit of color to your failed string comparisons (assert_equal).
+# Differences will be highlighted for you in color so that you can instantly find them.
+
+require 'rubygems'
+gem 'colored'
+require 'colored'
+gem 'facets'
+require 'facets/core/module/alias_method_chain'
+gem 'qualitysmith_extensions', '>=0.0.28'
+require 'qualitysmith_extensions/object/send_if'
+require 'qualitysmith_extensions/string/each_char_with_index'
+require 'qualitysmith_extensions/module/bool_attr_accessor'
+require 'qualitysmith_extensions/module/guard_method'
+require 'qualitysmith_extensions/colored/toggleability'
+
+require 'test/unit'
+
+class String
+  # For all of the next 3 methods, we will underline spaces so that they are actually visible on the screen.
+  # Newlines will be replaced with '\n'"\n".
+
+  # This is a (sub)string that is common to both expected and actual
+  def highlight_commonality
+    self.
+      make_control_characters_visible.
+      make_spaces_visible(:green).
+      green.bold
+      #send_unless(self == ' ', :bold)     # spaces are not bold; '_'s (and everything else) are
+  end
+  # This is a (sub)string that is different between expected and actual
+  def highlight_difference
+    self.
+      make_control_characters_visible.
+      make_spaces_visible(:red).
+      red.bold
+      #send_unless(self == ' ', :bold)     # spaces are not bold; '_'s (and everything else) are
+  end
+  # This is a (sub)string that exists only in *self*, not in the other string
+  def highlight_unique
+    self.
+      make_control_characters_visible.
+      make_spaces_visible(:magenta).
+      magenta
+  end
+  # This is a (sub)string that doesn't exist in self, only in the *other* string. It's just a placeholder character (a space) that represents a *missing* character.
+  def highlight_absence
+    self.white.on_cyan.bold
+  end
+  def make_spaces_visible(color)
+    #:todo: Make this optional? Might be useful if you are comparing things with lots of spaces and underscores and you want to be able to tell the difference between them...?
+    self.gsub(' ', ' '.send(:"on_#{color}"))
+  end
+  def make_control_characters_visible 
+    self.gsub(/\n/, '\n'+"\n").   # Show '\n' in addition to actually doing the line break
+         gsub(/\r/, '\r').        # Just escape it...
+         gsub(/\t/, '\t')
+    #:todo: Add other control characters?
+  end
+end
+
+module Test
+  module Unit
+    module Assertions
+
+      class AssertionMessage
+        @@inspect_strings = false
+        mguard_method :inspect_strings!, :@@inspect_strings
+
+        # The problem with the original convert() is that it always called #inspect on strings... which is fine if you really
+        # want to see all those \n's and such. But not so great if you want to visually compare the strings. And if you have
+        # ANSI color codes in the strings, it will escape those so that you see the codes (\e[33m1) rather than the nice
+        # colored strings that you (sometimes) *want* to see...
+        #
+        def convert_with_option_to_not_use_inspect_for_strings(object)
+          if String === object
+            if self.class.inspect_strings?
+              # Use the original method, which used pp or inspect
+              convert_without_option_to_not_use_inspect_for_strings(object)
+            else
+              object
+            end
+          else
+            # We only care about strings. Everything else can just keep happening like it was before.
+            convert_without_option_to_not_use_inspect_for_strings(object)
+          end
+        end
+        alias_method_chain :convert, :option_to_not_use_inspect_for_strings
+      end # class AssertionMessage
+
+    end
+  end
+end
+
+module Test
+  module Unit
+    module Assertions
+      @@use_assert_equal_with_highlight = nil
+      mguard_method :use_assert_equal_with_highlight!, :@@use_assert_equal_with_highlight
+
+      # The built-in behavior for <tt>assert_equal</tt> method is great for comparing small strings, but not so great for long strings.
+      # If both the strings you are dealing with are both 20 paragraphs long, for example, and they differ by only one character,
+      # the task of locating and identifying the one character that is off is akin to finding a (literal) needle in a 
+      # (literal) haystack (not fun!).
+      #
+      # link:include/assert_equal_with_difference_highlighting-wheres_waldo.png
+      #
+      # This replacement/wrapper for <tt>assert_equal</tt> aims to solve all of your string comparison woes (and eventually someday
+      # perhaps arrays and hashes as well), helping you to spot differences very quickly and to have fun doing it.
+      #
+      # Rather than simply showing you the raw (<tt>inspect</tt>ed) +expected+ and +actual+ and expecting you, the poor user, to
+      # painstakingly compare the two and figure out exactly which characters are different by yourself this method will *highlight*
+      # the differences for you, allowing you to spot them an instant or less!!
+      #
+      # link:include/assert_equal_with_difference_highlighting-there_he_is.png
+      #
+      # *Strings*:
+      # * Does a characterwise comparison between the two strings. That is, for each index, it will look at the character at that
+      #   index and decide if it is the same or different than the character at the same location in the other string. There are
+      #   3 1/2 cases:
+      #   * *Common* characters are displayed in _green_,
+      #   * *Different* characters in _red_,
+      #   * Characters that exist <b>in only one string</b> but not the other are displayed in _yellow_
+      #     * A _cyan_ <tt>~</tt> will appear that location in the _other_ string, as a placeholder for the <b>missing character</b>.
+      # *Arrays*:
+      # * [:todo:] 
+      # *Hashes*:
+      # * [:todo:] 
+      #
+      # <b>Disabling/enabling highlighting</b>:
+      #
+      # By default, highlighting is only used when one or both of the strings being compared is long or spans multiple lines. You can override the default with the <tt>:higlight</tt> option:
+      #   assert_equal 'really long string', 'another really long string', :highlight => true
+      # You can turn it on for all assert_equal assertions by calling
+      #   Test::Unit::Assertions::use_assert_equal_with_highlight!
+      # Or you can just turn it on or off for the duration of a block only:
+      #   Test::Unit::Assertions::use_assert_equal_with_highlight! do
+      #     assert_equal 'really long string', 'another really long string'
+      #   end
+      #
+      # *Notes*:
+      # * Spaces are displayed as with a bright colored background so that they are actually visible on the screen (so you can distinguish an empty line from a line with spaces on it, for example).
+      # * Newlines are displayed as the text <tt>\n</tt> followed by the actual newline. Other control characters (<tt>\t</tt>, <tt>\r</tt>) are escaped as well so that you can tell what character it is.
+      #
+      # <b>Difference in method signature</b> from <tt>assert_equal_without_difference_highlighting</tt> (the standard behavior):
+      # * The last argument (+options+) is expected to be a hash rather than message=nil, since I don't see the use in passing in a message if
+      #   the _default_ message can be made useful enough.
+      # * However, for compatibility with existing assert_equal calls, it will check if the 3rd argument is a string and if it is will use it as the failure message.
+      # * If you to pass in a message in combination with other options, use <tt>:message => 'my message'</tt>
+      #
+      # *Advanced*:
+      # * If you want everything to be escaped (so you can see the color _codes_ instead of the color itself, for example), use <tt>:inspect_strings => true</tt>
+      #
+      def assert_equal_with_highlighting(expected, actual, options = {})
+        if options.is_a?(String)
+          message = options 
+          options = {}
+        else
+          message = options.delete(:message) || nil
+        end
+        highlight = options.delete(:highlight)
+
+        Assertions.send_unless(highlight.nil?, :use_assert_equal_with_highlight!, highlight) do
+
+          if String===expected and String===actual and expected!=actual and 
+              (Assertions.use_assert_equal_with_highlight? || [expected.length, actual.length].max > 80 || [expected, actual].any? {|a| a.include?("\n")}) and
+              !(Assertions.use_assert_equal_with_highlight? == false)
+            expected_with_highlighting = ''
+            actual_with_highlighting = ''
+            full_message = nil
+            String.color_on! do
+              longest_string = [expected, actual].max {|a, b| a.length <=> b.length}
+              longest_string.each_char_with_index do |i, exp|
+                exp = expected[i] ? expected[i].chr : nil
+                act = actual[i]   ? actual[i].chr   : nil
+                if act.nil?
+                  expected_with_highlighting << exp.highlight_unique
+                  actual_with_highlighting   << '~'.highlight_absence
+                elsif exp.nil?
+                  expected_with_highlighting << '~'.highlight_absence
+                  actual_with_highlighting   << act.highlight_unique
+                elsif exp != act
+                  expected_with_highlighting << exp.highlight_difference
+                  actual_with_highlighting   << act.highlight_difference
+                else
+                  expected_with_highlighting << exp.highlight_commonality
+                  actual_with_highlighting   << exp.highlight_commonality
+                end
+
+              end
+              full_message = build_message(message, <<End, expected_with_highlighting, actual_with_highlighting)
+#{(' '*50 + ' Expected: ' + ' '*50).blue.underline.on_white }
+?
+#{(' '*50 + ' But was:  ' + ' '*50).yellow.underline.on_red }
+?
+End
+            end
+              AssertionMessage.inspect_strings!(options.delete(:inspect_strings) || false) do
+                assert_block(full_message) { expected == actual }
+              end
+          else
+            assert_equal_without_highlighting(expected, actual, message)
+          end
+
+        end # use_assert_equal_with_highlight!
+
+      end # def assert_equal_with_highlighting
+      alias_method_chain :assert_equal, :highlighting
+
+    end
+  end
+end
+
+
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+#Test::Unit::Assertions::use_assert_equal_with_highlight!
+
+# :todo: Currently these (intentionally failing) tests are just manual and require visual inspection. If possible it would be 
+# nice to capture the output of the failure and make an assertion against that. But I'm not sure how to do that...
+
+class TheTest < Test::Unit::TestCase
+  def test01_single_character_differences
+    assert_equal <<End, <<End
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed feugiat mi. In sagittis, augue non eleifend sodales, arcu urna congue sapien, aliquet molestie pede urna sit amet dolor. Etiam diam. Vestibulum ornare, felis et porta faucibus, magna sapien vulputate arcu, vel facilisis lectus ipsum et ipsum.
+
+Vivamus massa odio, lacinia eu, euismod vitae, lobortis eu, erat. Duis tincidunt, neque ac_tincidunt convallis, nibh tellus sodales eros, ut tristique nunc purus in urna. Nullam semper. Fusce quis augue ut metus interdum congue. Duis id dolor eu mi pellentesque sagittis. Quisque imperdiet orci a odio.
+End
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed feugiat mi. In sagittis, augue non eleifend sodales, arcu urna congue sapien, aliquet molestie pede urna sit amet dolor. Etiam diam. Vestibulum ornare, felis et porta faucibus, magna sapien vulputate arcu, vel facilisis lectus ipsum et ipsum.
+
+Vivamus massa odio, lacinia eu, euismod vitae, lobortis eu, erat. Duis tincidunt, neque ac tincidunt convallis, nibh tellus sodales eros, ut tristique nunc purus in urna. Nullam semper. Fusce quis augue ut metus interdum congue. Duis id color eu mi pellentesque sagittis. Quisque imperdiet orci a odio.
+End
+  end
+
+  def test02_difference_in_control_characters
+    assert_equal "Lorem ipsum dolor sit amet,\nconsectetuer adipiscing elit.\nSed feugiat mi.",
+                 "Lorem ipsum_dolor sit amet, consectetuer\tadipiscing elit.\n\rSed feugiat mi.", :highlight => true
+  end
+
+  def test03_expected_is_longer
+    assert_equal '1234567890', '123', :highlight => true
+  end
+
+  def test04_actual_is_longer
+    assert_equal '123', '1234567890', :highlight => true
+  end
+
+  # Use the ones above this line as screenshot material...
+
+  def test05_one_is_much_longer
+    assert_equal <<End, <<End
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed feugiat mi. In sagittis, augue non eleifend sodales, arcu urna congue sapien, aliquet molestie pede urna sit amet dolor. Etiam diam. Vestibulum ornare, felis et porta faucibus, magna sapien vulputate arcu, vel facilisis lectus ipsum et ipsum. Sed dictum, dolor suscipit malesuada pharetra, orci augue lobortis lectus, porta porta magna magna ut dui. Duis viverra enim sed felis. Mauris semper volutpat pede. Integer lectus lorem, lacinia in, iaculis ut, euismod non, nulla. Nunc non libero eget diam congue ornare. Nunc dictum tellus sed turpis. Sed venenatis, pede non ultricies pharetra, dolor felis malesuada nisl, id imperdiet lorem dui vel velit.
+End
+Lorem ipsum dolor sit amet
+End
+  end
+
+  def test06_only_minor_single_character_differences_but_then_it_gets_out_of_sync
+    assert_equal <<End, <<End
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed feugiat mi. In sagittis, augue non eleifend sodales, arcu urna congue sapien.
+
+Vivamus massa odio, lacinia eu, euismod vitae, lobortis eu, erat. Duis tincidunt, neque ac tincidunt convallis, nibh tellus sodales eros, ut tristique nunc purus in urna. Nullam semper. Fusce quis augue ut metus interdum congue. Duis id dolor eu mi pellentesque sagittis. Quisque imperdiet orci a odio.
+End
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed feugiat mi. In sagittis, argue non eleifend sodales, arcu urna conque sapien.
+
+Vivamus massa odio, lacinia eu, euismod vitae, lobortis eu, erat. Duis tincidunt, neque ac tincidunt convallis, nibh tellus sodales eros, ut tristique nunc purus in urna. Nullam semper. Fusce quis augue ut metus interdum congue. Duis id dolor eu mi pellentesque sagittis. Quisque imperdiet orci a odio.
+End
+  end
+
+  def test07_underscores_versus_underlines
+    assert_equal <<End, <<End
+___[Underscores]___[Underscores]   [Spaces] _ _ _ _ _ [Mix]
+End
+   [Spaces]     ___[Underscores]   [Spaces] _ _ __ _ _[Mix]     
+End
+  end
+
+  def test08_inspect_strings_true
+    assert_equal '1234567890', '123', :inspect_strings => true
+  end
+  def test09_inspect_highlight_false
+    assert_equal '1234567890', '123', :highlight => false
+  end
+  def test10_highlight_false
+    Test::Unit::Assertions::use_assert_equal_with_highlight! false do
+      assert_equal 'really long string', 'another really long string'
+    end
+  end
+  def test11_highlight_true
+    Test::Unit::Assertions::use_assert_equal_with_highlight! do
+      assert_equal 'really long string', 'another really long string'
+    end
+  end
+  def test12_compatibility__using_arg3_as_message
+    assert_equal 'really long string', 'another really long string', 'This is my message! Can you see it?'
+  end
+  def test13_that_assert_nil_still_works
+    # Exposed a bug that existed previously, where it tried to do "".delete(:message)
+    assert_nil nil
+  end
+
+end
+=end
+
+