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)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1934
def self.use_pp=(value)
  AssertionMessage.use_pp = value
end

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.

Public Instance Methods

add_assertion ()

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1928
def add_assertion
end

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]

assert (object=NOT_SPECIFIED, message=nil) { || ... }

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 129
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

@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]

assert_alias_method (object, alias_name, original_name, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1582
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

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

assert_all (collection, message=nil) { |item| ... }

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1792
      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

@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

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.") { || ... }

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 48
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

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

assert_boolean (actual, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1353
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

Passes if ‘actual` is a boolean value.

@example

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

assert_compare (expected, operator, actual, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1402
      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

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

@example

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

assert_const_defined (object, constant_name, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1497
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

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

@example

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

assert_empty (object, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1727
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

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

assert_equal (expected, actual, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 220
      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

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

assert_fail_assertion (message=nil) { || ... }

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1435
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

Passes if assertion is failed in block.

@example

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

assert_false (actual, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1385
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

Passes if ‘actual` is false.

@example

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

assert_in_delta (expected_float, actual_float, delta=0.001, message="")

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 922
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

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

@example

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

assert_in_epsilon (expected_float, actual_float, epsilon=0.001, message="")

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1084
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

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

assert_include (collection, object, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1666
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

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

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)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 386
      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

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

assert_kind_of (klass, object, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 473
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

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

assert_match (pattern, string, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 596
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

Passes if ‘pattern` =~ `string`.

@example

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

assert_nil (object, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 457
      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

Passes if ‘object`.nil?.

@example

assert_nil [1, 2].uniq!

assert_no_match (regexp, string, message="")

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 793
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

@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

assert_not_const_defined (object, constant_name, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1514
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

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

@example

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

assert_not_empty (object, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1750
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

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

Also aliased as: refute_empty

assert_not_equal (expected, actual, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 735
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

Passes if ‘expected` != `actual`

@example

assert_not_equal 'some string', 5

Also aliased as: refute_equal

assert_not_in_delta (expected_float, actual_float, delta=0.001, message="")

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 966
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

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

Also aliased as: refute_in_delta

assert_not_in_epsilon (expected_float, actual_float, epsilon=0.001, message="")

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1145
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

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

Also aliased as: refute_in_epsilon

assert_not_include (collection, object, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1693
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

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

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)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 422
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

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

Also aliased as: refute_instance_of

assert_not_kind_of (klass, object, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 511
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

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

Also aliased as: refute_kind_of

assert_not_match (pattern, string, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 770
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

Passes if ‘regexp` !~ `string`

@example

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

Also aliased as: refute_match

assert_not_nil (object, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 752
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

Passes if ! ‘object` .nil?

@example

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

Also aliased as: refute_nil

assert_not_operator (object1, operator, object2, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 653
      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

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

Also aliased as: refute_operator

assert_not_predicate (object, predicate, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1553
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

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

@example

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

Also aliased as: refute_predicate

assert_not_respond_to (object, method, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 569
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

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

@example

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

Also aliased as: refute_respond_to

assert_not_same (expected, actual, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 715
      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

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

@example

assert_not_same Object.new, Object.new

Also aliased as: refute_same

assert_not_send (send_array, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1318
      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

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

assert_nothing_leaked_memory (max_increasable_size, target=:physical, message=nil) { || ... }

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1866
      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

@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

assert_nothing_raised (*args) { || ... }

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 678
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

Passes if block does not raise an exception.

@example

assert_nothing_raised do
  [1, 2].uniq
end

assert_nothing_thrown (message=nil, &proc)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 898
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

Passes if block does not throw anything.

@example

assert_nothing_thrown do
  [1, 2].uniq
end

assert_operator (object1, operator, object2, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 630
      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

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

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

@example

assert_operator 5, :>=, 4

assert_path_exist (path, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1629
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

Passes if ‘path` exists.

@example

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

assert_path_not_exist (path, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1647
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

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

assert_predicate (object, predicate, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1531
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

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

@example

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

assert_raise (*args, &block)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 264
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

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

Also aliased as: assert_raises

assert_raise_kind_of (*args, &block)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 361
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

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

assert_raise_message (expected, message=nil) { || ... }

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1459
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

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

assert_raise_with_message (expected_exception_class, expected_message, message=nil, &block)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 313
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 ‘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

assert_raises (*args, &block)

Just for minitest compatibility. :<

Alias for: assert_raise

assert_respond_to (object, method, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 546
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

Passes if ‘object` .respond_to? `method`

@example

assert_respond_to 'bugbear', :slice

assert_same (expected, actual, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 613
      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

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

@example

o = Object.new
assert_same o, o

assert_send (send_array, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1278
      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

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

assert_throw (expected_object, message=nil, &proc)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 852
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

Passes if the block throws ‘expected_object`

@example

assert_throw(:done) do
  throw(:done)
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)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1369
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

Passes if ‘actual` is true.

@example

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

build_message (user_message, template=nil, *arguments)

Source

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

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

flunk (message="Flunked")

Source

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

Flunk always fails.

@example

flunk 'Not done testing yet.'

refute (object, message=nil)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 186
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

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

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={})

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1023
      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)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1007
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={})

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1211
      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)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1195
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) { || ... }

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1939
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)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1968
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)

Source

# File bundled-src/test-unit-3.7.5/lib/test/unit/assertions.rb, line 1905
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