##
## Set Test
##

assert("Set.new") do
  assert_nothing_raised {
    Set.new()
    Set.new(nil)
    Set.new([])
    Set.new([1,2])
    Set.new(1..3)
  }
  assert_raise(ArgumentError) { Set.new(false) }
  assert_raise(ArgumentError) { Set.new(1) }
  assert_raise(ArgumentError) { Set.new(1,2) }

  ary = [2,4,6,4]
  set = Set.new(ary)
  ary.clear
  assert_false set.empty?
  assert_equal(3, set.size)

  ary = [1,2,3]

  s = Set.new(ary) { |o| o * 2 }
  assert_equal([2,4,6], s.sort)
end

assert("Set.[]") do
  assert_nothing_raised {
    Set[]
    Set[nil]
    Set[[]]
    Set[[1,2]]
    Set['a'..'c']
    Set[false]
    Set[1]
    Set[1,2]
  }

  ary = [2,4,6,4]
  set = Set[ary]
  ary.clear
  assert_false set.empty?
  assert_equal([[]], set.to_a)
end

assert("Set#clone") do
  set1 = Set.new
  set2 = set1.clone

  assert_false set1.equal?(set2) # assert_not_same

  assert_equal(set1, set2)

  set1 << 'abc'

  assert_equal(Set.new, set2)
end

assert("Set#dup") do
  set1 = Set[1,2]
  set2 = set1.dup

  assert_false set1.equal?(set2) # assert_not_same

  assert_equal(set1, set2)

  set1 << 'abc'

  assert_equal(Set[1,2], set2)
end

assert("Set#size") do
  assert_equal(0, Set[].size)
  assert_equal(1, Set[nil].size)
  assert_equal(1, Set[[]].size)
  assert_equal(1, Set[[nil]].size)
end

assert("Set#empty?") do
  assert_true Set[].empty?
  assert_false Set[1,2].empty?
end

assert("Set#clear") do
  set = Set[1,2]
  ret = set.clear

  assert_true set.equal?(ret) # assert_same
  assert_true set.empty?
end

assert("Set#replace") do
  set = Set[1,2]
  ret = set.replace(['a','b','c'])

  assert_true set.equal?(ret) # assert_same
  assert_equal(Set['a','b','c'], set)


  set = Set[1,2]
  ret = set.replace(Set['a','b','c'])

  assert_true set.equal?(ret) # assert_same
  assert_equal(Set['a','b','c'], set)
end

assert("Set#to_a") do
  set = Set[1,2,3,2]
  ary = set.to_a

  assert_equal([1,2,3], ary.sort)
end

assert("Set#flatten") do
  # test1
  set1 = Set[
    1,
    Set[
      5,
      Set[7,
        Set[0]
      ],
      Set[6,2],
      1
    ],
    3,
    Set[3,4]
  ]

  set2 = set1.flatten
  set3 = Set.new(0..7)

  assert_false set1.equal?(set2) # assert_not_same
  assert_equal(set3, set2)


  # test2; multiple occurrences of a set in an set
  set1 = Set[1, 2]
  set2 = Set[set1, Set[set1, 4], 3]

  assert_nothing_raised {
    set3 = set2.flatten
  }

  assert_equal(Set.new(1..4), set3)


  # test3; recursion
  set2 = Set[]
  set1 = Set[1, set2]
  set2.add(set1)

  assert_raise(ArgumentError) {
    set1.flatten
  }

  # test4; miscellaneous
  empty = Set[]
  set = Set[Set[empty, "a"], Set[empty, "b"]]

  assert_nothing_raised {
    set.flatten
  }
end

assert("Set#flatten!") do
  # test1
  set1 = Set[
    1,
    Set[
      5,
      Set[7,
        Set[0]
      ],
      Set[6,2],
      1
    ],
    3,
    Set[3,4]
  ]

  set3 = Set.new(0..7)
  orig_set1 = set1
  set1.flatten!

  assert_true orig_set1.equal?(set1) # assert_same
  assert_equal(set3, set1)


  # test2; multiple occurrences of a set in an set
  set1 = Set[1, 2]
  set2 = Set[set1, Set[set1, 4], 3]

  assert_nothing_raised {
    set2.flatten!
  }

  assert_equal(Set.new(1..4), set2)


  # test3; recursion
  set2 = Set[]
  set1 = Set[1, set2]
  set2.add(set1)

  assert_raise(ArgumentError) {
    set1.flatten!
  }

  # test4; miscellaneous
  assert_nil(Set.new(0..31).flatten!)

  x = Set[Set[],Set[1,2]].flatten!
  y = Set[1,2]

  assert_equal(x, y)
end

assert("Set#include?") do
  set = Set[1,2,3]

  assert_true set.include?(1)
  assert_true set.include?(2)
  assert_true set.include?(3)
  assert_false set.include?(0)
  assert_false set.include?(nil)

  set = Set["1",nil,"2",nil,"0","1",false]
  assert_true set.include?(nil)
  assert_true set.include?(false)
  assert_true set.include?("1")
  assert_false set.include?(0)
  assert_false set.include?(true)
  assert_false set.include?(2)
end

assert("Set#superset?") do
  set = Set[1,2,3]

  assert_raise(ArgumentError) { set.superset?(nil) }
  assert_raise(ArgumentError) { set.superset?(2) }
  assert_raise(ArgumentError) { set.superset?([2]) }

  assert_true set.superset?(Set[])
  assert_true set.superset?(Set[1,2])
  assert_true set.superset?(Set[1,2,3])
  assert_false set.superset?(Set[1,2,3,4])
  assert_false set.superset?(Set[1,4])

  assert_true set >= Set[1,2]
  assert_true set >= Set[1,2,3]

  assert_true Set[].superset?(Set[])
end

assert("Set#proper_superset?") do
  set = Set[1,2,3]

  assert_raise(ArgumentError) { set.proper_superset?(nil) }
  assert_raise(ArgumentError) { set.proper_superset?(2) }
  assert_raise(ArgumentError) { set.proper_superset?([2]) }

  assert_true set.proper_superset?(Set[])
  assert_true set.proper_superset?(Set[1,2])
  assert_false set.proper_superset?(Set[1,2,3])
  assert_false set.proper_superset?(Set[1,2,3,4])
  assert_false set.proper_superset?(Set[1,4])

  assert_true set > Set[1,2]
  assert_false set > Set[1,2,3]

  assert_false Set[].proper_superset?(Set[])
end

assert("Set#subset?") do
  set = Set[1,2,3]

  assert_raise(ArgumentError) { set.subset?(nil) }
  assert_raise(ArgumentError) { set.subset?(2) }
  assert_raise(ArgumentError) { set.subset?([2]) }

  assert_true set.subset?(Set[1,2,3,4])
  assert_true set.subset?(Set[1,2,3])
  assert_false set.subset?(Set[1,2])
  assert_false set.subset?(Set[])

  assert_true set <= Set[1,2,3]
  assert_false set <= Set[1,2]

  assert_true Set[].subset?(Set[1])
  assert_true Set[].subset?(Set[])
end

assert("Set#proper_subset?") do
  set = Set[1,2,3]

  assert_raise(ArgumentError) { set.proper_subset?(nil) }
  assert_raise(ArgumentError) { set.proper_subset?(2) }
  assert_raise(ArgumentError) { set.proper_subset?([2]) }

  assert_true set.proper_subset?(Set[1,2,3,4])
  assert_false set.proper_subset?(Set[1,2,3])
  assert_false set.proper_subset?(Set[1,2])
  assert_false set.proper_subset?(Set[])

  assert_true set < Set[1,2,3,4]
  assert_false set < Set[1,2,3]

  assert_true Set[].proper_subset?(Set[1])
  assert_false Set[].proper_subset?(Set[])
end

assert("Set#intersect?") do
  set = Set[3,4,5]

  assert_raise(ArgumentError) { set.intersect?(3) }
  assert_raise(ArgumentError) { set.intersect?([2,4,6]) }

  assert_true set.intersect?(set)
  assert_true set.intersect?(Set[2,4])
  assert_true set.intersect?(Set[5,6,7])
  assert_true set.intersect?(Set[1,2,6,8,4])

  assert_false(set.intersect?(Set[]))
  assert_false(set.intersect?(Set[0,2]))
  assert_false(set.intersect?(Set[0,2,6]))
  assert_false(set.intersect?(Set[0,2,6,8,10]))

  # Make sure set hasn't changed
  assert_equal(Set[3,4,5], set)
end

assert("Set#disjoint?") do
  set = Set[3,4,5]

  assert_raise(ArgumentError) { set.disjoint?(3) }
  assert_raise(ArgumentError) { set.disjoint?([2,4,6]) }

  assert_true(set.disjoint?(Set[]))
  assert_true(set.disjoint?(Set[0,2]))
  assert_true(set.disjoint?(Set[0,2,6]))
  assert_true(set.disjoint?(Set[0,2,6,8,10]))

  assert_false set.disjoint?(set)
  assert_false set.disjoint?(Set[2,4])
  assert_false set.disjoint?(Set[5,6,7])
  assert_false set.disjoint?(Set[1,2,6,8,4])

  # Make sure set hasn't changed
  assert_equal(Set[3,4,5], set)
end

assert("Set#each") do
  ary = [1,3,5,7,10,20]
  set = Set.new(ary)

  ret = set.each { |o| }
  assert_true set.equal?(ret) # assert_same

  e = set.each
  assert_true e.instance_of?(Enumerator)

  assert_nothing_raised {
    set.each { |o|
      ary.delete(o) or raise "unexpected element: #{o}"
    }
    ary.empty? or raise "forgotten elements: #{ary.join(', ')}"
  }
end

assert("Set#add") do
  set = Set[1,2,3]

  ret = set.add(2)
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,2,3], set)

  ret = set.add(4)
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,2,3,4], set)
end

assert("Set#add?") do
  set = Set[1,2,3]

  ret = set.add?(2)
  assert_nil ret
  assert_equal(Set[1,2,3], set)

  ret = set.add?(4)
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,2,3,4], set)
end

assert("Set#delete") do
  set = Set[1,2,3]

  ret = set.delete(4)
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,2,3], set)

  ret = set.delete(2)
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,3], set)
end

assert("Set#delete?") do
  set = Set[1,2,3]

  ret = set.delete?(4)
  assert_nil ret
  assert_equal(Set[1,2,3], set)

  ret = set.delete?(1)
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[2,3], set)
end

assert("Set#delete_if") do
  set = Set.new(1..10)
  ret = set.delete_if { |i| i > 10 }
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set.new(1..10), set)

  set = Set.new(1..10)
  ret = set.delete_if { |i| i % 3 == 0 }
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,2,4,5,7,8,10], set)
end

assert("Set#keep_if") do
  set = Set.new(1..10)
  ret = set.keep_if { |i| i <= 10 }
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set.new(1..10), set)

  set = Set.new(1..10)
  ret = set.keep_if { |i| i % 3 != 0 }
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,2,4,5,7,8,10], set)
end

assert("Set#collect!") do
  set = Set[1,2,3,'a','b','c',-1..1,2..4]

  ret = set.collect! { |i|
    case i
    when Numeric
      i * 2
    when String
      i.upcase
    else
      nil
    end
  }

  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[2,4,6,"A","B","C",nil], set)
end

assert("Set#reject!") do
  set = Set.new(1..10)

  ret = set.reject! { |i| i > 10 }
  assert_nil(ret)
  assert_equal(Set.new(1..10), set)

  ret = set.reject! { |i| i % 3 == 0 }
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,2,4,5,7,8,10], set)
end

# this test is not in CRuby
assert("Set#select!") do
  set = Set.new(1..10)

  ret = set.select! { |i| i <= 10 }
  assert_nil(ret)
  assert_equal(Set.new(1..10), set)

  ret = set.select! { |i| i % 3 != 0 }
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,2,4,5,7,8,10], set)
end

assert("Set#merge") do
  set = Set[1,2,3]

  ret = set.merge([2,4,6])
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,2,3,4,6], set)
end

assert("Set#subtract") do
  set = Set[1,2,3]

  ret = set.subtract([2,4,6])
  assert_true set.equal?(ret) # assert_same
  assert_equal(Set[1,3], set)
end

assert("Set#+") do
  set = Set[1,2,3]

  ret = set + [2,4,6]
  assert_false set.equal?(ret) # assert_not_same
  assert_equal(Set[1,2,3,4,6], ret)
  assert_equal(Set[1,2,3], set, "original set should not be modified")

  # Set + Set
  set2 = Set[3, 4, 5]
  assert_equal(Set[1, 2, 3, 4, 5], set + set2)

  # Set + empty Set
  assert_equal(set, set + Set[])

  # empty Set + Set
  assert_equal(set, Set[] + set)

  # Set + Array with no common elements
  assert_equal(Set[1, 2, 3, 4, 5], set + [4, 5])

  # Set + self
  assert_equal(set, set + set)

  # with various object types
  s1 = Set["a", "b", "c"]
  s2 = Set["c", "d", "e"]
  assert_equal(Set["a", "b", "c", "d", "e"], s1 + s2)
end

assert("Set#-") do
  set = Set[1,2,3]

  ret = set - [2,4,6]
  assert_false set.equal?(ret) # assert_not_same
  assert_equal(Set[1,3], ret)
  assert_equal(Set[1,2,3], set, "original set should not be modified")

  # Set - Set
  set2 = Set[3, 4, 5]
  assert_equal(Set[1, 2], set - set2)

  # Set - empty Set
  assert_equal(set, set - Set[])

  # empty Set - Set
  assert_equal(Set[], Set[] - set)

  # Set - Array with no common elements
  assert_equal(set, set - [4, 5])

  # Set - self
  assert_equal(Set[], set - set)

  # with various object types
  s1 = Set["a", "b", "c"]
  s2 = Set["b", "c", "d"]
  assert_equal(Set["a"], s1 - s2)
end

assert("Set#&") do
  set = Set[1,2,3,4]

  ret = set & [2,4,6]
  assert_false set.equal?(ret) # assert_not_same
  assert_equal(Set[2,4], ret)
  assert_equal(Set[1, 2, 3, 4], set, "original set should not be modified")

  # Set & Set
  set2 = Set[3, 4, 5]
  assert_equal(Set[3, 4], set & set2)

  # Set & empty Set
  assert_equal(Set[], set & Set[])

  # empty Set & Set
  assert_equal(Set[], Set[] & set)

  # Set & Array with no common elements
  assert_equal(Set[], set & [5, 6, 7])

  # Set & self
  assert_equal(set, set & set)

  # with various object types
  s1 = Set["a", "b", "c"]
  s2 = Set["b", "c", "d"]
  assert_equal(Set["b", "c"], s1 & s2)
end

assert("Set#^") do
  set = Set[1,2,3,4]

  ret = set ^ [2,4,5,5]
  assert_false set.equal?(ret) # assert_not_same
  assert_equal(Set[1,3,5], ret)
end

assert("Set#==") do
  set1 = Set[2,3,1]
  set2 = Set[1,2,3]

  assert_equal(set1, set1)
  assert_equal(set1, set2)
  assert_not_equal(Set[1], [1])

  set1 = Class.new(Set)["a", "b"]
  set2 = Set["a", "b", set1]
  set1 = set1.add(set1.clone)

  assert_equal(set2, set2.clone)
  assert_equal(set1.clone, set1)
end

assert("Set#classify") do
  set = Set.new(1..10)
  ret = set.classify { |i| i % 3 }

  assert_equal(3, ret.size)
  assert_equal(Hash, ret.class)
  ret.each_value { |v| assert_equal(Set, v.class) }
  assert_equal(Set[3,6,9], ret[0])
  assert_equal(Set[1,4,7,10], ret[1])
  assert_equal(Set[2,5,8], ret[2])
end

assert("Set#divide") do
  # arity is 1
  set = Set.new(1..10)
  ret = set.divide { |i| i % 3 }

  assert_equal(3, ret.size)
  n = 0
  ret.each { |s| n += s.size }
  assert_equal(set.size, n)
  assert_equal(set, ret.flatten)

  assert_equal(Set, ret.class)
  assert_true(ret.include?(Set[3,6,9]))
  assert_true(ret.include?(Set[1,4,7,10]))
  assert_true(ret.include?(Set[2,5,8]))


  # arity is 2
  set = Set[7,10,5,11,1,3,4,9,0]
  assert_raise(NotImplementedError) {
    ret = set.divide { |a, b| (a - b).abs == 1 }
  }

  # assert_equal(4, ret.size)
  # n = 0
  # ret.each { |s| n += s.size }
  # assert_equal(set.size, n)
  # assert_equal(set, ret.flatten)

  # assert_equal(Set, ret.class)
end

# freeze is not implemented yet
#assert("freeze") do
#  orig = set = Set[1,2,3]
#  assert_equal false, set.frozen?
#  set << 4
#  assert_same orig, set.freeze
#  assert_equal true, set.frozen?
#  assert_raise(RuntimeError) {
#    set << 5
#  }
#  assert_equal 4, set.size
#end
#  assert("freeze_dup") do
#    set1 = Set[1,2,3]
#    set1.freeze
#    set2 = set1.dup
#
#    assert_not_predicate set2, :frozen?
#    assert_nothing_raised {
#      set2.add 4
#    }
#  end
#  assert("reeze_clone") do
#    set1 = Set[1,2,3]
#    set1.freeze
#    set2 = set1.clone
#
#    assert_predicate set2, :frozen?
#    assert_raise(RuntimeError) {
#      set2.add 5
#    }
#  end
#
assert("Set#inspect") do
  set = Set[1,1,1]
  assert_equal("Set[1]", set.inspect)
end

assert("Set operations with custom objects") do
  class MySettable
    attr_reader :val
    def initialize(val)
      @val = val
    end

    def hash
      @val.hash
    end

    def eql?(other)
      other.is_a?(self.class) && self.val.eql?(other.val)
    end

    def ==(other)
      eql?(other)
    end

    def to_s
      "MySettable(#{@val})"
    end
    alias inspect to_s
  end

  obj1 = MySettable.new(1)
  obj2 = MySettable.new(2)
  obj3 = MySettable.new(3)
  obj4 = MySettable.new(4)

  set1 = Set[obj1, obj2]
  set2 = Set[obj2, obj3]

  # Test for Set#+
  set_union = set1 + set2
  assert_equal(3, set_union.size)
  assert_true(set_union.include?(obj1))
  assert_true(set_union.include?(obj2))
  assert_true(set_union.include?(obj3))

  # Test for Set#-
  set_diff = set1 - set2
  assert_equal(1, set_diff.size)
  assert_equal(obj1, set_diff.to_a[0])

  # Test for Set#&
  set_intersect = set1 & set2
  assert_equal(1, set_intersect.size)
  assert_equal(obj2, set_intersect.to_a[0])

  # Test with an array of objects
  arr = [obj2, obj4]
  set_intersect_arr = set1 & arr
  assert_equal(1, set_intersect_arr.size)
  assert_equal(obj2, set_intersect_arr.to_a[0])
end

assert("Set#hash") do
  set = Set[1, 2, 3]
  assert_kind_of(Integer, set.hash)
  hash = set.hash
  assert_equal(hash, Set[3, 1, 2].hash)
  assert_not_equal(hash, Set[1, 2, 4].hash)
  assert_not_equal(hash, Set[].hash)
end