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

Instance Method Details

#_assertions ⇒ Object

:nodoc:



76
77
78
 
# File 'lib/minitest/unit.rb', line 76

def _assertions # :nodoc:
  @_assertions ||= 0
end

#_assertions=(n) ⇒ Object

:nodoc:



72
73
74
 
# File 'lib/minitest/unit.rb', line 72

def _assertions= n # :nodoc:
  @_assertions = n
end

#assert(test, msg = nil) ⇒ Object

Fails unless test is a true value.



83
84
85
86
87
88
89
90
91
 
# File 'lib/minitest/unit.rb', line 83

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.



96
97
98
 
# File 'lib/minitest/unit.rb', line 96

def assert_block msg = nil
  assert yield, "Expected block to return true value."
end

#assert_empty(obj, msg = nil) ⇒ Object

Fails unless obj is empty.



103
104
105
106
107
 
# File 'lib/minitest/unit.rb', line 103

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

#assert_equal(exp, act, msg = nil) ⇒ Object

Fails unless exp == act.

For floats use assert_in_delta



114
115
116
117
 
# File 'lib/minitest/unit.rb', line 114

def assert_equal exp, act, msg = nil
  msg = message(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



125
126
127
128
129
 
# File 'lib/minitest/unit.rb', line 125

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

#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.



135
136
137
 
# File 'lib/minitest/unit.rb', line 135

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.



142
143
144
145
146
147
148
 
# File 'lib/minitest/unit.rb', line 142

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

#assert_instance_of(cls, obj, msg = nil) ⇒ Object

Fails unless obj is an instace of cls.



153
154
155
156
157
158
159
 
# File 'lib/minitest/unit.rb', line 153

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

#assert_kind_of(cls, obj, msg = nil) ⇒ Object

Fails unless obj is a kind of cls.



164
165
166
167
168
169
 
# File 'lib/minitest/unit.rb', line 164

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

#assert_match(exp, act, msg = nil) ⇒ Object

Fails unless exp is =~ act.



174
175
176
177
178
179
 
# File 'lib/minitest/unit.rb', line 174

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

#assert_nil(obj, msg = nil) ⇒ Object

Fails unless obj is nil



184
185
186
187
 
# File 'lib/minitest/unit.rb', line 184

def assert_nil obj, msg = nil
  msg = message(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



194
195
196
197
 
# File 'lib/minitest/unit.rb', line 194

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

#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



206
207
208
209
210
211
212
213
214
215
 
# File 'lib/minitest/unit.rb', line 206

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



220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'lib/minitest/unit.rb', line 220

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.



252
253
254
255
256
257
 
# File 'lib/minitest/unit.rb', line 252

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

#assert_same(exp, act, msg = nil) ⇒ Object

Fails unless exp and act are #equal?



262
263
264
265
266
267
268
 
# File 'lib/minitest/unit.rb', line 262

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

#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



276
277
278
279
280
281
 
# File 'lib/minitest/unit.rb', line 276

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

#assert_silent ⇒ Object

Fails if the block outputs anything to stderr or stdout.

See also: #assert_output



288
289
290
291
292
 
# File 'lib/minitest/unit.rb', line 288

def assert_silent
  assert_output "", "" do
    yield
  end
end

#assert_throws(sym, msg = nil) ⇒ Object

Fails unless the block throws sym



297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
 
# File 'lib/minitest/unit.rb', line 297

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

#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



323
324
325
326
327
328
329
330
331
332
333
334
335
336
 
# File 'lib/minitest/unit.rb', line 323

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



341
342
343
 
# File 'lib/minitest/unit.rb', line 341

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

#flunk(msg = nil) ⇒ Object

Fails with msg



348
349
350
351
 
# File 'lib/minitest/unit.rb', line 348

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.



356
357
358
359
360
361
362
363
364
365
366
367
 
# File 'lib/minitest/unit.rb', line 356

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(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.



66
67
68
69
70
 
# File 'lib/minitest/unit.rb', line 66

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



372
373
374
 
# File 'lib/minitest/unit.rb', line 372

def pass msg = nil
  assert true
end

#refute(test, msg = nil) ⇒ Object

Fails if test is a true value



379
380
381
382
 
# File 'lib/minitest/unit.rb', line 379

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.



387
388
389
390
391
 
# File 'lib/minitest/unit.rb', line 387

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

#refute_equal(exp, act, msg = nil) ⇒ Object

Fails if exp == act.

For floats use refute_in_delta.



398
399
400
401
402
403
 
# File 'lib/minitest/unit.rb', line 398

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

#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)



410
411
412
413
414
415
416
 
# File 'lib/minitest/unit.rb', line 410

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

#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.



422
423
424
 
# File 'lib/minitest/unit.rb', line 422

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



429
430
431
432
433
434
435
 
# File 'lib/minitest/unit.rb', line 429

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

#refute_instance_of(cls, obj, msg = nil) ⇒ Object

Fails if obj is an instance of cls



440
441
442
443
444
445
 
# File 'lib/minitest/unit.rb', line 440

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

#refute_kind_of(cls, obj, msg = nil) ⇒ Object

Fails if obj is a kind of cls



450
451
452
453
 
# File 'lib/minitest/unit.rb', line 450

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

#refute_match(exp, act, msg = nil) ⇒ Object

Fails if exp =~ act



458
459
460
461
462
463
 
# File 'lib/minitest/unit.rb', line 458

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

#refute_nil(obj, msg = nil) ⇒ Object

Fails if obj is nil.



468
469
470
471
 
# File 'lib/minitest/unit.rb', line 468

def refute_nil obj, msg = nil
  msg = message(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



479
480
481
482
483
484
 
# File 'lib/minitest/unit.rb', line 479

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

#refute_respond_to(obj, meth, msg = nil) ⇒ Object

Fails if obj responds to the message meth.



489
490
491
492
493
 
# File 'lib/minitest/unit.rb', line 489

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

#refute_same(exp, act, msg = nil) ⇒ Object

Fails if exp is the same (by object identity) as act.



498
499
500
501
502
503
504
 
# File 'lib/minitest/unit.rb', line 498

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

#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.

Raises:



510
511
512
513
 
# File 'lib/minitest/unit.rb', line 510

def skip msg = nil, bt = caller
  msg ||= "Skipped, no message given"
  raise MiniTest::Skip, msg, bt
end