Module: Micron::TestCase::Assertions
- Included in:
- Micron::TestCase
- Defined in:
- lib/micron/test_case/assertions.rb
Overview
Micron Assertions. All assertion methods accept a msg
which is printed if the assertion fails.
Copied from MiniTest
Constant Summary collapse
- UNDEFINED =
:nodoc:
Object.new
Class Method Summary collapse
-
.diff ⇒ Object
Returns the diff command to use in #diff.
-
.diff=(o) ⇒ Object
Set the diff command to use in #diff.
Instance Method Summary collapse
-
#_assertions ⇒ Object
:nodoc:.
-
#_assertions=(n) ⇒ Object
:nodoc:.
-
#assert(test, msg = nil) ⇒ Object
Fails unless
test
is 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
printing the difference between the two, if possible. -
#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 instance ofcls
. -
#assert_kind_of(cls, obj, msg = nil) ⇒ Object
Fails unless
obj
is a kind ofcls
. -
#assert_match(matcher, obj, msg = nil) ⇒ Object
Fails unless
matcher
=~
obj
. -
#assert_nil(obj, msg = nil) ⇒ Object
Fails unless
obj
is nil. -
#assert_operator(o1, op, o2 = UNDEFINED, msg = nil) ⇒ Object
For testing with binary operators.
-
#assert_output(stdout = nil, stderr = nil) ⇒ Object
Fails if stdout or stderr do not output the expected results.
-
#assert_predicate(o1, op, msg = nil) ⇒ Object
For testing with predicates.
-
#assert_raises(*exp) ⇒ Object
(also: #assert_throws)
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.
-
#capture_io ⇒ Object
Captures $stdout and $stderr into strings:.
-
#capture_subprocess_io ⇒ Object
Captures $stdout and $stderr into strings, using Tempfile to ensure that subprocess IO is captured as well.
-
#diff(exp, act) ⇒ Object
Returns a diff between
exp
andact
. -
#exception_details(e, msg) ⇒ Object
Returns details for exception
e
. -
#flunk(msg = nil) ⇒ Object
Fails with
msg
. -
#message(msg = nil, ending = ".", &default) ⇒ Object
Returns a proc that will output
msg
along with the default message. -
#mu_pp(obj) ⇒ Object
This returns a human-readable version of
obj
. -
#mu_pp_for_diff(obj) ⇒ Object
This returns a diff-able 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(matcher, obj, msg = nil) ⇒ Object
Fails if
matcher
=~
obj
. -
#refute_nil(obj, msg = nil) ⇒ Object
Fails if
obj
is nil. -
#refute_operator(o1, op, o2 = UNDEFINED, msg = nil) ⇒ Object
Fails if
o1
is notop
o2
. -
#refute_predicate(o1, op, msg = nil) ⇒ Object
For testing with predicates.
-
#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.
-
#skipped? ⇒ Boolean
Was this testcase skipped? Meant for #teardown.
-
#synchronize ⇒ Object
Takes a block and wraps it with the runner’s shared mutex.
Class Method Details
.diff ⇒ Object
Returns the diff command to use in #diff. Tries to intelligently figure out what diff to use.
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
# File 'lib/micron/test_case/assertions.rb', line 22 def self.diff @diff = if (RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ && system("diff.exe", __FILE__, __FILE__)) then "diff.exe -u" # elsif Minitest::Unit::Guard.maglev? then # HACK # "diff -u" elsif system("gdiff", __FILE__, __FILE__) "gdiff -u" # solaris and kin suck elsif system("diff", __FILE__, __FILE__) "diff -u" else nil end unless defined? @diff @diff end |
.diff=(o) ⇒ Object
Set the diff command to use in #diff.
42 43 44 |
# File 'lib/micron/test_case/assertions.rb', line 42 def self.diff= o @diff = o end |
Instance Method Details
#_assertions ⇒ Object
:nodoc:
122 123 124 |
# File 'lib/micron/test_case/assertions.rb', line 122 def _assertions # :nodoc: @_assertions ||= 0 end |
#_assertions=(n) ⇒ Object
:nodoc:
118 119 120 |
# File 'lib/micron/test_case/assertions.rb', line 118 def _assertions= n # :nodoc: @_assertions = n end |
#assert(test, msg = nil) ⇒ Object
Fails unless test
is a true value.
129 130 131 132 133 134 135 136 137 |
# File 'lib/micron/test_case/assertions.rb', line 129 def assert test, msg = nil msg ||= "Failed assertion, no message given." self._assertions += 1 unless test then msg = msg.call if Proc === msg raise Micron::Assertion, msg end true end |
#assert_empty(obj, msg = nil) ⇒ Object
Fails unless obj
is empty.
142 143 144 145 146 |
# File 'lib/micron/test_case/assertions.rb', line 142 def assert_empty obj, msg = nil msg = (msg) { "Expected #{mu_pp(obj)} to be empty" } assert_respond_to obj, :empty? assert obj.empty?, msg end |
#assert_equal(exp, act, msg = nil) ⇒ Object
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: Micron::TestCase::Assertions.diff
160 161 162 163 |
# File 'lib/micron/test_case/assertions.rb', line 160 def assert_equal exp, act, msg = nil msg = (msg, "") { diff exp, 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
171 172 173 174 175 176 177 |
# File 'lib/micron/test_case/assertions.rb', line 171 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
.
183 184 185 |
# File 'lib/micron/test_case/assertions.rb', line 183 def assert_in_epsilon a, b, epsilon = 0.001, msg = nil assert_in_delta a, b, [a.abs, b.abs].min * epsilon, msg end |
#assert_includes(collection, obj, msg = nil) ⇒ Object
Fails unless collection
includes obj
.
190 191 192 193 194 195 196 |
# File 'lib/micron/test_case/assertions.rb', line 190 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 instance of cls
.
201 202 203 204 205 206 207 |
# File 'lib/micron/test_case/assertions.rb', line 201 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
.
212 213 214 215 216 217 |
# File 'lib/micron/test_case/assertions.rb', line 212 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(matcher, obj, msg = nil) ⇒ Object
Fails unless matcher
=~
obj
.
222 223 224 225 226 227 |
# File 'lib/micron/test_case/assertions.rb', line 222 def assert_match matcher, obj, msg = nil msg = (msg) { "Expected #{mu_pp matcher} to match #{mu_pp obj}" } assert_respond_to matcher, :"=~" matcher = Regexp.new Regexp.escape matcher if String === matcher assert matcher =~ obj, msg end |
#assert_nil(obj, msg = nil) ⇒ Object
Fails unless obj
is nil
232 233 234 235 |
# File 'lib/micron/test_case/assertions.rb', line 232 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 = UNDEFINED, msg = nil) ⇒ Object
For testing with binary operators.
assert_operator 5, :<=, 4
242 243 244 245 246 |
# File 'lib/micron/test_case/assertions.rb', line 242 def assert_operator o1, op, o2 = UNDEFINED, msg = nil return assert_predicate o1, op, msg if UNDEFINED == o2 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. Pass in a regexp if you want to pattern match.
NOTE: this uses #capture_io, not #capture_subprocess_io.
See also: #assert_silent
258 259 260 261 262 263 264 265 266 267 268 269 270 |
# File 'lib/micron/test_case/assertions.rb', line 258 def assert_output stdout = nil, stderr = nil out, err = capture_io do yield end err_msg = Regexp === stderr ? :assert_match : :assert_equal if stderr out_msg = Regexp === stdout ? :assert_match : :assert_equal if stdout y = send err_msg, stderr, err, "In stderr" if err_msg x = send out_msg, stdout, out, "In stdout" if out_msg (!stdout || x) && (!stderr || y) end |
#assert_predicate(o1, op, msg = nil) ⇒ Object
For testing with predicates.
assert_predicate str, :empty?
This is really meant for specs and is front-ended by assert_operator:
str.must_be :empty?
281 282 283 284 |
# File 'lib/micron/test_case/assertions.rb', line 281 def assert_predicate o1, op, msg = nil msg = (msg) { "Expected #{mu_pp(o1)} to be #{op}" } assert o1.__send__(op), msg end |
#assert_raises(*exp) ⇒ Object Also known as: assert_throws
Fails unless the block raises one of exp
. Returns the exception matched so you can check the message, attributes, etc.
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 |
# File 'lib/micron/test_case/assertions.rb', line 290 def assert_raises *exp msg = "#{exp.pop}.\n" if String === exp.last begin yield rescue Micron::Skip => e return e if exp.include? Micron::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, "#{msg}#{mu_pp(exp)} exception expected, not") } return e end exp = exp.first if exp.size == 1 flunk "#{msg}#{mu_pp(exp)} expected but nothing was raised." end |
#assert_respond_to(obj, meth, msg = nil) ⇒ Object
Fails unless obj
responds to meth
.
323 324 325 326 327 328 |
# File 'lib/micron/test_case/assertions.rb', line 323 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?
333 334 335 336 337 338 339 |
# File 'lib/micron/test_case/assertions.rb', line 333 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
347 348 349 350 351 352 |
# File 'lib/micron/test_case/assertions.rb', line 347 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
359 360 361 362 363 |
# File 'lib/micron/test_case/assertions.rb', line 359 def assert_silent assert_output "", "" do yield end end |
#capture_io ⇒ Object
Captures $stdout and $stderr into strings:
out, err = capture_io do
puts "Some info"
warn "You did a bad thing"
end
assert_match %r%info%, out
assert_match %r%bad%, err
NOTE: For efficiency, this method uses StringIO and does not capture IO for subprocesses. Use #capture_subprocess_io for that.
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 |
# File 'lib/micron/test_case/assertions.rb', line 431 def capture_io require 'stringio' captured_stdout, captured_stderr = StringIO.new, StringIO.new synchronize do orig_stdout, orig_stderr = $stdout, $stderr $stdout, $stderr = captured_stdout, captured_stderr begin yield ensure $stdout = orig_stdout $stderr = orig_stderr end end return captured_stdout.string, captured_stderr.string end |
#capture_subprocess_io ⇒ Object
Captures $stdout and $stderr into strings, using Tempfile to ensure that subprocess IO is captured as well.
out, err = capture_subprocess_io do
system "echo Some info"
system "echo You did a bad thing 1>&2"
end
assert_match %r%info%, out
assert_match %r%bad%, err
NOTE: This method is approximately 10x slower than #capture_io so only use it when you need to test the output of a subprocess.
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 |
# File 'lib/micron/test_case/assertions.rb', line 466 def capture_subprocess_io require 'tempfile' captured_stdout, captured_stderr = Tempfile.new("out"), Tempfile.new("err") synchronize do orig_stdout, orig_stderr = $stdout.dup, $stderr.dup $stdout.reopen captured_stdout $stderr.reopen captured_stderr begin yield $stdout.rewind $stderr.rewind [captured_stdout.read, captured_stderr.read] ensure captured_stdout.unlink captured_stderr.unlink $stdout.reopen orig_stdout $stderr.reopen orig_stderr end end end |
#diff(exp, act) ⇒ Object
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.
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
# File 'lib/micron/test_case/assertions.rb', line 52 def diff exp, act require "tempfile" expect = mu_pp_for_diff exp butwas = mu_pp_for_diff act result = nil need_to_diff = Micron::TestCase::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 = `#{Micron::TestCase::Assertions.diff} #{a.path} #{b.path}` result.sub!(/^\-\-\- .+/, "--- expected") result.sub!(/^\+\+\+ .+/, "+++ actual") if result.empty? then klass = exp.class result = [ "No visible difference in the #{klass}#inspect output.\n", "You should look at the implementation of #== on ", "#{klass} or its members.\n", expect, ].join end end end result end |
#exception_details(e, msg) ⇒ Object
Returns details for exception e
495 496 497 498 499 500 501 |
# File 'lib/micron/test_case/assertions.rb', line 495 def exception_details e, msg [ "#{msg}", "<#{e.class}> #{e..inspect}", "#{Micron.filter_backtrace(e.backtrace).join("\n")}", ].join "\n " end |
#flunk(msg = nil) ⇒ Object
Fails with msg
506 507 508 509 |
# File 'lib/micron/test_case/assertions.rb', line 506 def flunk msg = nil msg ||= "Epic Fail!" assert false, msg end |
#message(msg = nil, ending = ".", &default) ⇒ Object
Returns a proc that will output msg
along with the default message.
514 515 516 517 518 519 520 |
# File 'lib/micron/test_case/assertions.rb', line 514 def msg = nil, ending = ".", &default proc { msg = msg.call.chomp(".") if Proc === msg = "#{msg}.\n" unless msg.nil? or msg.to_s.empty? "#{}#{default.call}#{ending}" } end |
#mu_pp(obj) ⇒ Object
This returns a human-readable version of obj
. By default #inspect is called. You can override this to use #pretty_print if you want.
102 103 104 105 106 |
# File 'lib/micron/test_case/assertions.rb', line 102 def mu_pp obj s = obj.inspect s = s.encode Encoding.default_external if defined? Encoding s end |
#mu_pp_for_diff(obj) ⇒ Object
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.
114 115 116 |
# File 'lib/micron/test_case/assertions.rb', line 114 def mu_pp_for_diff obj mu_pp(obj).gsub(/\\n/, "\n").gsub(/:0x[a-fA-F0-9]{4,}/m, ':0xXXXXXX') end |
#pass(msg = nil) ⇒ Object
used for counting assertions
525 526 527 |
# File 'lib/micron/test_case/assertions.rb', line 525 def pass msg = nil assert true end |
#refute(test, msg = nil) ⇒ Object
Fails if test
is a true value
532 533 534 535 |
# File 'lib/micron/test_case/assertions.rb', line 532 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.
540 541 542 543 544 |
# File 'lib/micron/test_case/assertions.rb', line 540 def refute_empty obj, msg = nil msg = (msg) { "Expected #{mu_pp(obj)} 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.
551 552 553 554 555 556 |
# File 'lib/micron/test_case/assertions.rb', line 551 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)
563 564 565 566 567 568 569 |
# File 'lib/micron/test_case/assertions.rb', line 563 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
.
575 576 577 |
# File 'lib/micron/test_case/assertions.rb', line 575 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
.
582 583 584 585 586 587 588 |
# File 'lib/micron/test_case/assertions.rb', line 582 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
.
593 594 595 596 597 598 |
# File 'lib/micron/test_case/assertions.rb', line 593 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
.
603 604 605 606 |
# File 'lib/micron/test_case/assertions.rb', line 603 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(matcher, obj, msg = nil) ⇒ Object
Fails if matcher
=~
obj
.
611 612 613 614 615 616 |
# File 'lib/micron/test_case/assertions.rb', line 611 def refute_match matcher, obj, msg = nil msg = (msg) {"Expected #{mu_pp matcher} to not match #{mu_pp obj}"} assert_respond_to matcher, :"=~" matcher = Regexp.new Regexp.escape matcher if String === matcher refute matcher =~ obj, msg end |
#refute_nil(obj, msg = nil) ⇒ Object
Fails if obj
is nil.
621 622 623 624 |
# File 'lib/micron/test_case/assertions.rb', line 621 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 = UNDEFINED, msg = nil) ⇒ Object
Fails if o1
is not op
o2
. Eg:
refute_operator 1, :>, 2 #=> pass
refute_operator 1, :<, 2 #=> fail
632 633 634 635 636 |
# File 'lib/micron/test_case/assertions.rb', line 632 def refute_operator o1, op, o2 = UNDEFINED, msg = nil return refute_predicate o1, op, msg if UNDEFINED == o2 msg = (msg) { "Expected #{mu_pp(o1)} to not be #{op} #{mu_pp(o2)}"} refute o1.__send__(op, o2), msg end |
#refute_predicate(o1, op, msg = nil) ⇒ Object
For testing with predicates.
refute_predicate str, :empty?
This is really meant for specs and is front-ended by refute_operator:
str.wont_be :empty?
647 648 649 650 |
# File 'lib/micron/test_case/assertions.rb', line 647 def refute_predicate o1, op, msg = nil msg = (msg) { "Expected #{mu_pp(o1)} to not be #{op}" } refute o1.__send__(op), msg end |
#refute_respond_to(obj, meth, msg = nil) ⇒ Object
Fails if obj
responds to the message meth
.
655 656 657 658 659 |
# File 'lib/micron/test_case/assertions.rb', line 655 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
.
664 665 666 667 668 669 670 |
# File 'lib/micron/test_case/assertions.rb', line 664 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 |
#skip(msg = nil, bt = caller) ⇒ Object
Skips the current test. Gets listed at the end of the run but doesn’t cause a failure exit code.
676 677 678 679 680 |
# File 'lib/micron/test_case/assertions.rb', line 676 def skip msg = nil, bt = caller msg ||= "Skipped, no message given" @skip = true raise Micron::Skip, msg, bt end |
#skipped? ⇒ Boolean
Was this testcase skipped? Meant for #teardown.
685 686 687 |
# File 'lib/micron/test_case/assertions.rb', line 685 def skipped? defined?(@skip) and @skip end |