test-unit 3.2.9 → 3.5.5

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
@@ -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. :<
       #
@@ -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
@@ -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,7 +424,7 @@ 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
@@ -386,11 +455,11 @@ 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)
 <?> was expected to be nil.
 EOT
@@ -398,7 +467,7 @@ EOT
       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
@@ -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
@@ -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,18 +594,13 @@ 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
+          pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
           full_message = build_message(message,
                                        "<?> was expected to be =~\n<?>.",
                                        pattern, string)
@@ -545,13 +609,13 @@ EOT
       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 <?> was expected to be equal\\? to
@@ -562,13 +626,13 @@ 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)}
@@ -582,16 +646,16 @@ 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)}
@@ -649,11 +713,11 @@ 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 <?> was expected to not be equal\\? to
@@ -669,11 +733,11 @@ 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="")
+      def assert_not_equal(expected, actual, message=nil)
         full_message = build_message(message,
                                      "<?> was expected to be != to\n<?>.",
                                      expected, actual)
@@ -686,11 +750,11 @@ 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="")
+      def assert_not_nil(object, message=nil)
         full_message = build_message(message,
                                      "<?> was expected to not be nil.",
                                      object)
@@ -703,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,
                                        "<?> was expected to not match\n<?>.",
-                                       regexp, string)
-          assert_block(full_message) { regexp !~ string }
+                                       pattern, string)
+          assert_block(full_message) { pattern !~ string }
         end
       end
 
@@ -726,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
@@ -786,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([]) {}
@@ -838,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
@@ -857,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
@@ -889,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
@@ -922,7 +1025,9 @@ 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
@@ -936,9 +1041,6 @@ EOT
 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
@@ -978,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
@@ -987,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
@@ -1018,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
@@ -1056,13 +1213,10 @@ 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
 <?> -/+ (<?> * <?>)[?] was expected to not include
@@ -1116,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
@@ -1156,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
@@ -1196,7 +1350,7 @@ EOT
       end
 
       ##
-      # Passes if +actual+ is a boolean value.
+      # Passes if `actual` is a boolean value.
       #
       # @example
       #   assert_boolean(true) # -> pass
@@ -1206,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
@@ -1222,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
@@ -1238,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
@@ -1300,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
@@ -1340,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
@@ -1357,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
@@ -1374,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
@@ -1396,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
@@ -1423,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
@@ -1471,7 +1625,7 @@ EOT
       end
 
       ##
-      # Passes if +path+ exists.
+      # Passes if `path` exists.
       #
       # @example
       #   assert_path_exist("/tmp")          # -> pass
@@ -1489,7 +1643,7 @@ EOT
       end
 
       ##
-      # Passes if +path+ doesn't exist.
+      # Passes if `path` doesn't exist.
       #
       # @example
       #   assert_path_not_exist("/nonexistent")  # -> pass
@@ -1507,7 +1661,7 @@ EOT
       end
 
       ##
-      # Passes if +collection+ includes +object+.
+      # Passes if `collection` includes `object`.
       #
       # @example
       #   assert_include([1, 10], 1)            # -> pass
@@ -1534,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
@@ -1566,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
@@ -1589,7 +1743,7 @@ EOT
       end
 
       ##
-      # Passes if +object+ is not empty.
+      # Passes if `object` is not empty.
       #
       # @example
       #   assert_not_empty(" ")                      # -> pass
@@ -1616,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
@@ -1688,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
@@ -2071,8 +2352,8 @@ EOT
 
         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
@@ -2085,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
@@ -2114,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