third-party/mruby/test/assert.rb

   1 $ok_test = 0
   2 $ko_test = 0
   3 $kill_test = 0
   4 $skip_test = 0
   5 $asserts  = []
   6 $test_start = Time.now if Object.const_defined?(:Time)
   7
   8 unless RUBY_ENGINE == "mruby"
   9   # For bintest on Ruby
  10   def t_print(*args)
  11     print(*args)
  12     $stdout.flush
  13     nil
  14   end
  15 end
  16
  17 ##
  18 # Create the assertion in a readable way
  19 def assertion_string(err, str, iso=nil, e=nil, bt=nil)
  20   msg = "#{err}#{str}"
  21   msg += " [#{iso}]" if iso && !iso.empty?
  22   msg += " => #{e}" if e && !e.to_s.empty?
  23   msg += " (#{GEMNAME == 'mruby-test' ? 'core' : "mrbgems: #{GEMNAME}"})"
  24   if $mrbtest_assert && $mrbtest_assert.size > 0
  25     $mrbtest_assert.each do |idx, assert_msg, diff|
  26       msg += "\n - Assertion[#{idx}]"
  27       msg += " #{assert_msg}." if assert_msg && !assert_msg.empty?
  28       msg += "\n#{diff}" if diff && !diff.empty?
  29     end
  30   end
  31   msg += "\nbacktrace:\n\t#{bt.join("\n\t")}" if bt
  32   msg
  33 end
  34
  35 ##
  36 # Verify a code block.
  37 #
  38 # str : A remark which will be printed in case
  39 #       this assertion fails
  40 # iso : The ISO reference code of the feature
  41 #       which will be tested by this
  42 #       assertion
  43 def assert(str = 'Assertion failed', iso = '')
  44   t_print(str, (iso != '' ? " [#{iso}]" : ''), ' : ') if $mrbtest_verbose
  45   begin
  46     $mrbtest_assert = []
  47     $mrbtest_assert_idx = 0
  48     yield
  49     if($mrbtest_assert.size > 0)
  50       $asserts.push(assertion_string('Fail: ', str, iso))
  51       $ko_test += 1
  52       t_print('F')
  53     else
  54       $ok_test += 1
  55       t_print('.')
  56     end
  57   rescue MRubyTestSkip => e
  58     $asserts.push(assertion_string('Skip: ', str, iso, e))
  59     $skip_test += 1
  60     t_print('?')
  61   rescue Exception => e
  62     bt = e.backtrace if $mrbtest_verbose
  63     $asserts.push(assertion_string("#{e.class}: ", str, iso, e, bt))
  64     $kill_test += 1
  65     t_print('X')
  66   ensure
  67     $mrbtest_assert = nil
  68   end
  69   t_print("\n") if $mrbtest_verbose
  70 end
  71
  72 def assertion_diff(exp, act)
  73   "    Expected: #{exp.inspect}\n" \
  74   "      Actual: #{act.inspect}"
  75 end
  76
  77 def assert_true(obj, msg = nil, diff = nil)
  78   if $mrbtest_assert
  79     $mrbtest_assert_idx += 1
  80     unless obj == true
  81       diff ||= "    Expected #{obj.inspect} to be true."
  82       $mrbtest_assert.push([$mrbtest_assert_idx, msg, diff])
  83     end
  84   end
  85   obj
  86 end
  87
  88 def assert_false(obj, msg = nil, diff = nil)
  89   unless obj == false
  90     diff ||= "    Expected #{obj.inspect} to be false."
  91   end
  92   assert_true(!obj, msg, diff)
  93 end
  94
  95 def assert_equal(exp, act_or_msg = nil, msg = nil, &block)
  96   ret, exp, act, msg = _eval_assertion(:==, exp, act_or_msg, msg, block)
  97   unless ret
  98     diff = assertion_diff(exp, act)
  99   end
 100   assert_true(ret, msg, diff)
 101 end
 102
 103 def assert_not_equal(exp, act_or_msg = nil, msg = nil, &block)
 104   ret, exp, act, msg = _eval_assertion(:==, exp, act_or_msg, msg, block)
 105   if ret
 106     diff = "    Expected #{act.inspect} to not be equal to #{exp.inspect}."
 107   end
 108   assert_true(!ret, msg, diff)
 109 end
 110
 111 def assert_same(*args); _assert_same(true, *args) end
 112 def assert_not_same(*args); _assert_same(false, *args) end
 113 def _assert_same(affirmed, exp, act, msg = nil)
 114   unless ret = exp.equal?(act) == affirmed
 115     exp_str, act_str = [exp, act].map do |o|
 116       "#{o.inspect} (class=#{o.class}, oid=#{o.__id__})"
 117     end
 118     diff = "    Expected #{act_str} to #{'not ' unless affirmed}be the same as #{exp_str}."
 119   end
 120   assert_true(ret, msg, diff)
 121 end
 122
 123 def assert_nil(obj, msg = nil)
 124   unless ret = obj.nil?
 125     diff = "    Expected #{obj.inspect} to be nil."
 126   end
 127   assert_true(ret, msg, diff)
 128 end
 129
 130 def assert_include(*args); _assert_include(true, *args) end
 131 def assert_not_include(*args); _assert_include(false, *args) end
 132 def _assert_include(affirmed, collection, obj, msg = nil)
 133   unless ret = collection.include?(obj) == affirmed
 134     diff = "    Expected #{collection.inspect} to #{'not ' unless affirmed}include #{obj.inspect}."
 135   end
 136   assert_true(ret, msg, diff)
 137 end
 138
 139 ##
 140 # Fails unless +obj+ is a kind of +cls+.
 141 def assert_kind_of(cls, obj, msg = nil)
 142   unless ret = obj.kind_of?(cls)
 143     diff = "    Expected #{obj.inspect} to be a kind of #{cls}, not #{obj.class}."
 144   end
 145   assert_true(ret, msg, diff)
 146 end
 147
 148 ##
 149 # Fails unless +exp+ is equal to +act+ in terms of a Float
 150 def assert_float(exp, act, msg = nil)
 151   e, a = exp.to_f, act.to_f
 152   if (e.infinite? || a.infinite?) && e != a ||
 153      e.nan? && !a.nan? || !e.nan? && a.nan?
 154     flunk(msg, "    Expected #{act} to be #{exp}.")
 155   elsif (n = (e - a).abs) > Mrbtest::FLOAT_TOLERANCE
 156     flunk(msg, "    Expected |#{exp} - #{act}| (#{n}) to be <= #{Mrbtest::FLOAT_TOLERANCE}.")
 157   else
 158     pass
 159   end
 160 end
 161
 162 def assert_raise(*exc)
 163   msg = (exc.last.is_a? String) ? exc.pop : nil
 164   exc = exc.empty? ? StandardError : exc.size == 1 ? exc[0] : exc
 165   begin
 166     yield
 167   rescue *exc
 168     pass
 169   rescue Exception => e
 170     diff = "    #{exc} exception expected, not\n" \
 171            "    Class: <#{e.class}>\n" \
 172            "    Message: <#{e}>"
 173     flunk(msg, diff)
 174   else
 175     diff = "    #{exc} expected but nothing was raised."
 176     flunk(msg, diff)
 177   end
 178 end
 179
 180 def assert_nothing_raised(msg = nil)
 181   begin
 182     yield
 183   rescue Exception => e
 184     diff = "    Exception raised:\n" \
 185            "    Class: <#{e.class}>\n" \
 186            "    Message: <#{e}>"
 187     flunk(msg, diff)
 188   else
 189     pass
 190   end
 191 end
 192
 193 def pass
 194   assert_true(true)
 195 end
 196
 197 def flunk(msg = nil, diff = "Epic Fail!")
 198   assert_true(false, msg, diff)
 199 end
 200
 201 ##
 202 # Report the test result and print all assertions
 203 # which were reported broken.
 204 def report
 205   t_print("\n")
 206
 207   $asserts.each do |msg|
 208     t_print("#{msg}\n")
 209   end
 210
 211   $total_test = $ok_test + $ko_test + $kill_test + $skip_test
 212   t_print("Total: #{$total_test}\n")
 213
 214   t_print("   OK: #{$ok_test}\n")
 215   t_print("   KO: #{$ko_test}\n")
 216   t_print("Crash: #{$kill_test}\n")
 217   t_print(" Skip: #{$skip_test}\n")
 218
 219   if Object.const_defined?(:Time)
 220     t_time = Time.now - $test_start
 221     t_print(" Time: #{t_time.round(2)} seconds\n")
 222   end
 223
 224   $ko_test == 0 && $kill_test == 0
 225 end
 226
 227 def _eval_assertion(meth, exp, act_or_msg, msg, block)
 228   if block
 229     exp, act, msg = exp, block.call, act_or_msg
 230   else
 231     exp, act, msg = exp, act_or_msg, msg
 232   end
 233   return exp.__send__(meth, act), exp, act, msg
 234 end
 235
 236 ##
 237 # Skip the test
 238 class MRubyTestSkip < NotImplementedError; end
 239
 240 def skip(cause = "")
 241   raise MRubyTestSkip.new(cause)
 242 end