Module: MiniTest::Assertions
- Included in:
- Unit::TestCase
- Defined in:
- lib/minitest/unit.rb
Overview
MiniTest Assertions. All assertion methods accept a msg
which is printed if the assertion fails.
Instance Method Summary collapse
-
#_assertions ⇒ Object
:nodoc:.
-
#_assertions=(n) ⇒ Object
:nodoc:.
-
#assert(test, msg = nil) ⇒ Object
Fails unless
test
is a true value. -
#assert_block(msg = nil) ⇒ Object
Fails unless the block returns a true value.
-
#assert_empty(obj, msg = nil) ⇒ Object
Fails unless
obj
is empty. -
#assert_equal(exp, act, msg = nil) ⇒ Object
Fails unless
exp == act
. -
#assert_in_delta(exp, act, delta = 0.001, msg = nil) ⇒ Object
For comparing Floats.
-
#assert_in_epsilon(a, b, epsilon = 0.001, msg = nil) ⇒ Object
For comparing Floats.
-
#assert_includes(collection, obj, msg = nil) ⇒ Object
Fails unless
collection
includesobj
. -
#assert_instance_of(cls, obj, msg = nil) ⇒ Object
Fails unless
obj
is an instace ofcls
. -
#assert_kind_of(cls, obj, msg = nil) ⇒ Object
Fails unless
obj
is a kind ofcls
. -
#assert_match(exp, act, msg = nil) ⇒ Object
Fails unless
exp
is=~
act
. -
#assert_nil(obj, msg = nil) ⇒ Object
Fails unless
obj
is nil. -
#assert_operator(o1, op, o2, msg = nil) ⇒ Object
For testing equality operators and so-forth.
-
#assert_output(stdout = nil, stderr = nil) ⇒ Object
Fails if stdout or stderr do not output the expected results.
-
#assert_raises(*exp) ⇒ Object
Fails unless the block raises one of
exp
. -
#assert_respond_to(obj, meth, msg = nil) ⇒ Object
Fails unless
obj
responds tometh
. -
#assert_same(exp, act, msg = nil) ⇒ Object
Fails unless
exp
andact
are #equal?. -
#assert_send(send_ary, m = nil) ⇒ Object
send_ary
is a receiver, message and arguments. -
#assert_silent ⇒ Object
Fails if the block outputs anything to stderr or stdout.
-
#assert_throws(sym, msg = nil) ⇒ Object
Fails unless the block throws
sym
. -
#capture_io ⇒ Object
Captures $stdout and $stderr into strings:.
-
#exception_details(e, msg) ⇒ Object
Returns details for exception
e
. -
#flunk(msg = nil) ⇒ Object
Fails with
msg
. -
#message(msg = nil, &default) ⇒ Object
Returns a proc that will output
msg
along with the default message. -
#mu_pp(obj) ⇒ Object
mu_pp gives a human-readable version of
obj
. -
#pass(msg = nil) ⇒ Object
used for counting assertions.
-
#refute(test, msg = nil) ⇒ Object
Fails if
test
is a true value. -
#refute_empty(obj, msg = nil) ⇒ Object
Fails if
obj
is empty. -
#refute_equal(exp, act, msg = nil) ⇒ Object
Fails if
exp == act
. -
#refute_in_delta(exp, act, delta = 0.001, msg = nil) ⇒ Object
For comparing Floats.
-
#refute_in_epsilon(a, b, epsilon = 0.001, msg = nil) ⇒ Object
For comparing Floats.
-
#refute_includes(collection, obj, msg = nil) ⇒ Object
Fails if
collection
includesobj
. -
#refute_instance_of(cls, obj, msg = nil) ⇒ Object
Fails if
obj
is an instance ofcls
. -
#refute_kind_of(cls, obj, msg = nil) ⇒ Object
Fails if
obj
is a kind ofcls
. -
#refute_match(exp, act, msg = nil) ⇒ Object
Fails if
exp
=~
act
. -
#refute_nil(obj, msg = nil) ⇒ Object
Fails if
obj
is nil. -
#refute_operator(o1, op, o2, msg = nil) ⇒ Object
Fails if
o1
is notop
o2
nil. -
#refute_respond_to(obj, meth, msg = nil) ⇒ Object
Fails if
obj
responds to the messagemeth
. -
#refute_same(exp, act, msg = nil) ⇒ Object
Fails if
exp
is the same (by object identity) asact
. -
#skip(msg = nil, bt = caller) ⇒ Object
Skips the current test.
Instance Method Details
#_assertions ⇒ Object
:nodoc:
67 68 69 |
# File 'lib/minitest/unit.rb', line 67 def _assertions # :nodoc: @_assertions ||= 0 end |
#_assertions=(n) ⇒ Object
:nodoc:
63 64 65 |
# File 'lib/minitest/unit.rb', line 63 def _assertions= n # :nodoc: @_assertions = n end |
#assert(test, msg = nil) ⇒ Object
Fails unless test
is a true value.
74 75 76 77 78 79 80 81 82 |
# 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 |
#assert_block(msg = nil) ⇒ Object
Fails unless the block returns a true value.
87 88 89 90 |
# File 'lib/minitest/unit.rb', line 87 def assert_block msg = nil msg = (msg) { "Expected block to return true value" } assert yield, msg end |
#assert_empty(obj, msg = nil) ⇒ Object
Fails unless obj
is empty.
95 96 97 98 99 |
# File 'lib/minitest/unit.rb', line 95 def assert_empty obj, msg = nil msg = (msg) { "Expected #{obj.inspect} to be empty" } assert_respond_to obj, :empty? assert obj.empty?, msg end |
#assert_equal(exp, act, msg = nil) ⇒ Object
Fails unless exp == act
.
For floats use assert_in_delta
106 107 108 109 |
# File 'lib/minitest/unit.rb', line 106 def assert_equal exp, act, msg = nil msg = (msg) { "Expected #{mu_pp(exp)}, not #{mu_pp(act)}" } assert(exp == act, msg) end |
#assert_in_delta(exp, act, delta = 0.001, msg = nil) ⇒ Object
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
117 118 119 120 121 |
# File 'lib/minitest/unit.rb', line 117 def assert_in_delta exp, act, delta = 0.001, msg = nil n = (exp - act).abs msg = (msg) { "Expected #{exp} - #{act} (#{n}) to be < #{delta}" } assert delta >= n, msg end |
#assert_in_epsilon(a, b, epsilon = 0.001, msg = nil) ⇒ Object
For comparing Floats. Fails unless exp
and act
have a relative error less than epsilon
.
127 128 129 |
# 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 |
#assert_includes(collection, obj, msg = nil) ⇒ Object
Fails unless collection
includes obj
.
134 135 136 137 138 139 140 |
# File 'lib/minitest/unit.rb', line 134 def assert_includes collection, obj, msg = nil msg = (msg) { "Expected #{mu_pp(collection)} to include #{mu_pp(obj)}" } assert_respond_to collection, :include? assert collection.include?(obj), msg end |
#assert_instance_of(cls, obj, msg = nil) ⇒ Object
Fails unless obj
is an instace of cls
.
145 146 147 148 149 150 151 |
# File 'lib/minitest/unit.rb', line 145 def assert_instance_of cls, obj, msg = nil msg = (msg) { "Expected #{mu_pp(obj)} to be an instance of #{cls}, not #{obj.class}" } assert obj.instance_of?(cls), msg end |
#assert_kind_of(cls, obj, msg = nil) ⇒ Object
Fails unless obj
is a kind of cls
.
156 157 158 159 160 161 |
# File 'lib/minitest/unit.rb', line 156 def assert_kind_of cls, obj, msg = nil # TODO: merge with instance_of msg = (msg) { "Expected #{mu_pp(obj)} to be a kind of #{cls}, not #{obj.class}" } assert obj.kind_of?(cls), msg end |
#assert_match(exp, act, msg = nil) ⇒ Object
Fails unless exp
is =~
act
.
166 167 168 169 170 171 |
# File 'lib/minitest/unit.rb', line 166 def assert_match exp, act, msg = nil msg = (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 |
#assert_nil(obj, msg = nil) ⇒ Object
Fails unless obj
is nil
176 177 178 179 |
# File 'lib/minitest/unit.rb', line 176 def assert_nil obj, msg = nil msg = (msg) { "Expected #{mu_pp(obj)} to be nil" } assert obj.nil?, msg end |
#assert_operator(o1, op, o2, msg = nil) ⇒ Object
For testing equality operators and so-forth.
assert_operator 5, :<=, 4
186 187 188 189 |
# File 'lib/minitest/unit.rb', line 186 def assert_operator o1, op, o2, msg = nil msg = (msg) { "Expected #{mu_pp(o1)} to be #{op} #{mu_pp(o2)}" } assert o1.__send__(op, o2), msg end |
#assert_output(stdout = nil, stderr = nil) ⇒ Object
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
198 199 200 201 202 203 204 205 206 207 |
# File 'lib/minitest/unit.rb', line 198 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 |
#assert_raises(*exp) ⇒ Object
Fails unless the block raises one of exp
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 |
# File 'lib/minitest/unit.rb', line 212 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 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 |
#assert_respond_to(obj, meth, msg = nil) ⇒ Object
Fails unless obj
responds to meth
.
244 245 246 247 248 249 |
# File 'lib/minitest/unit.rb', line 244 def assert_respond_to obj, meth, msg = nil msg = (msg) { "Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}" } assert obj.respond_to?(meth), msg end |
#assert_same(exp, act, msg = nil) ⇒ Object
Fails unless exp
and act
are #equal?
254 255 256 257 258 259 260 |
# File 'lib/minitest/unit.rb', line 254 def assert_same exp, act, msg = nil msg = (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 |
#assert_send(send_ary, m = nil) ⇒ Object
send_ary
is a receiver, message and arguments.
Fails unless the call returns a true value TODO: I should prolly remove this from specs
268 269 270 271 272 273 |
# File 'lib/minitest/unit.rb', line 268 def assert_send send_ary, m = nil recv, msg, *args = send_ary m = (m) { "Expected #{mu_pp(recv)}.#{msg}(*#{mu_pp(args)}) to return true" } assert recv.__send__(msg, *args), m end |
#assert_silent ⇒ Object
Fails if the block outputs anything to stderr or stdout.
See also: #assert_output
280 281 282 283 284 |
# File 'lib/minitest/unit.rb', line 280 def assert_silent assert_output "", "" do yield end end |
#assert_throws(sym, msg = nil) ⇒ Object
Fails unless the block throws sym
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 |
# File 'lib/minitest/unit.rb', line 289 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..split(/ /).last}" rescue NameError => e # 1.8 exception default += ", not #{e.name.inspect}" end caught = false end assert caught, (msg) { default } end |
#capture_io ⇒ Object
Captures $stdout and $stderr into strings:
out, err = capture_io do
warn "You did a bad thing"
end
assert_match %r%bad%, err
315 316 317 318 319 320 321 322 323 324 325 326 327 328 |
# File 'lib/minitest/unit.rb', line 315 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 |
#exception_details(e, msg) ⇒ Object
Returns details for exception e
333 334 335 |
# File 'lib/minitest/unit.rb', line 333 def exception_details e, msg "#{msg}\nClass: <#{e.class}>\nMessage: <#{e..inspect}>\n---Backtrace---\n#{MiniTest::filter_backtrace(e.backtrace).join("\n")}\n---------------" end |
#flunk(msg = nil) ⇒ Object
Fails with msg
340 341 342 343 |
# File 'lib/minitest/unit.rb', line 340 def flunk msg = nil msg ||= "Epic Fail!" assert false, msg end |
#message(msg = nil, &default) ⇒ Object
Returns a proc that will output msg
along with the default message.
348 349 350 351 352 353 354 355 356 357 358 359 |
# File 'lib/minitest/unit.rb', line 348 def 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(obj) ⇒ Object
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.
57 58 59 60 61 |
# 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 |
#pass(msg = nil) ⇒ Object
used for counting assertions
364 365 366 |
# File 'lib/minitest/unit.rb', line 364 def pass msg = nil assert true end |
#refute(test, msg = nil) ⇒ Object
Fails if test
is a true value
371 372 373 374 |
# File 'lib/minitest/unit.rb', line 371 def refute test, msg = nil msg ||= "Failed refutation, no message given" not assert(! test, msg) end |
#refute_empty(obj, msg = nil) ⇒ Object
Fails if obj
is empty.
379 380 381 382 383 |
# File 'lib/minitest/unit.rb', line 379 def refute_empty obj, msg = nil msg = (msg) { "Expected #{obj.inspect} to not be empty" } assert_respond_to obj, :empty? refute obj.empty?, msg end |
#refute_equal(exp, act, msg = nil) ⇒ Object
Fails if exp == act
.
For floats use refute_in_delta.
390 391 392 393 394 395 |
# File 'lib/minitest/unit.rb', line 390 def refute_equal exp, act, msg = nil msg = (msg) { "Expected #{mu_pp(act)} to not be equal to #{mu_pp(exp)}" } refute exp == act, msg end |
#refute_in_delta(exp, act, delta = 0.001, msg = nil) ⇒ Object
For comparing Floats. Fails if exp
is within delta
of act
refute_in_delta Math::PI, (22.0 / 7.0)
402 403 404 405 406 407 408 |
# File 'lib/minitest/unit.rb', line 402 def refute_in_delta exp, act, delta = 0.001, msg = nil n = (exp - act).abs msg = (msg) { "Expected #{exp} - #{act} (#{n}) to not be < #{delta}" } refute delta > n, msg end |
#refute_in_epsilon(a, b, epsilon = 0.001, msg = nil) ⇒ Object
For comparing Floats. Fails if exp
and act
have a relative error less than epsilon
.
414 415 416 |
# File 'lib/minitest/unit.rb', line 414 def refute_in_epsilon a, b, epsilon = 0.001, msg = nil refute_in_delta a, b, a * epsilon, msg end |
#refute_includes(collection, obj, msg = nil) ⇒ Object
Fails if collection
includes obj
421 422 423 424 425 426 427 |
# File 'lib/minitest/unit.rb', line 421 def refute_includes collection, obj, msg = nil msg = (msg) { "Expected #{mu_pp(collection)} to not include #{mu_pp(obj)}" } assert_respond_to collection, :include? refute collection.include?(obj), msg end |
#refute_instance_of(cls, obj, msg = nil) ⇒ Object
Fails if obj
is an instance of cls
432 433 434 435 436 437 |
# File 'lib/minitest/unit.rb', line 432 def refute_instance_of cls, obj, msg = nil msg = (msg) { "Expected #{mu_pp(obj)} to not be an instance of #{cls}" } refute obj.instance_of?(cls), msg end |
#refute_kind_of(cls, obj, msg = nil) ⇒ Object
Fails if obj
is a kind of cls
442 443 444 445 |
# File 'lib/minitest/unit.rb', line 442 def refute_kind_of cls, obj, msg = nil # TODO: merge with instance_of msg = (msg) { "Expected #{mu_pp(obj)} to not be a kind of #{cls}" } refute obj.kind_of?(cls), msg end |
#refute_match(exp, act, msg = nil) ⇒ Object
Fails if exp
=~
act
450 451 452 453 454 455 |
# File 'lib/minitest/unit.rb', line 450 def refute_match exp, act, msg = nil msg = (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 |
#refute_nil(obj, msg = nil) ⇒ Object
Fails if obj
is nil.
460 461 462 463 |
# File 'lib/minitest/unit.rb', line 460 def refute_nil obj, msg = nil msg = (msg) { "Expected #{mu_pp(obj)} to not be nil" } refute obj.nil?, msg end |
#refute_operator(o1, op, o2, msg = nil) ⇒ Object
Fails if o1
is not op
o2
nil. eg:
refute_operator 1, :>, 2 #=> pass
refute_operator 1, :<, 2 #=> fail
471 472 473 474 475 476 |
# File 'lib/minitest/unit.rb', line 471 def refute_operator o1, op, o2, msg = nil msg = (msg) { "Expected #{mu_pp(o1)} to not be #{op} #{mu_pp(o2)}" } refute o1.__send__(op, o2), msg end |
#refute_respond_to(obj, meth, msg = nil) ⇒ Object
Fails if obj
responds to the message meth
.
481 482 483 484 485 |
# File 'lib/minitest/unit.rb', line 481 def refute_respond_to obj, meth, msg = nil msg = (msg) { "Expected #{mu_pp(obj)} to not respond to #{meth}" } refute obj.respond_to?(meth), msg end |
#refute_same(exp, act, msg = nil) ⇒ Object
Fails if exp
is the same (by object identity) as act
.
490 491 492 493 494 495 496 |
# File 'lib/minitest/unit.rb', line 490 def refute_same exp, act, msg = nil msg = (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 |