Tests if test
is true.
msg
may be a String or a Proc. If msg
is a
String, it will be used as the failure message. Otherwise, the result of
calling msg
will be used as the message if the assertion
fails.
If no msg
is given, a default message will be used.
assert(false, "This was expected to be true")
# File test/unit/assertions.rb, line 27 def assert(test, *msgs) case msg = msgs.first when String, Proc when nil msgs.shift else bt = caller.reject { |s| s.start_with?(MINI_DIR) } raise ArgumentError, "assertion message must be String or Proc, but #{msg.class} was given.", bt end unless msgs.empty? super end
# File test/unit/assertions.rb, line 425 def assert_all?(obj, m = nil, &blk) failed = [] obj.each do |*a, &b| unless blk.call(*a, &b) failed << (a.size > 1 ? a : a[0]) end end assert(failed.empty?, message(m) {failed.pretty_inspect}) end
Tests the result of the given block. If the block does not return true, the
assertion will fail. The optional failure_message
argument is
the same as in #assert.
assert_block do [1, 2, 3].any? { |num| num < 1 } end
# File test/unit/assertions.rb, line 49 def assert_block(*msgs) assert yield, *msgs end
Tests if expected
is equal to actual
.
An optional failure message may be provided as the final argument.
# File test/unit/assertions.rb, line 245 def assert_equal(exp, act, msg = nil) msg = message(msg) { exp_str = mu_pp(exp) act_str = mu_pp(act) exp_comment = '' act_comment = '' if exp_str == act_str if (exp.is_a?(String) && act.is_a?(String)) || (exp.is_a?(Regexp) && act.is_a?(Regexp)) exp_comment = " (#{exp.encoding})" act_comment = " (#{act.encoding})" elsif exp.is_a?(Float) && act.is_a?(Float) exp_str = "%\#.#{Float::DIG+2}g" % exp act_str = "%\#.#{Float::DIG+2}g" % act elsif exp.is_a?(Time) && act.is_a?(Time) if exp.subsec * 1000_000_000 == exp.nsec exp_comment = " (#{exp.nsec}[ns])" else exp_comment = " (subsec=#{exp.subsec})" end if act.subsec * 1000_000_000 == act.nsec act_comment = " (#{act.nsec}[ns])" else act_comment = " (subsec=#{act.subsec})" end elsif exp.class != act.class # a subclass of Range, for example. exp_comment = " (#{exp.class})" act_comment = " (#{act.class})" end elsif !Encoding.compatible?(exp_str, act_str) if exp.is_a?(String) && act.is_a?(String) exp_str = exp.dump act_str = act.dump exp_comment = " (#{exp.encoding})" act_comment = " (#{act.encoding})" else exp_str = exp_str.dump act_str = act_str.dump end end "<#{exp_str}>#{exp_comment} expected but was\n<#{act_str}>#{act_comment}" } assert(exp == act, msg) end
Tests if the given Regexp does not match a given String.
An optional failure message may be provided as the final argument.
# File test/unit/assertions.rb, line 319 def assert_no_match(regexp, string, msg=nil) assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.") self._assertions -= 1 msg = message(msg) { "<#{mu_pp(regexp)}> expected to not match\n<#{mu_pp(string)}>" } assert(regexp !~ string, msg) end
# File test/unit/assertions.rb, line 435 def assert_not_all?(obj, m = nil, &blk) failed = [] obj.each do |*a, &b| if blk.call(*a, &b) failed << a.size > 1 ? a : a[0] end end assert(failed.empty?, message(m) {failed.pretty_inspect}) end
Tests if expected
is not equal to actual
.
An optional failure message may be provided as the final argument.
# File test/unit/assertions.rb, line 308 def assert_not_equal(exp, act, msg=nil) msg = message(msg) { "<#{mu_pp(exp)}> expected to be != to\n<#{mu_pp(act)}>" } assert(exp != act, msg) end
Tests if expression
is not nil.
An optional failure message may be provided as the final argument.
# File test/unit/assertions.rb, line 297 def assert_not_nil(exp, msg=nil) msg = message(msg) { "<#{mu_pp(exp)}> expected to not be nil" } assert(!exp.nil?, msg) end
Tests if expected
is not the same object as
actual
. This test uses Object#equal? to test equality.
An optional failure message may be provided as the final argument.
assert_not_same("x", "x") #Succeeds
# File test/unit/assertions.rb, line 335 def assert_not_same(expected, actual, message="") msg = message(msg) { build_message(message, "<?> with id <?> expected to not be equal\\? to <?> with id <?>. ", expected, expected.__id__, actual, actual.__id__) } assert(!actual.equal?(expected), msg) end
Passes if the method send doesn’t return a true value.
send_array
is composed of:
A receiver
A method
Arguments to the method
Example:
assert_not_send([[1, 2], :member?, 1]) # -> fail assert_not_send([[1, 2], :member?, 4]) # -> pass
# File test/unit/assertions.rb, line 404 def assert_not_send send_ary, m = nil recv, msg, *args = send_ary m = message(m) { if args.empty? argsstr = "" else (argsstr = mu_pp(args)).sub!(/\A\[(.*)\]\z/m, '(\1)') end "Expected #{mu_pp(recv)}.#{msg}#{argsstr} to return false" } assert !recv.__send__(msg, *args), m end
If any exceptions are given as arguments, the assertion will fail if one of those exceptions are raised. Otherwise, the test fails if any exceptions are raised.
The final argument may be a failure message.
assert_nothing_raised RuntimeError do raise Exception #Assertion passes, Exception is not a RuntimeError end assert_nothing_raised do raise Exception #Assertion fails end
# File test/unit/assertions.rb, line 158 def assert_nothing_raised(*args) self._assertions += 1 if Module === args.last msg = nil else msg = args.pop end begin line = __LINE__; yield rescue MiniTest::Skip raise rescue Exception => e bt = e.backtrace as = e.instance_of?(MiniTest::Assertion) if as ans = /\A#{Regexp.quote(__FILE__)}:#{line}:in /o bt.reject! {|ln| ans =~ ln} end if ((args.empty? && !as) || args.any? {|a| a.instance_of?(Module) ? e.is_a?(a) : e.class == a }) msg = message(msg) { "Exception raised:\n<#{mu_pp(e)}>" } raise MiniTest::Assertion, msg.call, bt else raise end end nil end
Fails if the given block uses a call to Kernel#throw, and returns the result of the block otherwise.
An optional failure message may be provided as the final argument.
assert_nothing_thrown "Something was thrown!" do throw :problem? end
# File test/unit/assertions.rb, line 198 def assert_nothing_thrown(msg=nil) begin ret = yield rescue ArgumentError => error raise error if /\Auncaught throw (.+)\z/m !~ error.message msg = message(msg) { "<#{$1}> was thrown when nothing was expected" } flunk(msg) end assert(true, "Expected nothing to be thrown") ret end
Tests if the given block raises an exception. Acceptable exception types may be given as optional arguments. If the last argument is a String, it will be used as the error message.
assert_raise do #Fails, no Exceptions are raised end assert_raise NameError do puts x #Raises NameError, so assertion succeeds end
# File test/unit/assertions.rb, line 66 def assert_raise(*exp, &b) case exp.last when String, Proc msg = exp.pop end begin yield rescue MiniTest::Skip => e return e if exp.include? MiniTest::Skip raise e rescue Exception => e expected = exp.any? { |ex| if ex.instance_of? Module then e.kind_of? ex else e.instance_of? ex end } assert expected, proc { exception_details(e, message(msg) {"#{mu_pp(exp)} exception expected, not"}.call) } return e end exp = exp.first if exp.size == 1 flunk(message(msg) {"#{mu_pp(exp)} expected but nothing was raised"}) end
Tests if the given block raises an exception with the expected message.
assert_raise_with_message(RuntimeError, "foo") do nil #Fails, no Exceptions are raised end assert_raise_with_message(RuntimeError, "foo") do raise ArgumentError, "foo" #Fails, different Exception is raised end assert_raise_with_message(RuntimeError, "foo") do raise "bar" #Fails, RuntimeError is raised but the message differs end assert_raise_with_message(RuntimeError, "foo") do raise "foo" #Raises RuntimeError with the message, so assertion succeeds end
# File test/unit/assertions.rb, line 119 def assert_raise_with_message(exception, expected, msg = nil, &block) case expected when String assert = :assert_equal when Regexp assert = :assert_match else raise TypeError, "Expected #{expected.inspect} to be a kind of String or Regexp, not #{expected.class}" end ex = assert_raise(exception, *msg) {yield} msg = message(msg, "") {"Expected Exception(#{exception}) was raised, but the message doesn't match"} if assert == :assert_equal assert_equal(expected, ex.message, msg) else msg = message(msg) { "Expected #{mu_pp expected} to match #{mu_pp ex.message}" } assert expected =~ ex.message, msg block.binding.eval("proc{|_|$~=_}").call($~) end ex end
Tests if the given Object responds to method
.
An optional failure message may be provided as the final argument.
assert_respond_to("hello", :reverse) #Succeeds assert_respond_to("hello", :does_not_exist) #Fails
# File test/unit/assertions.rb, line 354 def assert_respond_to obj, (meth, priv), msg = nil if priv msg = message(msg) { "Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}#{" privately" if priv}" } return assert obj.respond_to?(meth, priv), msg end #get rid of overcounting super if !caller[0].rindex(MINI_DIR, 0) || !obj.respond_to?(meth) end
Passes if the method send returns a true value.
send_array
is composed of:
A receiver
A method
Arguments to the method
Example:
assert_send(["Hello world", :include?, "Hello"]) # -> pass assert_send(["Hello world", :include?, "Goodbye"]) # -> fail
# File test/unit/assertions.rb, line 378 def assert_send send_ary, m = nil recv, msg, *args = send_ary m = message(m) { if args.empty? argsstr = "" else (argsstr = mu_pp(args)).sub!(/\A\[(.*)\]\z/m, '(\1)') end "Expected #{mu_pp(recv)}.#{msg}#{argsstr} to return true" } assert recv.__send__(msg, *args), m end
Fails unless the given block throws tag
, returns the caught
value otherwise.
An optional failure message may be provided as the final argument.
tag = Object.new assert_throw(tag, "#{tag} was not thrown!") do throw tag end
# File test/unit/assertions.rb, line 222 def assert_throw(tag, msg = nil) ret = catch(tag) do begin yield(tag) rescue ArgumentError => e raise unless thrown = e.message[/\Auncaught throw (.+)\z/m, 1] end msg = message(msg) { "Expected #{mu_pp(tag)} to have been thrown" "#{", not #{thrown}" if thrown}" } assert(false, msg) end assert(true) ret end
Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.
If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.
If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.
If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.