Module: Test::Unit::Assertions (Ruby 2.7.5)
Description: Module : Test::Unit::Assertions - Ruby 2.7.5

### Home Classes Methods

### In Files

- test-unit-3.3.4/lib/test/unit/assertions.rb
- test-unit-3.3.4/lib/test/unit/autorunner.rb
- test-unit-3.3.4/lib/test/unit/failure.rb
- test-unit-3.3.4/lib/test/unit/ui/testrunner.rb

### Namespace

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

### 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_includes
- #assert_not_instance_of
- #assert_not_kind_of
- #assert_not_match
- #assert_not_nil
- #assert_not_operator
- #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_empty
- #refute_equal
- #refute_in_delta
- #refute_in_epsilon
- #refute_includes
- #refute_instance_of
- #refute_kind_of
- #refute_match
- #refute_nil
- #refute_operator
- #refute_predicate
- #refute_respond_to
- #refute_same

### Class/Module Index

Quicksearch

- Object
- Test
- Test::Unit
- Test::Unit::AssertionFailedError
- Test::Unit::Assertions
- Test::Unit::Assertions::AssertExceptionHelper
- Test::Unit::Assertions::AssertExceptionHelper::WrappedException
- Test::Unit::Assertions::AssertionMessage
- Test::Unit::Assertions::AssertionMessage::ArrayInspector
- Test::Unit::Assertions::AssertionMessage::DelayedLiteral
- Test::Unit::Assertions::AssertionMessage::HashInspector
- Test::Unit::Assertions::AssertionMessage::Inspector
- Test::Unit::Assertions::AssertionMessage::Literal
- Test::Unit::Assertions::AssertionMessage::MaybeContainer
- Test::Unit::Assertions::AssertionMessage::NumericInspector
- Test::Unit::Assertions::AssertionMessage::Template
- Test::Unit::Assertions::ThrowTagExtractor
- Test::Unit::Attribute
- Test::Unit::Attribute::BaseClassMethods
- Test::Unit::Attribute::ClassMethods
- Test::Unit::Attribute::StringifyKeyHash
- Test::Unit::AttributeMatcher
- Test::Unit::AutoRunner
- Test::Unit::AutoRunner::StopOnFailureListener
- Test::Unit::AutoRunnerLoader
- 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::DataSets
- 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::Fixture::Fixture
- Test::Unit::Fixture::HookPoint
- 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

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 Example Custom Assertion

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

### Constants

NOT_SPECIFIED

  @private

### Public Class Methods

use_pp=(value) click to toggle source

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

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

### Public Instance Methods

add_assertion() click to toggle source

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

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

@return [void]

                   # File test-unit-3.3.4/lib/test/unit/assertions.rb, line 1655
    def add_assertion
    end

assert(object=NOT_SPECIFIED, message=nil, &block) click to toggle source

@overload assert(object, message=nil)

    Asserts that `object` is not false nor nil.

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

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

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

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

@overload assert(message=nil) {}

    Asserts that the givens block returns not false nor nil.

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

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

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

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

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

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

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

                   # File test-unit-3.3.4/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) click to toggle source

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

@example

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

                   # File test-unit-3.3.4/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.") 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 test-unit-3.3.4/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) click to toggle source

Passes if `actual` is a boolean value.

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

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

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

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

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if `object` is empty.

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if `expected` == `actual`.

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

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if assertion is failed in block.

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if `actual` is false.

@example

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

                   # File test-unit-3.3.4/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="") click to toggle source

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

@example

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

                   # File test-unit-3.3.4/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="") click to toggle source

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

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if `collection` includes `object`.

@example

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

                   # File test-unit-3.3.4/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

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

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

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

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

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if `pattern` =~ `string`.

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if `object` is nil.

@example

    assert_nil [1, 2].uniq!

                   # File test-unit-3.3.4/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="") click to toggle source

Deprecated. Use `assert_not_match` instead.

Passes if `regexp` !~ `string`

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

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

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if `object` is not empty.

@example

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

                   # File test-unit-3.3.4/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

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

Passes if `expected` != `actual`

@example

    assert_not_equal 'some string', 5

                   # File test-unit-3.3.4/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

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

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

@example

    assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00002) # -> pass
    assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00001) # -> fail

                   # File test-unit-3.3.4/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

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

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

@example

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

                   # File test-unit-3.3.4/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

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

Passes if `collection` doesn't include `object`.

@example

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

                   # File test-unit-3.3.4/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

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

Just for minitest compatibility. :<

@since 3.0.0

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

Passes if `object`.instance_of?(`klass`) does not hold. When `klass` is an array of classes, it passes if no class satisfies +object.instance_of?(class).

@example

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

@since 3.0.0

                   # File test-unit-3.3.4/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

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

Passes if `object`.kind_of?(`klass`) does not hold. When `klass` is an array of classes or modules, it passes only if all classes (and modules) do not satisfy +object.kind_of?(class_or_module).

@example

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

@since 3.0.0

                   # File test-unit-3.3.4/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

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

Passes if `regexp` !~ `string`

@example

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

                   # File test-unit-3.3.4/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

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

Passes if ! `object` .nil?

@example

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

                   # File test-unit-3.3.4/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

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

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

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

@example

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

@since 3.0.0

                   # File test-unit-3.3.4/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

Also aliased as: refute_operator
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 test-unit-3.3.4/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

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

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

@example

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

                   # File test-unit-3.3.4/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

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

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

@example

    assert_not_same Object.new, Object.new

                   # File test-unit-3.3.4/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

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 test-unit-3.3.4/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) click to toggle source

Passes if block does not raise an exception.

@example

    assert_nothing_raised do
      [1, 2].uniq
    end

                   # File test-unit-3.3.4/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) click to toggle source

Passes if block does not throw anything.

@example

    assert_nothing_thrown do
      [1, 2].uniq
    end

                   # File test-unit-3.3.4/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) 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 test-unit-3.3.4/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) click to toggle source

Passes if `path` exists.

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if `path` doesn't exist.

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Passes if `object`.`predicate` is true.

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

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

@example

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

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

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

                   # File test-unit-3.3.4/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

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

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

@example

    assert_raise_kind_of(SystemCallError) do
      raise Errno::EACCES
    end

                   # File test-unit-3.3.4/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) click to toggle source

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

@example

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

                   # File test-unit-3.3.4/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) click to toggle source

Just for minitest compatibility. :<

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

Passes if `object` .respond_to? `method`

@example

    assert_respond_to 'bugbear', :slice

                   # File test-unit-3.3.4/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) click to toggle source

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

@example

    o = Object.new
    assert_same o, o

                   # File test-unit-3.3.4/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) 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 test-unit-3.3.4/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) click to toggle source

Passes if the block throws `expected_object`

@example

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

                   # File test-unit-3.3.4/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

Also aliased as: assert_throws
assert_throws(expected_object, message=nil, &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 test-unit-3.3.4/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) click to toggle source

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

                   # File test-unit-3.3.4/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") click to toggle source

Flunk always fails.

@example

    flunk 'Not done testing yet.'

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

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

Asserts that `object` is false or nil.

@note Just for minitest compatibility. :<

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

@example Pass patterns

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

@example `Failure` patterns

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

@since 2.5.3

                   # File test-unit-3.3.4/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) click to toggle source

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_empty
refute_equal(expected, actual, message=nil) 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_in_epsilon(expected_float, actual_float, epsilon=0.001, message="") click to toggle source

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_in_epsilon
refute_includes(collection, object, message=nil) click to toggle source

Just for minitest compatibility. :<

@since 3.0.0

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

Just for minitest compatibility. :<

@since 3.0.0

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

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_kind_of
refute_match(regexp, string, message=nil) click to toggle source

Just for minitest compatibility. :<

@since 2.5.3

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

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_nil
refute_operator(object1, operator, object2, message=nil) click to toggle source

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_operator
refute_predicate(object, predicate, message=nil) click to toggle source

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_predicate
refute_respond_to(object, method, message=nil) click to toggle source

Just for minitest compatibility. :<

@since 2.5.3

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

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_same