Module: Test::Unit::Assertions
Relationships & Source Files | |
Namespace Children | |
Classes:
| |
Extension / Inclusion / Inheritance Descendants | |
Included In:
| |
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().
Class Attribute Summary
-
.use_pp=(value)
writeonly
Select whether or not to use the pretty-printer.
Instance Method Summary
-
#add_assertion ⇒ void
Called whenever an assertion is made.
- #assert(object, message = nil) ⇒ void
-
#assert_alias_method(object, alias_name, original_name, message = nil)
Passes if
object
#alias_name
is an alias method ofobject
#original_name
. -
#assert_block(message = "assert_block failed.")
The assertion upon which all other assertions are based.
-
#assert_boolean(actual, message = nil)
Passes if
actual
is a boolean value. -
#assert_compare(expected, operator, actual, message = nil)
Passes if expression “
expected
operator
actual
” is true. -
#assert_const_defined(object, constant_name, message = nil)
Passes if
object
.const_defined?(constant_name
). -
#assert_empty(object, message = nil)
Passes if
object
is empty. -
#assert_equal(expected, actual, message = nil)
Passes if
expected
==actual
. -
#assert_fail_assertion(message = nil)
Passes if assertion is failed in block.
-
#assert_false(actual, message = nil)
Passes if
actual
is false. -
#assert_in_delta(expected_float, actual_float, delta = 0.001, message = "")
Passes if
expected_float
andactual_float
are equal withindelta
tolerance. -
#assert_in_epsilon(expected_float, actual_float, epsilon = 0.001, message = "")
Passes if
expected_float
andactual_float
are equal withinepsilon
relative error ofexpected_float
. -
#assert_include(collection, object, message = nil)
(also: #assert_includes)
Passes if
collection
includesobject
. -
#assert_includes(collection, object, message = nil)
Alias for #assert_include.
-
#assert_instance_of(klass, object, message = "")
Passes if
object
.instance_of?(klass
). -
#assert_kind_of(klass, object, message = "")
Passes if
object
.kind_of?(klass
). -
#assert_match(pattern, string, message = "")
Passes if
pattern
=~string
. -
#assert_nil(object, message = "")
Passes if
object
is nil. -
#assert_no_match(regexp, string, message = "")
Deprecated.
-
#assert_not_const_defined(object, constant_name, message = nil)
Passes if !
object
.const_defined?(constant_name
). -
#assert_not_empty(object, message = nil)
(also: #refute_empty)
Passes if
object
is not empty. -
#assert_not_equal(expected, actual, message = "")
(also: #refute_equal)
Passes if
expected
!=actual
-
#assert_not_in_delta(expected_float, actual_float, delta = 0.001, message = "")
(also: #refute_in_delta)
Passes if
expected_float
andactual_float
are not equal withindelta
tolerance. -
#assert_not_in_epsilon(expected_float, actual_float, epsilon = 0.001, message = "")
(also: #refute_in_epsilon)
Passes if
expected_float
andactual_float
are not equal withinepsilon
relative error ofexpected_float
. -
#assert_not_include(collection, object, message = nil)
(also: #assert_not_includes, #refute_includes)
Passes if
collection
doesn't includeobject
. -
#assert_not_includes(collection, object, message = nil)
Alias for #assert_not_include.
-
#assert_not_instance_of(klass, object, message = "")
(also: #refute_instance_of)
Passes if
object
.instance_of?(klass
) does not hold. -
#assert_not_kind_of(klass, object, message = "")
(also: #refute_kind_of)
Passes if
object
.kind_of?(klass
) does not hold. -
#assert_not_match(regexp, string, message = "")
(also: #refute_match)
Passes if
regexp
!~string
-
#assert_not_nil(object, message = "")
(also: #refute_nil)
Passes if !
object
.nil?
-
#assert_not_operator(object1, operator, object2, message = "")
(also: #refute_operator)
Compares the
object1
withobject2
usingoperator
. -
#assert_not_predicate(object, predicate, message = nil)
(also: #refute_predicate)
Passes if
object
.predicate
is not true. -
#assert_not_respond_to(object, method, message = "")
(also: #refute_respond_to)
Passes if
object
does not.respond_to?
method
. -
#assert_not_same(expected, actual, message = "")
(also: #refute_same)
Passes if !
actual
.equal?
expected
-
#assert_not_send(send_array, message = nil)
Passes if the method send doesn't return a true value.
-
#assert_nothing_raised(*args)
Passes if block does not raise an exception.
-
#assert_nothing_thrown(message = "", &proc)
Passes if block does not throw anything.
-
#assert_operator(object1, operator, object2, message = "")
Compares the
object1
withobject2
usingoperator
. -
#assert_path_exist(path, message = nil)
Passes if
path
exists. -
#assert_path_not_exist(path, message = nil)
Passes if
path
doesn't exist. -
#assert_predicate(object, predicate, message = nil)
Passes if
object
.predicate
is true. -
#assert_raise(*args, &block)
(also: #assert_raises)
Passes if the block raises one of the expected exceptions.
-
#assert_raise_kind_of(*args, &block)
Passes if the block raises one of the given exceptions or sub exceptions of the given exceptions.
-
#assert_raise_message(expected, message = nil)
Passes if an exception is raised in block and its message is
expected
. -
#assert_raises(*args, &block)
Alias for #assert_raise.
-
#assert_respond_to(object, method, message = "")
Passes if
object
.respond_to?
method
-
#assert_same(expected, actual, message = "")
Passes if
actual
.equal?
expected
(i.e. -
#assert_send(send_array, message = nil)
Passes if the method send returns a true value.
-
#assert_throw(expected_object, message = "", &proc)
(also: #assert_throws)
Passes if the block throws
expected_object
-
#assert_throws(expected_object, message = "", &proc)
Alias for #assert_throw.
-
#assert_true(actual, message = nil)
Passes if
actual
is true. -
#build_message(head, template = nil, *arguments)
Builds a failure message.
-
#flunk(message = "Flunked")
Flunk always fails.
-
#refute(object, message = nil) ⇒ void
Asserts that
object
is false or nil. -
#refute_empty(object, message = nil)
Alias for #assert_not_empty.
-
#refute_equal(expected, actual, message = "")
Alias for #assert_not_equal.
-
#refute_in_delta(expected_float, actual_float, delta = 0.001, message = "")
Alias for #assert_not_in_delta.
-
#refute_in_epsilon(expected_float, actual_float, epsilon = 0.001, message = "")
Alias for #assert_not_in_epsilon.
-
#refute_includes(collection, object, message = nil)
Alias for #assert_not_include.
-
#refute_instance_of(klass, object, message = "")
Alias for #assert_not_instance_of.
-
#refute_kind_of(klass, object, message = "")
Alias for #assert_not_kind_of.
-
#refute_match(regexp, string, message = "")
Alias for #assert_not_match.
-
#refute_nil(object, message = "")
Alias for #assert_not_nil.
-
#refute_operator(object1, operator, object2, message = "")
Alias for #assert_not_operator.
-
#refute_predicate(object, predicate, message = nil)
Alias for #assert_not_predicate.
-
#refute_respond_to(object, method, message = "")
Alias for #assert_not_respond_to.
-
#refute_same(expected, actual, message = "")
Alias for #assert_not_same.
- #_assert_in_delta_message(expected_float, actual_float, delta, message, options = {}) private
- #_assert_in_delta_validate_arguments(expected_float, actual_float, delta) private
- #_assert_in_epsilon_message(expected_float, actual_float, epsilon, message, options = {}) private
- #_assert_in_epsilon_validate_arguments(expected_float, actual_float, epsilon) private
- #_assert_raise(assert_expected_exception, *args, &block) private
- #_set_failed_information(failure, expected, actual, user_message) private
- #_wrap_assertion(&block) private
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.
# File 'lib/test/unit/assertions.rb', line 1653
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 921
def (expected_float, actual_float, delta, , ={}) if [:negative_assertion] format = <<-EOT <?> -/+ <?> expected to not include <?>. EOT else format = <<-EOT <?> -/+ <?> 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 (, format, *arguments) end
#_assert_in_delta_validate_arguments(expected_float, actual_float, delta) (private)
[ GitHub ]# File 'lib/test/unit/assertions.rb', line 905
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 1055
def (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 if [:negative_assertion] format = <<-EOT <?> -/+ (<?> * <?>)[?] expected to not include <?>. EOT else format = <<-EOT <?> -/+ (<?> * <?>)[?] 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 (, format, *arguments) end
#_assert_in_epsilon_validate_arguments(expected_float, actual_float, epsilon) (private)
[ GitHub ]# File 'lib/test/unit/assertions.rb', line 1039
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 1658
def _assert_raise(assert_expected_exception, *args, &block) _wrap_assertion do if args.last.is_a?(String) = args.pop else = "" end assert_exception_helper = AssertExceptionHelper.new(self, args) expected = assert_exception_helper.expected_exceptions actual_exception = nil = (, "<?> exception expected " + "but none was thrown.", expected) assert_block( ) do begin yield false rescue Exception => actual_exception true end end assert_expected_exception.call(, assert_exception_helper, actual_exception) actual_exception end end
#_set_failed_information(failure, expected, actual, user_message) (private)
[ GitHub ]# File 'lib/test/unit/assertions.rb', line 1687
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) failure. = end
#_wrap_assertion(&block) (private)
[ GitHub ]# File 'lib/test/unit/assertions.rb', line 1624
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.
# File 'lib/test/unit/assertions.rb', line 1647
def add_assertion end
#assert(object, message = nil) ⇒ void
#assert(message=nil) {}) { ... } ⇒ void
void
#assert(message=nil) {}) { ... } ⇒ void
# File 'lib/test/unit/assertions.rb', line 129
def assert(object=NOT_SPECIFIED, =nil, &block) _wrap_assertion do have_object = !NOT_SPECIFIED.equal?(object) if block = object if have_object if defined?(PowerAssert) PowerAssert.start(block, :assertion_method => __callee__) do |pa| = AssertionMessage.delayed_literal(&pa. ) = (, "?", ) assert_block( ) do pa.yield end end else assert(yield, ) end else unless have_object raise ArgumentError, "wrong number of arguments (0 for 1..2)" end = nil case when nil, String, Proc when AssertionMessage = else = "assertion message must be String, Proc or " << "#{AssertionMessage}: " << "<#{ .inspect}>(<#{ .class}>)" raise ArgumentError, , filter_backtrace(caller) end ||= (, "<?> is not true.", object) assert_block( ) 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
.
# File 'lib/test/unit/assertions.rb', line 1429
def assert_alias_method(object, alias_name, original_name, =nil) _wrap_assertion do = Proc.new do |method_name| (, "<?>.? doesn't exist\n" + "(Class: <?>)", object, AssertionMessage.literal(method_name), object.class) end alias_method = original_method = nil assert_block( .call(alias_name)) do begin alias_method = object.method(alias_name) true rescue NameError false end end assert_block( .call(original_name)) do begin original_method = object.method(original_name) true rescue NameError false end end = (, "<?> is alias of\n" + "<?> expected", alias_method, original_method) assert_block( ) do alias_method == original_method end end end
#assert_block(message = "assert_block failed.")
The assertion upon which all other assertions are based. Passes if the block yields true.
# File 'lib/test/unit/assertions.rb', line 52
def assert_block(="assert_block failed.") _wrap_assertion do if (! yield) raise AssertionFailedError.new( .to_s) end end end
#assert_boolean(actual, message = nil)
Passes if actual
is a boolean value.
# File 'lib/test/unit/assertions.rb', line 1200
def assert_boolean(actual, =nil) _wrap_assertion do assert_block( (, "<true> or <false> expected but was\n<?>", actual)) do [true, false].include?(actual) end end end
#assert_compare(expected, operator, actual, message = nil)
Passes if expression “expected
operator
actual
” is true.
# File 'lib/test/unit/assertions.rb', line 1249
def assert_compare(expected, operator, actual, =nil) _wrap_assertion do assert_send([["<", "<=", ">", ">="], :include?, operator.to_s]) case operator.to_s when "<" operator_description = "less than" when "<=" operator_description = "less than or equal to" when ">" operator_description = "greater than" when ">=" operator_description = "greater than or equal to" end template = <<-EOT <?> #{operator} <?> should be true <?> expected #{operator_description} <?>. EOT = (, template, expected, actual, expected, actual) assert_block( ) do expected.__send__(operator, actual) end end end
#assert_const_defined(object, constant_name, message = nil)
Passes if object
.const_defined?(constant_name
)
# File 'lib/test/unit/assertions.rb', line 1344
def assert_const_defined(object, constant_name, =nil) _wrap_assertion do = (, "<?>.const_defined\\?(<?>) expected.", object, constant_name) assert_block( ) do object.const_defined?(constant_name) end end end
#assert_empty(object, message = nil)
Passes if object
is empty.
# File 'lib/test/unit/assertions.rb', line 1574
def assert_empty(object, =nil) _wrap_assertion do assert_respond_to(object, :empty?, "The object must respond to :empty?.") = (, "<?> expected to be empty.", object) assert_block( ) 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.
# File 'lib/test/unit/assertions.rb', line 220
def assert_equal(expected, actual, =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 = (, format, expected, expected.encoding.name, actual, actual.encoding.name, diff) else = (, <<EOT, expected, actual, diff) <?> expected but was <?>.? EOT end begin assert_block( ) { 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.
# File 'lib/test/unit/assertions.rb', line 1282
def assert_fail_assertion(=nil) _wrap_assertion do = (, "Failed assertion was expected.") assert_block( ) do begin yield false rescue AssertionFailedError true end end end end
#assert_false(actual, message = nil)
Passes if actual
is false.
# File 'lib/test/unit/assertions.rb', line 1232
def assert_false(actual, =nil) _wrap_assertion do assert_block( (, "<false> expected but was\n<?>", actual)) do actual == false 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.
# File 'lib/test/unit/assertions.rb', line 861
def assert_in_delta(expected_float, actual_float, delta=0.001, ="") _wrap_assertion do _assert_in_delta_validate_arguments(expected_float, actual_float, delta) = (expected_float, actual_float, delta, ) assert_block( ) 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
.
# File 'lib/test/unit/assertions.rb', line 983
def assert_in_epsilon(expected_float, actual_float, epsilon=0.001, ="") _wrap_assertion do _assert_in_epsilon_validate_arguments(expected_float, actual_float, epsilon) = (expected_float, actual_float, epsilon, ) assert_block( ) 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
.
# File 'lib/test/unit/assertions.rb', line 1513
def assert_include(collection, object, =nil) _wrap_assertion do assert_respond_to(collection, :include?, "The collection must respond to :include?.") = (, "<?> expected to include\n<?>.", collection, object) assert_block( ) do collection.include?(object) end end end
#assert_includes(collection, object, message = nil)
Alias for #assert_include.
# File 'lib/test/unit/assertions.rb', line 1530
alias_method :assert_includes, :assert_include
#assert_instance_of(klass, object, message = "")
Passes if object
.instance_of?(klass
). When klass
is an array of classes, it passes if any class satisfies +object.instance_of?(class).
# File 'lib/test/unit/assertions.rb', line 322
def assert_instance_of(klass, object, ="") _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 = AssertionMessage.maybe_container(klass) do |value| "<#{value}>" end = (, <<EOT, object, , object.class) <?> expected to be instance_of\\? ? but was <?>. EOT assert_block( ) do klasses.any? {|k| object.instance_of?(k)} end end end
#assert_kind_of(klass, object, message = "")
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).
# File 'lib/test/unit/assertions.rb', line 409
def assert_kind_of(klass, object, ="") _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 = AssertionMessage.maybe_container(klass) do |value| "<#{value}>" end = (, "<?> expected to be kind_of\\?\n" + "? but was\n" + "<?>.", object, , object.class) assert_block( ) do klasses.any? {|k| object.kind_of?(k)} end end end
#assert_match(pattern, string, message = "")
Passes if pattern
=~ string
.
# File 'lib/test/unit/assertions.rb', line 532
def assert_match(pattern, string, ="") _wrap_assertion do pattern = case(pattern) when String Regexp.new(Regexp.escape(pattern)) else pattern end = (, "<?> expected to be =~\n<?>.", pattern, string) assert_block( ) { pattern =~ string } end end
#assert_nil(object, message = "")
Passes if object
is nil.
# File 'lib/test/unit/assertions.rb', line 393
def assert_nil(object, ="") = (, <<EOT, object) <?> expected to be nil. EOT assert_block( ) { object.nil? } end
#assert_no_match(regexp, string, message = "")
Deprecated. Use #assert_not_match instead.
Passes if regexp
!~ string
# File 'lib/test/unit/assertions.rb', line 732
def assert_no_match(regexp, string, ="") _wrap_assertion do assert_instance_of(Regexp, regexp, "The first argument to assert_no_match " + "should be a Regexp.") assert_not_match(regexp, string, ) end end
#assert_not_const_defined(object, constant_name, message = nil)
Passes if !object
.const_defined?(constant_name
)
# File 'lib/test/unit/assertions.rb', line 1361
def assert_not_const_defined(object, constant_name, =nil) _wrap_assertion do = (, "!<?>.const_defined\\?(<?>) expected.", object, constant_name) assert_block( ) 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.
# File 'lib/test/unit/assertions.rb', line 1597
def assert_not_empty(object, =nil) _wrap_assertion do assert_respond_to(object, :empty?, "The object must respond to :empty?.") = (, "<?> expected to not be empty.", object) assert_block( ) do not object.empty? end end end
#assert_not_equal(expected, actual, message = "") Also known as: #refute_equal
Passes if expected
!= actual
# File 'lib/test/unit/assertions.rb', line 676
def assert_not_equal(expected, actual, ="") = (, "<?> expected to be != to\n<?>.", expected, actual) assert_block( ) { 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.
# File 'lib/test/unit/assertions.rb', line 883
def assert_not_in_delta(expected_float, actual_float, delta=0.001, ="") _wrap_assertion do _assert_in_delta_validate_arguments(expected_float, actual_float, delta) = (expected_float, actual_float, delta, , :negative_assertion => true) assert_block( ) 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
.
# File 'lib/test/unit/assertions.rb', line 1014
def assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001, ="") _wrap_assertion do _assert_in_epsilon_validate_arguments(expected_float, actual_float, epsilon) = (expected_float, actual_float, epsilon, , :negative_assertion => true) assert_block( ) 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
.
# File 'lib/test/unit/assertions.rb', line 1540
def assert_not_include(collection, object, =nil) _wrap_assertion do assert_respond_to(collection, :include?, "The collection must respond to :include?.") = (, "<?> expected to not include\n<?>.", collection, object) assert_block( ) do not collection.include?(object) end end end
#assert_not_includes(collection, object, message = nil)
Alias for #assert_not_include.
# File 'lib/test/unit/assertions.rb', line 1557
alias_method :assert_not_includes, :assert_not_include
#assert_not_instance_of(klass, object, message = "") 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).
# File 'lib/test/unit/assertions.rb', line 358
def assert_not_instance_of(klass, object, ="") _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 = AssertionMessage.maybe_container(klass) do |value| "<#{value}>" end = (, "<?> expected to not be instance_of\\?\n" + "? but was.", object, ) assert_block( ) do klasses.none? {|k| object.instance_of?(k)} end end end
#assert_not_kind_of(klass, object, message = "") 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).
# File 'lib/test/unit/assertions.rb', line 447
def assert_not_kind_of(klass, object, ="") _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 = AssertionMessage.maybe_container(klass) do |value| "<#{value}>" end = (, "<?> expected to not be kind_of\\?\n" + "? but was.", object, ) assert_block( ) do klasses.none? {|k| object.kind_of?(k)} end end end
#assert_not_match(regexp, string, message = "") Also known as: #refute_match
Passes if regexp
!~ string
# File 'lib/test/unit/assertions.rb', line 707
def assert_not_match(regexp, string, ="") _wrap_assertion do assert_instance_of(Regexp, regexp, "<REGEXP> in assert_not_match(<REGEXP>, ...) " + "should be a Regexp.") = (, "<?> expected to not match\n<?>.", regexp, string) assert_block( ) { regexp !~ string } end end
#assert_not_nil(object, message = "") Also known as: #refute_nil
Passes if ! object
.nil?
# File 'lib/test/unit/assertions.rb', line 691
def assert_not_nil(object, ="") = (, "<?> expected to not be nil.", object) assert_block( ){!object.nil?} end
#assert_not_operator(object1, operator, object2, message = "") Also known as: #refute_operator
Compares the object1
with object2
using operator
.
Passes if object1.__send__(operator, object2) is not true.
# File 'lib/test/unit/assertions.rb', line 593
def assert_not_operator(object1, operator, object2, ="") _wrap_assertion do = (nil, "<?>\ngiven as the operator for #assert_not_operator must be a Symbol or #respond_to\\?(:to_str).", operator) assert_block( ){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)} = (, <<EOT, object1, AssertionMessage.literal(operator), object2) <?> expected to not be ? <?>. EOT assert_block( ) { ! object1.__send__(operator, object2) } end end
#assert_not_predicate(object, predicate, message = nil) Also known as: #refute_predicate
Passes if object
.predicate
is not true.
# File 'lib/test/unit/assertions.rb', line 1400
def assert_not_predicate(object, predicate, =nil) _wrap_assertion do assert_respond_to(object, predicate, ) actual = object.__send__(predicate) = (, "<?>.? is false value expected but was\n" + "<?>", object, AssertionMessage.literal(predicate), actual) assert_block( ) do not actual end end end
#assert_not_respond_to(object, method, message = "") Also known as: #refute_respond_to
Passes if object
does not .respond_to?
method
.
# File 'lib/test/unit/assertions.rb', line 505
def assert_not_respond_to(object, method, ="") _wrap_assertion do = (, "<?>.kind_of\\?(Symbol) or\n" + "<?>.respond_to\\?(:to_str) expected", method, method) assert_block( ) do method.kind_of?(Symbol) or method.respond_to?(:to_str) end = (, "!<?>.respond_to\\?(?) expected\n" + "(Class: <?>)", object, method, object.class) assert_block( ) {!object.respond_to?(method)} end end
#assert_not_same(expected, actual, message = "") Also known as: #refute_same
Passes if ! actual
.equal?
expected
# File 'lib/test/unit/assertions.rb', line 656
def assert_not_same(expected, actual, ="") = (, <<EOT, expected, expected.__id__, actual, actual.__id__) <?> with id <?> expected to not be equal\\? to <?> with id <?>. EOT assert_block( ) { !actual.equal?(expected) } end
#assert_not_send(send_array, message = nil)
Passes if the method send doesn't return a true value.
send_array
is composed of:
-
A receiver
-
A method
-
Arguments to the method
# File 'lib/test/unit/assertions.rb', line 1165
def assert_not_send(send_array, =nil) _wrap_assertion do assert_instance_of(Array, send_array, "assert_not_send requires an array " + "of send information") assert_operator(send_array.size, :>=, 2, "assert_not_send requires at least a receiver " + "and a message name") format = <<EOT <?> expected to respond to <?(*?)> with not a true value but was <?>. EOT receiver, , *arguments = send_array result = nil = (, format, receiver, AssertionMessage.literal( .to_s), arguments, AssertionMessage.delayed_literal {result}) assert_block( ) do result = receiver.__send__(, *arguments) not result end end end
#assert_nothing_raised(*args)
Passes if block does not raise an exception.
# File 'lib/test/unit/assertions.rb', line 618
def assert_nothing_raised(*args) _wrap_assertion do if args.last.is_a?(String) = args.pop else = "" 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)) = (, "Exception raised:\n?", e) assert_block( ) {false} else raise end end nil end end
#assert_nothing_thrown(message = "", &proc)
Passes if block does not throw anything.
# File 'lib/test/unit/assertions.rb', line 837
def assert_nothing_thrown(="", &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? = (, "<?> was thrown when nothing was expected", tag) flunk( ) end assert(true, "Expected nothing to be thrown") end end
#assert_operator(object1, operator, object2, message = "")
Compares the object1
with object2
using operator
.
Passes if object1.__send__(operator, object2) is true.
# File 'lib/test/unit/assertions.rb', line 570
def assert_operator(object1, operator, object2, ="") _wrap_assertion do = (nil, "<?>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to\\?(:to_str).", operator) assert_block( ){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)} = (, <<EOT, object1, AssertionMessage.literal(operator), object2) <?> expected to be ? <?>. EOT assert_block( ) { object1.__send__(operator, object2) } end end
#assert_path_exist(path, message = nil)
Passes if path
exists.
# File 'lib/test/unit/assertions.rb', line 1476
def assert_path_exist(path, =nil) _wrap_assertion do = (, "<?> expected to exist", path) assert_block( ) do File.exist?(path) end end end
#assert_path_not_exist(path, message = nil)
Passes if path
doesn't exist.
# File 'lib/test/unit/assertions.rb', line 1494
def assert_path_not_exist(path, =nil) _wrap_assertion do = (, "<?> expected to not exist", path) assert_block( ) do not File.exist?(path) end end end
#assert_predicate(object, predicate, message = nil)
Passes if object
.predicate
is true.
# File 'lib/test/unit/assertions.rb', line 1378
def assert_predicate(object, predicate, =nil) _wrap_assertion do assert_respond_to(object, predicate, ) actual = object.__send__(predicate) = (, "<?>.? is true value expected but was\n" + "<?>", object, AssertionMessage.literal(predicate), actual) assert_block( ) 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.
# File 'lib/test/unit/assertions.rb', line 264
def assert_raise(*args, &block) assert_expected_exception = Proc.new do |*_args| , assert_exception_helper, actual_exception = _args expected = assert_exception_helper.expected_exceptions diff = AssertionMessage.delayed_diff(expected, actual_exception) = (, "<?> exception expected but was\n<?>.?", expected, actual_exception, diff) begin assert_block( ) 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.
# File 'lib/test/unit/assertions.rb', line 297
def assert_raise_kind_of(*args, &block) assert_expected_exception = Proc.new do |*_args| , assert_exception_helper, actual_exception = _args expected = assert_exception_helper.expected_exceptions = (, "<?> family exception expected " + "but was\n<?>.", expected, actual_exception) assert_block( ) 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
.
# File 'lib/test/unit/assertions.rb', line 1306
def (expected, =nil) _wrap_assertion do = (, "<?> exception message expected " + "but none was thrown.", expected) exception = nil assert_block( ) do begin yield false rescue Exception => exception true end end actual = exception. diff = AssertionMessage.delayed_diff(expected, actual) = (, "<?> exception message expected but was\n" + "<?>.?", expected, actual, diff) assert_block( ) do if expected.is_a?(Regexp) expected =~ actual else expected == actual end end end end
#assert_raises(*args, &block)
Alias for #assert_raise.
# File 'lib/test/unit/assertions.rb', line 287
alias_method :assert_raises, :assert_raise
#assert_respond_to(object, method, message = "")
Passes if object
.respond_to?
method
# File 'lib/test/unit/assertions.rb', line 482
def assert_respond_to(object, method, ="") _wrap_assertion do = (, "<?>.kind_of\\?(Symbol) or\n" + "<?>.respond_to\\?(:to_str) expected", method, method) assert_block( ) do method.kind_of?(Symbol) or method.respond_to?(:to_str) end = (, "<?>.respond_to\\?(?) expected\n" + "(Class: <?>)", object, method, object.class) assert_block( ) {object.respond_to?(method)} end end
#assert_same(expected, actual, message = "")
Passes if actual
.equal?
expected
(i.e. they are the same instance).
# File 'lib/test/unit/assertions.rb', line 553
def assert_same(expected, actual, ="") = (, <<EOT, expected, expected.__id__, actual, actual.__id__) <?> with id <?> expected to be equal\\? to <?> with id <?>. EOT assert_block( ) { actual.equal?(expected) } end
#assert_send(send_array, message = nil)
Passes if the method send returns a true value.
send_array
is composed of:
-
A receiver
-
A method
-
Arguments to the method
# File 'lib/test/unit/assertions.rb', line 1125
def assert_send(send_array, =nil) _wrap_assertion do assert_instance_of(Array, send_array, "assert_send requires an array " + "of send information") assert_operator(send_array.size, :>=, 2, "assert_send requires at least a receiver " + "and a message name") format = <<EOT <?> expected to respond to <?(*?)> with a true value but was <?>. EOT receiver, , *arguments = send_array result = nil = (, format, receiver, AssertionMessage.literal( .to_s), arguments, AssertionMessage.delayed_literal {result}) assert_block( ) do result = receiver.__send__(, *arguments) result end end end
#assert_throw(expected_object, message = "", &proc) Also known as: #assert_throws
Passes if the block throws expected_object
# File 'lib/test/unit/assertions.rb', line 791
def assert_throw(expected_object, ="", &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 = (, "<?> should have been thrown.", expected_object) assert_block( ) {caught} rescue => error extractor = ThrowTagExtractor.new(error) tag = extractor.extract_tag raise if tag.nil? = (, "<?> expected to be thrown but\n" + "<?> was thrown.", expected_object, tag) flunk( ) end end end
#assert_throws(expected_object, message = "", &proc)
Alias for #assert_throw.
# File 'lib/test/unit/assertions.rb', line 828
alias_method :assert_throws, :assert_throw
#assert_true(actual, message = nil)
Passes if actual
is true.
# File 'lib/test/unit/assertions.rb', line 1216
def assert_true(actual, =nil) _wrap_assertion do assert_block( (, "<true> expected but was\n<?>", actual)) do actual == true end end end
#build_message(head, template = nil, *arguments)
Builds a failure message. head
is added before the template
and arguments
replaces the '?'s positionally in the template.
# File 'lib/test/unit/assertions.rb', line 1618
def (head, template=nil, *arguments) template &&= template.chomp return AssertionMessage.new(head, template, arguments) end
#flunk(message = "Flunked")
Flunk always fails.
# File 'lib/test/unit/assertions.rb', line 647
def flunk(="Flunked") assert_block( ( )){false} end
#refute(object, message = nil) ⇒ void
Just for minitest compatibility. :<
This method returns an undefined value.
Asserts that object
is false or nil.
# File 'lib/test/unit/assertions.rb', line 186
def refute(object, =nil) _wrap_assertion do = nil case when nil, String, Proc when AssertionMessage = else = "assertion message must be String, Proc or " << "#{AssertionMessage}: " << "<#{ .inspect}>(<#{ .class}>)" raise ArgumentError, , filter_backtrace(caller) end assert_block("refute should not be called with a block.") do !block_given? end ||= (, "<?> is neither nil or false.", object) assert_block( ) do not object end end end
#refute_empty(object, message = nil)
Alias for #assert_not_empty.
# File 'lib/test/unit/assertions.rb', line 1613
alias_method :refute_empty, :assert_not_empty
#refute_equal(expected, actual, message = "")
Alias for #assert_not_equal.
# File 'lib/test/unit/assertions.rb', line 684
alias_method :refute_equal, :assert_not_equal
#refute_in_delta(expected_float, actual_float, delta = 0.001, message = "")
Alias for #assert_not_in_delta.
# File 'lib/test/unit/assertions.rb', line 902
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.
# File 'lib/test/unit/assertions.rb', line 1036
alias_method :refute_in_epsilon, :assert_not_in_epsilon
#refute_includes(collection, object, message = nil)
Alias for #assert_not_include.
# File 'lib/test/unit/assertions.rb', line 1562
alias_method :refute_includes, :assert_not_include
#refute_instance_of(klass, object, message = "")
Alias for #assert_not_instance_of.
# File 'lib/test/unit/assertions.rb', line 386
alias_method :refute_instance_of, :assert_not_instance_of
#refute_kind_of(klass, object, message = "")
Alias for #assert_not_kind_of.
# File 'lib/test/unit/assertions.rb', line 475
alias_method :refute_kind_of, :assert_not_kind_of
#refute_match(regexp, string, message = "")
Alias for #assert_not_match.
# File 'lib/test/unit/assertions.rb', line 722
alias_method :refute_match, :assert_not_match
#refute_nil(object, message = "")
Alias for #assert_not_nil.
# File 'lib/test/unit/assertions.rb', line 699
alias_method :refute_nil, :assert_not_nil
#refute_operator(object1, operator, object2, message = "")
Alias for #assert_not_operator.
# File 'lib/test/unit/assertions.rb', line 609
alias_method :refute_operator, :assert_not_operator
#refute_predicate(object, predicate, message = nil)
Alias for #assert_not_predicate.
# File 'lib/test/unit/assertions.rb', line 1419
alias_method :refute_predicate, :assert_not_predicate
#refute_respond_to(object, method, message = "")
Alias for #assert_not_respond_to.
# File 'lib/test/unit/assertions.rb', line 525
alias_method :refute_respond_to, :assert_not_respond_to
#refute_same(expected, actual, message = "")
Alias for #assert_not_same.
# File 'lib/test/unit/assertions.rb', line 669
alias_method :refute_same, :assert_not_same