Module: Test::Unit::Assertions

Included in:
TestCase
Defined in:
lib/test/unit/assertions.rb

Overview

Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is included in Test::Unit::TestCase.

To include it in your own code and use its functionality, you simply need to rescue Test::Unit::AssertionFailedError. Additionally you may override add_assertion to get notified whenever an assertion is made.

Notes:

  • The message to each assertion, if given, will be propagated with the failure.

  • It is easy to add your own assertions based on assert_block().

Example Custom Assertion

def deny(boolean, message = nil)
  message = build_message message, '<?> is not false or nil.', boolean
  assert_block message do
    not boolean
  end
end

Defined Under Namespace

Classes: AssertExceptionHelper, AssertionMessage

Constant Summary collapse

UncaughtThrow = 
{
  NameError => /^uncaught throw \`(.+)\'$/,
  ArgumentError => /^uncaught throw (.+)$/,
  ThreadError => /^uncaught throw \`(.+)\' in thread /
}

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.use_pp=(value) ⇒ Object 



831
832
833
 
# File 'lib/test/unit/assertions.rb', line 831

def self.use_pp=(value)
  AssertionMessage.use_pp = value
end

Instance Method Details

#assert(boolean, message = nil) ⇒ Object 



63
64
65
66
67
68
 
# File 'lib/test/unit/assertions.rb', line 63

def assert(boolean, message=nil)
  _wrap_assertion do
    assert_block("assert should not be called with a block.") { !block_given? }
    assert_block(build_message(message, "<?> is not true.", boolean)) { boolean }
  end
end

#assert_block(message = "assert_block failed.") ⇒ Object

:yields:



48
49
50
51
52
53
54
 
# File 'lib/test/unit/assertions.rb', line 48

def assert_block(message="assert_block failed.") # :yields: 
  _wrap_assertion do
    if (! yield)
      raise AssertionFailedError.new(message.to_s)
    end
  end
end

#assert_boolean(actual, message = nil) ⇒ Object

Passes if actual is a boolean value.

Example:

assert_boolean(true) # -> pass
assert_boolean(nil)  # -> fail



576
577
578
579
580
581
582
583
584
 
# File 'lib/test/unit/assertions.rb', line 576

def assert_boolean(actual, message=nil)
  _wrap_assertion do
    assert_block(build_message(message,
                               "<true> or <false> expected but was\n<?>",
                               actual)) do
      [true, false].include?(actual)
    end
  end
end

#assert_compare(expected, operator, actual, message = nil) ⇒ Object

Passes if expression “expected operator actual” is true.

Example:

assert_compare(1, "<", 10)  # -> pass
assert_compare(1, ">=", 10) # -> fail



625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
 
# File 'lib/test/unit/assertions.rb', line 625

def assert_compare(expected, operator, actual, message=nil)
  _wrap_assertion do
    assert_send([["<", "<=", ">", ">="], :include?, operator.to_s])
    case operator.to_s
    when "<"
      operator_description = "less than"
    when "<="
      operator_description = "less than or equal to"
    when ">"
      operator_description = "greater than"
    when ">="
      operator_description = "greater than or equal to"
    end
    template = "<?> \#{operator} <?> should be true\n<?> expected \#{operator_description}\n<?>.\n"
    full_message = build_message(message, template,
                                 expected, actual,
                                 expected, actual)
    assert_block(full_message) do
      expected.send(operator, actual)
    end
  end
end

#assert_const_defined(object, constant_name, message = nil) ⇒ Object

Passes if object.const_defined?(constant_name)

Example:

assert_const_defined(Test, :Unit)          # -> pass
assert_const_defined(Object, :Nonexistent) # -> fail



720
721
722
723
724
725
726
727
728
729
 
# File 'lib/test/unit/assertions.rb', line 720

def assert_const_defined(object, constant_name, message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "<?>.const_defined\\?(<?>) expected.",
                                 object, constant_name)
    assert_block(full_message) do
      object.const_defined?(constant_name)
    end
  end
end

#assert_equal(expected, actual, message = nil) ⇒ Object 



81
82
83
84
85
86
87
88
 
# File 'lib/test/unit/assertions.rb', line 81

def assert_equal(expected, actual, message=nil)
  diff = AssertionMessage.delayed_diff(expected, actual)
  full_message = build_message(message, "<?> expected but was\n<?>.?\n", expected, actual, diff)
  assert_block(full_message) { expected == actual }
end

#assert_fail_assertion(message = nil) ⇒ Object

Passes if assertion is failed in block.

Example:

assert_fail_assertion {assert_equal("A", "B")}  # -> pass
assert_fail_assertion {assert_equal("A", "A")}  # -> fail



658
659
660
661
662
663
664
665
666
667
668
669
670
671
 
# File 'lib/test/unit/assertions.rb', line 658

def assert_fail_assertion(message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "Failed assertion was expected.")
    assert_block(full_message) do
      begin
        yield
        false
      rescue AssertionFailedError
        true
      end
    end
  end
end

#assert_false(actual, message = nil) ⇒ Object

Passes if actual is false.

Example:

assert_false(false)  # -> pass
assert_false(nil)    # -> fail



608
609
610
611
612
613
614
615
616
 
# File 'lib/test/unit/assertions.rb', line 608

def assert_false(actual, message=nil)
  _wrap_assertion do
    assert_block(build_message(message,
                               "<false> expected but was\n<?>",
                               actual)) do
      actual == false
    end
  end
end

#assert_in_delta(expected_float, actual_float, delta, message = "") ⇒ Object 



531
532
533
534
535
536
537
538
539
540
541
542
543
544
 
# File 'lib/test/unit/assertions.rb', line 531

def assert_in_delta(expected_float, actual_float, delta, message="")
  _wrap_assertion do
    {expected_float => "first float", actual_float => "second float", delta => "delta"}.each do |float, name|
      assert_respond_to(float, :to_f, "The arguments must respond to to_f; the #{name} did not")
    end
    assert_operator(delta, :>=, 0.0, "The delta should not be negative")
    full_message = build_message(message, "<?> and\n<?> expected to be within\n<?> of each other.\n", expected_float, actual_float, delta)
    assert_block(full_message) { (expected_float.to_f - actual_float.to_f).abs <= delta.to_f }
  end
end

#assert_instance_of(klass, object, message = "") ⇒ Object 



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/test/unit/assertions.rb', line 167

def assert_instance_of(klass, object, message="")
  _wrap_assertion do
    klasses = nil
    klasses = klass if klass.is_a?(Array)
    assert_block("The first parameter to assert_instance_of should be " +
                 "a Class or an Array of Class.") do
      if klasses
        klasses.all? {|k| k.is_a?(Class)}
      else
        klass.is_a?(Class)
      end
    end
    klass_message = AssertionMessage.maybe_container(klass) do |value|
      "<#{value}>"
    end
    full_message = build_message(message, "<?> expected to be an instance of\n? but was\n<?>.\n", object, klass_message, object.class)
    assert_block(full_message) do
      if klasses
        klasses.any? {|k| object.instance_of?(k)}
      else
        object.instance_of?(klass)
      end
    end
  end
end

#assert_kind_of(klass, object, message = "") ⇒ Object 



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
248
249
250
251
252
 
# File 'lib/test/unit/assertions.rb', line 222

def assert_kind_of(klass, object, message="")
  _wrap_assertion do
    klasses = nil
    klasses = klass if klass.is_a?(Array)
    assert_block("The first parameter to assert_kind_of should be " +
                 "a kind_of Module or an Array of a kind_of Module.") do
      if klasses
        klasses.all? {|k| k.kind_of?(Module)}
      else
        klass.kind_of?(Module)
      end
    end
    klass_message = AssertionMessage.maybe_container(klass) do |value|
      "<#{value}>"
    end
    full_message = build_message(message,
                                 "<?> expected to be kind_of\\?\n" +
                                 "? but was\n" +
                                 "<?>.",
                                 object,
                                 klass_message,
                                 object.class)
    assert_block(full_message) do
      if klasses
        klasses.any? {|k| object.kind_of?(k)}
      else
        object.kind_of?(klass)
      end
    end
  end
end

#assert_match(pattern, string, message = "") ⇒ Object 



285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/test/unit/assertions.rb', line 285

def assert_match(pattern, string, message="")
  _wrap_assertion do
    pattern = case(pattern)
      when String
        Regexp.new(Regexp.escape(pattern))
      else
        pattern
    end
    full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
    assert_block(full_message) { string =~ pattern }
  end
end

#assert_nil(object, message = "") ⇒ Object 



204
205
206
207
208
209
 
# File 'lib/test/unit/assertions.rb', line 204

def assert_nil(object, message="")
  full_message = build_message(message, "<?> expected to be nil.\n", object)
  assert_block(full_message) { object.nil? }
end

#assert_no_match(regexp, string, message = "") ⇒ Object 



431
432
433
434
435
436
437
 
# File 'lib/test/unit/assertions.rb', line 431

def assert_no_match(regexp, string, message="")
  _wrap_assertion do
    assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
    full_message = build_message(message, "<?> expected to not match\n<?>.", regexp, string)
    assert_block(full_message) { regexp !~ string }
  end
end

#assert_not_const_defined(object, constant_name, message = nil) ⇒ Object

Passes if !object.const_defined?(constant_name)

Example:

assert_not_const_defined(Object, :Nonexistent) # -> pass
assert_not_const_defined(Test, :Unit)          # -> fail



737
738
739
740
741
742
743
744
745
746
 
# File 'lib/test/unit/assertions.rb', line 737

def assert_not_const_defined(object, constant_name, message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "!<?>.const_defined\\?(<?>) expected.",
                                 object, constant_name)
    assert_block(full_message) do
      !object.const_defined?(constant_name)
    end
  end
end

#assert_not_equal(expected, actual, message = "") ⇒ Object 



407
408
409
410
 
# File 'lib/test/unit/assertions.rb', line 407

def assert_not_equal(expected, actual, message="")
  full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
  assert_block(full_message) { expected != actual }
end

#assert_not_nil(object, message = "") ⇒ Object 



419
420
421
422
 
# File 'lib/test/unit/assertions.rb', line 419

def assert_not_nil(object, message="")
  full_message = build_message(message, "<?> expected to not be nil.", object)
  assert_block(full_message){!object.nil?}
end

#assert_not_predicate(object, predicate, message = nil) ⇒ Object

Passes if object.predicate

Example:

assert_not_predicate([1], :empty?) # -> pass
assert_not_predicate([], :empty?)  # -> fail



776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
 
# File 'lib/test/unit/assertions.rb', line 776

def assert_not_predicate(object, predicate, message=nil)
  _wrap_assertion do
    assert_respond_to(object, predicate, message)
    actual = object.send(predicate)
    full_message = build_message(message,
                                 "<?>.? is false value expected but was\n" +
                                 "<?>",
                                 object,
                                 AssertionMessage.literal(predicate),
                                 actual)
    assert_block(full_message) do
      not actual
    end
  end
end

#assert_not_same(expected, actual, message = "") ⇒ Object 



390
391
392
393
394
395
396
397
398
 
# File 'lib/test/unit/assertions.rb', line 390

def assert_not_same(expected, actual, message="")
  full_message = build_message(message, "<?>\nwith id <?> expected to not be equal\\\\? to\n<?>\nwith id <?>.\n", expected, expected.__id__, actual, actual.__id__)
  assert_block(full_message) { !actual.equal?(expected) }
end

#assert_nothing_raised(*args) ⇒ Object 



348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
 
# File 'lib/test/unit/assertions.rb', line 348

def assert_nothing_raised(*args)
  _wrap_assertion do
    if args.last.is_a?(String)
      message = args.pop
    else
      message = ""
    end

    assert_exception_helper = AssertExceptionHelper.new(self, args)
    begin
      yield
    rescue Exception => e
      if ((args.empty? && !e.instance_of?(AssertionFailedError)) ||
          assert_exception_helper.expected?(e))
        failure_message = build_message(message, "Exception raised:\n?", e)
        assert_block(failure_message) {false}
      else
        raise
      end
    end
    nil
  end
end

#assert_nothing_thrown(message = "", &proc) ⇒ Object 



505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
 
# File 'lib/test/unit/assertions.rb', line 505

def assert_nothing_thrown(message="", &proc)
  _wrap_assertion do
    assert(block_given?, "Should have passed a block to assert_nothing_thrown")
    begin
      proc.call
    rescue NameError, ArgumentError, ThreadError => error
      raise unless UncaughtThrow[error.class] =~ error.message
      tag = $1
      tag = tag[1..-1].intern if tag[0, 1] == ":"
      full_message = build_message(message,
                                   "<?> was thrown when nothing was expected",
                                   tag)
      flunk(full_message)
    end
    assert(true, "Expected nothing to be thrown")
  end
end

#assert_operator(object1, operator, object2, message = "") ⇒ Object 



326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/test/unit/assertions.rb', line 326

def assert_operator(object1, operator, object2, message="")
  _wrap_assertion do
    full_message = build_message(nil, "<?>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
    assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
    full_message = build_message(message, "<?> expected to be\n?\n<?>.\n", object1, AssertionMessage.literal(operator), object2)
    assert_block(full_message) { object1.__send__(operator, object2) }
  end
end

#assert_predicate(object, predicate, message = nil) ⇒ Object

Passes if object.predicate

Example:

assert_predicate([], :empty?)  # -> pass
assert_predicate([1], :empty?) # -> fail



754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
 
# File 'lib/test/unit/assertions.rb', line 754

def assert_predicate(object, predicate, message=nil)
  _wrap_assertion do
    assert_respond_to(object, predicate, message)
    actual = object.send(predicate)
    full_message = build_message(message,
                                 "<?>.? is true value expected but was\n" +
                                 "<?>",
                                 object,
                                 AssertionMessage.literal(predicate),
                                 actual)
    assert_block(full_message) do
      actual
    end
  end
end

#assert_raise(*args, &block) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/test/unit/assertions.rb', line 108

def assert_raise(*args, &block)
  assert_expected_exception = Proc.new do |*_args|
    message, assert_exception_helper, actual_exception = _args
    expected = assert_exception_helper.expected_exceptions
    full_message = build_message(message,
                                 "<?> exception expected but was\n?",
                                 expected, actual_exception)
    assert_block(full_message) do
      expected == [] or assert_exception_helper.expected?(actual_exception)
    end
  end
  _assert_raise(assert_expected_exception, *args, &block)
end

#assert_raise_kind_of(*args, &block) ⇒ Object

Passes if the block raises one of the given exceptions or sub exceptions of the given exceptions.

Example:

assert_raise_kind_of(SystemCallError) do
  raise Errno::EACCES
end



140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/test/unit/assertions.rb', line 140

def assert_raise_kind_of(*args, &block)
  assert_expected_exception = Proc.new do |*_args|
    message, assert_exception_helper, actual_exception = _args
    expected = assert_exception_helper.expected_exceptions
    full_message = build_message(message,
                                 "<?> family exception expected " +
                                 "but was\n?",
                                 expected, actual_exception)
    assert_block(full_message) do
      assert_exception_helper.expected?(actual_exception, :kind_of?)
    end
  end
  _assert_raise(assert_expected_exception, *args, &block)
end

#assert_raise_message(expected, message = nil) ⇒ Object

Passes if an exception is raised in block and its message is expected.

Example:

assert_raise_message("exception") {raise "exception"}  # -> pass
assert_raise_message(/exc/i) {raise "exception"}       # -> pass
assert_raise_message("exception") {raise "EXCEPTION"}  # -> fail
assert_raise_message("exception") {}                   # -> fail



682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
 
# File 'lib/test/unit/assertions.rb', line 682

def assert_raise_message(expected, message=nil)
  _wrap_assertion do
    full_message = build_message(message,
                                 "<?> exception message expected " +
                                 "but none was thrown.",
                                 expected)
    exception = nil
    assert_block(full_message) do
      begin
        yield
        false
      rescue Exception => exception
        true
      end
    end

    actual = exception.message
    diff = AssertionMessage.delayed_diff(expected, actual)
    full_message =
      build_message(message,
                    "<?> exception message expected but was\n" +
                    "<?>.?", expected, actual, diff)
    assert_block(full_message) do
      if expected.is_a?(Regexp)
        expected =~ actual
      else
        expected == actual
      end
    end
  end
end

#assert_raises(*args, &block) ⇒ Object 



128
129
130
 
# File 'lib/test/unit/assertions.rb', line 128

def assert_raises(*args, &block)
  assert_raise(*args, &block)
end

#assert_respond_to(object, method, message = "") ⇒ Object 



261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
 
# File 'lib/test/unit/assertions.rb', line 261

def assert_respond_to(object, method, message="")
  _wrap_assertion do
    full_message = build_message(message,
                                 "<?>.kind_of\\?(Symbol) or\n" +
                                 "<?>.respond_to\\?(:to_str) expected",
                                 method, method)
    assert_block(full_message) do
      method.kind_of?(Symbol) or method.respond_to?(:to_str)
    end
    full_message = build_message(message,
                                 "<?>.respond_to\\?(?) expected\n" +
                                 "(Class: <?>)",
                                 object, method, object.class)
    assert_block(full_message) {object.respond_to?(method)}
  end
end

#assert_same(expected, actual, message = "") ⇒ Object 



307
308
309
310
311
312
313
314
315
 
# File 'lib/test/unit/assertions.rb', line 307

def assert_same(expected, actual, message="")
  full_message = build_message(message, "<?>\nwith id <?> expected to be equal\\\\? to\n<?>\nwith id <?>.\n", expected, expected.__id__, actual, actual.__id__)
  assert_block(full_message) { actual.equal?(expected) }
end

#assert_send(send_array, message = "") ⇒ Object 



558
559
560
561
562
563
564
565
566
567
568
 
# File 'lib/test/unit/assertions.rb', line 558

def assert_send(send_array, message="")
  _wrap_assertion do
    assert_instance_of(Array, send_array, "assert_send requires an array of send information")
    assert(send_array.size >= 2, "assert_send requires at least a receiver and a message name")
    full_message = build_message(message, "<?> expected to respond to\n<?(?)> with a true value.\n", send_array[0], AssertionMessage.literal(send_array[1].to_s), send_array[2..-1])
    assert_block(full_message) { send_array[0].__send__(send_array[1], *send_array[2..-1]) }
  end
end

#assert_throw(expected_object, message = "", &proc) ⇒ Object 



454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
 
# File 'lib/test/unit/assertions.rb', line 454

def assert_throw(expected_object, message="", &proc)
  _wrap_assertion do
    begin
      catch([]) {}
    rescue TypeError
      assert_instance_of(Symbol, expected_object,
                         "assert_throws expects the symbol that should be thrown for its first argument")
    end
    assert_block("Should have passed a block to assert_throw.") do
      block_given?
    end
    caught = true
    begin
      catch(expected_object) do
        proc.call
        caught = false
      end
      full_message = build_message(message,
                                   "<?> should have been thrown.",
                                   expected_object)
      assert_block(full_message) {caught}
    rescue NameError, ArgumentError, ThreadError => error
      raise unless UncaughtThrow[error.class] =~ error.message
      tag = $1
      tag = tag[1..-1].intern if tag[0, 1] == ":"
      full_message = build_message(message,
                                   "<?> expected to be thrown but\n" +
                                   "<?> was thrown.",
                                   expected_object, tag)
      flunk(full_message)
    end
  end
end

#assert_throws(*args, &block) ⇒ Object

Alias of assert_throw.

Will be deprecated in 1.9, and removed in 2.0.



492
493
494
 
# File 'lib/test/unit/assertions.rb', line 492

def assert_throws(*args, &block)
  assert_throw(*args, &block)
end

#assert_true(actual, message = nil) ⇒ Object

Passes if actual is true.

Example:

assert_true(true)  # -> pass
assert_true(:true) # -> fail



592
593
594
595
596
597
598
599
600
 
# File 'lib/test/unit/assertions.rb', line 592

def assert_true(actual, message=nil)
  _wrap_assertion do
    assert_block(build_message(message,
                               "<true> expected but was\n<?>",
                               actual)) do
      actual == true
    end
  end
end

#build_message(head, template = nil, *arguments) ⇒ Object 



797
798
799
800
 
# File 'lib/test/unit/assertions.rb', line 797

def build_message(head, template=nil, *arguments)
  template &&= template.chomp
  return AssertionMessage.new(head, template, arguments)
end

#flunk(message = "Flunked") ⇒ Object 



379
380
381
 
# File 'lib/test/unit/assertions.rb', line 379

def flunk(message="Flunked")
  assert_block(build_message(message)){false}
end