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:

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

UncaughtThrow

Public Class Methods

use_pp=(value) click to toggle source

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

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

Public Instance Methods

add_assertion() click to toggle source

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

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

@return [void]

# File lib/test/unit/assertions.rb, line 1457
def add_assertion
end
assert(boolean, message=nil) click to toggle source

Asserts that boolean is not false or nil.

Example:

assert [1, 2].include?(5)
# File lib/test/unit/assertions.rb, line 63
def assert(boolean, 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("assert should not be called with a block.") do
      !block_given?
    end
    assertion_message ||= build_message(message,
                                        "<?> is not true.",
                                        boolean)
    assert_block(assertion_message) do
      boolean
    end
  end
end
assert_alias_method(object, alias_name, original_name, message=nil) click to toggle source

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

Example:

assert_alias_method([], :length, :size)  # -> pass
assert_alias_method([], :size, :length)  # -> pass
assert_alias_method([], :each, :size)    # -> fail
# File lib/test/unit/assertions.rb, line 1252
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.") { || ... } click to toggle source

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

Example:

assert_block "Couldn't do the thing" do
  do_the_thing
end
# File lib/test/unit/assertions.rb, line 48
def assert_block(message="assert_block failed.") # :yields:
  _wrap_assertion do
    if (! yield)
      raise AssertionFailedError.new(message.to_s)
    end
  end
end
assert_boolean(actual, message=nil) click to toggle source

Passes if actual is a boolean value.

Example:

assert_boolean(true) # -> pass
assert_boolean(nil)  # -> fail
# File lib/test/unit/assertions.rb, line 1028
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) click to toggle source

Passes if expression “expected operator actual” is true.

Example:

assert_compare(1, "<", 10)  # -> pass
assert_compare(1, ">=", 10) # -> fail
# File lib/test/unit/assertions.rb, line 1077
      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
<?> expected #{operator_description}
<?>.
EOT
          full_message = build_message(message, template,
                                       expected, actual,
                                       expected, actual)
          assert_block(full_message) do
            expected.__send__(operator, actual)
          end
        end
      end
assert_const_defined(object, constant_name, message=nil) click to toggle source

Passes if object.const_defined?(constant_name)

Example:

assert_const_defined(Test, :Unit)          # -> pass
assert_const_defined(Object, :Nonexistent) # -> fail
# File lib/test/unit/assertions.rb, line 1172
def assert_const_defined(object, constant_name, message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "<?>.const_defined\\?(<?>) expected.",
                                 object, constant_name)
    assert_block(full_message) do
      object.const_defined?(constant_name)
    end
  end
end
assert_empty(object, message=nil) click to toggle source

Passes if object is empty.

Example:

assert_empty("")                       # -> pass
assert_empty([])                       # -> pass
assert_empty({})                       # -> pass
assert_empty(" ")                      # -> fail
assert_empty([nil])                    # -> fail
assert_empty({1 => 2})                 # -> fail
# File lib/test/unit/assertions.rb, line 1387
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,
                                 "<?> expected to be empty.",
                                 object)
    assert_block(full_message) do
      object.empty?
    end
  end
end
assert_equal(expected, actual, message=nil) click to toggle source

Passes if expected == actual.

Note that the ordering of arguments is important, since a helpful error message is generated when this one fails that tells you the values of expected and actual.

Example:

assert_equal 'MY STRING', 'my string'.upcase
# File lib/test/unit/assertions.rb, line 140
      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, "<?> expected but was
<?>.?
", expected, actual, diff)
        end
        begin
          assert_block(full_message) { expected == actual }
        rescue AssertionFailedError => failure
          _set_failed_information(failure, expected, actual, message)
          raise failure # For JRuby. :<
        end
      end
assert_fail_assertion(message=nil) { || ... } click to toggle source

Passes if assertion is failed in block.

Example:

assert_fail_assertion {assert_equal("A", "B")}  # -> pass
assert_fail_assertion {assert_equal("A", "A")}  # -> fail
# File lib/test/unit/assertions.rb, line 1110
def assert_fail_assertion(message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "Failed assertion was expected.")
    assert_block(full_message) do
      begin
        yield
        false
      rescue AssertionFailedError
        true
      end
    end
  end
end
assert_false(actual, message=nil) click to toggle source

Passes if actual is false.

Example:

assert_false(false)  # -> pass
assert_false(nil)    # -> fail
# File lib/test/unit/assertions.rb, line 1060
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="") click to toggle source

Passes if expected_float and actual_float are equal within delta tolerance.

Example:

assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
# File lib/test/unit/assertions.rb, line 680
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="") click to toggle source

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

Example:

assert_in_epsilon(10000.0, 9900.0, 0.1) # -> pass
assert_in_epsilon(10000.0, 9899.0, 0.1) # -> fail
# File lib/test/unit/assertions.rb, line 809
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) click to toggle source

Passes if collection includes object.

Example:

assert_include([1, 10], 1)            # -> pass
assert_include(1..10, 5)              # -> pass
assert_include([1, 10], 5)            # -> fail
assert_include(1..10, 20)             # -> fail
# File lib/test/unit/assertions.rb, line 1336
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,
                                 "<?> expected to include\n<?>.",
                                 collection,
                                 object)
    assert_block(full_message) do
      collection.include?(object)
    end
  end
end
Also aliased as: assert_includes
assert_includes(collection, object, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

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

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

Example:

assert_instance_of(String, 'foo')            # -> pass
assert_instance_of([Fixnum, NilClass], 100)  # -> pass
assert_instance_of([Numeric, NilClass], 100) # -> fail
# File lib/test/unit/assertions.rb, line 245
      def assert_instance_of(klass, object, message="")
        _wrap_assertion do
          klasses = nil
          klasses = klass if klass.is_a?(Array)
          assert_block("The first parameter to assert_instance_of should be " +
                       "a Class or an Array of Class.") do
            if klasses
              klasses.all? {|k| k.is_a?(Class)}
            else
              klass.is_a?(Class)
            end
          end
          klass_message = AssertionMessage.maybe_container(klass) do |value|
            "<#{value}>"
          end
          full_message = build_message(message, "<?> expected to be an instance of
? but was
<?>.
", object, klass_message, object.class)
          assert_block(full_message) do
            if klasses
              klasses.any? {|k| object.instance_of?(k)}
            else
              object.instance_of?(klass)
            end
          end
        end
      end
assert_kind_of(klass, object, message="") click to toggle source

Passes if object.kind_of?(klass). When klass is an array of classes or modules, it passes if any class or module satisfies +object.kind_of?(class_or_module).

Example:

assert_kind_of(Object, 'foo')                # -> pass
assert_kind_of([Fixnum, NilClass], 100)      # -> pass
assert_kind_of([Fixnum, NilClass], "string") # -> fail
# File lib/test/unit/assertions.rb, line 300
def assert_kind_of(klass, object, message="")
  _wrap_assertion do
    klasses = nil
    klasses = klass if klass.is_a?(Array)
    assert_block("The first parameter to assert_kind_of should be " +
                 "a kind_of Module or an Array of a kind_of Module.") do
      if klasses
        klasses.all? {|k| k.kind_of?(Module)}
      else
        klass.kind_of?(Module)
      end
    end
    klass_message = AssertionMessage.maybe_container(klass) do |value|
      "<#{value}>"
    end
    full_message = build_message(message,
                                 "<?> expected to be kind_of\\?\n" +
                                 "? but was\n" +
                                 "<?>.",
                                 object,
                                 klass_message,
                                 object.class)
    assert_block(full_message) do
      if klasses
        klasses.any? {|k| object.kind_of?(k)}
      else
        object.kind_of?(klass)
      end
    end
  end
end
assert_match(pattern, string, message="") click to toggle source

Passes if string =~ pattern.

Example:

assert_match(/\d+/, 'five, 6, seven')
# File lib/test/unit/assertions.rb, line 393
def assert_match(pattern, string, message="")
  _wrap_assertion do
    pattern = case(pattern)
      when String
        Regexp.new(Regexp.escape(pattern))
      else
        pattern
    end
    full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
    assert_block(full_message) { string =~ pattern }
  end
end
assert_nil(object, message="") click to toggle source

Passes if object is nil.

Example:

assert_nil [1, 2].uniq!
# File lib/test/unit/assertions.rb, line 282
      def assert_nil(object, message="")
        full_message = build_message(message, "<?> expected to be nil.
", object)
        assert_block(full_message) { object.nil? }
      end
assert_no_match(regexp, string, message="") click to toggle source

Deprecated. Use assert_not_match instead.

Passes if regexp !~ string

Example:

assert_no_match(/two/, 'one 2 three')   # -> pass
assert_no_match(/three/, 'one 2 three') # -> fail
# File lib/test/unit/assertions.rb, line 582
def assert_no_match(regexp, string, message="")
  _wrap_assertion do
    assert_instance_of(Regexp, regexp,
                       "The first argument to assert_no_match " +
                       "should be a Regexp.")
    assert_not_match(regexp, string, message)
  end
end
assert_not_const_defined(object, constant_name, message=nil) click to toggle source

Passes if !object.const_defined?(constant_name)

Example:

assert_not_const_defined(Object, :Nonexistent) # -> pass
assert_not_const_defined(Test, :Unit)          # -> fail
# File lib/test/unit/assertions.rb, line 1189
def assert_not_const_defined(object, constant_name, message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "!<?>.const_defined\\?(<?>) expected.",
                                 object, constant_name)
    assert_block(full_message) do
      !object.const_defined?(constant_name)
    end
  end
end
assert_not_empty(object, message=nil) click to toggle source

Passes if object is not empty.

Example:

assert_not_empty(" ")                      # -> pass
assert_not_empty([nil])                    # -> pass
assert_not_empty({1 => 2})                 # -> pass
assert_not_empty("")                       # -> fail
assert_not_empty([])                       # -> fail
assert_not_empty({})                       # -> fail
# File lib/test/unit/assertions.rb, line 1410
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,
                                 "<?> expected to not be empty.",
                                 object)
    assert_block(full_message) do
      not object.empty?
    end
  end
end
assert_not_equal(expected, actual, message="") click to toggle source

Passes if expected != actual

Example:

assert_not_equal 'some string', 5
# File lib/test/unit/assertions.rb, line 520
def assert_not_equal(expected, actual, message="")
  full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
  assert_block(full_message) { expected != actual }
end
Also aliased as: refute_equal
assert_not_in_delta(expected_float, actual_float, delta=0.001, message="") click to toggle source

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

Example:

assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00002) # -> pass
assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00001) # -> fail
# File lib/test/unit/assertions.rb, line 704
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
Also aliased as: refute_in_delta
assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001, message="") click to toggle source

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

Example:

assert_not_in_epsilon(10000.0, 9900.0, 0.1) # -> fail
assert_not_in_epsilon(10000.0, 9899.0, 0.1) # -> pass
# File lib/test/unit/assertions.rb, line 842
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) click to toggle source

Passes if collection doesn't include object.

Example:

assert_not_include([1, 10], 5)            # -> pass
assert_not_include(1..10, 20)             # -> pass
assert_not_include([1, 10], 1)            # -> fail
assert_not_include(1..10, 5)              # -> fail
# File lib/test/unit/assertions.rb, line 1363
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,
                                 "<?> expected to not include\n<?>.",
                                 collection,
                                 object)
    assert_block(full_message) do
      not collection.include?(object)
    end
  end
end
assert_not_match(regexp, string, message="") click to toggle source

Passes if regexp !~ string

Example:

assert_not_match(/two/, 'one 2 three')   # -> pass
assert_not_match(/three/, 'one 2 three') # -> fail
# File lib/test/unit/assertions.rb, line 555
def assert_not_match(regexp, string, message="")
  _wrap_assertion do
    assert_instance_of(Regexp, regexp,
                       "<REGEXP> in assert_not_match(<REGEXP>, ...) " +
                       "should be a Regexp.")
    full_message = build_message(message,
                                 "<?> expected to not match\n<?>.",
                                 regexp, string)
    assert_block(full_message) { regexp !~ string }
  end
end
Also aliased as: refute_match
assert_not_nil(object, message="") click to toggle source

Passes if ! object .nil?

Example:

assert_not_nil '1 two 3'.sub!(/two/, '2')
# File lib/test/unit/assertions.rb, line 537
def assert_not_nil(object, message="")
  full_message = build_message(message, "<?> expected to not be nil.", object)
  assert_block(full_message){!object.nil?}
end
Also aliased as: refute_nil
assert_not_predicate(object, predicate, message=nil) click to toggle source

Passes if object.predicate is not true.

Example:

assert_not_predicate([1], :empty?) # -> pass
assert_not_predicate([], :empty?)  # -> fail
# File lib/test/unit/assertions.rb, line 1228
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="") click to toggle source

Passes if object does not .respond_to? method.

Example:

assert_not_respond_to('bugbear', :nonexistence) # -> pass
assert_not_respond_to('bugbear', :size)         # -> fail
# File lib/test/unit/assertions.rb, line 364
def assert_not_respond_to(object, method, message="")
  _wrap_assertion do
    full_message = build_message(message,
                                 "<?>.kind_of\\?(Symbol) or\n" +
                                 "<?>.respond_to\\?(:to_str) expected",
                                 method, method)
    assert_block(full_message) do
      method.kind_of?(Symbol) or method.respond_to?(:to_str)
    end
    full_message = build_message(message,
                                 "!<?>.respond_to\\?(?) expected\n" +
                                 "(Class: <?>)",
                                 object, method, object.class)
    assert_block(full_message) {!object.respond_to?(method)}
  end
end
Also aliased as: refute_respond_to
assert_not_same(expected, actual, message="") click to toggle source

Passes if ! actual .equal? expected

Example:

assert_not_same Object.new, Object.new
# File lib/test/unit/assertions.rb, line 498
      def assert_not_same(expected, actual, message="")
        full_message = build_message(message, "<?>
with id <?> expected to not be equal\\? to
<?>
with id <?>.
", expected, expected.__id__, actual, actual.__id__)
        assert_block(full_message) { !actual.equal?(expected) }
      end
Also aliased as: refute_same
assert_not_send(send_array, message=nil) click to toggle source

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

send_array is composed of:

  • A receiver

  • A method

  • Arguments to the method

Example:

assert_not_send([[1, 2], :member?, 1]) # -> fail
assert_not_send([[1, 2], :member?, 4]) # -> pass
# File lib/test/unit/assertions.rb, line 993
      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
<?> 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) { || ... } click to toggle source

Passes if block does not raise an exception.

Example:

assert_nothing_raised do
  [1, 2].uniq
end
# File lib/test/unit/assertions.rb, line 456
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
    nil
  end
end
assert_nothing_thrown(message="", &proc) click to toggle source

Passes if block does not throw anything.

Example:

assert_nothing_thrown do
  [1, 2].uniq
end
# File lib/test/unit/assertions.rb, line 654
def assert_nothing_thrown(message="", &proc)
  _wrap_assertion do
    assert(block_given?, "Should have passed a block to assert_nothing_thrown")
    begin
      proc.call
    rescue NameError, ArgumentError, ThreadError => error
      raise unless UncaughtThrow[error.class] =~ error.message
      tag = $1
      tag = tag[1..-1].intern if tag[0, 1] == ":"
      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="") click to toggle source

Compares the object1 with object2 using operator.

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

Example:

assert_operator 5, :>=, 4
# File lib/test/unit/assertions.rb, line 434
      def assert_operator(object1, operator, object2, message="")
        _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, "<?> expected to be
?
<?>.
", object1, AssertionMessage.literal(operator), object2)
          assert_block(full_message) { object1.__send__(operator, object2) }
        end
      end
assert_path_exist(path, message=nil) click to toggle source

Passes if path exists.

Example:

assert_path_exist("/tmp")          # -> pass
assert_path_exist("/bin/sh")       # -> pass
assert_path_exist("/nonexistent")  # -> fail
# File lib/test/unit/assertions.rb, line 1299
def assert_path_exist(path, message=nil)
  _wrap_assertion do
    failure_message = build_message(message,
                                    "<?> expected to exist",
                                    path)
    assert_block(failure_message) do
      File.exist?(path)
    end
  end
end
assert_path_not_exist(path, message=nil) click to toggle source

Passes if path doesn't exist.

Example:

assert_path_not_exist("/nonexistent")  # -> pass
assert_path_not_exist("/tmp")          # -> fail
assert_path_not_exist("/bin/sh")       # -> fail
# File lib/test/unit/assertions.rb, line 1317
def assert_path_not_exist(path, message=nil)
  _wrap_assertion do
    failure_message = build_message(message,
                                    "<?> expected to not exist",
                                    path)
    assert_block(failure_message) do
      not File.exist?(path)
    end
  end
end
assert_predicate(object, predicate, message=nil) click to toggle source

Passes if object.predicate is true.

Example:

assert_predicate([], :empty?)  # -> pass
assert_predicate([1], :empty?) # -> fail
# File lib/test/unit/assertions.rb, line 1206
def assert_predicate(object, predicate, message=nil)
  _wrap_assertion do
    assert_respond_to(object, predicate, message)
    actual = object.__send__(predicate)
    full_message = build_message(message,
                                 "<?>.? is true value expected but was\n" +
                                 "<?>",
                                 object,
                                 AssertionMessage.literal(predicate),
                                 actual)
    assert_block(full_message) do
      actual
    end
  end
end
assert_raise(*args, &block) click to toggle source

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

Example:

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

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

assert_raise(RuntimeError.new("XXX")) {raise "XXX"} # -> pass
assert_raise(MyError.new("XXX"))      {raise "XXX"} # -> fail
assert_raise(RuntimeError.new("ZZZ")) {raise "XXX"} # -> fail
# File lib/test/unit/assertions.rb, line 185
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,
                              message)
      raise failure # For JRuby. :<
    end
  end
  _assert_raise(assert_expected_exception, *args, &block)
end
Also aliased as: assert_raises
assert_raise_kind_of(*args, &block) click to toggle source

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

Example:

assert_raise_kind_of(SystemCallError) do
  raise Errno::EACCES
end
# File lib/test/unit/assertions.rb, line 218
def assert_raise_kind_of(*args, &block)
  assert_expected_exception = Proc.new do |*_args|
    message, assert_exception_helper, actual_exception = _args
    expected = assert_exception_helper.expected_exceptions
    full_message = build_message(message,
                                 "<?> family exception expected " +
                                 "but was\n<?>.",
                                 expected, actual_exception)
    assert_block(full_message) do
      assert_exception_helper.expected?(actual_exception, :kind_of?)
    end
  end
  _assert_raise(assert_expected_exception, *args, &block)
end
assert_raise_message(expected, message=nil) { || ... } click to toggle source

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

Example:

assert_raise_message("exception") {raise "exception"}  # -> pass
assert_raise_message(/exc/i) {raise "exception"}       # -> pass
assert_raise_message("exception") {raise "EXCEPTION"}  # -> fail
assert_raise_message("exception") {}                   # -> fail
# File lib/test/unit/assertions.rb, line 1134
def assert_raise_message(expected, message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "<?> exception message 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)

Just for minitest compatibility. :<

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

Passes if object .respond_to? method

Example:

assert_respond_to 'bugbear', :slice
# File lib/test/unit/assertions.rb, line 339
def assert_respond_to(object, method, message="")
  _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="") click to toggle source

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

Example:

o = Object.new
assert_same o, o
# File lib/test/unit/assertions.rb, line 415
      def assert_same(expected, actual, message="")
        full_message = build_message(message, "<?>
with id <?> expected to be equal\\? to
<?>
with id <?>.
", expected, expected.__id__, actual, actual.__id__)
        assert_block(full_message) { actual.equal?(expected) }
      end
assert_send(send_array, message=nil) click to toggle source

Passes if the method send returns a true value.

send_array is composed of:

  • A receiver

  • A method

  • Arguments to the method

Example:

assert_send([[1, 2], :member?, 1]) # -> pass
assert_send([[1, 2], :member?, 4]) # -> fail
# File lib/test/unit/assertions.rb, line 953
      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
<?> 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="", &proc) click to toggle source

Passes if the block throws expected_object

Example:

assert_throw(:done) do
  throw(:done)
end
# File lib/test/unit/assertions.rb, line 606
def assert_throw(expected_object, message="", &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 NameError, ArgumentError, ThreadError => error
      raise unless UncaughtThrow[error.class] =~ error.message
      tag = $1
      tag = tag[1..-1].intern if tag[0, 1] == ":"
      full_message = build_message(message,
                                   "<?> expected to be thrown but\n" +
                                   "<?> was thrown.",
                                   expected_object, tag)
      flunk(full_message)
    end
  end
end
Also aliased as: assert_throws
assert_throws(expected_object, message="", &proc)

Just for minitest compatibility. :<

@since 2.5.3

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

Passes if actual is true.

Example:

assert_true(true)  # -> pass
assert_true(:true) # -> fail
# File lib/test/unit/assertions.rb, line 1044
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(head, template=nil, *arguments) click to toggle source

Builds a failure message. head is added before the template and arguments replaces the '?'s positionally in the template.

# File lib/test/unit/assertions.rb, line 1428
def build_message(head, template=nil, *arguments)
  template &&= template.chomp
  return AssertionMessage.new(head, template, arguments)
end
flunk(message="Flunked") click to toggle source

Flunk always fails.

Example:

flunk 'Not done testing yet.'
# File lib/test/unit/assertions.rb, line 487
def flunk(message="Flunked")
  assert_block(build_message(message)){false}
end
refute(object, message=nil) click to toggle source

Asserts that object is false or nil.

@note Just for minitest compatibility. :<

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

@example Pass patterns

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

@example Fialure patterns

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

@since 2.5.3

# File lib/test/unit/assertions.rb, line 104
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_equal(expected, actual, message="")

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_match(regexp, string, message="")

Just for minitest compatibility. :<

@since 2.5.3

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

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_nil
refute_respond_to(object, method, message="")

Just for minitest compatibility. :<

@since 2.5.3

refute_same(expected, actual, message="")

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_same