Module: Test::Unit::Assertions

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

Constant Summary collapse

MINI_DIR =

:nodoc:

File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), "minitest")

Instance Method Summary collapse

Instance Method Details

#assert(test, *msgs) ⇒ Object

:call-seq:

assert(test, [failure_message])

Tests if test is true.

msg may be a String or a Proc. If msg is a String, it will be used as the failure message. Otherwise, the result of calling msg will be used as the message if the assertion fails.

If no msg is given, a default message will be used.

assert(false, "This was expected to be true")



27
28
29
30
31
32
33
34
35
 
# File 'lib/test/unit/assertions.rb', line 27

def assert(test, *msgs)
  case msg = msgs.first
  when String, Proc
  else
    bt = caller.reject { |s| s.start_with?(MINI_DIR) }
    raise ArgumentError, "assertion message must be String or Proc, but #{msg.class} was given.", bt
  end unless msgs.empty?
  super
end

#assert_block(*msgs) ⇒ Object

:call-seq:

assert_block( failure_message = nil )

Tests the result of the given block. If the block does not return true, the assertion will fail. The optional failure_message argument is the same as in Assertions#assert.

assert_block do
  [1, 2, 3].any? { |num| num < 1 }
end



47
48
49
 
# File 'lib/test/unit/assertions.rb', line 47

def assert_block(*msgs)
  assert yield, *msgs
end

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

:call-seq:

assert_equal( expected, actual, failure_message = nil )

Tests if expected is equal to actual.

An optional failure message may be provided as the final argument.



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'lib/test/unit/assertions.rb', line 176

def assert_equal(exp, act, msg = nil)
  msg = message(msg) {
    exp_str = mu_pp(exp)
    act_str = mu_pp(act)
    exp_comment = ''
    act_comment = ''
    if exp_str == act_str
      if (exp.is_a?(String) && act.is_a?(String)) ||
         (exp.is_a?(Regexp) && act.is_a?(Regexp))
        exp_comment = " (#{exp.encoding})"
        act_comment = " (#{act.encoding})"
      elsif exp.is_a?(Float) && act.is_a?(Float)
        exp_str = "%\#.#{Float::DIG+2}g" % exp
        act_str = "%\#.#{Float::DIG+2}g" % act
      elsif exp.is_a?(Time) && act.is_a?(Time)
        if exp.subsec * 1000_000_000 == exp.nsec
          exp_comment = " (#{exp.nsec}[ns])"
        else
          exp_comment = " (subsec=#{exp.subsec})"
        end
        if act.subsec * 1000_000_000 == act.nsec
          act_comment = " (#{act.nsec}[ns])"
        else
          act_comment = " (subsec=#{act.subsec})"
        end
      elsif exp.class != act.class
        # a subclass of Range, for example.
        exp_comment = " (#{exp.class})"
        act_comment = " (#{act.class})"
      end
    elsif !Encoding.compatible?(exp_str, act_str)
      if exp.is_a?(String) && act.is_a?(String)
        exp_str = exp.dump
        act_str = act.dump
        exp_comment = " (#{exp.encoding})"
        act_comment = " (#{act.encoding})"
      else
        exp_str = exp_str.dump
        act_str = act_str.dump
      end
    end
    "<#{exp_str}>#{exp_comment} expected but was\n<#{act_str}>#{act_comment}"
  }
  assert(exp == act, msg)
end

#assert_no_match(regexp, string, msg = nil) ⇒ Object

:call-seq:

assert_no_match( regexp, string, failure_message = nil )

Tests if the given Regexp does not match a given String.

An optional failure message may be provided as the final argument.



250
251
252
253
254
255
 
# File 'lib/test/unit/assertions.rb', line 250

def assert_no_match(regexp, string, msg=nil)
  assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
  self._assertions -= 1
  msg = message(msg) { "<#{mu_pp(regexp)}> expected to not match\n<#{mu_pp(string)}>" }
  assert(regexp !~ string, msg)
end

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

:call-seq:

assert_not_equal( expected, actual, failure_message = nil )

Tests if expected is not equal to actual.

An optional failure message may be provided as the final argument.



239
240
241
242
 
# File 'lib/test/unit/assertions.rb', line 239

def assert_not_equal(exp, act, msg=nil)
  msg = message(msg) { "<#{mu_pp(exp)}> expected to be != to\n<#{mu_pp(act)}>" }
  assert(exp != act, msg)
end

#assert_not_nil(exp, msg = nil) ⇒ Object

:call-seq:

assert_not_nil( expression, failure_message = nil )

Tests if expression is not nil.

An optional failure message may be provided as the final argument.



228
229
230
231
 
# File 'lib/test/unit/assertions.rb', line 228

def assert_not_nil(exp, msg=nil)
  msg = message(msg) { "<#{mu_pp(exp)}> expected to not be nil" }
  assert(!exp.nil?, msg)
end

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

:call-seq:

assert_not_same( expected, actual, failure_message = nil )

Tests if expected is not the same object as actual. This test uses Object#equal? to test equality.

An optional failure message may be provided as the final argument.

assert_not_same("x", "x") #Succeeds



266
267
268
269
270
271
272
273
274
 
# File 'lib/test/unit/assertions.rb', line 266

def assert_not_same(expected, actual, message="")
  msg = message(msg) { build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__) }
<?>
with id <?> expected to not be equal\\? to
<?>
with id <?>.
EOT
  assert(!actual.equal?(expected), msg)
end

#assert_not_send(send_ary, m = nil) ⇒ Object

:call-seq:

assert_not_send( +send_array+, failure_message = nil )

Passes if the method send doesn’t return a true value.

send_array is composed of:

  • A receiver

  • A method

  • Arguments to the method

Example:

assert_not_send([[1, 2], :member?, 1]) # -> fail
assert_not_send([[1, 2], :member?, 4]) # -> pass



335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/test/unit/assertions.rb', line 335

def assert_not_send send_ary, m = nil
  recv, msg, *args = send_ary
  m = message(m) {
    if args.empty?
      argsstr = ""
    else
      (argsstr = mu_pp(args)).sub!(/\A\[(.*)\]\z/m, '(\1)')
    end
    "Expected #{mu_pp(recv)}.#{msg}#{argsstr} to return false"
  }
  assert !recv.__send__(msg, *args), m
end

#assert_nothing_raised(*args) ⇒ Object

:call-seq:

assert_nothing_raised( *args, &block )

If any exceptions are given as arguments, the assertion will fail if one of those exceptions are raised. Otherwise, the test fails if any exceptions are raised.

The final argument may be a failure message.

assert_nothing_raised RuntimeError do
  raise Exception #Assertion passes, Exception is not a RuntimeError
end

assert_nothing_raised do
  raise Exception #Assertion fails
end



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/test/unit/assertions.rb', line 120

def assert_nothing_raised(*args)
  self._assertions += 1
  if Module === args.last
    msg = nil
  else
    msg = args.pop
  end
  begin
    line = __LINE__; yield
  rescue MiniTest::Skip
    raise
  rescue Exception => e
    bt = e.backtrace
    as = e.instance_of?(MiniTest::Assertion)
    if as
      ans = /\A#{Regexp.quote(__FILE__)}:#{line}:in /o
      bt.reject! {|ln| ans =~ ln}
    end
    if ((args.empty? && !as) ||
        args.any? {|a| a.instance_of?(Module) ? e.is_a?(a) : e.class == a })
      msg = message(msg) { "Exception raised:\n<#{mu_pp(e)}>" }
      raise MiniTest::Assertion, msg.call, bt
    else
      raise
    end
  end
  nil
end

#assert_nothing_thrown(msg = nil) ⇒ Object

:call-seq:

assert_nothing_thrown( failure_message = nil, &block )

Fails if the given block uses a call to Kernel#throw.

An optional failure message may be provided as the final argument.

assert_nothing_thrown "Something was thrown!" do
  throw :problem?
end



159
160
161
162
163
164
165
166
167
168
 
# File 'lib/test/unit/assertions.rb', line 159

def assert_nothing_thrown(msg=nil)
  begin
    yield
  rescue ArgumentError => error
    raise error if /\Auncaught throw (.+)\z/m !~ error.message
    msg = message(msg) { "<#{$1}> was thrown when nothing was expected" }
    flunk(msg)
  end
  assert(true, "Expected nothing to be thrown")
end

#assert_raise(*args, &b) ⇒ Object

:call-seq:

assert_raise( *args, &block )

Tests if the given block raises an exception. Acceptable exception types maye be given as optional arguments. If the last argument is a String, it will be used as the error message.

assert_raise do #Fails, no Exceptions are raised
end

assert_raise NameError do
  puts x  #Raises NameError, so assertion succeeds
end



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

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

#assert_raise_with_message(exception, expected, msg = nil) ⇒ Object

:call-seq:

assert_raise_with_message(exception, expected, msg = nil, &block)

Tests if the given block raises an exception with the expected message.

assert_raise_with_message(RuntimeError, "foo") do
  nil #Fails, no Exceptions are raised
end

assert_raise_with_message(RuntimeError, "foo") do
  raise ArgumentError, "foo" #Fails, different Exception is raised
end

assert_raise_with_message(RuntimeError, "foo") do
  raise "bar" #Fails, RuntimeError is raised but the message differs
end

assert_raise_with_message(RuntimeError, "foo") do
  raise "foo" #Raises RuntimeError with the message, so assertion succeeds
end



89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/test/unit/assertions.rb', line 89

def assert_raise_with_message(exception, expected, msg = nil)
  case expected
  when String
    assert = :assert_equal
  when Regexp
    assert = :assert_match
  else
    raise TypeError, "Expected #{expected.inspect} to be a kind of String or Regexp, not #{expected.class}"
  end

  ex = assert_raise(exception, msg) {yield}
  msg = message(msg, "") {"Expected Exception(#{exception}) was raised, but the message doesn't match"}
  __send__(assert, expected, ex.message, msg)
end

#assert_respond_to(obj, meth, priv, msg = nil) ⇒ Object

:call-seq:

assert_respond_to( object, method, failure_message = nil )

Tests if the given Object responds to method.

An optional failure message may be provided as the final argument.

assert_respond_to("hello", :reverse)  #Succeeds
assert_respond_to("hello", :does_not_exist)  #Fails



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

def assert_respond_to obj, (meth, priv), msg = nil
  if priv
    msg = message(msg) {
      "Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}#{" privately" if priv}"
    }
    return assert obj.respond_to?(meth, priv), msg
  end
  #get rid of overcounting
  super if !caller[0].rindex(MINI_DIR, 0) || !obj.respond_to?(meth)
end

#assert_send(send_ary, m = nil) ⇒ Object

:call-seq:

assert_send( +send_array+, failure_message = nil )

Passes if the method send returns a true value.

send_array is composed of:

  • A receiver

  • A method

  • Arguments to the method

Example:

assert_send([[1, 2], :member?, 1]) # -> pass
assert_send([[1, 2], :member?, 4]) # -> fail



309
310
311
312
313
314
315
316
317
318
319
320
 
# File 'lib/test/unit/assertions.rb', line 309

def assert_send send_ary, m = nil
  recv, msg, *args = send_ary
  m = message(m) {
    if args.empty?
      argsstr = ""
    else
      (argsstr = mu_pp(args)).sub!(/\A\[(.*)\]\z/m, '(\1)')
    end
    "Expected #{mu_pp(recv)}.#{msg}#{argsstr} to return true"
  }
  assert recv.__send__(msg, *args), m
end

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

:nodoc:



356
357
358
359
 
# File 'lib/test/unit/assertions.rb', line 356

def build_message(head, template=nil, *arguments) #:nodoc:
  template &&= template.chomp
  template.gsub(/\G((?:[^\\]|\\.)*?)(\\)?\?/) { $1 + ($2 ? "?" : mu_pp(arguments.shift)) }
end

#message(msg = nil, *args, &default) ⇒ Object

:nodoc:



361
362
363
364
365
366
367
368
369
 
# File 'lib/test/unit/assertions.rb', line 361

def message(msg = nil, *args, &default) # :nodoc:
  if Proc === msg
    super(nil, *args) do
      [msg.call, (default.call if default)].compact.reject(&:empty?).join(".\n")
    end
  else
    super
  end
end

#mu_pp(obj) ⇒ Object

:nodoc:



9
10
11
 
# File 'lib/test/unit/assertions.rb', line 9

def mu_pp(obj) #:nodoc:
  obj.pretty_inspect.chomp
end