Test::Unit::Assertions

 
 # File test/unit/assertions.rb, line 29
def assert(test, msg = UNASSIGNED)
 case msg
 when UNASSIGNED
 msg = nil
 when String, Proc
 else
 bt = caller.reject { |s| s.rindex(MINI_DIR, 0) }
 raise ArgumentError, "assertion message must be String or Proc, but #{msg.class} was given.", bt
 end
 super
end
 

 
 # File test/unit/assertions.rb, line 51
def assert_block(*msgs)
 assert yield, *msgs
end
 

 
 # File test/unit/assertions.rb, line 144
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
 

 
 # File test/unit/assertions.rb, line 218
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
 

 
 # File test/unit/assertions.rb, line 207
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
 

 
 # File test/unit/assertions.rb, line 196
def assert_not_nil(exp, msg=nil)
 msg = message(msg) { "<#{mu_pp(exp)}> expected to not be nil" }
 assert(!exp.nil?, msg)
end
 

 
 # File test/unit/assertions.rb, line 234
 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
 

 
 # File test/unit/assertions.rb, line 303
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
 

 
 # File test/unit/assertions.rb, line 88
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
 

 
 # File test/unit/assertions.rb, line 127
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
 

 
 # File test/unit/assertions.rb, line 68
def assert_raise(*args, &b)
 assert_raises(*args, &b)
end
 

 
 # File test/unit/assertions.rb, line 253
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
 

 
 # File test/unit/assertions.rb, line 277
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