test/test_set.rb

   1 # frozen_string_literal: false
   2 require 'test/unit'
   3 require 'set'
   4
   5 class TC_Set < Test::Unit::TestCase
   6   class Set2 < Set
   7   end
   8
   9   def test_aref
  10     assert_nothing_raised {
  11       Set[]
  12       Set[nil]
  13       Set[1,2,3]
  14     }
  15
  16     assert_equal(0, Set[].size)
  17     assert_equal(1, Set[nil].size)
  18     assert_equal(1, Set[[]].size)
  19     assert_equal(1, Set[[nil]].size)
  20
  21     set = Set[2,4,6,4]
  22     assert_equal(Set.new([2,4,6]), set)
  23   end
  24
  25   def test_s_new
  26     assert_nothing_raised {
  27       Set.new()
  28       Set.new(nil)
  29       Set.new([])
  30       Set.new([1,2])
  31       Set.new('a'..'c')
  32     }
  33     assert_raise(ArgumentError) {
  34       Set.new(false)
  35     }
  36     assert_raise(ArgumentError) {
  37       Set.new(1)
  38     }
  39     assert_raise(ArgumentError) {
  40       Set.new(1,2)
  41     }
  42
  43     assert_equal(0, Set.new().size)
  44     assert_equal(0, Set.new(nil).size)
  45     assert_equal(0, Set.new([]).size)
  46     assert_equal(1, Set.new([nil]).size)
  47
  48     ary = [2,4,6,4]
  49     set = Set.new(ary)
  50     ary.clear
  51     assert_equal(false, set.empty?)
  52     assert_equal(3, set.size)
  53
  54     ary = [1,2,3]
  55
  56     s = Set.new(ary) { |o| o * 2 }
  57     assert_equal([2,4,6], s.sort)
  58   end
  59
  60   def test_clone
  61     set1 = Set.new
  62     set2 = set1.clone
  63     set1 << 'abc'
  64     assert_equal(Set.new, set2)
  65   end
  66
  67   def test_dup
  68     set1 = Set[1,2]
  69     set2 = set1.dup
  70
  71     assert_not_same(set1, set2)
  72
  73     assert_equal(set1, set2)
  74
  75     set1.add(3)
  76
  77     assert_not_equal(set1, set2)
  78   end
  79
  80   def test_size
  81     assert_equal(0, Set[].size)
  82     assert_equal(2, Set[1,2].size)
  83     assert_equal(2, Set[1,2,1].size)
  84   end
  85
  86   def test_empty?
  87     assert_equal(true, Set[].empty?)
  88     assert_equal(false, Set[1, 2].empty?)
  89   end
  90
  91   def test_clear
  92     set = Set[1,2]
  93     ret = set.clear
  94
  95     assert_same(set, ret)
  96     assert_equal(true, set.empty?)
  97   end
  98
  99   def test_replace
 100     set = Set[1,2]
 101     ret = set.replace('a'..'c')
 102
 103     assert_same(set, ret)
 104     assert_equal(Set['a','b','c'], set)
 105
 106     set = Set[1,2]
 107     assert_raise(ArgumentError) {
 108       set.replace(3)
 109     }
 110     assert_equal(Set[1,2], set)
 111   end
 112
 113   def test_to_a
 114     set = Set[1,2,3,2]
 115     ary = set.to_a
 116
 117     assert_equal([1,2,3], ary.sort)
 118   end
 119
 120   def test_flatten
 121     # test1
 122     set1 = Set[
 123       1,
 124       Set[
 125         5,
 126         Set[7,
 127           Set[0]
 128         ],
 129         Set[6,2],
 130         1
 131       ],
 132       3,
 133       Set[3,4]
 134     ]
 135
 136     set2 = set1.flatten
 137     set3 = Set.new(0..7)
 138
 139     assert_not_same(set2, set1)
 140     assert_equal(set3, set2)
 141
 142     # test2; destructive
 143     orig_set1 = set1
 144     set1.flatten!
 145
 146     assert_same(orig_set1, set1)
 147     assert_equal(set3, set1)
 148
 149     # test3; multiple occurrences of a set in an set
 150     set1 = Set[1, 2]
 151     set2 = Set[set1, Set[set1, 4], 3]
 152
 153     assert_nothing_raised {
 154       set2.flatten!
 155     }
 156
 157     assert_equal(Set.new(1..4), set2)
 158
 159     # test4; recursion
 160     set2 = Set[]
 161     set1 = Set[1, set2]
 162     set2.add(set1)
 163
 164     assert_raise(ArgumentError) {
 165       set1.flatten!
 166     }
 167
 168     # test5; miscellaneous
 169     empty = Set[]
 170     set =  Set[Set[empty, "a"],Set[empty, "b"]]
 171
 172     assert_nothing_raised {
 173       set.flatten
 174     }
 175
 176     set1 = empty.merge(Set["no_more", set])
 177
 178     assert_nil(Set.new(0..31).flatten!)
 179
 180     x = Set[Set[],Set[1,2]].flatten!
 181     y = Set[1,2]
 182
 183     assert_equal(x, y)
 184   end
 185
 186   def test_include?
 187     set = Set[1,2,3]
 188
 189     assert_equal(true, set.include?(1))
 190     assert_equal(true, set.include?(2))
 191     assert_equal(true, set.include?(3))
 192     assert_equal(false, set.include?(0))
 193     assert_equal(false, set.include?(nil))
 194
 195     set = Set["1",nil,"2",nil,"0","1",false]
 196     assert_equal(true, set.include?(nil))
 197     assert_equal(true, set.include?(false))
 198     assert_equal(true, set.include?("1"))
 199     assert_equal(false, set.include?(0))
 200     assert_equal(false, set.include?(true))
 201   end
 202
 203   def test_eqq
 204     set = Set[1,2,3]
 205
 206     assert_equal(true, set === 1)
 207     assert_equal(true, set === 2)
 208     assert_equal(true, set === 3)
 209     assert_equal(false, set === 0)
 210     assert_equal(false, set === nil)
 211
 212     set = Set["1",nil,"2",nil,"0","1",false]
 213     assert_equal(true, set === nil)
 214     assert_equal(true, set === false)
 215     assert_equal(true, set === "1")
 216     assert_equal(false, set === 0)
 217     assert_equal(false, set === true)
 218   end
 219
 220   def test_superset?
 221     set = Set[1,2,3]
 222
 223     assert_raise(ArgumentError) {
 224       set.superset?()
 225     }
 226
 227     assert_raise(ArgumentError) {
 228       set.superset?(2)
 229     }
 230
 231     assert_raise(ArgumentError) {
 232       set.superset?([2])
 233     }
 234
 235     [Set, Set2].each { |klass|
 236       assert_equal(true, set.superset?(klass[]), klass.name)
 237       assert_equal(true, set.superset?(klass[1,2]), klass.name)
 238       assert_equal(true, set.superset?(klass[1,2,3]), klass.name)
 239       assert_equal(false, set.superset?(klass[1,2,3,4]), klass.name)
 240       assert_equal(false, set.superset?(klass[1,4]), klass.name)
 241
 242       assert_equal(true, set >= klass[1,2,3], klass.name)
 243       assert_equal(true, set >= klass[1,2], klass.name)
 244
 245       assert_equal(true, Set[].superset?(klass[]), klass.name)
 246     }
 247   end
 248
 249   def test_proper_superset?
 250     set = Set[1,2,3]
 251
 252     assert_raise(ArgumentError) {
 253       set.proper_superset?()
 254     }
 255
 256     assert_raise(ArgumentError) {
 257       set.proper_superset?(2)
 258     }
 259
 260     assert_raise(ArgumentError) {
 261       set.proper_superset?([2])
 262     }
 263
 264     [Set, Set2].each { |klass|
 265       assert_equal(true, set.proper_superset?(klass[]), klass.name)
 266       assert_equal(true, set.proper_superset?(klass[1,2]), klass.name)
 267       assert_equal(false, set.proper_superset?(klass[1,2,3]), klass.name)
 268       assert_equal(false, set.proper_superset?(klass[1,2,3,4]), klass.name)
 269       assert_equal(false, set.proper_superset?(klass[1,4]), klass.name)
 270
 271       assert_equal(false, set > klass[1,2,3], klass.name)
 272       assert_equal(true, set > klass[1,2], klass.name)
 273
 274       assert_equal(false, Set[].proper_superset?(klass[]), klass.name)
 275     }
 276   end
 277
 278   def test_subset?
 279     set = Set[1,2,3]
 280
 281     assert_raise(ArgumentError) {
 282       set.subset?()
 283     }
 284
 285     assert_raise(ArgumentError) {
 286       set.subset?(2)
 287     }
 288
 289     assert_raise(ArgumentError) {
 290       set.subset?([2])
 291     }
 292
 293     [Set, Set2].each { |klass|
 294       assert_equal(true, set.subset?(klass[1,2,3,4]), klass.name)
 295       assert_equal(true, set.subset?(klass[1,2,3]), klass.name)
 296       assert_equal(false, set.subset?(klass[1,2]), klass.name)
 297       assert_equal(false, set.subset?(klass[]), klass.name)
 298
 299       assert_equal(true, set <= klass[1,2,3], klass.name)
 300       assert_equal(true, set <= klass[1,2,3,4], klass.name)
 301
 302       assert_equal(true, Set[].subset?(klass[1]), klass.name)
 303       assert_equal(true, Set[].subset?(klass[]), klass.name)
 304     }
 305   end
 306
 307   def test_proper_subset?
 308     set = Set[1,2,3]
 309
 310     assert_raise(ArgumentError) {
 311       set.proper_subset?()
 312     }
 313
 314     assert_raise(ArgumentError) {
 315       set.proper_subset?(2)
 316     }
 317
 318     assert_raise(ArgumentError) {
 319       set.proper_subset?([2])
 320     }
 321
 322     [Set, Set2].each { |klass|
 323       assert_equal(true, set.proper_subset?(klass[1,2,3,4]), klass.name)
 324       assert_equal(false, set.proper_subset?(klass[1,2,3]), klass.name)
 325       assert_equal(false, set.proper_subset?(klass[1,2]), klass.name)
 326       assert_equal(false, set.proper_subset?(klass[]), klass.name)
 327
 328       assert_equal(false, set < klass[1,2,3], klass.name)
 329       assert_equal(true, set < klass[1,2,3,4], klass.name)
 330
 331       assert_equal(false, Set[].proper_subset?(klass[]), klass.name)
 332     }
 333   end
 334
 335   def test_spacecraft_operator
 336     set = Set[1,2,3]
 337
 338     assert_nil(set <=> 2)
 339
 340     assert_nil(set <=> set.to_a)
 341
 342     [Set, Set2].each { |klass|
 343       assert_equal(-1,  set <=> klass[1,2,3,4], klass.name)
 344       assert_equal( 0,  set <=> klass[3,2,1]  , klass.name)
 345       assert_equal(nil, set <=> klass[1,2,4]  , klass.name)
 346       assert_equal(+1,  set <=> klass[2,3]    , klass.name)
 347       assert_equal(+1,  set <=> klass[]       , klass.name)
 348
 349       assert_equal(0, Set[] <=> klass[], klass.name)
 350     }
 351   end
 352
 353   def assert_intersect(expected, set, other)
 354     case expected
 355     when true
 356       assert_send([set, :intersect?, other])
 357       assert_send([set, :intersect?, other.to_a])
 358       assert_send([other, :intersect?, set])
 359       assert_not_send([set, :disjoint?, other])
 360       assert_not_send([set, :disjoint?, other.to_a])
 361       assert_not_send([other, :disjoint?, set])
 362     when false
 363       assert_not_send([set, :intersect?, other])
 364       assert_not_send([set, :intersect?, other.to_a])
 365       assert_not_send([other, :intersect?, set])
 366       assert_send([set, :disjoint?, other])
 367       assert_send([set, :disjoint?, other.to_a])
 368       assert_send([other, :disjoint?, set])
 369     when Class
 370       assert_raise(expected) {
 371         set.intersect?(other)
 372       }
 373       assert_raise(expected) {
 374         set.disjoint?(other)
 375       }
 376     else
 377       raise ArgumentError, "%s: unsupported expected value: %s" % [__method__, expected.inspect]
 378     end
 379   end
 380
 381   def test_intersect?
 382     set = Set[3,4,5]
 383
 384     assert_intersect(ArgumentError, set, 3)
 385     assert_intersect(true, set, Set[2,4,6])
 386
 387     assert_intersect(true, set, set)
 388     assert_intersect(true, set, Set[2,4])
 389     assert_intersect(true, set, Set[5,6,7])
 390     assert_intersect(true, set, Set[1,2,6,8,4])
 391
 392     assert_intersect(false, set, Set[])
 393     assert_intersect(false, set, Set[0,2])
 394     assert_intersect(false, set, Set[0,2,6])
 395     assert_intersect(false, set, Set[0,2,6,8,10])
 396
 397     # Make sure set hasn't changed
 398     assert_equal(Set[3,4,5], set)
 399   end
 400
 401   def test_each
 402     ary = [1,3,5,7,10,20]
 403     set = Set.new(ary)
 404
 405     ret = set.each { |o| }
 406     assert_same(set, ret)
 407
 408     e = set.each
 409     assert_instance_of(Enumerator, e)
 410
 411     assert_nothing_raised {
 412       set.each { |o|
 413         ary.delete(o) or raise "unexpected element: #{o}"
 414       }
 415
 416       ary.empty? or raise "forgotten elements: #{ary.join(', ')}"
 417     }
 418
 419     assert_equal(6, e.size)
 420     set << 42
 421     assert_equal(7, e.size)
 422   end
 423
 424   def test_add
 425     set = Set[1,2,3]
 426
 427     ret = set.add(2)
 428     assert_same(set, ret)
 429     assert_equal(Set[1,2,3], set)
 430
 431     ret = set.add?(2)
 432     assert_nil(ret)
 433     assert_equal(Set[1,2,3], set)
 434
 435     ret = set.add(4)
 436     assert_same(set, ret)
 437     assert_equal(Set[1,2,3,4], set)
 438
 439     ret = set.add?(5)
 440     assert_same(set, ret)
 441     assert_equal(Set[1,2,3,4,5], set)
 442   end
 443
 444   def test_delete
 445     set = Set[1,2,3]
 446
 447     ret = set.delete(4)
 448     assert_same(set, ret)
 449     assert_equal(Set[1,2,3], set)
 450
 451     ret = set.delete?(4)
 452     assert_nil(ret)
 453     assert_equal(Set[1,2,3], set)
 454
 455     ret = set.delete(2)
 456     assert_equal(set, ret)
 457     assert_equal(Set[1,3], set)
 458
 459     ret = set.delete?(1)
 460     assert_equal(set, ret)
 461     assert_equal(Set[3], set)
 462   end
 463
 464   def test_delete_if
 465     set = Set.new(1..10)
 466     ret = set.delete_if { |i| i > 10 }
 467     assert_same(set, ret)
 468     assert_equal(Set.new(1..10), set)
 469
 470     set = Set.new(1..10)
 471     ret = set.delete_if { |i| i % 3 == 0 }
 472     assert_same(set, ret)
 473     assert_equal(Set[1,2,4,5,7,8,10], set)
 474
 475     set = Set.new(1..10)
 476     enum = set.delete_if
 477     assert_equal(set.size, enum.size)
 478     assert_same(set, enum.each { |i| i % 3 == 0 })
 479     assert_equal(Set[1,2,4,5,7,8,10], set)
 480   end
 481
 482   def test_keep_if
 483     set = Set.new(1..10)
 484     ret = set.keep_if { |i| i <= 10 }
 485     assert_same(set, ret)
 486     assert_equal(Set.new(1..10), set)
 487
 488     set = Set.new(1..10)
 489     ret = set.keep_if { |i| i % 3 != 0 }
 490     assert_same(set, ret)
 491     assert_equal(Set[1,2,4,5,7,8,10], set)
 492
 493     set = Set.new(1..10)
 494     enum = set.keep_if
 495     assert_equal(set.size, enum.size)
 496     assert_same(set, enum.each { |i| i % 3 != 0 })
 497     assert_equal(Set[1,2,4,5,7,8,10], set)
 498   end
 499
 500   def test_collect!
 501     set = Set[1,2,3,'a','b','c',-1..1,2..4]
 502
 503     ret = set.collect! { |i|
 504       case i
 505       when Numeric
 506         i * 2
 507       when String
 508         i.upcase
 509       else
 510         nil
 511       end
 512     }
 513
 514     assert_same(set, ret)
 515     assert_equal(Set[2,4,6,'A','B','C',nil], set)
 516
 517     set = Set[1,2,3,'a','b','c',-1..1,2..4]
 518     enum = set.collect!
 519
 520     assert_equal(set.size, enum.size)
 521     assert_same(set, enum.each  { |i|
 522       case i
 523       when Numeric
 524         i * 2
 525       when String
 526         i.upcase
 527       else
 528         nil
 529       end
 530     })
 531     assert_equal(Set[2,4,6,'A','B','C',nil], set)
 532   end
 533
 534   def test_reject!
 535     set = Set.new(1..10)
 536
 537     ret = set.reject! { |i| i > 10 }
 538     assert_nil(ret)
 539     assert_equal(Set.new(1..10), set)
 540
 541     ret = set.reject! { |i| i % 3 == 0 }
 542     assert_same(set, ret)
 543     assert_equal(Set[1,2,4,5,7,8,10], set)
 544
 545     set = Set.new(1..10)
 546     enum = set.reject!
 547     assert_equal(set.size, enum.size)
 548     assert_same(set, enum.each { |i| i % 3 == 0 })
 549     assert_equal(Set[1,2,4,5,7,8,10], set)
 550   end
 551
 552   def test_select!
 553     set = Set.new(1..10)
 554     ret = set.select! { |i| i <= 10 }
 555     assert_equal(nil, ret)
 556     assert_equal(Set.new(1..10), set)
 557
 558     set = Set.new(1..10)
 559     ret = set.select! { |i| i % 3 != 0 }
 560     assert_same(set, ret)
 561     assert_equal(Set[1,2,4,5,7,8,10], set)
 562
 563     set = Set.new(1..10)
 564     enum = set.select!
 565     assert_equal(set.size, enum.size)
 566     assert_equal(nil, enum.each { |i| i <= 10 })
 567     assert_equal(Set.new(1..10), set)
 568   end
 569
 570   def test_filter!
 571     set = Set.new(1..10)
 572     ret = set.filter! { |i| i <= 10 }
 573     assert_equal(nil, ret)
 574     assert_equal(Set.new(1..10), set)
 575
 576     set = Set.new(1..10)
 577     ret = set.filter! { |i| i % 3 != 0 }
 578     assert_same(set, ret)
 579     assert_equal(Set[1,2,4,5,7,8,10], set)
 580
 581     set = Set.new(1..10)
 582     enum = set.filter!
 583     assert_equal(set.size, enum.size)
 584     assert_equal(nil, enum.each { |i| i <= 10 })
 585     assert_equal(Set.new(1..10), set)
 586   end
 587
 588   def test_merge
 589     set = Set[1,2,3]
 590
 591     ret = set.merge([2,4,6])
 592     assert_same(set, ret)
 593     assert_equal(Set[1,2,3,4,6], set)
 594   end
 595
 596   def test_subtract
 597     set = Set[1,2,3]
 598
 599     ret = set.subtract([2,4,6])
 600     assert_same(set, ret)
 601     assert_equal(Set[1,3], set)
 602   end
 603
 604   def test_plus
 605     set = Set[1,2,3]
 606
 607     ret = set + [2,4,6]
 608     assert_not_same(set, ret)
 609     assert_equal(Set[1,2,3,4,6], ret)
 610   end
 611
 612   def test_minus
 613     set = Set[1,2,3]
 614
 615     ret = set - [2,4,6]
 616     assert_not_same(set, ret)
 617     assert_equal(Set[1,3], ret)
 618   end
 619
 620   def test_and
 621     set = Set[1,2,3,4]
 622
 623     ret = set & [2,4,6]
 624     assert_not_same(set, ret)
 625     assert_equal(Set[2,4], ret)
 626   end
 627
 628   def test_xor
 629     set = Set[1,2,3,4]
 630     ret = set ^ [2,4,5,5]
 631     assert_not_same(set, ret)
 632     assert_equal(Set[1,3,5], ret)
 633   end
 634
 635   def test_eq
 636     set1 = Set[2,3,1]
 637     set2 = Set[1,2,3]
 638
 639     assert_equal(set1, set1)
 640     assert_equal(set1, set2)
 641     assert_not_equal(Set[1], [1])
 642
 643     set1 = Class.new(Set)["a", "b"]
 644     set1.add(set1).reset # Make recursive
 645     set2 = Set["a", "b", Set["a", "b", set1]]
 646
 647     assert_equal(set1, set2)
 648
 649     assert_not_equal(Set[Exception.new,nil], Set[Exception.new,Exception.new], "[ruby-dev:26127]")
 650   end
 651
 652   def test_classify
 653     set = Set.new(1..10)
 654     ret = set.classify { |i| i % 3 }
 655
 656     assert_equal(3, ret.size)
 657     assert_instance_of(Hash, ret)
 658     ret.each_value { |value| assert_instance_of(Set, value) }
 659     assert_equal(Set[3,6,9], ret[0])
 660     assert_equal(Set[1,4,7,10], ret[1])
 661     assert_equal(Set[2,5,8], ret[2])
 662
 663     set = Set.new(1..10)
 664     enum = set.classify
 665
 666     assert_equal(set.size, enum.size)
 667     ret = enum.each { |i| i % 3 }
 668     assert_equal(3, ret.size)
 669     assert_instance_of(Hash, ret)
 670     ret.each_value { |value| assert_instance_of(Set, value) }
 671     assert_equal(Set[3,6,9], ret[0])
 672     assert_equal(Set[1,4,7,10], ret[1])
 673     assert_equal(Set[2,5,8], ret[2])
 674   end
 675
 676   def test_divide
 677     set = Set.new(1..10)
 678     ret = set.divide { |i| i % 3 }
 679
 680     assert_equal(3, ret.size)
 681     n = 0
 682     ret.each { |s| n += s.size }
 683     assert_equal(set.size, n)
 684     assert_equal(set, ret.flatten)
 685
 686     set = Set[7,10,5,11,1,3,4,9,0]
 687     ret = set.divide { |a,b| (a - b).abs == 1 }
 688
 689     assert_equal(4, ret.size)
 690     n = 0
 691     ret.each { |s| n += s.size }
 692     assert_equal(set.size, n)
 693     assert_equal(set, ret.flatten)
 694     ret.each { |s|
 695       if s.include?(0)
 696         assert_equal(Set[0,1], s)
 697       elsif s.include?(3)
 698         assert_equal(Set[3,4,5], s)
 699       elsif s.include?(7)
 700         assert_equal(Set[7], s)
 701       elsif s.include?(9)
 702         assert_equal(Set[9,10,11], s)
 703       else
 704         raise "unexpected group: #{s.inspect}"
 705       end
 706     }
 707
 708     set = Set.new(1..10)
 709     enum = set.divide
 710     ret = enum.each { |i| i % 3 }
 711
 712     assert_equal(set.size, enum.size)
 713     assert_equal(3, ret.size)
 714     n = 0
 715     ret.each { |s| n += s.size }
 716     assert_equal(set.size, n)
 717     assert_equal(set, ret.flatten)
 718   end
 719
 720   def test_freeze
 721     orig = set = Set[1,2,3]
 722     assert_equal false, set.frozen?
 723     set << 4
 724     assert_same orig, set.freeze
 725     assert_equal true, set.frozen?
 726     assert_raise(FrozenError) {
 727       set << 5
 728     }
 729     assert_equal 4, set.size
 730   end
 731
 732   def test_freeze_dup
 733     set1 = Set[1,2,3]
 734     set1.freeze
 735     set2 = set1.dup
 736
 737     assert_not_predicate set2, :frozen?
 738     assert_nothing_raised {
 739       set2.add 4
 740     }
 741   end
 742
 743   def test_freeze_clone
 744     set1 = Set[1,2,3]
 745     set1.freeze
 746     set2 = set1.clone
 747
 748     assert_predicate set2, :frozen?
 749     assert_raise(FrozenError) {
 750       set2.add 5
 751     }
 752   end
 753
 754   def test_freeze_clone_false
 755     set1 = Set[1,2,3]
 756     set1.freeze
 757     set2 = set1.clone(freeze: false)
 758
 759     assert_not_predicate set2, :frozen?
 760     set2.add 5
 761     assert_equal Set[1,2,3,5], set2
 762     assert_equal Set[1,2,3], set1
 763   end if Kernel.instance_method(:initialize_clone).arity != 1
 764
 765   def test_join
 766     assert_equal('123', Set[1, 2, 3].join)
 767     assert_equal('1 & 2 & 3', Set[1, 2, 3].join(' & '))
 768   end
 769
 770   def test_inspect
 771     set1 = Set[1, 2]
 772     assert_equal('#<Set: {1, 2}>', set1.inspect)
 773
 774     set2 = Set[Set[0], 1, 2, set1]
 775     assert_equal('#<Set: {#<Set: {0}>, 1, 2, #<Set: {1, 2}>}>', set2.inspect)
 776
 777     set1.add(set2)
 778     assert_equal('#<Set: {#<Set: {0}>, 1, 2, #<Set: {1, 2, #<Set: {...}>}>}>', set2.inspect)
 779   end
 780
 781   def test_to_s
 782     set1 = Set[1, 2]
 783     assert_equal('#<Set: {1, 2}>', set1.to_s)
 784
 785     set2 = Set[Set[0], 1, 2, set1]
 786     assert_equal('#<Set: {#<Set: {0}>, 1, 2, #<Set: {1, 2}>}>', set2.to_s)
 787
 788     set1.add(set2)
 789     assert_equal('#<Set: {#<Set: {0}>, 1, 2, #<Set: {1, 2, #<Set: {...}>}>}>', set2.to_s)
 790   end
 791
 792   def test_compare_by_identity
 793     a1, a2 = "a", "a"
 794     b1, b2 = "b", "b"
 795     c = "c"
 796     array = [a1, b1, c, a2, b2]
 797
 798     iset = Set.new.compare_by_identity
 799     assert_send([iset, :compare_by_identity?])
 800     iset.merge(array)
 801     assert_equal(5, iset.size)
 802     assert_equal(array.map(&:object_id).sort, iset.map(&:object_id).sort)
 803
 804     set = Set.new
 805     assert_not_send([set, :compare_by_identity?])
 806     set.merge(array)
 807     assert_equal(3, set.size)
 808     assert_equal(array.uniq.sort, set.sort)
 809   end
 810
 811   def test_reset
 812     [Set, Class.new(Set)].each { |klass|
 813       a = [1, 2]
 814       b = [1]
 815       set = klass.new([a, b])
 816
 817       b << 2
 818       set.reset
 819
 820       assert_equal(klass.new([a]), set, klass.name)
 821     }
 822   end
 823 end
 824
 825 class TC_Enumerable < Test::Unit::TestCase
 826   def test_to_set
 827     ary = [2,5,4,3,2,1,3]
 828
 829     set = ary.to_set
 830     assert_instance_of(Set, set)
 831     assert_equal([1,2,3,4,5], set.sort)
 832
 833     set = ary.to_set { |o| o * -2 }
 834     assert_instance_of(Set, set)
 835     assert_equal([-10,-8,-6,-4,-2], set.sort)
 836
 837     assert_same set, set.to_set
 838     assert_not_same set, set.to_set { |o| o }
 839   end
 840 end