Extended maintenance of Ruby 1.9.3 ended on February 23, 2015. Read more
MiniTest Assertions. All assertion methods accept a
msg
which is printed if the assertion fails.
Returns the diff command to use in diff. Tries to intelligently figure out what diff to use.
# File minitest/unit.rb, line 75 def self.diff @diff = if WINDOZE "diff.exe -u" else if system("gdiff", __FILE__, __FILE__) "gdiff -u" # solaris and kin suck elsif system("diff", __FILE__, __FILE__) "diff -u" else nil end end unless defined? @diff @diff end
Set the diff command to use in diff.
# File minitest/unit.rb, line 94 def self.diff= o @diff = o end
Fails unless test
is a true value.
# File minitest/unit.rb, line 180 def assert test, msg = nil msg ||= "Failed assertion, no message given." self._assertions += 1 unless test then msg = msg.call if Proc === msg raise MiniTest::Assertion, msg end true end
Fails unless the block returns a true value.
# File minitest/unit.rb, line 193 def assert_block msg = nil msg = message(msg) { "Expected block to return true value" } assert yield, msg end
Fails unless obj
is empty.
# File minitest/unit.rb, line 201 def assert_empty obj, msg = nil msg = message(msg) { "Expected #{mu_pp(obj)} to be empty" } assert_respond_to obj, :empty? assert obj.empty?, msg end
Fails unless exp == act
printing the difference between the
two, if possible.
If there is no visible difference but the assertion fails, you should suspect that your #== is buggy, or your inspect output is missing crucial details.
For floats use assert_in_delta.
See also: ::diff
# File minitest/unit.rb, line 219 def assert_equal exp, act, msg = nil msg = message(msg, "") { diff exp, act } assert(exp == act, msg) end
For comparing Floats. Fails unless exp
and act
are within delta
of each other.
assert_in_delta Math::PI, (22.0 / 7.0), 0.01
# File minitest/unit.rb, line 230 def assert_in_delta exp, act, delta = 0.001, msg = nil n = (exp - act).abs msg = message(msg) { "Expected #{exp} - #{act} (#{n}) to be < #{delta}" } assert delta >= n, msg end
For comparing Floats. Fails unless exp
and act
have a relative error less than epsilon
.
# File minitest/unit.rb, line 240 def assert_in_epsilon a, b, epsilon = 0.001, msg = nil assert_in_delta a, b, [a, b].min * epsilon, msg end
Fails unless collection
includes obj
.
# File minitest/unit.rb, line 247 def assert_includes collection, obj, msg = nil msg = message(msg) { "Expected #{mu_pp(collection)} to include #{mu_pp(obj)}" } assert_respond_to collection, :include? assert collection.include?(obj), msg end
Fails unless obj
is an instace of cls
.
# File minitest/unit.rb, line 258 def assert_instance_of cls, obj, msg = nil msg = message(msg) { "Expected #{mu_pp(obj)} to be an instance of #{cls}, not #{obj.class}" } assert obj.instance_of?(cls), msg end
Fails unless obj
is a kind of cls
.
# File minitest/unit.rb, line 269 def assert_kind_of cls, obj, msg = nil # TODO: merge with instance_of msg = message(msg) { "Expected #{mu_pp(obj)} to be a kind of #{cls}, not #{obj.class}" } assert obj.kind_of?(cls), msg end
Fails unless exp
is =~
act
.
# File minitest/unit.rb, line 279 def assert_match exp, act, msg = nil msg = message(msg) { "Expected #{mu_pp(exp)} to match #{mu_pp(act)}" } assert_respond_to act, :"=~" exp = Regexp.new Regexp.escape exp if String === exp and String === act assert exp =~ act, msg end
Fails unless obj
is nil
# File minitest/unit.rb, line 289 def assert_nil obj, msg = nil msg = message(msg) { "Expected #{mu_pp(obj)} to be nil" } assert obj.nil?, msg end
For testing equality operators and so-forth.
assert_operator 5, :<=, 4
# File minitest/unit.rb, line 299 def assert_operator o1, op, o2, msg = nil msg = message(msg) { "Expected #{mu_pp(o1)} to be #{op} #{mu_pp(o2)}" } assert o1.__send__(op, o2), msg end
Fails if stdout or stderr do not output the expected results. Pass in nil if you don’t care about that streams output. Pass in “” if you require it to be silent.
See also: assert_silent
# File minitest/unit.rb, line 311 def assert_output stdout = nil, stderr = nil out, err = capture_io do yield end x = assert_equal stdout, out, "In stdout" if stdout y = assert_equal stderr, err, "In stderr" if stderr (!stdout || x) && (!stderr || y) end
Fails unless the block raises one of exp
# File minitest/unit.rb, line 325 def assert_raises *exp msg = "#{exp.pop}\n" if String === exp.last should_raise = false begin yield should_raise = true rescue MiniTest::Skip => e details = "#{msg}#{mu_pp(exp)} exception expected, not" if exp.include? MiniTest::Skip then return e else raise e end rescue Exception => e details = "#{msg}#{mu_pp(exp)} exception expected, not" assert(exp.any? { |ex| ex.instance_of?(Module) ? e.kind_of?(ex) : ex == e.class }, exception_details(e, details)) return e end exp = exp.first if exp.size == 1 flunk "#{msg}#{mu_pp(exp)} expected but nothing was raised." if should_raise end
Fails unless obj
responds to meth
.
# File minitest/unit.rb, line 357 def assert_respond_to obj, meth, msg = nil msg = message(msg) { "Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}" } assert obj.respond_to?(meth), msg end
Fails unless exp
and act
are equal?
# File minitest/unit.rb, line 367 def assert_same exp, act, msg = nil msg = message(msg) { data = [mu_pp(act), act.object_id, mu_pp(exp), exp.object_id] "Expected %s (oid=%d) to be the same as %s (oid=%d)" % data } assert exp.equal?(act), msg end
send_ary
is a receiver, message and arguments.
Fails unless the call returns a true value TODO: I should prolly remove this from specs
# File minitest/unit.rb, line 381 def assert_send send_ary, m = nil recv, msg, *args = send_ary m = message(m) { "Expected #{mu_pp(recv)}.#{msg}(*#{mu_pp(args)}) to return true" } assert recv.__send__(msg, *args), m end
Fails if the block outputs anything to stderr or stdout.
See also: assert_output
# File minitest/unit.rb, line 393 def assert_silent assert_output "", "" do yield end end
Fails unless the block throws sym
# File minitest/unit.rb, line 402 def assert_throws sym, msg = nil default = "Expected #{mu_pp(sym)} to have been thrown" caught = true catch(sym) do begin yield rescue ArgumentError => e # 1.9 exception default += ", not #{e.message.split(/ /).last}" rescue NameError => e # 1.8 exception default += ", not #{e.name.inspect}" end caught = false end assert caught, message(msg) { default } end
Captures $stdout and $stderr into strings:
out, err = capture_io do warn "You did a bad thing" end assert_match %r%bad%, err
# File minitest/unit.rb, line 428 def capture_io require 'stringio' orig_stdout, orig_stderr = $stdout, $stderr captured_stdout, captured_stderr = StringIO.new, StringIO.new $stdout, $stderr = captured_stdout, captured_stderr yield return captured_stdout.string, captured_stderr.string ensure $stdout = orig_stdout $stderr = orig_stderr end
Returns a diff between exp
and act
. If there is
no known diff command or if it doesn’t make sense to diff the output
(single line, short output), then it simply returns a basic comparison
between the two.
# File minitest/unit.rb, line 104 def diff exp, act require "tempfile" expect = mu_pp_for_diff exp butwas = mu_pp_for_diff act result = nil need_to_diff = MiniTest::Assertions.diff && (expect.include?("\n") || butwas.include?("\n") || expect.size > 30 || butwas.size > 30 || expect == butwas) return "Expected: #{mu_pp exp}\n Actual: #{mu_pp act}" unless need_to_diff Tempfile.open("expect") do |a| a.puts expect a.flush Tempfile.open("butwas") do |b| b.puts butwas b.flush result = %x`#{MiniTest::Assertions.diff} #{a.path} #{b.path}` result.sub!(/^\-\-\- .+/, "--- expected") result.sub!(/^\+\+\+ .+/, "+++ actual") if result.empty? then klass = exp.class result = [ "No visible difference.", "You should look at your implementation of #{klass}#==.", expect ].join "\n" end end end result end
Returns details for exception e
# File minitest/unit.rb, line 446 def exception_details e, msg [ "#{msg}", "Class: <#{e.class}>", "Message: <#{e.message.inspect}>", "---Backtrace---", "#{MiniTest::filter_backtrace(e.backtrace).join("\n")}", "---------------", ].join "\n" end
Fails with msg
# File minitest/unit.rb, line 460 def flunk msg = nil msg ||= "Epic Fail!" assert false, msg end
Returns a proc that will output msg
along with the default
message.
# File minitest/unit.rb, line 468 def message msg = nil, ending = ".", &default proc { custom_message = "#{msg}.\n" unless msg.nil? or msg.to_s.empty? "#{custom_message}#{default.call}#{ending}" } end
This returns a human-readable version of obj
. By default
inspect is called. You can override this to use pretty_print if you want.
# File minitest/unit.rb, line 153 def mu_pp obj s = obj.inspect s = s.encode Encoding.default_external if defined? Encoding s end
This returns a diff-able human-readable version of obj
. This
differs from the regular #mu_pp because it expands escaped
newlines and makes hex-values generic (like object_ids). This uses #mu_pp to do the first pass and
then cleans it up.
# File minitest/unit.rb, line 165 def mu_pp_for_diff obj # TODO: possibly rename mu_pp(obj).gsub(/\n/, "\n").gsub(/0x[a-f0-9]+/m, '0xXXXXXX') end
used for counting assertions
# File minitest/unit.rb, line 478 def pass msg = nil assert true end
Fails if test
is a true value
# File minitest/unit.rb, line 485 def refute test, msg = nil msg ||= "Failed refutation, no message given" not assert(! test, msg) end
Fails if obj
is empty.
# File minitest/unit.rb, line 493 def refute_empty obj, msg = nil msg = message(msg) { "Expected #{mu_pp(obj)} to not be empty" } assert_respond_to obj, :empty? refute obj.empty?, msg end
Fails if exp == act
.
For floats use refute_in_delta.
# File minitest/unit.rb, line 504 def refute_equal exp, act, msg = nil msg = message(msg) { "Expected #{mu_pp(act)} to not be equal to #{mu_pp(exp)}" } refute exp == act, msg end
For comparing Floats. Fails if exp
is within
delta
of act
refute_in_delta Math::PI, (22.0 / 7.0)
# File minitest/unit.rb, line 516 def refute_in_delta exp, act, delta = 0.001, msg = nil n = (exp - act).abs msg = message(msg) { "Expected #{exp} - #{act} (#{n}) to not be < #{delta}" } refute delta > n, msg end
For comparing Floats. Fails if exp
and act
have
a relative error less than epsilon
.
# File minitest/unit.rb, line 528 def refute_in_epsilon a, b, epsilon = 0.001, msg = nil refute_in_delta a, b, a * epsilon, msg end
Fails if collection
includes obj
# File minitest/unit.rb, line 535 def refute_includes collection, obj, msg = nil msg = message(msg) { "Expected #{mu_pp(collection)} to not include #{mu_pp(obj)}" } assert_respond_to collection, :include? refute collection.include?(obj), msg end
Fails if obj
is an instance of cls
# File minitest/unit.rb, line 546 def refute_instance_of cls, obj, msg = nil msg = message(msg) { "Expected #{mu_pp(obj)} to not be an instance of #{cls}" } refute obj.instance_of?(cls), msg end
Fails if obj
is a kind of cls
# File minitest/unit.rb, line 556 def refute_kind_of cls, obj, msg = nil # TODO: merge with instance_of msg = message(msg) { "Expected #{mu_pp(obj)} to not be a kind of #{cls}" } refute obj.kind_of?(cls), msg end
Fails if exp
=~
act
# File minitest/unit.rb, line 564 def refute_match exp, act, msg = nil msg = message(msg) { "Expected #{mu_pp(exp)} to not match #{mu_pp(act)}" } assert_respond_to act, :"=~" exp = (/#{Regexp.escape exp}/) if String === exp and String === act refute exp =~ act, msg end
Fails if obj
is nil.
# File minitest/unit.rb, line 574 def refute_nil obj, msg = nil msg = message(msg) { "Expected #{mu_pp(obj)} to not be nil" } refute obj.nil?, msg end
Fails if o1
is not op
o2
. Eg:
refute_operator 1, :>, 2 #=> pass refute_operator 1, :<, 2 #=> fail
# File minitest/unit.rb, line 585 def refute_operator o1, op, o2, msg = nil msg = message(msg) { "Expected #{mu_pp(o1)} to not be #{op} #{mu_pp(o2)}" } refute o1.__send__(op, o2), msg end
Fails if obj
responds to the message meth
.
# File minitest/unit.rb, line 595 def refute_respond_to obj, meth, msg = nil msg = message(msg) { "Expected #{mu_pp(obj)} to not respond to #{meth}" } refute obj.respond_to?(meth), msg end
Fails if exp
is the same (by object identity) as
act
.
# File minitest/unit.rb, line 604 def refute_same exp, act, msg = nil msg = message(msg) { data = [mu_pp(act), act.object_id, mu_pp(exp), exp.object_id] "Expected %s (oid=%d) to not be the same as %s (oid=%d)" % data } refute exp.equal?(act), msg 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.