1require 'test/unit' 2require 'set' 3 4class TC_Set < Test::Unit::TestCase 5 def test_aref 6 assert_nothing_raised { 7 Set[] 8 Set[nil] 9 Set[1,2,3] 10 } 11 12 assert_equal(0, Set[].size) 13 assert_equal(1, Set[nil].size) 14 assert_equal(1, Set[[]].size) 15 assert_equal(1, Set[[nil]].size) 16 17 set = Set[2,4,6,4] 18 assert_equal(Set.new([2,4,6]), set) 19 end 20 21 def test_s_new 22 assert_nothing_raised { 23 Set.new() 24 Set.new(nil) 25 Set.new([]) 26 Set.new([1,2]) 27 Set.new('a'..'c') 28 } 29 assert_raises(ArgumentError) { 30 Set.new(false) 31 } 32 assert_raises(ArgumentError) { 33 Set.new(1) 34 } 35 assert_raises(ArgumentError) { 36 Set.new(1,2) 37 } 38 39 assert_equal(0, Set.new().size) 40 assert_equal(0, Set.new(nil).size) 41 assert_equal(0, Set.new([]).size) 42 assert_equal(1, Set.new([nil]).size) 43 44 ary = [2,4,6,4] 45 set = Set.new(ary) 46 ary.clear 47 assert_equal(false, set.empty?) 48 assert_equal(3, set.size) 49 50 ary = [1,2,3] 51 52 s = Set.new(ary) { |o| o * 2 } 53 assert_equal([2,4,6], s.sort) 54 end 55 56 def test_clone 57 set1 = Set.new 58 set2 = set1.clone 59 set1 << 'abc' 60 assert_equal(Set.new, set2) 61 end 62 63 def test_dup 64 set1 = Set[1,2] 65 set2 = set1.dup 66 67 assert_not_same(set1, set2) 68 69 assert_equal(set1, set2) 70 71 set1.add(3) 72 73 assert_not_equal(set1, set2) 74 end 75 76 def test_size 77 assert_equal(0, Set[].size) 78 assert_equal(2, Set[1,2].size) 79 assert_equal(2, Set[1,2,1].size) 80 end 81 82 def test_empty? 83 assert_equal(true, Set[].empty?) 84 assert_equal(false, Set[1, 2].empty?) 85 end 86 87 def test_clear 88 set = Set[1,2] 89 ret = set.clear 90 91 assert_same(set, ret) 92 assert_equal(true, set.empty?) 93 end 94 95 def test_replace 96 set = Set[1,2] 97 ret = set.replace('a'..'c') 98 99 assert_same(set, ret) 100 assert_equal(Set['a','b','c'], set) 101 end 102 103 def test_to_a 104 set = Set[1,2,3,2] 105 ary = set.to_a 106 107 assert_equal([1,2,3], ary.sort) 108 end 109 110 def test_flatten 111 # test1 112 set1 = Set[ 113 1, 114 Set[ 115 5, 116 Set[7, 117 Set[0] 118 ], 119 Set[6,2], 120 1 121 ], 122 3, 123 Set[3,4] 124 ] 125 126 set2 = set1.flatten 127 set3 = Set.new(0..7) 128 129 assert_not_same(set2, set1) 130 assert_equal(set3, set2) 131 132 # test2; destructive 133 orig_set1 = set1 134 set1.flatten! 135 136 assert_same(orig_set1, set1) 137 assert_equal(set3, set1) 138 139 # test3; multiple occurrences of a set in an set 140 set1 = Set[1, 2] 141 set2 = Set[set1, Set[set1, 4], 3] 142 143 assert_nothing_raised { 144 set2.flatten! 145 } 146 147 assert_equal(Set.new(1..4), set2) 148 149 # test4; recursion 150 set2 = Set[] 151 set1 = Set[1, set2] 152 set2.add(set1) 153 154 assert_raises(ArgumentError) { 155 set1.flatten! 156 } 157 158 # test5; miscellaneous 159 empty = Set[] 160 set = Set[Set[empty, "a"],Set[empty, "b"]] 161 162 assert_nothing_raised { 163 set.flatten 164 } 165 166 set1 = empty.merge(Set["no_more", set]) 167 168 assert_nil(Set.new(0..31).flatten!) 169 170 x = Set[Set[],Set[1,2]].flatten! 171 y = Set[1,2] 172 173 assert_equal(x, y) 174 end 175 176 def test_include? 177 set = Set[1,2,3] 178 179 assert_equal(true, set.include?(1)) 180 assert_equal(true, set.include?(2)) 181 assert_equal(true, set.include?(3)) 182 assert_equal(false, set.include?(0)) 183 assert_equal(false, set.include?(nil)) 184 185 set = Set["1",nil,"2",nil,"0","1",false] 186 assert_equal(true, set.include?(nil)) 187 assert_equal(true, set.include?(false)) 188 assert_equal(true, set.include?("1")) 189 assert_equal(false, set.include?(0)) 190 assert_equal(false, set.include?(true)) 191 end 192 193 def test_superset? 194 set = Set[1,2,3] 195 196 assert_raises(ArgumentError) { 197 set.superset?() 198 } 199 200 assert_raises(ArgumentError) { 201 set.superset?(2) 202 } 203 204 assert_raises(ArgumentError) { 205 set.superset?([2]) 206 } 207 208 assert_equal(true, set.superset?(Set[])) 209 assert_equal(true, set.superset?(Set[1,2])) 210 assert_equal(true, set.superset?(Set[1,2,3])) 211 assert_equal(false, set.superset?(Set[1,2,3,4])) 212 assert_equal(false, set.superset?(Set[1,4])) 213 214 assert_equal(true, set >= Set[1,2,3]) 215 assert_equal(true, set >= Set[1,2]) 216 217 assert_equal(true, Set[].superset?(Set[])) 218 end 219 220 def test_proper_superset? 221 set = Set[1,2,3] 222 223 assert_raises(ArgumentError) { 224 set.proper_superset?() 225 } 226 227 assert_raises(ArgumentError) { 228 set.proper_superset?(2) 229 } 230 231 assert_raises(ArgumentError) { 232 set.proper_superset?([2]) 233 } 234 235 assert_equal(true, set.proper_superset?(Set[])) 236 assert_equal(true, set.proper_superset?(Set[1,2])) 237 assert_equal(false, set.proper_superset?(Set[1,2,3])) 238 assert_equal(false, set.proper_superset?(Set[1,2,3,4])) 239 assert_equal(false, set.proper_superset?(Set[1,4])) 240 241 assert_equal(false, set > Set[1,2,3]) 242 assert_equal(true, set > Set[1,2]) 243 244 assert_equal(false, Set[].proper_superset?(Set[])) 245 end 246 247 def test_subset? 248 set = Set[1,2,3] 249 250 assert_raises(ArgumentError) { 251 set.subset?() 252 } 253 254 assert_raises(ArgumentError) { 255 set.subset?(2) 256 } 257 258 assert_raises(ArgumentError) { 259 set.subset?([2]) 260 } 261 262 assert_equal(true, set.subset?(Set[1,2,3,4])) 263 assert_equal(true, set.subset?(Set[1,2,3])) 264 assert_equal(false, set.subset?(Set[1,2])) 265 assert_equal(false, set.subset?(Set[])) 266 267 assert_equal(true, set <= Set[1,2,3]) 268 assert_equal(true, set <= Set[1,2,3,4]) 269 270 assert_equal(true, Set[].subset?(Set[1])) 271 assert_equal(true, Set[].subset?(Set[])) 272 end 273 274 def test_proper_subset? 275 set = Set[1,2,3] 276 277 assert_raises(ArgumentError) { 278 set.proper_subset?() 279 } 280 281 assert_raises(ArgumentError) { 282 set.proper_subset?(2) 283 } 284 285 assert_raises(ArgumentError) { 286 set.proper_subset?([2]) 287 } 288 289 assert_equal(true, set.proper_subset?(Set[1,2,3,4])) 290 assert_equal(false, set.proper_subset?(Set[1,2,3])) 291 assert_equal(false, set.proper_subset?(Set[1,2])) 292 assert_equal(false, set.proper_subset?(Set[])) 293 294 assert_equal(false, set < Set[1,2,3]) 295 assert_equal(true, set < Set[1,2,3,4]) 296 297 assert_equal(false, Set[].proper_subset?(Set[])) 298 end 299 300 def test_each 301 ary = [1,3,5,7,10,20] 302 set = Set.new(ary) 303 304 ret = set.each { |o| } 305 assert_same(set, ret) 306 307 e = set.each 308 assert_instance_of(Enumerator, e) 309 310 assert_nothing_raised { 311 set.each { |o| 312 ary.delete(o) or raise "unexpected element: #{o}" 313 } 314 315 ary.empty? or raise "forgotten elements: #{ary.join(', ')}" 316 } 317 end 318 319 def test_add 320 set = Set[1,2,3] 321 322 ret = set.add(2) 323 assert_same(set, ret) 324 assert_equal(Set[1,2,3], set) 325 326 ret = set.add?(2) 327 assert_nil(ret) 328 assert_equal(Set[1,2,3], set) 329 330 ret = set.add(4) 331 assert_same(set, ret) 332 assert_equal(Set[1,2,3,4], set) 333 334 ret = set.add?(5) 335 assert_same(set, ret) 336 assert_equal(Set[1,2,3,4,5], set) 337 end 338 339 def test_delete 340 set = Set[1,2,3] 341 342 ret = set.delete(4) 343 assert_same(set, ret) 344 assert_equal(Set[1,2,3], set) 345 346 ret = set.delete?(4) 347 assert_nil(ret) 348 assert_equal(Set[1,2,3], set) 349 350 ret = set.delete(2) 351 assert_equal(set, ret) 352 assert_equal(Set[1,3], set) 353 354 ret = set.delete?(1) 355 assert_equal(set, ret) 356 assert_equal(Set[3], set) 357 end 358 359 def test_delete_if 360 set = Set.new(1..10) 361 ret = set.delete_if { |i| i > 10 } 362 assert_same(set, ret) 363 assert_equal(Set.new(1..10), set) 364 365 set = Set.new(1..10) 366 ret = set.delete_if { |i| i % 3 == 0 } 367 assert_same(set, ret) 368 assert_equal(Set[1,2,4,5,7,8,10], set) 369 end 370 371 def test_collect! 372 set = Set[1,2,3,'a','b','c',-1..1,2..4] 373 374 ret = set.collect! { |i| 375 case i 376 when Numeric 377 i * 2 378 when String 379 i.upcase 380 else 381 nil 382 end 383 } 384 385 assert_same(set, ret) 386 assert_equal(Set[2,4,6,'A','B','C',nil], set) 387 end 388 389 def test_reject! 390 set = Set.new(1..10) 391 392 ret = set.reject! { |i| i > 10 } 393 assert_nil(ret) 394 assert_equal(Set.new(1..10), set) 395 396 ret = set.reject! { |i| i % 3 == 0 } 397 assert_same(set, ret) 398 assert_equal(Set[1,2,4,5,7,8,10], set) 399 end 400 401 def test_merge 402 set = Set[1,2,3] 403 404 ret = set.merge([2,4,6]) 405 assert_same(set, ret) 406 assert_equal(Set[1,2,3,4,6], set) 407 end 408 409 def test_subtract 410 set = Set[1,2,3] 411 412 ret = set.subtract([2,4,6]) 413 assert_same(set, ret) 414 assert_equal(Set[1,3], set) 415 end 416 417 def test_plus 418 set = Set[1,2,3] 419 420 ret = set + [2,4,6] 421 assert_not_same(set, ret) 422 assert_equal(Set[1,2,3,4,6], ret) 423 end 424 425 def test_minus 426 set = Set[1,2,3] 427 428 ret = set - [2,4,6] 429 assert_not_same(set, ret) 430 assert_equal(Set[1,3], ret) 431 end 432 433 def test_and 434 set = Set[1,2,3,4] 435 436 ret = set & [2,4,6] 437 assert_not_same(set, ret) 438 assert_equal(Set[2,4], ret) 439 end 440 441 def test_xor 442 set = Set[1,2,3,4] 443 ret = set ^ [2,4,5,5] 444 assert_not_same(set, ret) 445 assert_equal(Set[1,3,5], ret) 446 end 447 448 def test_eq 449 set1 = Set[2,3,1] 450 set2 = Set[1,2,3] 451 452 assert_equal(set1, set1) 453 assert_equal(set1, set2) 454 assert_not_equal(Set[1], [1]) 455 456 set1 = Class.new(Set)["a", "b"] 457 set2 = Set["a", "b", set1] 458 set1 = set1.add(set1.clone) 459 460# assert_equal(set1, set2) 461# assert_equal(set2, set1) 462 assert_equal(set2, set2.clone) 463 assert_equal(set1.clone, set1) 464 465 assert_not_equal(Set[Exception.new,nil], Set[Exception.new,Exception.new], "[ruby-dev:26127]") 466 end 467 468 # def test_hash 469 # end 470 471 # def test_eql? 472 # end 473 474 def test_classify 475 set = Set.new(1..10) 476 ret = set.classify { |i| i % 3 } 477 478 assert_equal(3, ret.size) 479 assert_instance_of(Hash, ret) 480 ret.each_value { |value| assert_instance_of(Set, value) } 481 assert_equal(Set[3,6,9], ret[0]) 482 assert_equal(Set[1,4,7,10], ret[1]) 483 assert_equal(Set[2,5,8], ret[2]) 484 end 485 486 def test_divide 487 set = Set.new(1..10) 488 ret = set.divide { |i| i % 3 } 489 490 assert_equal(3, ret.size) 491 n = 0 492 ret.each { |s| n += s.size } 493 assert_equal(set.size, n) 494 assert_equal(set, ret.flatten) 495 496 set = Set[7,10,5,11,1,3,4,9,0] 497 ret = set.divide { |a,b| (a - b).abs == 1 } 498 499 assert_equal(4, ret.size) 500 n = 0 501 ret.each { |s| n += s.size } 502 assert_equal(set.size, n) 503 assert_equal(set, ret.flatten) 504 ret.each { |s| 505 if s.include?(0) 506 assert_equal(Set[0,1], s) 507 elsif s.include?(3) 508 assert_equal(Set[3,4,5], s) 509 elsif s.include?(7) 510 assert_equal(Set[7], s) 511 elsif s.include?(9) 512 assert_equal(Set[9,10,11], s) 513 else 514 raise "unexpected group: #{s.inspect}" 515 end 516 } 517 end 518 519 def test_inspect 520 set1 = Set[1] 521 522 assert_equal('#<Set: {1}>', set1.inspect) 523 524 set2 = Set[Set[0], 1, 2, set1] 525 assert_equal(false, set2.inspect.include?('#<Set: {...}>')) 526 527 set1.add(set2) 528 assert_equal(true, set1.inspect.include?('#<Set: {...}>')) 529 end 530 531 # def test_pretty_print 532 # end 533 534 # def test_pretty_print_cycle 535 # end 536end 537 538class TC_SortedSet < Test::Unit::TestCase 539 def test_sortedset 540 s = SortedSet[4,5,3,1,2] 541 542 assert_equal([1,2,3,4,5], s.to_a) 543 544 prev = nil 545 s.each { |o| assert(prev < o) if prev; prev = o } 546 assert_not_nil(prev) 547 548 s.map! { |o| -2 * o } 549 550 assert_equal([-10,-8,-6,-4,-2], s.to_a) 551 552 prev = nil 553 ret = s.each { |o| assert(prev < o) if prev; prev = o } 554 assert_not_nil(prev) 555 assert_same(s, ret) 556 557 s = SortedSet.new([2,1,3]) { |o| o * -2 } 558 assert_equal([-6,-4,-2], s.to_a) 559 560 s = SortedSet.new(['one', 'two', 'three', 'four']) 561 a = [] 562 ret = s.delete_if { |o| a << o; o.start_with?('t') } 563 assert_same(s, ret) 564 assert_equal(['four', 'one'], s.to_a) 565 assert_equal(['four', 'one', 'three', 'two'], a) 566 567 s = SortedSet.new(['one', 'two', 'three', 'four']) 568 a = [] 569 ret = s.reject! { |o| a << o; o.start_with?('t') } 570 assert_same(s, ret) 571 assert_equal(['four', 'one'], s.to_a) 572 assert_equal(['four', 'one', 'three', 'two'], a) 573 574 s = SortedSet.new(['one', 'two', 'three', 'four']) 575 a = [] 576 ret = s.reject! { |o| a << o; false } 577 assert_same(nil, ret) 578 assert_equal(['four', 'one', 'three', 'two'], s.to_a) 579 assert_equal(['four', 'one', 'three', 'two'], a) 580 end 581end 582 583class TC_Enumerable < Test::Unit::TestCase 584 def test_to_set 585 ary = [2,5,4,3,2,1,3] 586 587 set = ary.to_set 588 assert_instance_of(Set, set) 589 assert_equal([1,2,3,4,5], set.sort) 590 591 set = ary.to_set { |o| o * -2 } 592 assert_instance_of(Set, set) 593 assert_equal([-10,-8,-6,-4,-2], set.sort) 594 595 set = ary.to_set(SortedSet) 596 assert_instance_of(SortedSet, set) 597 assert_equal([1,2,3,4,5], set.to_a) 598 599 set = ary.to_set(SortedSet) { |o| o * -2 } 600 assert_instance_of(SortedSet, set) 601 assert_equal([-10,-8,-6,-4,-2], set.sort) 602 end 603end 604 605# class TC_RestricedSet < Test::Unit::TestCase 606# def test_s_new 607# assert_raises(ArgumentError) { RestricedSet.new } 608# 609# s = RestricedSet.new([-1,2,3]) { |o| o > 0 } 610# assert_equal([2,3], s.sort) 611# end 612# 613# def test_restriction_proc 614# s = RestricedSet.new([-1,2,3]) { |o| o > 0 } 615# 616# f = s.restriction_proc 617# assert_instance_of(Proc, f) 618# assert(f[1]) 619# assert(!f[0]) 620# end 621# 622# def test_replace 623# s = RestricedSet.new(-3..3) { |o| o > 0 } 624# assert_equal([1,2,3], s.sort) 625# 626# s.replace([-2,0,3,4,5]) 627# assert_equal([3,4,5], s.sort) 628# end 629# 630# def test_merge 631# s = RestricedSet.new { |o| o > 0 } 632# s.merge(-5..5) 633# assert_equal([1,2,3,4,5], s.sort) 634# 635# s.merge([10,-10,-8,8]) 636# assert_equal([1,2,3,4,5,8,10], s.sort) 637# end 638# end 639