enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-set/test/set.rb

@@ -0,0 +1,764 @@
+##
+## 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