module Test::Unit::Assertions - test-unit: Ruby Standard Library Documentation

# module Test::Unit::Assertions

`Test::Unit::Assertions` contains the standard `Test::Unit` assertions. `Assertions` is included in `Test::Unit::TestCase`.

To include it in your own code and use its functionality, you simply need to rescue `Test::Unit::AssertionFailedError`. Additionally you may override `add_assertion` to get notified whenever an assertion is made.

Notes:

- The message to each assertion, if given, will be propagated with the failure.

- It is easy to add your own assertions based on `assert_block`().

@example Example Custom Assertion

    def deny(boolean, message=nil)
      message = build_message(message, '<?> is not false or nil.', boolean)
      assert_block(message) do
        not boolean
      end
    end

### Constants

NOT_SPECIFIED

  @private

### Public Class Methods

use_pp=(value) click to toggle source

Select whether or not to use the pretty-printer. If this option is set to false before any assertions are made, pp.rb will not be required.

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1939
    def self.use_pp=(value)
      AssertionMessage.use_pp = value
    end

### Public Instance Methods

add_assertion() click to toggle source

Called whenever an assertion is made. Define this in classes that include `Test::Unit::Assertions` to record assertion counts.

This is a public API for developers who extend test-unit.

@return [void]

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1933
    def add_assertion
    end

assert(object=NOT_SPECIFIED, message=nil) { || ... } click to toggle source

@overload assert(object, message=nil)

    Asserts that `object` is not false nor nil.

    Normally, you don't need to use this assertion. Use more
    specific assertions such as #assert_equal and
    #assert_include.

    @example Pass patterns
      assert(true)               # => pass
      assert([1, 2].include?(1)) # => pass

    @example Failure patterns
      assert(nil)                # => failure
      assert(false)              # => failure
      assert([1, 2].include?(5)) # => failure

    @param [Object] object The check target.
    @param [String] message The additional user message. It is
      showed when the assertion is failed.
    @return [void]

@overload assert(message=nil) {}

    Asserts that the givens block returns not false nor nil.

    This style uses Power Assert. It means that you can see each
    object values in method chains on failure. See the following
    example about Power Assert.

    @example Power Assert
      coins = [1, 5, 50]
      target_coin = 10
      assert do
        coins.include?(target_coin)
      end
      # =>
      #  coins.include?(target_coin)
      #  |     |        |
      #  |     |        10
      #  |     false
      #  [1, 5, 50]

    We recommend you to use Power Assert for predicate method
    checks rather than existing assertions such as
    #assert_include and #assert_predicate. Power Assert shows
    useful message for debugging.

    We don't recommend you use Power Assert for equality
    check. You should use #assert_equal for the case. Because
    #assert_equal shows more useful message for debugging.

    @example Pass patterns
      assert {true}               # => pass
      assert {[1, 2].include?(1)} # => pass

    @example Failure patterns
      assert {nil}                # => failure
      assert {false}              # => failure
      assert {[1, 2].include?(5)} # => failure

    @param [String] message The additional user message. It is
      showed when the assertion is failed.
    @yield [] Given no parameters to the block.
    @yieldreturn [Object] The checked object.
    @return [void]

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 134
    def assert(object=NOT_SPECIFIED, message=nil, &block)
      _wrap_assertion do
        have_object = !NOT_SPECIFIED.equal?(object)
        if block
          message = object if have_object
          if defined?(PowerAssert)
            PowerAssert.start(block, :assertion_method => __callee__) do |pa|
              pa_message = AssertionMessage.delayed_literal(&pa.message_proc)
              assertion_message = build_message(message, "?", pa_message)
              assert_block(assertion_message) do
                pa.yield
              end
            end
          else
            assert(yield, message)
          end
        else
          unless have_object
            raise ArgumentError, "wrong number of arguments (0 for 1..2)"
          end
          assertion_message = nil
          case message
          when nil, String, Proc
          when AssertionMessage
            assertion_message = message
          else
            error_message = "assertion message must be String, Proc or "
            error_message += "#{AssertionMessage}: "
            error_message += "<#{message.inspect}>(<#{message.class}>)"
            raise ArgumentError, error_message, filter_backtrace(caller)
          end
          assertion_message ||= build_message(message,
                                              "<?> is not true.",
                                              object)
          assert_block(assertion_message) do
            object
          end
        end
      end
    end

assert_alias_method(object, alias_name, original_name, message=nil) click to toggle source

Passes if ‘object`#`alias_name` is an alias method of `object`#`original_name`.

@example

    assert_alias_method([], :length, :size)  # -> pass
    assert_alias_method([], :size, :length)  # -> pass
    assert_alias_method([], :each, :size)    # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1587
    def assert_alias_method(object, alias_name, original_name, message=nil)
      _wrap_assertion do
        find_method_failure_message = Proc.new do |method_name|
          build_message(message,
                        "<?>.? doesn't exist\n" +
                        "(Class: <?>)",
                        object,
                        AssertionMessage.literal(method_name),
                        object.class)
        end

        alias_method = original_method = nil
        assert_block(find_method_failure_message.call(alias_name)) do
          begin
            alias_method = object.method(alias_name)
            true
          rescue NameError
            false
          end
        end
        assert_block(find_method_failure_message.call(original_name)) do
          begin
            original_method = object.method(original_name)
            true
          rescue NameError
            false
          end
        end

        full_message = build_message(message,
                                     "<?> is alias of\n" +
                                     "<?> expected",
                                     alias_method,
                                     original_method)
        assert_block(full_message) do
          alias_method == original_method
        end
      end
    end

assert_all(collection, message=nil) { |item| ... } click to toggle source

@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

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1797
          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

Also aliased as: assert_all?
assert_all?(collection, message=nil)

Just for Ruby’s tool/lib/test/unit compatibility.

@since 3.4.3

Alias for: assert_all
assert_block(message="assert_block failed.") { || ... } click to toggle source

The assertion upon which all other assertions are based. Passes if the block yields not false nor nil.

@example

    assert_block "Couldn't do the thing" do
      do_the_thing
    end

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 53
    def assert_block(message="assert_block failed.")
      _wrap_assertion do
        if (! yield)
          options = {}
          if message.respond_to?(:user_message)
            options[:user_message] = message.user_message
          end
          raise AssertionFailedError.new(message.to_s, options)
        end
      end
    end

assert_boolean(actual, message=nil) click to toggle source

Passes if ‘actual` is a boolean value.

@example

    assert_boolean(true) # -> pass
    assert_boolean(nil)  # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1358
    def assert_boolean(actual, message=nil)
      _wrap_assertion do
        assert_block(build_message(message,
                                   "<true> or <false> expected but was\n<?>",
                                   actual)) do
          true == actual || false == actual
        end
      end
    end

assert_compare(expected, operator, actual, message=nil) click to toggle source

Passes if expression “‘expected` `operator` `actual`” is not false nor nil.

@example

    assert_compare(1, "<", 10)  # -> pass
    assert_compare(1, ">=", 10) # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1407
          def assert_compare(expected, operator, actual, message=nil)
            _wrap_assertion do
              assert_send([["<", "<=", ">", ">="], :include?, operator.to_s])
              case operator.to_s
              when "<"
                operator_description = "less than"
              when "<="
                operator_description = "less than or equal to"
              when ">"
                operator_description = "greater than"
              when ">="
                operator_description = "greater than or equal to"
              end
              template = <<-EOT
    <?> #{operator} <?> should be true
    <?> was expected to be #{operator_description}
    <?>.
    EOT
              full_message = build_message(message, template,
                                           expected, actual,
                                           expected, actual)
              assert_block(full_message) do
                expected.__send__(operator, actual)
              end
            end
          end

assert_const_defined(object, constant_name, message=nil) click to toggle source

Passes if ‘object`.const_defined?(`constant_name`)

@example

    assert_const_defined(Test, :Unit)          # -> pass
    assert_const_defined(Object, :Nonexistent) # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1502
    def assert_const_defined(object, constant_name, message=nil)
      _wrap_assertion do
        full_message = build_message(message,
                                     "<?>.const_defined\\?(<?>) expected.",
                                     object, constant_name)
        assert_block(full_message) do
          object.const_defined?(constant_name)
        end
      end
    end

assert_empty(object, message=nil) click to toggle source

Passes if ‘object` is empty.

@example

    assert_empty("")                       # -> pass
    assert_empty([])                       # -> pass
    assert_empty({})                       # -> pass
    assert_empty(" ")                      # -> fail
    assert_empty([nil])                    # -> fail
    assert_empty({1 => 2})                 # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1732
    def assert_empty(object, message=nil)
      _wrap_assertion do
        assert_respond_to(object, :empty?,
                          "The object must respond to :empty?.")
        full_message = build_message(message,
                                     "<?> was expected to be empty.",
                                     object)
        assert_block(full_message) do
          object.empty?
        end
      end
    end

assert_equal(expected, actual, message=nil) click to toggle source

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 values of expected and actual.

@example

    assert_equal 'MY STRING', 'my string'.upcase

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 225
          def assert_equal(expected, actual, message=nil)
            diff = AssertionMessage.delayed_diff(expected, actual)
            if expected.respond_to?(:encoding) and
                actual.respond_to?(:encoding) and
                expected.encoding != actual.encoding
              format = <<EOT
    <?>(?) expected but was
    <?>(?).?
    EOT
              full_message = build_message(message, format,
                                           expected, expected.encoding.name,
                                           actual, actual.encoding.name,
                                           diff)
            else
              full_message = build_message(message, <<EOT, expected, actual, diff)
    <?> expected but was
    <?>.?
    EOT
            end
            begin
              assert_block(full_message) { expected == actual }
            rescue AssertionFailedError => failure
              _set_failed_information(failure, expected, actual)
              raise failure # For JRuby. :<
            end
          end

assert_fail_assertion(message=nil) { || ... } click to toggle source

Passes if assertion is failed in block.

@example

    assert_fail_assertion {assert_equal("A", "B")}  # -> pass
    assert_fail_assertion {assert_equal("A", "A")}  # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1440
    def assert_fail_assertion(message=nil)
      _wrap_assertion do
        full_message = build_message(message,
                                     "Failed assertion was expected.")
        assert_block(full_message) do
          begin
            yield
            false
          rescue AssertionFailedError
            true
          end
        end
      end
    end

assert_false(actual, message=nil) click to toggle source

Passes if ‘actual` is false.

@example

    assert_false(false)  # -> pass
    assert_false(nil)    # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1390
    def assert_false(actual, message=nil)
      _wrap_assertion do
        assert_block(build_message(message,
                                   "<false> expected but was\n<?>",
                                   actual)) do
          false == actual
        end
      end
    end

assert_in_delta(expected_float, actual_float, delta=0.001, message="") click to toggle source

Passes if ‘expected_float` and `actual_float` are equal within `delta` tolerance.

@example

    assert_in_delta 0.05, (50000.0 / 10**6), 0.00001

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 927
    def assert_in_delta(expected_float, actual_float, delta=0.001, message="")
      _wrap_assertion do
        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
          pass
        end
      end
    end

assert_in_epsilon(expected_float, actual_float, epsilon=0.001, message="") click to toggle source

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
    assert_in_epsilon(10000.0, 9899.0, 0.1) # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1089
    def assert_in_epsilon(expected_float, actual_float, epsilon=0.001,
                          message="")
      _wrap_assertion do
        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 * normalized_epsilon
          end
          delta = delta.abs
          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

assert_include(collection, object, message=nil) click to toggle source

Passes if ‘collection` includes `object`.

@example

    assert_include([1, 10], 1)            # -> pass
    assert_include(1..10, 5)              # -> pass
    assert_include([1, 10], 5)            # -> fail
    assert_include(1..10, 20)             # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1671
    def assert_include(collection, object, message=nil)
      _wrap_assertion do
        assert_respond_to(collection, :include?,
                          "The collection must respond to :include?.")
        full_message = build_message(message,
                                     "<?> was expected to include\n<?>.",
                                     collection,
                                     object)
        assert_block(full_message) do
          collection.include?(object)
        end
      end
    end

Also aliased as: assert_includes
assert_includes(collection, object, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_include
assert_instance_of(klass, object, message=nil) click to toggle source

Passes if ‘object`.instance_of?(`klass`). When `klass` is an array of classes, it passes if any class satisfies +object.instance_of?(class).

@example

    assert_instance_of(String, 'foo')            # -> pass
    assert_instance_of([Fixnum, NilClass], 100)  # -> pass
    assert_instance_of([Numeric, NilClass], 100) # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 391
          def assert_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_instance_of should be " +
                           "a Class or an Array of Class.") do
                klasses.all? {|k| k.is_a?(Class)}
              end
              klass_message = AssertionMessage.maybe_container(klass) do |value|
                "<#{value}>"
              end
              full_message = build_message(message, <<EOT, object, klass_message, object.class)
    <?> was expected to be instance_of\\?
    ? but was
    <?>.
    EOT
              assert_block(full_message) do
                klasses.any? {|k| object.instance_of?(k)}
              end
            end
          end

assert_kind_of(klass, object, message=nil) click to toggle source

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).

@example

    assert_kind_of(Object, 'foo')                # -> pass
    assert_kind_of([Fixnum, NilClass], 100)      # -> pass
    assert_kind_of([Fixnum, NilClass], "string") # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 478
    def assert_kind_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_kind_of should be " +
                     "a kind_of Module or an Array of a kind_of Module.") do
          klasses.all? {|k| k.kind_of?(Module)}
        end
        klass_message = AssertionMessage.maybe_container(klass) do |value|
          "<#{value}>"
        end
        full_message = build_message(message,
                                     "<?> was expected to be kind_of\\?\n" +
                                     "? but was\n" +
                                     "<?>.",
                                     object,
                                     klass_message,
                                     object.class)
        assert_block(full_message) do
          klasses.any? {|k| object.kind_of?(k)}
        end
      end
    end

assert_match(pattern, string, message=nil) click to toggle source

Passes if ‘pattern` =~ `string`.

@example

    assert_match(/\d+/, 'five, 6, seven')

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 601
    def assert_match(pattern, string, message=nil)
      _wrap_assertion do
        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

assert_nil(object, message=nil) click to toggle source

Passes if ‘object`.nil?.

@example

    assert_nil [1, 2].uniq!

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 462
          def assert_nil(object, message=nil)
            full_message = build_message(message, <<EOT, object)
    <?> was expected to be nil.
    EOT
            assert_block(full_message) { object.nil? }
          end

assert_no_match(regexp, string, message="") click to toggle source

@deprecated Use {#assert_not_match} instead.

Passes if ‘regexp` !~ `string`

@example

    assert_no_match(/two/, 'one 2 three')   # -> pass
    assert_no_match(/three/, 'one 2 three') # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 798
    def assert_no_match(regexp, string, message="")
      _wrap_assertion do
        assert_instance_of(Regexp, regexp,
                           "The first argument to assert_no_match " +
                           "should be a Regexp.")
        assert_not_match(regexp, string, message)
      end
    end

assert_not_const_defined(object, constant_name, message=nil) click to toggle source

Passes if !‘object`.const_defined?(`constant_name`)

@example

    assert_not_const_defined(Object, :Nonexistent) # -> pass
    assert_not_const_defined(Test, :Unit)          # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1519
    def assert_not_const_defined(object, constant_name, message=nil)
      _wrap_assertion do
        full_message = build_message(message,
                                     "!<?>.const_defined\\?(<?>) expected.",
                                     object, constant_name)
        assert_block(full_message) do
          !object.const_defined?(constant_name)
        end
      end
    end

assert_not_empty(object, message=nil) click to toggle source

Passes if ‘object` is not empty.

@example

    assert_not_empty(" ")                      # -> pass
    assert_not_empty([nil])                    # -> pass
    assert_not_empty({1 => 2})                 # -> pass
    assert_not_empty("")                       # -> fail
    assert_not_empty([])                       # -> fail
    assert_not_empty({})                       # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1755
    def assert_not_empty(object, message=nil)
      _wrap_assertion do
        assert_respond_to(object, :empty?,
                          "The object must respond to :empty?.")
        full_message = build_message(message,
                                     "<?> was expected to not be empty.",
                                     object)
        assert_block(full_message) do
          not object.empty?
        end
      end
    end

Also aliased as: refute_empty
assert_not_equal(expected, actual, message=nil) click to toggle source

Passes if ‘expected` != `actual`

@example

    assert_not_equal 'some string', 5

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 740
    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

Also aliased as: refute_equal
assert_not_in_delta(expected_float, actual_float, delta=0.001, message="") click to toggle source

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
    assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00001) # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 971
    def assert_not_in_delta(expected_float, actual_float, delta=0.001, message="")
      _wrap_assertion do
        _assert_in_delta_validate_arguments(expected_float,
                                            actual_float,
                                            delta)
        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
          pass
        end
      end
    end

Also aliased as: refute_in_delta
assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001, message="") click to toggle source

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
    assert_not_in_epsilon(10000.0, 9899.0, 0.1) # -> pass

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1150
    def assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001,
                              message="")
      _wrap_assertion do
        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
          pass
        end
      end
    end

Also aliased as: refute_in_epsilon
assert_not_include(collection, object, message=nil) click to toggle source

Passes if ‘collection` doesn’t include ‘object`.

@example

    assert_not_include([1, 10], 5)            # -> pass
    assert_not_include(1..10, 20)             # -> pass
    assert_not_include([1, 10], 1)            # -> fail
    assert_not_include(1..10, 5)              # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1698
    def assert_not_include(collection, object, message=nil)
      _wrap_assertion do
        assert_respond_to(collection, :include?,
                          "The collection must respond to :include?.")
        full_message = build_message(message,
                                     "<?> was expected to not include\n<?>.",
                                     collection,
                                     object)
        assert_block(full_message) do
          not collection.include?(object)
        end
      end
    end

Also aliased as: assert_not_includes, refute_includes
assert_not_includes(collection, object, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_include
assert_not_instance_of(klass, object, message=nil) click to toggle source

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

    assert_not_instance_of(String, 100)                # -> pass
    assert_not_instance_of([Fixnum, NilClass], '100')  # -> pass
    assert_not_instance_of([Numeric, NilClass], 100)   # -> fail

@since 3.0.0

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 427
    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 " +
                     "a Class or an Array of Class.") do
          klasses.all? {|k| k.is_a?(Class)}
        end
        klass_message = AssertionMessage.maybe_container(klass) do |value|
          "<#{value}>"
        end
        full_message = build_message(message,
                                     "<?> was expected to not be instance_of\\?\n" +
                                     "? but was.",
                                     object,
                                     klass_message)
        assert_block(full_message) do
          klasses.none? {|k| object.instance_of?(k)}
        end
      end
    end

Also aliased as: refute_instance_of
assert_not_kind_of(klass, object, message=nil) click to toggle source

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

    assert_not_kind_of(Fixnum, 'foo')           # -> pass
    assert_not_kind_of([Fixnum, NilClass], '0') # -> pass
    assert_not_kind_of([Fixnum, NilClass], 100) # -> fail

@since 3.0.0

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 516
    def assert_not_kind_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_kind_of should be " +
                     "a kind_of Module or an Array of a kind_of Module.") do
          klasses.all? {|k| k.kind_of?(Module)}
        end
        klass_message = AssertionMessage.maybe_container(klass) do |value|
          "<#{value}>"
        end
        full_message = build_message(message,
                                     "<?> was expected to not be kind_of\\?\n" +
                                     "? but was.",
                                     object,
                                     klass_message)
        assert_block(full_message) do
          klasses.none? {|k| object.kind_of?(k)}
        end
      end
    end

Also aliased as: refute_kind_of
assert_not_match(pattern, string, message=nil) click to toggle source

Passes if ‘regexp` !~ `string`

@example

    assert_not_match(/two/, 'one 2 three')   # -> pass
    assert_not_match(/three/, 'one 2 three') # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 775
    def assert_not_match(pattern, string, message=nil)
      _wrap_assertion do
        pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
        full_message = build_message(message,
                                     "<?> was expected to not match\n<?>.",
                                     pattern, string)
        assert_block(full_message) { pattern !~ string }
      end
    end

Also aliased as: refute_match
assert_not_nil(object, message=nil) click to toggle source

Passes if ! ‘object` .nil?

@example

    assert_not_nil '1 two 3'.sub!(/two/, '2')

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 757
    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

Also aliased as: refute_nil
assert_not_operator(object1, operator, object2, message=nil) click to toggle source

Compares the ‘object1` with `object2` using `operator`.

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

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 658
          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)
    <?> was expected to not be
    ?
    <?>.
    EOT
              assert_block(full_message) { ! object1.__send__(operator, object2) }
            end
          end

Also aliased as: refute_operator
assert_not_predicate(object, predicate, message=nil) click to toggle source

Passes if ‘object`.`predicate` is false or nil.

@example

    assert_not_predicate([1], :empty?) # -> pass
    assert_not_predicate([], :empty?)  # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1558
    def assert_not_predicate(object, predicate, message=nil)
      _wrap_assertion do
        assert_respond_to(object, predicate, message)
        actual = object.__send__(predicate)
        full_message = build_message(message,
                                     "<?>.? is false value expected but was\n" +
                                     "<?>",
                                     object,
                                     AssertionMessage.literal(predicate),
                                     actual)
        assert_block(full_message) do
          not actual
        end
      end
    end

Also aliased as: refute_predicate
assert_not_respond_to(object, method, message=nil) click to toggle source

Passes if ‘object` does not .respond_to? `method`.

@example

    assert_not_respond_to('bugbear', :nonexistence) # -> pass
    assert_not_respond_to('bugbear', :size)         # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 574
    def assert_not_respond_to(object, method, message=nil)
      _wrap_assertion do
        full_message = build_message(message,
                                     "<?>.kind_of\\?(Symbol) or\n" +
                                     "<?>.respond_to\\?(:to_str) expected",
                                     method, method)
        assert_block(full_message) do
          method.kind_of?(Symbol) or method.respond_to?(:to_str)
        end
        full_message = build_message(message,
                                     "!<?>.respond_to\\?(?) expected\n" +
                                     "(Class: <?>)",
                                     object, method, object.class)
        assert_block(full_message) {!object.respond_to?(method)}
      end
    end

Also aliased as: refute_respond_to
assert_not_same(expected, actual, message=nil) click to toggle source

Passes if ! ‘actual` .equal? `expected`

@example

    assert_not_same Object.new, Object.new

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 720
          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
    <?>
    with id <?>.
    EOT
            assert_block(full_message) { !actual.equal?(expected) }
          end

Also aliased as: refute_same
assert_not_send(send_array, message=nil) click to toggle source

Passes if the method ‘__send__` returns false or nil.

‘send_array` is composed of:

- A receiver

- A method

- Arguments to the method

@example

    assert_not_send([[1, 2], :member?, 1]) # -> fail
    assert_not_send([[1, 2], :member?, 4]) # -> pass

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1323
          def assert_not_send(send_array, message=nil)
            _wrap_assertion do
              assert_instance_of(Array, send_array,
                                 "assert_not_send requires an array " +
                                 "of send information")
              assert_operator(send_array.size, :>=, 2,
                              "assert_not_send requires at least a receiver " +
                              "and a message name")
              format = <<EOT
    <?> was expected to respond to
    <?(*?)> with not a true value but was
    <?>.
    EOT
              receiver, message_name, *arguments = send_array
              result = nil
              full_message =
                build_message(message,
                              format,
                              receiver,
                              AssertionMessage.literal(message_name.to_s),
                              arguments,
                              AssertionMessage.delayed_literal {result})
              assert_block(full_message) do
                result = receiver.__send__(message_name, *arguments)
                not result
              end
            end
          end

assert_nothing_leaked_memory(max_increasable_size, target=:physical, message=nil) { || ... } click to toggle source

@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

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1871
          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

assert_nothing_raised(*args) { || ... } click to toggle source

Passes if block does not raise an exception.

@example

    assert_nothing_raised do
      [1, 2].uniq
    end

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 683
    def assert_nothing_raised(*args)
      _wrap_assertion do
        if args.last.is_a?(String)
          message = args.pop
        else
          message = ""
        end

        assert_exception_helper = AssertExceptionHelper.new(self, args)
        begin
          yield
        rescue Exception => e
          if ((args.empty? && !e.instance_of?(AssertionFailedError)) ||
              assert_exception_helper.expected?(e))
            failure_message = build_message(message, "Exception raised:\n?", e)
            assert_block(failure_message) {false}
          else
            raise
          end
        end
      end
    end

assert_nothing_thrown(message=nil, &proc) click to toggle source

Passes if block does not throw anything.

@example

    assert_nothing_thrown do
      [1, 2].uniq
    end

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 903
    def assert_nothing_thrown(message=nil, &proc)
      _wrap_assertion do
        assert(block_given?, "Should have passed a block to assert_nothing_thrown")
        begin
          proc.call
        rescue => error
          extractor = ThrowTagExtractor.new(error)
          tag = extractor.extract_tag
          raise if tag.nil?
          full_message = build_message(message,
                                       "<?> was thrown when nothing was expected",
                                       tag)
          flunk(full_message)
        end
        assert(true, "Expected nothing to be thrown")
      end
    end

assert_operator(object1, operator, object2, message=nil) click to toggle source

Compares the ‘object1` with `object2` using `operator`.

Passes if object1.__send__(operator, object2) is not false nor nil.

@example

    assert_operator 5, :>=, 4

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 635
          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)
    <?> was expected to be
    ?
    <?>.
    EOT
              assert_block(full_message) { object1.__send__(operator, object2) }
            end
          end

assert_path_exist(path, message=nil) click to toggle source

Passes if ‘path` exists.

@example

    assert_path_exist("/tmp")          # -> pass
    assert_path_exist("/bin/sh")       # -> pass
    assert_path_exist("/nonexistent")  # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1634
    def assert_path_exist(path, message=nil)
      _wrap_assertion do
        failure_message = build_message(message,
                                        "<?> was expected to exist",
                                        path)
        assert_block(failure_message) do
          File.exist?(path)
        end
      end
    end

assert_path_not_exist(path, message=nil) click to toggle source

Passes if ‘path` doesn’t exist.

@example

    assert_path_not_exist("/nonexistent")  # -> pass
    assert_path_not_exist("/tmp")          # -> fail
    assert_path_not_exist("/bin/sh")       # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1652
    def assert_path_not_exist(path, message=nil)
      _wrap_assertion do
        failure_message = build_message(message,
                                        "<?> was expected to not exist",
                                        path)
        assert_block(failure_message) do
          not File.exist?(path)
        end
      end
    end

assert_predicate(object, predicate, message=nil) click to toggle source

Passes if ‘object`.`predicate` is not false nor nil.

@example

    assert_predicate([], :empty?)  # -> pass
    assert_predicate([1], :empty?) # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1536
    def assert_predicate(object, predicate, message=nil)
      _wrap_assertion do
        assert_respond_to(object, predicate, message)
        actual = object.__send__(predicate)
        full_message = build_message(message,
                                     "<?>.? is true value expected but was\n" +
                                     "<?>",
                                     object,
                                     AssertionMessage.literal(predicate),
                                     actual)
        assert_block(full_message) do
          actual
        end
      end
    end

assert_raise(*args, &block) click to toggle source

Passes if the block raises one of the expected exceptions. When an expected exception is an Exception object, passes if expected_exception == actual_exception.

@example

    assert_raise(RuntimeError, LoadError) do
      raise 'Boom!!!'
    end # -> pass

    assert_raise do
      raise Exception, 'Any exception should be raised!!!'
    end # -> pass

    assert_raise(RuntimeError.new("XXX")) {raise "XXX"} # -> pass
    assert_raise(MyError.new("XXX"))      {raise "XXX"} # -> fail
    assert_raise(RuntimeError.new("ZZZ")) {raise "XXX"} # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 269
    def assert_raise(*args, &block)
      assert_expected_exception = Proc.new do |*_args|
        message, assert_exception_helper, actual_exception = _args
        expected = assert_exception_helper.expected_exceptions
        diff = AssertionMessage.delayed_diff(expected, actual_exception)
        full_message = build_message(message,
                                     "<?> exception expected but was\n<?>.?",
                                     expected, actual_exception, diff)
        begin
          assert_block(full_message) do
            expected == [] or
              assert_exception_helper.expected?(actual_exception)
          end
        rescue AssertionFailedError => failure
          _set_failed_information(failure, expected, actual_exception)
          raise failure # For JRuby. :<
        end
      end
      _assert_raise(assert_expected_exception, *args, &block)
    end

Also aliased as: assert_raises
assert_raise_kind_of(*args, &block) click to toggle source

Passes if the block raises one of the given exceptions or sub exceptions of the given exceptions.

@example

    assert_raise_kind_of(SystemCallError) do
      raise Errno::EACCES
    end

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 366
    def assert_raise_kind_of(*args, &block)
      assert_expected_exception = Proc.new do |*_args|
        message, assert_exception_helper, actual_exception = _args
        expected = assert_exception_helper.expected_exceptions
        full_message = build_message(message,
                                     "<?> family exception expected " +
                                     "but was\n<?>.",
                                     expected, actual_exception)
        assert_block(full_message) do
          assert_exception_helper.expected?(actual_exception, :kind_of?)
        end
      end
      _assert_raise(assert_expected_exception, *args, &block)
    end

assert_raise_message(expected, message=nil) { || ... } click to toggle source

Passes if an exception is raised in block and its message is ‘expected`.

@example

    assert_raise_message("exception") {raise "exception"}  # -> pass
    assert_raise_message(/exc/i) {raise "exception"}       # -> pass
    assert_raise_message("exception") {raise "EXCEPTION"}  # -> fail
    assert_raise_message("exception") {}                   # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1464
    def assert_raise_message(expected, message=nil)
      _wrap_assertion do
        full_message = build_message(message,
                                     "<?> exception message was expected " +
                                     "but none was thrown.",
                                     expected)
        exception = nil
        assert_block(full_message) do
          begin
            yield
            false
          rescue Exception => exception
            true
          end
        end

        actual = exception.message
        diff = AssertionMessage.delayed_diff(expected, actual)
        full_message =
          build_message(message,
                        "<?> exception message expected but was\n" +
                        "<?>.?", expected, actual, diff)
        assert_block(full_message) do
          if expected.is_a?(Regexp)
            expected =~ actual
          else
            expected == actual
          end
        end
      end
    end

assert_raise_with_message(expected_exception_class, expected_message, message=nil, &block) click to toggle source

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

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 318
    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

assert_raises(*args, &block)

Just for minitest compatibility. :<

Alias for: assert_raise
assert_respond_to(object, method, message=nil) click to toggle source

Passes if ‘object` .respond_to? `method`

@example

    assert_respond_to 'bugbear', :slice

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 551
    def assert_respond_to(object, method, message=nil)
      _wrap_assertion do
        full_message = build_message(message,
                                     "<?>.kind_of\\?(Symbol) or\n" +
                                     "<?>.respond_to\\?(:to_str) expected",
                                     method, method)
        assert_block(full_message) do
          method.kind_of?(Symbol) or method.respond_to?(:to_str)
        end
        full_message = build_message(message,
                                     "<?>.respond_to\\?(?) expected\n" +
                                     "(Class: <?>)",
                                     object, method, object.class)
        assert_block(full_message) {object.respond_to?(method)}
      end
    end

assert_same(expected, actual, message=nil) click to toggle source

Passes if ‘actual` .equal? `expected` (i.e. they are the same instance).

@example

    o = Object.new
    assert_same o, o

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 618
          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
    <?>
    with id <?>.
    EOT
            assert_block(full_message) { actual.equal?(expected) }
          end

assert_send(send_array, message=nil) click to toggle source

Passes if the method ‘__send__` returns not false nor nil.

‘send_array` is composed of:

- A receiver

- A method

- Arguments to the method

@example

    assert_send([[1, 2], :member?, 1]) # -> pass
    assert_send([[1, 2], :member?, 4]) # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1283
          def assert_send(send_array, message=nil)
            _wrap_assertion do
              assert_instance_of(Array, send_array,
                                 "assert_send requires an array " +
                                 "of send information")
              assert_operator(send_array.size, :>=, 2,
                              "assert_send requires at least a receiver " +
                              "and a message name")
              format = <<EOT
    <?> was expected to respond to
    <?(*?)> with a true value but was
    <?>.
    EOT
              receiver, message_name, *arguments = send_array
              result = nil
              full_message =
                build_message(message,
                              format,
                              receiver,
                              AssertionMessage.literal(message_name.to_s),
                              arguments,
                              AssertionMessage.delayed_literal {result})
              assert_block(full_message) do
                result = receiver.__send__(message_name, *arguments)
                result
              end
            end
          end

assert_throw(expected_object, message=nil, &proc) click to toggle source

Passes if the block throws ‘expected_object`

@example

    assert_throw(:done) do
      throw(:done)
    end

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 857
    def assert_throw(expected_object, message=nil, &proc)
      _wrap_assertion do
        begin
          catch([]) {}
        rescue TypeError
          assert_instance_of(Symbol, expected_object,
                             "assert_throws expects the symbol that should be thrown for its first argument")
        end
        assert_block("Should have passed a block to assert_throw.") do
          block_given?
        end
        caught = true
        begin
          catch(expected_object) do
            proc.call
            caught = false
          end
          full_message = build_message(message,
                                       "<?> should have been thrown.",
                                       expected_object)
          assert_block(full_message) {caught}
        rescue => error
          extractor = ThrowTagExtractor.new(error)
          tag = extractor.extract_tag
          raise if tag.nil?
          full_message = build_message(message,
                                       "<?> was expected to be thrown but\n" +
                                       "<?> was thrown.",
                                       expected_object, tag)
          flunk(full_message)
        end
      end
    end

Also aliased as: assert_throws
assert_throws(expected_object, message=nil, &proc)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_throw
assert_true(actual, message=nil) click to toggle source

Passes if ‘actual` is true.

@example

    assert_true(true)  # -> pass
    assert_true(:true) # -> fail

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1374
    def assert_true(actual, message=nil)
      _wrap_assertion do
        assert_block(build_message(message,
                                   "<true> expected but was\n<?>",
                                   actual)) do
          true == actual
        end
      end
    end

build_message(user_message, template=nil, *arguments) click to toggle source

Builds a failure message. ‘user_message` is added before the `template` and `arguments` replaces the ’?‘s positionally in the template.

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1904
    def build_message(user_message, template=nil, *arguments)
      template &&= template.chomp
      return AssertionMessage.new(user_message, template, arguments)
    end

flunk(message="Flunked") click to toggle source

Flunk always fails.

@example

    flunk 'Not done testing yet.'

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 711
    def flunk(message="Flunked")
      assert_block(build_message(message)){false}
    end

refute(object, message=nil) click to toggle source

Asserts that ‘object` is false or nil.

@note Just for minitest compatibility. :<

@param [Object] object The object to be asserted. @return [void]

@example Pass patterns

    refute(false)    # => pass
    refute(nil)      # => pass

@example `Failure` patterns

    refute(true)     # => failure
    refute("string") # => failure

@since 2.5.3

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 191
    def refute(object, message=nil)
      _wrap_assertion do
        assertion_message = nil
        case message
        when nil, String, Proc
        when AssertionMessage
          assertion_message = message
        else
          error_message = "assertion message must be String, Proc or "
          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
          !block_given?
        end
        assertion_message ||= build_message(message,
                                            "<?> is neither nil or false.",
                                            object)
        assert_block(assertion_message) do
          not object
        end
      end
    end

refute_empty(object, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_empty
refute_equal(expected, actual, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_equal
refute_in_delta(expected_float, actual_float, delta=0.001, message="")

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_in_delta
refute_in_epsilon(expected_float, actual_float, epsilon=0.001, message="")

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_in_epsilon
refute_includes(collection, object, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_include
refute_instance_of(klass, object, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_instance_of
refute_kind_of(klass, object, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_kind_of
refute_match(pattern, string, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_match
refute_nil(object, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_nil
refute_operator(object1, operator, object2, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_operator
refute_predicate(object, predicate, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_predicate
refute_respond_to(object, method, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_respond_to
refute_same(expected, actual, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_same

### Private Instance Methods

_assert_in_delta_message(expected_float, normalized_expected, actual_float, normalized_actual, delta, normalized_delta, message, options={}) click to toggle source

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1028
          def _assert_in_delta_message(expected_float, normalized_expected,
                                       actual_float, normalized_actual,
                                       delta, normalized_delta,
                                       message, options={})
            if options[:negative_assertion]
              format = <<-EOT
    <?> -/+ <?> was expected to not include
    <?>.
    EOT
            else
              format = <<-EOT
    <?> -/+ <?> was expected to include
    <?>.
    EOT
            end
            arguments = [expected_float, delta, actual_float]
            relation_format = nil
            relation_arguments = nil
            if normalized_actual < normalized_expected - normalized_delta
              relation_format = "<<?> < <?>-<?>[?] <= <?>+<?>[?]>"
              relation_arguments = [actual_float,
                                    expected_float, delta,
                                    normalized_expected - normalized_delta,
                                    expected_float, delta,
                                    normalized_expected + normalized_delta]
            elsif normalized_actual <= normalized_expected + normalized_delta
              relation_format = "<<?>-<?>[?] <= <?> <= <?>+<?>[?]>"
              relation_arguments = [expected_float, delta,
                                    normalized_expected - normalized_delta,
                                    actual_float,
                                    expected_float, delta,
                                    normalized_expected + normalized_delta]
            else
              relation_format = "<<?>-<?>[?] <= <?>+<?>[?] < <?>>"
              relation_arguments = [expected_float, delta,
                                    normalized_expected - normalized_delta,
                                    expected_float, delta,
                                    normalized_expected + normalized_delta,
                                    actual_float]
            end

            if relation_format
              format += <<-EOT

    Relation:
    #{relation_format}
    EOT
              arguments.concat(relation_arguments)
            end

            build_message(message, format, *arguments)
          end

_assert_in_delta_validate_arguments(expected_float, actual_float, delta) click to toggle source

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1012
    def _assert_in_delta_validate_arguments(expected_float,
                                            actual_float,
                                            delta)
      {
        expected_float => "first float",
        actual_float => "second float",
        delta => "delta"
      }.each do |float, name|
        assert_respond_to(float, :to_f,
                          "The arguments must respond to to_f; " +
                          "the #{name} did not")
      end
      delta = delta.to_f
      assert_operator(delta, :>=, 0.0, "The delta should not be negative")
    end

_assert_in_epsilon_message(expected_float, normalized_expected, actual_float, normalized_actual, epsilon, normalized_epsilon, delta, message, options={}) click to toggle source

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1216
          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
    <?>.
    EOT
            else
              format = <<-EOT
    <?> -/+ (<?> * <?>)[?] was expected to include
    <?>.
    EOT
            end
            arguments = [expected_float, expected_float, epsilon, delta,
                         actual_float]

            relation_format = nil
            relation_arguments = nil
            if normalized_actual < normalized_expected - delta
              relation_format = "<<?> < <?>-(<?>*<?>)[?] <= <?>+(<?>*<?>)[?]>"
              relation_arguments = [actual_float,
                                    expected_float, expected_float, epsilon,
                                    normalized_expected - delta,
                                    expected_float, expected_float, epsilon,
                                    normalized_expected + delta]
            elsif normalized_actual <= normalized_expected + delta
              relation_format = "<<?>-(<?>*<?>)[?] <= <?> <= <?>+(<?>*<?>)[?]>"
              relation_arguments = [expected_float, expected_float, epsilon,
                                    normalized_expected - delta,
                                    actual_float,
                                    expected_float, expected_float, epsilon,
                                    normalized_expected + delta]
            else
              relation_format = "<<?>-(<?>*<?>)[?] <= <?>+(<?>*<?>)[?] < <?>>"
              relation_arguments = [expected_float, expected_float, epsilon,
                                    normalized_expected - delta,
                                    expected_float, expected_float, epsilon,
                                    normalized_expected + delta,
                                    actual_float]
            end

            if relation_format
              format += <<-EOT

    Relation:
    #{relation_format}
    EOT
              arguments.concat(relation_arguments)
            end

            build_message(message, format, *arguments)
          end

_assert_in_epsilon_validate_arguments(expected_float, actual_float, epsilon) click to toggle source

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1200
    def _assert_in_epsilon_validate_arguments(expected_float,
                                              actual_float,
                                              epsilon)
      {
        expected_float => "first float",
        actual_float => "second float",
        epsilon => "epsilon"
      }.each do |float, name|
        assert_respond_to(float, :to_f,
                          "The arguments must respond to to_f; " +
                          "the #{name} did not")
      end
      epsilon = epsilon.to_f
      assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
    end

_assert_raise(assert_expected_exception, *args) { || ... } click to toggle source

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1944
    def _assert_raise(assert_expected_exception, *args, &block)
      _wrap_assertion do
        if args.last.is_a?(String)
          message = args.pop
        else
          message = ""
        end

        assert_exception_helper = AssertExceptionHelper.new(self, args)
        expected = assert_exception_helper.expected_exceptions
        actual_exception = nil
        full_message = build_message(message,
                                     "<?> exception was expected " +
                                     "but none was thrown.",
                                     expected)
        assert_block(full_message) do
          begin
            yield
            false
          rescue Exception => actual_exception
            true
          end
        end
        assert_expected_exception.call(message, assert_exception_helper,
                                       actual_exception)
        actual_exception
      end
    end

_set_failed_information(failure, expected, actual) click to toggle source

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1973
    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)
    end

_wrap_assertion(&block) click to toggle source

    # File test-unit-3.6.7/lib/test/unit/assertions.rb, line 1910
    def _wrap_assertion(&block)
      @_assertion_wrapped ||= false
      if @_assertion_wrapped
        block.call
      else
        @_assertion_wrapped = true
        begin
          add_assertion
          block.call
        ensure
          @_assertion_wrapped = false
        end
      end
    end