123456789_123456789_123456789_123456789_123456789_

Module: Test::Unit::Assertions

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

Overview

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

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

Notes:

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

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

Examples:

Example Custom Assertion

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

Constant Summary

Class Attribute Summary

Instance Method Summary

Class Attribute Details

.use_pp=(value) (writeonly)

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

[ GitHub ] 

  


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



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


  







Instance Method Details



  

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

  [ GitHub ]


  

  


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



def _assert_in_delta_message(expected_float, actual_float, delta,
                             message, options={})
  if options[:negative_assertion]
    format = <<-EOT
<?> -/+ <?> was expected to not include
<?>.
EOT
  else
    format = <<-EOT
<?> -/+ <?> was expected to include
<?>.
EOT
  end
  arguments = [expected_float, delta, actual_float]
  normalized_expected = expected_float.to_f
  normalized_actual = actual_float.to_f
  normalized_delta = delta.to_f
  relation_format = nil
  relation_arguments = nil
  if normalized_actual < normalized_expected - normalized_delta
    relation_format = "<<?> < <?>-<?>[?] <= <?>+<?>[?]>"
    relation_arguments = [actual_float,
                          expected_float, delta,
                          normalized_expected - normalized_delta,
                          expected_float, delta,
                          normalized_expected + normalized_delta]
  elsif normalized_actual <= normalized_expected + normalized_delta
    relation_format = "<<?>-<?>[?] <= <?> <= <?>+<?>[?]>"
    relation_arguments = [expected_float, delta,
                          normalized_expected - normalized_delta,
                          actual_float,
                          expected_float, delta,
                          normalized_expected + normalized_delta]
  else
    relation_format = "<<?>-<?>[?] <= <?>+<?>[?] < <?>>"
    relation_arguments = [expected_float, delta,
                          normalized_expected - normalized_delta,
                          expected_float, delta,
                          normalized_expected + normalized_delta,
                          actual_float]
  end

  if relation_format
    format += <<-EOT

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

  build_message(message, format, *arguments)
end


  








  

    #_assert_in_delta_validate_arguments(expected_float, actual_float, delta)   (private)
  

  [ GitHub ]


  

  


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



def _assert_in_delta_validate_arguments(expected_float,
                                        actual_float,
                                        delta)
  {
    expected_float => "first float",
    actual_float => "second float",
    delta => "delta"
  }.each do |float, name|
    assert_respond_to(float, :to_f,
                      "The arguments must respond to to_f; " +
                      "the #{name} did not")
  end
  delta = delta.to_f
  assert_operator(delta, :>=, 0.0, "The delta should not be negative")
end


  








  

    #_assert_in_epsilon_message(expected_float, actual_float, epsilon, message, options = {})   (private)
  

  [ GitHub ]


  

  


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



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

  if options[:negative_assertion]
    format = <<-EOT
<?> -/+ (<?> * <?>)[?] was expected to not include
<?>.
EOT
  else
    format = <<-EOT
<?> -/+ (<?> * <?>)[?] was expected to include
<?>.
EOT
  end
  arguments = [expected_float, expected_float, epsilon, delta,
               actual_float]

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

  if relation_format
    format += <<-EOT

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

  build_message(message, format, *arguments)
end


  








  

    #_assert_in_epsilon_validate_arguments(expected_float, actual_float, epsilon)   (private)
  

  [ GitHub ]


  

  


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



def _assert_in_epsilon_validate_arguments(expected_float,
                                          actual_float,
                                          epsilon)
  {
    expected_float => "first float",
    actual_float => "second float",
    epsilon => "epsilon"
  }.each do |float, name|
    assert_respond_to(float, :to_f,
                      "The arguments must respond to to_f; " +
                      "the #{name} did not")
  end
  epsilon = epsilon.to_f
  assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
end


  








  

    #_assert_raise(assert_expected_exception, *args, &block)   (private)
  

  [ GitHub ]


  

  


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



def _assert_raise(assert_expected_exception, *args, &block)
  _wrap_assertion do
    if args.last.is_a?(String)
      message = args.pop
    else
      message = ""
    end

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


  








  

    #_set_failed_information(failure, expected, actual)   (private)
  

  [ GitHub ]


  

  


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



def _set_failed_information(failure, expected, actual)
  failure.expected = expected
  failure.actual = actual
  failure.inspected_expected = AssertionMessage.convert(expected)
  failure.inspected_actual = AssertionMessage.convert(actual)
end


  








  

    #_wrap_assertion(&block)   (private)
  

  [ GitHub ]


  

  


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



def _wrap_assertion(&block)
  @_assertion_wrapped ||= false
  if @_assertion_wrapped
    block.call
  else
    @_assertion_wrapped = true
    begin
      add_assertion
      block.call
    ensure
      @_assertion_wrapped = false
    end
  end
end


  








  

    #add_assertion  ⇒ void 
  



  

    
This method returns an undefined value.


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



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


  





  


  [ GitHub ]


  

  


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



def add_assertion
end


  








  

    

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

  



  

    
  





  


  [ GitHub ]


  

  


# File '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)  
  



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



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) {|Object| ... } ⇒ void     Also known as: #assert_all?
  



  

    
  





  
Since:


    
  
  • 
    
    

    3.4.4
    

    
  
    • 





  [ GitHub ]


  

  


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



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


  








  

    #assert_all?(collection, message = nil)  
  



  

    

Alias for #assert_all.


  



  [ GitHub ]


  

  


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



alias_method :assert_all?, :assert_all


  








  

    #assert_block(message = "assert_block failed.")  
  



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


# File '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)  
  



  

    

Passes if actual is a boolean value.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



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)  
  



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_compare(expected, operator, actual, message=nil)
  _wrap_assertion do
    assert_send([["<", "<=", ">", ">="], :include?, operator.to_s])
    case operator.to_s
    when "<"
      operator_description = "less than"
    when "<="
      operator_description = "less than or equal to"
    when ">"
      operator_description = "greater than"
    when ">="
      operator_description = "greater than or equal to"
    end
    template = <<-EOT
<?> #{operator} <?> should be true
<?> was expected to be #{operator_description}
<?>.
EOT
    full_message = build_message(message, template,
                                 expected, actual,
                                 expected, actual)
    assert_block(full_message) do
      expected.__send__(operator, actual)
    end
  end
end


  








  

    #assert_const_defined(object, constant_name, message = nil)  
  



  

    

Passes if object.const_defined?(constant_name)


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_const_defined(object, constant_name, message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "<?>.const_defined\\?(<?>) expected.",
                                 object, constant_name)
    assert_block(full_message) do
      object.const_defined?(constant_name)
    end
  end
end


  








  

    #assert_empty(object, message = nil)  
  



  

    

Passes if object is empty.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_empty(object, message=nil)
  _wrap_assertion do
    assert_respond_to(object, :empty?,
                      "The object must respond to :empty?.")
    full_message = build_message(message,
                                 "<?> was expected to be empty.",
                                 object)
    assert_block(full_message) do
      object.empty?
    end
  end
end


  








  

    #assert_equal(expected, actual, message = nil)  
  



  

    

Passes if expected == actual.



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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



  

    

Passes if assertion is failed in block.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_fail_assertion(message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "Failed assertion was expected.")
    assert_block(full_message) do
      begin
        yield
        false
      rescue AssertionFailedError
        true
      end
    end
  end
end


  








  

    #assert_false(actual, message = nil)  
  



  

    

Passes if actual is false.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



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



  

    

Passes if expected_float and actual_float are equal within delta tolerance.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



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


  








  

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



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



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


  








  

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



  

    

Passes if collection includes object.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_include(collection, object, message=nil)
  _wrap_assertion do
    assert_respond_to(collection, :include?,
                      "The collection must respond to :include?.")
    full_message = build_message(message,
                                 "<?> was expected to include\n<?>.",
                                 collection,
                                 object)
    assert_block(full_message) do
      collection.include?(object)
    end
  end
end


  








  

    #assert_includes(collection, object, message = nil)  
  



  

    

Alias for #assert_include.


  



  [ GitHub ]


  

  


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



alias_method :assert_includes, :assert_include


  








  

    #assert_instance_of(klass, object, message = nil)  
  



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



  

    

Passes if pattern =~ string.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


# File '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)  
  



  

    

Passes if object.nil?.


  





    

    
Examples:

      
assert_nil [1, 2].uniq!

  




  [ GitHub ]


  

  


# File '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 = "")  
  



  

    
Deprecated. 


Use #assert_not_match instead.





Passes if regexp !~ string


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_not_const_defined(object, constant_name, message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "!<?>.const_defined\\?(<?>) expected.",
                                 object, constant_name)
    assert_block(full_message) do
      !object.const_defined?(constant_name)
    end
  end
end


  








  

    #assert_not_empty(object, message = nil)  
    Also known as: #refute_empty
  



  

    

Passes if object is not empty.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_not_empty(object, message=nil)
  _wrap_assertion do
    assert_respond_to(object, :empty?,
                      "The object must respond to :empty?.")
    full_message = build_message(message,
                                 "<?> was expected to not be empty.",
                                 object)
    assert_block(full_message) do
      not object.empty?
    end
  end
end


  








  

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



  

    

Passes if expected != actual


  





    

    
Examples:

      
assert_not_equal 'some string', 5

  




  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

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



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_not_in_delta(expected_float, actual_float, delta=0.001, message="")
  _wrap_assertion do
    _assert_in_delta_validate_arguments(expected_float,
                                        actual_float,
                                        delta)
    full_message = _assert_in_delta_message(expected_float,
                                            actual_float,
                                            delta,
                                            message,
                                            :negative_assertion => true)
    assert_block(full_message) do
      (expected_float.to_f - actual_float.to_f).abs > delta.to_f
    end
  end
end


  








  

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



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



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


  








  

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



  

    

Passes if collection doesn’t include object.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_not_include(collection, object, message=nil)
  _wrap_assertion do
    assert_respond_to(collection, :include?,
                      "The collection must respond to :include?.")
    full_message = build_message(message,
                                 "<?> was expected to not include\n<?>.",
                                 collection,
                                 object)
    assert_block(full_message) do
      not collection.include?(object)
    end
  end
end


  








  

    #assert_not_includes(collection, object, message = nil)  
  



  

    

Alias for #assert_not_include.


  



  [ GitHub ]


  

  


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



alias_method :assert_not_includes, :assert_not_include


  








  

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



  

    

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


  





    

    
Examples:

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

  


Since:


    
  
  • 
    
    

    3.0.0
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

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



  

    

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


  





    

    
Examples:

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

  


Since:


    
  
  • 
    
    

    3.0.0
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

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



  

    

Passes if regexp !~ string


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

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



  

    

Passes if ! object .nil?


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

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



  

    

Compares the object1 with object2 using operator.



Passes if object1.__send__(operator, object2) is false or nil.


  





    

    
Examples:

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

  


Since:


    
  
  • 
    
    

    3.0.0
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

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



  

    

Passes if object.‘predicate` is false or nil.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_not_predicate(object, predicate, message=nil)
  _wrap_assertion do
    assert_respond_to(object, predicate, message)
    actual = object.__send__(predicate)
    full_message = build_message(message,
                                 "<?>.? is false value expected but was\n" +
                                 "<?>",
                                 object,
                                 AssertionMessage.literal(predicate),
                                 actual)
    assert_block(full_message) do
      not actual
    end
  end
end


  








  

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



  

    

Passes if object does not .respond_to? method.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

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



  

    

Passes if ! actual .equal? expected


  





    

    
Examples:

      
assert_not_same Object.new, Object.new

  




  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

    #assert_not_send(send_array, message = nil)  
  



  

    

Passes if the method __send__ returns false or nil.



send_array is composed of:


  • 

    A receiver
    

  • 

    A method
    

  • 

    Arguments to the method
    



  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



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) { ... } ⇒ void   



  

    
  





  
Since:


    
  
  • 
    
    

    3.4.5
    

    
  
    • 





  [ GitHub ]


  

  


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



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)  
  



  

    

Passes if block does not raise an exception.


  





    

    
Examples:

      
assert_nothing_raised do
  [1, 2].uniq
end

  




  [ GitHub ]


  

  


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



  

    

Passes if block does not throw anything.


  





    

    
Examples:

      
assert_nothing_thrown do
  [1, 2].uniq
end

  




  [ GitHub ]


  

  


# File '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)  
  



  

    

Compares the object1 with object2 using operator.



Passes if object1.__send__(operator, object2) is not false nor nil.


  





    

    
Examples:

      
assert_operator 5, :>=, 4

  




  [ GitHub ]


  

  


# File '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)  
  



  

    

Passes if path exists.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_path_exist(path, message=nil)
  _wrap_assertion do
    failure_message = build_message(message,
                                    "<?> was expected to exist",
                                    path)
    assert_block(failure_message) do
      File.exist?(path)
    end
  end
end


  








  

    #assert_path_not_exist(path, message = nil)  
  



  

    

Passes if path doesn’t exist.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_path_not_exist(path, message=nil)
  _wrap_assertion do
    failure_message = build_message(message,
                                    "<?> was expected to not exist",
                                    path)
    assert_block(failure_message) do
      not File.exist?(path)
    end
  end
end


  








  

    #assert_predicate(object, predicate, message = nil)  
  



  

    

Passes if object.‘predicate` is not false nor nil.


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_predicate(object, predicate, message=nil)
  _wrap_assertion do
    assert_respond_to(object, predicate, message)
    actual = object.__send__(predicate)
    full_message = build_message(message,
                                 "<?>.? is true value expected but was\n" +
                                 "<?>",
                                 object,
                                 AssertionMessage.literal(predicate),
                                 actual)
    assert_block(full_message) do
      actual
    end
  end
end


  








  

    #assert_raise(*args, &block)  
    Also known as: #assert_raises
  



  

    

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


  





    

    
Examples:

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

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

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

  




  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

    #assert_raise_kind_of(*args, &block)  
  



  

    

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


  





    

    
Examples:

      
assert_raise_kind_of(SystemCallError) do
  raise Errno::EACCES
end

  




  [ GitHub ]


  

  


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



  

    

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


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



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)  
  



  

    

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


  





    

    
Examples:

        


Pass pattern: String



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

        


Pass pattern: Regexp



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

        


Failure pattern: Exception class isn’t matched



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

        


Failure pattern: Exception message isn’t matched



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

  


Since:


    
  
  • 
    
    

    3.4.3
    

    
  
    • 





  [ GitHub ]


  

  


# File '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)  
  



  

    

Alias for #assert_raise.


  



  [ GitHub ]


  

  


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



alias_method :assert_raises, :assert_raise


  








  

    #assert_respond_to(object, method, message = nil)  
  



  

    

Passes if object .respond_to? method


  





    

    
Examples:

      
assert_respond_to 'bugbear', :slice

  




  [ GitHub ]


  

  


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



  

    

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


  





    

    
Examples:

      
o = Object.new
assert_same o, o

  




  [ GitHub ]


  

  


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



  

    

Passes if the method __send__ returns not false nor nil.



send_array is composed of:


  • 

    A receiver
    

  • 

    A method
    

  • 

    Arguments to the method
    



  





    

    
Examples:

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

  




  [ GitHub ]


  

  


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



def assert_send(send_array, message=nil)
  _wrap_assertion do
    assert_instance_of(Array, send_array,
                       "assert_send requires an array " +
                       "of send information")
    assert_operator(send_array.size, :>=, 2,
                    "assert_send requires at least a receiver " +
                    "and a message name")
    format = <<EOT
<?> was expected to respond to
<?(*?)> with a true value but was
<?>.
EOT
    receiver, message_name, *arguments = send_array
    result = nil
    full_message =
      build_message(message,
                    format,
                    receiver,
                    AssertionMessage.literal(message_name.to_s),
                    arguments,
                    AssertionMessage.delayed_literal {result})
    assert_block(full_message) do
      result = receiver.__send__(message_name, *arguments)
      result
    end
  end
end


  








  

    #assert_throw(expected_object, message = nil, &proc)  
    Also known as: #assert_throws
  



  

    

Passes if the block throws expected_object


  





    

    
Examples:

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

  




  [ GitHub ]


  

  


# File 'lib/test/unit/assertions.rb', line 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


  








  

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



  

    

Alias for #assert_throw.


  



  [ GitHub ]


  

  


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



alias_method :assert_throws, :assert_throw


  








  

    #assert_true(actual, message = nil)  
  



  

    

Passes if actual is true.


  





    

    
Examples:

      
assert_true(true)  # -> pass
assert_true(:true) # -> fail

  




  [ GitHub ]


  

  


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



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)  
  



  

    

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


  



  [ GitHub ]


  

  


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



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


  








  

    #flunk(message = "Flunked")  
  



  

    

Flunk always fails.


  





    

    
Examples:

      
flunk 'Not done testing yet.'

  




  [ GitHub ]


  

  


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



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


  








  

    #refute(object, message = nil)  ⇒ void 
  



  

    
  

    Note:
    


Just for minitest compatibility. :<



  



This method returns an undefined value.


Asserts that object is false or nil.


  





    

    
Examples:

        


Pass patterns



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

        


Failure patterns



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

  


Parameters:


    
  
  • 
    object
    (Object)
—    
    

    The object to be asserted.
    

    
  
    • 



Since:


    
  
  • 
    
    

    2.5.3
    

    
  
    • 





  [ GitHub ]


  

  


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



  

    

Alias for #assert_not_empty.


  



  [ GitHub ]


  

  


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



alias_method :refute_empty, :assert_not_empty


  








  

    #refute_equal(expected, actual, message = nil)  
  



  

    

Alias for #assert_not_equal.


  



  [ GitHub ]


  

  


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



alias_method :refute_equal, :assert_not_equal


  








  

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



  

    

Alias for #assert_not_in_delta.


  



  [ GitHub ]


  

  


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



alias_method :refute_in_delta, :assert_not_in_delta


  








  

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



  

    

Alias for #assert_not_in_epsilon.


  



  [ GitHub ]


  

  


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



alias_method :refute_in_epsilon, :assert_not_in_epsilon


  








  

    #refute_includes(collection, object, message = nil)  
  



  

    

Alias for #assert_not_include.


  



  [ GitHub ]


  

  


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



alias_method :refute_includes, :assert_not_include


  








  

    #refute_instance_of(klass, object, message = nil)  
  



  

    

Alias for #assert_not_instance_of.


  



  [ GitHub ]


  

  


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



alias_method :refute_instance_of, :assert_not_instance_of


  








  

    #refute_kind_of(klass, object, message = nil)  
  



  

    

Alias for #assert_not_kind_of.


  



  [ GitHub ]


  

  


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



alias_method :refute_kind_of, :assert_not_kind_of


  








  

    #refute_match(pattern, string, message = nil)  
  



  

    

Alias for #assert_not_match.


  



  [ GitHub ]


  

  


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



alias_method :refute_match, :assert_not_match


  








  

    #refute_nil(object, message = nil)  
  



  

    

Alias for #assert_not_nil.


  



  [ GitHub ]


  

  


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



alias_method :refute_nil, :assert_not_nil


  








  

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



  

    

Alias for #assert_not_operator.


  



  [ GitHub ]


  

  


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



alias_method :refute_operator, :assert_not_operator


  








  

    #refute_predicate(object, predicate, message = nil)  
  



  

    

Alias for #assert_not_predicate.


  



  [ GitHub ]


  

  


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



alias_method :refute_predicate, :assert_not_predicate


  








  

    #refute_respond_to(object, method, message = nil)  
  



  

    

Alias for #assert_not_respond_to.


  



  [ GitHub ]


  

  


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



alias_method :refute_respond_to, :assert_not_respond_to


  








  

    #refute_same(expected, actual, message = nil)  
  



  

    

Alias for #assert_not_same.


  



  [ GitHub ]


  

  


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



alias_method :refute_same, :assert_not_same