test-unit 2.4.4 → 2.4.5

data/lib/test/unit/assertions.rb

@@ -86,7 +86,7 @@ module Test
       end
 
       ##
-      # Passes if +expected+ == +actual.
+      # Passes if +expected+ == +actual+.
       #
       # Note that the ordering of arguments is important, since a helpful
       # error message is generated when this one fails that tells you the
@@ -118,11 +118,7 @@ EOT
         begin
           assert_block(full_message) { expected == actual }
         rescue AssertionFailedError => failure
-          failure.expected = expected
-          failure.actual = actual
-          failure.inspected_expected = AssertionMessage.convert(expected)
-          failure.inspected_actual = AssertionMessage.convert(actual)
-          failure.user_message = message
+          _set_failed_information(failure, expected, actual, message)
           raise failure # For JRuby. :<
         end
       end
@@ -149,11 +145,19 @@ EOT
         assert_expected_exception = Proc.new do |*_args|
           message, assert_exception_helper, actual_exception = _args
           expected = assert_exception_helper.expected_exceptions
+          diff = AssertionMessage.delayed_diff(expected, actual_exception)
           full_message = build_message(message,
-                                       "<?> exception expected but was\n?",
-                                       expected, actual_exception)
-          assert_block(full_message) do
-            expected == [] or assert_exception_helper.expected?(actual_exception)
+                                       "<?> exception expected but was\n<?>.?",
+                                       expected, actual_exception, diff)
+          begin
+            assert_block(full_message) do
+              expected == [] or
+                assert_exception_helper.expected?(actual_exception)
+            end
+          rescue AssertionFailedError => failure
+            _set_failed_information(failure, expected, actual_exception,
+                                    message)
+            raise failure # For JRuby. :<
           end
         end
         _assert_raise(assert_expected_exception, *args, &block)
@@ -183,7 +187,7 @@ EOT
           expected = assert_exception_helper.expected_exceptions
           full_message = build_message(message,
                                        "<?> family exception expected " +
-                                       "but was\n?",
+                                       "but was\n<?>.",
                                        expected, actual_exception)
           assert_block(full_message) do
             assert_exception_helper.expected?(actual_exception, :kind_of?)
@@ -1423,6 +1427,15 @@ EOT
         end
       end
 
+      private
+      def _set_failed_information(failure, expected, actual, user_message)
+        failure.expected = expected
+        failure.actual = actual
+        failure.inspected_expected = AssertionMessage.convert(expected)
+        failure.inspected_actual = AssertionMessage.convert(actual)
+        failure.user_message = user_message
+      end
+
       class AssertionMessage
         @use_pp = true
         class << self
@@ -1515,30 +1528,22 @@ EOT
           end
 
           def convert(object)
-            case object
-            when Exception
-              <<EOM.chop
-Class: <#{convert(object.class)}>
-Message: <#{convert(object.message)}>
----Backtrace---
-#{Util::BacktraceFilter.filter_backtrace(object.backtrace).join("\n")}
----------------
-EOM
-            else
-              inspector = Inspector.new(object)
-              if use_pp
+            if object.is_a?(Exception)
+              object = AssertExceptionHelper::WrappedException.new(object)
+            end
+            inspector = Inspector.new(object)
+            if use_pp
+              begin
+                require 'pp' unless defined?(PP)
                 begin
-                  require 'pp' unless defined?(PP)
-                  begin
-                    return PP.pp(inspector, '').chomp
-                  rescue NameError
-                  end
-                rescue LoadError
-                  self.use_pp = false
+                  return PP.pp(inspector, '').chomp
+                rescue NameError
                 end
+              rescue LoadError
+                self.use_pp = false
               end
-              inspector.inspect
             end
+            inspector.inspect
           end
         end
 
@@ -1550,6 +1555,19 @@ EOM
               inspected_objects[object.object_id] ||=
                 new(object, inspected_objects)
             end
+
+            @@inspector_classes = []
+            def inspector_classes
+              @@inspector_classes
+            end
+
+            def register_inspector_class(inspector_class)
+              @@inspector_classes << inspector_class
+            end
+
+            def unregister_inspector_class(inspector_class)
+              @@inspector_classes.delete(inspector_class)
+            end
           end
 
           attr_reader :object
@@ -1583,17 +1601,18 @@ EOM
 
           private
           def inspect_target
-            if HashInspector.target?(@object)
-              HashInspector.new(@object, @inspected_objects)
-            elsif ArrayInspector.target?(@object)
-              ArrayInspector.new(@object, @inspected_objects)
-            else
-              @object
+            self.class.inspector_classes.each do |inspector_class|
+              if inspector_class.target?(@object)
+                return inspector_class.new(@object, @inspected_objects)
+              end
             end
+            @object
           end
         end
 
         class HashInspector
+          Inspector.register_inspector_class(self)
+
           class << self
             def target?(object)
               object.is_a?(Hash) or object == ENV
@@ -1646,6 +1665,8 @@ EOM
         end
 
         class ArrayInspector
+          Inspector.register_inspector_class(self)
+
           class << self
             def target?(object)
               object.is_a?(Array)
@@ -1761,7 +1782,7 @@ EOM
         def to_s
           message_parts = []
           if (@head)
-            head = @head.to_s 
+            head = @head.to_s
             unless(head.empty?)
               message_parts << add_period(head)
             end
@@ -1774,13 +1795,14 @@ EOM
 
       class AssertExceptionHelper
         class WrappedException
+          attr_reader :exception
           def initialize(exception)
             @exception = exception
           end
 
           def inspect
             if default_inspect?
-              "#{@exception.class.inspect}(#{@exception.message.inspect})"
+              "#{@exception.class.inspect}(<#{@exception.message}>)"
             else
               @exception.inspect
             end

data/lib/test/unit/version.rb

@@ -1,5 +1,5 @@
 module Test
   module Unit
-    VERSION = '2.4.4'
+    VERSION = '2.4.5'
   end
 end

data/test/test-assertions.rb

@@ -10,18 +10,16 @@ require 'test/unit'
 module Test
   module Unit
     module AssertionCheckable
-      backtrace_pre  = "---Backtrace---"
-      backtrace_post = "---------------"
-      BACKTRACE_RE = /#{backtrace_pre}\n.+\n#{backtrace_post}/m
-
       private
       def check(value, message="")
         add_assertion
         raise AssertionFailedError.new(message) unless value
       end
 
-      def check_assertions(expect_fail, expected_message="",
-                           return_value_expected=false)
+      def check_assertions(expect_fail, options={})
+        expected_message = options[:expected_message]
+        actual_message_normalizer = options[:actual_message_normalizer]
+        return_value_expected = options[:return_value_expected]
         @actual_assertion_count = 0
         failed = true
         actual_message = nil
@@ -48,14 +46,17 @@ module Test
         check(1 == @actual_assertion_count, message)
 
         if expect_fail
+          if actual_message_normalizer
+            actual_message = actual_message_normalizer.call(actual_message)
+          end
           case expected_message
           when String
-            check(actual_message == expected_message,
+            check(expected_message == actual_message,
                   "Should have the correct message.\n" +
                   "<#{expected_message.inspect}> expected but was\n" +
                   "<#{actual_message.inspect}>")
           when Regexp
-            check(actual_message =~ expected_message,
+            check(expected_message =~ actual_message,
                   "The message should match correctly.\n" +
                   "</#{expected_message.source}/> expected to match\n" +
                   "<#{actual_message.inspect}>")
@@ -76,11 +77,26 @@ module Test
       end
 
       def check_nothing_fails(return_value_expected=false, &proc)
-        check_assertions(false, "", return_value_expected, &proc)
+        check_assertions(false,
+                         {:expected_message => nil,
+                          :return_value_expected => return_value_expected},
+                         &proc)
       end
 
-      def check_fails(expected_message="", &proc)
-        check_assertions(true, expected_message, &proc)
+      def check_fail(expected_message, options={}, &proc)
+        check_assertions(true,
+                         options.merge(:expected_message => expected_message),
+                         &proc)
+      end
+
+      def check_fail_exception(expected_message, options={}, &proc)
+        normalizer = lambda do |actual_message|
+          actual_message.gsub(/(^[^:\n]+:\d+:.+\n?)+\z/, "")
+        end
+        check_assertions(true,
+                         options.merge(:expected_message => expected_message,
+                                       :actual_message_normalizer => normalizer),
+                         &proc)
       end
 
       def inspect_tag(tag)
@@ -121,10 +137,10 @@ module Test
         check_nothing_fails {
           assert_block("successful assert_block") {true}
         }
-        check_fails("assert_block failed.") {
+        check_fail("assert_block failed.") {
           assert_block {false}
         }
-        check_fails("failed assert_block") {
+        check_fail("failed assert_block") {
           assert_block("failed assert_block") {false}
         }
       end
@@ -147,7 +163,7 @@ diff:
 + string2
 ?       ^
 EOM
-        check_fails(message) {
+        check_fail(message) {
           assert_equal("string1", "string2")
         }
 
@@ -162,7 +178,7 @@ diff:
 + string2
 ?       ^
 EOM
-        check_fails(message) {
+        check_fail(message) {
           assert_equal("string1", "string2", "failed assert_equal")
         }
 
@@ -175,7 +191,7 @@ diff:
 ? -      -
 + 111111
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal("111111", 111111)
         end
       end
@@ -216,7 +232,7 @@ folded diff:
 ?  ^^^^^^^^^
   898123456789
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal(expected, actual)
         end
       end
@@ -226,7 +242,7 @@ EOM
 <1> expected but was
 <2>.
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal(1, 2)
         end
       end
@@ -238,7 +254,7 @@ EOM
 <#{now.inspect}> expected but was
 <#{now.inspect}>.
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal(now, now_without_usec)
         end
       end
@@ -253,7 +269,7 @@ diff:
 - a
 - b
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal("a\nb", "x")
         end
       end
@@ -274,7 +290,7 @@ folded diff:
 #{(["- " + ("x" * 78)] * 12).join("\n")}
 - #{"x" * 61}
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal("a\n" + "x" * 997, "x")
         end
 
@@ -282,7 +298,7 @@ EOM
 <#{("a\n" + "x" * 998).inspect}> expected but was
 <#{"x".inspect}>.
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal("a\n" + "x" * 998, "x")
         end
       end
@@ -307,7 +323,7 @@ folded diff:
 #{(["- " + ("x" * 78)]).join("\n")}
 - #{"x" * 19}
 EOM
-          check_fails(message) do
+          check_fail(message) do
             assert_equal("a\n" + "x" * 97, "x")
           end
 
@@ -315,7 +331,7 @@ EOM
 <#{("a\n" + "x" * 98).inspect}> expected but was
 <#{"x".inspect}>.
 EOM
-          check_fails(message) do
+          check_fail(message) do
             assert_equal("a\n" + "x" * 98, "x")
           end
         ensure
@@ -333,7 +349,7 @@ EOM
 <#{utf8_string.inspect}>("UTF-8") expected but was
 <#{ascii_8bit_string.inspect}>("ASCII-8BIT").
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal(utf8_string, ascii_8bit_string)
         end
       end
@@ -351,7 +367,7 @@ EOM
 <{"Lisp"=>"John McCarthy", "Ruby"=>"Matz"}> expected but was
 <{"Heavy"=>["C", "C++"], "LL"=>["Ruby", "Python"]}>.
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal(designers, categories)
         end
       end
@@ -371,7 +387,7 @@ diff:
 + {"followers"=>[{"followers"=>[{...}], "name"=>"Alice"}], "name"=>"Bob"}
 ?                                                       +++++++++++++++++
 EOM
-        check_fails(message) do
+        check_fail(message) do
           assert_equal(alice, bob)
         end
       end
@@ -416,19 +432,18 @@ EOM
       end
 
       def test_assert_raise_fail
-        check_fails("<RuntimeError> exception expected but none was thrown.") do
+        check_fail("<RuntimeError> exception expected but none was thrown.") do
           assert_raise(RuntimeError) do
             1 + 1
           end
         end
 
-        message = <<-EOM
+        message = <<-EOM.chomp
 failed assert_raise.
 <ArgumentError> exception expected but was
-Class: <RuntimeError>
-Message: <"Error">
+<RuntimeError(<Error>)>.
 EOM
-        check_fails(/\A#{message}#{BACKTRACE_RE}\Z/m) do
+        check_fail_exception(message) do
           assert_raise(ArgumentError, "failed assert_raise") do
             raise "Error"
           end
@@ -438,7 +453,7 @@ EOM
 Should expect a class of exception, Object.
 <false> is not true.
 EOM
-        check_fails(message.chomp) do
+        check_fail(message.chomp) do
           assert_nothing_raised(Object) do
             1 + 1
           end
@@ -478,21 +493,19 @@ EOM
                 "from a successful assert_raise")
         end
 
-        check_fails("<[ArgumentError, TypeError, Math, Comparable]> exception " +
+        check_fail("<[ArgumentError, TypeError, Math, Comparable]> exception " +
                     "expected but none was thrown.") do
           assert_raise(*rescues) do
             1 + 1
           end
         end
 
-        message = <<-EOM
+        message = <<-EOM.chomp
 failed assert_raise.
 <[ArgumentError, TypeError]> exception expected but was
-Class: <RuntimeError>
-Message: <"Error">
+<RuntimeError(<Error>)>.
 EOM
-        message = Regexp.escape(message)
-        check_fails(/\A#{message}#{BACKTRACE_RE}\z/m) do
+        check_fail_exception(message) do
           assert_raise(ArgumentError, TypeError, "failed assert_raise") do
             raise "Error"
           end
@@ -513,25 +526,28 @@ EOM
               "Should have returned the correct exception " +
               "from a successful assert_raise")
 
-        message = <<-EOM
-<RuntimeError("XXX")> exception expected but was
-Class: <RuntimeError>
-Message: <"Error">
+        message = <<-EOM.chomp
+<RuntimeError(<XXX>)> exception expected but was
+<RuntimeError(<Error>)>.
+
+diff:
+- RuntimeError(<XXX>)
+?               ^^^
++ RuntimeError(<Error>)
+?               ^^^^^
 EOM
-        message = Regexp.escape(message)
-        check_fails(/\A#{message}#{BACKTRACE_RE}\z/) do
+        check_fail_exception(message) do
           return_value = assert_raise(RuntimeError.new("XXX")) do
             raise "Error"
           end
         end
 
         different_error_class = Class.new(StandardError)
-        message = <<-EOM
-<\#<Class:[xa-f\\d]+>\\("Error"\\)> exception expected but was
-Class: <RuntimeError>
-Message: <"Error">
+        message = <<-EOM.chomp
+<#{different_error_class.inspect}(<Error>)> exception expected but was
+<RuntimeError(<Error>)>.
 EOM
-        check_fails(/\A#{message}#{BACKTRACE_RE}\z/) do
+        check_fail_exception(message) do
           assert_raise(different_error_class.new("Error")) do
             raise "Error"
           end
@@ -541,12 +557,11 @@ EOM
         def different_error.inspect
           "DifferentError: \"Error\""
         end
-        message = <<-EOM
-<\DifferentError: \\"Error\\"> exception expected but was
-Class: <RuntimeError>
-Message: <"Error">
+        message = <<-EOM.chomp
+<DifferentError: "Error"> exception expected but was
+<RuntimeError(<Error>)>.
 EOM
-        check_fails(/\A#{message}#{BACKTRACE_RE}\z/) do
+        check_fail_exception(message) do
           assert_raise(different_error) do
             raise "Error"
           end
@@ -571,20 +586,20 @@ EOM
         check_nothing_fails {
           assert_instance_of(String, "string", "successful assert_instance_of")
         }
-        check_fails(%Q{<"string"> expected to be an instance of\n<Hash> but was\n<String>.}) {
+        check_fail(%Q{<"string"> expected to be an instance of\n<Hash> but was\n<String>.}) {
           assert_instance_of(Hash, "string")
         }
-        check_fails(%Q{failed assert_instance_of.\n<"string"> expected to be an instance of\n<Hash> but was\n<String>.}) {
+        check_fail(%Q{failed assert_instance_of.\n<"string"> expected to be an instance of\n<Hash> but was\n<String>.}) {
           assert_instance_of(Hash, "string", "failed assert_instance_of")
         }
 
         check_nothing_fails do
           assert_instance_of([Fixnum, NilClass], 100)
         end
-        check_fails(%Q{<"string"> expected to be an instance of\n[<Fixnum>, <NilClass>] but was\n<String>.}) do
+        check_fail(%Q{<"string"> expected to be an instance of\n[<Fixnum>, <NilClass>] but was\n<String>.}) do
           assert_instance_of([Fixnum, NilClass], "string")
         end
-        check_fails(%Q{<100> expected to be an instance of\n[<Numeric>, <NilClass>] but was\n<Fixnum>.}) do
+        check_fail(%Q{<100> expected to be an instance of\n[<Numeric>, <NilClass>] but was\n<Fixnum>.}) do
           assert_instance_of([Numeric, NilClass], 100)
         end
       end
@@ -599,10 +614,10 @@ EOM
         check_nothing_fails {
           assert_nil(nil, "successful assert_nil")
         }
-        check_fails(%Q{<"string"> expected to be nil.}) {
+        check_fail(%Q{<"string"> expected to be nil.}) {
           assert_nil("string")
         }
-        check_fails(%Q{failed assert_nil.\n<"string"> expected to be nil.}) {
+        check_fail(%Q{failed assert_nil.\n<"string"> expected to be nil.}) {
           assert_nil("string", "failed assert_nil")
         }
       end
@@ -610,8 +625,8 @@ EOM
       def test_assert_not_nil
         check_nothing_fails{assert_not_nil(false)}
         check_nothing_fails{assert_not_nil(false, "message")}
-        check_fails("<nil> expected to not be nil."){assert_not_nil(nil)}
-        check_fails("message.\n<nil> expected to not be nil.") {assert_not_nil(nil, "message")}
+        check_fail("<nil> expected to not be nil."){assert_not_nil(nil)}
+        check_fail("message.\n<nil> expected to not be nil.") {assert_not_nil(nil, "message")}
       end
         
       def test_assert_kind_of
@@ -627,17 +642,17 @@ EOM
         check_nothing_fails {
           assert_kind_of(Comparable, 1)
         }
-        check_fails(%Q{<"string"> expected to be kind_of?\n<Class> but was\n<String>.}) {
+        check_fail(%Q{<"string"> expected to be kind_of?\n<Class> but was\n<String>.}) {
           assert_kind_of(Class, "string")
         }
-        check_fails(%Q{failed assert_kind_of.\n<"string"> expected to be kind_of?\n<Class> but was\n<String>.}) {
+        check_fail(%Q{failed assert_kind_of.\n<"string"> expected to be kind_of?\n<Class> but was\n<String>.}) {
           assert_kind_of(Class, "string", "failed assert_kind_of")
         }
 
         check_nothing_fails do
           assert_kind_of([Fixnum, NilClass], 100)
         end
-        check_fails(%Q{<"string"> expected to be kind_of?\n[<Fixnum>, <NilClass>] but was\n<String>.}) do
+        check_fail(%Q{<"string"> expected to be kind_of?\n[<Fixnum>, <NilClass>] but was\n<String>.}) do
           assert_kind_of([Fixnum, NilClass], "string")
         end
       end
@@ -655,13 +670,13 @@ EOM
         check_nothing_fails {
           assert_match(/strin./, "string", "successful assert_match")
         }
-        check_fails(%Q{<"string"> expected to be =~\n</slin./>.}) {
+        check_fail(%Q{<"string"> expected to be =~\n</slin./>.}) {
           assert_match(/slin./, "string")
         }
-        check_fails(%Q{<"string"> expected to be =~\n</strin\\./>.}) {
+        check_fail(%Q{<"string"> expected to be =~\n</strin\\./>.}) {
           assert_match("strin.", "string")
         }
-        check_fails(%Q{failed assert_match.\n<"string"> expected to be =~\n</slin./>.}) {
+        check_fail(%Q{failed assert_match.\n<"string"> expected to be =~\n</slin./>.}) {
           assert_match(/slin./, "string", "failed assert_match")
         }
       end
@@ -678,10 +693,10 @@ EOM
           assert_same(thing, thing, "successful assert_same")
         }
         thing2 = "thing"
-        check_fails(%Q{<"thing">\nwith id <#{thing.__id__}> expected to be equal? to\n<"thing">\nwith id <#{thing2.__id__}>.}) {
+        check_fail(%Q{<"thing">\nwith id <#{thing.__id__}> expected to be equal? to\n<"thing">\nwith id <#{thing2.__id__}>.}) {
           assert_same(thing, thing2)
         }
-        check_fails(%Q{failed assert_same.\n<"thing">\nwith id <#{thing.__id__}> expected to be equal? to\n<"thing">\nwith id <#{thing2.__id__}>.}) {
+        check_fail(%Q{failed assert_same.\n<"thing">\nwith id <#{thing.__id__}> expected to be equal? to\n<"thing">\nwith id <#{thing2.__id__}>.}) {
           assert_same(thing, thing2, "failed assert_same")
         }
       end
@@ -710,42 +725,55 @@ EOM
           rescue ZeroDivisionError
           end
         }
-        check_fails("Should expect a class of exception, Object.\n<false> is not true.") {
+        check_fail("Should expect a class of exception, Object.\n<false> is not true.") {
           assert_nothing_raised(Object) {
             1 + 1
           }
         }
-        check_fails(%r{\AException raised:\nClass: <RuntimeError>\nMessage: <"Error">\n---Backtrace---\n.+\n---------------\Z}m) {
+        expected_message = <<-EOM.chomp
+Exception raised:
+RuntimeError(<Error>)
+EOM
+        check_fail_exception(expected_message) {
           assert_nothing_raised {
             raise "Error"
           }
         }
-        check_fails(%r{\Afailed assert_nothing_raised\.\nException raised:\nClass: <RuntimeError>\nMessage: <"Error">\n---Backtrace---\n.+\n---------------\Z}m) {
+        expected_message = <<-EOM.chomp
+failed assert_nothing_raised.
+Exception raised:
+RuntimeError(<Error>)
+EOM
+        check_fail_exception(expected_message) {
           assert_nothing_raised("failed assert_nothing_raised") {
             raise "Error"
           }
         }
-        check_fails(%r{\AException raised:\nClass: <RuntimeError>\nMessage: <"Error">\n---Backtrace---\n.+\n---------------\Z}m) {
+        expected_message = <<-EOM.chomp
+Exception raised:
+RuntimeError(<Error>)
+EOM
+        check_fail_exception(expected_message) {
           assert_nothing_raised(StandardError, RuntimeError) {
             raise "Error"
           }
         }
-        check_fails("Failure.") do
+        check_fail("Failure.") do
           assert_nothing_raised do
             flunk("Failure")
           end
         end
       end
-      
+
       def test_flunk
-        check_fails("Flunked.") {
+        check_fail("Flunked.") {
           flunk
         }
-        check_fails("flunk message.") {
+        check_fail("flunk message.") {
           flunk("flunk message")
         }
       end
-      
+
       def test_assert_not_same
         thing = "thing"
         thing2 = "thing"
@@ -755,10 +783,10 @@ EOM
         check_nothing_fails {
           assert_not_same(thing, thing2, "message")
         }
-        check_fails(%Q{<"thing">\nwith id <#{thing.__id__}> expected to not be equal? to\n<"thing">\nwith id <#{thing.__id__}>.}) {
+        check_fail(%Q{<"thing">\nwith id <#{thing.__id__}> expected to not be equal? to\n<"thing">\nwith id <#{thing.__id__}>.}) {
           assert_not_same(thing, thing)
         }
-        check_fails(%Q{message.\n<"thing">\nwith id <#{thing.__id__}> expected to not be equal? to\n<"thing">\nwith id <#{thing.__id__}>.}) {
+        check_fail(%Q{message.\n<"thing">\nwith id <#{thing.__id__}> expected to not be equal? to\n<"thing">\nwith id <#{thing.__id__}>.}) {
           assert_not_same(thing, thing, "message")
         }
       end
@@ -770,10 +798,10 @@ EOM
         check_nothing_fails {
           assert_not_equal("string1", "string2", "message")
         }
-        check_fails(%Q{<"string"> expected to be != to\n<"string">.}) {
+        check_fail(%Q{<"string"> expected to be != to\n<"string">.}) {
           assert_not_equal("string", "string")
         }
-        check_fails(%Q{message.\n<"string"> expected to be != to\n<"string">.}) {
+        check_fail(%Q{message.\n<"string"> expected to be != to\n<"string">.}) {
           assert_not_equal("string", "string", "message")
         }
       end
@@ -791,7 +819,7 @@ EOM
       end
 
       def test_assert_not_match_fail_not_regexp
-        check_fails("<REGEXP> in assert_not_match(<REGEXP>, ...) " +
+        check_fail("<REGEXP> in assert_not_match(<REGEXP>, ...) " +
                     "should be a Regexp.\n" +
                     "<\"asdf\"> expected to be an instance of\n" +
                     "<Regexp> but was\n" +
@@ -801,14 +829,14 @@ EOM
       end
 
       def test_assert_not_match_fail_match
-        check_fails("</string/> expected to not match\n" +
+        check_fail("</string/> expected to not match\n" +
                     "<\"string\">.") do
           assert_not_match(/string/, "string")
         end
       end
 
       def test_assert_not_match_fail_match_with_message
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "</string/> expected to not match\n" +
                     "<\"string\">.") do
           assert_not_match(/string/, "string", "message")
@@ -818,13 +846,13 @@ EOM
       def test_assert_no_match
         check_nothing_fails{assert_no_match(/sling/, "string")}
         check_nothing_fails{assert_no_match(/sling/, "string", "message")}
-        check_fails(%Q{The first argument to assert_no_match should be a Regexp.\n<"asdf"> expected to be an instance of\n<Regexp> but was\n<String>.}) do
+        check_fail(%Q{The first argument to assert_no_match should be a Regexp.\n<"asdf"> expected to be an instance of\n<Regexp> but was\n<String>.}) do
           assert_no_match("asdf", "asdf")
         end
-        check_fails(%Q{</string/> expected to not match\n<"string">.}) do
+        check_fail(%Q{</string/> expected to not match\n<"string">.}) do
           assert_no_match(/string/, "string")
         end
-        check_fails(%Q{message.\n</string/> expected to not match\n<"string">.}) do
+        check_fail(%Q{message.\n</string/> expected to not match\n<"string">.}) do
           assert_no_match(/string/, "string", "message")
         end
       end
@@ -837,14 +865,14 @@ EOM
         end
 
         tag = :thing2
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<:thing> expected to be thrown but\n" +
                     "<#{inspect_tag(tag)}> was thrown.") do
           assert_throw(:thing, "message") do
             throw :thing2
           end
         end
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<:thing> should have been thrown.") do
           assert_throw(:thing, "message") do
             1 + 1
@@ -861,7 +889,7 @@ EOM
 
         tag = :thing
         inspected = inspect_tag(tag)
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<#{inspected}> was thrown when nothing was expected.") do
           assert_nothing_thrown("message") do
             throw tag
@@ -873,10 +901,10 @@ EOM
         check_nothing_fails {
           assert_operator("thing", :==, "thing", "message")
         }
-        check_fails(%Q{<0.15>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to?(:to_str).}) do
+        check_fail(%Q{<0.15>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to?(:to_str).}) do
           assert_operator("thing", 0.15, "thing")
         end
-        check_fails(%Q{message.\n<"thing1"> expected to be\n==\n<"thing2">.}) {
+        check_fail(%Q{message.\n<"thing1"> expected to be\n==\n<"thing2">.}) {
           assert_operator("thing1", :==, "thing2", "message")
         }
       end
@@ -888,11 +916,11 @@ EOM
         check_nothing_fails {
           assert_respond_to("thing", "to_s", "message")
         }
-        check_fails("<0.15>.kind_of?(Symbol) or\n" +
+        check_fail("<0.15>.kind_of?(Symbol) or\n" +
                     "<0.15>.respond_to?(:to_str) expected") {
           assert_respond_to("thing", 0.15)
         }
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<:symbol>.respond_to?(:nonexistence) expected\n" +
                     "(Class: <Symbol>)") {
           assert_respond_to(:symbol, :nonexistence, "message")
@@ -912,14 +940,14 @@ EOM
       end
 
       def test_assert_not_respond_to_fail_number
-        check_fails("<0.15>.kind_of?(Symbol) or\n" +
+        check_fail("<0.15>.kind_of?(Symbol) or\n" +
                     "<0.15>.respond_to?(:to_str) expected") do
           assert_respond_to("thing", 0.15)
         end
       end
 
       def tset_assert_not_respond_to_fail_existence
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "!<:symbol>.respond_to?(:to_s) expected\n" +
                     "(Class: <Symbol>)") do
           assert_respond_to(:symbol, :to_s, "message")
@@ -945,7 +973,7 @@ message.
 <return_argument(*[false, "bogus"])> with a true value but was
 <false>.
 EOM
-        check_fails(expected_message.chomp) do
+        check_fail(expected_message.chomp) do
           assert_send([object, :return_argument, false, "bogus"], "message")
         end
       end
@@ -972,15 +1000,15 @@ EOM
           assert_boolean(false)
         end
 
-        check_fails("<true> or <false> expected but was\n<1>") do
+        check_fail("<true> or <false> expected but was\n<1>") do
           assert_boolean(1)
         end
 
-        check_fails("<true> or <false> expected but was\n<nil>") do
+        check_fail("<true> or <false> expected but was\n<nil>") do
           assert_boolean(nil)
         end
 
-        check_fails("message.\n<true> or <false> expected but was\n<\"XXX\">") do
+        check_fail("message.\n<true> or <false> expected but was\n<\"XXX\">") do
           assert_boolean("XXX", "message")
         end
       end
@@ -990,15 +1018,15 @@ EOM
           assert_true(true)
         end
 
-        check_fails("<true> expected but was\n<false>") do
+        check_fail("<true> expected but was\n<false>") do
           assert_true(false)
         end
 
-        check_fails("<true> expected but was\n<1>") do
+        check_fail("<true> expected but was\n<1>") do
           assert_true(1)
         end
 
-        check_fails("message.\n<true> expected but was\n<nil>") do
+        check_fail("message.\n<true> expected but was\n<nil>") do
           assert_true(nil, "message")
         end
       end
@@ -1008,15 +1036,15 @@ EOM
           assert_false(false)
         end
 
-        check_fails("<false> expected but was\n<true>") do
+        check_fail("<false> expected but was\n<true>") do
           assert_false(true)
         end
 
-        check_fails("<false> expected but was\n<nil>") do
+        check_fail("<false> expected but was\n<nil>") do
           assert_false(nil)
         end
 
-        check_fails("message.\n<false> expected but was\n<:false>") do
+        check_fail("message.\n<false> expected but was\n<:false>") do
           assert_false(:false, "message")
         end
       end
@@ -1043,7 +1071,7 @@ EOM
 <15> expected less than
 <10>.
 EOM
-        check_fails(expected_message.chomp) do
+        check_fail(expected_message.chomp) do
           assert_compare(15, "<", 10)
         end
 
@@ -1052,7 +1080,7 @@ EOM
 <15> expected less than or equal to
 <10>.
 EOM
-        check_fails(expected_message.chomp) do
+        check_fail(expected_message.chomp) do
           assert_compare(15, "<=", 10)
         end
 
@@ -1061,7 +1089,7 @@ EOM
 <10> expected greater than
 <15>.
 EOM
-        check_fails(expected_message.chomp) do
+        check_fail(expected_message.chomp) do
           assert_compare(10, ">", 15)
         end
 
@@ -1070,7 +1098,7 @@ EOM
 <10> expected greater than or equal to
 <15>.
 EOM
-        check_fails(expected_message.chomp) do
+        check_fail(expected_message.chomp) do
           assert_compare(10, ">=", 15)
         end
       end
@@ -1082,7 +1110,7 @@ EOM
           end
         end
 
-        check_fails("Failed assertion was expected.") do
+        check_fail("Failed assertion was expected.") do
           assert_fail_assertion do
           end
         end
@@ -1111,7 +1139,7 @@ EOM
 <"Expected message"> exception message expected but was
 <"Actual message">.
 EOM
-        check_fails(expected_message.chomp) do
+        check_fail(expected_message.chomp) do
           assert_raise_message("Expected message") do
             raise "Actual message"
           end
@@ -1120,7 +1148,7 @@ EOM
         expected_message = <<-EOM
 <"Expected message"> exception message expected but none was thrown.
 EOM
-        check_fails(expected_message.chomp) do
+        check_fail(expected_message.chomp) do
           assert_raise_message("Expected message") do
           end
         end
@@ -1133,13 +1161,11 @@ EOM
           end
         end
 
-        expected_message = <<-EOM
+        expected_message = <<-EOM.chomp
 <SystemCallError> family exception expected but was
-Class: <RuntimeError>
-Message: <"XXX">
----Backtrace---
+<RuntimeError(<XXX>)>.
 EOM
-        check_fails(/\A#{Regexp.escape(expected_message)}(?m).+\z/) do
+        check_fail_exception(expected_message) do
           assert_raise_kind_of(SystemCallError) do
             raise RuntimeError, "XXX"
           end
@@ -1155,7 +1181,7 @@ EOM
           assert_const_defined(Test, "Unit")
         end
 
-        check_fails("<Test>.const_defined?(<:Nonexistence>) expected.") do
+        check_fail("<Test>.const_defined?(<:Nonexistence>) expected.") do
           assert_const_defined(Test, :Nonexistence)
         end
       end
@@ -1165,11 +1191,11 @@ EOM
           assert_not_const_defined(Test, :Nonexistence)
         end
 
-        check_fails("!<Test>.const_defined?(<:Unit>) expected.") do
+        check_fail("!<Test>.const_defined?(<:Unit>) expected.") do
           assert_not_const_defined(Test, :Unit)
         end
 
-        check_fails("!<Test>.const_defined?(<\"Unit\">) expected.") do
+        check_fail("!<Test>.const_defined?(<\"Unit\">) expected.") do
           assert_not_const_defined(Test, "Unit")
         end
       end
@@ -1179,11 +1205,11 @@ EOM
           assert_predicate([], :empty?)
         end
 
-        check_fails("<[1]>.empty? is true value expected but was\n<false>") do
+        check_fail("<[1]>.empty? is true value expected but was\n<false>") do
           assert_predicate([1], :empty?)
         end
 
-        check_fails("<[1]>.respond_to?(:nonexistent?) expected\n" +
+        check_fail("<[1]>.respond_to?(:nonexistent?) expected\n" +
                     "(Class: <Array>)") do
           assert_predicate([1], :nonexistent?)
         end
@@ -1194,11 +1220,11 @@ EOM
           assert_not_predicate([1], :empty?)
         end
 
-        check_fails("<[]>.empty? is false value expected but was\n<true>") do
+        check_fail("<[]>.empty? is false value expected but was\n<true>") do
           assert_not_predicate([], :empty?)
         end
 
-        check_fails("<[]>.respond_to?(:nonexistent?) expected\n" +
+        check_fail("<[]>.respond_to?(:nonexistent?) expected\n" +
                     "(Class: <Array>)") do
           assert_not_predicate([], :nonexistent?)
         end
@@ -1223,18 +1249,18 @@ EOM
           assert_alias_method(object, :original_method, :alias_method)
         end
 
-        check_fails("<#{object.method(:other).inspect}> is alias of\n" +
+        check_fail("<#{object.method(:other).inspect}> is alias of\n" +
                     "<#{object.method(:original_method).inspect}> expected") do
           assert_alias_method(object, :other, :original_method)
         end
 
         inspected_object = AssertionMessage.convert(object)
-        check_fails("<#{inspected_object}>.nonexistent doesn't exist\n" +
+        check_fail("<#{inspected_object}>.nonexistent doesn't exist\n" +
                     "(Class: <Object>)") do
           assert_alias_method(object, :nonexistent, :original_method)
         end
 
-        check_fails("<#{inspected_object}>.nonexistent doesn't exist\n" +
+        check_fail("<#{inspected_object}>.nonexistent doesn't exist\n" +
                     "(Class: <Object>)") do
           assert_alias_method(object, :alias_method, :nonexistent)
         end
@@ -1246,7 +1272,7 @@ EOM
         end
 
         nonexistent_file = __FILE__ + ".nonexistent"
-        check_fails("<#{nonexistent_file.inspect}> expected to exist") do
+        check_fail("<#{nonexistent_file.inspect}> expected to exist") do
           assert_path_exist(nonexistent_file)
         end
       end
@@ -1257,7 +1283,7 @@ EOM
           assert_path_not_exist(nonexistent_file)
         end
 
-        check_fails("<#{__FILE__.inspect}> expected to not exist") do
+        check_fail("<#{__FILE__.inspect}> expected to not exist") do
           assert_path_not_exist(__FILE__)
         end
       end
@@ -1285,26 +1311,26 @@ EOM
       end
 
       def test_fail_nil
-        check_fails("<nil> is not true.") do
+        check_fail("<nil> is not true.") do
           assert(nil)
         end
       end
 
       def test_fail_false
-        check_fails("<false> is not true.") do
+        check_fail("<false> is not true.") do
           assert(false)
         end
       end
 
       def test_fail_false_with_message
-        check_fails("failed assert.\n" +
+        check_fail("failed assert.\n" +
                     "<false> is not true.") do
           assert(false, "failed assert")
         end
       end
 
       def test_fail_with_assertion_message
-        check_fails("user message.\n" +
+        check_fail("user message.\n" +
                     "placeholder <:in> message") do
           assert(false, build_message("user message",
                                       "placeholder <?> message",
@@ -1313,7 +1339,7 @@ EOM
       end
 
       def test_error_invalid_message_true
-        check_fails("assertion message must be String, Proc or " +
+        check_fail("assertion message must be String, Proc or " +
                     "Test::Unit::Assertions::AssertionMessage: " +
                     "<true>(<TrueClass>)") do
           begin
@@ -1363,7 +1389,7 @@ EOM
       end
 
       def test_fail_with_message
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<0.5> -/+ <0.05> expected to include\n" +
                     "<0.4>.\n" +
                     "\n" +
@@ -1376,7 +1402,7 @@ EOM
       def test_fail_because_not_float_like_object
         object = Object.new
         inspected_object = AssertionMessage.convert(object)
-        check_fails("The arguments must respond to to_f; " +
+        check_fail("The arguments must respond to to_f; " +
                     "the first float did not.\n" +
                     "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                     "(Class: <Object>)") do
@@ -1385,14 +1411,14 @@ EOM
       end
 
       def test_fail_because_negaitve_delta
-        check_fails("The delta should not be negative.\n" +
+        check_fail("The delta should not be negative.\n" +
                     "<-0.1> expected to be\n>=\n<0.0>.") do
           assert_in_delta(0.5, 0.4, -0.1, "message")
         end
       end
 
       def test_fail_without_delta
-        check_fails("<1.402> -/+ <0.001> expected to include\n" +
+        check_fail("<1.402> -/+ <0.001> expected to include\n" +
                     "<1.404>.\n" +
                     "\n" +
                     "Relation:\n" +
@@ -1444,7 +1470,7 @@ EOM
       end
 
       def test_fail
-        check_fails("<1.4> -/+ <0.11> expected to not include\n" +
+        check_fail("<1.4> -/+ <0.11> expected to not include\n" +
                     "<1.5>.\n" +
                     "\n" +
                     "Relation:\n" +
@@ -1458,7 +1484,7 @@ EOM
       end
 
       def test_fail_without_delta
-        check_fails("<1.402> -/+ <0.001> expected to not include\n" +
+        check_fail("<1.402> -/+ <0.001> expected to not include\n" +
                     "<1.4021>.\n" +
                     "\n" +
                     "Relation:\n" +
@@ -1472,7 +1498,7 @@ EOM
       end
 
       def test_fail_with_message
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<0.5> -/+ <0.11> expected to not include\n" +
                     "<0.4>.\n" +
                     "\n" +
@@ -1489,7 +1515,7 @@ EOM
       def test_fail_because_not_float_like_object
         object = Object.new
         inspected_object = AssertionMessage.convert(object)
-        check_fails("The arguments must respond to to_f; " +
+        check_fail("The arguments must respond to to_f; " +
                     "the first float did not.\n" +
                     "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                     "(Class: <Object>)") do
@@ -1498,7 +1524,7 @@ EOM
       end
 
       def test_fail_because_negaitve_delta
-        check_fails("The delta should not be negative.\n" +
+        check_fail("The delta should not be negative.\n" +
                     "<-0.11> expected to be\n>=\n<0.0>.") do
           assert_not_in_delta(0.5, 0.4, -0.11, "message")
         end
@@ -1549,7 +1575,7 @@ EOM
       end
 
       def test_fail_with_message
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<10000> -/+ (<10000> * <0.1>)[1000.0] " +
                     "expected to include\n" +
                     "<8999>.\n" +
@@ -1567,7 +1593,7 @@ EOM
       def test_fail_because_not_float_like_object
         object = Object.new
         inspected_object = AssertionMessage.convert(object)
-        check_fails("The arguments must respond to to_f; " +
+        check_fail("The arguments must respond to to_f; " +
                     "the first float did not.\n" +
                     "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                     "(Class: <Object>)") do
@@ -1576,14 +1602,14 @@ EOM
       end
 
       def test_fail_because_negaitve_epsilon
-        check_fails("The epsilon should not be negative.\n" +
+        check_fail("The epsilon should not be negative.\n" +
                     "<-0.1> expected to be\n>=\n<0.0>.") do
           assert_in_epsilon(10000, 9000, -0.1, "message")
         end
       end
 
       def test_fail_without_epsilon
-        check_fails("<10000> -/+ (<10000> * <0.001>)[10.0] " +
+        check_fail("<10000> -/+ (<10000> * <0.001>)[10.0] " +
                     "expected to include\n" +
                     "<10011>.\n" +
                     "\n" +
@@ -1636,7 +1662,7 @@ EOM
       end
 
       def test_fail
-        check_fails("<10000> -/+ (<10000> * <0.1>)[1000.0] " +
+        check_fail("<10000> -/+ (<10000> * <0.1>)[1000.0] " +
                     "expected to not include\n" +
                     "<9000>.\n" +
                     "\n" +
@@ -1651,7 +1677,7 @@ EOM
       end
 
       def test_fail_without_epsilon
-        check_fails("<10000> -/+ (<10000> * <0.001>)[10.0] " +
+        check_fail("<10000> -/+ (<10000> * <0.001>)[10.0] " +
                     "expected to not include\n" +
                     "<9990>.\n" +
                     "\n" +
@@ -1666,7 +1692,7 @@ EOM
       end
 
       def test_fail_with_message
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<10000> -/+ (<10000> * <0.1>)[1000.0] " +
                     "expected to not include\n" +
                     "<9000>.\n" +
@@ -1684,7 +1710,7 @@ EOM
       def test_fail_because_not_float_like_object
         object = Object.new
         inspected_object = AssertionMessage.convert(object)
-        check_fails("The arguments must respond to to_f; " +
+        check_fail("The arguments must respond to to_f; " +
                     "the first float did not.\n" +
                     "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                     "(Class: <Object>)") do
@@ -1693,7 +1719,7 @@ EOM
       end
 
       def test_fail_because_negaitve_epsilon
-        check_fails("The epsilon should not be negative.\n" +
+        check_fail("The epsilon should not be negative.\n" +
                     "<-0.1> expected to be\n>=\n<0.0>.") do
           assert_not_in_epsilon(10000, 9000, -0.1, "message")
         end
@@ -1716,14 +1742,14 @@ EOM
       end
 
       def test_fail
-        check_fails("<[1, 2, 3]> expected to include\n" +
+        check_fail("<[1, 2, 3]> expected to include\n" +
                     "<4>.") do
           assert_include([1, 2, 3], 4)
         end
       end
 
       def test_fail_with_message
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<[1, 2, 3]> expected to include\n" +
                     "<4>.") do
           assert_include([1, 2, 3], 4, "message")
@@ -1733,7 +1759,7 @@ EOM
       def test_fail_because_not_collection_like_object
         object = Object.new
         inspected_object = AssertionMessage.convert(object)
-        check_fails("The collection must respond to :include?.\n" +
+        check_fail("The collection must respond to :include?.\n" +
                     "<#{inspected_object}>.respond_to?(:include?) expected\n" +
                     "(Class: <Object>)") do
           assert_include(object, 1)
@@ -1757,14 +1783,14 @@ EOM
       end
 
       def test_fail
-        check_fails("<[1, 2, 3]> expected to not include\n" +
+        check_fail("<[1, 2, 3]> expected to not include\n" +
                     "<2>.") do
           assert_not_include([1, 2, 3], 2)
         end
       end
 
       def test_fail_with_message
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<[1, 2, 3]> expected to not include\n" +
                     "<2>.") do
           assert_not_include([1, 2, 3], 2, "message")
@@ -1774,7 +1800,7 @@ EOM
       def test_fail_because_not_collection_like_object
         object = Object.new
         inspected_object = AssertionMessage.convert(object)
-        check_fails("The collection must respond to :include?.\n" +
+        check_fail("The collection must respond to :include?.\n" +
                     "<#{inspected_object}>.respond_to?(:include?) expected\n" +
                     "(Class: <Object>)") do
           assert_not_include(object, 1)
@@ -1798,13 +1824,13 @@ EOM
       end
 
       def test_fail
-        check_fails("<[1]> expected to be empty.") do
+        check_fail("<[1]> expected to be empty.") do
           assert_empty([1])
         end
       end
 
       def test_fail_with_message
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<[1]> expected to be empty.") do
           assert_empty([1], "message")
         end
@@ -1813,7 +1839,7 @@ EOM
       def test_fail_because_no_empty_method
         object = Object.new
         inspected_object = AssertionMessage.convert(object)
-        check_fails("The object must respond to :empty?.\n" +
+        check_fail("The object must respond to :empty?.\n" +
                     "<#{inspected_object}>.respond_to?(:empty?) expected\n" +
                     "(Class: <Object>)") do
           assert_empty(object)
@@ -1837,13 +1863,13 @@ EOM
       end
 
       def test_fail
-        check_fails("<[]> expected to not be empty.") do
+        check_fail("<[]> expected to not be empty.") do
           assert_not_empty([])
         end
       end
 
       def test_fail_with_message
-        check_fails("message.\n" +
+        check_fail("message.\n" +
                     "<[]> expected to not be empty.") do
           assert_not_empty([], "message")
         end
@@ -1852,7 +1878,7 @@ EOM
       def test_fail_because_no_empty_method
         object = Object.new
         inspected_object = AssertionMessage.convert(object)
-        check_fails("The object must respond to :empty?.\n" +
+        check_fail("The object must respond to :empty?.\n" +
                     "<#{inspected_object}>.respond_to?(:empty?) expected\n" +
                     "(Class: <Object>)") do
           assert_not_empty(object)
@@ -1876,7 +1902,7 @@ message.
 <member?(*[2])> with not a true value but was
 <true>.
 EOM
-        check_fails(expected_message.chomp) do
+        check_fail(expected_message.chomp) do
           assert_not_send([[1, 2], :member?, 2], "message")
         end
       end