third-party/mruby/test/t/hash.rb

   1 ##
   2 # Hash ISO Test
   3
   4 assert('Hash', '15.2.13') do
   5   assert_equal Class, Hash.class
   6 end
   7
   8 assert('Hash#==', '15.2.13.4.1') do
   9   assert_true({ 'abc' => 'abc' } == { 'abc' => 'abc' })
  10   assert_false({ 'abc' => 'abc' } ==  { 'cba' => 'cba' })
  11   assert_false({ :a => 1 } == true)
  12   skip unless Object.const_defined?(:Float)
  13   assert_true({ :equal => 1 } == { :equal => 1.0 })
  14 end
  15
  16 assert('Hash#[]', '15.2.13.4.2') do
  17   a = { 'abc' => 'abc' }
  18
  19   assert_equal 'abc', a['abc']
  20
  21   # Hash#[] should call #default (#3272)
  22   hash = {}
  23   def hash.default(k); self[k] = 1; end
  24   hash[:foo] += 1
  25
  26   assert_equal 2, hash[:foo]
  27 end
  28
  29 assert('Hash#[]=', '15.2.13.4.3') do
  30   a = Hash.new
  31   a['abc'] = 'abc'
  32
  33   assert_equal 'abc', a['abc']
  34 end
  35
  36 assert('Hash#clear', '15.2.13.4.4') do
  37   a = { 'abc' => 'abc' }
  38   a.clear
  39
  40   assert_equal({ }, a)
  41 end
  42
  43 assert('Hash#dup') do
  44   a = { 'a' => 1 }
  45   b = a.dup
  46   a['a'] = 2
  47   assert_equal({'a' => 1}, b)
  48
  49   c = Hash.new { |h, k| h[k] = k.upcase }
  50   d = c.dup
  51   assert_equal("FOO", d["foo"])
  52 end
  53
  54 assert('Hash#default', '15.2.13.4.5') do
  55   a = Hash.new
  56   b = Hash.new('abc')
  57   c = Hash.new {|s,k| s[k] = k}
  58
  59   assert_nil a.default
  60   assert_equal 'abc', b.default
  61   assert_nil c.default
  62   assert_equal 'abc', c.default('abc')
  63 end
  64
  65 assert('Hash#default=', '15.2.13.4.6') do
  66   a = { 'abc' => 'abc' }
  67   a.default = 'cba'
  68
  69   assert_equal 'abc', a['abc']
  70   assert_equal 'cba', a['notexist']
  71 end
  72
  73 assert('Hash#default_proc', '15.2.13.4.7') do
  74   a = Hash.new
  75   b = Hash.new {|s,k| s[k] = k + k}
  76   c = b[2]
  77   d = b['cat']
  78
  79   assert_nil a.default_proc
  80   assert_equal Proc, b.default_proc.class
  81   assert_equal 4, c
  82   assert_equal 'catcat', d
  83 end
  84
  85 assert('Hash#delete', '15.2.13.4.8') do
  86   a = { 'abc' => 'ABC' }
  87   b = { 'abc' => 'ABC' }
  88   b_tmp_1 = false
  89   b_tmp_2 = false
  90
  91   assert_equal 'ABC', a.delete('abc')
  92   b.delete('abc') do |k|
  93     b_tmp_1 = true
  94   end
  95   b.delete('abc') do |k|
  96     b_tmp_2 = true
  97   end
  98
  99   assert_nil a.delete('cba')
 100   assert_false a.has_key?('abc')
 101   assert_false b_tmp_1
 102   assert_true b_tmp_2
 103 end
 104
 105 assert('Hash#each', '15.2.13.4.9') do
 106   a = { 'abc_key' => 'abc_value' }
 107   key = nil
 108   value = nil
 109
 110   a.each  do |k,v|
 111     key = k
 112     value = v
 113   end
 114
 115   assert_equal 'abc_key', key
 116   assert_equal 'abc_value', value
 117 end
 118
 119 assert('Hash#each_key', '15.2.13.4.10') do
 120   a = { 'abc_key' => 'abc_value' }
 121   key = nil
 122
 123   a.each_key  do |k|
 124     key = k
 125   end
 126
 127   assert_equal 'abc_key', key
 128 end
 129
 130 assert('Hash#each_value', '15.2.13.4.11') do
 131   a = { 'abc_key' => 'abc_value' }
 132   value = nil
 133
 134   a.each_value  do |v|
 135     value = v
 136   end
 137
 138   assert_equal 'abc_value', value
 139 end
 140
 141 assert('Hash#empty?', '15.2.13.4.12') do
 142   a = { 'abc_key' => 'abc_value' }
 143   b = Hash.new
 144
 145   assert_false a.empty?
 146   assert_true b.empty?
 147 end
 148
 149 assert('Hash#has_key?', '15.2.13.4.13') do
 150   a = { 'abc_key' => 'abc_value' }
 151   b = Hash.new
 152
 153   assert_true a.has_key?('abc_key')
 154   assert_false b.has_key?('cba')
 155 end
 156
 157 assert('Hash#has_value?', '15.2.13.4.14') do
 158   a = { 'abc_key' => 'abc_value' }
 159   b = Hash.new
 160
 161   assert_true a.has_value?('abc_value')
 162   assert_false b.has_value?('cba')
 163 end
 164
 165 assert('Hash#include?', '15.2.13.4.15') do
 166   a = { 'abc_key' => 'abc_value' }
 167   b = Hash.new
 168
 169   assert_true a.include?('abc_key')
 170   assert_false b.include?('cba')
 171 end
 172
 173 assert('Hash#initialize', '15.2.13.4.16') do
 174   # Testing initialize by new.
 175   h = Hash.new
 176   h2 = Hash.new(:not_found)
 177
 178   assert_true h.is_a? Hash
 179   assert_equal({ }, h)
 180   assert_nil h["hello"]
 181   assert_equal :not_found, h2["hello"]
 182 end
 183
 184 assert('Hash#initialize_copy', '15.2.13.4.17') do
 185   a = { 'abc_key' => 'abc_value' }
 186   b = Hash.new.initialize_copy(a)
 187
 188   assert_equal({ 'abc_key' => 'abc_value' }, b)
 189 end
 190
 191 assert('Hash#key?', '15.2.13.4.18') do
 192   a = { 'abc_key' => 'abc_value' }
 193   b = Hash.new
 194
 195   assert_true a.key?('abc_key')
 196   assert_false b.key?('cba')
 197 end
 198
 199 assert('Hash#keys', '15.2.13.4.19') do
 200   a = { 'abc_key' => 'abc_value' }
 201
 202   assert_equal ['abc_key'], a.keys
 203 end
 204
 205 assert('Hash#length', '15.2.13.4.20') do
 206   a = { 'abc_key' => 'abc_value' }
 207   b = Hash.new
 208
 209   assert_equal 1, a.length
 210   assert_equal 0, b.length
 211 end
 212
 213 assert('Hash#member?', '15.2.13.4.21') do
 214   a = { 'abc_key' => 'abc_value' }
 215   b = Hash.new
 216
 217   assert_true a.member?('abc_key')
 218   assert_false b.member?('cba')
 219 end
 220
 221 assert('Hash#merge', '15.2.13.4.22') do
 222   a = { 'abc_key' => 'abc_value', 'cba_key' => 'cba_value' }
 223   b = { 'cba_key' => 'XXX',  'xyz_key' => 'xyz_value' }
 224
 225   result_1 = a.merge b
 226   result_2 = a.merge(b) do |key, original, new|
 227     original
 228   end
 229
 230   assert_equal({'abc_key' => 'abc_value', 'cba_key' => 'XXX',
 231                 'xyz_key' => 'xyz_value' }, result_1)
 232   assert_equal({'abc_key' => 'abc_value', 'cba_key' => 'cba_value',
 233                 'xyz_key' => 'xyz_value' }, result_2)
 234
 235   assert_raise(TypeError) do
 236     { 'abc_key' => 'abc_value' }.merge "a"
 237   end
 238 end
 239
 240 assert('Hash#replace', '15.2.13.4.23') do
 241   a = { 'abc_key' => 'abc_value' }
 242   b = Hash.new.replace(a)
 243
 244   assert_equal({ 'abc_key' => 'abc_value' }, b)
 245
 246   a = Hash.new(42)
 247   b = {}
 248   b.replace(a)
 249   assert_equal(42, b[1])
 250
 251   a = Hash.new{|h,x| x}
 252   b.replace(a)
 253   assert_equal(127, b[127])
 254
 255    assert_raise(TypeError) do
 256     { 'abc_key' => 'abc_value' }.replace "a"
 257   end
 258 end
 259
 260 assert('Hash#shift', '15.2.13.4.24') do
 261   a = { 'abc_key' => 'abc_value', 'cba_key' => 'cba_value' }
 262   b = a.shift
 263
 264   assert_equal Array, b.class
 265   assert_equal 2, b.size
 266   assert_equal 1, a.size
 267
 268   b = a.shift
 269
 270   assert_equal Array, b.class
 271   assert_equal 2, b.size
 272   assert_equal 0, a.size
 273 end
 274
 275 assert('Hash#size', '15.2.13.4.25') do
 276   a = { 'abc_key' => 'abc_value' }
 277   b = Hash.new
 278
 279   assert_equal 1, a.size
 280   assert_equal 0, b.size
 281 end
 282
 283 assert('Hash#store', '15.2.13.4.26') do
 284   a = Hash.new
 285   a.store('abc', 'abc')
 286
 287   assert_equal 'abc', a['abc']
 288 end
 289
 290 assert('Hash#value?', '15.2.13.4.27') do
 291   a = { 'abc_key' => 'abc_value' }
 292   b = Hash.new
 293
 294   assert_true a.value?('abc_value')
 295   assert_false b.value?('cba')
 296 end
 297
 298 assert('Hash#values', '15.2.13.4.28') do
 299   a = { 'abc_key' => 'abc_value' }
 300
 301   assert_equal ['abc_value'], a.values
 302 end
 303
 304 # Not ISO specified
 305
 306 assert('Hash#eql?') do
 307   a = { 'a' => 1, 'b' => 2, 'c' => 3 }
 308   b = { 'a' => 1, 'b' => 2, 'c' => 3 }
 309   c = { 'a' => 1.0, 'b' => 2, 'c' => 3 }
 310   assert_true(a.eql?(b))
 311   assert_false(a.eql?(c))
 312   assert_false(a.eql?(true))
 313 end
 314
 315 assert('Hash#reject') do
 316   h = {:one => 1, :two => 2, :three => 3, :four => 4}
 317   ret = h.reject do |k,v|
 318     v % 2 == 0
 319   end
 320   assert_equal({:one => 1, :three => 3}, ret)
 321   assert_equal({:one => 1, :two => 2, :three => 3, :four => 4}, h)
 322 end
 323
 324 assert('Hash#reject!') do
 325   h = {:one => 1, :two => 2, :three => 3, :four => 4}
 326   ret = h.reject! do |k,v|
 327     v % 2 == 0
 328   end
 329   assert_equal({:one => 1, :three => 3}, ret)
 330   assert_equal({:one => 1, :three => 3}, h)
 331 end
 332
 333 assert('Hash#select') do
 334   h = {:one => 1, :two => 2, :three => 3, :four => 4}
 335   ret = h.select do |k,v|
 336     v % 2 == 0
 337   end
 338   assert_equal({:two => 2, :four => 4}, ret)
 339   assert_equal({:one => 1, :two => 2, :three => 3, :four => 4}, h)
 340 end
 341
 342 assert('Hash#select!') do
 343   h = {:one => 1, :two => 2, :three => 3, :four => 4}
 344   ret = h.select! do |k,v|
 345     v % 2 == 0
 346   end
 347   assert_equal({:two => 2, :four => 4}, ret)
 348   assert_equal({:two => 2, :four => 4}, h)
 349 end
 350
 351 # Not ISO specified
 352
 353 assert('Hash#inspect') do
 354   h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
 355   h["recur"] = h
 356   ret = h.to_s
 357
 358   assert_include ret, '"c"=>300'
 359   assert_include ret, '"a"=>100'
 360   assert_include ret, '"d"=>400'
 361   assert_include ret, '"recur"=>{...}'
 362 end
 363
 364 assert('Hash#rehash') do
 365   h = {[:a] => "b"}
 366   # hash key modified
 367   h.keys[0][0] = :b
 368   # h[[:b]] => nil
 369   h.rehash
 370   assert_equal("b", h[[:b]])
 371 end
 372
 373 assert('Hash#freeze') do
 374   h = {}.freeze
 375   assert_raise(FrozenError) do
 376     h[:a] = 'b'
 377   end
 378 end