Module: Test::Unit::Assertions
- Included in:
- TestCase
- Defined in:
- lib/test/unit/assertions.rb
Overview
Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is included in Test::Unit::TestCase.
To include it in your own code and use its functionality, you simply need to rescue Test::Unit::AssertionFailedError. Additionally you may override add_assertion to get notified whenever an assertion is made.
Notes:
-
The message to each assertion, if given, will be propagated with the failure.
-
It is easy to add your own assertions based on assert_block().
Defined Under Namespace
Classes: AssertExceptionHelper, AssertionMessage, ThrowTagExtractor
Constant Summary collapse
- NOT_SPECIFIED =
Object.new
Class Method Summary collapse
-
.use_pp=(value) ⇒ Object
Select whether or not to use the pretty-printer.
Instance Method Summary collapse
-
#add_assertion ⇒ void
Called whenever an assertion is made.
- #assert(object = NOT_SPECIFIED, message = nil, &block) ⇒ Object
-
#assert_alias_method(object, alias_name, original_name, message = nil) ⇒ Object
Passes if ‘object`#`alias_name` is an alias method of `object`#`original_name`.
-
#assert_all(collection, message = nil) {|Object| ... } ⇒ void
(also: #assert_all?)
Asserts that all ‘block.call(item)` where `item` is each item in `collection` are not false nor nil.
-
#assert_block(message = "assert_block failed.") ⇒ Object
The assertion upon which all other assertions are based.
-
#assert_boolean(actual, message = nil) ⇒ Object
Passes if ‘actual` is a boolean value.
-
#assert_compare(expected, operator, actual, message = nil) ⇒ Object
Passes if expression “‘expected` `operator` `actual`” is not false nor nil.
-
#assert_const_defined(object, constant_name, message = nil) ⇒ Object
Passes if ‘object`.const_defined?(`constant_name`).
-
#assert_empty(object, message = nil) ⇒ Object
Passes if ‘object` is empty.
-
#assert_equal(expected, actual, message = nil) ⇒ Object
Passes if ‘expected` == `actual`.
-
#assert_fail_assertion(message = nil) ⇒ Object
Passes if assertion is failed in block.
-
#assert_false(actual, message = nil) ⇒ Object
Passes if ‘actual` is false.
-
#assert_in_delta(expected_float, actual_float, delta = 0.001, message = "") ⇒ Object
Passes if ‘expected_float` and `actual_float` are equal within `delta` tolerance.
-
#assert_in_epsilon(expected_float, actual_float, epsilon = 0.001, message = "") ⇒ Object
Passes if ‘expected_float` and `actual_float` are equal within `epsilon` relative error of `expected_float`.
-
#assert_include(collection, object, message = nil) ⇒ Object
(also: #assert_includes)
Passes if ‘collection` includes `object`.
-
#assert_instance_of(klass, object, message = nil) ⇒ Object
Passes if ‘object`.instance_of?(`klass`).
-
#assert_kind_of(klass, object, message = nil) ⇒ Object
Passes if ‘object`.kind_of?(`klass`).
-
#assert_match(pattern, string, message = nil) ⇒ Object
Passes if ‘pattern` =~ `string`.
-
#assert_nil(object, message = nil) ⇒ Object
Passes if ‘object`.nil?.
-
#assert_no_match(regexp, string, message = "") ⇒ Object
deprecated
Deprecated.
Use #assert_not_match instead.
-
#assert_not_const_defined(object, constant_name, message = nil) ⇒ Object
Passes if !‘object`.const_defined?(`constant_name`).
-
#assert_not_empty(object, message = nil) ⇒ Object
(also: #refute_empty)
Passes if ‘object` is not empty.
-
#assert_not_equal(expected, actual, message = nil) ⇒ Object
(also: #refute_equal)
Passes if ‘expected` != `actual`.
-
#assert_not_in_delta(expected_float, actual_float, delta = 0.001, message = "") ⇒ Object
(also: #refute_in_delta)
Passes if ‘expected_float` and `actual_float` are not equal within `delta` tolerance.
-
#assert_not_in_epsilon(expected_float, actual_float, epsilon = 0.001, message = "") ⇒ Object
(also: #refute_in_epsilon)
Passes if ‘expected_float` and `actual_float` are not equal within `epsilon` relative error of `expected_float`.
-
#assert_not_include(collection, object, message = nil) ⇒ Object
(also: #assert_not_includes, #refute_includes)
Passes if ‘collection` doesn’t include ‘object`.
-
#assert_not_instance_of(klass, object, message = nil) ⇒ Object
(also: #refute_instance_of)
Passes if ‘object`.instance_of?(`klass`) does not hold.
-
#assert_not_kind_of(klass, object, message = nil) ⇒ Object
(also: #refute_kind_of)
Passes if ‘object`.kind_of?(`klass`) does not hold.
-
#assert_not_match(pattern, string, message = nil) ⇒ Object
(also: #refute_match)
Passes if ‘regexp` !~ `string`.
-
#assert_not_nil(object, message = nil) ⇒ Object
(also: #refute_nil)
Passes if ! ‘object` .nil?.
-
#assert_not_operator(object1, operator, object2, message = nil) ⇒ Object
(also: #refute_operator)
Compares the ‘object1` with `object2` using `operator`.
-
#assert_not_predicate(object, predicate, message = nil) ⇒ Object
(also: #refute_predicate)
Passes if ‘object`.`predicate` is false or nil.
-
#assert_not_respond_to(object, method, message = nil) ⇒ Object
(also: #refute_respond_to)
Passes if ‘object` does not .respond_to? `method`.
-
#assert_not_same(expected, actual, message = nil) ⇒ Object
(also: #refute_same)
Passes if ! ‘actual` .equal? `expected`.
-
#assert_not_send(send_array, message = nil) ⇒ Object
Passes if the method ‘__send__` returns false or nil.
-
#assert_nothing_leaked_memory(max_increasable_size, target = :physical, message = nil) { ... } ⇒ void
Asserts that increased memory usage by ‘block.call` is less than `max_increasable_size`.
-
#assert_nothing_raised(*args) ⇒ Object
Passes if block does not raise an exception.
-
#assert_nothing_thrown(message = nil, &proc) ⇒ Object
Passes if block does not throw anything.
-
#assert_operator(object1, operator, object2, message = nil) ⇒ Object
Compares the ‘object1` with `object2` using `operator`.
-
#assert_path_exist(path, message = nil) ⇒ Object
Passes if ‘path` exists.
-
#assert_path_not_exist(path, message = nil) ⇒ Object
Passes if ‘path` doesn’t exist.
-
#assert_predicate(object, predicate, message = nil) ⇒ Object
Passes if ‘object`.`predicate` is not false nor nil.
-
#assert_raise(*args, &block) ⇒ Object
(also: #assert_raises)
Passes if the block raises one of the expected exceptions.
-
#assert_raise_kind_of(*args, &block) ⇒ Object
Passes if the block raises one of the given exceptions or sub exceptions of the given exceptions.
-
#assert_raise_message(expected, message = nil) ⇒ Object
Passes if an exception is raised in block and its message is ‘expected`.
-
#assert_raise_with_message(expected_exception_class, expected_message, message = nil, &block) ⇒ Object
Passes if the block raises ‘expected_exception` with `expected_message`.
-
#assert_respond_to(object, method, message = nil) ⇒ Object
Passes if ‘object` .respond_to? `method`.
-
#assert_same(expected, actual, message = nil) ⇒ Object
Passes if ‘actual` .equal? `expected` (i.e. they are the same instance).
-
#assert_send(send_array, message = nil) ⇒ Object
Passes if the method ‘__send__` returns not false nor nil.
-
#assert_throw(expected_object, message = nil, &proc) ⇒ Object
(also: #assert_throws)
Passes if the block throws ‘expected_object`.
-
#assert_true(actual, message = nil) ⇒ Object
Passes if ‘actual` is true.
-
#build_message(user_message, template = nil, *arguments) ⇒ Object
Builds a failure message.
-
#flunk(message = "Flunked") ⇒ Object
Flunk always fails.
-
#refute(object, message = nil) ⇒ void
Asserts that ‘object` is false or nil.
Class Method Details
.use_pp=(value) ⇒ Object
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.
1847 1848 1849 |
# File 'lib/test/unit/assertions.rb', line 1847 def self.use_pp=(value) AssertionMessage.use_pp = value end |
Instance Method Details
#add_assertion ⇒ void
This method returns an undefined value.
Called whenever an assertion is made. Define this in classes that include Test::Unit::Assertions to record assertion counts.
This is a public API for developers who extend test-unit.
1841 1842 |
# File 'lib/test/unit/assertions.rb', line 1841 def add_assertion end |
#assert(object, message = nil) ⇒ void #assert(message = nil) { ... } ⇒ void
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 |
# File 'lib/test/unit/assertions.rb', line 134 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) ⇒ Object
Passes if ‘object`#`alias_name` is an alias method of `object`#`original_name`.
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 |
# File 'lib/test/unit/assertions.rb', line 1495 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_all(collection, message = nil) {|Object| ... } ⇒ void Also known as: assert_all?
1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 |
# File 'lib/test/unit/assertions.rb', line 1705 def assert_all(collection, =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 = (, format, collection, result) assert_block() do not failed end end end |
#assert_block(message = "assert_block failed.") ⇒ Object
The assertion upon which all other assertions are based. Passes if the block yields not false nor nil.
53 54 55 56 57 58 59 60 61 62 63 |
# File 'lib/test/unit/assertions.rb', line 53 def assert_block(="assert_block failed.") _wrap_assertion do if (! yield) = {} if .respond_to?(:user_message) [:user_message] = . end raise AssertionFailedError.new(.to_s, ) end end end |
#assert_boolean(actual, message = nil) ⇒ Object
Passes if ‘actual` is a boolean value.
1266 1267 1268 1269 1270 1271 1272 1273 1274 |
# File 'lib/test/unit/assertions.rb', line 1266 def assert_boolean(actual, =nil) _wrap_assertion do assert_block((, "<true> or <false> expected but was\n<?>", actual)) do true == actual || false == actual end end end |
#assert_compare(expected, operator, actual, message = nil) ⇒ Object
Passes if expression “‘expected` `operator` `actual`” is not false nor nil.
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 |
# File 'lib/test/unit/assertions.rb', line 1315 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 <?> was expected to be #{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) ⇒ Object
Passes if ‘object`.const_defined?(`constant_name`)
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 |
# File 'lib/test/unit/assertions.rb', line 1410 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) ⇒ Object
Passes if ‘object` is empty.
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 |
# File 'lib/test/unit/assertions.rb', line 1640 def assert_empty(object, =nil) _wrap_assertion do assert_respond_to(object, :empty?, "The object must respond to :empty?.") = (, "<?> was expected to be empty.", object) assert_block() do object.empty? end end end |
#assert_equal(expected, actual, message = nil) ⇒ Object
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.
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 |
# File 'lib/test/unit/assertions.rb', line 225 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) ⇒ Object
Passes if assertion is failed in block.
1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 |
# File 'lib/test/unit/assertions.rb', line 1348 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) ⇒ Object
Passes if ‘actual` is false.
1298 1299 1300 1301 1302 1303 1304 1305 1306 |
# File 'lib/test/unit/assertions.rb', line 1298 def assert_false(actual, =nil) _wrap_assertion do assert_block((, "<false> expected but was\n<?>", actual)) do false == actual end end end |
#assert_in_delta(expected_float, actual_float, delta = 0.001, message = "") ⇒ Object
Passes if ‘expected_float` and `actual_float` are equal within `delta` tolerance.
927 928 929 930 931 932 933 934 935 936 937 938 939 940 |
# File 'lib/test/unit/assertions.rb', line 927 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 = "") ⇒ Object
Passes if ‘expected_float` and `actual_float` are equal within `epsilon` relative error of `expected_float`.
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 |
# File 'lib/test/unit/assertions.rb', line 1049 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) ⇒ Object Also known as: assert_includes
Passes if ‘collection` includes `object`.
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 |
# File 'lib/test/unit/assertions.rb', line 1579 def assert_include(collection, object, =nil) _wrap_assertion do assert_respond_to(collection, :include?, "The collection must respond to :include?.") = (, "<?> was expected to include\n<?>.", collection, object) assert_block() do collection.include?(object) end end end |
#assert_instance_of(klass, object, message = nil) ⇒ Object
Passes if ‘object`.instance_of?(`klass`). When `klass` is an array of classes, it passes if any class satisfies +object.instance_of?(class).
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 |
# File 'lib/test/unit/assertions.rb', line 391 def assert_instance_of(klass, object, =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 = AssertionMessage.maybe_container(klass) do |value| "<#{value}>" end = (, <<EOT, object, , object.class) <?> was 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 = nil) ⇒ Object
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).
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 |
# File 'lib/test/unit/assertions.rb', line 478 def assert_kind_of(klass, object, =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 = AssertionMessage.maybe_container(klass) do |value| "<#{value}>" end = (, "<?> was 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 = nil) ⇒ Object
Passes if ‘pattern` =~ `string`.
601 602 603 604 605 606 607 608 609 |
# File 'lib/test/unit/assertions.rb', line 601 def assert_match(pattern, string, =nil) _wrap_assertion do pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String) = (, "<?> was expected to be =~\n<?>.", pattern, string) assert_block() { pattern =~ string } end end |
#assert_nil(object, message = nil) ⇒ Object
Passes if ‘object`.nil?.
462 463 464 465 466 467 |
# File 'lib/test/unit/assertions.rb', line 462 def assert_nil(object, =nil) = (, <<EOT, object) <?> was expected to be nil. EOT assert_block() { object.nil? } end |
#assert_no_match(regexp, string, message = "") ⇒ Object
Use #assert_not_match instead.
Passes if ‘regexp` !~ `string`
798 799 800 801 802 803 804 805 |
# File 'lib/test/unit/assertions.rb', line 798 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) ⇒ Object
Passes if !‘object`.const_defined?(`constant_name`)
1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 |
# File 'lib/test/unit/assertions.rb', line 1427 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) ⇒ Object Also known as: refute_empty
Passes if ‘object` is not empty.
1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 |
# File 'lib/test/unit/assertions.rb', line 1663 def assert_not_empty(object, =nil) _wrap_assertion do assert_respond_to(object, :empty?, "The object must respond to :empty?.") = (, "<?> was expected to not be empty.", object) assert_block() do not object.empty? end end end |
#assert_not_equal(expected, actual, message = nil) ⇒ Object Also known as: refute_equal
Passes if ‘expected` != `actual`
740 741 742 743 744 745 |
# File 'lib/test/unit/assertions.rb', line 740 def assert_not_equal(expected, actual, =nil) = (, "<?> was expected to be != to\n<?>.", expected, actual) assert_block() { expected != actual } end |
#assert_not_in_delta(expected_float, actual_float, delta = 0.001, message = "") ⇒ Object Also known as: refute_in_delta
Passes if ‘expected_float` and `actual_float` are not equal within `delta` tolerance.
949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 |
# File 'lib/test/unit/assertions.rb', line 949 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 = "") ⇒ Object Also known as: refute_in_epsilon
Passes if ‘expected_float` and `actual_float` are not equal within `epsilon` relative error of `expected_float`.
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 |
# File 'lib/test/unit/assertions.rb', line 1080 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) ⇒ Object Also known as: assert_not_includes, refute_includes
Passes if ‘collection` doesn’t include ‘object`.
1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 |
# File 'lib/test/unit/assertions.rb', line 1606 def assert_not_include(collection, object, =nil) _wrap_assertion do assert_respond_to(collection, :include?, "The collection must respond to :include?.") = (, "<?> was expected to not include\n<?>.", collection, object) assert_block() do not collection.include?(object) end end end |
#assert_not_instance_of(klass, object, message = nil) ⇒ Object 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).
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 |
# File 'lib/test/unit/assertions.rb', line 427 def assert_not_instance_of(klass, object, =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 = AssertionMessage.maybe_container(klass) do |value| "<#{value}>" end = (, "<?> was 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 = nil) ⇒ Object 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).
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 |
# File 'lib/test/unit/assertions.rb', line 516 def assert_not_kind_of(klass, object, =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 = AssertionMessage.maybe_container(klass) do |value| "<#{value}>" end = (, "<?> was 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(pattern, string, message = nil) ⇒ Object Also known as: refute_match
Passes if ‘regexp` !~ `string`
775 776 777 778 779 780 781 782 783 |
# File 'lib/test/unit/assertions.rb', line 775 def assert_not_match(pattern, string, =nil) _wrap_assertion do pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String) = (, "<?> was expected to not match\n<?>.", pattern, string) assert_block() { pattern !~ string } end end |
#assert_not_nil(object, message = nil) ⇒ Object Also known as: refute_nil
Passes if ! ‘object` .nil?
757 758 759 760 761 762 |
# File 'lib/test/unit/assertions.rb', line 757 def assert_not_nil(object, =nil) = (, "<?> was expected to not be nil.", object) assert_block(){!object.nil?} end |
#assert_not_operator(object1, operator, object2, message = nil) ⇒ Object Also known as: refute_operator
Compares the ‘object1` with `object2` using `operator`.
Passes if object1.__send__(operator, object2) is false or nil.
658 659 660 661 662 663 664 665 666 667 668 669 |
# File 'lib/test/unit/assertions.rb', line 658 def assert_not_operator(object1, operator, object2, =nil) _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) <?> was expected to not be ? <?>. EOT assert_block() { ! object1.__send__(operator, object2) } end end |
#assert_not_predicate(object, predicate, message = nil) ⇒ Object Also known as: refute_predicate
Passes if ‘object`.`predicate` is false or nil.
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 |
# File 'lib/test/unit/assertions.rb', line 1466 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 = nil) ⇒ Object Also known as: refute_respond_to
Passes if ‘object` does not .respond_to? `method`.
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 |
# File 'lib/test/unit/assertions.rb', line 574 def assert_not_respond_to(object, method, =nil) _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 = nil) ⇒ Object Also known as: refute_same
Passes if ! ‘actual` .equal? `expected`
720 721 722 723 724 725 726 727 728 |
# File 'lib/test/unit/assertions.rb', line 720 def assert_not_same(expected, actual, =nil) = (, <<EOT, expected, expected.__id__, actual, actual.__id__) <?> with id <?> was expected to not be equal\\? to <?> with id <?>. EOT assert_block() { !actual.equal?(expected) } end |
#assert_not_send(send_array, message = nil) ⇒ Object
Passes if the method ‘__send__` returns false or nil.
‘send_array` is composed of:
-
A receiver
-
A method
-
Arguments to the method
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 |
# File 'lib/test/unit/assertions.rb', line 1231 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 <?> was 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_leaked_memory(max_increasable_size, target = :physical, message = nil) { ... } ⇒ void
1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 |
# File 'lib/test/unit/assertions.rb', line 1779 def assert_nothing_leaked_memory(max_increasable_size, target=:physical, =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 = (, template, actual_increased_size, max_increasable_size) assert_block() do actual_increased_size < max_increasable_size end end end |
#assert_nothing_raised(*args) ⇒ Object
Passes if block does not raise an exception.
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 |
# File 'lib/test/unit/assertions.rb', line 683 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 end end |
#assert_nothing_thrown(message = nil, &proc) ⇒ Object
Passes if block does not throw anything.
903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 |
# File 'lib/test/unit/assertions.rb', line 903 def assert_nothing_thrown(=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? = (, "<?> was thrown when nothing was expected", tag) flunk() end assert(true, "Expected nothing to be thrown") end end |
#assert_operator(object1, operator, object2, message = nil) ⇒ Object
Compares the ‘object1` with `object2` using `operator`.
Passes if object1.__send__(operator, object2) is not false nor nil.
635 636 637 638 639 640 641 642 643 644 645 646 |
# File 'lib/test/unit/assertions.rb', line 635 def assert_operator(object1, operator, object2, =nil) _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) <?> was expected to be ? <?>. EOT assert_block() { object1.__send__(operator, object2) } end end |
#assert_path_exist(path, message = nil) ⇒ Object
Passes if ‘path` exists.
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 |
# File 'lib/test/unit/assertions.rb', line 1542 def assert_path_exist(path, =nil) _wrap_assertion do = (, "<?> was expected to exist", path) assert_block() do File.exist?(path) end end end |
#assert_path_not_exist(path, message = nil) ⇒ Object
Passes if ‘path` doesn’t exist.
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 |
# File 'lib/test/unit/assertions.rb', line 1560 def assert_path_not_exist(path, =nil) _wrap_assertion do = (, "<?> was expected to not exist", path) assert_block() do not File.exist?(path) end end end |
#assert_predicate(object, predicate, message = nil) ⇒ Object
Passes if ‘object`.`predicate` is not false nor nil.
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 |
# File 'lib/test/unit/assertions.rb', line 1444 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) ⇒ Object 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.
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 |
# File 'lib/test/unit/assertions.rb', line 269 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) ⇒ Object
Passes if the block raises one of the given exceptions or sub exceptions of the given exceptions.
366 367 368 369 370 371 372 373 374 375 376 377 378 379 |
# File 'lib/test/unit/assertions.rb', line 366 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) ⇒ Object
Passes if an exception is raised in block and its message is ‘expected`.
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 |
# File 'lib/test/unit/assertions.rb', line 1372 def (expected, =nil) _wrap_assertion do = (, "<?> exception message was 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_raise_with_message(expected_exception_class, expected_message, message = nil, &block) ⇒ Object
Passes if the block raises ‘expected_exception` with `expected_message`. `expected_message` can be a `String` or `Regexp`.
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 |
# File 'lib/test/unit/assertions.rb', line 318 def (expected_exception_class, , =nil, &block) assert_expected_exception = Proc.new do |*_args| , assert_exception_helper, actual_exception = _args diff = AssertionMessage.delayed_diff([ expected_exception_class, , ], [ actual_exception.class, actual_exception., ]) = (, "<?>(<?>) exception expected but was\n" + "<?>(<?>).?", expected_exception_class, , actual_exception.class, actual_exception., diff) begin assert_block() do assert_exception_helper.expected?(actual_exception) and === actual_exception. 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 << if _assert_raise(assert_expected_exception, *args, &block) end |
#assert_respond_to(object, method, message = nil) ⇒ Object
Passes if ‘object` .respond_to? `method`
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 |
# File 'lib/test/unit/assertions.rb', line 551 def assert_respond_to(object, method, =nil) _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 = nil) ⇒ Object
Passes if ‘actual` .equal? `expected` (i.e. they are the same instance).
618 619 620 621 622 623 624 625 626 |
# File 'lib/test/unit/assertions.rb', line 618 def assert_same(expected, actual, =nil) = (, <<EOT, expected, expected.__id__, actual, actual.__id__) <?> with id <?> was expected to be equal\\? to <?> with id <?>. EOT assert_block() { actual.equal?(expected) } end |
#assert_send(send_array, message = nil) ⇒ Object
Passes if the method ‘__send__` returns not false nor nil.
‘send_array` is composed of:
-
A receiver
-
A method
-
Arguments to the method
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 |
# File 'lib/test/unit/assertions.rb', line 1191 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 <?> was 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 = nil, &proc) ⇒ Object Also known as: assert_throws
Passes if the block throws ‘expected_object`
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 |
# File 'lib/test/unit/assertions.rb', line 857 def assert_throw(expected_object, =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 = (, "<?> should have been thrown.", expected_object) assert_block() {caught} rescue => error extractor = ThrowTagExtractor.new(error) tag = extractor.extract_tag raise if tag.nil? = (, "<?> was expected to be thrown but\n" + "<?> was thrown.", expected_object, tag) flunk() end end end |
#assert_true(actual, message = nil) ⇒ Object
Passes if ‘actual` is true.
1282 1283 1284 1285 1286 1287 1288 1289 1290 |
# File 'lib/test/unit/assertions.rb', line 1282 def assert_true(actual, =nil) _wrap_assertion do assert_block((, "<true> expected but was\n<?>", actual)) do true == actual end end end |
#build_message(user_message, template = nil, *arguments) ⇒ Object
Builds a failure message. ‘user_message` is added before the `template` and `arguments` replaces the ’?‘s positionally in the template.
1812 1813 1814 1815 |
# File 'lib/test/unit/assertions.rb', line 1812 def (, template=nil, *arguments) template &&= template.chomp return AssertionMessage.new(, template, arguments) end |
#flunk(message = "Flunked") ⇒ Object
Flunk always fails.
711 712 713 |
# File 'lib/test/unit/assertions.rb', line 711 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.
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 |
# File 'lib/test/unit/assertions.rb', line 191 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 |