MiniTest Assertions. All assertion methods accept a msg which is printed if the assertion fails.
Fails unless test is a true value.
# File lib/minitest/unit.rb, line 74 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 lib/minitest/unit.rb, line 87 def assert_block msg = nil msg = message(msg) { "Expected block to return true value" } assert yield, msg end
Fails unless obj is empty.
# File lib/minitest/unit.rb, line 95 def assert_empty obj, msg = nil msg = message(msg) { "Expected #{obj.inspect} to be empty" } assert_respond_to obj, :empty? assert obj.empty?, msg end
Fails unless exp == act.
For floats use assert_in_delta
# File lib/minitest/unit.rb, line 106 def assert_equal exp, act, msg = nil msg = message(msg) { "Expected #{mu_pp(exp)}, not #{mu_pp(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 lib/minitest/unit.rb, line 117 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 lib/minitest/unit.rb, line 127 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 lib/minitest/unit.rb, line 134 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 lib/minitest/unit.rb, line 145 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 lib/minitest/unit.rb, line 156 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 lib/minitest/unit.rb, line 166 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.escape exp}/ if String === exp && String === act assert exp =~ act, msg end
Fails unless obj is nil
# File lib/minitest/unit.rb, line 176 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 lib/minitest/unit.rb, line 186 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 unless the block raises one of exp
# File lib/minitest/unit.rb, line 194 def assert_raises *exp msg = String === exp.last ? exp.pop : nil msg = msg.to_s + "\n" if msg should_raise = false begin yield should_raise = true 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 lib/minitest/unit.rb, line 218 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 lib/minitest/unit.rb, line 228 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
# File lib/minitest/unit.rb, line 241 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 unless the block throws sym
# File lib/minitest/unit.rb, line 251 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 lib/minitest/unit.rb, line 277 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 details for exception e
# File lib/minitest/unit.rb, line 295 def exception_details e, msg "#{msg}\nClass: <#{e.class}>\nMessage: <#{e.message.inspect}>\n---Backtrace---\n#{MiniTest::filter_backtrace(e.backtrace).join("\n")}\n---------------" end
Fails with msg
# File lib/minitest/unit.rb, line 302 def flunk msg = nil msg ||= "Epic Fail!" assert false, msg end
Returns a proc that will output msg along with the default message.
# File lib/minitest/unit.rb, line 310 def message msg = nil, &default proc { if msg then msg = msg.to_s unless String === msg msg += '.' unless msg.empty? msg += "\n#{default.call}." msg.strip else "#{default.call}." end } end
mu_pp gives a human-readable version of obj. By default inspect is called. You can override this to use pretty_print if you want.
# File lib/minitest/unit.rb, line 57 def mu_pp obj s = obj.inspect s = s.force_encoding(Encoding.default_external) if defined? Encoding s end
used for counting assertions
# File lib/minitest/unit.rb, line 326 def pass msg = nil assert true end
Fails if test is a true value
# File lib/minitest/unit.rb, line 333 def refute test, msg = nil msg ||= "Failed refutation, no message given" not assert(! test, msg) end
Fails if obj is empty.
# File lib/minitest/unit.rb, line 341 def refute_empty obj, msg = nil msg = message(msg) { "Expected #{obj.inspect} 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 lib/minitest/unit.rb, line 352 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 lib/minitest/unit.rb, line 364 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 lib/minitest/unit.rb, line 376 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 lib/minitest/unit.rb, line 383 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 lib/minitest/unit.rb, line 394 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 lib/minitest/unit.rb, line 404 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 lib/minitest/unit.rb, line 412 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 lib/minitest/unit.rb, line 422 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 nil. eg:
refute_operator 1, :>, 2 #=> pass refute_operator 1, :<, 2 #=> fail
# File lib/minitest/unit.rb, line 433 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 lib/minitest/unit.rb, line 443 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 lib/minitest/unit.rb, line 452 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
Generated with the Darkfish Rdoc Generator 2.