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