| Module | Test::Unit::Assertions |
| In: |
lib/test/unit/assertions.rb
|
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:
def deny(boolean, message = nil)
message = build_message message, '<?> is not false or nil.', boolean
assert_block message do
not boolean
end
end
| UncaughtThrow | = | { NameError => /^uncaught throw \`(.+)\'$/, #` ArgumentError => /^uncaught throw (.+)$/, ThreadError => /^uncaught throw \`(.+)\' in thread / |
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.
Called whenever an assertion is made. Define this in classes that include Test::Unit::Assertions to record assertion counts.
This is a public API for developers who extend test-unit.
@return [void]
Passes if object#alias_name is an alias method of object#original_name.
Example:
assert_alias_method([], :length, :size) # -> pass assert_alias_method([], :size, :length) # -> pass assert_alias_method([], :each, :size) # -> fail
The assertion upon which all other assertions are based. Passes if the block yields true.
Example:
assert_block "Couldn't do the thing" do
do_the_thing
end
Passes if actual is a boolean value.
Example:
assert_boolean(true) # -> pass assert_boolean(nil) # -> fail
Passes if expression "expected operator actual" is true.
Example:
assert_compare(1, "<", 10) # -> pass assert_compare(1, ">=", 10) # -> fail
Passes if object.const_defined?(constant_name)
Example:
assert_const_defined(Test, :Unit) # -> pass assert_const_defined(Object, :Nonexistent) # -> fail
Passes if object is empty.
Example:
assert_empty("") # -> pass
assert_empty([]) # -> pass
assert_empty({}) # -> pass
assert_empty(" ") # -> fail
assert_empty([nil]) # -> fail
assert_empty({1 => 2}) # -> fail
Passes if expected == actual.
Note that the ordering of arguments is important, since a helpful error message is generated when this one fails that tells you the values of expected and actual.
Example:
assert_equal 'MY STRING', 'my string'.upcase
Passes if assertion is failed in block.
Example:
assert_fail_assertion {assert_equal("A", "B")} # -> pass
assert_fail_assertion {assert_equal("A", "A")} # -> fail
Passes if expected_float and actual_float are equal within delta tolerance.
Example:
assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
Passes if expected_float and actual_float are equal within epsilon relative error of expected_float.
Example:
assert_in_epsilon(10000.0, 9900.0, 0.1) # -> pass assert_in_epsilon(10000.0, 9899.0, 0.1) # -> fail
Passes if collection includes object.
Example:
assert_include([1, 10], 1) # -> pass assert_include(1..10, 5) # -> pass assert_include([1, 10], 5) # -> fail assert_include(1..10, 20) # -> fail
Passes if object.instance_of?(klass). When klass is an array of classes, it passes if any class satisfies +object.instance_of?(class).
Example:
assert_instance_of(String, 'foo') # -> pass assert_instance_of([Fixnum, NilClass], 100) # -> pass assert_instance_of([Numeric, NilClass], 100) # -> fail
Passes if object.kind_of?(klass). When klass is an array of classes or modules, it passes if any class or module satisfies +object.kind_of?(class_or_module).
Example:
assert_kind_of(Object, 'foo') # -> pass assert_kind_of([Fixnum, NilClass], 100) # -> pass assert_kind_of([Fixnum, NilClass], "string") # -> fail
Deprecated. Use assert_not_match instead.
Passes if regexp !~ string
Example:
assert_no_match(/two/, 'one 2 three') # -> pass assert_no_match(/three/, 'one 2 three') # -> fail
Passes if !object.const_defined?(constant_name)
Example:
assert_not_const_defined(Object, :Nonexistent) # -> pass assert_not_const_defined(Test, :Unit) # -> fail
Passes if object is not empty.
Example:
assert_not_empty(" ") # -> pass
assert_not_empty([nil]) # -> pass
assert_not_empty({1 => 2}) # -> pass
assert_not_empty("") # -> fail
assert_not_empty([]) # -> fail
assert_not_empty({}) # -> fail
Passes if expected_float and actual_float are not equal within delta tolerance.
Example:
assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00002) # -> pass assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00001) # -> fail
Passes if expected_float and actual_float are not equal within epsilon relative error of expected_float.
Example:
assert_not_in_epsilon(10000.0, 9900.0, 0.1) # -> fail assert_not_in_epsilon(10000.0, 9899.0, 0.1) # -> pass
Passes if collection doesn‘t include object.
Example:
assert_not_include([1, 10], 5) # -> pass assert_not_include(1..10, 20) # -> pass assert_not_include([1, 10], 1) # -> fail assert_not_include(1..10, 5) # -> fail
Passes if regexp !~ string
Example:
assert_not_match(/two/, 'one 2 three') # -> pass assert_not_match(/three/, 'one 2 three') # -> fail
Passes if object.predicate is not true.
Example:
assert_not_predicate([1], :empty?) # -> pass assert_not_predicate([], :empty?) # -> fail
Passes if object does not .respond_to? method.
Example:
assert_not_respond_to('bugbear', :nonexistence) # -> pass
assert_not_respond_to('bugbear', :size) # -> fail
Passes if the method send doesn‘t return a true value.
send_array is composed of:
Example:
assert_not_send([[1, 2], :member?, 1]) # -> fail assert_not_send([[1, 2], :member?, 4]) # -> pass
Compares the +object1+ with +object2+ using operator.
Passes if object1.send(operator, object2) is true.
Example:
assert_operator 5, :>=, 4
Passes if path exists.
Example:
assert_path_exist("/tmp") # -> pass
assert_path_exist("/bin/sh") # -> pass
assert_path_exist("/nonexistent") # -> fail
Passes if path doesn‘t exist.
Example:
assert_path_not_exist("/nonexistent") # -> pass
assert_path_not_exist("/tmp") # -> fail
assert_path_not_exist("/bin/sh") # -> fail
Passes if object.predicate is true.
Example:
assert_predicate([], :empty?) # -> pass assert_predicate([1], :empty?) # -> fail
Passes if the block raises one of the expected exceptions. When an expected exception is an Exception object, passes if expected_exception == actual_exception.
Example:
assert_raise(RuntimeError, LoadError) do
raise 'Boom!!!'
end # -> pass
assert_raise do
raise Exception, 'Any exception should be raised!!!'
end # -> pass
assert_raise(RuntimeError.new("XXX")) {raise "XXX"} # -> pass
assert_raise(MyError.new("XXX")) {raise "XXX"} # -> fail
assert_raise(RuntimeError.new("ZZZ")) {raise "XXX"} # -> fail
Passes if the block raises one of the given exceptions or sub exceptions of the given exceptions.
Example:
assert_raise_kind_of(SystemCallError) do
raise Errno::EACCES
end
Passes if an exception is raised in block and its message is expected.
Example:
assert_raise_message("exception") {raise "exception"} # -> pass
assert_raise_message(/exc/i) {raise "exception"} # -> pass
assert_raise_message("exception") {raise "EXCEPTION"} # -> fail
assert_raise_message("exception") {} # -> fail
Passes if actual .equal? expected (i.e. they are the same instance).
Example:
o = Object.new assert_same o, o
Passes if the method send returns a true value.
send_array is composed of:
Example:
assert_send([[1, 2], :member?, 1]) # -> pass assert_send([[1, 2], :member?, 4]) # -> fail
Builds a failure message. head is added before the template and arguments replaces the ’?’s positionally in the template.
Asserts that object is false or nil.
@note Just for minitest compatibility. :<
@param [Object] object The object to be asserted. @return [void]
@example Pass patterns
refute(false) # => pass refute(nil) # => pass
@example Fialure patterns
refute(true) # => failure
refute("string") # => failure
@since 2.5.3
Alias for assert_not_in_delta