123456789_123456789_123456789_123456789_123456789_

Module: Test::Unit::Assertions

Relationships & Source Files
Namespace Children
Classes:
Extension / Inclusion / Inheritance Descendants
Included In:
Defined in: lib/test/unit/assertions.rb

Overview

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

To include it in your own code and use its functionality, you simply need to rescue 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().

Examples:

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

Constant Summary

Class Attribute Summary

Instance Method Summary

Class Attribute Details

.use_pp=(value) (writeonly)

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.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1661

def self.use_pp=(value)
  AssertionMessage.use_pp = value
end

Instance Method Details

#_assert_in_delta_message(expected_float, actual_float, delta, message, options = {}) (private)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 928

def _assert_in_delta_message(expected_float, actual_float, 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]
  normalized_expected = expected_float.to_f
  normalized_actual = actual_float.to_f
  normalized_delta = delta.to_f
  relation_format = nil
  relation_arguments = nil
  if normalized_actual < normalized_expected - normalized_delta
    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) (private)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 912

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, actual_float, epsilon, message, options = {}) (private)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1062

def _assert_in_epsilon_message(expected_float, actual_float, epsilon,
                               message, options={})
  normalized_expected = expected_float.to_f
  normalized_actual = actual_float.to_f
  normalized_epsilon = epsilon.to_f
  delta = normalized_expected * normalized_epsilon

  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) (private)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1046

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, &block) (private)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1666

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) (private)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1695

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) (private)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1632

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

#add_assertionvoid

This method returns an undefined value.

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

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

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1655

def add_assertion
end

#assert(object, message = nil) ⇒ void #assert(message=nil) {}) { ... } ⇒ void

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 133

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)

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

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1436

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_block(message = "assert_block failed.")

The assertion upon which all other assertions are based. Passes if the block yields true.

Examples:

assert_block "Couldn't do the thing" do
  do_the_thing
end
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 52

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)

Passes if actual is a boolean value.

Examples:

assert_boolean(true) # -> pass
assert_boolean(nil)  # -> fail
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1207

def assert_boolean(actual, message=nil)
  _wrap_assertion do
    assert_block(build_message(message,
                               "<true> or <false> expected but was\n<?>",
                               actual)) do
      [true, false].include?(actual)
    end
  end
end

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

Passes if expression “‘expected` operator actual” is true.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1256

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)

Passes if object.const_defined?(constant_name)

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1351

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)

Passes if object is empty.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1581

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)

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.

Examples:

assert_equal 'MY STRING', 'my string'.upcase
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 224

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)

Passes if assertion is failed in block.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1289

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)

Passes if actual is false.

Examples:

assert_false(false)  # -> pass
assert_false(nil)    # -> fail
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1239

def assert_false(actual, message=nil)
  _wrap_assertion do
    assert_block(build_message(message,
                               "<false> expected but was\n<?>",
                               actual)) do
      actual == false
    end
  end
end

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

Passes if expected_float and actual_float are equal within delta tolerance.

Examples:

assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 868

def assert_in_delta(expected_float, actual_float, delta=0.001, message="")
  _wrap_assertion do
    _assert_in_delta_validate_arguments(expected_float,
                                        actual_float,
                                        delta)
    full_message = _assert_in_delta_message(expected_float,
                                            actual_float,
                                            delta,
                                            message)
    assert_block(full_message) do
      (expected_float.to_f - actual_float.to_f).abs <= delta.to_f
    end
  end
end

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

Passes if expected_float and actual_float are equal within epsilon relative error of expected_float.

Examples:

assert_in_epsilon(10000.0, 9900.0, 0.1) # -> pass
assert_in_epsilon(10000.0, 9899.0, 0.1) # -> fail
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 990

def assert_in_epsilon(expected_float, actual_float, epsilon=0.001,
                      message="")
  _wrap_assertion do
    _assert_in_epsilon_validate_arguments(expected_float,
                                          actual_float,
                                          epsilon)
    full_message = _assert_in_epsilon_message(expected_float,
                                              actual_float,
                                              epsilon,
                                              message)
    assert_block(full_message) do
      normalized_expected_float = expected_float.to_f
      if normalized_expected_float.zero?
        delta = epsilon.to_f ** 2
      else
        delta = normalized_expected_float * epsilon.to_f
      end
      delta = delta.abs
      (normalized_expected_float - actual_float.to_f).abs <= delta
    end
  end
end

#assert_include(collection, object, message = nil) Also known as: #assert_includes

Passes if collection includes object.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1520

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

#assert_includes(collection, object, message = nil)

Alias for #assert_include.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1537

alias_method :assert_includes, :assert_include

#assert_instance_of(klass, object, message = nil)

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

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 325

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)

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

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 412

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)

Passes if pattern =~ string.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 535

def assert_match(pattern, string, message=nil)
  _wrap_assertion do
    pattern = case(pattern)
      when String
        Regexp.new(Regexp.escape(pattern))
      else
        pattern
    end
    full_message = build_message(message,
                                 "<?> was expected to be =~\n<?>.",
                                 pattern, string)
    assert_block(full_message) { pattern =~ string }
  end
end

#assert_nil(object, message = nil)

Passes if object is nil.

Examples:

assert_nil [1, 2].uniq!
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 396

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 = "")

Deprecated. Use #assert_not_match instead.

Passes if regexp !~ string

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 739

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)

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

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1368

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) Also known as: #refute_empty

Passes if object is not empty.

Examples:

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
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1604

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

#assert_not_equal(expected, actual, message = nil) Also known as: #refute_equal

Passes if expected != actual

Examples:

assert_not_equal 'some string', 5
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 679

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

#assert_not_in_delta(expected_float, actual_float, delta = 0.001, message = "") Also known as: #refute_in_delta

Passes if expected_float and actual_float are not equal within delta tolerance.

Examples:

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
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 890

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)
    full_message = _assert_in_delta_message(expected_float,
                                            actual_float,
                                            delta,
                                            message,
                                            :negative_assertion => true)
    assert_block(full_message) do
      (expected_float.to_f - actual_float.to_f).abs > delta.to_f
    end
  end
end

#assert_not_in_epsilon(expected_float, actual_float, epsilon = 0.001, message = "") Also known as: #refute_in_epsilon

Passes if expected_float and actual_float are not equal within epsilon relative error of expected_float.

Examples:

assert_not_in_epsilon(10000.0, 9900.0, 0.1) # -> fail
assert_not_in_epsilon(10000.0, 9899.0, 0.1) # -> pass
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1021

def assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001,
                          message="")
  _wrap_assertion do
    _assert_in_epsilon_validate_arguments(expected_float,
                                          actual_float,
                                          epsilon)
    full_message = _assert_in_epsilon_message(expected_float,
                                              actual_float,
                                              epsilon,
                                              message,
                                              :negative_assertion => true)
    assert_block(full_message) do
      normalized_expected_float = expected_float.to_f
      delta = normalized_expected_float * epsilon.to_f
      (normalized_expected_float - actual_float.to_f).abs > delta
    end
  end
end

#assert_not_include(collection, object, message = nil) Also known as: #assert_not_includes, #refute_includes

Passes if collection doesn’t include object.

Examples:

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
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1547

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

#assert_not_includes(collection, object, message = nil)

Alias for #assert_not_include.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1564

alias_method :assert_not_includes, :assert_not_include

#assert_not_instance_of(klass, object, message = nil) Also known as: #refute_instance_of

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

Examples:

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

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 361

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

#assert_not_kind_of(klass, object, message = nil) Also known as: #refute_kind_of

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

Examples:

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

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 450

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

#assert_not_match(regexp, string, message = nil) Also known as: #refute_match

Passes if regexp !~ string

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 714

def assert_not_match(regexp, string, message=nil)
  _wrap_assertion do
    assert_instance_of(Regexp, regexp,
                       "<REGEXP> in assert_not_match(<REGEXP>, ...) " +
                       "should be a Regexp.")
    full_message = build_message(message,
                                 "<?> was expected to not match\n<?>.",
                                 regexp, string)
    assert_block(full_message) { regexp !~ string }
  end
end

#assert_not_nil(object, message = nil) Also known as: #refute_nil

Passes if ! object .nil?

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 696

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

#assert_not_operator(object1, operator, object2, message = nil) Also known as: #refute_operator

Compares the object1 with object2 using operator.

Passes if object1.__send__(operator, object2) is not true.

Examples:

assert_not_operator(5, :<, 4) # => pass
assert_not_operator(5, :>, 4) # => fail

Since:

  • 3.0.0

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 597

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

#assert_not_predicate(object, predicate, message = nil) Also known as: #refute_predicate

Passes if object.‘predicate` is not true.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1407

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

#assert_not_respond_to(object, method, message = nil) Also known as: #refute_respond_to

Passes if object does not .respond_to? method.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 508

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

#assert_not_same(expected, actual, message = nil) Also known as: #refute_same

Passes if ! actual .equal? expected

Examples:

assert_not_same Object.new, Object.new
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 659

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

#assert_not_send(send_array, message = nil)

Passes if the method send doesn’t return a true value.

send_array is composed of:

  • A receiver

  • A method

  • Arguments to the method

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1172

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_raised(*args)

Passes if block does not raise an exception.

Examples:

assert_nothing_raised do
  [1, 2].uniq
end
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 622

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)

Passes if block does not throw anything.

Examples:

assert_nothing_thrown do
  [1, 2].uniq
end
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 844

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)

Compares the object1 with object2 using operator.

Passes if object1.__send__(operator, object2) is true.

Examples:

assert_operator 5, :>=, 4
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 574

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)

Passes if path exists.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1483

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)

Passes if path doesn’t exist.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1501

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)

Passes if object.‘predicate` is true.

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1385

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) Also known as: #assert_raises

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

Examples:

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
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 268

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

#assert_raise_kind_of(*args, &block)

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

Examples:

assert_raise_kind_of(SystemCallError) do
  raise Errno::EACCES
end
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 300

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)

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

Examples:

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
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1313

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_raises(*args, &block)

Alias for #assert_raise.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 290

alias_method :assert_raises, :assert_raise

#assert_respond_to(object, method, message = nil)

Passes if object .respond_to? method

Examples:

assert_respond_to 'bugbear', :slice
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 485

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)

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

Examples:

o = Object.new
assert_same o, o
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 557

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)

Passes if the method send returns a true value.

send_array is composed of:

  • A receiver

  • A method

  • Arguments to the method

Examples:

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

  
# File 'lib/test/unit/assertions.rb', line 1132

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) Also known as: #assert_throws

Passes if the block throws expected_object

Examples:

assert_throw(:done) do
  throw(:done)
end
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 798

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

#assert_throws(expected_object, message = nil, &proc)

Alias for #assert_throw.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 835

alias_method :assert_throws, :assert_throw

#assert_true(actual, message = nil)

Passes if actual is true.

Examples:

assert_true(true)  # -> pass
assert_true(:true) # -> fail
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1223

def assert_true(actual, message=nil)
  _wrap_assertion do
    assert_block(build_message(message,
                               "<true> expected but was\n<?>",
                               actual)) do
      actual == true
    end
  end
end

#build_message(user_message, template = nil, *arguments)

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

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1626

def build_message(user_message, template=nil, *arguments)
  template &&= template.chomp
  return AssertionMessage.new(user_message, template, arguments)
end

#flunk(message = "Flunked")

Flunk always fails.

Examples:

flunk 'Not done testing yet.'
[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 650

def flunk(message="Flunked")
  assert_block(build_message(message)){false}
end

#refute(object, message = nil) ⇒ void

Note:

Just for minitest compatibility. :<

This method returns an undefined value.

Asserts that object is false or nil.

Examples:

Pass patterns

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

Failure patterns

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

Parameters:

  • object (Object)

    The object to be asserted.

Since:

  • 2.5.3

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 190

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)

Alias for #assert_not_empty.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1620

alias_method :refute_empty, :assert_not_empty

#refute_equal(expected, actual, message = nil)

Alias for #assert_not_equal.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 689

alias_method :refute_equal, :assert_not_equal

#refute_in_delta(expected_float, actual_float, delta = 0.001, message = "")

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 909

alias_method :refute_in_delta, :assert_not_in_delta

#refute_in_epsilon(expected_float, actual_float, epsilon = 0.001, message = "")

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1043

alias_method :refute_in_epsilon, :assert_not_in_epsilon

#refute_includes(collection, object, message = nil)

Alias for #assert_not_include.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1569

alias_method :refute_includes, :assert_not_include

#refute_instance_of(klass, object, message = nil)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 389

alias_method :refute_instance_of, :assert_not_instance_of

#refute_kind_of(klass, object, message = nil)

Alias for #assert_not_kind_of.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 478

alias_method :refute_kind_of, :assert_not_kind_of

#refute_match(regexp, string, message = nil)

Alias for #assert_not_match.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 729

alias_method :refute_match, :assert_not_match

#refute_nil(object, message = nil)

Alias for #assert_not_nil.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 706

alias_method :refute_nil, :assert_not_nil

#refute_operator(object1, operator, object2, message = nil)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 613

alias_method :refute_operator, :assert_not_operator

#refute_predicate(object, predicate, message = nil)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 1426

alias_method :refute_predicate, :assert_not_predicate

#refute_respond_to(object, method, message = nil)

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 528

alias_method :refute_respond_to, :assert_not_respond_to

#refute_same(expected, actual, message = nil)

Alias for #assert_not_same.

[ GitHub ]

  
# File 'lib/test/unit/assertions.rb', line 672

alias_method :refute_same, :assert_not_same