test-unit 3.1.5 → 3.6.1

data/lib/test/unit/assertions.rb

@@ -5,6 +5,7 @@
 
 require 'test/unit/assertion-failed-error'
 require 'test/unit/util/backtracefilter'
+require 'test/unit/util/memory-usage'
 require 'test/unit/util/method-owner-finder'
 require 'test/unit/diff'
 
@@ -32,9 +33,9 @@ module Test
     #
     # @example Example Custom Assertion
     #
-    #   def deny(boolean, message = nil)
-    #     message = build_message message, '<?> is not false or nil.', boolean
-    #     assert_block message do
+    #   def deny(boolean, message=nil)
+    #     message = build_message(message, '<?> is not false or nil.', boolean)
+    #     assert_block(message) do
     #       not boolean
     #     end
     #   end
@@ -43,7 +44,7 @@ module Test
 
       ##
       # The assertion upon which all other assertions are based. Passes if the
-      # block yields true.
+      # block yields not false nor nil.
       #
       # @example
       #   assert_block "Couldn't do the thing" do
@@ -52,7 +53,11 @@ module Test
       def assert_block(message="assert_block failed.")
         _wrap_assertion do
           if (! yield)
-            raise AssertionFailedError.new(message.to_s)
+            options = {}
+            if message.respond_to?(:user_message)
+              options[:user_message] = message.user_message
+            end
+            raise AssertionFailedError.new(message.to_s, options)
           end
         end
       end
@@ -153,8 +158,8 @@ module Test
               assertion_message = message
             else
               error_message = "assertion message must be String, Proc or "
-              error_message << "#{AssertionMessage}: "
-              error_message << "<#{message.inspect}>(<#{message.class}>)"
+              error_message += "#{AssertionMessage}: "
+              error_message += "<#{message.inspect}>(<#{message.class}>)"
               raise ArgumentError, error_message, filter_backtrace(caller)
             end
             assertion_message ||= build_message(message,
@@ -167,7 +172,7 @@ module Test
         end
       end
 
-      # Asserts that +object+ is false or nil.
+      # Asserts that `object` is false or nil.
       #
       # @note Just for minitest compatibility. :<
       #
@@ -192,8 +197,8 @@ module Test
             assertion_message = message
           else
             error_message = "assertion message must be String, Proc or "
-            error_message << "#{AssertionMessage}: "
-            error_message << "<#{message.inspect}>(<#{message.class}>)"
+            error_message += "#{AssertionMessage}: "
+            error_message += "<#{message.inspect}>(<#{message.class}>)"
             raise ArgumentError, error_message, filter_backtrace(caller)
           end
           assert_block("refute should not be called with a block.") do
@@ -209,7 +214,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
@@ -239,7 +244,7 @@ EOT
         begin
           assert_block(full_message) { expected == actual }
         rescue AssertionFailedError => failure
-          _set_failed_information(failure, expected, actual, message)
+          _set_failed_information(failure, expected, actual)
           raise failure # For JRuby. :<
         end
       end
@@ -275,8 +280,7 @@ EOT
                 assert_exception_helper.expected?(actual_exception)
             end
           rescue AssertionFailedError => failure
-            _set_failed_information(failure, expected, actual_exception,
-                                    message)
+            _set_failed_information(failure, expected, actual_exception)
             raise failure # For JRuby. :<
           end
         end
@@ -286,6 +290,71 @@ EOT
       # Just for minitest compatibility. :<
       alias_method :assert_raises, :assert_raise
 
+      # Passes if the block raises `expected_exception` with
+      # `expected_message`. `expected_message` can be a `String` or
+      # `Regexp`.
+      #
+      # @example Pass pattern: String
+      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
+      #     raise "Boom!!!"
+      #   end # -> pass
+      #
+      # @example Pass pattern: Regexp
+      #   assert_raise_with_message(RuntimeError, /!!!/) do
+      #     raise "Boom!!!"
+      #   end # -> pass
+      #
+      # @example Failure pattern: Exception class isn't matched
+      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
+      #     raise ArgumentError, "Boom!!!"
+      #   end # -> failure
+      #
+      # @example Failure pattern: Exception message isn't matched
+      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
+      #     raise "Hello"
+      #   end # -> failure
+      #
+      # @since 3.4.3
+      def assert_raise_with_message(expected_exception_class,
+                                    expected_message,
+                                    message=nil,
+                                    &block)
+        assert_expected_exception = Proc.new do |*_args|
+          _message, assert_exception_helper, actual_exception = _args
+          diff = AssertionMessage.delayed_diff([
+                                                 expected_exception_class,
+                                                 expected_message,
+                                               ],
+                                               [
+                                                 actual_exception.class,
+                                                 actual_exception.message,
+                                               ])
+          full_message = build_message(message,
+                                       "<?>(<?>) exception expected but was\n" +
+                                       "<?>(<?>).?",
+                                       expected_exception_class,
+                                       expected_message,
+                                       actual_exception.class,
+                                       actual_exception.message,
+                                       diff)
+          begin
+            assert_block(full_message) do
+              assert_exception_helper.expected?(actual_exception) and
+                expected_message === actual_exception.message
+            end
+          rescue AssertionFailedError => failure
+            _set_failed_information(failure,
+                                    expected_exception_class,
+                                    actual_exception)
+            raise failure # For JRuby. :<
+          end
+          actual_exception
+        end
+        args = [expected_exception_class]
+        args << message if message
+        _assert_raise(assert_expected_exception, *args, &block)
+      end
+
       ##
       # Passes if the block raises one of the given
       # exceptions or sub exceptions of the given exceptions.
@@ -311,7 +380,7 @@ EOT
 
 
       ##
-      # Passes if +object+.instance_of?(+klass+). When +klass+ is
+      # Passes if `object`.instance_of?(`klass`). When `klass` is
       # an array of classes, it passes if any class
       # satisfies +object.instance_of?(class).
       #
@@ -319,7 +388,7 @@ EOT
       #   assert_instance_of(String, 'foo')            # -> pass
       #   assert_instance_of([Fixnum, NilClass], 100)  # -> pass
       #   assert_instance_of([Numeric, NilClass], 100) # -> fail
-      def assert_instance_of(klass, object, message="")
+      def assert_instance_of(klass, object, message=nil)
         _wrap_assertion do
           if klass.is_a?(Array)
             klasses = klass
@@ -334,7 +403,7 @@ EOT
             "<#{value}>"
           end
           full_message = build_message(message, <<EOT, object, klass_message, object.class)
-<?> expected to be instance_of\\?
+<?> was expected to be instance_of\\?
 ? but was
 <?>.
 EOT
@@ -345,8 +414,8 @@ EOT
       end
 
       ##
-      # Passes if +object+.instance_of?(+klass+) does not hold.
-      # When +klass+ is an array of classes, it passes if no class
+      # Passes if `object`.instance_of?(`klass`) does not hold.
+      # When `klass` is an array of classes, it passes if no class
       # satisfies +object.instance_of?(class).
       #
       # @example
@@ -355,14 +424,14 @@ EOT
       #   assert_not_instance_of([Numeric, NilClass], 100)   # -> fail
       #
       # @since 3.0.0
-      def assert_not_instance_of(klass, object, message="")
+      def assert_not_instance_of(klass, object, message=nil)
         _wrap_assertion do
           if klass.is_a?(Array)
             klasses = klass
           else
             klasses = [klass]
           end
-          assert_block("The first parameter to assert_not_instance_of should be " <<
+          assert_block("The first parameter to assert_not_instance_of should be " +
                        "a Class or an Array of Class.") do
             klasses.all? {|k| k.is_a?(Class)}
           end
@@ -370,7 +439,7 @@ EOT
             "<#{value}>"
           end
           full_message = build_message(message,
-                                       "<?> expected to not be instance_of\\?\n" +
+                                       "<?> was expected to not be instance_of\\?\n" +
                                        "? but was.",
                                        object,
                                        klass_message)
@@ -386,19 +455,19 @@ EOT
       alias_method :refute_instance_of, :assert_not_instance_of
 
       ##
-      # Passes if +object+ is nil.
+      # Passes if `object`.nil?.
       #
       # @example
       #   assert_nil [1, 2].uniq!
-      def assert_nil(object, message="")
+      def assert_nil(object, message=nil)
         full_message = build_message(message, <<EOT, object)
-<?> expected to be nil.
+<?> was expected to be nil.
 EOT
         assert_block(full_message) { object.nil? }
       end
 
       ##
-      # Passes if +object+.kind_of?(+klass+). When +klass+ is
+      # Passes if `object`.kind_of?(`klass`). When `klass` is
       # an array of classes or modules, it passes if any
       # class or module satisfies +object.kind_of?(class_or_module).
       #
@@ -406,7 +475,7 @@ EOT
       #   assert_kind_of(Object, 'foo')                # -> pass
       #   assert_kind_of([Fixnum, NilClass], 100)      # -> pass
       #   assert_kind_of([Fixnum, NilClass], "string") # -> fail
-      def assert_kind_of(klass, object, message="")
+      def assert_kind_of(klass, object, message=nil)
         _wrap_assertion do
           if klass.is_a?(Array)
             klasses = klass
@@ -421,7 +490,7 @@ EOT
             "<#{value}>"
           end
           full_message = build_message(message,
-                                       "<?> expected to be kind_of\\?\n" +
+                                       "<?> was expected to be kind_of\\?\n" +
                                        "? but was\n" +
                                        "<?>.",
                                        object,
@@ -434,8 +503,8 @@ EOT
       end
 
       ##
-      # Passes if +object+.kind_of?(+klass+) does not hold.
-      # When +klass+ is an array of classes or modules, it passes only if all
+      # Passes if `object`.kind_of?(`klass`) does not hold.
+      # When `klass` is an array of classes or modules, it passes only if all
       # classes (and modules) do not satisfy +object.kind_of?(class_or_module).
       #
       # @example
@@ -444,7 +513,7 @@ EOT
       #   assert_not_kind_of([Fixnum, NilClass], 100) # -> fail
       #
       # @since 3.0.0
-      def assert_not_kind_of(klass, object, message="")
+      def assert_not_kind_of(klass, object, message=nil)
         _wrap_assertion do
           if klass.is_a?(Array)
             klasses = klass
@@ -459,7 +528,7 @@ EOT
             "<#{value}>"
           end
           full_message = build_message(message,
-                                       "<?> expected to not be kind_of\\?\n" +
+                                       "<?> was expected to not be kind_of\\?\n" +
                                        "? but was.",
                                        object,
                                        klass_message)
@@ -475,11 +544,11 @@ EOT
       alias_method :refute_kind_of, :assert_not_kind_of
 
       ##
-      # Passes if +object+ .respond_to? +method+
+      # Passes if `object` .respond_to? `method`
       #
       # @example
       #   assert_respond_to 'bugbear', :slice
-      def assert_respond_to(object, method, message="")
+      def assert_respond_to(object, method, message=nil)
         _wrap_assertion do
           full_message = build_message(message,
                                        "<?>.kind_of\\?(Symbol) or\n" +
@@ -497,12 +566,12 @@ EOT
       end
 
       ##
-      # Passes if +object+ does not .respond_to? +method+.
+      # Passes if `object` does not .respond_to? `method`.
       #
       # @example
       #   assert_not_respond_to('bugbear', :nonexistence) # -> pass
       #   assert_not_respond_to('bugbear', :size)         # -> fail
-      def assert_not_respond_to(object, method, message="")
+      def assert_not_respond_to(object, method, message=nil)
         _wrap_assertion do
           full_message = build_message(message,
                                        "<?>.kind_of\\?(Symbol) or\n" +
@@ -525,35 +594,31 @@ EOT
       alias_method :refute_respond_to, :assert_not_respond_to
 
       ##
-      # Passes if +pattern+ =~ +string+.
+      # Passes if `pattern` =~ `string`.
       #
       # @example
       #   assert_match(/\d+/, 'five, 6, seven')
-      def assert_match(pattern, string, message="")
+      def assert_match(pattern, string, message=nil)
         _wrap_assertion do
-          pattern = case(pattern)
-            when String
-              Regexp.new(Regexp.escape(pattern))
-            else
-              pattern
-          end
-          full_message = build_message(message, "<?> expected to be =~\n<?>.",
+          pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
+          full_message = build_message(message,
+                                       "<?> was expected to be =~\n<?>.",
                                        pattern, string)
           assert_block(full_message) { pattern =~ string }
         end
       end
 
       ##
-      # Passes if +actual+ .equal? +expected+ (i.e. they are the same
+      # Passes if `actual` .equal? `expected` (i.e. they are the same
       # instance).
       #
       # @example
       #   o = Object.new
       #   assert_same o, o
-      def assert_same(expected, actual, message="")
+      def assert_same(expected, actual, message=nil)
         full_message = build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__)
 <?>
-with id <?> expected to be equal\\? to
+with id <?> was expected to be equal\\? to
 <?>
 with id <?>.
 EOT
@@ -561,18 +626,18 @@ EOT
       end
 
       ##
-      # Compares the +object1+ with +object2+ using +operator+.
+      # Compares the `object1` with `object2` using `operator`.
       #
-      # Passes if object1.__send__(operator, object2) is true.
+      # Passes if object1.__send__(operator, object2) is not false nor nil.
       #
       # @example
       #   assert_operator 5, :>=, 4
-      def assert_operator(object1, operator, object2, message="")
+      def assert_operator(object1, operator, object2, message=nil)
         _wrap_assertion do
           full_message = build_message(nil, "<?>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
           assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
           full_message = build_message(message, <<EOT, object1, AssertionMessage.literal(operator), object2)
-<?> expected to be
+<?> was expected to be
 ?
 <?>.
 EOT
@@ -581,21 +646,21 @@ EOT
       end
 
       ##
-      # Compares the +object1+ with +object2+ using +operator+.
+      # Compares the `object1` with `object2` using `operator`.
       #
-      # Passes if object1.__send__(operator, object2) is not true.
+      # Passes if object1.__send__(operator, object2) is false or nil.
       #
       # @example
       #   assert_not_operator(5, :<, 4) # => pass
       #   assert_not_operator(5, :>, 4) # => fail
       #
       # @since 3.0.0
-      def assert_not_operator(object1, operator, object2, message="")
+      def assert_not_operator(object1, operator, object2, message=nil)
         _wrap_assertion do
           full_message = build_message(nil, "<?>\ngiven as the operator for #assert_not_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
           assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
           full_message = build_message(message, <<EOT, object1, AssertionMessage.literal(operator), object2)
-<?> expected to not be
+<?> was expected to not be
 ?
 <?>.
 EOT
@@ -635,7 +700,6 @@ EOT
               raise
             end
           end
-          nil
         end
       end
 
@@ -649,14 +713,14 @@ EOT
       end
 
       ##
-      # Passes if ! +actual+ .equal? +expected+
+      # Passes if ! `actual` .equal? `expected`
       #
       # @example
       #   assert_not_same Object.new, Object.new
-      def assert_not_same(expected, actual, message="")
+      def assert_not_same(expected, actual, message=nil)
         full_message = build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__)
 <?>
-with id <?> expected to not be equal\\? to
+with id <?> was expected to not be equal\\? to
 <?>
 with id <?>.
 EOT
@@ -669,12 +733,14 @@ EOT
       alias_method :refute_same, :assert_not_same
 
       ##
-      # Passes if +expected+ != +actual+
+      # Passes if `expected` != `actual`
       #
       # @example
       #   assert_not_equal 'some string', 5
-      def assert_not_equal(expected, actual, message="")
-        full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
+      def assert_not_equal(expected, actual, message=nil)
+        full_message = build_message(message,
+                                     "<?> was expected to be != to\n<?>.",
+                                     expected, actual)
         assert_block(full_message) { expected != actual }
       end
 
@@ -684,12 +750,14 @@ EOT
       alias_method :refute_equal, :assert_not_equal
 
       ##
-      # Passes if ! +object+ .nil?
+      # Passes if ! `object` .nil?
       #
       # @example
       #   assert_not_nil '1 two 3'.sub!(/two/, '2')
-      def assert_not_nil(object, message="")
-        full_message = build_message(message, "<?> expected to not be nil.", object)
+      def assert_not_nil(object, message=nil)
+        full_message = build_message(message,
+                                     "<?> was expected to not be nil.",
+                                     object)
         assert_block(full_message){!object.nil?}
       end
 
@@ -699,20 +767,18 @@ EOT
       alias_method :refute_nil, :assert_not_nil
 
       ##
-      # Passes if +regexp+ !~ +string+
+      # Passes if `regexp` !~ `string`
       #
       # @example
       #   assert_not_match(/two/, 'one 2 three')   # -> pass
       #   assert_not_match(/three/, 'one 2 three') # -> fail
-      def assert_not_match(regexp, string, message="")
+      def assert_not_match(pattern, string, message=nil)
         _wrap_assertion do
-          assert_instance_of(Regexp, regexp,
-                             "<REGEXP> in assert_not_match(<REGEXP>, ...) " +
-                             "should be a Regexp.")
+          pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
           full_message = build_message(message,
-                                       "<?> expected to not match\n<?>.",
-                                       regexp, string)
-          assert_block(full_message) { regexp !~ string }
+                                       "<?> was expected to not match\n<?>.",
+                                       pattern, string)
+          assert_block(full_message) { pattern !~ string }
         end
       end
 
@@ -722,9 +788,9 @@ EOT
       alias_method :refute_match, :assert_not_match
 
       ##
-      # Deprecated. Use #assert_not_match instead.
+      # @deprecated Use {#assert_not_match} instead.
       #
-      # Passes if +regexp+ !~ +string+
+      # Passes if `regexp` !~ `string`
       #
       # @example
       #   assert_no_match(/two/, 'one 2 three')   # -> pass
@@ -782,13 +848,13 @@ EOT
       end
 
       ##
-      # Passes if the block throws +expected_object+
+      # Passes if the block throws `expected_object`
       #
       # @example
       #   assert_throw(:done) do
       #     throw(:done)
       #   end
-      def assert_throw(expected_object, message="", &proc)
+      def assert_throw(expected_object, message=nil, &proc)
         _wrap_assertion do
           begin
             catch([]) {}
@@ -814,7 +880,7 @@ EOT
             tag = extractor.extract_tag
             raise if tag.nil?
             full_message = build_message(message,
-                                         "<?> expected to be thrown but\n" +
+                                         "<?> was expected to be thrown but\n" +
                                          "<?> was thrown.",
                                          expected_object, tag)
             flunk(full_message)
@@ -834,7 +900,7 @@ EOT
       #  assert_nothing_thrown do
       #    [1, 2].uniq
       #  end
-      def assert_nothing_thrown(message="", &proc)
+      def assert_nothing_thrown(message=nil, &proc)
         _wrap_assertion do
           assert(block_given?, "Should have passed a block to assert_nothing_thrown")
           begin
@@ -853,29 +919,51 @@ EOT
       end
 
       ##
-      # Passes if +expected_float+ and +actual_float+ are equal
-      # within +delta+ tolerance.
+      # Passes if `expected_float` and `actual_float` are equal
+      # within `delta` tolerance.
       #
       # @example
       #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
       def assert_in_delta(expected_float, actual_float, delta=0.001, message="")
         _wrap_assertion do
-          _assert_in_delta_validate_arguments(expected_float,
-                                              actual_float,
-                                              delta)
-          full_message = _assert_in_delta_message(expected_float,
-                                                  actual_float,
-                                                  delta,
-                                                  message)
+          begin
+            pass = delta >= (expected_float - actual_float).abs
+            assert_operator(delta, :>=, 0.0, "The delta should not be negative")
+            full_message = _assert_in_delta_message(expected_float,
+                                                    expected_float,
+                                                    actual_float,
+                                                    actual_float,
+                                                    delta,
+                                                    delta,
+                                                    message)
+          rescue Test::Unit::AssertionFailedError
+            # for the above assert_operator
+            raise
+          rescue
+            _assert_in_delta_validate_arguments(expected_float,
+                                                actual_float,
+                                                delta)
+            normalized_expected = expected_float.to_f
+            normalized_actual = actual_float.to_f
+            normalized_delta = delta.to_f
+            pass = (normalized_expected - normalized_actual).abs <= normalized_delta
+            full_message = _assert_in_delta_message(expected_float,
+                                                    normalized_expected,
+                                                    actual_float,
+                                                    normalized_actual,
+                                                    delta,
+                                                    normalized_delta,
+                                                    message)
+          end
           assert_block(full_message) do
-            (expected_float.to_f - actual_float.to_f).abs <= delta.to_f
+            pass
           end
         end
       end
 
       ##
-      # Passes if +expected_float+ and +actual_float+ are
-      # not equal within +delta+ tolerance.
+      # Passes if `expected_float` and `actual_float` are
+      # not equal within `delta` tolerance.
       #
       # @example
       #   assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00002) # -> pass
@@ -885,13 +973,32 @@ EOT
           _assert_in_delta_validate_arguments(expected_float,
                                               actual_float,
                                               delta)
-          full_message = _assert_in_delta_message(expected_float,
-                                                  actual_float,
-                                                  delta,
-                                                  message,
-                                                  :negative_assertion => true)
+          begin
+            pass = (expected_float - actual_float).abs > delta
+            full_message = _assert_in_delta_message(expected_float,
+                                                    expected_float,
+                                                    actual_float,
+                                                    actual_float,
+                                                    delta,
+                                                    delta,
+                                                    message,
+                                                    :negative_assertion => true)
+          rescue
+            normalized_expected = expected_float.to_f
+            normalized_actual = actual_float.to_f
+            normalized_delta = delta.to_f
+            pass = (normalized_expected - normalized_actual).abs > normalized_delta
+            full_message = _assert_in_delta_message(expected_float,
+                                                    normalized_expected,
+                                                    actual_float,
+                                                    normalized_actual,
+                                                    delta,
+                                                    normalized_delta,
+                                                    message,
+                                                    :negative_assertion => true)
+          end
           assert_block(full_message) do
-            (expected_float.to_f - actual_float.to_f).abs > delta.to_f
+            pass
           end
         end
       end
@@ -918,23 +1025,22 @@ EOT
         assert_operator(delta, :>=, 0.0, "The delta should not be negative")
       end
 
-      def _assert_in_delta_message(expected_float, actual_float, delta,
+      def _assert_in_delta_message(expected_float, normalized_expected,
+                                   actual_float, normalized_actual,
+                                   delta, normalized_delta,
                                    message, options={})
         if options[:negative_assertion]
           format = <<-EOT
-<?> -/+ <?> expected to not include
+<?> -/+ <?> was expected to not include
 <?>.
 EOT
         else
           format = <<-EOT
-<?> -/+ <?> expected to include
+<?> -/+ <?> was expected to include
 <?>.
 EOT
         end
         arguments = [expected_float, delta, actual_float]
-        normalized_expected = expected_float.to_f
-        normalized_actual = actual_float.to_f
-        normalized_delta = delta.to_f
         relation_format = nil
         relation_arguments = nil
         if normalized_actual < normalized_expected - normalized_delta
@@ -961,7 +1067,7 @@ EOT
         end
 
         if relation_format
-          format << <<-EOT
+          format += <<-EOT
 
 Relation:
 #{relation_format}
@@ -974,8 +1080,8 @@ EOT
 
       public
       ##
-      # Passes if +expected_float+ and +actual_float+ are equal
-      # within +epsilon+ relative error of +expected_float+.
+      # Passes if `expected_float` and `actual_float` are equal
+      # within `epsilon` relative error of `expected_float`.
       #
       # @example
       #   assert_in_epsilon(10000.0, 9900.0, 0.1) # -> pass
@@ -983,30 +1089,60 @@ EOT
       def assert_in_epsilon(expected_float, actual_float, epsilon=0.001,
                             message="")
         _wrap_assertion do
-          _assert_in_epsilon_validate_arguments(expected_float,
-                                                actual_float,
-                                                epsilon)
-          full_message = _assert_in_epsilon_message(expected_float,
-                                                    actual_float,
-                                                    epsilon,
-                                                    message)
-          assert_block(full_message) do
-            normalized_expected_float = expected_float.to_f
-            if normalized_expected_float.zero?
-              delta = epsilon.to_f ** 2
+          begin
+            zero_p = expected_float.zero? rescue expected_float == 0
+            if zero_p
+              delta = epsilon ** 2
+            else
+              delta = expected_float * epsilon
+            end
+            delta = delta.abs
+            pass = (expected_float - actual_float).abs <= delta
+            assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
+            full_message = _assert_in_epsilon_message(expected_float,
+                                                      expected_float,
+                                                      actual_float,
+                                                      actual_float,
+                                                      epsilon,
+                                                      epsilon,
+                                                      delta,
+                                                      message)
+          rescue Test::Unit::AssertionFailedError
+            # for the above assert_operator
+            raise
+          rescue
+            _assert_in_epsilon_validate_arguments(expected_float,
+                                                  actual_float,
+                                                  epsilon)
+            normalized_expected = expected_float.to_f
+            normalized_actual = actual_float.to_f
+            normalized_epsilon = epsilon.to_f
+            if normalized_expected.zero?
+              delta = normalized_epsilon ** 2
             else
-              delta = normalized_expected_float * epsilon.to_f
+              delta = normalized_expected * normalized_epsilon
             end
             delta = delta.abs
-            (normalized_expected_float - actual_float.to_f).abs <= delta
+            full_message = _assert_in_epsilon_message(expected_float,
+                                                      normalized_expected,
+                                                      actual_float,
+                                                      normalized_actual,
+                                                      epsilon,
+                                                      normalized_epsilon,
+                                                      delta,
+                                                      message)
+            pass = (normalized_expected - normalized_actual).abs <= delta
+          end
+          assert_block(full_message) do
+            pass
           end
         end
       end
 
       ##
-      # Passes if +expected_float+ and +actual_float+ are
-      # not equal within +epsilon+ relative error of
-      # +expected_float+.
+      # Passes if `expected_float` and `actual_float` are
+      # not equal within `epsilon` relative error of
+      # `expected_float`.
       #
       # @example
       #   assert_not_in_epsilon(10000.0, 9900.0, 0.1) # -> fail
@@ -1014,18 +1150,43 @@ EOT
       def assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001,
                                 message="")
         _wrap_assertion do
-          _assert_in_epsilon_validate_arguments(expected_float,
-                                                actual_float,
-                                                epsilon)
-          full_message = _assert_in_epsilon_message(expected_float,
-                                                    actual_float,
-                                                    epsilon,
-                                                    message,
-                                                    :negative_assertion => true)
+          begin
+            delta = expected_float * epsilon
+            pass = (expected_float - actual_float).abs > delta
+            assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
+            full_message = _assert_in_epsilon_message(expected_float,
+                                                      expected_float,
+                                                      actual_float,
+                                                      actual_float,
+                                                      epsilon,
+                                                      epsilon,
+                                                      delta,
+                                                      message,
+                                                      :negative_assertion => true)
+          rescue Test::Unit::AssertionFailedError
+            # for the above assert_operator
+            raise
+          rescue
+            _assert_in_epsilon_validate_arguments(expected_float,
+                                                  actual_float,
+                                                  epsilon)
+            normalized_expected = expected_float.to_f
+            normalized_actual = actual_float.to_f
+            normalized_epsilon = epsilon.to_f
+            delta = normalized_expected * normalized_epsilon
+            pass = (normalized_expected - normalized_actual).abs > delta
+            full_message = _assert_in_epsilon_message(expected_float,
+                                                      normalized_expected,
+                                                      actual_float,
+                                                      normalized_actual,
+                                                      epsilon,
+                                                      normalized_epsilon,
+                                                      delta,
+                                                      message,
+                                                      :negative_assertion => true)
+          end
           assert_block(full_message) do
-            normalized_expected_float = expected_float.to_f
-            delta = normalized_expected_float * epsilon.to_f
-            (normalized_expected_float - actual_float.to_f).abs > delta
+            pass
           end
         end
       end
@@ -1052,21 +1213,18 @@ EOT
         assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
       end
 
-      def _assert_in_epsilon_message(expected_float, actual_float, epsilon,
-                                     message, options={})
-        normalized_expected = expected_float.to_f
-        normalized_actual = actual_float.to_f
-        normalized_epsilon = epsilon.to_f
-        delta = normalized_expected * normalized_epsilon
-
+      def _assert_in_epsilon_message(expected_float, normalized_expected,
+                                     actual_float, normalized_actual,
+                                     epsilon, normalized_epsilon,
+                                     delta, message, options={})
         if options[:negative_assertion]
           format = <<-EOT
-<?> -/+ (<?> * <?>)[?] expected to not include
+<?> -/+ (<?> * <?>)[?] was expected to not include
 <?>.
 EOT
         else
           format = <<-EOT
-<?> -/+ (<?> * <?>)[?] expected to include
+<?> -/+ (<?> * <?>)[?] was expected to include
 <?>.
 EOT
         end
@@ -1099,7 +1257,7 @@ EOT
         end
 
         if relation_format
-          format << <<-EOT
+          format += <<-EOT
 
 Relation:
 #{relation_format}
@@ -1112,9 +1270,9 @@ EOT
 
       public
       ##
-      # Passes if the method send returns a true value.
+      # Passes if the method `__send__` returns not false nor nil.
       #
-      # +send_array+ is composed of:
+      # `send_array` is composed of:
       # * A receiver
       # * A method
       # * Arguments to the method
@@ -1131,7 +1289,7 @@ EOT
                           "assert_send requires at least a receiver " +
                           "and a message name")
           format = <<EOT
-<?> expected to respond to
+<?> was expected to respond to
 <?(*?)> with a true value but was
 <?>.
 EOT
@@ -1152,9 +1310,9 @@ EOT
       end
 
       ##
-      # Passes if the method send doesn't return a true value.
+      # Passes if the method `__send__` returns false or nil.
       #
-      # +send_array+ is composed of:
+      # `send_array` is composed of:
       # * A receiver
       # * A method
       # * Arguments to the method
@@ -1171,7 +1329,7 @@ EOT
                           "assert_not_send requires at least a receiver " +
                           "and a message name")
           format = <<EOT
-<?> expected to respond to
+<?> was expected to respond to
 <?(*?)> with not a true value but was
 <?>.
 EOT
@@ -1192,7 +1350,7 @@ EOT
       end
 
       ##
-      # Passes if +actual+ is a boolean value.
+      # Passes if `actual` is a boolean value.
       #
       # @example
       #   assert_boolean(true) # -> pass
@@ -1202,13 +1360,13 @@ EOT
           assert_block(build_message(message,
                                      "<true> or <false> expected but was\n<?>",
                                      actual)) do
-            [true, false].include?(actual)
+            true == actual || false == actual
           end
         end
       end
 
       ##
-      # Passes if +actual+ is true.
+      # Passes if `actual` is true.
       #
       # @example
       #   assert_true(true)  # -> pass
@@ -1218,13 +1376,13 @@ EOT
           assert_block(build_message(message,
                                      "<true> expected but was\n<?>",
                                      actual)) do
-            actual == true
+            true == actual
           end
         end
       end
 
       ##
-      # Passes if +actual+ is false.
+      # Passes if `actual` is false.
       #
       # @example
       #   assert_false(false)  # -> pass
@@ -1234,14 +1392,14 @@ EOT
           assert_block(build_message(message,
                                      "<false> expected but was\n<?>",
                                      actual)) do
-            actual == false
+            false == actual
           end
         end
       end
 
       ##
-      # Passes if expression "+expected+ +operator+
-      # +actual+" is true.
+      # Passes if expression "`expected` `operator`
+      # `actual`" is not false nor nil.
       #
       # @example
       #   assert_compare(1, "<", 10)  # -> pass
@@ -1261,7 +1419,7 @@ EOT
           end
           template = <<-EOT
 <?> #{operator} <?> should be true
-<?> expected #{operator_description}
+<?> was expected to be #{operator_description}
 <?>.
 EOT
           full_message = build_message(message, template,
@@ -1296,7 +1454,7 @@ EOT
 
       ##
       # Passes if an exception is raised in block and its
-      # message is +expected+.
+      # message is `expected`.
       #
       # @example
       #   assert_raise_message("exception") {raise "exception"}  # -> pass
@@ -1306,7 +1464,7 @@ EOT
       def assert_raise_message(expected, message=nil)
         _wrap_assertion do
           full_message = build_message(message,
-                                       "<?> exception message expected " +
+                                       "<?> exception message was expected " +
                                        "but none was thrown.",
                                        expected)
           exception = nil
@@ -1336,7 +1494,7 @@ EOT
       end
 
       ##
-      # Passes if +object+.const_defined?(+constant_name+)
+      # Passes if `object`.const_defined?(`constant_name`)
       #
       # @example
       #   assert_const_defined(Test, :Unit)          # -> pass
@@ -1353,7 +1511,7 @@ EOT
       end
 
       ##
-      # Passes if !+object+.const_defined?(+constant_name+)
+      # Passes if !`object`.const_defined?(`constant_name`)
       #
       # @example
       #   assert_not_const_defined(Object, :Nonexistent) # -> pass
@@ -1370,7 +1528,7 @@ EOT
       end
 
       ##
-      # Passes if +object+.+predicate+ is _true_.
+      # Passes if `object`.`predicate` is not false nor nil.
       #
       # @example
       #   assert_predicate([], :empty?)  # -> pass
@@ -1392,7 +1550,7 @@ EOT
       end
 
       ##
-      # Passes if +object+.+predicate+ is not _true_.
+      # Passes if `object`.`predicate` is false or nil.
       #
       # @example
       #   assert_not_predicate([1], :empty?) # -> pass
@@ -1419,8 +1577,8 @@ EOT
       alias_method :refute_predicate, :assert_not_predicate
 
       ##
-      # Passes if +object+#+alias_name+ is an alias method of
-      # +object+#+original_name+.
+      # Passes if `object`#`alias_name` is an alias method of
+      # `object`#`original_name`.
       #
       # @example
       #   assert_alias_method([], :length, :size)  # -> pass
@@ -1467,7 +1625,7 @@ EOT
       end
 
       ##
-      # Passes if +path+ exists.
+      # Passes if `path` exists.
       #
       # @example
       #   assert_path_exist("/tmp")          # -> pass
@@ -1476,7 +1634,7 @@ EOT
       def assert_path_exist(path, message=nil)
         _wrap_assertion do
           failure_message = build_message(message,
-                                          "<?> expected to exist",
+                                          "<?> was expected to exist",
                                           path)
           assert_block(failure_message) do
             File.exist?(path)
@@ -1485,7 +1643,7 @@ EOT
       end
 
       ##
-      # Passes if +path+ doesn't exist.
+      # Passes if `path` doesn't exist.
       #
       # @example
       #   assert_path_not_exist("/nonexistent")  # -> pass
@@ -1494,7 +1652,7 @@ EOT
       def assert_path_not_exist(path, message=nil)
         _wrap_assertion do
           failure_message = build_message(message,
-                                          "<?> expected to not exist",
+                                          "<?> was expected to not exist",
                                           path)
           assert_block(failure_message) do
             not File.exist?(path)
@@ -1503,7 +1661,7 @@ EOT
       end
 
       ##
-      # Passes if +collection+ includes +object+.
+      # Passes if `collection` includes `object`.
       #
       # @example
       #   assert_include([1, 10], 1)            # -> pass
@@ -1515,7 +1673,7 @@ EOT
           assert_respond_to(collection, :include?,
                             "The collection must respond to :include?.")
           full_message = build_message(message,
-                                       "<?> expected to include\n<?>.",
+                                       "<?> was expected to include\n<?>.",
                                        collection,
                                        object)
           assert_block(full_message) do
@@ -1530,7 +1688,7 @@ EOT
       alias_method :assert_includes, :assert_include
 
       ##
-      # Passes if +collection+ doesn't include +object+.
+      # Passes if `collection` doesn't include `object`.
       #
       # @example
       #   assert_not_include([1, 10], 5)            # -> pass
@@ -1542,7 +1700,7 @@ EOT
           assert_respond_to(collection, :include?,
                             "The collection must respond to :include?.")
           full_message = build_message(message,
-                                       "<?> expected to not include\n<?>.",
+                                       "<?> was expected to not include\n<?>.",
                                        collection,
                                        object)
           assert_block(full_message) do
@@ -1562,7 +1720,7 @@ EOT
       alias_method :refute_includes, :assert_not_include
 
       ##
-      # Passes if +object+ is empty.
+      # Passes if `object` is empty.
       #
       # @example
       #   assert_empty("")                       # -> pass
@@ -1576,7 +1734,7 @@ EOT
           assert_respond_to(object, :empty?,
                             "The object must respond to :empty?.")
           full_message = build_message(message,
-                                       "<?> expected to be empty.",
+                                       "<?> was expected to be empty.",
                                        object)
           assert_block(full_message) do
             object.empty?
@@ -1585,7 +1743,7 @@ EOT
       end
 
       ##
-      # Passes if +object+ is not empty.
+      # Passes if `object` is not empty.
       #
       # @example
       #   assert_not_empty(" ")                      # -> pass
@@ -1599,7 +1757,7 @@ EOT
           assert_respond_to(object, :empty?,
                             "The object must respond to :empty?.")
           full_message = build_message(message,
-                                       "<?> expected to not be empty.",
+                                       "<?> was expected to not be empty.",
                                        object)
           assert_block(full_message) do
             not object.empty?
@@ -1612,12 +1770,140 @@ EOT
       # @since 3.0.0
       alias_method :refute_empty, :assert_not_empty
 
+      # @overload assert_all(collection, message=nil, &block)
+      #
+      #   Asserts that all `block.call(item)` where `item` is each
+      #   item in `collection` are not false nor nil.
+      #
+      #   If `collection` is empty, this assertion is always passed
+      #   with any `block`.
+      #
+      #   @example Pass patterns
+      #     assert_all([1, 2, 3]) {|item| item > 0} # => pass
+      #     assert_all([1, 2, 3], &:positive?)      # => pass
+      #     assert_all([]) {|item| false}           # => pass
+      #
+      #   @example Failure pattern
+      #     assert_all([0, 1, 2], &:zero?) # => failure
+      #
+      #   @param [#each] collection The check target.
+      #   @param [String] message The additional user message. It is
+      #     showed when the assertion is failed.
+      #   @yield [Object] Give each item in `collection` to the block.
+      #   @yieldreturn [Object] The checked object.
+      #   @return [void]
+      #
+      # @since 3.4.4
+      def assert_all(collection, message=nil)
+        _wrap_assertion do
+          failed = false
+          result = {}
+          collection.each do |item|
+            element_result = yield(item)
+            failed = true unless element_result
+            result[item] = element_result
+          end
+          format = <<-FORMAT
+<?> was expected to be all true values with the given block but was
+<?>
+          FORMAT
+          full_message = build_message(message,
+                                       format,
+                                       collection,
+                                       result)
+          assert_block(full_message) do
+            not failed
+          end
+        end
+      end
+
+      # Just for Ruby's tool/lib/test/unit compatibility.
+      #
+      # @since 3.4.3
+      alias_method :assert_all?, :assert_all
+
+      # @overload assert_nothing_leaked_memory(max_increasable_size, target=:physical, message=nil, &block)
+      #
+      #   Asserts that increased memory usage by `block.call` is less
+      #   than `max_increasable_size`. `GC.start` is called before and
+      #   after `block.call`.
+      #
+      #   This assertion may be fragile. Because memory usage is
+      #   depends on the current Ruby process's memory
+      #   usage. Launching a new Ruby process for this will produce
+      #   more stable result but we need to specify target code as
+      #   `String` instead of block for the approach. We choose easy
+      #   to write API approach rather than more stable result
+      #   approach for this case.
+      #
+      #   @example Pass pattern
+      #     require "objspace"
+      #     size_per_object = ObjectSpace.memsize_of("Hello")
+      #     # If memory isn't leaked, physical memory of almost created objects
+      #     # (1000 - 10 objects) must be freed.
+      #     assert_nothing_leaked_memory(size_per_object * 10) do
+      #       1_000.times do
+      #         "Hello".dup
+      #       end
+      #     end # => pass
+      #
+      #   @example Failure pattern
+      #     require "objspace"
+      #     size_per_object = ObjectSpace.memsize_of("Hello")
+      #     strings = []
+      #     assert_nothing_leaked_memory(size_per_object * 10) do
+      #       10_000.times do
+      #         # Created objects aren't GC-ed because they are referred.
+      #         strings << "Hello".dup
+      #       end
+      #     end # => failure
+      #
+      #   @param target [:physical, :virtual] which memory usage is
+      #     used for comparing. `:physical` means physical memory usage
+      #     also known as Resident Set Size (RSS). `:virtual` means
+      #     virtual memory usage.
+      #   @yield [] do anything you want to measure memory usage
+      #     in the block.
+      #   @yieldreturn [void]
+      #   @return [void]
+      #
+      # @since 3.4.5
+      def assert_nothing_leaked_memory(max_increasable_size,
+                                       target=:physical,
+                                       message=nil)
+        _wrap_assertion do
+          GC.start
+          before = Util::MemoryUsage.new
+          unless before.collected?
+            omit("memory usage collection isn't supported on this platform")
+          end
+          yield
+          GC.start
+          after = Util::MemoryUsage.new
+          before_value = before.__send__(target)
+          after_value = after.__send__(target)
+          actual_increased_size = after_value - before_value
+          template = <<-TEMPLATE
+<?> was expected to be less than
+<?>.
+          TEMPLATE
+          full_message = build_message(message,
+                                       template,
+                                       actual_increased_size,
+                                       max_increasable_size)
+          assert_block(full_message) do
+            actual_increased_size < max_increasable_size
+          end
+        end
+      end
+
       ##
-      # Builds a failure message.  +head+ is added before the +template+ and
-      # +arguments+ replaces the '?'s positionally in the template.
-      def build_message(head, template=nil, *arguments)
+      # Builds a failure message.  `user_message` is added before the
+      # `template` and `arguments` replaces the '?'s positionally in
+      # the template.
+      def build_message(user_message, template=nil, *arguments)
         template &&= template.chomp
-        return AssertionMessage.new(head, template, arguments)
+        return AssertionMessage.new(user_message, template, arguments)
       end
 
       private
@@ -1667,7 +1953,7 @@ EOT
           expected = assert_exception_helper.expected_exceptions
           actual_exception = nil
           full_message = build_message(message,
-                                       "<?> exception expected " +
+                                       "<?> exception was expected " +
                                        "but none was thrown.",
                                        expected)
           assert_block(full_message) do
@@ -1684,12 +1970,11 @@ EOT
         end
       end
 
-      def _set_failed_information(failure, expected, actual, user_message)
+      def _set_failed_information(failure, expected, actual)
         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
@@ -1776,7 +2061,7 @@ EOT
 
               if Diff.need_fold?(diff)
                 folded_diff = Diff.folded_readable(from, to)
-                diff << "\n\nfolded diff:\n#{folded_diff}"
+                diff += "\n\nfolded diff:\n#{folded_diff}"
               end
 
               diff
@@ -1790,9 +2075,9 @@ EOT
             inspector = Inspector.new(object)
             if use_pp
               begin
-                require 'pp' unless defined?(PP)
+                require "pp" unless defined?(PP)
                 begin
-                  return PP.pp(inspector, '').chomp
+                  return PP.pp(inspector, String.new).chomp
                 rescue NameError
                 end
               rescue LoadError
@@ -2041,34 +2326,34 @@ EOT
             expanded_template = ""
             @parts.each do |part|
               if part == '?'
-                encoding_safe_concat(expanded_template, params.shift)
+                param = params.shift
+                if Object.const_defined?(:Encoding)
+                  expanded_template += concatenatable(param,
+                                                      expanded_template.encoding)
+                else
+                  expanded_template += param
+                end
               else
-                expanded_template << part.gsub(/\\\?/m, '?')
+                expanded_template += part.gsub(/\\\?/m, '?')
               end
             end
             expanded_template
           end
 
           private
-          if Object.const_defined?(:Encoding)
-            def encoding_safe_concat(buffer, parameter)
-              if Encoding.compatible?(buffer, parameter)
-                buffer << parameter
-              else
-                buffer << parameter.dup.force_encoding(buffer.encoding)
-              end
-            end
-          else
-            def encoding_safe_concat(buffer, parameter)
-              buffer << parameter
+          def concatenatable(text, encoding)
+            if Encoding.compatible?(text, encoding)
+              text
+            else
+              text.dup.force_encoding(encoding)
             end
           end
         end
 
         include Util::BacktraceFilter
 
-        def initialize(head, template_string, parameters)
-          @head = head
+        def initialize(user_message, template_string, parameters)
+          @user_message = user_message
           @template_string = template_string
           @parameters = parameters
         end
@@ -2081,24 +2366,28 @@ EOT
           @template ||= Template.create(@template_string)
         end
 
-        def add_period(string)
-          (string =~ /\.\Z/ ? string : string + '.')
+        def user_message
+          return nil unless @user_message
+          message = @user_message
+          message = message.call if message.respond_to?(:call)
+          message.to_s
         end
 
         def to_s
           message_parts = []
-          if (@head)
-            head = @head
-            head = head.call if head.respond_to?(:call)
-            head = head.to_s
-            unless(head.empty?)
-              message_parts << add_period(head)
-            end
+          head = user_message
+          if head and not head.empty?
+            message_parts << add_period(head)
           end
           tail = template.result(@parameters.collect{|e| convert(e)})
           message_parts << tail unless(tail.empty?)
           message_parts.join("\n")
         end
+
+        private
+        def add_period(string)
+          (string =~ /\.\Z/ ? string : string + '.')
+        end
       end
 
       class AssertExceptionHelper
@@ -2110,7 +2399,14 @@ EOT
 
           def inspect
             if default_inspect?
-              "#{@exception.class.inspect}(<#{@exception.message}>)"
+              inspected = "#{@exception.class.inspect}(<#{@exception.message}>)"
+              unless (@exception.backtrace || []).empty?
+                inspected += "\n"
+                @exception.backtrace.each do |trace|
+                  inspected << "#{trace}\n"
+                end
+              end
+              inspected
             else
               @exception.inspect
             end
@@ -2170,19 +2466,45 @@ EOT
           expected_exceptions.each do |exception_type|
             if exception_type.instance_of?(Module)
               exception_modules << exception_type
-            elsif exception_type.is_a?(Exception)
+            elsif exception_object?(exception_type)
               exception_objects << exception_type
-            else
-              @test_case.__send__(:assert,
-                                  Exception >= exception_type,
-                                  "Should expect a class of exception, " +
-                                  "#{exception_type}")
+            elsif exception_class?(exception_type)
               exception_classes << exception_type
+            else
+              full_message =
+                @test_case.__send__(:build_message,
+                                    nil,
+                                    "<?> must be " +
+                                    "a subclass of Exception, " +
+                                    "an object of Exception subclasses " +
+                                    "or a Module",
+                                    exception_type)
+              @test_case.flunk(full_message)
             end
           end
           [exception_classes, exception_modules, exception_objects]
         end
 
+        def exception_object?(exception_type)
+          return true if exception_type.is_a?(Exception)
+
+          if Object.const_defined?(:Java)
+            return true if exception_type.is_a?(Java::JavaLang::Throwable)
+          end
+
+          false
+        end
+
+        def exception_class?(exception_type)
+          return true if exception_type <= Exception
+
+          if Object.const_defined?(:Java)
+            return true if exception_type <= Java::JavaLang::Throwable
+          end
+
+          false
+        end
+
         def expected_class?(actual_exception, equality)
           @expected_classes.any? do |expected_class|
             actual_exception.__send__(equality, expected_class)