Module: Test::Unit::Assertions

### Home Classes Methods

### In Files

- lib/test/unit/assertions.rb

### Namespace

- CLASS Test::Unit::Assertions::AssertExceptionHelper
- CLASS Test::Unit::Assertions::AssertionMessage

### Methods

- ::use_pp=
- #add_assertion
- #assert
- #assert_alias_method
- #assert_block
- #assert_boolean
- #assert_compare
- #assert_const_defined
- #assert_empty
- #assert_equal
- #assert_fail_assertion
- #assert_false
- #assert_in_delta
- #assert_in_epsilon
- #assert_include
- #assert_includes
- #assert_instance_of
- #assert_kind_of
- #assert_match
- #assert_nil
- #assert_no_match
- #assert_not_const_defined
- #assert_not_empty
- #assert_not_equal
- #assert_not_in_delta
- #assert_not_in_epsilon
- #assert_not_include
- #assert_not_match
- #assert_not_nil
- #assert_not_predicate
- #assert_not_respond_to
- #assert_not_same
- #assert_not_send
- #assert_nothing_raised
- #assert_nothing_thrown
- #assert_operator
- #assert_path_exist
- #assert_path_not_exist
- #assert_predicate
- #assert_raise
- #assert_raise_kind_of
- #assert_raise_message
- #assert_raises
- #assert_respond_to
- #assert_same
- #assert_send
- #assert_throw
- #assert_throws
- #assert_true
- #build_message
- #flunk
- #refute
- #refute_equal
- #refute_in_delta
- #refute_match
- #refute_nil
- #refute_respond_to
- #refute_same

### Class/Module Index

Quicksearch

- Test
- Test::Unit
- Test::Unit::AssertionFailedError
- Test::Unit::Assertions
- Test::Unit::Attribute
- Test::Unit::Attribute::BaseClassMethods
- Test::Unit::Attribute::ClassMethods
- Test::Unit::Attribute::StringifyKeyHash
- Test::Unit::AttributeMatcher
- Test::Unit::AutoRunner
- Test::Unit::CodeSnippetFetcher
- Test::Unit::Collector
- Test::Unit::Collector::Descendant
- Test::Unit::Collector::Dir
- Test::Unit::Collector::Load
- Test::Unit::Collector::ObjectSpace
- Test::Unit::Collector::XML
- Test::Unit::Collector::XML::Listener
- Test::Unit::Color
- Test::Unit::Color::Error
- Test::Unit::Color::ParseError
- Test::Unit::ColorScheme
- Test::Unit::Data
- Test::Unit::Data::ClassMethods
- Test::Unit::Data::ClassMethods::Loader
- Test::Unit::Diff
- Test::Unit::Diff::Differ
- Test::Unit::Diff::ReadableDiffer
- Test::Unit::Diff::SequenceMatcher
- Test::Unit::Diff::UTF8Line
- Test::Unit::Diff::UnifiedDiffer
- Test::Unit::Error
- Test::Unit::ErrorHandler
- Test::Unit::ExceptionHandler
- Test::Unit::ExceptionHandler::ClassMethods
- Test::Unit::Failure
- Test::Unit::FailureHandler
- Test::Unit::FaultLocationDetector
- Test::Unit::Fixture
- Test::Unit::Fixture::ClassMethods
- Test::Unit::MixColor
- Test::Unit::Notification
- Test::Unit::NotificationHandler
- Test::Unit::NotifiedError
- Test::Unit::NullResultContainerInitializer
- Test::Unit::Omission
- Test::Unit::OmissionHandler
- Test::Unit::OmittedError
- Test::Unit::PendedError
- Test::Unit::Pending
- Test::Unit::PendingHandler
- Test::Unit::Priority
- Test::Unit::Priority::Checker
- Test::Unit::Priority::ClassMethods
- Test::Unit::TestCase
- Test::Unit::TestCase::InternalData
- Test::Unit::TestCaseNotificationSupport
- Test::Unit::TestCaseOmissionSupport
- Test::Unit::TestCasePendingSupport
- Test::Unit::TestResult
- Test::Unit::TestResultErrorSupport
- Test::Unit::TestResultFailureSupport
- Test::Unit::TestResultNotificationSupport
- Test::Unit::TestResultOmissionSupport
- Test::Unit::TestResultPendingSupport
- Test::Unit::TestSuite
- Test::Unit::UI
- Test::Unit::UI::Console
- Test::Unit::UI::Console::ColorizedReadableDiffer
- Test::Unit::UI::Console::OutputLevel
- Test::Unit::UI::Console::TestRunner
- Test::Unit::UI::Emacs
- Test::Unit::UI::Emacs::TestRunner
- Test::Unit::UI::TestRunner
- Test::Unit::UI::TestRunnerMediator
- Test::Unit::UI::TestRunnerUtilities
- Test::Unit::UI::XML
- Test::Unit::UI::XML::TestRunner
- Test::Unit::Util
- Test::Unit::Util::BacktraceFilter
- Test::Unit::Util::MethodOwnerFinder
- Test::Unit::Util::Observable
- Test::Unit::Util::Output
- Test::Unit::Util::ProcWrapper
- Object

No matching classes.

# Test::Unit::Assertions

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

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

Notes:

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

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

# Example 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 = <?> #{operator} <?> should be true<?> expected #{operator_description}<?>.
        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 = <?>(?) expected but was<?>(?).?
        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) click to toggle source

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 = <?> expected to respond to<?(*?)> with not a true value but was<?>.
        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) click to toggle source

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 = <?> expected to respond to<?(*?)> with a true value but was<?>.
        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) click to toggle source

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="") click to toggle source

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_equal
refute_in_delta(expected_float, actual_float, delta=0.001, message="") click to toggle source

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_in_delta
refute_match(regexp, string, message="") click to toggle source

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_match
refute_nil(object, message="") click to toggle source

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_nil
refute_respond_to(object, method, message="") click to toggle source

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_respond_to
refute_same(expected, actual, message="") click to toggle source

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_same

[Validate]

Generated with the Darkfish Rdoc Generator 2.