module Test::Unit::Assertions

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

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

Notes:

The message to each assertion, if given, will be propagated with the failure.
It is easy to add your own assertions based on assert_block().

@example Example Custom Assertion

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

Constants

NOT_SPECIFIED: @private

Public Class Methods

use_pp=(value) 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.6.2/lib/test/unit/assertions.rb, line 1939
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.6.2/lib/test/unit/assertions.rb, line 1933
def add_assertion
end

assert(object=NOT_SPECIFIED, message=nil) { || ... } 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.6.2/lib/test/unit/assertions.rb, line 134
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.6.2/lib/test/unit/assertions.rb, line 1587
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_all(collection, message=nil) { |item| ... } click to toggle source

@overload assert_all(collection, message=nil, &block)

Asserts that all `block.call(item)` where `item` is each
item in `collection` are not false nor nil.

If `collection` is empty, this assertion is always passed
with any `block`.

@example Pass patterns
  assert_all([1, 2, 3]) {|item| item > 0} # => pass
  assert_all([1, 2, 3], &:positive?)      # => pass
  assert_all([]) {|item| false}           # => pass

@example Failure pattern
  assert_all([0, 1, 2], &:zero?) # => failure

@param [#each] collection The check target.
@param [String] message The additional user message. It is
  showed when the assertion is failed.
@yield [Object] Give each item in `collection` to the block.
@yieldreturn [Object] The checked object.
@return [void]

@since 3.4.4

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1797
      def assert_all(collection, message=nil)
        _wrap_assertion do
          failed = false
          result = {}
          collection.each do |item|
            element_result = yield(item)
            failed = true unless element_result
            result[item] = element_result
          end
          format = <<-FORMAT
<?> was expected to be all true values with the given block but was
<?>
          FORMAT
          full_message = build_message(message,
                                       format,
                                       collection,
                                       result)
          assert_block(full_message) do
            not failed
          end
        end
      end

Also aliased as: assert_all?

assert_all?(collection, message=nil)

Just for Ruby’s tool/lib/test/unit compatibility.

@since 3.4.3

Alias for: assert_all

assert_block(message="assert_block failed.") { || ... } click to toggle source

The assertion upon which all other assertions are based. Passes if the block yields not false nor nil.

@example

assert_block "Couldn't do the thing" do
  do_the_thing
end

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 53
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.6.2/lib/test/unit/assertions.rb, line 1358
def assert_boolean(actual, message=nil)
  _wrap_assertion do
    assert_block(build_message(message,
                               "<true> or <false> expected but was\n<?>",
                               actual)) do
      true == actual || false == actual
    end
  end
end

assert_compare(expected, operator, actual, message=nil) click to toggle source

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

@example

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

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1407
      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.6.2/lib/test/unit/assertions.rb, line 1502
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.6.2/lib/test/unit/assertions.rb, line 1732
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.6.2/lib/test/unit/assertions.rb, line 225
      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.6.2/lib/test/unit/assertions.rb, line 1440
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.6.2/lib/test/unit/assertions.rb, line 1390
def assert_false(actual, message=nil)
  _wrap_assertion do
    assert_block(build_message(message,
                               "<false> expected but was\n<?>",
                               actual)) do
      false == actual
    end
  end
end

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.6.2/lib/test/unit/assertions.rb, line 927
def assert_in_delta(expected_float, actual_float, delta=0.001, message="")
  _wrap_assertion do
    begin
      pass = delta >= (expected_float - actual_float).abs
      assert_operator(delta, :>=, 0.0, "The delta should not be negative")
      full_message = _assert_in_delta_message(expected_float,
                                              expected_float,
                                              actual_float,
                                              actual_float,
                                              delta,
                                              delta,
                                              message)
    rescue Test::Unit::AssertionFailedError
      # for the above assert_operator
      raise
    rescue
      _assert_in_delta_validate_arguments(expected_float,
                                          actual_float,
                                          delta)
      normalized_expected = expected_float.to_f
      normalized_actual = actual_float.to_f
      normalized_delta = delta.to_f
      pass = (normalized_expected - normalized_actual).abs <= normalized_delta
      full_message = _assert_in_delta_message(expected_float,
                                              normalized_expected,
                                              actual_float,
                                              normalized_actual,
                                              delta,
                                              normalized_delta,
                                              message)
    end
    assert_block(full_message) do
      pass
    end
  end
end

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.6.2/lib/test/unit/assertions.rb, line 1089
def assert_in_epsilon(expected_float, actual_float, epsilon=0.001,
                      message="")
  _wrap_assertion do
    begin
      zero_p = expected_float.zero? rescue expected_float == 0
      if zero_p
        delta = epsilon ** 2
      else
        delta = expected_float * epsilon
      end
      delta = delta.abs
      pass = (expected_float - actual_float).abs <= delta
      assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
      full_message = _assert_in_epsilon_message(expected_float,
                                                expected_float,
                                                actual_float,
                                                actual_float,
                                                epsilon,
                                                epsilon,
                                                delta,
                                                message)
    rescue Test::Unit::AssertionFailedError
      # for the above assert_operator
      raise
    rescue
      _assert_in_epsilon_validate_arguments(expected_float,
                                            actual_float,
                                            epsilon)
      normalized_expected = expected_float.to_f
      normalized_actual = actual_float.to_f
      normalized_epsilon = epsilon.to_f
      if normalized_expected.zero?
        delta = normalized_epsilon ** 2
      else
        delta = normalized_expected * normalized_epsilon
      end
      delta = delta.abs
      full_message = _assert_in_epsilon_message(expected_float,
                                                normalized_expected,
                                                actual_float,
                                                normalized_actual,
                                                epsilon,
                                                normalized_epsilon,
                                                delta,
                                                message)
      pass = (normalized_expected - normalized_actual).abs <= delta
    end
    assert_block(full_message) do
      pass
    end
  end
end

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.6.2/lib/test/unit/assertions.rb, line 1671
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)

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.6.2/lib/test/unit/assertions.rb, line 391
      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.6.2/lib/test/unit/assertions.rb, line 478
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.6.2/lib/test/unit/assertions.rb, line 601
def assert_match(pattern, string, message=nil)
  _wrap_assertion do
    pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
    full_message = build_message(message,
                                 "<?> was expected to be =~\n<?>.",
                                 pattern, string)
    assert_block(full_message) { pattern =~ string }
  end
end

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

Passes if ‘object`.nil?.

@example

assert_nil [1, 2].uniq!

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 462
      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.6.2/lib/test/unit/assertions.rb, line 798
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.6.2/lib/test/unit/assertions.rb, line 1519
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.6.2/lib/test/unit/assertions.rb, line 1755
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.6.2/lib/test/unit/assertions.rb, line 740
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.6.2/lib/test/unit/assertions.rb, line 971
def assert_not_in_delta(expected_float, actual_float, delta=0.001, message="")
  _wrap_assertion do
    _assert_in_delta_validate_arguments(expected_float,
                                        actual_float,
                                        delta)
    begin
      pass = (expected_float - actual_float).abs > delta
      full_message = _assert_in_delta_message(expected_float,
                                              expected_float,
                                              actual_float,
                                              actual_float,
                                              delta,
                                              delta,
                                              message,
                                              :negative_assertion => true)
    rescue
      normalized_expected = expected_float.to_f
      normalized_actual = actual_float.to_f
      normalized_delta = delta.to_f
      pass = (normalized_expected - normalized_actual).abs > normalized_delta
      full_message = _assert_in_delta_message(expected_float,
                                              normalized_expected,
                                              actual_float,
                                              normalized_actual,
                                              delta,
                                              normalized_delta,
                                              message,
                                              :negative_assertion => true)
    end
    assert_block(full_message) do
      pass
    end
  end
end

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.6.2/lib/test/unit/assertions.rb, line 1150
def assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001,
                          message="")
  _wrap_assertion do
    begin
      delta = expected_float * epsilon
      pass = (expected_float - actual_float).abs > delta
      assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
      full_message = _assert_in_epsilon_message(expected_float,
                                                expected_float,
                                                actual_float,
                                                actual_float,
                                                epsilon,
                                                epsilon,
                                                delta,
                                                message,
                                                :negative_assertion => true)
    rescue Test::Unit::AssertionFailedError
      # for the above assert_operator
      raise
    rescue
      _assert_in_epsilon_validate_arguments(expected_float,
                                            actual_float,
                                            epsilon)
      normalized_expected = expected_float.to_f
      normalized_actual = actual_float.to_f
      normalized_epsilon = epsilon.to_f
      delta = normalized_expected * normalized_epsilon
      pass = (normalized_expected - normalized_actual).abs > delta
      full_message = _assert_in_epsilon_message(expected_float,
                                                normalized_expected,
                                                actual_float,
                                                normalized_actual,
                                                epsilon,
                                                normalized_epsilon,
                                                delta,
                                                message,
                                                :negative_assertion => true)
    end
    assert_block(full_message) do
      pass
    end
  end
end

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.6.2/lib/test/unit/assertions.rb, line 1698
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)

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.6.2/lib/test/unit/assertions.rb, line 427
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.6.2/lib/test/unit/assertions.rb, line 516
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(pattern, 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.6.2/lib/test/unit/assertions.rb, line 775
def assert_not_match(pattern, string, message=nil)
  _wrap_assertion do
    pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
    full_message = build_message(message,
                                 "<?> was expected to not match\n<?>.",
                                 pattern, string)
    assert_block(full_message) { pattern !~ string }
  end
end

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.6.2/lib/test/unit/assertions.rb, line 757
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 false or nil.

@example

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

@since 3.0.0

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 658
      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 false or nil.

@example

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

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1558
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.6.2/lib/test/unit/assertions.rb, line 574
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.6.2/lib/test/unit/assertions.rb, line 720
      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__` returns false or nil.

‘send_array` is composed of:

A receiver
A method
Arguments to the method

@example

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

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1323
      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_leaked_memory(max_increasable_size, target=:physical, message=nil) { || ... } click to toggle source

@overload assert_nothing_leaked_memory(max_increasable_size, target=:physical, message=nil, &block)

Asserts that increased memory usage by `block.call` is less
than `max_increasable_size`. `GC.start` is called before and
after `block.call`.

This assertion may be fragile. Because memory usage is
depends on the current Ruby process's memory
usage. Launching a new Ruby process for this will produce
more stable result but we need to specify target code as
`String` instead of block for the approach. We choose easy
to write API approach rather than more stable result
approach for this case.

@example Pass pattern
  require "objspace"
  size_per_object = ObjectSpace.memsize_of("Hello")
  # If memory isn't leaked, physical memory of almost created objects
  # (1000 - 10 objects) must be freed.
  assert_nothing_leaked_memory(size_per_object * 10) do
    1_000.times do
      "Hello".dup
    end
  end # => pass

@example Failure pattern
  require "objspace"
  size_per_object = ObjectSpace.memsize_of("Hello")
  strings = []
  assert_nothing_leaked_memory(size_per_object * 10) do
    10_000.times do
      # Created objects aren't GC-ed because they are referred.
      strings << "Hello".dup
    end
  end # => failure

@param target [:physical, :virtual] which memory usage is
  used for comparing. `:physical` means physical memory usage
  also known as Resident Set Size (RSS). `:virtual` means
  virtual memory usage.
@yield [] do anything you want to measure memory usage
  in the block.
@yieldreturn [void]
@return [void]

@since 3.4.5

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1871
      def assert_nothing_leaked_memory(max_increasable_size,
                                       target=:physical,
                                       message=nil)
        _wrap_assertion do
          GC.start
          before = Util::MemoryUsage.new
          unless before.collected?
            omit("memory usage collection isn't supported on this platform")
          end
          yield
          GC.start
          after = Util::MemoryUsage.new
          before_value = before.__send__(target)
          after_value = after.__send__(target)
          actual_increased_size = after_value - before_value
          template = <<-TEMPLATE
<?> was expected to be less than
<?>.
          TEMPLATE
          full_message = build_message(message,
                                       template,
                                       actual_increased_size,
                                       max_increasable_size)
          assert_block(full_message) do
            actual_increased_size < max_increasable_size
          end
        end
      end

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.6.2/lib/test/unit/assertions.rb, line 683
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.6.2/lib/test/unit/assertions.rb, line 903
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 not false nor nil.

@example

assert_operator 5, :>=, 4

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 635
      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.6.2/lib/test/unit/assertions.rb, line 1634
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.6.2/lib/test/unit/assertions.rb, line 1652
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 not false nor nil.

@example

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

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1536
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.6.2/lib/test/unit/assertions.rb, line 269
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.6.2/lib/test/unit/assertions.rb, line 366
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.6.2/lib/test/unit/assertions.rb, line 1464
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_raise_with_message(expected_exception_class, expected_message, message=nil, &block) click to toggle source

Passes if the block raises ‘expected_exception` with `expected_message`. `expected_message` can be a `String` or `Regexp`.

@example Pass pattern: String

assert_raise_with_message(RuntimeError, "Boom!!!") do
  raise "Boom!!!"
end # -> pass

@example Pass pattern: Regexp

assert_raise_with_message(RuntimeError, /!!!/) do
  raise "Boom!!!"
end # -> pass

@example Failure pattern: Exception class isn’t matched

assert_raise_with_message(RuntimeError, "Boom!!!") do
  raise ArgumentError, "Boom!!!"
end # -> failure

@example Failure pattern: Exception message isn’t matched

assert_raise_with_message(RuntimeError, "Boom!!!") do
  raise "Hello"
end # -> failure

@since 3.4.3

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 318
def assert_raise_with_message(expected_exception_class,
                              expected_message,
                              message=nil,
                              &block)
  assert_expected_exception = Proc.new do |*_args|
    _message, assert_exception_helper, actual_exception = _args
    diff = AssertionMessage.delayed_diff([
                                           expected_exception_class,
                                           expected_message,
                                         ],
                                         [
                                           actual_exception.class,
                                           actual_exception.message,
                                         ])
    full_message = build_message(message,
                                 "<?>(<?>) exception expected but was\n" +
                                 "<?>(<?>).?",
                                 expected_exception_class,
                                 expected_message,
                                 actual_exception.class,
                                 actual_exception.message,
                                 diff)
    begin
      assert_block(full_message) do
        assert_exception_helper.expected?(actual_exception) and
          expected_message === actual_exception.message
      end
    rescue AssertionFailedError => failure
      _set_failed_information(failure,
                              expected_exception_class,
                              actual_exception)
      raise failure # For JRuby. :<
    end
    actual_exception
  end
  args = [expected_exception_class]
  args << message if message
  _assert_raise(assert_expected_exception, *args, &block)
end

assert_raises(*args, &block)

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.6.2/lib/test/unit/assertions.rb, line 551
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.6.2/lib/test/unit/assertions.rb, line 618
      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 not false nor nil.

‘send_array` is composed of:

A receiver
A method
Arguments to the method

@example

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

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1283
      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.6.2/lib/test/unit/assertions.rb, line 857
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)

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.6.2/lib/test/unit/assertions.rb, line 1374
def assert_true(actual, message=nil)
  _wrap_assertion do
    assert_block(build_message(message,
                               "<true> expected but was\n<?>",
                               actual)) do
      true == actual
    end
  end
end

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.6.2/lib/test/unit/assertions.rb, line 1904
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.6.2/lib/test/unit/assertions.rb, line 711
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.6.2/lib/test/unit/assertions.rb, line 191
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)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_empty

refute_equal(expected, actual, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_equal

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

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_in_delta

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

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_in_epsilon

refute_includes(collection, object, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_include

refute_instance_of(klass, object, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_instance_of

refute_kind_of(klass, object, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_kind_of

refute_match(pattern, string, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_match

refute_nil(object, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_nil

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

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_operator

refute_predicate(object, predicate, message=nil)

Just for minitest compatibility. :<

@since 3.0.0

Alias for: assert_not_predicate

refute_respond_to(object, method, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_respond_to

refute_same(expected, actual, message=nil)

Just for minitest compatibility. :<

@since 2.5.3

Alias for: assert_not_same

Private Instance Methods

_assert_in_delta_message(expected_float, normalized_expected, actual_float, normalized_actual, delta, normalized_delta, message, options={}) click to toggle source

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1028
      def _assert_in_delta_message(expected_float, normalized_expected,
                                   actual_float, normalized_actual,
                                   delta, normalized_delta,
                                   message, options={})
        if options[:negative_assertion]
          format = <<-EOT
<?> -/+ <?> was expected to not include
<?>.
EOT
        else
          format = <<-EOT
<?> -/+ <?> was expected to include
<?>.
EOT
        end
        arguments = [expected_float, delta, actual_float]
        relation_format = nil
        relation_arguments = nil
        if normalized_actual < normalized_expected - normalized_delta
          relation_format = "<<?> < <?>-<?>[?] <= <?>+<?>[?]>"
          relation_arguments = [actual_float,
                                expected_float, delta,
                                normalized_expected - normalized_delta,
                                expected_float, delta,
                                normalized_expected + normalized_delta]
        elsif normalized_actual <= normalized_expected + normalized_delta
          relation_format = "<<?>-<?>[?] <= <?> <= <?>+<?>[?]>"
          relation_arguments = [expected_float, delta,
                                normalized_expected - normalized_delta,
                                actual_float,
                                expected_float, delta,
                                normalized_expected + normalized_delta]
        else
          relation_format = "<<?>-<?>[?] <= <?>+<?>[?] < <?>>"
          relation_arguments = [expected_float, delta,
                                normalized_expected - normalized_delta,
                                expected_float, delta,
                                normalized_expected + normalized_delta,
                                actual_float]
        end

        if relation_format
          format += <<-EOT

Relation:
#{relation_format}
EOT
          arguments.concat(relation_arguments)
        end

        build_message(message, format, *arguments)
      end

_assert_in_delta_validate_arguments(expected_float, actual_float, delta) click to toggle source

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1012
def _assert_in_delta_validate_arguments(expected_float,
                                        actual_float,
                                        delta)
  {
    expected_float => "first float",
    actual_float => "second float",
    delta => "delta"
  }.each do |float, name|
    assert_respond_to(float, :to_f,
                      "The arguments must respond to to_f; " +
                      "the #{name} did not")
  end
  delta = delta.to_f
  assert_operator(delta, :>=, 0.0, "The delta should not be negative")
end

_assert_in_epsilon_message(expected_float, normalized_expected, actual_float, normalized_actual, epsilon, normalized_epsilon, delta, message, options={}) click to toggle source

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1216
      def _assert_in_epsilon_message(expected_float, normalized_expected,
                                     actual_float, normalized_actual,
                                     epsilon, normalized_epsilon,
                                     delta, message, options={})
        if options[:negative_assertion]
          format = <<-EOT
<?> -/+ (<?> * <?>)[?] was expected to not include
<?>.
EOT
        else
          format = <<-EOT
<?> -/+ (<?> * <?>)[?] was expected to include
<?>.
EOT
        end
        arguments = [expected_float, expected_float, epsilon, delta,
                     actual_float]

        relation_format = nil
        relation_arguments = nil
        if normalized_actual < normalized_expected - delta
          relation_format = "<<?> < <?>-(<?>*<?>)[?] <= <?>+(<?>*<?>)[?]>"
          relation_arguments = [actual_float,
                                expected_float, expected_float, epsilon,
                                normalized_expected - delta,
                                expected_float, expected_float, epsilon,
                                normalized_expected + delta]
        elsif normalized_actual <= normalized_expected + delta
          relation_format = "<<?>-(<?>*<?>)[?] <= <?> <= <?>+(<?>*<?>)[?]>"
          relation_arguments = [expected_float, expected_float, epsilon,
                                normalized_expected - delta,
                                actual_float,
                                expected_float, expected_float, epsilon,
                                normalized_expected + delta]
        else
          relation_format = "<<?>-(<?>*<?>)[?] <= <?>+(<?>*<?>)[?] < <?>>"
          relation_arguments = [expected_float, expected_float, epsilon,
                                normalized_expected - delta,
                                expected_float, expected_float, epsilon,
                                normalized_expected + delta,
                                actual_float]
        end

        if relation_format
          format += <<-EOT

Relation:
#{relation_format}
EOT
          arguments.concat(relation_arguments)
        end

        build_message(message, format, *arguments)
      end

_assert_in_epsilon_validate_arguments(expected_float, actual_float, epsilon) click to toggle source

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1200
def _assert_in_epsilon_validate_arguments(expected_float,
                                          actual_float,
                                          epsilon)
  {
    expected_float => "first float",
    actual_float => "second float",
    epsilon => "epsilon"
  }.each do |float, name|
    assert_respond_to(float, :to_f,
                      "The arguments must respond to to_f; " +
                      "the #{name} did not")
  end
  epsilon = epsilon.to_f
  assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
end

_assert_raise(assert_expected_exception, *args) { || ... } click to toggle source

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1944
def _assert_raise(assert_expected_exception, *args, &block)
  _wrap_assertion do
    if args.last.is_a?(String)
      message = args.pop
    else
      message = ""
    end

    assert_exception_helper = AssertExceptionHelper.new(self, args)
    expected = assert_exception_helper.expected_exceptions
    actual_exception = nil
    full_message = build_message(message,
                                 "<?> exception was expected " +
                                 "but none was thrown.",
                                 expected)
    assert_block(full_message) do
      begin
        yield
        false
      rescue Exception => actual_exception
        true
      end
    end
    assert_expected_exception.call(message, assert_exception_helper,
                                   actual_exception)
    actual_exception
  end
end

_set_failed_information(failure, expected, actual) click to toggle source

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1973
def _set_failed_information(failure, expected, actual)
  failure.expected = expected
  failure.actual = actual
  failure.inspected_expected = AssertionMessage.convert(expected)
  failure.inspected_actual = AssertionMessage.convert(actual)
end

_wrap_assertion(&block) click to toggle source

# File test-unit-3.6.2/lib/test/unit/assertions.rb, line 1910
def _wrap_assertion(&block)
  @_assertion_wrapped ||= false
  if @_assertion_wrapped
    block.call
  else
    @_assertion_wrapped = true
    begin
      add_assertion
      block.call
    ensure
      @_assertion_wrapped = false
    end
  end
end